tree-walk: don't parse incorrect entries
[git/git.git] / tree-walk.c
1 #include "cache.h"
2 #include "tree-walk.h"
3 #include "tree.h"
4
5 static const char *get_mode(const char *str, unsigned int *modep)
6 {
7 unsigned char c;
8 unsigned int mode = 0;
9
10 if (*str == ' ')
11 return NULL;
12
13 while ((c = *str++) != ' ') {
14 if (c < '0' || c > '7')
15 return NULL;
16 mode = (mode << 3) + (c - '0');
17 }
18 *modep = mode;
19 return str;
20 }
21
22 static void decode_tree_entry(struct tree_desc *desc, const char *buf, unsigned long size)
23 {
24 const char *path;
25 unsigned int mode, len;
26
27 if (size < 24 || buf[size - 21])
28 die("corrupt tree file");
29
30 path = get_mode(buf, &mode);
31 if (!path || !*path)
32 die("corrupt tree file");
33 len = strlen(path) + 1;
34
35 /* Initialize the descriptor entry */
36 desc->entry.path = path;
37 desc->entry.mode = mode;
38 desc->entry.sha1 = (const unsigned char *)(path + len);
39 }
40
41 void init_tree_desc(struct tree_desc *desc, const void *buffer, unsigned long size)
42 {
43 desc->buffer = buffer;
44 desc->size = size;
45 if (size)
46 decode_tree_entry(desc, buffer, size);
47 }
48
49 void *fill_tree_descriptor(struct tree_desc *desc, const unsigned char *sha1)
50 {
51 unsigned long size = 0;
52 void *buf = NULL;
53
54 if (sha1) {
55 buf = read_object_with_reference(sha1, tree_type, &size, NULL);
56 if (!buf)
57 die("unable to read tree %s", sha1_to_hex(sha1));
58 }
59 init_tree_desc(desc, buf, size);
60 return buf;
61 }
62
63 static int entry_compare(struct name_entry *a, struct name_entry *b)
64 {
65 return base_name_compare(
66 a->path, tree_entry_len(a->path, a->sha1), a->mode,
67 b->path, tree_entry_len(b->path, b->sha1), b->mode);
68 }
69
70 static void entry_clear(struct name_entry *a)
71 {
72 memset(a, 0, sizeof(*a));
73 }
74
75 static void entry_extract(struct tree_desc *t, struct name_entry *a)
76 {
77 *a = t->entry;
78 }
79
80 void update_tree_entry(struct tree_desc *desc)
81 {
82 const void *buf = desc->buffer;
83 const unsigned char *end = desc->entry.sha1 + 20;
84 unsigned long size = desc->size;
85 unsigned long len = end - (const unsigned char *)buf;
86
87 if (size < len)
88 die("corrupt tree file");
89 buf = end;
90 size -= len;
91 desc->buffer = buf;
92 desc->size = size;
93 if (size)
94 decode_tree_entry(desc, buf, size);
95 }
96
97 int tree_entry(struct tree_desc *desc, struct name_entry *entry)
98 {
99 if (!desc->size)
100 return 0;
101
102 *entry = desc->entry;
103 update_tree_entry(desc);
104 return 1;
105 }
106
107 void traverse_trees(int n, struct tree_desc *t, const char *base, traverse_callback_t callback)
108 {
109 struct name_entry *entry = xmalloc(n*sizeof(*entry));
110
111 for (;;) {
112 unsigned long mask = 0;
113 int i, last;
114
115 last = -1;
116 for (i = 0; i < n; i++) {
117 if (!t[i].size)
118 continue;
119 entry_extract(t+i, entry+i);
120 if (last >= 0) {
121 int cmp = entry_compare(entry+i, entry+last);
122
123 /*
124 * Is the new name bigger than the old one?
125 * Ignore it
126 */
127 if (cmp > 0)
128 continue;
129 /*
130 * Is the new name smaller than the old one?
131 * Ignore all old ones
132 */
133 if (cmp < 0)
134 mask = 0;
135 }
136 mask |= 1ul << i;
137 last = i;
138 }
139 if (!mask)
140 break;
141
142 /*
143 * Update the tree entries we've walked, and clear
144 * all the unused name-entries.
145 */
146 for (i = 0; i < n; i++) {
147 if (mask & (1ul << i)) {
148 update_tree_entry(t+i);
149 continue;
150 }
151 entry_clear(entry + i);
152 }
153 callback(n, mask, entry, base);
154 }
155 free(entry);
156 }
157
158 static int find_tree_entry(struct tree_desc *t, const char *name, unsigned char *result, unsigned *mode)
159 {
160 int namelen = strlen(name);
161 while (t->size) {
162 const char *entry;
163 const unsigned char *sha1;
164 int entrylen, cmp;
165
166 sha1 = tree_entry_extract(t, &entry, mode);
167 update_tree_entry(t);
168 entrylen = tree_entry_len(entry, sha1);
169 if (entrylen > namelen)
170 continue;
171 cmp = memcmp(name, entry, entrylen);
172 if (cmp > 0)
173 continue;
174 if (cmp < 0)
175 break;
176 if (entrylen == namelen) {
177 hashcpy(result, sha1);
178 return 0;
179 }
180 if (name[entrylen] != '/')
181 continue;
182 if (!S_ISDIR(*mode))
183 break;
184 if (++entrylen == namelen) {
185 hashcpy(result, sha1);
186 return 0;
187 }
188 return get_tree_entry(sha1, name + entrylen, result, mode);
189 }
190 return -1;
191 }
192
193 int get_tree_entry(const unsigned char *tree_sha1, const char *name, unsigned char *sha1, unsigned *mode)
194 {
195 int retval;
196 void *tree;
197 unsigned long size;
198 struct tree_desc t;
199 unsigned char root[20];
200
201 tree = read_object_with_reference(tree_sha1, tree_type, &size, root);
202 if (!tree)
203 return -1;
204
205 if (name[0] == '\0') {
206 hashcpy(sha1, root);
207 return 0;
208 }
209
210 init_tree_desc(&t, tree, size);
211 retval = find_tree_entry(&t, name, sha1, mode);
212 free(tree);
213 return retval;
214 }