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
10const char *write_ref = NULL;
11const char *write_ref_log_details = NULL;
12
13const unsigned char *current_ref = NULL;
14
15int get_tree = 0;
16int get_history = 0;
17int get_all = 0;
18int get_verbosely = 0;
19int get_recover = 0;
20static unsigned char current_commit_sha1[20];
21
22void pull_say(const char *fmt, const char *hex)
23{
24 if (get_verbosely)
25 fprintf(stderr, fmt, hex);
26}
27
28static 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
38static int process(struct object *obj);
39
40static 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
64static struct commit_list *complete = NULL;
65
66static 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
98static int process_tag(struct tag *tag)
99{
100 if (parse_tag(tag))
101 return -1;
102 return process(tag->tagged);
103}
104
105static struct object_list *process_queue = NULL;
106static struct object_list **process_queue_end = &process_queue;
107
108static 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
133static 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
153static 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
184static 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
196static 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
206int 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}