Merge branch 'master' into next
[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 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 }