git.oblomov.eu Git - git/blob - builtin/fetch-pack.c

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