cleanups: Fix potential bugs in connect.c
[git] / tree-walk.c
1 #include "cache.h"
2 #include "tree-walk.h"
3 #include "tree.h"
4
5 void *fill_tree_descriptor(struct tree_desc *desc, const unsigned char *sha1)
6 {
7         unsigned long size = 0;
8         void *buf = NULL;
9
10         if (sha1) {
11                 buf = read_object_with_reference(sha1, tree_type, &size, NULL);
12                 if (!buf)
13                         die("unable to read tree %s", sha1_to_hex(sha1));
14         }
15         desc->size = size;
16         desc->buf = buf;
17         return buf;
18 }
19
20 static int entry_compare(struct name_entry *a, struct name_entry *b)
21 {
22         return base_name_compare(
23                         a->path, a->pathlen, a->mode,
24                         b->path, b->pathlen, b->mode);
25 }
26
27 static void entry_clear(struct name_entry *a)
28 {
29         memset(a, 0, sizeof(*a));
30 }
31
32 static void entry_extract(struct tree_desc *t, struct name_entry *a)
33 {
34         a->sha1 = tree_entry_extract(t, &a->path, &a->mode);
35         a->pathlen = strlen(a->path);
36 }
37
38 void update_tree_entry(struct tree_desc *desc)
39 {
40         void *buf = desc->buf;
41         unsigned long size = desc->size;
42         int len = strlen(buf) + 1 + 20;
43
44         if (size < len)
45                 die("corrupt tree file");
46         desc->buf = buf + len;
47         desc->size = size - len;
48 }
49
50 const unsigned char *tree_entry_extract(struct tree_desc *desc, const char **pathp, unsigned int *modep)
51 {
52         void *tree = desc->buf;
53         unsigned long size = desc->size;
54         int len = strlen(tree)+1;
55         const unsigned char *sha1 = tree + len;
56         const char *path = strchr(tree, ' ');
57         unsigned int mode;
58
59         if (!path || size < len + 20 || sscanf(tree, "%o", &mode) != 1)
60                 die("corrupt tree file");
61         *pathp = path+1;
62         *modep = canon_mode(mode);
63         return sha1;
64 }
65
66 void traverse_trees(int n, struct tree_desc *t, const char *base, traverse_callback_t callback)
67 {
68         struct name_entry *entry = xmalloc(n*sizeof(*entry));
69
70         for (;;) {
71                 struct name_entry entry[3];
72                 unsigned long mask = 0;
73                 int i, last;
74
75                 last = -1;
76                 for (i = 0; i < n; i++) {
77                         if (!t[i].size)
78                                 continue;
79                         entry_extract(t+i, entry+i);
80                         if (last >= 0) {
81                                 int cmp = entry_compare(entry+i, entry+last);
82
83                                 /*
84                                  * Is the new name bigger than the old one?
85                                  * Ignore it
86                                  */
87                                 if (cmp > 0)
88                                         continue;
89                                 /*
90                                  * Is the new name smaller than the old one?
91                                  * Ignore all old ones
92                                  */
93                                 if (cmp < 0)
94                                         mask = 0;
95                         }
96                         mask |= 1ul << i;
97                         last = i;
98                 }
99                 if (!mask)
100                         break;
101
102                 /*
103                  * Update the tree entries we've walked, and clear
104                  * all the unused name-entries.
105                  */
106                 for (i = 0; i < n; i++) {
107                         if (mask & (1ul << i)) {
108                                 update_tree_entry(t+i);
109                                 continue;
110                         }
111                         entry_clear(entry + i);
112                 }
113                 callback(n, mask, entry, base);
114         }
115         free(entry);
116 }
117