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