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 df_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 setup_traverse_info(struct traverse_info *info, const char *base)
 108 {
 109         int pathlen = strlen(base);
 110         static struct traverse_info dummy;
 111
 112         memset(info, 0, sizeof(*info));
 113         if (pathlen && base[pathlen-1] == '/')
 114                 pathlen--;
 115         info->pathlen = pathlen ? pathlen + 1 : 0;
 116         info->name.path = base;
 117         info->name.sha1 = (void *)(base + pathlen + 1);
 118         if (pathlen)
 119                 info->prev = &dummy;
 120 }
 121
 122 char *make_traverse_path(char *path, const struct traverse_info *info, const struct name_entry *n)
 123 {
 124         int len = tree_entry_len(n->path, n->sha1);
 125         int pathlen = info->pathlen;
 126
 127         path[pathlen + len] = 0;
 128         for (;;) {
 129                 memcpy(path + pathlen, n->path, len);
 130                 if (!pathlen)
 131                         break;
 132                 path[--pathlen] = '/';
 133                 n = &info->name;
 134                 len = tree_entry_len(n->path, n->sha1);
 135                 info = info->prev;
 136                 pathlen -= len;
 137         }
 138         return path;
 139 }
 140
 141 int traverse_trees(int n, struct tree_desc *t, struct traverse_info *info)
 142 {
 143         int ret = 0;
 144         struct name_entry *entry = xmalloc(n*sizeof(*entry));
 145
 146         for (;;) {
 147                 unsigned long mask = 0;
 148                 unsigned long dirmask = 0;
 149                 int i, last;
 150
 151                 last = -1;
 152                 for (i = 0; i < n; i++) {
 153                         if (!t[i].size)
 154                                 continue;
 155                         entry_extract(t+i, entry+i);
 156                         if (last >= 0) {
 157                                 int cmp = entry_compare(entry+i, entry+last);
 158
 159                                 /*
 160                                  * Is the new name bigger than the old one?
 161                                  * Ignore it
 162                                  */
 163                                 if (cmp > 0)
 164                                         continue;
 165                                 /*
 166                                  * Is the new name smaller than the old one?
 167                                  * Ignore all old ones
 168                                  */
 169                                 if (cmp < 0)
 170                                         mask = 0;
 171                         }
 172                         mask |= 1ul << i;
 173                         if (S_ISDIR(entry[i].mode))
 174                                 dirmask |= 1ul << i;
 175                         last = i;
 176                 }
 177                 if (!mask)
 178                         break;
 179                 dirmask &= mask;
 180
 181                 /*
 182                  * Clear all the unused name-entries.
 183                  */
 184                 for (i = 0; i < n; i++) {
 185                         if (mask & (1ul << i))
 186                                 continue;
 187                         entry_clear(entry + i);
 188                 }
 189                 ret = info->fn(n, mask, dirmask, entry, info);
 190                 if (ret < 0)
 191                         break;
 192                 if (ret)
 193                         mask &= ret;
 194                 ret = 0;
 195                 for (i = 0; i < n; i++) {
 196                         if (mask & (1ul << i))
 197                                 update_tree_entry(t + i);
 198                 }
 199         }
 200         free(entry);
 201         return ret;
 202 }
 203
 204 static int find_tree_entry(struct tree_desc *t, const char *name, unsigned char *result, unsigned *mode)
 205 {
 206         int namelen = strlen(name);
 207         while (t->size) {
 208                 const char *entry;
 209                 const unsigned char *sha1;
 210                 int entrylen, cmp;
 211
 212                 sha1 = tree_entry_extract(t, &entry, mode);
 213                 update_tree_entry(t);
 214                 entrylen = tree_entry_len(entry, sha1);
 215                 if (entrylen > namelen)
 216                         continue;
 217                 cmp = memcmp(name, entry, entrylen);
 218                 if (cmp > 0)
 219                         continue;
 220                 if (cmp < 0)
 221                         break;
 222                 if (entrylen == namelen) {
 223                         hashcpy(result, sha1);
 224                         return 0;
 225                 }
 226                 if (name[entrylen] != '/')
 227                         continue;
 228                 if (!S_ISDIR(*mode))
 229                         break;
 230                 if (++entrylen == namelen) {
 231                         hashcpy(result, sha1);
 232                         return 0;
 233                 }
 234                 return get_tree_entry(sha1, name + entrylen, result, mode);
 235         }
 236         return -1;
 237 }
 238
 239 int get_tree_entry(const unsigned char *tree_sha1, const char *name, unsigned char *sha1, unsigned *mode)
 240 {
 241         int retval;
 242         void *tree;
 243         unsigned long size;
 244         struct tree_desc t;
 245         unsigned char root[20];
 246
 247         tree = read_object_with_reference(tree_sha1, tree_type, &size, root);
 248         if (!tree)
 249                 return -1;
 250
 251         if (name[0] == '\0') {
 252                 hashcpy(sha1, root);
 253                 return 0;
 254         }
 255
 256         init_tree_desc(&t, tree, size);
 257         retval = find_tree_entry(&t, name, sha1, mode);
 258         free(tree);
 259         return retval;
 260 }