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