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 fetch_fsck_objects = -1;
  18 static int transfer_fsck_objects = -1;
  19 static struct fetch_pack_args args = {
  20         /* .uploadpack = */ "git-upload-pack",
  21 };
  22
  23 static const char fetch_pack_usage[] =
  24 "git fetch-pack [--all] [--quiet|-q] [--keep|-k] [--thin] [--include-tag] [--upload-pack=<git-upload-pack>] [--depth=<n>] [--no-progress] [-v] [<host>:]<directory> [<refs>...]";
  25
  26 #define COMPLETE        (1U << 0)
  27 #define COMMON          (1U << 1)
  28 #define COMMON_REF      (1U << 2)
  29 #define SEEN            (1U << 3)
  30 #define POPPED          (1U << 4)
  31
  32 static int marked;
  33
  34 /*
  35  * After sending this many "have"s if we do not get any new ACK , we
  36  * give up traversing our history.
  37  */
  38 #define MAX_IN_VAIN 256
  39
  40 static struct commit_list *rev_list;
  41 static int non_common_revs, multi_ack, use_sideband;
  42
  43 static void rev_list_push(struct commit *commit, int mark)
  44 {
  45         if (!(commit->object.flags & mark)) {
  46                 commit->object.flags |= mark;
  47
  48                 if (!(commit->object.parsed))
  49                         if (parse_commit(commit))
  50                                 return;
  51
  52                 insert_by_date(commit, &rev_list);
  53
  54                 if (!(commit->object.flags & COMMON))
  55                         non_common_revs++;
  56         }
  57 }
  58
  59 static int rev_list_insert_ref(const char *path, const unsigned char *sha1, int flag, void *cb_data)
  60 {
  61         struct object *o = deref_tag(parse_object(sha1), path, 0);
  62
  63         if (o && o->type == OBJ_COMMIT)
  64                 rev_list_push((struct commit *)o, SEEN);
  65
  66         return 0;
  67 }
  68
  69 static int clear_marks(const char *path, const unsigned char *sha1, int flag, void *cb_data)
  70 {
  71         struct object *o = deref_tag(parse_object(sha1), path, 0);
  72
  73         if (o && o->type == OBJ_COMMIT)
  74                 clear_commit_marks((struct commit *)o,
  75                                    COMMON | COMMON_REF | SEEN | POPPED);
  76         return 0;
  77 }
  78
  79 /*
  80    This function marks a rev and its ancestors as common.
  81    In some cases, it is desirable to mark only the ancestors (for example
  82    when only the server does not yet know that they are common).
  83 */
  84
  85 static void mark_common(struct commit *commit,
  86                 int ancestors_only, int dont_parse)
  87 {
  88         if (commit != NULL && !(commit->object.flags & COMMON)) {
  89                 struct object *o = (struct object *)commit;
  90
  91                 if (!ancestors_only)
  92                         o->flags |= COMMON;
  93
  94                 if (!(o->flags & SEEN))
  95                         rev_list_push(commit, SEEN);
  96                 else {
  97                         struct commit_list *parents;
  98
  99                         if (!ancestors_only && !(o->flags & POPPED))
 100                                 non_common_revs--;
 101                         if (!o->parsed && !dont_parse)
 102                                 if (parse_commit(commit))
 103                                         return;
 104
 105                         for (parents = commit->parents;
 106                                         parents;
 107                                         parents = parents->next)
 108                                 mark_common(parents->item, 0, dont_parse);
 109                 }
 110         }
 111 }
 112
 113 /*
 114   Get the next rev to send, ignoring the common.
 115 */
 116
 117 static const unsigned char *get_rev(void)
 118 {
 119         struct commit *commit = NULL;
 120
 121         while (commit == NULL) {
 122                 unsigned int mark;
 123                 struct commit_list *parents;
 124
 125                 if (rev_list == NULL || non_common_revs == 0)
 126                         return NULL;
 127
 128                 commit = rev_list->item;
 129                 if (!commit->object.parsed)
 130                         parse_commit(commit);
 131                 parents = commit->parents;
 132
 133                 commit->object.flags |= POPPED;
 134                 if (!(commit->object.flags & COMMON))
 135                         non_common_revs--;
 136
 137                 if (commit->object.flags & COMMON) {
 138                         /* do not send "have", and ignore ancestors */
 139                         commit = NULL;
 140                         mark = COMMON | SEEN;
 141                 } else if (commit->object.flags & COMMON_REF)
 142                         /* send "have", and ignore ancestors */
 143                         mark = COMMON | SEEN;
 144                 else
 145                         /* send "have", also for its ancestors */
 146                         mark = SEEN;
 147
 148                 while (parents) {
 149                         if (!(parents->item->object.flags & SEEN))
 150                                 rev_list_push(parents->item, mark);
 151                         if (mark & COMMON)
 152                                 mark_common(parents->item, 1, 0);
 153                         parents = parents->next;
 154                 }
 155
 156                 rev_list = rev_list->next;
 157         }
 158
 159         return commit->object.sha1;
 160 }
 161
 162 enum ack_type {
 163         NAK = 0,
 164         ACK,
 165         ACK_continue,
 166         ACK_common,
 167         ACK_ready
 168 };
 169
 170 static void consume_shallow_list(int fd)
 171 {
 172         if (args.stateless_rpc && args.depth > 0) {
 173                 /* If we sent a depth we will get back "duplicate"
 174                  * shallow and unshallow commands every time there
 175                  * is a block of have lines exchanged.
 176                  */
 177                 char line[1000];
 178                 while (packet_read_line(fd, line, sizeof(line))) {
 179                         if (!prefixcmp(line, "shallow "))
 180                                 continue;
 181                         if (!prefixcmp(line, "unshallow "))
 182                                 continue;
 183                         die("git fetch-pack: expected shallow list");
 184                 }
 185         }
 186 }
 187
 188 static enum ack_type get_ack(int fd, unsigned char *result_sha1)
 189 {
 190         static char line[1000];
 191         int len = packet_read_line(fd, line, sizeof(line));
 192
 193         if (!len)
 194                 die("git fetch-pack: expected ACK/NAK, got EOF");
 195         if (line[len-1] == '\n')
 196                 line[--len] = 0;
 197         if (!strcmp(line, "NAK"))
 198                 return NAK;
 199         if (!prefixcmp(line, "ACK ")) {
 200                 if (!get_sha1_hex(line+4, result_sha1)) {
 201                         if (strstr(line+45, "continue"))
 202                                 return ACK_continue;
 203                         if (strstr(line+45, "common"))
 204                                 return ACK_common;
 205                         if (strstr(line+45, "ready"))
 206                                 return ACK_ready;
 207                         return ACK;
 208                 }
 209         }
 210         die("git fetch_pack: expected ACK/NAK, got '%s'", line);
 211 }
 212
 213 static void send_request(int fd, struct strbuf *buf)
 214 {
 215         if (args.stateless_rpc) {
 216                 send_sideband(fd, -1, buf->buf, buf->len, LARGE_PACKET_MAX);
 217                 packet_flush(fd);
 218         } else
 219                 safe_write(fd, buf->buf, buf->len);
 220 }
 221
 222 static int find_common(int fd[2], unsigned char *result_sha1,
 223                        struct ref *refs)
 224 {
 225         int fetching;
 226         int count = 0, flushes = 0, retval;
 227         const unsigned char *sha1;
 228         unsigned in_vain = 0;
 229         int got_continue = 0;
 230         struct strbuf req_buf = STRBUF_INIT;
 231         size_t state_len = 0;
 232
 233         if (args.stateless_rpc && multi_ack == 1)
 234                 die("--stateless-rpc requires multi_ack_detailed");
 235         if (marked)
 236                 for_each_ref(clear_marks, NULL);
 237         marked = 1;
 238
 239         for_each_ref(rev_list_insert_ref, NULL);
 240
 241         fetching = 0;
 242         for ( ; refs ; refs = refs->next) {
 243                 unsigned char *remote = refs->old_sha1;
 244                 const char *remote_hex;
 245                 struct object *o;
 246
 247                 /*
 248                  * If that object is complete (i.e. it is an ancestor of a
 249                  * local ref), we tell them we have it but do not have to
 250                  * tell them about its ancestors, which they already know
 251                  * about.
 252                  *
 253                  * We use lookup_object here because we are only
 254                  * interested in the case we *know* the object is
 255                  * reachable and we have already scanned it.
 256                  */
 257                 if (((o = lookup_object(remote)) != NULL) &&
 258                                 (o->flags & COMPLETE)) {
 259                         continue;
 260                 }
 261
 262                 remote_hex = sha1_to_hex(remote);
 263                 if (!fetching) {
 264                         struct strbuf c = STRBUF_INIT;
 265                         if (multi_ack == 2)     strbuf_addstr(&c, " multi_ack_detailed");
 266                         if (multi_ack == 1)     strbuf_addstr(&c, " multi_ack");
 267                         if (use_sideband == 2)  strbuf_addstr(&c, " side-band-64k");
 268                         if (use_sideband == 1)  strbuf_addstr(&c, " side-band");
 269                         if (args.use_thin_pack) strbuf_addstr(&c, " thin-pack");
 270                         if (args.no_progress)   strbuf_addstr(&c, " no-progress");
 271                         if (args.include_tag)   strbuf_addstr(&c, " include-tag");
 272                         if (prefer_ofs_delta)   strbuf_addstr(&c, " ofs-delta");
 273                         packet_buf_write(&req_buf, "want %s%s\n", remote_hex, c.buf);
 274                         strbuf_release(&c);
 275                 } else
 276                         packet_buf_write(&req_buf, "want %s\n", remote_hex);
 277                 fetching++;
 278         }
 279
 280         if (!fetching) {
 281                 strbuf_release(&req_buf);
 282                 packet_flush(fd[1]);
 283                 return 1;
 284         }
 285
 286         if (is_repository_shallow())
 287                 write_shallow_commits(&req_buf, 1);
 288         if (args.depth > 0)
 289                 packet_buf_write(&req_buf, "deepen %d", args.depth);
 290         packet_buf_flush(&req_buf);
 291         state_len = req_buf.len;
 292
 293         if (args.depth > 0) {
 294                 char line[1024];
 295                 unsigned char sha1[20];
 296
 297                 send_request(fd[1], &req_buf);
 298                 while (packet_read_line(fd[0], line, sizeof(line))) {
 299                         if (!prefixcmp(line, "shallow ")) {
 300                                 if (get_sha1_hex(line + 8, sha1))
 301                                         die("invalid shallow line: %s", line);
 302                                 register_shallow(sha1);
 303                                 continue;
 304                         }
 305                         if (!prefixcmp(line, "unshallow ")) {
 306                                 if (get_sha1_hex(line + 10, sha1))
 307                                         die("invalid unshallow line: %s", line);
 308                                 if (!lookup_object(sha1))
 309                                         die("object not found: %s", line);
 310                                 /* make sure that it is parsed as shallow */
 311                                 if (!parse_object(sha1))
 312                                         die("error in object: %s", line);
 313                                 if (unregister_shallow(sha1))
 314                                         die("no shallow found: %s", line);
 315                                 continue;
 316                         }
 317                         die("expected shallow/unshallow, got %s", line);
 318                 }
 319         } else if (!args.stateless_rpc)
 320                 send_request(fd[1], &req_buf);
 321
 322         if (!args.stateless_rpc) {
 323                 /* If we aren't using the stateless-rpc interface
 324                  * we don't need to retain the headers.
 325                  */
 326                 strbuf_setlen(&req_buf, 0);
 327                 state_len = 0;
 328         }
 329
 330         flushes = 0;
 331         retval = -1;
 332         while ((sha1 = get_rev())) {
 333                 packet_buf_write(&req_buf, "have %s\n", sha1_to_hex(sha1));
 334                 if (args.verbose)
 335                         fprintf(stderr, "have %s\n", sha1_to_hex(sha1));
 336                 in_vain++;
 337                 if (!(31 & ++count)) {
 338                         int ack;
 339
 340                         packet_buf_flush(&req_buf);
 341                         send_request(fd[1], &req_buf);
 342                         strbuf_setlen(&req_buf, state_len);
 343                         flushes++;
 344
 345                         /*
 346                          * We keep one window "ahead" of the other side, and
 347                          * will wait for an ACK only on the next one
 348                          */
 349                         if (!args.stateless_rpc && count == 32)
 350                                 continue;
 351
 352                         consume_shallow_list(fd[0]);
 353                         do {
 354                                 ack = get_ack(fd[0], result_sha1);
 355                                 if (args.verbose && ack)
 356                                         fprintf(stderr, "got ack %d %s\n", ack,
 357                                                         sha1_to_hex(result_sha1));
 358                                 switch (ack) {
 359                                 case ACK:
 360                                         flushes = 0;
 361                                         multi_ack = 0;
 362                                         retval = 0;
 363                                         goto done;
 364                                 case ACK_common:
 365                                 case ACK_ready:
 366                                 case ACK_continue: {
 367                                         struct commit *commit =
 368                                                 lookup_commit(result_sha1);
 369                                         if (args.stateless_rpc
 370                                          && ack == ACK_common
 371                                          && !(commit->object.flags & COMMON)) {
 372                                                 /* We need to replay the have for this object
 373                                                  * on the next RPC request so the peer knows
 374                                                  * it is in common with us.
 375                                                  */
 376                                                 const char *hex = sha1_to_hex(result_sha1);
 377                                                 packet_buf_write(&req_buf, "have %s\n", hex);
 378                                                 state_len = req_buf.len;
 379                                         }
 380                                         mark_common(commit, 0, 1);
 381                                         retval = 0;
 382                                         in_vain = 0;
 383                                         got_continue = 1;
 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                 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         if (fetch_fsck_objects >= 0
 669             ? fetch_fsck_objects
 670             : transfer_fsck_objects >= 0
 671             ? transfer_fsck_objects
 672             : 0)
 673                 *av++ = "--strict";
 674         *av++ = NULL;
 675
 676         cmd.in = demux.out;
 677         cmd.git_cmd = 1;
 678         if (start_command(&cmd))
 679                 die("fetch-pack: unable to fork off %s", argv[0]);
 680         if (do_keep && pack_lockfile) {
 681                 *pack_lockfile = index_pack_lockfile(cmd.out);
 682                 close(cmd.out);
 683         }
 684
 685         if (finish_command(&cmd))
 686                 die("%s failed", argv[0]);
 687         if (use_sideband && finish_async(&demux))
 688                 die("error in sideband demultiplexer");
 689         return 0;
 690 }
 691
 692 static struct ref *do_fetch_pack(int fd[2],
 693                 const struct ref *orig_ref,
 694                 int nr_match,
 695                 char **match,
 696                 char **pack_lockfile)
 697 {
 698         struct ref *ref = copy_ref_list(orig_ref);
 699         unsigned char sha1[20];
 700
 701         if (is_repository_shallow() && !server_supports("shallow"))
 702                 die("Server does not support shallow clients");
 703         if (server_supports("multi_ack_detailed")) {
 704                 if (args.verbose)
 705                         fprintf(stderr, "Server supports multi_ack_detailed\n");
 706                 multi_ack = 2;
 707         }
 708         else if (server_supports("multi_ack")) {
 709                 if (args.verbose)
 710                         fprintf(stderr, "Server supports multi_ack\n");
 711                 multi_ack = 1;
 712         }
 713         if (server_supports("side-band-64k")) {
 714                 if (args.verbose)
 715                         fprintf(stderr, "Server supports side-band-64k\n");
 716                 use_sideband = 2;
 717         }
 718         else if (server_supports("side-band")) {
 719                 if (args.verbose)
 720                         fprintf(stderr, "Server supports side-band\n");
 721                 use_sideband = 1;
 722         }
 723         if (server_supports("ofs-delta")) {
 724                 if (args.verbose)
 725                         fprintf(stderr, "Server supports ofs-delta\n");
 726         } else
 727                 prefer_ofs_delta = 0;
 728         if (everything_local(&ref, nr_match, match)) {
 729                 packet_flush(fd[1]);
 730                 goto all_done;
 731         }
 732         if (find_common(fd, sha1, ref) < 0)
 733                 if (!args.keep_pack)
 734                         /* When cloning, it is not unusual to have
 735                          * no common commit.
 736                          */
 737                         warning("no common commits");
 738
 739         if (args.stateless_rpc)
 740                 packet_flush(fd[1]);
 741         if (get_pack(fd, pack_lockfile))
 742                 die("git fetch-pack: fetch failed.");
 743
 744  all_done:
 745         return ref;
 746 }
 747
 748 static int remove_duplicates(int nr_heads, char **heads)
 749 {
 750         int src, dst;
 751
 752         for (src = dst = 0; src < nr_heads; src++) {
 753                 /* If heads[src] is different from any of
 754                  * heads[0..dst], push it in.
 755                  */
 756                 int i;
 757                 for (i = 0; i < dst; i++) {
 758                         if (!strcmp(heads[i], heads[src]))
 759                                 break;
 760                 }
 761                 if (i < dst)
 762                         continue;
 763                 if (src != dst)
 764                         heads[dst] = heads[src];
 765                 dst++;
 766         }
 767         return dst;
 768 }
 769
 770 static int fetch_pack_config(const char *var, const char *value, void *cb)
 771 {
 772         if (strcmp(var, "fetch.unpacklimit") == 0) {
 773                 fetch_unpack_limit = git_config_int(var, value);
 774                 return 0;
 775         }
 776
 777         if (strcmp(var, "transfer.unpacklimit") == 0) {
 778                 transfer_unpack_limit = git_config_int(var, value);
 779                 return 0;
 780         }
 781
 782         if (strcmp(var, "repack.usedeltabaseoffset") == 0) {
 783                 prefer_ofs_delta = git_config_bool(var, value);
 784                 return 0;
 785         }
 786
 787         if (!strcmp(var, "fetch.fsckobjects")) {
 788                 fetch_fsck_objects = git_config_bool(var, value);
 789                 return 0;
 790         }
 791
 792         if (!strcmp(var, "transfer.fsckobjects")) {
 793                 transfer_fsck_objects = git_config_bool(var, value);
 794                 return 0;
 795         }
 796
 797         return git_default_config(var, value, cb);
 798 }
 799
 800 static struct lock_file lock;
 801
 802 static void fetch_pack_setup(void)
 803 {
 804         static int did_setup;
 805         if (did_setup)
 806                 return;
 807         git_config(fetch_pack_config, NULL);
 808         if (0 <= transfer_unpack_limit)
 809                 unpack_limit = transfer_unpack_limit;
 810         else if (0 <= fetch_unpack_limit)
 811                 unpack_limit = fetch_unpack_limit;
 812         did_setup = 1;
 813 }
 814
 815 int cmd_fetch_pack(int argc, const char **argv, const char *prefix)
 816 {
 817         int i, ret, nr_heads;
 818         struct ref *ref = NULL;
 819         char *dest = NULL, **heads;
 820         int fd[2];
 821         char *pack_lockfile = NULL;
 822         char **pack_lockfile_ptr = NULL;
 823         struct child_process *conn;
 824
 825         nr_heads = 0;
 826         heads = NULL;
 827         for (i = 1; i < argc; i++) {
 828                 const char *arg = argv[i];
 829
 830                 if (*arg == '-') {
 831                         if (!prefixcmp(arg, "--upload-pack=")) {
 832                                 args.uploadpack = arg + 14;
 833                                 continue;
 834                         }
 835                         if (!prefixcmp(arg, "--exec=")) {
 836                                 args.uploadpack = arg + 7;
 837                                 continue;
 838                         }
 839                         if (!strcmp("--quiet", arg) || !strcmp("-q", arg)) {
 840                                 args.quiet = 1;
 841                                 continue;
 842                         }
 843                         if (!strcmp("--keep", arg) || !strcmp("-k", arg)) {
 844                                 args.lock_pack = args.keep_pack;
 845                                 args.keep_pack = 1;
 846                                 continue;
 847                         }
 848                         if (!strcmp("--thin", arg)) {
 849                                 args.use_thin_pack = 1;
 850                                 continue;
 851                         }
 852                         if (!strcmp("--include-tag", arg)) {
 853                                 args.include_tag = 1;
 854                                 continue;
 855                         }
 856                         if (!strcmp("--all", arg)) {
 857                                 args.fetch_all = 1;
 858                                 continue;
 859                         }
 860                         if (!strcmp("-v", arg)) {
 861                                 args.verbose = 1;
 862                                 continue;
 863                         }
 864                         if (!prefixcmp(arg, "--depth=")) {
 865                                 args.depth = strtol(arg + 8, NULL, 0);
 866                                 continue;
 867                         }
 868                         if (!strcmp("--no-progress", arg)) {
 869                                 args.no_progress = 1;
 870                                 continue;
 871                         }
 872                         if (!strcmp("--stateless-rpc", arg)) {
 873                                 args.stateless_rpc = 1;
 874                                 continue;
 875                         }
 876                         if (!strcmp("--lock-pack", arg)) {
 877                                 args.lock_pack = 1;
 878                                 pack_lockfile_ptr = &pack_lockfile;
 879                                 continue;
 880                         }
 881                         usage(fetch_pack_usage);
 882                 }
 883                 dest = (char *)arg;
 884                 heads = (char **)(argv + i + 1);
 885                 nr_heads = argc - i - 1;
 886                 break;
 887         }
 888         if (!dest)
 889                 usage(fetch_pack_usage);
 890
 891         if (args.stateless_rpc) {
 892                 conn = NULL;
 893                 fd[0] = 0;
 894                 fd[1] = 1;
 895         } else {
 896                 conn = git_connect(fd, (char *)dest, args.uploadpack,
 897                                    args.verbose ? CONNECT_VERBOSE : 0);
 898         }
 899
 900         get_remote_heads(fd[0], &ref, 0, NULL, 0, NULL);
 901
 902         ref = fetch_pack(&args, fd, conn, ref, dest,
 903                 nr_heads, heads, pack_lockfile_ptr);
 904         if (pack_lockfile) {
 905                 printf("lock %s\n", pack_lockfile);
 906                 fflush(stdout);
 907         }
 908         close(fd[0]);
 909         close(fd[1]);
 910         if (finish_connect(conn))
 911                 ref = NULL;
 912         ret = !ref;
 913
 914         if (!ret && nr_heads) {
 915                 /* If the heads to pull were given, we should have
 916                  * consumed all of them by matching the remote.
 917                  * Otherwise, 'git fetch remote no-such-ref' would
 918                  * silently succeed without issuing an error.
 919                  */
 920                 for (i = 0; i < nr_heads; i++)
 921                         if (heads[i] && heads[i][0]) {
 922                                 error("no such remote ref %s", heads[i]);
 923                                 ret = 1;
 924                         }
 925         }
 926         while (ref) {
 927                 printf("%s %s\n",
 928                        sha1_to_hex(ref->old_sha1), ref->name);
 929                 ref = ref->next;
 930         }
 931
 932         return ret;
 933 }
 934
 935 struct ref *fetch_pack(struct fetch_pack_args *my_args,
 936                        int fd[], struct child_process *conn,
 937                        const struct ref *ref,
 938                 const char *dest,
 939                 int nr_heads,
 940                 char **heads,
 941                 char **pack_lockfile)
 942 {
 943         struct stat st;
 944         struct ref *ref_cpy;
 945
 946         fetch_pack_setup();
 947         if (&args != my_args)
 948                 memcpy(&args, my_args, sizeof(args));
 949         if (args.depth > 0) {
 950                 if (stat(git_path("shallow"), &st))
 951                         st.st_mtime = 0;
 952         }
 953
 954         if (heads && nr_heads)
 955                 nr_heads = remove_duplicates(nr_heads, heads);
 956         if (!ref) {
 957                 packet_flush(fd[1]);
 958                 die("no matching remote head");
 959         }
 960         ref_cpy = do_fetch_pack(fd, ref, nr_heads, heads, pack_lockfile);
 961
 962         if (args.depth > 0) {
 963                 struct cache_time mtime;
 964                 struct strbuf sb = STRBUF_INIT;
 965                 char *shallow = git_path("shallow");
 966                 int fd;
 967
 968                 mtime.sec = st.st_mtime;
 969                 mtime.nsec = ST_MTIME_NSEC(st);
 970                 if (stat(shallow, &st)) {
 971                         if (mtime.sec)
 972                                 die("shallow file was removed during fetch");
 973                 } else if (st.st_mtime != mtime.sec
 974 #ifdef USE_NSEC
 975                                 || ST_MTIME_NSEC(st) != mtime.nsec
 976 #endif
 977                           )
 978                         die("shallow file was changed during fetch");
 979
 980                 fd = hold_lock_file_for_update(&lock, shallow,
 981                                                LOCK_DIE_ON_ERROR);
 982                 if (!write_shallow_commits(&sb, 0)
 983                  || write_in_full(fd, sb.buf, sb.len) != sb.len) {
 984                         unlink_or_warn(shallow);
 985                         rollback_lock_file(&lock);
 986                 } else {
 987                         commit_lock_file(&lock);
 988                 }
 989                 strbuf_release(&sb);
 990         }
 991
 992         reprepare_packed_git();
 993         return ref_cpy;
 994 }