fetch.c

   1 #include "fetch.h"
   2
   3 #include "cache.h"
   4 #include "commit.h"
   5 #include "tree.h"
   6 #include "tag.h"
   7 #include "blob.h"
   8 #include "refs.h"
   9
  10 const char *write_ref = NULL;
  11 const char *write_ref_log_details = NULL;
  12
  13 const unsigned char *current_ref = NULL;
  14
  15 int get_tree = 0;
  16 int get_history = 0;
  17 int get_all = 0;
  18 int get_verbosely = 0;
  19 int get_recover = 0;
  20 static unsigned char current_commit_sha1[20];
  21
  22 void pull_say(const char *fmt, const char *hex)
  23 {
  24         if (get_verbosely)
  25                 fprintf(stderr, fmt, hex);
  26 }
  27
  28 static void report_missing(const char *what, const unsigned char *missing)
  29 {
  30         char missing_hex[41];
  31
  32         strcpy(missing_hex, sha1_to_hex(missing));;
  33         fprintf(stderr,
  34                 "Cannot obtain needed %s %s\nwhile processing commit %s.\n",
  35                 what, missing_hex, sha1_to_hex(current_commit_sha1));
  36 }
  37
  38 static int process(struct object *obj);
  39
  40 static int process_tree(struct tree *tree)
  41 {
  42         struct tree_entry_list *entry;
  43
  44         if (parse_tree(tree))
  45                 return -1;
  46
  47         entry = tree->entries;
  48         tree->entries = NULL;
  49         while (entry) {
  50                 struct tree_entry_list *next = entry->next;
  51                 if (process(entry->item.any))
  52                         return -1;
  53                 free(entry->name);
  54                 free(entry);
  55                 entry = next;
  56         }
  57         return 0;
  58 }
  59
  60 #define COMPLETE        (1U << 0)
  61 #define SEEN            (1U << 1)
  62 #define TO_SCAN         (1U << 2)
  63
  64 static struct commit_list *complete = NULL;
  65
  66 static int process_commit(struct commit *commit)
  67 {
  68         if (parse_commit(commit))
  69                 return -1;
  70
  71         while (complete && complete->item->date >= commit->date) {
  72                 pop_most_recent_commit(&complete, COMPLETE);
  73         }
  74
  75         if (commit->object.flags & COMPLETE)
  76                 return 0;
  77
  78         memcpy(current_commit_sha1, commit->object.sha1, 20);
  79
  80         pull_say("walk %s\n", sha1_to_hex(commit->object.sha1));
  81
  82         if (get_tree) {
  83                 if (process(&commit->tree->object))
  84                         return -1;
  85                 if (!get_all)
  86                         get_tree = 0;
  87         }
  88         if (get_history) {
  89                 struct commit_list *parents = commit->parents;
  90                 for (; parents; parents = parents->next) {
  91                         if (process(&parents->item->object))
  92                                 return -1;
  93                 }
  94         }
  95         return 0;
  96 }
  97
  98 static int process_tag(struct tag *tag)
  99 {
 100         if (parse_tag(tag))
 101                 return -1;
 102         return process(tag->tagged);
 103 }
 104
 105 static struct object_list *process_queue = NULL;
 106 static struct object_list **process_queue_end = &process_queue;
 107
 108 static int process_object(struct object *obj)
 109 {
 110         if (obj->type == commit_type) {
 111                 if (process_commit((struct commit *)obj))
 112                         return -1;
 113                 return 0;
 114         }
 115         if (obj->type == tree_type) {
 116                 if (process_tree((struct tree *)obj))
 117                         return -1;
 118                 return 0;
 119         }
 120         if (obj->type == blob_type) {
 121                 return 0;
 122         }
 123         if (obj->type == tag_type) {
 124                 if (process_tag((struct tag *)obj))
 125                         return -1;
 126                 return 0;
 127         }
 128         return error("Unable to determine requirements "
 129                      "of type %s for %s",
 130                      obj->type, sha1_to_hex(obj->sha1));
 131 }
 132
 133 static int process(struct object *obj)
 134 {
 135         if (obj->flags & SEEN)
 136                 return 0;
 137         obj->flags |= SEEN;
 138
 139         if (has_sha1_file(obj->sha1)) {
 140                 /* We already have it, so we should scan it now. */
 141                 obj->flags |= TO_SCAN;
 142         } else {
 143                 if (obj->flags & COMPLETE)
 144                         return 0;
 145                 prefetch(obj->sha1);
 146         }
 147
 148         object_list_insert(obj, process_queue_end);
 149         process_queue_end = &(*process_queue_end)->next;
 150         return 0;
 151 }
 152
 153 static int loop(void)
 154 {
 155         struct object_list *elem;
 156
 157         while (process_queue) {
 158                 struct object *obj = process_queue->item;
 159                 elem = process_queue;
 160                 process_queue = elem->next;
 161                 free(elem);
 162                 if (!process_queue)
 163                         process_queue_end = &process_queue;
 164
 165                 /* If we are not scanning this object, we placed it in
 166                  * the queue because we needed to fetch it first.
 167                  */
 168                 if (! (obj->flags & TO_SCAN)) {
 169                         if (fetch(obj->sha1)) {
 170                                 report_missing(obj->type
 171                                                ? obj->type
 172                                                : "object", obj->sha1);
 173                                 return -1;
 174                         }
 175                 }
 176                 if (!obj->type)
 177                         parse_object(obj->sha1);
 178                 if (process_object(obj))
 179                         return -1;
 180         }
 181         return 0;
 182 }
 183
 184 static int interpret_target(char *target, unsigned char *sha1)
 185 {
 186         if (!get_sha1_hex(target, sha1))
 187                 return 0;
 188         if (!check_ref_format(target)) {
 189                 if (!fetch_ref(target, sha1)) {
 190                         return 0;
 191                 }
 192         }
 193         return -1;
 194 }
 195
 196 static int mark_complete(const char *path, const unsigned char *sha1)
 197 {
 198         struct commit *commit = lookup_commit_reference_gently(sha1, 1);
 199         if (commit) {
 200                 commit->object.flags |= COMPLETE;
 201                 insert_by_date(commit, &complete);
 202         }
 203         return 0;
 204 }
 205
 206 int pull(char *target)
 207 {
 208         struct ref_lock *lock;
 209         unsigned char sha1[20];
 210         char *msg;
 211         int ret;
 212
 213         save_commit_buffer = 0;
 214         track_object_refs = 0;
 215         if (write_ref) {
 216                 lock = lock_ref_sha1(write_ref, current_ref, 1);
 217                 if (!lock) {
 218                         error("Can't lock ref %s", write_ref);
 219                         return -1;
 220                 }
 221         }
 222
 223         if (!get_recover) {
 224                 for_each_ref(mark_complete);
 225         }
 226
 227         if (interpret_target(target, sha1)) {
 228                 error("Could not interpret %s as something to pull", target);
 229                 unlock_ref(lock);
 230                 return -1;
 231         }
 232         if (process(lookup_unknown_object(sha1))) {
 233                 unlock_ref(lock);
 234                 return -1;
 235         }
 236         if (loop()) {
 237                 unlock_ref(lock);
 238                 return -1;
 239         }
 240
 241         if (write_ref) {
 242                 if (write_ref_log_details) {
 243                         msg = xmalloc(strlen(write_ref_log_details) + 12);
 244                         sprintf(msg, "fetch from %s", write_ref_log_details);
 245                 } else
 246                         msg = NULL;
 247                 ret = write_ref_sha1(lock, sha1, msg ? msg : "fetch (unknown)");
 248                 if (msg)
 249                         free(msg);
 250                 return ret;
 251         }
 252         return 0;
 253 }