attr.c

   1 #include "cache.h"
   2 #include "attr.h"
   3
   4 /*
   5  * The basic design decision here is that we are not going to have
   6  * insanely large number of attributes.
   7  *
   8  * This is a randomly chosen prime.
   9  */
  10 #define HASHSIZE 257
  11
  12 #ifndef DEBUG_ATTR
  13 #define DEBUG_ATTR 0
  14 #endif
  15
  16 struct git_attr {
  17         struct git_attr *next;
  18         unsigned h;
  19         int attr_nr;
  20         char name[FLEX_ARRAY];
  21 };
  22 static int attr_nr;
  23
  24 static struct git_attr_check *check_all_attr;
  25 static struct git_attr *(git_attr_hash[HASHSIZE]);
  26
  27 static unsigned hash_name(const char *name, int namelen)
  28 {
  29         unsigned val = 0;
  30         unsigned char c;
  31
  32         while (namelen--) {
  33                 c = *name++;
  34                 val = ((val << 7) | (val >> 22)) ^ c;
  35         }
  36         return val;
  37 }
  38
  39 struct git_attr *git_attr(const char *name, int len)
  40 {
  41         unsigned hval = hash_name(name, len);
  42         unsigned pos = hval % HASHSIZE;
  43         struct git_attr *a;
  44
  45         for (a = git_attr_hash[pos]; a; a = a->next) {
  46                 if (a->h == hval &&
  47                     !memcmp(a->name, name, len) && !a->name[len])
  48                         return a;
  49         }
  50
  51         a = xmalloc(sizeof(*a) + len + 1);
  52         memcpy(a->name, name, len);
  53         a->name[len] = 0;
  54         a->h = hval;
  55         a->next = git_attr_hash[pos];
  56         a->attr_nr = attr_nr++;
  57         git_attr_hash[pos] = a;
  58
  59         check_all_attr = xrealloc(check_all_attr,
  60                                   sizeof(*check_all_attr) * attr_nr);
  61         check_all_attr[a->attr_nr].attr = a;
  62         return a;
  63 }
  64
  65 /*
  66  * .gitattributes file is one line per record, each of which is
  67  *
  68  * (1) glob pattern.
  69  * (2) whitespace
  70  * (3) whitespace separated list of attribute names, each of which
  71  *     could be prefixed with '!' to mean "not set".
  72  */
  73
  74 struct attr_state {
  75         int unset;
  76         struct git_attr *attr;
  77 };
  78
  79 struct match_attr {
  80         union {
  81                 char *pattern;
  82                 struct git_attr *attr;
  83         } u;
  84         char is_macro;
  85         unsigned num_attr;
  86         struct attr_state state[FLEX_ARRAY];
  87 };
  88
  89 static const char blank[] = " \t\r\n";
  90
  91 static struct match_attr *parse_attr_line(const char *line, const char *src,
  92                                           int lineno, int macro_ok)
  93 {
  94         int namelen;
  95         int num_attr;
  96         const char *cp, *name;
  97         struct match_attr *res = res;
  98         int pass;
  99         int is_macro;
 100
 101         cp = line + strspn(line, blank);
 102         if (!*cp || *cp == '#')
 103                 return NULL;
 104         name = cp;
 105         namelen = strcspn(name, blank);
 106         if (strlen(ATTRIBUTE_MACRO_PREFIX) < namelen &&
 107             !prefixcmp(name, ATTRIBUTE_MACRO_PREFIX)) {
 108                 if (!macro_ok) {
 109                         fprintf(stderr, "%s not allowed: %s:%d\n",
 110                                 name, src, lineno);
 111                         return NULL;
 112                 }
 113                 is_macro = 1;
 114                 name += strlen(ATTRIBUTE_MACRO_PREFIX);
 115                 name += strspn(name, blank);
 116                 namelen = strcspn(name, blank);
 117         }
 118         else
 119                 is_macro = 0;
 120
 121         for (pass = 0; pass < 2; pass++) {
 122                 /* pass 0 counts and allocates, pass 1 fills */
 123                 num_attr = 0;
 124                 cp = name + namelen;
 125                 cp = cp + strspn(cp, blank);
 126                 while (*cp) {
 127                         const char *ep;
 128                         ep = cp + strcspn(cp, blank);
 129                         if (pass) {
 130                                 struct attr_state *e;
 131
 132                                 e = &(res->state[num_attr]);
 133                                 if (*cp == '!') {
 134                                         e->unset = 1;
 135                                         cp++;
 136                                 }
 137                                 e->attr = git_attr(cp, ep - cp);
 138                         }
 139                         num_attr++;
 140                         cp = ep + strspn(ep, blank);
 141                 }
 142                 if (pass)
 143                         break;
 144
 145                 res = xcalloc(1,
 146                               sizeof(*res) +
 147                               sizeof(struct attr_state) * num_attr +
 148                               (is_macro ? 0 : namelen + 1));
 149                 if (is_macro)
 150                         res->u.attr = git_attr(name, namelen);
 151                 else {
 152                         res->u.pattern = (char*)&(res->state[num_attr]);
 153                         memcpy(res->u.pattern, name, namelen);
 154                         res->u.pattern[namelen] = 0;
 155                 }
 156                 res->is_macro = is_macro;
 157                 res->num_attr = num_attr;
 158         }
 159         return res;
 160 }
 161
 162 /*
 163  * Like info/exclude and .gitignore, the attribute information can
 164  * come from many places.
 165  *
 166  * (1) .gitattribute file of the same directory;
 167  * (2) .gitattribute file of the parent directory if (1) does not have any match;
 168  *     this goes recursively upwards, just like .gitignore
 169  * (3) perhaps $GIT_DIR/info/attributes, as the final fallback.
 170  *
 171  * In the same file, later entries override the earlier match, so in the
 172  * global list, we would have entries from info/attributes the earliest
 173  * (reading the file from top to bottom), .gitattribute of the root
 174  * directory (again, reading the file from top to bottom) down to the
 175  * current directory, and then scan the list backwards to find the first match.
 176  * This is exactly the same as what excluded() does in dir.c to deal with
 177  * .gitignore
 178  */
 179
 180 static struct attr_stack {
 181         struct attr_stack *prev;
 182         char *origin;
 183         unsigned num_matches;
 184         struct match_attr **attrs;
 185 } *attr_stack;
 186
 187 static void free_attr_elem(struct attr_stack *e)
 188 {
 189         int i;
 190         free(e->origin);
 191         for (i = 0; i < e->num_matches; i++)
 192                 free(e->attrs[i]);
 193         free(e);
 194 }
 195
 196 static const char *builtin_attr[] = {
 197         NULL,
 198 };
 199
 200 static struct attr_stack *read_attr_from_array(const char **list)
 201 {
 202         struct attr_stack *res;
 203         const char *line;
 204         int lineno = 0;
 205
 206         res = xcalloc(1, sizeof(*res));
 207         while ((line = *(list++)) != NULL) {
 208                 struct match_attr *a;
 209
 210                 a = parse_attr_line(line, "[builtin]", ++lineno, 1);
 211                 if (!a)
 212                         continue;
 213                 res->attrs = xrealloc(res->attrs, res->num_matches + 1);
 214                 res->attrs[res->num_matches++] = a;
 215         }
 216         return res;
 217 }
 218
 219 static struct attr_stack *read_attr_from_file(const char *path, int macro_ok)
 220 {
 221         FILE *fp;
 222         struct attr_stack *res;
 223         char buf[2048];
 224         int lineno = 0;
 225
 226         res = xcalloc(1, sizeof(*res));
 227         fp = fopen(path, "r");
 228         if (!fp)
 229                 return res;
 230
 231         while (fgets(buf, sizeof(buf), fp)) {
 232                 struct match_attr *a;
 233
 234                 a = parse_attr_line(buf, path, ++lineno, macro_ok);
 235                 if (!a)
 236                         continue;
 237                 res->attrs = xrealloc(res->attrs, res->num_matches + 1);
 238                 res->attrs[res->num_matches++] = a;
 239         }
 240         fclose(fp);
 241         return res;
 242 }
 243
 244 #if DEBUG_ATTR
 245 static void debug_info(const char *what, struct attr_stack *elem)
 246 {
 247         fprintf(stderr, "%s: %s\n", what, elem->origin ? elem->origin : "()");
 248 }
 249 static void debug_set(const char *what, const char *match, struct git_attr *attr, int set)
 250 {
 251         fprintf(stderr, "%s: %s => %d (%s)\n",
 252                 what, attr->name, set, match);
 253 }
 254 #define debug_push(a) debug_info("push", (a))
 255 #define debug_pop(a) debug_info("pop", (a))
 256 #else
 257 #define debug_push(a) do { ; } while (0)
 258 #define debug_pop(a) do { ; } while (0)
 259 #define debug_set(a,b,c,d) do { ; } while (0)
 260 #endif
 261
 262 static void bootstrap_attr_stack(void)
 263 {
 264         if (!attr_stack) {
 265                 struct attr_stack *elem;
 266
 267                 elem = read_attr_from_array(builtin_attr);
 268                 elem->origin = NULL;
 269                 elem->prev = attr_stack;
 270                 attr_stack = elem;
 271
 272                 elem = read_attr_from_file(GITATTRIBUTES_FILE, 1);
 273                 elem->origin = strdup("");
 274                 elem->prev = attr_stack;
 275                 attr_stack = elem;
 276                 debug_push(elem);
 277
 278                 elem = read_attr_from_file(git_path(INFOATTRIBUTES_FILE), 1);
 279                 elem->origin = NULL;
 280                 elem->prev = attr_stack;
 281                 attr_stack = elem;
 282         }
 283 }
 284
 285 static void prepare_attr_stack(const char *path, int dirlen)
 286 {
 287         struct attr_stack *elem, *info;
 288         int len;
 289         char pathbuf[PATH_MAX];
 290
 291         /*
 292          * At the bottom of the attribute stack is the built-in
 293          * set of attribute definitions.  Then, contents from
 294          * .gitattribute files from directories closer to the
 295          * root to the ones in deeper directories are pushed
 296          * to the stack.  Finally, at the very top of the stack
 297          * we always keep the contents of $GIT_DIR/info/attributes.
 298          *
 299          * When checking, we use entries from near the top of the
 300          * stack, preferring $GIT_DIR/info/attributes, then
 301          * .gitattributes in deeper directories to shallower ones,
 302          * and finally use the built-in set as the default.
 303          */
 304         if (!attr_stack)
 305                 bootstrap_attr_stack();
 306
 307         /*
 308          * Pop the "info" one that is always at the top of the stack.
 309          */
 310         info = attr_stack;
 311         attr_stack = info->prev;
 312
 313         /*
 314          * Pop the ones from directories that are not the prefix of
 315          * the path we are checking.
 316          */
 317         while (attr_stack && attr_stack->origin) {
 318                 int namelen = strlen(attr_stack->origin);
 319
 320                 elem = attr_stack;
 321                 if (namelen <= dirlen &&
 322                     !strncmp(elem->origin, path, namelen))
 323                         break;
 324
 325                 debug_pop(elem);
 326                 attr_stack = elem->prev;
 327                 free_attr_elem(elem);
 328         }
 329
 330         /*
 331          * Read from parent directories and push them down
 332          */
 333         while (1) {
 334                 char *cp;
 335
 336                 len = strlen(attr_stack->origin);
 337                 if (dirlen <= len)
 338                         break;
 339                 memcpy(pathbuf, path, dirlen);
 340                 memcpy(pathbuf + dirlen, "/", 2);
 341                 cp = strchr(pathbuf + len + 1, '/');
 342                 strcpy(cp + 1, GITATTRIBUTES_FILE);
 343                 elem = read_attr_from_file(pathbuf, 0);
 344                 *cp = '\0';
 345                 elem->origin = strdup(pathbuf);
 346                 elem->prev = attr_stack;
 347                 attr_stack = elem;
 348                 debug_push(elem);
 349         }
 350
 351         /*
 352          * Finally push the "info" one at the top of the stack.
 353          */
 354         info->prev = attr_stack;
 355         attr_stack = info;
 356 }
 357
 358 static int path_matches(const char *pathname, int pathlen,
 359                         const char *pattern,
 360                         const char *base, int baselen)
 361 {
 362         if (!strchr(pattern, '/')) {
 363                 /* match basename */
 364                 const char *basename = strrchr(pathname, '/');
 365                 basename = basename ? basename + 1 : pathname;
 366                 return (fnmatch(pattern, basename, 0) == 0);
 367         }
 368         /*
 369          * match with FNM_PATHNAME; the pattern has base implicitly
 370          * in front of it.
 371          */
 372         if (*pattern == '/')
 373                 pattern++;
 374         if (pathlen < baselen ||
 375             (baselen && pathname[baselen - 1] != '/') ||
 376             strncmp(pathname, base, baselen))
 377                 return 0;
 378         return fnmatch(pattern, pathname + baselen, FNM_PATHNAME) == 0;
 379 }
 380
 381 static int fill(const char *path, int pathlen, struct attr_stack *stk, int rem)
 382 {
 383         const char *base = stk->origin ? stk->origin : "";
 384         int i, j;
 385         struct git_attr_check *check = check_all_attr;
 386
 387         for (i = stk->num_matches - 1; 0 < rem && 0 <= i; i--) {
 388                 struct match_attr *a = stk->attrs[i];
 389                 if (a->is_macro)
 390                         continue;
 391                 if (path_matches(path, pathlen,
 392                                  a->u.pattern, base, strlen(base))) {
 393                         for (j = 0; 0 < rem && j < a->num_attr; j++) {
 394                                 struct git_attr *attr = a->state[j].attr;
 395                                 int set = !a->state[j].unset;
 396                                 int *n = &(check[attr->attr_nr].isset);
 397
 398                                 if (*n < 0) {
 399                                         debug_set("fill", a->u.pattern, attr, set);
 400                                         *n = set;
 401                                         rem--;
 402                                 }
 403                         }
 404                 }
 405         }
 406         return rem;
 407 }
 408
 409 static int macroexpand(struct attr_stack *stk, int rem)
 410 {
 411         int i, j;
 412         struct git_attr_check *check = check_all_attr;
 413
 414         for (i = stk->num_matches - 1; 0 < rem && 0 <= i; i--) {
 415                 struct match_attr *a = stk->attrs[i];
 416                 if (!a->is_macro)
 417                         continue;
 418                 if (check[a->u.attr->attr_nr].isset < 0)
 419                         continue;
 420                 for (j = 0; 0 < rem && j < a->num_attr; j++) {
 421                         struct git_attr *attr = a->state[j].attr;
 422                         int set = !a->state[j].unset;
 423                         int *n = &(check[attr->attr_nr].isset);
 424
 425                         if (*n < 0) {
 426                                 debug_set("expand", a->u.attr->name, attr, set);
 427                                 *n = set;
 428                                 rem--;
 429                         }
 430                 }
 431         }
 432         return rem;
 433 }
 434
 435 int git_checkattr(const char *path, int num, struct git_attr_check *check)
 436 {
 437         struct attr_stack *stk;
 438         const char *cp;
 439         int dirlen, pathlen, i, rem;
 440
 441         bootstrap_attr_stack();
 442         for (i = 0; i < attr_nr; i++)
 443                 check_all_attr[i].isset = -1;
 444
 445         pathlen = strlen(path);
 446         cp = strrchr(path, '/');
 447         if (!cp)
 448                 dirlen = 0;
 449         else
 450                 dirlen = cp - path;
 451         prepare_attr_stack(path, dirlen);
 452         rem = attr_nr;
 453         for (stk = attr_stack; 0 < rem && stk; stk = stk->prev)
 454                 rem = fill(path, pathlen, stk, rem);
 455
 456         for (stk = attr_stack; 0 < rem && stk; stk = stk->prev)
 457                 rem = macroexpand(stk, rem);
 458
 459         for (i = 0; i < num; i++)
 460                 check[i].isset = check_all_attr[check[i].attr->attr_nr].isset;
 461
 462         return 0;
 463 }