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