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 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                                         break;
 383                                         }
 384                                 }
 385                         } while (ack);
 386                         flushes--;
 387                         if (got_continue && MAX_IN_VAIN < in_vain) {
 388                                 if (args.verbose)
 389                                         fprintf(stderr, "giving up\n");
 390                                 break; /* give up */
 391                         }
 392                 }
 393         }
 394 done:
 395         packet_buf_write(&req_buf, "done\n");
 396         send_request(fd[1], &req_buf);
 397         if (args.verbose)
 398                 fprintf(stderr, "done\n");
 399         if (retval != 0) {
 400                 multi_ack = 0;
 401                 flushes++;
 402         }
 403         strbuf_release(&req_buf);
 404
 405         consume_shallow_list(fd[0]);
 406         while (flushes || multi_ack) {
 407                 int ack = get_ack(fd[0], result_sha1);
 408                 if (ack) {
 409                         if (args.verbose)
 410                                 fprintf(stderr, "got ack (%d) %s\n", ack,
 411                                         sha1_to_hex(result_sha1));
 412                         if (ack == ACK)
 413                                 return 0;
 414                         multi_ack = 1;
 415                         continue;
 416                 }
 417                 flushes--;
 418         }
 419         /* it is no error to fetch into a completely empty repo */
 420         return count ? retval : 0;
 421 }
 422
 423 static struct commit_list *complete;
 424
 425 static int mark_complete(const char *path, const unsigned char *sha1, int flag, void *cb_data)
 426 {
 427         struct object *o = parse_object(sha1);
 428
 429         while (o && o->type == OBJ_TAG) {
 430                 struct tag *t = (struct tag *) o;
 431                 if (!t->tagged)
 432                         break; /* broken repository */
 433                 o->flags |= COMPLETE;
 434                 o = parse_object(t->tagged->sha1);
 435         }
 436         if (o && o->type == OBJ_COMMIT) {
 437                 struct commit *commit = (struct commit *)o;
 438                 commit->object.flags |= COMPLETE;
 439                 insert_by_date(commit, &complete);
 440         }
 441         return 0;
 442 }
 443
 444 static void mark_recent_complete_commits(unsigned long cutoff)
 445 {
 446         while (complete && cutoff <= complete->item->date) {
 447                 if (args.verbose)
 448                         fprintf(stderr, "Marking %s as complete\n",
 449                                 sha1_to_hex(complete->item->object.sha1));
 450                 pop_most_recent_commit(&complete, COMPLETE);
 451         }
 452 }
 453
 454 static void filter_refs(struct ref **refs, int nr_match, char **match)
 455 {
 456         struct ref **return_refs;
 457         struct ref *newlist = NULL;
 458         struct ref **newtail = &newlist;
 459         struct ref *ref, *next;
 460         struct ref *fastarray[32];
 461
 462         if (nr_match && !args.fetch_all) {
 463                 if (ARRAY_SIZE(fastarray) < nr_match)
 464                         return_refs = xcalloc(nr_match, sizeof(struct ref *));
 465                 else {
 466                         return_refs = fastarray;
 467                         memset(return_refs, 0, sizeof(struct ref *) * nr_match);
 468                 }
 469         }
 470         else
 471                 return_refs = NULL;
 472
 473         for (ref = *refs; ref; ref = next) {
 474                 next = ref->next;
 475                 if (!memcmp(ref->name, "refs/", 5) &&
 476                     check_ref_format(ref->name + 5))
 477                         ; /* trash */
 478                 else if (args.fetch_all &&
 479                          (!args.depth || prefixcmp(ref->name, "refs/tags/") )) {
 480                         *newtail = ref;
 481                         ref->next = NULL;
 482                         newtail = &ref->next;
 483                         continue;
 484                 }
 485                 else {
 486                         int order = path_match(ref->name, nr_match, match);
 487                         if (order) {
 488                                 return_refs[order-1] = ref;
 489                                 continue; /* we will link it later */
 490                         }
 491                 }
 492                 free(ref);
 493         }
 494
 495         if (!args.fetch_all) {
 496                 int i;
 497                 for (i = 0; i < nr_match; i++) {
 498                         ref = return_refs[i];
 499                         if (ref) {
 500                                 *newtail = ref;
 501                                 ref->next = NULL;
 502                                 newtail = &ref->next;
 503                         }
 504                 }
 505                 if (return_refs != fastarray)
 506                         free(return_refs);
 507         }
 508         *refs = newlist;
 509 }
 510
 511 static int everything_local(struct ref **refs, int nr_match, char **match)
 512 {
 513         struct ref *ref;
 514         int retval;
 515         unsigned long cutoff = 0;
 516
 517         save_commit_buffer = 0;
 518
 519         for (ref = *refs; ref; ref = ref->next) {
 520                 struct object *o;
 521
 522                 o = parse_object(ref->old_sha1);
 523                 if (!o)
 524                         continue;
 525
 526                 /* We already have it -- which may mean that we were
 527                  * in sync with the other side at some time after
 528                  * that (it is OK if we guess wrong here).
 529                  */
 530                 if (o->type == OBJ_COMMIT) {
 531                         struct commit *commit = (struct commit *)o;
 532                         if (!cutoff || cutoff < commit->date)
 533                                 cutoff = commit->date;
 534                 }
 535         }
 536
 537         if (!args.depth) {
 538                 for_each_ref(mark_complete, NULL);
 539                 if (cutoff)
 540                         mark_recent_complete_commits(cutoff);
 541         }
 542
 543         /*
 544          * Mark all complete remote refs as common refs.
 545          * Don't mark them common yet; the server has to be told so first.
 546          */
 547         for (ref = *refs; ref; ref = ref->next) {
 548                 struct object *o = deref_tag(lookup_object(ref->old_sha1),
 549                                              NULL, 0);
 550
 551                 if (!o || o->type != OBJ_COMMIT || !(o->flags & COMPLETE))
 552                         continue;
 553
 554                 if (!(o->flags & SEEN)) {
 555                         rev_list_push((struct commit *)o, COMMON_REF | SEEN);
 556
 557                         mark_common((struct commit *)o, 1, 1);
 558                 }
 559         }
 560
 561         filter_refs(refs, nr_match, match);
 562
 563         for (retval = 1, ref = *refs; ref ; ref = ref->next) {
 564                 const unsigned char *remote = ref->old_sha1;
 565                 unsigned char local[20];
 566                 struct object *o;
 567
 568                 o = lookup_object(remote);
 569                 if (!o || !(o->flags & COMPLETE)) {
 570                         retval = 0;
 571                         if (!args.verbose)
 572                                 continue;
 573                         fprintf(stderr,
 574                                 "want %s (%s)\n", sha1_to_hex(remote),
 575                                 ref->name);
 576                         continue;
 577                 }
 578
 579                 hashcpy(ref->new_sha1, local);
 580                 if (!args.verbose)
 581                         continue;
 582                 fprintf(stderr,
 583                         "already have %s (%s)\n", sha1_to_hex(remote),
 584                         ref->name);
 585         }
 586         return retval;
 587 }
 588
 589 static int sideband_demux(int in, int out, void *data)
 590 {
 591         int *xd = data;
 592
 593         int ret = recv_sideband("fetch-pack", xd[0], out);
 594         close(out);
 595         return ret;
 596 }
 597
 598 static int get_pack(int xd[2], char **pack_lockfile)
 599 {
 600         struct async demux;
 601         const char *argv[20];
 602         char keep_arg[256];
 603         char hdr_arg[256];
 604         const char **av;
 605         int do_keep = args.keep_pack;
 606         struct child_process cmd;
 607
 608         memset(&demux, 0, sizeof(demux));
 609         if (use_sideband) {
 610                 /* xd[] is talking with upload-pack; subprocess reads from
 611                  * xd[0], spits out band#2 to stderr, and feeds us band#1
 612                  * through demux->out.
 613                  */
 614                 demux.proc = sideband_demux;
 615                 demux.data = xd;
 616                 demux.out = -1;
 617                 if (start_async(&demux))
 618                         die("fetch-pack: unable to fork off sideband"
 619                             " demultiplexer");
 620         }
 621         else
 622                 demux.out = xd[0];
 623
 624         memset(&cmd, 0, sizeof(cmd));
 625         cmd.argv = argv;
 626         av = argv;
 627         *hdr_arg = 0;
 628         if (!args.keep_pack && unpack_limit) {
 629                 struct pack_header header;
 630
 631                 if (read_pack_header(demux.out, &header))
 632                         die("protocol error: bad pack header");
 633                 snprintf(hdr_arg, sizeof(hdr_arg),
 634                          "--pack_header=%"PRIu32",%"PRIu32,
 635                          ntohl(header.hdr_version), ntohl(header.hdr_entries));
 636                 if (ntohl(header.hdr_entries) < unpack_limit)
 637                         do_keep = 0;
 638                 else
 639                         do_keep = 1;
 640         }
 641
 642         if (do_keep) {
 643                 if (pack_lockfile)
 644                         cmd.out = -1;
 645                 *av++ = "index-pack";
 646                 *av++ = "--stdin";
 647                 if (!args.quiet && !args.no_progress)
 648                         *av++ = "-v";
 649                 if (args.use_thin_pack)
 650                         *av++ = "--fix-thin";
 651                 if (args.lock_pack || unpack_limit) {
 652                         int s = sprintf(keep_arg,
 653                                         "--keep=fetch-pack %"PRIuMAX " on ", (uintmax_t) getpid());
 654                         if (gethostname(keep_arg + s, sizeof(keep_arg) - s))
 655                                 strcpy(keep_arg + s, "localhost");
 656                         *av++ = keep_arg;
 657                 }
 658         }
 659         else {
 660                 *av++ = "unpack-objects";
 661                 if (args.quiet)
 662                         *av++ = "-q";
 663         }
 664         if (*hdr_arg)
 665                 *av++ = hdr_arg;
 666         *av++ = NULL;
 667
 668         cmd.in = demux.out;
 669         cmd.git_cmd = 1;
 670         if (start_command(&cmd))
 671                 die("fetch-pack: unable to fork off %s", argv[0]);
 672         if (do_keep && pack_lockfile) {
 673                 *pack_lockfile = index_pack_lockfile(cmd.out);
 674                 close(cmd.out);
 675         }
 676
 677         if (finish_command(&cmd))
 678                 die("%s failed", argv[0]);
 679         if (use_sideband && finish_async(&demux))
 680                 die("error in sideband demultiplexer");
 681         return 0;
 682 }
 683
 684 static struct ref *do_fetch_pack(int fd[2],
 685                 const struct ref *orig_ref,
 686                 int nr_match,
 687                 char **match,
 688                 char **pack_lockfile)
 689 {
 690         struct ref *ref = copy_ref_list(orig_ref);
 691         unsigned char sha1[20];
 692
 693         if (is_repository_shallow() && !server_supports("shallow"))
 694                 die("Server does not support shallow clients");
 695         if (server_supports("multi_ack_detailed")) {
 696                 if (args.verbose)
 697                         fprintf(stderr, "Server supports multi_ack_detailed\n");
 698                 multi_ack = 2;
 699         }
 700         else if (server_supports("multi_ack")) {
 701                 if (args.verbose)
 702                         fprintf(stderr, "Server supports multi_ack\n");
 703                 multi_ack = 1;
 704         }
 705         if (server_supports("side-band-64k")) {
 706                 if (args.verbose)
 707                         fprintf(stderr, "Server supports side-band-64k\n");
 708                 use_sideband = 2;
 709         }
 710         else if (server_supports("side-band")) {
 711                 if (args.verbose)
 712                         fprintf(stderr, "Server supports side-band\n");
 713                 use_sideband = 1;
 714         }
 715         if (server_supports("ofs-delta")) {
 716                 if (args.verbose)
 717                         fprintf(stderr, "Server supports ofs-delta\n");
 718         } else
 719                 prefer_ofs_delta = 0;
 720         if (everything_local(&ref, nr_match, match)) {
 721                 packet_flush(fd[1]);
 722                 goto all_done;
 723         }
 724         if (find_common(fd, sha1, ref) < 0)
 725                 if (!args.keep_pack)
 726                         /* When cloning, it is not unusual to have
 727                          * no common commit.
 728                          */
 729                         warning("no common commits");
 730
 731         if (args.stateless_rpc)
 732                 packet_flush(fd[1]);
 733         if (get_pack(fd, pack_lockfile))
 734                 die("git fetch-pack: fetch failed.");
 735
 736  all_done:
 737         return ref;
 738 }
 739
 740 static int remove_duplicates(int nr_heads, char **heads)
 741 {
 742         int src, dst;
 743
 744         for (src = dst = 0; src < nr_heads; src++) {
 745                 /* If heads[src] is different from any of
 746                  * heads[0..dst], push it in.
 747                  */
 748                 int i;
 749                 for (i = 0; i < dst; i++) {
 750                         if (!strcmp(heads[i], heads[src]))
 751                                 break;
 752                 }
 753                 if (i < dst)
 754                         continue;
 755                 if (src != dst)
 756                         heads[dst] = heads[src];
 757                 dst++;
 758         }
 759         return dst;
 760 }
 761
 762 static int fetch_pack_config(const char *var, const char *value, void *cb)
 763 {
 764         if (strcmp(var, "fetch.unpacklimit") == 0) {
 765                 fetch_unpack_limit = git_config_int(var, value);
 766                 return 0;
 767         }
 768
 769         if (strcmp(var, "transfer.unpacklimit") == 0) {
 770                 transfer_unpack_limit = git_config_int(var, value);
 771                 return 0;
 772         }
 773
 774         if (strcmp(var, "repack.usedeltabaseoffset") == 0) {
 775                 prefer_ofs_delta = git_config_bool(var, value);
 776                 return 0;
 777         }
 778
 779         return git_default_config(var, value, cb);
 780 }
 781
 782 static struct lock_file lock;
 783
 784 static void fetch_pack_setup(void)
 785 {
 786         static int did_setup;
 787         if (did_setup)
 788                 return;
 789         git_config(fetch_pack_config, NULL);
 790         if (0 <= transfer_unpack_limit)
 791                 unpack_limit = transfer_unpack_limit;
 792         else if (0 <= fetch_unpack_limit)
 793                 unpack_limit = fetch_unpack_limit;
 794         did_setup = 1;
 795 }
 796
 797 int cmd_fetch_pack(int argc, const char **argv, const char *prefix)
 798 {
 799         int i, ret, nr_heads;
 800         struct ref *ref = NULL;
 801         char *dest = NULL, **heads;
 802         int fd[2];
 803         char *pack_lockfile = NULL;
 804         char **pack_lockfile_ptr = NULL;
 805         struct child_process *conn;
 806
 807         nr_heads = 0;
 808         heads = NULL;
 809         for (i = 1; i < argc; i++) {
 810                 const char *arg = argv[i];
 811
 812                 if (*arg == '-') {
 813                         if (!prefixcmp(arg, "--upload-pack=")) {
 814                                 args.uploadpack = arg + 14;
 815                                 continue;
 816                         }
 817                         if (!prefixcmp(arg, "--exec=")) {
 818                                 args.uploadpack = arg + 7;
 819                                 continue;
 820                         }
 821                         if (!strcmp("--quiet", arg) || !strcmp("-q", arg)) {
 822                                 args.quiet = 1;
 823                                 continue;
 824                         }
 825                         if (!strcmp("--keep", arg) || !strcmp("-k", arg)) {
 826                                 args.lock_pack = args.keep_pack;
 827                                 args.keep_pack = 1;
 828                                 continue;
 829                         }
 830                         if (!strcmp("--thin", arg)) {
 831                                 args.use_thin_pack = 1;
 832                                 continue;
 833                         }
 834                         if (!strcmp("--include-tag", arg)) {
 835                                 args.include_tag = 1;
 836                                 continue;
 837                         }
 838                         if (!strcmp("--all", arg)) {
 839                                 args.fetch_all = 1;
 840                                 continue;
 841                         }
 842                         if (!strcmp("-v", arg)) {
 843                                 args.verbose = 1;
 844                                 continue;
 845                         }
 846                         if (!prefixcmp(arg, "--depth=")) {
 847                                 args.depth = strtol(arg + 8, NULL, 0);
 848                                 continue;
 849                         }
 850                         if (!strcmp("--no-progress", arg)) {
 851                                 args.no_progress = 1;
 852                                 continue;
 853                         }
 854                         if (!strcmp("--stateless-rpc", arg)) {
 855                                 args.stateless_rpc = 1;
 856                                 continue;
 857                         }
 858                         if (!strcmp("--lock-pack", arg)) {
 859                                 args.lock_pack = 1;
 860                                 pack_lockfile_ptr = &pack_lockfile;
 861                                 continue;
 862                         }
 863                         usage(fetch_pack_usage);
 864                 }
 865                 dest = (char *)arg;
 866                 heads = (char **)(argv + i + 1);
 867                 nr_heads = argc - i - 1;
 868                 break;
 869         }
 870         if (!dest)
 871                 usage(fetch_pack_usage);
 872
 873         if (args.stateless_rpc) {
 874                 conn = NULL;
 875                 fd[0] = 0;
 876                 fd[1] = 1;
 877         } else {
 878                 conn = git_connect(fd, (char *)dest, args.uploadpack,
 879                                    args.verbose ? CONNECT_VERBOSE : 0);
 880         }
 881
 882         get_remote_heads(fd[0], &ref, 0, NULL, 0, NULL);
 883
 884         ref = fetch_pack(&args, fd, conn, ref, dest,
 885                 nr_heads, heads, pack_lockfile_ptr);
 886         if (pack_lockfile) {
 887                 printf("lock %s\n", pack_lockfile);
 888                 fflush(stdout);
 889         }
 890         close(fd[0]);
 891         close(fd[1]);
 892         if (finish_connect(conn))
 893                 ref = NULL;
 894         ret = !ref;
 895
 896         if (!ret && nr_heads) {
 897                 /* If the heads to pull were given, we should have
 898                  * consumed all of them by matching the remote.
 899                  * Otherwise, 'git fetch remote no-such-ref' would
 900                  * silently succeed without issuing an error.
 901                  */
 902                 for (i = 0; i < nr_heads; i++)
 903                         if (heads[i] && heads[i][0]) {
 904                                 error("no such remote ref %s", heads[i]);
 905                                 ret = 1;
 906                         }
 907         }
 908         while (ref) {
 909                 printf("%s %s\n",
 910                        sha1_to_hex(ref->old_sha1), ref->name);
 911                 ref = ref->next;
 912         }
 913
 914         return ret;
 915 }
 916
 917 struct ref *fetch_pack(struct fetch_pack_args *my_args,
 918                        int fd[], struct child_process *conn,
 919                        const struct ref *ref,
 920                 const char *dest,
 921                 int nr_heads,
 922                 char **heads,
 923                 char **pack_lockfile)
 924 {
 925         struct stat st;
 926         struct ref *ref_cpy;
 927
 928         fetch_pack_setup();
 929         if (&args != my_args)
 930                 memcpy(&args, my_args, sizeof(args));
 931         if (args.depth > 0) {
 932                 if (stat(git_path("shallow"), &st))
 933                         st.st_mtime = 0;
 934         }
 935
 936         if (heads && nr_heads)
 937                 nr_heads = remove_duplicates(nr_heads, heads);
 938         if (!ref) {
 939                 packet_flush(fd[1]);
 940                 die("no matching remote head");
 941         }
 942         ref_cpy = do_fetch_pack(fd, ref, nr_heads, heads, pack_lockfile);
 943
 944         if (args.depth > 0) {
 945                 struct cache_time mtime;
 946                 struct strbuf sb = STRBUF_INIT;
 947                 char *shallow = git_path("shallow");
 948                 int fd;
 949
 950                 mtime.sec = st.st_mtime;
 951                 mtime.nsec = ST_MTIME_NSEC(st);
 952                 if (stat(shallow, &st)) {
 953                         if (mtime.sec)
 954                                 die("shallow file was removed during fetch");
 955                 } else if (st.st_mtime != mtime.sec
 956 #ifdef USE_NSEC
 957                                 || ST_MTIME_NSEC(st) != mtime.nsec
 958 #endif
 959                           )
 960                         die("shallow file was changed during fetch");
 961
 962                 fd = hold_lock_file_for_update(&lock, shallow,
 963                                                LOCK_DIE_ON_ERROR);
 964                 if (!write_shallow_commits(&sb, 0)
 965                  || write_in_full(fd, sb.buf, sb.len) != sb.len) {
 966                         unlink_or_warn(shallow);
 967                         rollback_lock_file(&lock);
 968                 } else {
 969                         commit_lock_file(&lock);
 970                 }
 971                 strbuf_release(&sb);
 972         }
 973
 974         reprepare_packed_git();
 975         return ref_cpy;
 976 }