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