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 "connect.h"
  13 #include "transport.h"
  14 #include "version.h"
  15 #include "prio-queue.h"
  16 #include "sha1-array.h"
  17
  18 static int transfer_unpack_limit = -1;
  19 static int fetch_unpack_limit = -1;
  20 static int unpack_limit = 100;
  21 static int prefer_ofs_delta = 1;
  22 static int no_done;
  23 static int fetch_fsck_objects = -1;
  24 static int transfer_fsck_objects = -1;
  25 static int agent_supported;
  26 static struct lock_file shallow_lock;
  27 static const char *alternate_shallow_file;
  28
  29 /* Remember to update object flag allocation in object.h */
  30 #define COMPLETE        (1U << 0)
  31 #define COMMON          (1U << 1)
  32 #define COMMON_REF      (1U << 2)
  33 #define SEEN            (1U << 3)
  34 #define POPPED          (1U << 4)
  35
  36 static int marked;
  37
  38 /*
  39  * After sending this many "have"s if we do not get any new ACK , we
  40  * give up traversing our history.
  41  */
  42 #define MAX_IN_VAIN 256
  43
  44 static struct prio_queue rev_list = { compare_commits_by_commit_date };
  45 static int non_common_revs, multi_ack, use_sideband, allow_tip_sha1_in_want;
  46
  47 static void rev_list_push(struct commit *commit, int mark)
  48 {
  49         if (!(commit->object.flags & mark)) {
  50                 commit->object.flags |= mark;
  51
  52                 if (parse_commit(commit))
  53                         return;
  54
  55                 prio_queue_put(&rev_list, commit);
  56
  57                 if (!(commit->object.flags & COMMON))
  58                         non_common_revs++;
  59         }
  60 }
  61
  62 static int rev_list_insert_ref(const char *refname, const unsigned char *sha1, int flag, void *cb_data)
  63 {
  64         struct object *o = deref_tag(parse_object(sha1), refname, 0);
  65
  66         if (o && o->type == OBJ_COMMIT)
  67                 rev_list_push((struct commit *)o, SEEN);
  68
  69         return 0;
  70 }
  71
  72 static int clear_marks(const char *refname, const unsigned char *sha1, int flag, void *cb_data)
  73 {
  74         struct object *o = deref_tag(parse_object(sha1), refname, 0);
  75
  76         if (o && o->type == OBJ_COMMIT)
  77                 clear_commit_marks((struct commit *)o,
  78                                    COMMON | COMMON_REF | SEEN | POPPED);
  79         return 0;
  80 }
  81
  82 /*
  83    This function marks a rev and its ancestors as common.
  84    In some cases, it is desirable to mark only the ancestors (for example
  85    when only the server does not yet know that they are common).
  86 */
  87
  88 static void mark_common(struct commit *commit,
  89                 int ancestors_only, int dont_parse)
  90 {
  91         if (commit != NULL && !(commit->object.flags & COMMON)) {
  92                 struct object *o = (struct object *)commit;
  93
  94                 if (!ancestors_only)
  95                         o->flags |= COMMON;
  96
  97                 if (!(o->flags & SEEN))
  98                         rev_list_push(commit, SEEN);
  99                 else {
 100                         struct commit_list *parents;
 101
 102                         if (!ancestors_only && !(o->flags & POPPED))
 103                                 non_common_revs--;
 104                         if (!o->parsed && !dont_parse)
 105                                 if (parse_commit(commit))
 106                                         return;
 107
 108                         for (parents = commit->parents;
 109                                         parents;
 110                                         parents = parents->next)
 111                                 mark_common(parents->item, 0, dont_parse);
 112                 }
 113         }
 114 }
 115
 116 /*
 117   Get the next rev to send, ignoring the common.
 118 */
 119
 120 static const unsigned char *get_rev(void)
 121 {
 122         struct commit *commit = NULL;
 123
 124         while (commit == NULL) {
 125                 unsigned int mark;
 126                 struct commit_list *parents;
 127
 128                 if (rev_list.nr == 0 || non_common_revs == 0)
 129                         return NULL;
 130
 131                 commit = prio_queue_get(&rev_list);
 132                 parse_commit(commit);
 133                 parents = commit->parents;
 134
 135                 commit->object.flags |= POPPED;
 136                 if (!(commit->object.flags & COMMON))
 137                         non_common_revs--;
 138
 139                 if (commit->object.flags & COMMON) {
 140                         /* do not send "have", and ignore ancestors */
 141                         commit = NULL;
 142                         mark = COMMON | SEEN;
 143                 } else if (commit->object.flags & COMMON_REF)
 144                         /* send "have", and ignore ancestors */
 145                         mark = COMMON | SEEN;
 146                 else
 147                         /* send "have", also for its ancestors */
 148                         mark = SEEN;
 149
 150                 while (parents) {
 151                         if (!(parents->item->object.flags & SEEN))
 152                                 rev_list_push(parents->item, mark);
 153                         if (mark & COMMON)
 154                                 mark_common(parents->item, 1, 0);
 155                         parents = parents->next;
 156                 }
 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(struct fetch_pack_args *args, 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;
 178                 while ((line = packet_read_line(fd, NULL))) {
 179                         if (starts_with(line, "shallow "))
 180                                 continue;
 181                         if (starts_with(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         int len;
 191         char *line = packet_read_line(fd, &len);
 192         const char *arg;
 193
 194         if (!len)
 195                 die("git fetch-pack: expected ACK/NAK, got EOF");
 196         if (!strcmp(line, "NAK"))
 197                 return NAK;
 198         if (skip_prefix(line, "ACK ", &arg)) {
 199                 if (!get_sha1_hex(arg, result_sha1)) {
 200                         arg += 40;
 201                         len -= arg - line;
 202                         if (len < 1)
 203                                 return ACK;
 204                         if (strstr(arg, "continue"))
 205                                 return ACK_continue;
 206                         if (strstr(arg, "common"))
 207                                 return ACK_common;
 208                         if (strstr(arg, "ready"))
 209                                 return ACK_ready;
 210                         return ACK;
 211                 }
 212         }
 213         die("git fetch_pack: expected ACK/NAK, got '%s'", line);
 214 }
 215
 216 static void send_request(struct fetch_pack_args *args,
 217                          int fd, struct strbuf *buf)
 218 {
 219         if (args->stateless_rpc) {
 220                 send_sideband(fd, -1, buf->buf, buf->len, LARGE_PACKET_MAX);
 221                 packet_flush(fd);
 222         } else
 223                 write_or_die(fd, buf->buf, buf->len);
 224 }
 225
 226 static void insert_one_alternate_ref(const struct ref *ref, void *unused)
 227 {
 228         rev_list_insert_ref(NULL, ref->old_sha1, 0, NULL);
 229 }
 230
 231 #define INITIAL_FLUSH 16
 232 #define PIPESAFE_FLUSH 32
 233 #define LARGE_FLUSH 1024
 234
 235 static int next_flush(struct fetch_pack_args *args, int count)
 236 {
 237         int flush_limit = args->stateless_rpc ? LARGE_FLUSH : PIPESAFE_FLUSH;
 238
 239         if (count < flush_limit)
 240                 count <<= 1;
 241         else
 242                 count += flush_limit;
 243         return count;
 244 }
 245
 246 static int find_common(struct fetch_pack_args *args,
 247                        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         for_each_alternate_ref(insert_one_alternate_ref, NULL);
 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                         if (agent_supported)    strbuf_addf(&c, " agent=%s",
 302                                                             git_user_agent_sanitized());
 303                         packet_buf_write(&req_buf, "want %s%s\n", remote_hex, c.buf);
 304                         strbuf_release(&c);
 305                 } else
 306                         packet_buf_write(&req_buf, "want %s\n", remote_hex);
 307                 fetching++;
 308         }
 309
 310         if (!fetching) {
 311                 strbuf_release(&req_buf);
 312                 packet_flush(fd[1]);
 313                 return 1;
 314         }
 315
 316         if (is_repository_shallow())
 317                 write_shallow_commits(&req_buf, 1, NULL);
 318         if (args->depth > 0)
 319                 packet_buf_write(&req_buf, "deepen %d", args->depth);
 320         packet_buf_flush(&req_buf);
 321         state_len = req_buf.len;
 322
 323         if (args->depth > 0) {
 324                 char *line;
 325                 const char *arg;
 326                 unsigned char sha1[20];
 327
 328                 send_request(args, fd[1], &req_buf);
 329                 while ((line = packet_read_line(fd[0], NULL))) {
 330                         if (skip_prefix(line, "shallow ", &arg)) {
 331                                 if (get_sha1_hex(arg, sha1))
 332                                         die("invalid shallow line: %s", line);
 333                                 register_shallow(sha1);
 334                                 continue;
 335                         }
 336                         if (skip_prefix(line, "unshallow ", &arg)) {
 337                                 if (get_sha1_hex(arg, sha1))
 338                                         die("invalid unshallow line: %s", line);
 339                                 if (!lookup_object(sha1))
 340                                         die("object not found: %s", line);
 341                                 /* make sure that it is parsed as shallow */
 342                                 if (!parse_object(sha1))
 343                                         die("error in object: %s", line);
 344                                 if (unregister_shallow(sha1))
 345                                         die("no shallow found: %s", line);
 346                                 continue;
 347                         }
 348                         die("expected shallow/unshallow, got %s", line);
 349                 }
 350         } else if (!args->stateless_rpc)
 351                 send_request(args, fd[1], &req_buf);
 352
 353         if (!args->stateless_rpc) {
 354                 /* If we aren't using the stateless-rpc interface
 355                  * we don't need to retain the headers.
 356                  */
 357                 strbuf_setlen(&req_buf, 0);
 358                 state_len = 0;
 359         }
 360
 361         flushes = 0;
 362         retval = -1;
 363         while ((sha1 = get_rev())) {
 364                 packet_buf_write(&req_buf, "have %s\n", sha1_to_hex(sha1));
 365                 if (args->verbose)
 366                         fprintf(stderr, "have %s\n", sha1_to_hex(sha1));
 367                 in_vain++;
 368                 if (flush_at <= ++count) {
 369                         int ack;
 370
 371                         packet_buf_flush(&req_buf);
 372                         send_request(args, fd[1], &req_buf);
 373                         strbuf_setlen(&req_buf, state_len);
 374                         flushes++;
 375                         flush_at = next_flush(args, count);
 376
 377                         /*
 378                          * We keep one window "ahead" of the other side, and
 379                          * will wait for an ACK only on the next one
 380                          */
 381                         if (!args->stateless_rpc && count == INITIAL_FLUSH)
 382                                 continue;
 383
 384                         consume_shallow_list(args, fd[0]);
 385                         do {
 386                                 ack = get_ack(fd[0], result_sha1);
 387                                 if (args->verbose && ack)
 388                                         fprintf(stderr, "got ack %d %s\n", ack,
 389                                                         sha1_to_hex(result_sha1));
 390                                 switch (ack) {
 391                                 case ACK:
 392                                         flushes = 0;
 393                                         multi_ack = 0;
 394                                         retval = 0;
 395                                         goto done;
 396                                 case ACK_common:
 397                                 case ACK_ready:
 398                                 case ACK_continue: {
 399                                         struct commit *commit =
 400                                                 lookup_commit(result_sha1);
 401                                         if (!commit)
 402                                                 die("invalid commit %s", sha1_to_hex(result_sha1));
 403                                         if (args->stateless_rpc
 404                                          && ack == ACK_common
 405                                          && !(commit->object.flags & COMMON)) {
 406                                                 /* We need to replay the have for this object
 407                                                  * on the next RPC request so the peer knows
 408                                                  * it is in common with us.
 409                                                  */
 410                                                 const char *hex = sha1_to_hex(result_sha1);
 411                                                 packet_buf_write(&req_buf, "have %s\n", hex);
 412                                                 state_len = req_buf.len;
 413                                         }
 414                                         mark_common(commit, 0, 1);
 415                                         retval = 0;
 416                                         in_vain = 0;
 417                                         got_continue = 1;
 418                                         if (ack == ACK_ready) {
 419                                                 clear_prio_queue(&rev_list);
 420                                                 got_ready = 1;
 421                                         }
 422                                         break;
 423                                         }
 424                                 }
 425                         } while (ack);
 426                         flushes--;
 427                         if (got_continue && MAX_IN_VAIN < in_vain) {
 428                                 if (args->verbose)
 429                                         fprintf(stderr, "giving up\n");
 430                                 break; /* give up */
 431                         }
 432                 }
 433         }
 434 done:
 435         if (!got_ready || !no_done) {
 436                 packet_buf_write(&req_buf, "done\n");
 437                 send_request(args, fd[1], &req_buf);
 438         }
 439         if (args->verbose)
 440                 fprintf(stderr, "done\n");
 441         if (retval != 0) {
 442                 multi_ack = 0;
 443                 flushes++;
 444         }
 445         strbuf_release(&req_buf);
 446
 447         if (!got_ready || !no_done)
 448                 consume_shallow_list(args, fd[0]);
 449         while (flushes || multi_ack) {
 450                 int ack = get_ack(fd[0], result_sha1);
 451                 if (ack) {
 452                         if (args->verbose)
 453                                 fprintf(stderr, "got ack (%d) %s\n", ack,
 454                                         sha1_to_hex(result_sha1));
 455                         if (ack == ACK)
 456                                 return 0;
 457                         multi_ack = 1;
 458                         continue;
 459                 }
 460                 flushes--;
 461         }
 462         /* it is no error to fetch into a completely empty repo */
 463         return count ? retval : 0;
 464 }
 465
 466 static struct commit_list *complete;
 467
 468 static int mark_complete(const char *refname, const unsigned char *sha1, int flag, void *cb_data)
 469 {
 470         struct object *o = parse_object(sha1);
 471
 472         while (o && o->type == OBJ_TAG) {
 473                 struct tag *t = (struct tag *) o;
 474                 if (!t->tagged)
 475                         break; /* broken repository */
 476                 o->flags |= COMPLETE;
 477                 o = parse_object(t->tagged->sha1);
 478         }
 479         if (o && o->type == OBJ_COMMIT) {
 480                 struct commit *commit = (struct commit *)o;
 481                 if (!(commit->object.flags & COMPLETE)) {
 482                         commit->object.flags |= COMPLETE;
 483                         commit_list_insert(commit, &complete);
 484                 }
 485         }
 486         return 0;
 487 }
 488
 489 static void mark_recent_complete_commits(struct fetch_pack_args *args,
 490                                          unsigned long cutoff)
 491 {
 492         while (complete && cutoff <= complete->item->date) {
 493                 if (args->verbose)
 494                         fprintf(stderr, "Marking %s as complete\n",
 495                                 sha1_to_hex(complete->item->object.sha1));
 496                 pop_most_recent_commit(&complete, COMPLETE);
 497         }
 498 }
 499
 500 static void filter_refs(struct fetch_pack_args *args,
 501                         struct ref **refs,
 502                         struct ref **sought, int nr_sought)
 503 {
 504         struct ref *newlist = NULL;
 505         struct ref **newtail = &newlist;
 506         struct ref *ref, *next;
 507         int i;
 508
 509         i = 0;
 510         for (ref = *refs; ref; ref = next) {
 511                 int keep = 0;
 512                 next = ref->next;
 513
 514                 if (starts_with(ref->name, "refs/") &&
 515                     check_refname_format(ref->name, 0))
 516                         ; /* trash */
 517                 else {
 518                         while (i < nr_sought) {
 519                                 int cmp = strcmp(ref->name, sought[i]->name);
 520                                 if (cmp < 0)
 521                                         break; /* definitely do not have it */
 522                                 else if (cmp == 0) {
 523                                         keep = 1; /* definitely have it */
 524                                         sought[i]->matched = 1;
 525                                 }
 526                                 i++;
 527                         }
 528                 }
 529
 530                 if (!keep && args->fetch_all &&
 531                     (!args->depth || !starts_with(ref->name, "refs/tags/")))
 532                         keep = 1;
 533
 534                 if (keep) {
 535                         *newtail = ref;
 536                         ref->next = NULL;
 537                         newtail = &ref->next;
 538                 } else {
 539                         free(ref);
 540                 }
 541         }
 542
 543         /* Append unmatched requests to the list */
 544         if (allow_tip_sha1_in_want) {
 545                 for (i = 0; i < nr_sought; i++) {
 546                         ref = sought[i];
 547                         if (ref->matched)
 548                                 continue;
 549                         if (get_sha1_hex(ref->name, ref->old_sha1))
 550                                 continue;
 551
 552                         ref->matched = 1;
 553                         *newtail = ref;
 554                         ref->next = NULL;
 555                         newtail = &ref->next;
 556                 }
 557         }
 558         *refs = newlist;
 559 }
 560
 561 static void mark_alternate_complete(const struct ref *ref, void *unused)
 562 {
 563         mark_complete(NULL, ref->old_sha1, 0, NULL);
 564 }
 565
 566 static int everything_local(struct fetch_pack_args *args,
 567                             struct ref **refs,
 568                             struct ref **sought, int nr_sought)
 569 {
 570         struct ref *ref;
 571         int retval;
 572         unsigned long cutoff = 0;
 573
 574         save_commit_buffer = 0;
 575
 576         for (ref = *refs; ref; ref = ref->next) {
 577                 struct object *o;
 578
 579                 if (!has_sha1_file(ref->old_sha1))
 580                         continue;
 581
 582                 o = parse_object(ref->old_sha1);
 583                 if (!o)
 584                         continue;
 585
 586                 /* We already have it -- which may mean that we were
 587                  * in sync with the other side at some time after
 588                  * that (it is OK if we guess wrong here).
 589                  */
 590                 if (o->type == OBJ_COMMIT) {
 591                         struct commit *commit = (struct commit *)o;
 592                         if (!cutoff || cutoff < commit->date)
 593                                 cutoff = commit->date;
 594                 }
 595         }
 596
 597         if (!args->depth) {
 598                 for_each_ref(mark_complete, NULL);
 599                 for_each_alternate_ref(mark_alternate_complete, NULL);
 600                 commit_list_sort_by_date(&complete);
 601                 if (cutoff)
 602                         mark_recent_complete_commits(args, cutoff);
 603         }
 604
 605         /*
 606          * Mark all complete remote refs as common refs.
 607          * Don't mark them common yet; the server has to be told so first.
 608          */
 609         for (ref = *refs; ref; ref = ref->next) {
 610                 struct object *o = deref_tag(lookup_object(ref->old_sha1),
 611                                              NULL, 0);
 612
 613                 if (!o || o->type != OBJ_COMMIT || !(o->flags & COMPLETE))
 614                         continue;
 615
 616                 if (!(o->flags & SEEN)) {
 617                         rev_list_push((struct commit *)o, COMMON_REF | SEEN);
 618
 619                         mark_common((struct commit *)o, 1, 1);
 620                 }
 621         }
 622
 623         filter_refs(args, refs, sought, nr_sought);
 624
 625         for (retval = 1, ref = *refs; ref ; ref = ref->next) {
 626                 const unsigned char *remote = ref->old_sha1;
 627                 unsigned char local[20];
 628                 struct object *o;
 629
 630                 o = lookup_object(remote);
 631                 if (!o || !(o->flags & COMPLETE)) {
 632                         retval = 0;
 633                         if (!args->verbose)
 634                                 continue;
 635                         fprintf(stderr,
 636                                 "want %s (%s)\n", sha1_to_hex(remote),
 637                                 ref->name);
 638                         continue;
 639                 }
 640
 641                 hashcpy(ref->new_sha1, local);
 642                 if (!args->verbose)
 643                         continue;
 644                 fprintf(stderr,
 645                         "already have %s (%s)\n", sha1_to_hex(remote),
 646                         ref->name);
 647         }
 648         return retval;
 649 }
 650
 651 static int sideband_demux(int in, int out, void *data)
 652 {
 653         int *xd = data;
 654
 655         int ret = recv_sideband("fetch-pack", xd[0], out);
 656         close(out);
 657         return ret;
 658 }
 659
 660 static int get_pack(struct fetch_pack_args *args,
 661                     int xd[2], char **pack_lockfile)
 662 {
 663         struct async demux;
 664         const char *argv[22];
 665         char keep_arg[256];
 666         char hdr_arg[256];
 667         const char **av, *cmd_name;
 668         int do_keep = args->keep_pack;
 669         struct child_process cmd = CHILD_PROCESS_INIT;
 670         int ret;
 671
 672         memset(&demux, 0, sizeof(demux));
 673         if (use_sideband) {
 674                 /* xd[] is talking with upload-pack; subprocess reads from
 675                  * xd[0], spits out band#2 to stderr, and feeds us band#1
 676                  * through demux->out.
 677                  */
 678                 demux.proc = sideband_demux;
 679                 demux.data = xd;
 680                 demux.out = -1;
 681                 if (start_async(&demux))
 682                         die("fetch-pack: unable to fork off sideband"
 683                             " demultiplexer");
 684         }
 685         else
 686                 demux.out = xd[0];
 687
 688         cmd.argv = argv;
 689         av = argv;
 690         *hdr_arg = 0;
 691         if (!args->keep_pack && unpack_limit) {
 692                 struct pack_header header;
 693
 694                 if (read_pack_header(demux.out, &header))
 695                         die("protocol error: bad pack header");
 696                 snprintf(hdr_arg, sizeof(hdr_arg),
 697                          "--pack_header=%"PRIu32",%"PRIu32,
 698                          ntohl(header.hdr_version), ntohl(header.hdr_entries));
 699                 if (ntohl(header.hdr_entries) < unpack_limit)
 700                         do_keep = 0;
 701                 else
 702                         do_keep = 1;
 703         }
 704
 705         if (alternate_shallow_file) {
 706                 *av++ = "--shallow-file";
 707                 *av++ = alternate_shallow_file;
 708         }
 709
 710         if (do_keep) {
 711                 if (pack_lockfile)
 712                         cmd.out = -1;
 713                 *av++ = cmd_name = "index-pack";
 714                 *av++ = "--stdin";
 715                 if (!args->quiet && !args->no_progress)
 716                         *av++ = "-v";
 717                 if (args->use_thin_pack)
 718                         *av++ = "--fix-thin";
 719                 if (args->lock_pack || unpack_limit) {
 720                         int s = sprintf(keep_arg,
 721                                         "--keep=fetch-pack %"PRIuMAX " on ", (uintmax_t) getpid());
 722                         if (gethostname(keep_arg + s, sizeof(keep_arg) - s))
 723                                 strcpy(keep_arg + s, "localhost");
 724                         *av++ = keep_arg;
 725                 }
 726                 if (args->check_self_contained_and_connected)
 727                         *av++ = "--check-self-contained-and-connected";
 728         }
 729         else {
 730                 *av++ = cmd_name = "unpack-objects";
 731                 if (args->quiet || args->no_progress)
 732                         *av++ = "-q";
 733                 args->check_self_contained_and_connected = 0;
 734         }
 735         if (*hdr_arg)
 736                 *av++ = hdr_arg;
 737         if (fetch_fsck_objects >= 0
 738             ? fetch_fsck_objects
 739             : transfer_fsck_objects >= 0
 740             ? transfer_fsck_objects
 741             : 0)
 742                 *av++ = "--strict";
 743         *av++ = NULL;
 744
 745         cmd.in = demux.out;
 746         cmd.git_cmd = 1;
 747         if (start_command(&cmd))
 748                 die("fetch-pack: unable to fork off %s", cmd_name);
 749         if (do_keep && pack_lockfile) {
 750                 *pack_lockfile = index_pack_lockfile(cmd.out);
 751                 close(cmd.out);
 752         }
 753
 754         if (!use_sideband)
 755                 /* Closed by start_command() */
 756                 xd[0] = -1;
 757
 758         ret = finish_command(&cmd);
 759         if (!ret || (args->check_self_contained_and_connected && ret == 1))
 760                 args->self_contained_and_connected =
 761                         args->check_self_contained_and_connected &&
 762                         ret == 0;
 763         else
 764                 die("%s failed", cmd_name);
 765         if (use_sideband && finish_async(&demux))
 766                 die("error in sideband demultiplexer");
 767         return 0;
 768 }
 769
 770 static int cmp_ref_by_name(const void *a_, const void *b_)
 771 {
 772         const struct ref *a = *((const struct ref **)a_);
 773         const struct ref *b = *((const struct ref **)b_);
 774         return strcmp(a->name, b->name);
 775 }
 776
 777 static struct ref *do_fetch_pack(struct fetch_pack_args *args,
 778                                  int fd[2],
 779                                  const struct ref *orig_ref,
 780                                  struct ref **sought, int nr_sought,
 781                                  struct shallow_info *si,
 782                                  char **pack_lockfile)
 783 {
 784         struct ref *ref = copy_ref_list(orig_ref);
 785         unsigned char sha1[20];
 786         const char *agent_feature;
 787         int agent_len;
 788
 789         sort_ref_list(&ref, ref_compare_name);
 790         qsort(sought, nr_sought, sizeof(*sought), cmp_ref_by_name);
 791
 792         if (is_repository_shallow() && !server_supports("shallow"))
 793                 die("Server does not support shallow clients");
 794         if (server_supports("multi_ack_detailed")) {
 795                 if (args->verbose)
 796                         fprintf(stderr, "Server supports multi_ack_detailed\n");
 797                 multi_ack = 2;
 798                 if (server_supports("no-done")) {
 799                         if (args->verbose)
 800                                 fprintf(stderr, "Server supports no-done\n");
 801                         if (args->stateless_rpc)
 802                                 no_done = 1;
 803                 }
 804         }
 805         else if (server_supports("multi_ack")) {
 806                 if (args->verbose)
 807                         fprintf(stderr, "Server supports multi_ack\n");
 808                 multi_ack = 1;
 809         }
 810         if (server_supports("side-band-64k")) {
 811                 if (args->verbose)
 812                         fprintf(stderr, "Server supports side-band-64k\n");
 813                 use_sideband = 2;
 814         }
 815         else if (server_supports("side-band")) {
 816                 if (args->verbose)
 817                         fprintf(stderr, "Server supports side-band\n");
 818                 use_sideband = 1;
 819         }
 820         if (server_supports("allow-tip-sha1-in-want")) {
 821                 if (args->verbose)
 822                         fprintf(stderr, "Server supports allow-tip-sha1-in-want\n");
 823                 allow_tip_sha1_in_want = 1;
 824         }
 825         if (!server_supports("thin-pack"))
 826                 args->use_thin_pack = 0;
 827         if (!server_supports("no-progress"))
 828                 args->no_progress = 0;
 829         if (!server_supports("include-tag"))
 830                 args->include_tag = 0;
 831         if (server_supports("ofs-delta")) {
 832                 if (args->verbose)
 833                         fprintf(stderr, "Server supports ofs-delta\n");
 834         } else
 835                 prefer_ofs_delta = 0;
 836
 837         if ((agent_feature = server_feature_value("agent", &agent_len))) {
 838                 agent_supported = 1;
 839                 if (args->verbose && agent_len)
 840                         fprintf(stderr, "Server version is %.*s\n",
 841                                 agent_len, agent_feature);
 842         }
 843
 844         if (everything_local(args, &ref, sought, nr_sought)) {
 845                 packet_flush(fd[1]);
 846                 goto all_done;
 847         }
 848         if (find_common(args, fd, sha1, ref) < 0)
 849                 if (!args->keep_pack)
 850                         /* When cloning, it is not unusual to have
 851                          * no common commit.
 852                          */
 853                         warning("no common commits");
 854
 855         if (args->stateless_rpc)
 856                 packet_flush(fd[1]);
 857         if (args->depth > 0)
 858                 setup_alternate_shallow(&shallow_lock, &alternate_shallow_file,
 859                                         NULL);
 860         else if (si->nr_ours || si->nr_theirs)
 861                 alternate_shallow_file = setup_temporary_shallow(si->shallow);
 862         else
 863                 alternate_shallow_file = NULL;
 864         if (get_pack(args, fd, pack_lockfile))
 865                 die("git fetch-pack: fetch failed.");
 866
 867  all_done:
 868         return ref;
 869 }
 870
 871 static void fetch_pack_config(void)
 872 {
 873         git_config_get_int("fetch.unpacklimit", &fetch_unpack_limit);
 874         git_config_get_int("transfer.unpacklimit", &transfer_unpack_limit);
 875         git_config_get_bool("repack.usedeltabaseoffset", &prefer_ofs_delta);
 876         git_config_get_bool("fetch.fsckobjects", &fetch_fsck_objects);
 877         git_config_get_bool("transfer.fsckobjects", &transfer_fsck_objects);
 878
 879         git_config(git_default_config, NULL);
 880 }
 881
 882 static void fetch_pack_setup(void)
 883 {
 884         static int did_setup;
 885         if (did_setup)
 886                 return;
 887         fetch_pack_config();
 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 static int remove_duplicates_in_refs(struct ref **ref, int nr)
 896 {
 897         struct string_list names = STRING_LIST_INIT_NODUP;
 898         int src, dst;
 899
 900         for (src = dst = 0; src < nr; src++) {
 901                 struct string_list_item *item;
 902                 item = string_list_insert(&names, ref[src]->name);
 903                 if (item->util)
 904                         continue; /* already have it */
 905                 item->util = ref[src];
 906                 if (src != dst)
 907                         ref[dst] = ref[src];
 908                 dst++;
 909         }
 910         for (src = dst; src < nr; src++)
 911                 ref[src] = NULL;
 912         string_list_clear(&names, 0);
 913         return dst;
 914 }
 915
 916 static void update_shallow(struct fetch_pack_args *args,
 917                            struct ref **sought, int nr_sought,
 918                            struct shallow_info *si)
 919 {
 920         struct sha1_array ref = SHA1_ARRAY_INIT;
 921         int *status;
 922         int i;
 923
 924         if (args->depth > 0 && alternate_shallow_file) {
 925                 if (*alternate_shallow_file == '\0') { /* --unshallow */
 926                         unlink_or_warn(git_path("shallow"));
 927                         rollback_lock_file(&shallow_lock);
 928                 } else
 929                         commit_lock_file(&shallow_lock);
 930                 return;
 931         }
 932
 933         if (!si->shallow || !si->shallow->nr)
 934                 return;
 935
 936         if (args->cloning) {
 937                 /*
 938                  * remote is shallow, but this is a clone, there are
 939                  * no objects in repo to worry about. Accept any
 940                  * shallow points that exist in the pack (iow in repo
 941                  * after get_pack() and reprepare_packed_git())
 942                  */
 943                 struct sha1_array extra = SHA1_ARRAY_INIT;
 944                 unsigned char (*sha1)[20] = si->shallow->sha1;
 945                 for (i = 0; i < si->shallow->nr; i++)
 946                         if (has_sha1_file(sha1[i]))
 947                                 sha1_array_append(&extra, sha1[i]);
 948                 if (extra.nr) {
 949                         setup_alternate_shallow(&shallow_lock,
 950                                                 &alternate_shallow_file,
 951                                                 &extra);
 952                         commit_lock_file(&shallow_lock);
 953                 }
 954                 sha1_array_clear(&extra);
 955                 return;
 956         }
 957
 958         if (!si->nr_ours && !si->nr_theirs)
 959                 return;
 960
 961         remove_nonexistent_theirs_shallow(si);
 962         if (!si->nr_ours && !si->nr_theirs)
 963                 return;
 964         for (i = 0; i < nr_sought; i++)
 965                 sha1_array_append(&ref, sought[i]->old_sha1);
 966         si->ref = &ref;
 967
 968         if (args->update_shallow) {
 969                 /*
 970                  * remote is also shallow, .git/shallow may be updated
 971                  * so all refs can be accepted. Make sure we only add
 972                  * shallow roots that are actually reachable from new
 973                  * refs.
 974                  */
 975                 struct sha1_array extra = SHA1_ARRAY_INIT;
 976                 unsigned char (*sha1)[20] = si->shallow->sha1;
 977                 assign_shallow_commits_to_refs(si, NULL, NULL);
 978                 if (!si->nr_ours && !si->nr_theirs) {
 979                         sha1_array_clear(&ref);
 980                         return;
 981                 }
 982                 for (i = 0; i < si->nr_ours; i++)
 983                         sha1_array_append(&extra, sha1[si->ours[i]]);
 984                 for (i = 0; i < si->nr_theirs; i++)
 985                         sha1_array_append(&extra, sha1[si->theirs[i]]);
 986                 setup_alternate_shallow(&shallow_lock,
 987                                         &alternate_shallow_file,
 988                                         &extra);
 989                 commit_lock_file(&shallow_lock);
 990                 sha1_array_clear(&extra);
 991                 sha1_array_clear(&ref);
 992                 return;
 993         }
 994
 995         /*
 996          * remote is also shallow, check what ref is safe to update
 997          * without updating .git/shallow
 998          */
 999         status = xcalloc(nr_sought, sizeof(*status));
1000         assign_shallow_commits_to_refs(si, NULL, status);
1001         if (si->nr_ours || si->nr_theirs) {
1002                 for (i = 0; i < nr_sought; i++)
1003                         if (status[i])
1004                                 sought[i]->status = REF_STATUS_REJECT_SHALLOW;
1005         }
1006         free(status);
1007         sha1_array_clear(&ref);
1008 }
1009
1010 struct ref *fetch_pack(struct fetch_pack_args *args,
1011                        int fd[], struct child_process *conn,
1012                        const struct ref *ref,
1013                        const char *dest,
1014                        struct ref **sought, int nr_sought,
1015                        struct sha1_array *shallow,
1016                        char **pack_lockfile)
1017 {
1018         struct ref *ref_cpy;
1019         struct shallow_info si;
1020
1021         fetch_pack_setup();
1022         if (nr_sought)
1023                 nr_sought = remove_duplicates_in_refs(sought, nr_sought);
1024
1025         if (!ref) {
1026                 packet_flush(fd[1]);
1027                 die("no matching remote head");
1028         }
1029         prepare_shallow_info(&si, shallow);
1030         ref_cpy = do_fetch_pack(args, fd, ref, sought, nr_sought,
1031                                 &si, pack_lockfile);
1032         reprepare_packed_git();
1033         update_shallow(args, sought, nr_sought, &si);
1034         clear_shallow_info(&si);
1035         return ref_cpy;
1036 }