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] [--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;
  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\n", sha1_to_hex(remote),
 160                         multi_ack ? " multi_ack" : "");
 161                 fetching++;
 162         }
 163         packet_flush(fd[1]);
 164         if (!fetching)
 165                 return 1;
 166
 167         flushes = 0;
 168         retval = -1;
 169         while ((sha1 = get_rev())) {
 170                 packet_write(fd[1], "have %s\n", sha1_to_hex(sha1));
 171                 if (verbose)
 172                         fprintf(stderr, "have %s\n", sha1_to_hex(sha1));
 173                 if (!(31 & ++count)) {
 174                         int ack;
 175
 176                         packet_flush(fd[1]);
 177                         flushes++;
 178
 179                         /*
 180                          * We keep one window "ahead" of the other side, and
 181                          * will wait for an ACK only on the next one
 182                          */
 183                         if (count == 32)
 184                                 continue;
 185
 186                         do {
 187                                 ack = get_ack(fd[0], result_sha1);
 188                                 if (verbose && ack)
 189                                         fprintf(stderr, "got ack %d %s\n", ack,
 190                                                         sha1_to_hex(result_sha1));
 191                                 if (ack == 1) {
 192                                         flushes = 0;
 193                                         multi_ack = 0;
 194                                         retval = 0;
 195                                         goto done;
 196                                 } else if (ack == 2) {
 197                                         struct commit *commit =
 198                                                 lookup_commit(result_sha1);
 199                                         mark_common(commit, 0, 1);
 200                                         retval = 0;
 201                                 }
 202                         } while (ack);
 203                         flushes--;
 204                 }
 205         }
 206 done:
 207         packet_write(fd[1], "done\n");
 208         if (verbose)
 209                 fprintf(stderr, "done\n");
 210         if (retval != 0) {
 211                 multi_ack = 0;
 212                 flushes++;
 213         }
 214         while (flushes || multi_ack) {
 215                 int ack = get_ack(fd[0], result_sha1);
 216                 if (ack) {
 217                         if (verbose)
 218                                 fprintf(stderr, "got ack (%d) %s\n", ack,
 219                                         sha1_to_hex(result_sha1));
 220                         if (ack == 1)
 221                                 return 0;
 222                         multi_ack = 1;
 223                         continue;
 224                 }
 225                 flushes--;
 226         }
 227         return retval;
 228 }
 229
 230 static struct commit_list *complete = NULL;
 231
 232 static int mark_complete(const char *path, const unsigned char *sha1)
 233 {
 234         struct object *o = parse_object(sha1);
 235
 236         while (o && o->type == tag_type) {
 237                 struct tag *t = (struct tag *) o;
 238                 if (!t->tagged)
 239                         break; /* broken repository */
 240                 o->flags |= COMPLETE;
 241                 o = parse_object(t->tagged->sha1);
 242         }
 243         if (o && o->type == commit_type) {
 244                 struct commit *commit = (struct commit *)o;
 245                 commit->object.flags |= COMPLETE;
 246                 insert_by_date(commit, &complete);
 247         }
 248         return 0;
 249 }
 250
 251 static void mark_recent_complete_commits(unsigned long cutoff)
 252 {
 253         while (complete && cutoff <= complete->item->date) {
 254                 if (verbose)
 255                         fprintf(stderr, "Marking %s as complete\n",
 256                                 sha1_to_hex(complete->item->object.sha1));
 257                 pop_most_recent_commit(&complete, COMPLETE);
 258         }
 259 }
 260
 261 static void filter_refs(struct ref **refs, int nr_match, char **match)
 262 {
 263         struct ref *prev, *current, *next;
 264
 265         for (prev = NULL, current = *refs; current; current = next) {
 266                 next = current->next;
 267                 if ((!memcmp(current->name, "refs/", 5) &&
 268                                         check_ref_format(current->name + 5)) ||
 269                                 !path_match(current->name, nr_match, match)) {
 270                         if (prev == NULL)
 271                                 *refs = next;
 272                         else
 273                                 prev->next = next;
 274                         free(current);
 275                 } else
 276                         prev = current;
 277         }
 278 }
 279
 280 static int everything_local(struct ref **refs, int nr_match, char **match)
 281 {
 282         struct ref *ref;
 283         int retval;
 284         unsigned long cutoff = 0;
 285
 286         track_object_refs = 0;
 287         save_commit_buffer = 0;
 288
 289         for (ref = *refs; ref; ref = ref->next) {
 290                 struct object *o;
 291
 292                 o = parse_object(ref->old_sha1);
 293                 if (!o)
 294                         continue;
 295
 296                 /* We already have it -- which may mean that we were
 297                  * in sync with the other side at some time after
 298                  * that (it is OK if we guess wrong here).
 299                  */
 300                 if (o->type == commit_type) {
 301                         struct commit *commit = (struct commit *)o;
 302                         if (!cutoff || cutoff < commit->date)
 303                                 cutoff = commit->date;
 304                 }
 305         }
 306
 307         for_each_ref(mark_complete);
 308         if (cutoff)
 309                 mark_recent_complete_commits(cutoff);
 310
 311         /*
 312          * Mark all complete remote refs as common refs.
 313          * Don't mark them common yet; the server has to be told so first.
 314          */
 315         for (ref = *refs; ref; ref = ref->next) {
 316                 struct object *o = deref_tag(lookup_object(ref->old_sha1),
 317                                              NULL, 0);
 318
 319                 if (!o || o->type != commit_type || !(o->flags & COMPLETE))
 320                         continue;
 321
 322                 if (!(o->flags & SEEN)) {
 323                         rev_list_push((struct commit *)o, COMMON_REF | SEEN);
 324
 325                         mark_common((struct commit *)o, 1, 1);
 326                 }
 327         }
 328
 329         filter_refs(refs, nr_match, match);
 330
 331         for (retval = 1, ref = *refs; ref ; ref = ref->next) {
 332                 const unsigned char *remote = ref->old_sha1;
 333                 unsigned char local[20];
 334                 struct object *o;
 335
 336                 o = lookup_object(remote);
 337                 if (!o || !(o->flags & COMPLETE)) {
 338                         retval = 0;
 339                         if (!verbose)
 340                                 continue;
 341                         fprintf(stderr,
 342                                 "want %s (%s)\n", sha1_to_hex(remote),
 343                                 ref->name);
 344                         continue;
 345                 }
 346
 347                 memcpy(ref->new_sha1, local, 20);
 348                 if (!verbose)
 349                         continue;
 350                 fprintf(stderr,
 351                         "already have %s (%s)\n", sha1_to_hex(remote),
 352                         ref->name);
 353         }
 354         return retval;
 355 }
 356
 357 static int fetch_pack(int fd[2], int nr_match, char **match)
 358 {
 359         struct ref *ref;
 360         unsigned char sha1[20];
 361         int status;
 362
 363         get_remote_heads(fd[0], &ref, 0, NULL, 0);
 364         if (server_supports("multi_ack")) {
 365                 if (verbose)
 366                         fprintf(stderr, "Server supports multi_ack\n");
 367                 multi_ack = 1;
 368         }
 369         if (!ref) {
 370                 packet_flush(fd[1]);
 371                 die("no matching remote head");
 372         }
 373         if (everything_local(&ref, nr_match, match)) {
 374                 packet_flush(fd[1]);
 375                 goto all_done;
 376         }
 377         if (find_common(fd, sha1, ref) < 0)
 378                 fprintf(stderr, "warning: no common commits\n");
 379
 380         if (keep_pack)
 381                 status = receive_keep_pack(fd, "git-fetch-pack");
 382         else
 383                 status = receive_unpack_pack(fd, "git-fetch-pack", quiet);
 384
 385         if (status)
 386                 die("git-fetch-pack: fetch failed.");
 387
 388  all_done:
 389         while (ref) {
 390                 printf("%s %s\n",
 391                        sha1_to_hex(ref->old_sha1), ref->name);
 392                 ref = ref->next;
 393         }
 394         return 0;
 395 }
 396
 397 int main(int argc, char **argv)
 398 {
 399         int i, ret, nr_heads;
 400         char *dest = NULL, **heads;
 401         int fd[2];
 402         pid_t pid;
 403
 404         setup_git_directory();
 405
 406         nr_heads = 0;
 407         heads = NULL;
 408         for (i = 1; i < argc; i++) {
 409                 char *arg = argv[i];
 410
 411                 if (*arg == '-') {
 412                         if (!strncmp("--exec=", arg, 7)) {
 413                                 exec = arg + 7;
 414                                 continue;
 415                         }
 416                         if (!strcmp("--quiet", arg) || !strcmp("-q", arg)) {
 417                                 quiet = 1;
 418                                 continue;
 419                         }
 420                         if (!strcmp("--keep", arg) || !strcmp("-k", arg)) {
 421                                 keep_pack = 1;
 422                                 continue;
 423                         }
 424                         if (!strcmp("-v", arg)) {
 425                                 verbose = 1;
 426                                 continue;
 427                         }
 428                         usage(fetch_pack_usage);
 429                 }
 430                 dest = arg;
 431                 heads = argv + i + 1;
 432                 nr_heads = argc - i - 1;
 433                 break;
 434         }
 435         if (!dest)
 436                 usage(fetch_pack_usage);
 437         pid = git_connect(fd, dest, exec);
 438         if (pid < 0)
 439                 return 1;
 440         ret = fetch_pack(fd, nr_heads, heads);
 441         close(fd[0]);
 442         close(fd[1]);
 443         finish_connect(pid);
 444
 445         if (!ret && nr_heads) {
 446                 /* If the heads to pull were given, we should have
 447                  * consumed all of them by matching the remote.
 448                  * Otherwise, 'git-fetch remote no-such-ref' would
 449                  * silently succeed without issuing an error.
 450                  */
 451                 for (i = 0; i < nr_heads; i++)
 452                         if (heads[i] && heads[i][0]) {
 453                                 error("no such remote ref %s", heads[i]);
 454                                 ret = 1;
 455                         }
 456         }
 457
 458         return ret;
 459 }