builtin/fetch-pack.c

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