builtin/fetch-pack.c

   1 #include "builtin.h"
   2 #include "refs.h"
   3 #include "pkt-line.h"
   4 #include "commit.h"
   5 #include "tag.h"
   6 #include "exec_cmd.h"
   7 #include "pack.h"
   8 #include "sideband.h"
   9 #include "fetch-pack.h"
  10 #include "remote.h"
  11 #include "run-command.h"
  12 #include "transport.h"
  13
  14 static int transfer_unpack_limit = -1;
  15 static int fetch_unpack_limit = -1;
  16 static int unpack_limit = 100;
  17 static int prefer_ofs_delta = 1;
  18 static int no_done;
  19 static int fetch_fsck_objects = -1;
  20 static int transfer_fsck_objects = -1;
  21 static struct fetch_pack_args args = {
  22         /* .uploadpack = */ "git-upload-pack",
  23 };
  24
  25 static const char fetch_pack_usage[] =
  26 "git fetch-pack [--all] [--quiet|-q] [--keep|-k] [--thin] [--include-tag] [--upload-pack=<git-upload-pack>] [--depth=<n>] [--no-progress] [-v] [<host>:]<directory> [<refs>...]";
  27
  28 #define COMPLETE        (1U << 0)
  29 #define COMMON          (1U << 1)
  30 #define COMMON_REF      (1U << 2)
  31 #define SEEN            (1U << 3)
  32 #define POPPED          (1U << 4)
  33
  34 static int marked;
  35
  36 /*
  37  * After sending this many "have"s if we do not get any new ACK , we
  38  * give up traversing our history.
  39  */
  40 #define MAX_IN_VAIN 256
  41
  42 static struct commit_list *rev_list;
  43 static int non_common_revs, multi_ack, use_sideband;
  44
  45 static void rev_list_push(struct commit *commit, int mark)
  46 {
  47         if (!(commit->object.flags & mark)) {
  48                 commit->object.flags |= mark;
  49
  50                 if (!(commit->object.parsed))
  51                         if (parse_commit(commit))
  52                                 return;
  53
  54                 commit_list_insert_by_date(commit, &rev_list);
  55
  56                 if (!(commit->object.flags & COMMON))
  57                         non_common_revs++;
  58         }
  59 }
  60
  61 static int rev_list_insert_ref(const char *refname, const unsigned char *sha1, int flag, void *cb_data)
  62 {
  63         struct object *o = deref_tag(parse_object(sha1), refname, 0);
  64
  65         if (o && o->type == OBJ_COMMIT)
  66                 rev_list_push((struct commit *)o, SEEN);
  67
  68         return 0;
  69 }
  70
  71 static int clear_marks(const char *refname, const unsigned char *sha1, int flag, void *cb_data)
  72 {
  73         struct object *o = deref_tag(parse_object(sha1), refname, 0);
  74
  75         if (o && o->type == OBJ_COMMIT)
  76                 clear_commit_marks((struct commit *)o,
  77                                    COMMON | COMMON_REF | SEEN | POPPED);
  78         return 0;
  79 }
  80
  81 /*
  82    This function marks a rev and its ancestors as common.
  83    In some cases, it is desirable to mark only the ancestors (for example
  84    when only the server does not yet know that they are common).
  85 */
  86
  87 static void mark_common(struct commit *commit,
  88                 int ancestors_only, int dont_parse)
  89 {
  90         if (commit != NULL && !(commit->object.flags & COMMON)) {
  91                 struct object *o = (struct object *)commit;
  92
  93                 if (!ancestors_only)
  94                         o->flags |= COMMON;
  95
  96                 if (!(o->flags & SEEN))
  97                         rev_list_push(commit, SEEN);
  98                 else {
  99                         struct commit_list *parents;
 100
 101                         if (!ancestors_only && !(o->flags & POPPED))
 102                                 non_common_revs--;
 103                         if (!o->parsed && !dont_parse)
 104                                 if (parse_commit(commit))
 105                                         return;
 106
 107                         for (parents = commit->parents;
 108                                         parents;
 109                                         parents = parents->next)
 110                                 mark_common(parents->item, 0, dont_parse);
 111                 }
 112         }
 113 }
 114
 115 /*
 116   Get the next rev to send, ignoring the common.
 117 */
 118
 119 static const unsigned char *get_rev(void)
 120 {
 121         struct commit *commit = NULL;
 122
 123         while (commit == NULL) {
 124                 unsigned int mark;
 125                 struct commit_list *parents;
 126
 127                 if (rev_list == NULL || non_common_revs == 0)
 128                         return NULL;
 129
 130                 commit = rev_list->item;
 131                 if (!commit->object.parsed)
 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                 rev_list = rev_list->next;
 159         }
 160
 161         return commit->object.sha1;
 162 }
 163
 164 enum ack_type {
 165         NAK = 0,
 166         ACK,
 167         ACK_continue,
 168         ACK_common,
 169         ACK_ready
 170 };
 171
 172 static void consume_shallow_list(int fd)
 173 {
 174         if (args.stateless_rpc && args.depth > 0) {
 175                 /* If we sent a depth we will get back "duplicate"
 176                  * shallow and unshallow commands every time there
 177                  * is a block of have lines exchanged.
 178                  */
 179                 char line[1000];
 180                 while (packet_read_line(fd, line, sizeof(line))) {
 181                         if (!prefixcmp(line, "shallow "))
 182                                 continue;
 183                         if (!prefixcmp(line, "unshallow "))
 184                                 continue;
 185                         die("git fetch-pack: expected shallow list");
 186                 }
 187         }
 188 }
 189
 190 struct write_shallow_data {
 191         struct strbuf *out;
 192         int use_pack_protocol;
 193         int count;
 194 };
 195
 196 static int write_one_shallow(const struct commit_graft *graft, void *cb_data)
 197 {
 198         struct write_shallow_data *data = cb_data;
 199         const char *hex = sha1_to_hex(graft->sha1);
 200         data->count++;
 201         if (data->use_pack_protocol)
 202                 packet_buf_write(data->out, "shallow %s", hex);
 203         else {
 204                 strbuf_addstr(data->out, hex);
 205                 strbuf_addch(data->out, '\n');
 206         }
 207         return 0;
 208 }
 209
 210 static int write_shallow_commits(struct strbuf *out, int use_pack_protocol)
 211 {
 212         struct write_shallow_data data;
 213         data.out = out;
 214         data.use_pack_protocol = use_pack_protocol;
 215         data.count = 0;
 216         for_each_commit_graft(write_one_shallow, &data);
 217         return data.count;
 218 }
 219
 220 static enum ack_type get_ack(int fd, unsigned char *result_sha1)
 221 {
 222         static char line[1000];
 223         int len = packet_read_line(fd, line, sizeof(line));
 224
 225         if (!len)
 226                 die("git fetch-pack: expected ACK/NAK, got EOF");
 227         if (line[len-1] == '\n')
 228                 line[--len] = 0;
 229         if (!strcmp(line, "NAK"))
 230                 return NAK;
 231         if (!prefixcmp(line, "ACK ")) {
 232                 if (!get_sha1_hex(line+4, result_sha1)) {
 233                         if (strstr(line+45, "continue"))
 234                                 return ACK_continue;
 235                         if (strstr(line+45, "common"))
 236                                 return ACK_common;
 237                         if (strstr(line+45, "ready"))
 238                                 return ACK_ready;
 239                         return ACK;
 240                 }
 241         }
 242         die("git fetch_pack: expected ACK/NAK, got '%s'", line);
 243 }
 244
 245 static void send_request(int fd, struct strbuf *buf)
 246 {
 247         if (args.stateless_rpc) {
 248                 send_sideband(fd, -1, buf->buf, buf->len, LARGE_PACKET_MAX);
 249                 packet_flush(fd);
 250         } else
 251                 safe_write(fd, buf->buf, buf->len);
 252 }
 253
 254 static void insert_one_alternate_ref(const struct ref *ref, void *unused)
 255 {
 256         rev_list_insert_ref(NULL, ref->old_sha1, 0, NULL);
 257 }
 258
 259 #define INITIAL_FLUSH 16
 260 #define PIPESAFE_FLUSH 32
 261 #define LARGE_FLUSH 1024
 262
 263 static int next_flush(int count)
 264 {
 265         int flush_limit = args.stateless_rpc ? LARGE_FLUSH : PIPESAFE_FLUSH;
 266
 267         if (count < flush_limit)
 268                 count <<= 1;
 269         else
 270                 count += flush_limit;
 271         return count;
 272 }
 273
 274 static int find_common(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                         packet_buf_write(&req_buf, "want %s%s\n", remote_hex, c.buf);
 329                         strbuf_release(&c);
 330                 } else
 331                         packet_buf_write(&req_buf, "want %s\n", remote_hex);
 332                 fetching++;
 333         }
 334
 335         if (!fetching) {
 336                 strbuf_release(&req_buf);
 337                 packet_flush(fd[1]);
 338                 return 1;
 339         }
 340
 341         if (is_repository_shallow())
 342                 write_shallow_commits(&req_buf, 1);
 343         if (args.depth > 0)
 344                 packet_buf_write(&req_buf, "deepen %d", args.depth);
 345         packet_buf_flush(&req_buf);
 346         state_len = req_buf.len;
 347
 348         if (args.depth > 0) {
 349                 char line[1024];
 350                 unsigned char sha1[20];
 351
 352                 send_request(fd[1], &req_buf);
 353                 while (packet_read_line(fd[0], line, sizeof(line))) {
 354                         if (!prefixcmp(line, "shallow ")) {
 355                                 if (get_sha1_hex(line + 8, sha1))
 356                                         die("invalid shallow line: %s", line);
 357                                 register_shallow(sha1);
 358                                 continue;
 359                         }
 360                         if (!prefixcmp(line, "unshallow ")) {
 361                                 if (get_sha1_hex(line + 10, sha1))
 362                                         die("invalid unshallow line: %s", line);
 363                                 if (!lookup_object(sha1))
 364                                         die("object not found: %s", line);
 365                                 /* make sure that it is parsed as shallow */
 366                                 if (!parse_object(sha1))
 367                                         die("error in object: %s", line);
 368                                 if (unregister_shallow(sha1))
 369                                         die("no shallow found: %s", line);
 370                                 continue;
 371                         }
 372                         die("expected shallow/unshallow, got %s", line);
 373                 }
 374         } else if (!args.stateless_rpc)
 375                 send_request(fd[1], &req_buf);
 376
 377         if (!args.stateless_rpc) {
 378                 /* If we aren't using the stateless-rpc interface
 379                  * we don't need to retain the headers.
 380                  */
 381                 strbuf_setlen(&req_buf, 0);
 382                 state_len = 0;
 383         }
 384
 385         flushes = 0;
 386         retval = -1;
 387         while ((sha1 = get_rev())) {
 388                 packet_buf_write(&req_buf, "have %s\n", sha1_to_hex(sha1));
 389                 if (args.verbose)
 390                         fprintf(stderr, "have %s\n", sha1_to_hex(sha1));
 391                 in_vain++;
 392                 if (flush_at <= ++count) {
 393                         int ack;
 394
 395                         packet_buf_flush(&req_buf);
 396                         send_request(fd[1], &req_buf);
 397                         strbuf_setlen(&req_buf, state_len);
 398                         flushes++;
 399                         flush_at = next_flush(count);
 400
 401                         /*
 402                          * We keep one window "ahead" of the other side, and
 403                          * will wait for an ACK only on the next one
 404                          */
 405                         if (!args.stateless_rpc && count == INITIAL_FLUSH)
 406                                 continue;
 407
 408                         consume_shallow_list(fd[0]);
 409                         do {
 410                                 ack = get_ack(fd[0], result_sha1);
 411                                 if (args.verbose && ack)
 412                                         fprintf(stderr, "got ack %d %s\n", ack,
 413                                                         sha1_to_hex(result_sha1));
 414                                 switch (ack) {
 415                                 case ACK:
 416                                         flushes = 0;
 417                                         multi_ack = 0;
 418                                         retval = 0;
 419                                         goto done;
 420                                 case ACK_common:
 421                                 case ACK_ready:
 422                                 case ACK_continue: {
 423                                         struct commit *commit =
 424                                                 lookup_commit(result_sha1);
 425                                         if (!commit)
 426                                                 die("invalid commit %s", sha1_to_hex(result_sha1));
 427                                         if (args.stateless_rpc
 428                                          && ack == ACK_common
 429                                          && !(commit->object.flags & COMMON)) {
 430                                                 /* We need to replay the have for this object
 431                                                  * on the next RPC request so the peer knows
 432                                                  * it is in common with us.
 433                                                  */
 434                                                 const char *hex = sha1_to_hex(result_sha1);
 435                                                 packet_buf_write(&req_buf, "have %s\n", hex);
 436                                                 state_len = req_buf.len;
 437                                         }
 438                                         mark_common(commit, 0, 1);
 439                                         retval = 0;
 440                                         in_vain = 0;
 441                                         got_continue = 1;
 442                                         if (ack == ACK_ready) {
 443                                                 rev_list = NULL;
 444                                                 got_ready = 1;
 445                                         }
 446                                         break;
 447                                         }
 448                                 }
 449                         } while (ack);
 450                         flushes--;
 451                         if (got_continue && MAX_IN_VAIN < in_vain) {
 452                                 if (args.verbose)
 453                                         fprintf(stderr, "giving up\n");
 454                                 break; /* give up */
 455                         }
 456                 }
 457         }
 458 done:
 459         if (!got_ready || !no_done) {
 460                 packet_buf_write(&req_buf, "done\n");
 461                 send_request(fd[1], &req_buf);
 462         }
 463         if (args.verbose)
 464                 fprintf(stderr, "done\n");
 465         if (retval != 0) {
 466                 multi_ack = 0;
 467                 flushes++;
 468         }
 469         strbuf_release(&req_buf);
 470
 471         consume_shallow_list(fd[0]);
 472         while (flushes || multi_ack) {
 473                 int ack = get_ack(fd[0], result_sha1);
 474                 if (ack) {
 475                         if (args.verbose)
 476                                 fprintf(stderr, "got ack (%d) %s\n", ack,
 477                                         sha1_to_hex(result_sha1));
 478                         if (ack == ACK)
 479                                 return 0;
 480                         multi_ack = 1;
 481                         continue;
 482                 }
 483                 flushes--;
 484         }
 485         /* it is no error to fetch into a completely empty repo */
 486         return count ? retval : 0;
 487 }
 488
 489 static struct commit_list *complete;
 490
 491 static int mark_complete(const char *refname, const unsigned char *sha1, int flag, void *cb_data)
 492 {
 493         struct object *o = parse_object(sha1);
 494
 495         while (o && o->type == OBJ_TAG) {
 496                 struct tag *t = (struct tag *) o;
 497                 if (!t->tagged)
 498                         break; /* broken repository */
 499                 o->flags |= COMPLETE;
 500                 o = parse_object(t->tagged->sha1);
 501         }
 502         if (o && o->type == OBJ_COMMIT) {
 503                 struct commit *commit = (struct commit *)o;
 504                 if (!(commit->object.flags & COMPLETE)) {
 505                         commit->object.flags |= COMPLETE;
 506                         commit_list_insert_by_date(commit, &complete);
 507                 }
 508         }
 509         return 0;
 510 }
 511
 512 static void mark_recent_complete_commits(unsigned long cutoff)
 513 {
 514         while (complete && cutoff <= complete->item->date) {
 515                 if (args.verbose)
 516                         fprintf(stderr, "Marking %s as complete\n",
 517                                 sha1_to_hex(complete->item->object.sha1));
 518                 pop_most_recent_commit(&complete, COMPLETE);
 519         }
 520 }
 521
 522 static void filter_refs(struct ref **refs, int nr_match, char **match)
 523 {
 524         struct ref **return_refs;
 525         struct ref *newlist = NULL;
 526         struct ref **newtail = &newlist;
 527         struct ref *ref, *next;
 528         struct ref *fastarray[32];
 529
 530         if (nr_match && !args.fetch_all) {
 531                 if (ARRAY_SIZE(fastarray) < nr_match)
 532                         return_refs = xcalloc(nr_match, sizeof(struct ref *));
 533                 else {
 534                         return_refs = fastarray;
 535                         memset(return_refs, 0, sizeof(struct ref *) * nr_match);
 536                 }
 537         }
 538         else
 539                 return_refs = NULL;
 540
 541         for (ref = *refs; ref; ref = next) {
 542                 next = ref->next;
 543                 if (!memcmp(ref->name, "refs/", 5) &&
 544                     check_refname_format(ref->name + 5, 0))
 545                         ; /* trash */
 546                 else if (args.fetch_all &&
 547                          (!args.depth || prefixcmp(ref->name, "refs/tags/") )) {
 548                         *newtail = ref;
 549                         ref->next = NULL;
 550                         newtail = &ref->next;
 551                         continue;
 552                 }
 553                 else {
 554                         int i;
 555                         for (i = 0; i < nr_match; i++) {
 556                                 if (!strcmp(ref->name, match[i])) {
 557                                         match[i][0] = '\0';
 558                                         return_refs[i] = ref;
 559                                         break;
 560                                 }
 561                         }
 562                         if (i < nr_match)
 563                                 continue; /* we will link it later */
 564                 }
 565                 free(ref);
 566         }
 567
 568         if (!args.fetch_all) {
 569                 int i;
 570                 for (i = 0; i < nr_match; i++) {
 571                         ref = return_refs[i];
 572                         if (ref) {
 573                                 *newtail = ref;
 574                                 ref->next = NULL;
 575                                 newtail = &ref->next;
 576                         }
 577                 }
 578                 if (return_refs != fastarray)
 579                         free(return_refs);
 580         }
 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, int nr_match, char **match)
 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, nr_match, match);
 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                 int nr_match,
 772                 char **match,
 773                 char **pack_lockfile)
 774 {
 775         struct ref *ref = copy_ref_list(orig_ref);
 776         unsigned char sha1[20];
 777
 778         if (is_repository_shallow() && !server_supports("shallow"))
 779                 die("Server does not support shallow clients");
 780         if (server_supports("multi_ack_detailed")) {
 781                 if (args.verbose)
 782                         fprintf(stderr, "Server supports multi_ack_detailed\n");
 783                 multi_ack = 2;
 784                 if (server_supports("no-done")) {
 785                         if (args.verbose)
 786                                 fprintf(stderr, "Server supports no-done\n");
 787                         if (args.stateless_rpc)
 788                                 no_done = 1;
 789                 }
 790         }
 791         else if (server_supports("multi_ack")) {
 792                 if (args.verbose)
 793                         fprintf(stderr, "Server supports multi_ack\n");
 794                 multi_ack = 1;
 795         }
 796         if (server_supports("side-band-64k")) {
 797                 if (args.verbose)
 798                         fprintf(stderr, "Server supports side-band-64k\n");
 799                 use_sideband = 2;
 800         }
 801         else if (server_supports("side-band")) {
 802                 if (args.verbose)
 803                         fprintf(stderr, "Server supports side-band\n");
 804                 use_sideband = 1;
 805         }
 806         if (server_supports("ofs-delta")) {
 807                 if (args.verbose)
 808                         fprintf(stderr, "Server supports ofs-delta\n");
 809         } else
 810                 prefer_ofs_delta = 0;
 811         if (everything_local(&ref, nr_match, match)) {
 812                 packet_flush(fd[1]);
 813                 goto all_done;
 814         }
 815         if (find_common(fd, sha1, ref) < 0)
 816                 if (!args.keep_pack)
 817                         /* When cloning, it is not unusual to have
 818                          * no common commit.
 819                          */
 820                         warning("no common commits");
 821
 822         if (args.stateless_rpc)
 823                 packet_flush(fd[1]);
 824         if (get_pack(fd, pack_lockfile))
 825                 die("git fetch-pack: fetch failed.");
 826
 827  all_done:
 828         return ref;
 829 }
 830
 831 static int remove_duplicates(int nr_heads, char **heads)
 832 {
 833         int src, dst;
 834
 835         for (src = dst = 0; src < nr_heads; src++) {
 836                 /* If heads[src] is different from any of
 837                  * heads[0..dst], push it in.
 838                  */
 839                 int i;
 840                 for (i = 0; i < dst; i++) {
 841                         if (!strcmp(heads[i], heads[src]))
 842                                 break;
 843                 }
 844                 if (i < dst)
 845                         continue;
 846                 if (src != dst)
 847                         heads[dst] = heads[src];
 848                 dst++;
 849         }
 850         return dst;
 851 }
 852
 853 static int fetch_pack_config(const char *var, const char *value, void *cb)
 854 {
 855         if (strcmp(var, "fetch.unpacklimit") == 0) {
 856                 fetch_unpack_limit = git_config_int(var, value);
 857                 return 0;
 858         }
 859
 860         if (strcmp(var, "transfer.unpacklimit") == 0) {
 861                 transfer_unpack_limit = git_config_int(var, value);
 862                 return 0;
 863         }
 864
 865         if (strcmp(var, "repack.usedeltabaseoffset") == 0) {
 866                 prefer_ofs_delta = git_config_bool(var, value);
 867                 return 0;
 868         }
 869
 870         if (!strcmp(var, "fetch.fsckobjects")) {
 871                 fetch_fsck_objects = git_config_bool(var, value);
 872                 return 0;
 873         }
 874
 875         if (!strcmp(var, "transfer.fsckobjects")) {
 876                 transfer_fsck_objects = git_config_bool(var, value);
 877                 return 0;
 878         }
 879
 880         return git_default_config(var, value, cb);
 881 }
 882
 883 static struct lock_file lock;
 884
 885 static void fetch_pack_setup(void)
 886 {
 887         static int did_setup;
 888         if (did_setup)
 889                 return;
 890         git_config(fetch_pack_config, NULL);
 891         if (0 <= transfer_unpack_limit)
 892                 unpack_limit = transfer_unpack_limit;
 893         else if (0 <= fetch_unpack_limit)
 894                 unpack_limit = fetch_unpack_limit;
 895         did_setup = 1;
 896 }
 897
 898 int cmd_fetch_pack(int argc, const char **argv, const char *prefix)
 899 {
 900         int i, ret, nr_heads;
 901         struct ref *ref = NULL;
 902         char *dest = NULL, **heads;
 903         int fd[2];
 904         char *pack_lockfile = NULL;
 905         char **pack_lockfile_ptr = NULL;
 906         struct child_process *conn;
 907
 908         packet_trace_identity("fetch-pack");
 909
 910         nr_heads = 0;
 911         heads = NULL;
 912         for (i = 1; i < argc; i++) {
 913                 const char *arg = argv[i];
 914
 915                 if (*arg == '-') {
 916                         if (!prefixcmp(arg, "--upload-pack=")) {
 917                                 args.uploadpack = arg + 14;
 918                                 continue;
 919                         }
 920                         if (!prefixcmp(arg, "--exec=")) {
 921                                 args.uploadpack = arg + 7;
 922                                 continue;
 923                         }
 924                         if (!strcmp("--quiet", arg) || !strcmp("-q", arg)) {
 925                                 args.quiet = 1;
 926                                 continue;
 927                         }
 928                         if (!strcmp("--keep", arg) || !strcmp("-k", arg)) {
 929                                 args.lock_pack = args.keep_pack;
 930                                 args.keep_pack = 1;
 931                                 continue;
 932                         }
 933                         if (!strcmp("--thin", arg)) {
 934                                 args.use_thin_pack = 1;
 935                                 continue;
 936                         }
 937                         if (!strcmp("--include-tag", arg)) {
 938                                 args.include_tag = 1;
 939                                 continue;
 940                         }
 941                         if (!strcmp("--all", arg)) {
 942                                 args.fetch_all = 1;
 943                                 continue;
 944                         }
 945                         if (!strcmp("-v", arg)) {
 946                                 args.verbose = 1;
 947                                 continue;
 948                         }
 949                         if (!prefixcmp(arg, "--depth=")) {
 950                                 args.depth = strtol(arg + 8, NULL, 0);
 951                                 continue;
 952                         }
 953                         if (!strcmp("--no-progress", arg)) {
 954                                 args.no_progress = 1;
 955                                 continue;
 956                         }
 957                         if (!strcmp("--stateless-rpc", arg)) {
 958                                 args.stateless_rpc = 1;
 959                                 continue;
 960                         }
 961                         if (!strcmp("--lock-pack", arg)) {
 962                                 args.lock_pack = 1;
 963                                 pack_lockfile_ptr = &pack_lockfile;
 964                                 continue;
 965                         }
 966                         usage(fetch_pack_usage);
 967                 }
 968                 dest = (char *)arg;
 969                 heads = (char **)(argv + i + 1);
 970                 nr_heads = argc - i - 1;
 971                 break;
 972         }
 973         if (!dest)
 974                 usage(fetch_pack_usage);
 975
 976         if (args.stateless_rpc) {
 977                 conn = NULL;
 978                 fd[0] = 0;
 979                 fd[1] = 1;
 980         } else {
 981                 conn = git_connect(fd, (char *)dest, args.uploadpack,
 982                                    args.verbose ? CONNECT_VERBOSE : 0);
 983         }
 984
 985         get_remote_heads(fd[0], &ref, 0, NULL);
 986
 987         ref = fetch_pack(&args, fd, conn, ref, dest,
 988                 nr_heads, heads, pack_lockfile_ptr);
 989         if (pack_lockfile) {
 990                 printf("lock %s\n", pack_lockfile);
 991                 fflush(stdout);
 992         }
 993         close(fd[0]);
 994         close(fd[1]);
 995         if (finish_connect(conn))
 996                 ref = NULL;
 997         ret = !ref;
 998
 999         if (!ret && nr_heads) {
1000                 /* If the heads to pull were given, we should have
1001                  * consumed all of them by matching the remote.
1002                  * Otherwise, 'git fetch remote no-such-ref' would
1003                  * silently succeed without issuing an error.
1004                  */
1005                 for (i = 0; i < nr_heads; i++)
1006                         if (heads[i] && heads[i][0]) {
1007                                 error("no such remote ref %s", heads[i]);
1008                                 ret = 1;
1009                         }
1010         }
1011         while (ref) {
1012                 printf("%s %s\n",
1013                        sha1_to_hex(ref->old_sha1), ref->name);
1014                 ref = ref->next;
1015         }
1016
1017         return ret;
1018 }
1019
1020 struct ref *fetch_pack(struct fetch_pack_args *my_args,
1021                        int fd[], struct child_process *conn,
1022                        const struct ref *ref,
1023                 const char *dest,
1024                 int nr_heads,
1025                 char **heads,
1026                 char **pack_lockfile)
1027 {
1028         struct stat st;
1029         struct ref *ref_cpy;
1030
1031         fetch_pack_setup();
1032         if (&args != my_args)
1033                 memcpy(&args, my_args, sizeof(args));
1034         if (args.depth > 0) {
1035                 if (stat(git_path("shallow"), &st))
1036                         st.st_mtime = 0;
1037         }
1038
1039         if (heads && nr_heads)
1040                 nr_heads = remove_duplicates(nr_heads, heads);
1041         if (!ref) {
1042                 packet_flush(fd[1]);
1043                 die("no matching remote head");
1044         }
1045         ref_cpy = do_fetch_pack(fd, ref, nr_heads, heads, pack_lockfile);
1046
1047         if (args.depth > 0) {
1048                 struct cache_time mtime;
1049                 struct strbuf sb = STRBUF_INIT;
1050                 char *shallow = git_path("shallow");
1051                 int fd;
1052
1053                 mtime.sec = st.st_mtime;
1054                 mtime.nsec = ST_MTIME_NSEC(st);
1055                 if (stat(shallow, &st)) {
1056                         if (mtime.sec)
1057                                 die("shallow file was removed during fetch");
1058                 } else if (st.st_mtime != mtime.sec
1059 #ifdef USE_NSEC
1060                                 || ST_MTIME_NSEC(st) != mtime.nsec
1061 #endif
1062                           )
1063                         die("shallow file was changed during fetch");
1064
1065                 fd = hold_lock_file_for_update(&lock, shallow,
1066                                                LOCK_DIE_ON_ERROR);
1067                 if (!write_shallow_commits(&sb, 0)
1068                  || write_in_full(fd, sb.buf, sb.len) != sb.len) {
1069                         unlink_or_warn(shallow);
1070                         rollback_lock_file(&lock);
1071                 } else {
1072                         commit_lock_file(&lock);
1073                 }
1074                 strbuf_release(&sb);
1075         }
1076
1077         reprepare_packed_git();
1078         return ref_cpy;
1079 }