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
   7 static int keep_pack;
   8 static int quiet;
   9 static int verbose;
  10 static const char fetch_pack_usage[] =
  11 "git-fetch-pack [-q] [-v] [-k] [--thin] [--exec=upload-pack] [host:]directory <refs>...";
  12 static const char *exec = "git-upload-pack";
  13
  14 #define COMPLETE        (1U << 0)
  15 #define COMMON          (1U << 1)
  16 #define COMMON_REF      (1U << 2)
  17 #define SEEN            (1U << 3)
  18 #define POPPED          (1U << 4)
  19
  20 static struct commit_list *rev_list = NULL;
  21 static int non_common_revs = 0, multi_ack = 0, use_thin_pack = 0;
  22
  23 static void rev_list_push(struct commit *commit, int mark)
  24 {
  25         if (!(commit->object.flags & mark)) {
  26                 commit->object.flags |= mark;
  27
  28                 if (!(commit->object.parsed))
  29                         parse_commit(commit);
  30
  31                 insert_by_date(commit, &rev_list);
  32
  33                 if (!(commit->object.flags & COMMON))
  34                         non_common_revs++;
  35         }
  36 }
  37
  38 static int rev_list_insert_ref(const char *path, const unsigned char *sha1)
  39 {
  40         struct object *o = deref_tag(parse_object(sha1), path, 0);
  41
  42         if (o && o->type == commit_type)
  43                 rev_list_push((struct commit *)o, SEEN);
  44
  45         return 0;
  46 }
  47
  48 /*
  49    This function marks a rev and its ancestors as common.
  50    In some cases, it is desirable to mark only the ancestors (for example
  51    when only the server does not yet know that they are common).
  52 */
  53
  54 static void mark_common(struct commit *commit,
  55                 int ancestors_only, int dont_parse)
  56 {
  57         if (commit != NULL && !(commit->object.flags & COMMON)) {
  58                 struct object *o = (struct object *)commit;
  59
  60                 if (!ancestors_only)
  61                         o->flags |= COMMON;
  62
  63                 if (!(o->flags & SEEN))
  64                         rev_list_push(commit, SEEN);
  65                 else {
  66                         struct commit_list *parents;
  67
  68                         if (!ancestors_only && !(o->flags & POPPED))
  69                                 non_common_revs--;
  70                         if (!o->parsed && !dont_parse)
  71                                 parse_commit(commit);
  72
  73                         for (parents = commit->parents;
  74                                         parents;
  75                                         parents = parents->next)
  76                                 mark_common(parents->item, 0, dont_parse);
  77                 }
  78         }
  79 }
  80
  81 /*
  82   Get the next rev to send, ignoring the common.
  83 */
  84
  85 static const unsigned char* get_rev()
  86 {
  87         struct commit *commit = NULL;
  88
  89         while (commit == NULL) {
  90                 unsigned int mark;
  91                 struct commit_list* parents;
  92
  93                 if (rev_list == NULL || non_common_revs == 0)
  94                         return NULL;
  95
  96                 commit = rev_list->item;
  97                 if (!(commit->object.parsed))
  98                         parse_commit(commit);
  99                 commit->object.flags |= POPPED;
 100                 if (!(commit->object.flags & COMMON))
 101                         non_common_revs--;
 102
 103                 parents = commit->parents;
 104
 105                 if (commit->object.flags & COMMON) {
 106                         /* do not send "have", and ignore ancestors */
 107                         commit = NULL;
 108                         mark = COMMON | SEEN;
 109                 } else if (commit->object.flags & COMMON_REF)
 110                         /* send "have", and ignore ancestors */
 111                         mark = COMMON | SEEN;
 112                 else
 113                         /* send "have", also for its ancestors */
 114                         mark = SEEN;
 115
 116                 while (parents) {
 117                         if (!(parents->item->object.flags & SEEN))
 118                                 rev_list_push(parents->item, mark);
 119                         if (mark & COMMON)
 120                                 mark_common(parents->item, 1, 0);
 121                         parents = parents->next;
 122                 }
 123
 124                 rev_list = rev_list->next;
 125         }
 126
 127         return commit->object.sha1;
 128 }
 129
 130 static int find_common(int fd[2], unsigned char *result_sha1,
 131                        struct ref *refs)
 132 {
 133         int fetching;
 134         int count = 0, flushes = 0, retval;
 135         const unsigned char *sha1;
 136
 137         for_each_ref(rev_list_insert_ref);
 138
 139         fetching = 0;
 140         for ( ; refs ; refs = refs->next) {
 141                 unsigned char *remote = refs->old_sha1;
 142                 struct object *o;
 143
 144                 /*
 145                  * If that object is complete (i.e. it is an ancestor of a
 146                  * local ref), we tell them we have it but do not have to
 147                  * tell them about its ancestors, which they already know
 148                  * about.
 149                  *
 150                  * We use lookup_object here because we are only
 151                  * interested in the case we *know* the object is
 152                  * reachable and we have already scanned it.
 153                  */
 154                 if (((o = lookup_object(remote)) != NULL) &&
 155                                 (o->flags & COMPLETE)) {
 156                         continue;
 157                 }
 158
 159                 packet_write(fd[1], "want %s%s%s\n", sha1_to_hex(remote),
 160                              (multi_ack ? " multi_ack" : ""),
 161                              (use_thin_pack ? " thin-pack" : ""));
 162                 fetching++;
 163         }
 164         packet_flush(fd[1]);
 165         if (!fetching)
 166                 return 1;
 167
 168         flushes = 0;
 169         retval = -1;
 170         while ((sha1 = get_rev())) {
 171                 packet_write(fd[1], "have %s\n", sha1_to_hex(sha1));
 172                 if (verbose)
 173                         fprintf(stderr, "have %s\n", sha1_to_hex(sha1));
 174                 if (!(31 & ++count)) {
 175                         int ack;
 176
 177                         packet_flush(fd[1]);
 178                         flushes++;
 179
 180                         /*
 181                          * We keep one window "ahead" of the other side, and
 182                          * will wait for an ACK only on the next one
 183                          */
 184                         if (count == 32)
 185                                 continue;
 186
 187                         do {
 188                                 ack = get_ack(fd[0], result_sha1);
 189                                 if (verbose && ack)
 190                                         fprintf(stderr, "got ack %d %s\n", ack,
 191                                                         sha1_to_hex(result_sha1));
 192                                 if (ack == 1) {
 193                                         flushes = 0;
 194                                         multi_ack = 0;
 195                                         retval = 0;
 196                                         goto done;
 197                                 } else if (ack == 2) {
 198                                         struct commit *commit =
 199                                                 lookup_commit(result_sha1);
 200                                         mark_common(commit, 0, 1);
 201                                         retval = 0;
 202                                 }
 203                         } while (ack);
 204                         flushes--;
 205                 }
 206         }
 207 done:
 208         packet_write(fd[1], "done\n");
 209         if (verbose)
 210                 fprintf(stderr, "done\n");
 211         if (retval != 0) {
 212                 multi_ack = 0;
 213                 flushes++;
 214         }
 215         while (flushes || multi_ack) {
 216                 int ack = get_ack(fd[0], result_sha1);
 217                 if (ack) {
 218                         if (verbose)
 219                                 fprintf(stderr, "got ack (%d) %s\n", ack,
 220                                         sha1_to_hex(result_sha1));
 221                         if (ack == 1)
 222                                 return 0;
 223                         multi_ack = 1;
 224                         continue;
 225                 }
 226                 flushes--;
 227         }
 228         return retval;
 229 }
 230
 231 static struct commit_list *complete = NULL;
 232
 233 static int mark_complete(const char *path, const unsigned char *sha1)
 234 {
 235         struct object *o = parse_object(sha1);
 236
 237         while (o && o->type == tag_type) {
 238                 struct tag *t = (struct tag *) o;
 239                 if (!t->tagged)
 240                         break; /* broken repository */
 241                 o->flags |= COMPLETE;
 242                 o = parse_object(t->tagged->sha1);
 243         }
 244         if (o && o->type == commit_type) {
 245                 struct commit *commit = (struct commit *)o;
 246                 commit->object.flags |= COMPLETE;
 247                 insert_by_date(commit, &complete);
 248         }
 249         return 0;
 250 }
 251
 252 static void mark_recent_complete_commits(unsigned long cutoff)
 253 {
 254         while (complete && cutoff <= complete->item->date) {
 255                 if (verbose)
 256                         fprintf(stderr, "Marking %s as complete\n",
 257                                 sha1_to_hex(complete->item->object.sha1));
 258                 pop_most_recent_commit(&complete, COMPLETE);
 259         }
 260 }
 261
 262 static void filter_refs(struct ref **refs, int nr_match, char **match)
 263 {
 264         struct ref *prev, *current, *next;
 265
 266         for (prev = NULL, current = *refs; current; current = next) {
 267                 next = current->next;
 268                 if ((!memcmp(current->name, "refs/", 5) &&
 269                                         check_ref_format(current->name + 5)) ||
 270                                 !path_match(current->name, nr_match, match)) {
 271                         if (prev == NULL)
 272                                 *refs = next;
 273                         else
 274                                 prev->next = next;
 275                         free(current);
 276                 } else
 277                         prev = current;
 278         }
 279 }
 280
 281 static int everything_local(struct ref **refs, int nr_match, char **match)
 282 {
 283         struct ref *ref;
 284         int retval;
 285         unsigned long cutoff = 0;
 286
 287         track_object_refs = 0;
 288         save_commit_buffer = 0;
 289
 290         for (ref = *refs; ref; ref = ref->next) {
 291                 struct object *o;
 292
 293                 o = parse_object(ref->old_sha1);
 294                 if (!o)
 295                         continue;
 296
 297                 /* We already have it -- which may mean that we were
 298                  * in sync with the other side at some time after
 299                  * that (it is OK if we guess wrong here).
 300                  */
 301                 if (o->type == commit_type) {
 302                         struct commit *commit = (struct commit *)o;
 303                         if (!cutoff || cutoff < commit->date)
 304                                 cutoff = commit->date;
 305                 }
 306         }
 307
 308         for_each_ref(mark_complete);
 309         if (cutoff)
 310                 mark_recent_complete_commits(cutoff);
 311
 312         /*
 313          * Mark all complete remote refs as common refs.
 314          * Don't mark them common yet; the server has to be told so first.
 315          */
 316         for (ref = *refs; ref; ref = ref->next) {
 317                 struct object *o = deref_tag(lookup_object(ref->old_sha1),
 318                                              NULL, 0);
 319
 320                 if (!o || o->type != commit_type || !(o->flags & COMPLETE))
 321                         continue;
 322
 323                 if (!(o->flags & SEEN)) {
 324                         rev_list_push((struct commit *)o, COMMON_REF | SEEN);
 325
 326                         mark_common((struct commit *)o, 1, 1);
 327                 }
 328         }
 329
 330         filter_refs(refs, nr_match, match);
 331
 332         for (retval = 1, ref = *refs; ref ; ref = ref->next) {
 333                 const unsigned char *remote = ref->old_sha1;
 334                 unsigned char local[20];
 335                 struct object *o;
 336
 337                 o = lookup_object(remote);
 338                 if (!o || !(o->flags & COMPLETE)) {
 339                         retval = 0;
 340                         if (!verbose)
 341                                 continue;
 342                         fprintf(stderr,
 343                                 "want %s (%s)\n", sha1_to_hex(remote),
 344                                 ref->name);
 345                         continue;
 346                 }
 347
 348                 memcpy(ref->new_sha1, local, 20);
 349                 if (!verbose)
 350                         continue;
 351                 fprintf(stderr,
 352                         "already have %s (%s)\n", sha1_to_hex(remote),
 353                         ref->name);
 354         }
 355         return retval;
 356 }
 357
 358 static int fetch_pack(int fd[2], int nr_match, char **match)
 359 {
 360         struct ref *ref;
 361         unsigned char sha1[20];
 362         int status;
 363
 364         get_remote_heads(fd[0], &ref, 0, NULL, 0);
 365         if (server_supports("multi_ack")) {
 366                 if (verbose)
 367                         fprintf(stderr, "Server supports multi_ack\n");
 368                 multi_ack = 1;
 369         }
 370         if (!ref) {
 371                 packet_flush(fd[1]);
 372                 die("no matching remote head");
 373         }
 374         if (everything_local(&ref, nr_match, match)) {
 375                 packet_flush(fd[1]);
 376                 goto all_done;
 377         }
 378         if (find_common(fd, sha1, ref) < 0)
 379                 fprintf(stderr, "warning: no common commits\n");
 380
 381         if (keep_pack)
 382                 status = receive_keep_pack(fd, "git-fetch-pack", quiet);
 383         else
 384                 status = receive_unpack_pack(fd, "git-fetch-pack", quiet);
 385
 386         if (status)
 387                 die("git-fetch-pack: fetch failed.");
 388
 389  all_done:
 390         while (ref) {
 391                 printf("%s %s\n",
 392                        sha1_to_hex(ref->old_sha1), ref->name);
 393                 ref = ref->next;
 394         }
 395         return 0;
 396 }
 397
 398 int main(int argc, char **argv)
 399 {
 400         int i, ret, nr_heads;
 401         char *dest = NULL, **heads;
 402         int fd[2];
 403         pid_t pid;
 404
 405         setup_git_directory();
 406
 407         nr_heads = 0;
 408         heads = NULL;
 409         for (i = 1; i < argc; i++) {
 410                 char *arg = argv[i];
 411
 412                 if (*arg == '-') {
 413                         if (!strncmp("--exec=", arg, 7)) {
 414                                 exec = arg + 7;
 415                                 continue;
 416                         }
 417                         if (!strcmp("--quiet", arg) || !strcmp("-q", arg)) {
 418                                 quiet = 1;
 419                                 continue;
 420                         }
 421                         if (!strcmp("--keep", arg) || !strcmp("-k", arg)) {
 422                                 keep_pack = 1;
 423                                 continue;
 424                         }
 425                         if (!strcmp("--thin", arg)) {
 426                                 use_thin_pack = 1;
 427                                 continue;
 428                         }
 429                         if (!strcmp("-v", arg)) {
 430                                 verbose = 1;
 431                                 continue;
 432                         }
 433                         usage(fetch_pack_usage);
 434                 }
 435                 dest = arg;
 436                 heads = argv + i + 1;
 437                 nr_heads = argc - i - 1;
 438                 break;
 439         }
 440         if (!dest)
 441                 usage(fetch_pack_usage);
 442         if (keep_pack)
 443                 use_thin_pack = 0;
 444         pid = git_connect(fd, dest, exec);
 445         if (pid < 0)
 446                 return 1;
 447         ret = fetch_pack(fd, nr_heads, heads);
 448         close(fd[0]);
 449         close(fd[1]);
 450         finish_connect(pid);
 451
 452         if (!ret && nr_heads) {
 453                 /* If the heads to pull were given, we should have
 454                  * consumed all of them by matching the remote.
 455                  * Otherwise, 'git-fetch remote no-such-ref' would
 456                  * silently succeed without issuing an error.
 457                  */
 458                 for (i = 0; i < nr_heads; i++)
 459                         if (heads[i] && heads[i][0]) {
 460                                 error("no such remote ref %s", heads[i]);
 461                                 ret = 1;
 462                         }
 463         }
 464
 465         return ret;
 466 }