git.oblomov.eu Git - git/blob - 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                 commit_list_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 void consume_shallow_list(int fd)
 169 {
 170         if (args.stateless_rpc && args.depth > 0) {
 171                 /* If we sent a depth we will get back "duplicate"
 172                  * shallow and unshallow commands every time there
 173                  * is a block of have lines exchanged.
 174                  */
 175                 char line[1000];
 176                 while (packet_read_line(fd, line, sizeof(line))) {
 177                         if (!prefixcmp(line, "shallow "))
 178                                 continue;
 179                         if (!prefixcmp(line, "unshallow "))
 180                                 continue;
 181                         die("git fetch-pack: expected shallow list");
 182                 }
 183         }
 184 }
 185
 186 static enum ack_type get_ack(int fd, unsigned char *result_sha1)
 187 {
 188         static char line[1000];
 189         int len = packet_read_line(fd, line, sizeof(line));
 190
 191         if (!len)
 192                 die("git fetch-pack: expected ACK/NAK, got EOF");
 193         if (line[len-1] == '\n')
 194                 line[--len] = 0;
 195         if (!strcmp(line, "NAK"))
 196                 return NAK;
 197         if (!prefixcmp(line, "ACK ")) {
 198                 if (!get_sha1_hex(line+4, result_sha1)) {
 199                         if (strstr(line+45, "continue"))
 200                                 return ACK_continue;
 201                         if (strstr(line+45, "common"))
 202                                 return ACK_common;
 203                         if (strstr(line+45, "ready"))
 204                                 return ACK_ready;
 205                         return ACK;
 206                 }
 207         }
 208         die("git fetch_pack: expected ACK/NAK, got '%s'", line);
 209 }
 210
 211 static void send_request(int fd, struct strbuf *buf)
 212 {
 213         if (args.stateless_rpc) {
 214                 send_sideband(fd, -1, buf->buf, buf->len, LARGE_PACKET_MAX);
 215                 packet_flush(fd);
 216         } else
 217                 safe_write(fd, buf->buf, buf->len);
 218 }
 219
 220 static int find_common(int fd[2], unsigned char *result_sha1,
 221                        struct ref *refs)
 222 {
 223         int fetching;
 224         int count = 0, flushes = 0, retval;
 225         const unsigned char *sha1;
 226         unsigned in_vain = 0;
 227         int got_continue = 0;
 228         struct strbuf req_buf = STRBUF_INIT;
 229         size_t state_len = 0;
 230
 231         if (args.stateless_rpc && multi_ack == 1)
 232                 die("--stateless-rpc requires multi_ack_detailed");
 233         if (marked)
 234                 for_each_ref(clear_marks, NULL);
 235         marked = 1;
 236
 237         for_each_ref(rev_list_insert_ref, NULL);
 238
 239         fetching = 0;
 240         for ( ; refs ; refs = refs->next) {
 241                 unsigned char *remote = refs->old_sha1;
 242                 const char *remote_hex;
 243                 struct object *o;
 244
 245                 /*
 246                  * If that object is complete (i.e. it is an ancestor of a
 247                  * local ref), we tell them we have it but do not have to
 248                  * tell them about its ancestors, which they already know
 249                  * about.
 250                  *
 251                  * We use lookup_object here because we are only
 252                  * interested in the case we *know* the object is
 253                  * reachable and we have already scanned it.
 254                  */
 255                 if (((o = lookup_object(remote)) != NULL) &&
 256                                 (o->flags & COMPLETE)) {
 257                         continue;
 258                 }
 259
 260                 remote_hex = sha1_to_hex(remote);
 261                 if (!fetching) {
 262                         struct strbuf c = STRBUF_INIT;
 263                         if (multi_ack == 2)     strbuf_addstr(&c, " multi_ack_detailed");
 264                         if (multi_ack == 1)     strbuf_addstr(&c, " multi_ack");
 265                         if (use_sideband == 2)  strbuf_addstr(&c, " side-band-64k");
 266                         if (use_sideband == 1)  strbuf_addstr(&c, " side-band");
 267                         if (args.use_thin_pack) strbuf_addstr(&c, " thin-pack");
 268                         if (args.no_progress)   strbuf_addstr(&c, " no-progress");
 269                         if (args.include_tag)   strbuf_addstr(&c, " include-tag");
 270                         if (prefer_ofs_delta)   strbuf_addstr(&c, " ofs-delta");
 271                         packet_buf_write(&req_buf, "want %s%s\n", remote_hex, c.buf);
 272                         strbuf_release(&c);
 273                 } else
 274                         packet_buf_write(&req_buf, "want %s\n", remote_hex);
 275                 fetching++;
 276         }
 277
 278         if (!fetching) {
 279                 strbuf_release(&req_buf);
 280                 packet_flush(fd[1]);
 281                 return 1;
 282         }
 283
 284         if (is_repository_shallow())
 285                 write_shallow_commits(&req_buf, 1);
 286         if (args.depth > 0)
 287                 packet_buf_write(&req_buf, "deepen %d", args.depth);
 288         packet_buf_flush(&req_buf);
 289         state_len = req_buf.len;
 290
 291         if (args.depth > 0) {
 292                 char line[1024];
 293                 unsigned char sha1[20];
 294
 295                 send_request(fd[1], &req_buf);
 296                 while (packet_read_line(fd[0], line, sizeof(line))) {
 297                         if (!prefixcmp(line, "shallow ")) {
 298                                 if (get_sha1_hex(line + 8, sha1))
 299                                         die("invalid shallow line: %s", line);
 300                                 register_shallow(sha1);
 301                                 continue;
 302                         }
 303                         if (!prefixcmp(line, "unshallow ")) {
 304                                 if (get_sha1_hex(line + 10, sha1))
 305                                         die("invalid unshallow line: %s", line);
 306                                 if (!lookup_object(sha1))
 307                                         die("object not found: %s", line);
 308                                 /* make sure that it is parsed as shallow */
 309                                 if (!parse_object(sha1))
 310                                         die("error in object: %s", line);
 311                                 if (unregister_shallow(sha1))
 312                                         die("no shallow found: %s", line);
 313                                 continue;
 314                         }
 315                         die("expected shallow/unshallow, got %s", line);
 316                 }
 317         } else if (!args.stateless_rpc)
 318                 send_request(fd[1], &req_buf);
 319
 320         if (!args.stateless_rpc) {
 321                 /* If we aren't using the stateless-rpc interface
 322                  * we don't need to retain the headers.
 323                  */
 324                 strbuf_setlen(&req_buf, 0);
 325                 state_len = 0;
 326         }
 327
 328         flushes = 0;
 329         retval = -1;
 330         while ((sha1 = get_rev())) {
 331                 packet_buf_write(&req_buf, "have %s\n", sha1_to_hex(sha1));
 332                 if (args.verbose)
 333                         fprintf(stderr, "have %s\n", sha1_to_hex(sha1));
 334                 in_vain++;
 335                 if (!(31 & ++count)) {
 336                         int ack;
 337
 338                         packet_buf_flush(&req_buf);
 339                         send_request(fd[1], &req_buf);
 340                         strbuf_setlen(&req_buf, state_len);
 341                         flushes++;
 342
 343                         /*
 344                          * We keep one window "ahead" of the other side, and
 345                          * will wait for an ACK only on the next one
 346                          */
 347                         if (!args.stateless_rpc && count == 32)
 348                                 continue;
 349
 350                         consume_shallow_list(fd[0]);
 351                         do {
 352                                 ack = get_ack(fd[0], result_sha1);
 353                                 if (args.verbose && ack)
 354                                         fprintf(stderr, "got ack %d %s\n", ack,
 355                                                         sha1_to_hex(result_sha1));
 356                                 switch (ack) {
 357                                 case ACK:
 358                                         flushes = 0;
 359                                         multi_ack = 0;
 360                                         retval = 0;
 361                                         goto done;
 362                                 case ACK_common:
 363                                 case ACK_ready:
 364                                 case ACK_continue: {
 365                                         struct commit *commit =
 366                                                 lookup_commit(result_sha1);
 367                                         if (args.stateless_rpc
 368                                          && ack == ACK_common
 369                                          && !(commit->object.flags & COMMON)) {
 370                                                 /* We need to replay the have for this object
 371                                                  * on the next RPC request so the peer knows
 372                                                  * it is in common with us.
 373                                                  */
 374                                                 const char *hex = sha1_to_hex(result_sha1);
 375                                                 packet_buf_write(&req_buf, "have %s\n", hex);
 376                                                 state_len = req_buf.len;
 377                                         }
 378                                         mark_common(commit, 0, 1);
 379                                         retval = 0;
 380                                         in_vain = 0;
 381                                         got_continue = 1;
 382                                         if (ack == ACK_ready)
 383                                                 rev_list = NULL;
 384                                         break;
 385                                         }
 386                                 }
 387                         } while (ack);
 388                         flushes--;
 389                         if (got_continue && MAX_IN_VAIN < in_vain) {
 390                                 if (args.verbose)
 391                                         fprintf(stderr, "giving up\n");
 392                                 break; /* give up */
 393                         }
 394                 }
 395         }
 396 done:
 397         packet_buf_write(&req_buf, "done\n");
 398         send_request(fd[1], &req_buf);
 399         if (args.verbose)
 400                 fprintf(stderr, "done\n");
 401         if (retval != 0) {
 402                 multi_ack = 0;
 403                 flushes++;
 404         }
 405         strbuf_release(&req_buf);
 406
 407         consume_shallow_list(fd[0]);
 408         while (flushes || multi_ack) {
 409                 int ack = get_ack(fd[0], result_sha1);
 410                 if (ack) {
 411                         if (args.verbose)
 412                                 fprintf(stderr, "got ack (%d) %s\n", ack,
 413                                         sha1_to_hex(result_sha1));
 414                         if (ack == ACK)
 415                                 return 0;
 416                         multi_ack = 1;
 417                         continue;
 418                 }
 419                 flushes--;
 420         }
 421         /* it is no error to fetch into a completely empty repo */
 422         return count ? retval : 0;
 423 }
 424
 425 static struct commit_list *complete;
 426
 427 static int mark_complete(const char *path, const unsigned char *sha1, int flag, void *cb_data)
 428 {
 429         struct object *o = parse_object(sha1);
 430
 431         while (o && o->type == OBJ_TAG) {
 432                 struct tag *t = (struct tag *) o;
 433                 if (!t->tagged)
 434                         break; /* broken repository */
 435                 o->flags |= COMPLETE;
 436                 o = parse_object(t->tagged->sha1);
 437         }
 438         if (o && o->type == OBJ_COMMIT) {
 439                 struct commit *commit = (struct commit *)o;
 440                 commit->object.flags |= COMPLETE;
 441                 commit_list_insert_by_date(commit, &complete);
 442         }
 443         return 0;
 444 }
 445
 446 static void mark_recent_complete_commits(unsigned long cutoff)
 447 {
 448         while (complete && cutoff <= complete->item->date) {
 449                 if (args.verbose)
 450                         fprintf(stderr, "Marking %s as complete\n",
 451                                 sha1_to_hex(complete->item->object.sha1));
 452                 pop_most_recent_commit(&complete, COMPLETE);
 453         }
 454 }
 455
 456 static void filter_refs(struct ref **refs, int nr_match, char **match)
 457 {
 458         struct ref **return_refs;
 459         struct ref *newlist = NULL;
 460         struct ref **newtail = &newlist;
 461         struct ref *ref, *next;
 462         struct ref *fastarray[32];
 463
 464         if (nr_match && !args.fetch_all) {
 465                 if (ARRAY_SIZE(fastarray) < nr_match)
 466                         return_refs = xcalloc(nr_match, sizeof(struct ref *));
 467                 else {
 468                         return_refs = fastarray;
 469                         memset(return_refs, 0, sizeof(struct ref *) * nr_match);
 470                 }
 471         }
 472         else
 473                 return_refs = NULL;
 474
 475         for (ref = *refs; ref; ref = next) {
 476                 next = ref->next;
 477                 if (!memcmp(ref->name, "refs/", 5) &&
 478                     check_ref_format(ref->name + 5))
 479                         ; /* trash */
 480                 else if (args.fetch_all &&
 481                          (!args.depth || prefixcmp(ref->name, "refs/tags/") )) {
 482                         *newtail = ref;
 483                         ref->next = NULL;
 484                         newtail = &ref->next;
 485                         continue;
 486                 }
 487                 else {
 488                         int order = path_match(ref->name, nr_match, match);
 489                         if (order) {
 490                                 return_refs[order-1] = ref;
 491                                 continue; /* we will link it later */
 492                         }
 493                 }
 494                 free(ref);
 495         }
 496
 497         if (!args.fetch_all) {
 498                 int i;
 499                 for (i = 0; i < nr_match; i++) {
 500                         ref = return_refs[i];
 501                         if (ref) {
 502                                 *newtail = ref;
 503                                 ref->next = NULL;
 504                                 newtail = &ref->next;
 505                         }
 506                 }
 507                 if (return_refs != fastarray)
 508                         free(return_refs);
 509         }
 510         *refs = newlist;
 511 }
 512
 513 static int everything_local(struct ref **refs, int nr_match, char **match)
 514 {
 515         struct ref *ref;
 516         int retval;
 517         unsigned long cutoff = 0;
 518
 519         save_commit_buffer = 0;
 520
 521         for (ref = *refs; ref; ref = ref->next) {
 522                 struct object *o;
 523
 524                 o = parse_object(ref->old_sha1);
 525                 if (!o)
 526                         continue;
 527
 528                 /* We already have it -- which may mean that we were
 529                  * in sync with the other side at some time after
 530                  * that (it is OK if we guess wrong here).
 531                  */
 532                 if (o->type == OBJ_COMMIT) {
 533                         struct commit *commit = (struct commit *)o;
 534                         if (!cutoff || cutoff < commit->date)
 535                                 cutoff = commit->date;
 536                 }
 537         }
 538
 539         if (!args.depth) {
 540                 for_each_ref(mark_complete, NULL);
 541                 if (cutoff)
 542                         mark_recent_complete_commits(cutoff);
 543         }
 544
 545         /*
 546          * Mark all complete remote refs as common refs.
 547          * Don't mark them common yet; the server has to be told so first.
 548          */
 549         for (ref = *refs; ref; ref = ref->next) {
 550                 struct object *o = deref_tag(lookup_object(ref->old_sha1),
 551                                              NULL, 0);
 552
 553                 if (!o || o->type != OBJ_COMMIT || !(o->flags & COMPLETE))
 554                         continue;
 555
 556                 if (!(o->flags & SEEN)) {
 557                         rev_list_push((struct commit *)o, COMMON_REF | SEEN);
 558
 559                         mark_common((struct commit *)o, 1, 1);
 560                 }
 561         }
 562
 563         filter_refs(refs, nr_match, match);
 564
 565         for (retval = 1, ref = *refs; ref ; ref = ref->next) {
 566                 const unsigned char *remote = ref->old_sha1;
 567                 unsigned char local[20];
 568                 struct object *o;
 569
 570                 o = lookup_object(remote);
 571                 if (!o || !(o->flags & COMPLETE)) {
 572                         retval = 0;
 573                         if (!args.verbose)
 574                                 continue;
 575                         fprintf(stderr,
 576                                 "want %s (%s)\n", sha1_to_hex(remote),
 577                                 ref->name);
 578                         continue;
 579                 }
 580
 581                 hashcpy(ref->new_sha1, local);
 582                 if (!args.verbose)
 583                         continue;
 584                 fprintf(stderr,
 585                         "already have %s (%s)\n", sha1_to_hex(remote),
 586                         ref->name);
 587         }
 588         return retval;
 589 }
 590
 591 static int sideband_demux(int in, int out, void *data)
 592 {
 593         int *xd = data;
 594
 595         int ret = recv_sideband("fetch-pack", xd[0], out);
 596         close(out);
 597         return ret;
 598 }
 599
 600 static int get_pack(int xd[2], char **pack_lockfile)
 601 {
 602         struct async demux;
 603         const char *argv[20];
 604         char keep_arg[256];
 605         char hdr_arg[256];
 606         const char **av;
 607         int do_keep = args.keep_pack;
 608         struct child_process cmd;
 609
 610         memset(&demux, 0, sizeof(demux));
 611         if (use_sideband) {
 612                 /* xd[] is talking with upload-pack; subprocess reads from
 613                  * xd[0], spits out band#2 to stderr, and feeds us band#1
 614                  * through demux->out.
 615                  */
 616                 demux.proc = sideband_demux;
 617                 demux.data = xd;
 618                 demux.out = -1;
 619                 if (start_async(&demux))
 620                         die("fetch-pack: unable to fork off sideband"
 621                             " demultiplexer");
 622         }
 623         else
 624                 demux.out = xd[0];
 625
 626         memset(&cmd, 0, sizeof(cmd));
 627         cmd.argv = argv;
 628         av = argv;
 629         *hdr_arg = 0;
 630         if (!args.keep_pack && unpack_limit) {
 631                 struct pack_header header;
 632
 633                 if (read_pack_header(demux.out, &header))
 634                         die("protocol error: bad pack header");
 635                 snprintf(hdr_arg, sizeof(hdr_arg),
 636                          "--pack_header=%"PRIu32",%"PRIu32,
 637                          ntohl(header.hdr_version), ntohl(header.hdr_entries));
 638                 if (ntohl(header.hdr_entries) < unpack_limit)
 639                         do_keep = 0;
 640                 else
 641                         do_keep = 1;
 642         }
 643
 644         if (do_keep) {
 645                 if (pack_lockfile)
 646                         cmd.out = -1;
 647                 *av++ = "index-pack";
 648                 *av++ = "--stdin";
 649                 if (!args.quiet && !args.no_progress)
 650                         *av++ = "-v";
 651                 if (args.use_thin_pack)
 652                         *av++ = "--fix-thin";
 653                 if (args.lock_pack || unpack_limit) {
 654                         int s = sprintf(keep_arg,
 655                                         "--keep=fetch-pack %"PRIuMAX " on ", (uintmax_t) getpid());
 656                         if (gethostname(keep_arg + s, sizeof(keep_arg) - s))
 657                                 strcpy(keep_arg + s, "localhost");
 658                         *av++ = keep_arg;
 659                 }
 660         }
 661         else {
 662                 *av++ = "unpack-objects";
 663                 if (args.quiet)
 664                         *av++ = "-q";
 665         }
 666         if (*hdr_arg)
 667                 *av++ = hdr_arg;
 668         *av++ = NULL;
 669
 670         cmd.in = demux.out;
 671         cmd.git_cmd = 1;
 672         if (start_command(&cmd))
 673                 die("fetch-pack: unable to fork off %s", argv[0]);
 674         if (do_keep && pack_lockfile) {
 675                 *pack_lockfile = index_pack_lockfile(cmd.out);
 676                 close(cmd.out);
 677         }
 678
 679         if (finish_command(&cmd))
 680                 die("%s failed", argv[0]);
 681         if (use_sideband && finish_async(&demux))
 682                 die("error in sideband demultiplexer");
 683         return 0;
 684 }
 685
 686 static struct ref *do_fetch_pack(int fd[2],
 687                 const struct ref *orig_ref,
 688                 int nr_match,
 689                 char **match,
 690                 char **pack_lockfile)
 691 {
 692         struct ref *ref = copy_ref_list(orig_ref);
 693         unsigned char sha1[20];
 694
 695         if (is_repository_shallow() && !server_supports("shallow"))
 696                 die("Server does not support shallow clients");
 697         if (server_supports("multi_ack_detailed")) {
 698                 if (args.verbose)
 699                         fprintf(stderr, "Server supports multi_ack_detailed\n");
 700                 multi_ack = 2;
 701         }
 702         else if (server_supports("multi_ack")) {
 703                 if (args.verbose)
 704                         fprintf(stderr, "Server supports multi_ack\n");
 705                 multi_ack = 1;
 706         }
 707         if (server_supports("side-band-64k")) {
 708                 if (args.verbose)
 709                         fprintf(stderr, "Server supports side-band-64k\n");
 710                 use_sideband = 2;
 711         }
 712         else if (server_supports("side-band")) {
 713                 if (args.verbose)
 714                         fprintf(stderr, "Server supports side-band\n");
 715                 use_sideband = 1;
 716         }
 717         if (server_supports("ofs-delta")) {
 718                 if (args.verbose)
 719                         fprintf(stderr, "Server supports ofs-delta\n");
 720         } else
 721                 prefer_ofs_delta = 0;
 722         if (everything_local(&ref, nr_match, match)) {
 723                 packet_flush(fd[1]);
 724                 goto all_done;
 725         }
 726         if (find_common(fd, sha1, ref) < 0)
 727                 if (!args.keep_pack)
 728                         /* When cloning, it is not unusual to have
 729                          * no common commit.
 730                          */
 731                         warning("no common commits");
 732
 733         if (args.stateless_rpc)
 734                 packet_flush(fd[1]);
 735         if (get_pack(fd, pack_lockfile))
 736                 die("git fetch-pack: fetch failed.");
 737
 738  all_done:
 739         return ref;
 740 }
 741
 742 static int remove_duplicates(int nr_heads, char **heads)
 743 {
 744         int src, dst;
 745
 746         for (src = dst = 0; src < nr_heads; src++) {
 747                 /* If heads[src] is different from any of
 748                  * heads[0..dst], push it in.
 749                  */
 750                 int i;
 751                 for (i = 0; i < dst; i++) {
 752                         if (!strcmp(heads[i], heads[src]))
 753                                 break;
 754                 }
 755                 if (i < dst)
 756                         continue;
 757                 if (src != dst)
 758                         heads[dst] = heads[src];
 759                 dst++;
 760         }
 761         return dst;
 762 }
 763
 764 static int fetch_pack_config(const char *var, const char *value, void *cb)
 765 {
 766         if (strcmp(var, "fetch.unpacklimit") == 0) {
 767                 fetch_unpack_limit = git_config_int(var, value);
 768                 return 0;
 769         }
 770
 771         if (strcmp(var, "transfer.unpacklimit") == 0) {
 772                 transfer_unpack_limit = git_config_int(var, value);
 773                 return 0;
 774         }
 775
 776         if (strcmp(var, "repack.usedeltabaseoffset") == 0) {
 777                 prefer_ofs_delta = git_config_bool(var, value);
 778                 return 0;
 779         }
 780
 781         return git_default_config(var, value, cb);
 782 }
 783
 784 static struct lock_file lock;
 785
 786 static void fetch_pack_setup(void)
 787 {
 788         static int did_setup;
 789         if (did_setup)
 790                 return;
 791         git_config(fetch_pack_config, NULL);
 792         if (0 <= transfer_unpack_limit)
 793                 unpack_limit = transfer_unpack_limit;
 794         else if (0 <= fetch_unpack_limit)
 795                 unpack_limit = fetch_unpack_limit;
 796         did_setup = 1;
 797 }
 798
 799 int cmd_fetch_pack(int argc, const char **argv, const char *prefix)
 800 {
 801         int i, ret, nr_heads;
 802         struct ref *ref = NULL;
 803         char *dest = NULL, **heads;
 804         int fd[2];
 805         char *pack_lockfile = NULL;
 806         char **pack_lockfile_ptr = NULL;
 807         struct child_process *conn;
 808
 809         nr_heads = 0;
 810         heads = NULL;
 811         for (i = 1; i < argc; i++) {
 812                 const char *arg = argv[i];
 813
 814                 if (*arg == '-') {
 815                         if (!prefixcmp(arg, "--upload-pack=")) {
 816                                 args.uploadpack = arg + 14;
 817                                 continue;
 818                         }
 819                         if (!prefixcmp(arg, "--exec=")) {
 820                                 args.uploadpack = arg + 7;
 821                                 continue;
 822                         }
 823                         if (!strcmp("--quiet", arg) || !strcmp("-q", arg)) {
 824                                 args.quiet = 1;
 825                                 continue;
 826                         }
 827                         if (!strcmp("--keep", arg) || !strcmp("-k", arg)) {
 828                                 args.lock_pack = args.keep_pack;
 829                                 args.keep_pack = 1;
 830                                 continue;
 831                         }
 832                         if (!strcmp("--thin", arg)) {
 833                                 args.use_thin_pack = 1;
 834                                 continue;
 835                         }
 836                         if (!strcmp("--include-tag", arg)) {
 837                                 args.include_tag = 1;
 838                                 continue;
 839                         }
 840                         if (!strcmp("--all", arg)) {
 841                                 args.fetch_all = 1;
 842                                 continue;
 843                         }
 844                         if (!strcmp("-v", arg)) {
 845                                 args.verbose = 1;
 846                                 continue;
 847                         }
 848                         if (!prefixcmp(arg, "--depth=")) {
 849                                 args.depth = strtol(arg + 8, NULL, 0);
 850                                 continue;
 851                         }
 852                         if (!strcmp("--no-progress", arg)) {
 853                                 args.no_progress = 1;
 854                                 continue;
 855                         }
 856                         if (!strcmp("--stateless-rpc", arg)) {
 857                                 args.stateless_rpc = 1;
 858                                 continue;
 859                         }
 860                         if (!strcmp("--lock-pack", arg)) {
 861                                 args.lock_pack = 1;
 862                                 pack_lockfile_ptr = &pack_lockfile;
 863                                 continue;
 864                         }
 865                         usage(fetch_pack_usage);
 866                 }
 867                 dest = (char *)arg;
 868                 heads = (char **)(argv + i + 1);
 869                 nr_heads = argc - i - 1;
 870                 break;
 871         }
 872         if (!dest)
 873                 usage(fetch_pack_usage);
 874
 875         if (args.stateless_rpc) {
 876                 conn = NULL;
 877                 fd[0] = 0;
 878                 fd[1] = 1;
 879         } else {
 880                 conn = git_connect(fd, (char *)dest, args.uploadpack,
 881                                    args.verbose ? CONNECT_VERBOSE : 0);
 882         }
 883
 884         get_remote_heads(fd[0], &ref, 0, NULL, 0, NULL);
 885
 886         ref = fetch_pack(&args, fd, conn, ref, dest,
 887                 nr_heads, heads, pack_lockfile_ptr);
 888         if (pack_lockfile) {
 889                 printf("lock %s\n", pack_lockfile);
 890                 fflush(stdout);
 891         }
 892         close(fd[0]);
 893         close(fd[1]);
 894         if (finish_connect(conn))
 895                 ref = NULL;
 896         ret = !ref;
 897
 898         if (!ret && nr_heads) {
 899                 /* If the heads to pull were given, we should have
 900                  * consumed all of them by matching the remote.
 901                  * Otherwise, 'git fetch remote no-such-ref' would
 902                  * silently succeed without issuing an error.
 903                  */
 904                 for (i = 0; i < nr_heads; i++)
 905                         if (heads[i] && heads[i][0]) {
 906                                 error("no such remote ref %s", heads[i]);
 907                                 ret = 1;
 908                         }
 909         }
 910         while (ref) {
 911                 printf("%s %s\n",
 912                        sha1_to_hex(ref->old_sha1), ref->name);
 913                 ref = ref->next;
 914         }
 915
 916         return ret;
 917 }
 918
 919 struct ref *fetch_pack(struct fetch_pack_args *my_args,
 920                        int fd[], struct child_process *conn,
 921                        const struct ref *ref,
 922                 const char *dest,
 923                 int nr_heads,
 924                 char **heads,
 925                 char **pack_lockfile)
 926 {
 927         struct stat st;
 928         struct ref *ref_cpy;
 929
 930         fetch_pack_setup();
 931         if (&args != my_args)
 932                 memcpy(&args, my_args, sizeof(args));
 933         if (args.depth > 0) {
 934                 if (stat(git_path("shallow"), &st))
 935                         st.st_mtime = 0;
 936         }
 937
 938         if (heads && nr_heads)
 939                 nr_heads = remove_duplicates(nr_heads, heads);
 940         if (!ref) {
 941                 packet_flush(fd[1]);
 942                 die("no matching remote head");
 943         }
 944         ref_cpy = do_fetch_pack(fd, ref, nr_heads, heads, pack_lockfile);
 945
 946         if (args.depth > 0) {
 947                 struct cache_time mtime;
 948                 struct strbuf sb = STRBUF_INIT;
 949                 char *shallow = git_path("shallow");
 950                 int fd;
 951
 952                 mtime.sec = st.st_mtime;
 953                 mtime.nsec = ST_MTIME_NSEC(st);
 954                 if (stat(shallow, &st)) {
 955                         if (mtime.sec)
 956                                 die("shallow file was removed during fetch");
 957                 } else if (st.st_mtime != mtime.sec
 958 #ifdef USE_NSEC
 959                                 || ST_MTIME_NSEC(st) != mtime.nsec
 960 #endif
 961                           )
 962                         die("shallow file was changed during fetch");
 963
 964                 fd = hold_lock_file_for_update(&lock, shallow,
 965                                                LOCK_DIE_ON_ERROR);
 966                 if (!write_shallow_commits(&sb, 0)
 967                  || write_in_full(fd, sb.buf, sb.len) != sb.len) {
 968                         unlink_or_warn(shallow);
 969                         rollback_lock_file(&lock);
 970                 } else {
 971                         commit_lock_file(&lock);
 972                 }
 973                 strbuf_release(&sb);
 974         }
 975
 976         reprepare_packed_git();
 977         return ref_cpy;
 978 }