forked from git/git
-
Notifications
You must be signed in to change notification settings - Fork 175
Expand file tree
/
Copy pathattr.c
More file actions
1367 lines (1165 loc) · 34.3 KB
/
attr.c
File metadata and controls
1367 lines (1165 loc) · 34.3 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
4
10BC0
10
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
/*
* Handle git attributes. See gitattributes(5) for a description of
* the file syntax, and attr.h for a description of the API.
*
* One basic design decision here is that we are not going to support
* an insanely large number of attributes.
*/
#define USE_THE_REPOSITORY_VARIABLE
#define DISABLE_SIGN_COMPARE_WARNINGS
#include "git-compat-util.h"
#include "config.h"
#include "environment.h"
#include "exec-cmd.h"
#include "attr.h"
#include "dir.h"
#include "gettext.h"
#include "path.h"
#include "utf8.h"
#include "quote.h"
#include "read-cache-ll.h"
#include "refs.h"
#include &
6880
quot;revision.h"
#include "odb.h"
#include "setup.h"
#include "thread-utils.h"
#include "tree-walk.h"
#include "object-name.h"
char *git_attr_tree;
const char git_attr__true[] = "(builtin)true";
const char git_attr__false[] = "\0(builtin)false";
static const char git_attr__unknown[] = "(builtin)unknown";
#define ATTR__TRUE git_attr__true
#define ATTR__FALSE git_attr__false
#define ATTR__UNSET NULL
#define ATTR__UNKNOWN git_attr__unknown
struct git_attr {
unsigned int attr_nr; /* unique attribute number */
char name[FLEX_ARRAY]; /* attribute name */
};
const char *git_attr_name(const struct git_attr *attr)
{
return attr->name;
}
struct attr_hashmap {
struct hashmap map;
pthread_mutex_t mutex;
};
static inline void hashmap_lock(struct attr_hashmap *map)
{
pthread_mutex_lock(&map->mutex);
}
static inline void hashmap_unlock(struct attr_hashmap *map)
{
pthread_mutex_unlock(&map->mutex);
}
/* The container for objects stored in "struct attr_hashmap" */
struct attr_hash_entry {
struct hashmap_entry ent;
const char *key; /* the key; memory should be owned by value */
size_t keylen; /* length of the key */
void *value; /* the stored value */
};
/* attr_hashmap comparison function */
static int attr_hash_entry_cmp(const void *cmp_data UNUSED,
const struct hashmap_entry *eptr,
const struct hashmap_entry *entry_or_key,
const void *keydata UNUSED)
{
const struct attr_hash_entry *a, *b;
a = container_of(eptr, const struct attr_hash_entry, ent);
b = container_of(entry_or_key, const struct attr_hash_entry, ent);
return (a->keylen != b->keylen) || strncmp(a->key, b->key, a->keylen);
}
/*
* The global dictionary of all interned attributes. This
* is a singleton object which is shared between threads.
* Access to this dictionary must be surrounded with a mutex.
*/
static struct attr_hashmap g_attr_hashmap = {
.map = HASHMAP_INIT(attr_hash_entry_cmp, NULL),
};
/*
* Retrieve the 'value' stored in a hashmap given the provided 'key'.
* If there is no matching entry, return NULL.
*/
static void *attr_hashmap_get(struct attr_hashmap *map,
const char *key, size_t keylen)
{
struct attr_hash_entry k;
struct attr_hash_entry *e;
hashmap_entry_init(&k.ent, memhash(key, keylen));
k.key = key;
k.keylen = keylen;
e = hashmap_get_entry(&map->map, &k, ent, NULL);
return e ? e->value : NULL;
}
/* Add 'value' to a hashmap based on the provided 'key'. */
static void attr_hashmap_add(struct attr_hashmap *map,
const char *key, size_t keylen,
void *value)
{
struct attr_hash_entry *e;
e = xmalloc(sizeof(struct attr_hash_entry));
hashmap_entry_init(&e->ent, memhash(key, keylen));
e->key = key;
e->keylen = keylen;
e->value = value;
hashmap_add(&map->map, &e->ent);
}
struct all_attrs_item {
const struct git_attr *attr;
const char *value;
/*
* If 'macro' is non-NULL, indicates that 'attr' is a macro based on
* the current attribute stack and contains a pointer to the match_attr
* definition of the macro
*/
const struct match_attr *macro;
};
/*
* Reallocate and reinitialize the array of all attributes (which is used in
* the attribute collection process) in 'check' based on the global dictionary
* of attributes.
*/
static void all_attrs_init(struct attr_hashmap *map, struct attr_check *check)
{
int i;
unsigned int size;
hashmap_lock(map);
size = hashmap_get_size(&map->map);
if (size < check->all_attrs_nr)
BUG("interned attributes shouldn't be deleted");
/*
* If the number of attributes in the global dictionary has increased
* (or this attr_check instance doesn't have an initialized all_attrs
* field), reallocate the provided attr_check instance's all_attrs
* field and fill each entry with its corresponding git_attr.
*/
if (size != check->all_attrs_nr) {
struct attr_hash_entry *e;
struct hashmap_iter iter;
REALLOC_ARRAY(check->all_attrs, size);
check->all_attrs_nr = size;
hashmap_for_each_entry(&map->map, &iter, e,
ent /* member name */) {
const struct git_attr *a = e->value;
check->all_attrs[a->attr_nr].attr = a;
}
}
hashmap_unlock(map);
/*
* Re-initialize every entry in check->all_attrs.
* This re-initialization can live outside of the locked region since
* the attribute dictionary is no longer being accessed.
*/
for (i = 0; i < check->all_attrs_nr; i++) {
check->all_attrs[i].value = ATTR__UNKNOWN;
check->all_attrs[i].macro = NULL;
}
}
/*
* Attribute name cannot begin with "builtin_" which
* is a reserved namespace for built in attributes values.
*/
static int attr_name_reserved(const char *name)
{
return starts_with(name, "builtin_");
}
static int attr_name_valid(const char *name, size_t namelen)
{
/*
* Attribute name cannot begin with '-' and must consist of
* characters from [-A-Za-z0-9_.].
*/
if (namelen <= 0 || *name == '-')
return 0;
while (namelen--) {
char ch = *name++;
if (! (ch == '-' || ch == '.' || ch == '_' ||
('0' <= ch && ch <= '9') ||
('a' <= ch && ch <= 'z') ||
('A' <= ch && ch <= 'Z')) )
return 0;
}
return 1;
}
static void report_invalid_attr(const char *name, size_t len,
const char *src, int lineno)
{
struct strbuf err = STRBUF_INIT;
strbuf_addf(&err, _("%.*s is not a valid attribute name"),
(int) len, name);
fprintf(stderr, "%s: %s:%d\n", err.buf, src, lineno);
strbuf_release(&err);
}
/*
* Given a 'name', lookup and return the corresponding attribute in the global
* dictionary. If no entry is found, create a new attribute and store it in
* the dictionary.
*/
static const struct git_attr *git_attr_internal(const char *name, size_t namelen)
{
struct git_attr *a;
if (!attr_name_valid(name, namelen))
return NULL;
hashmap_lock(&g_attr_hashmap);
a = attr_hashmap_get(&g_attr_hashmap, name, namelen);
if (!a) {
FLEX_ALLOC_MEM(a, name, name, namelen);
a->attr_nr = hashmap_get_size(&g_attr_hashmap.map);
attr_hashmap_add(&g_attr_hashmap, a->name, namelen, a);
if (a->attr_nr != hashmap_get_size(&g_attr_hashmap.map) - 1)
die(_("unable to add additional attribute"));
}
hashmap_unlock(&g_attr_hashmap);
return a;
}
const struct git_attr *git_attr(const char *name)
{
return git_attr_internal(name, strlen(name));
}
static const char blank[] = " \t\r\n";
/* Flags usable in read_attr() and parse_attr_line() family of functions. */
#define READ_ATTR_MACRO_OK (1<<0)
#define READ_ATTR_NOFOLLOW (1<<1)
/*
* Parse a whitespace-delimited attribute state (i.e., "attr",
* "-attr", "!attr", or "attr=value") from the string starting at src.
* If e is not NULL, write the results to *e. Return a pointer to the
* remainder of the string (with leading whitespace removed), or NULL
* if there was an error.
*/
static const char *parse_attr(const char *src, int lineno, const char *cp,
struct attr_state *e)
{
const char *ep, *equals;
size_t len;
ep = cp + strcspn(cp, blank);
equals = strchr(cp, '=');
if (equals && ep < equals)
equals = NULL;
if (equals)
len = equals - cp;
else
len = ep - cp;
if (!e) {
if (*cp == '-' || *cp == '!') {
cp++;
len--;
}
if (!attr_name_valid(cp, len) || attr_name_reserved(cp)) {
report_invalid_attr(cp, len, src, lineno);
return NULL;
}
} else {
/*
* As this function is always called twice, once with
* e == NULL in the first pass and then e != NULL in
* the second pass, no need for attr_name_valid()
* check here.
*/
if (*cp == '-' || *cp == '!') {
e->setto = (*cp == '-') ? ATTR__FALSE : ATTR__UNSET;
cp++;
len--;
}
else if (!equals)
e->setto = ATTR__TRUE;
else {
e->setto = xmemdupz(equals + 1, ep - equals - 1);
}
e->attr = git_attr_internal(cp, len);
}
return ep + strspn(ep, blank);
}
struct match_attr *parse_attr_line(const char *line, const char *src,
int lineno, unsigned flags)
{
size_t namelen, num_attr, i;
const char *cp, *name, *states;
struct match_attr *res = NULL;
int is_macro;
struct strbuf pattern = STRBUF_INIT;
cp = line + strspn(line, blank);
if (!*cp || *cp == '#')
return NULL;
name = cp;
if (strlen(line) >= ATTR_MAX_LINE_LENGTH) {
warning(_("ignoring overly long attributes line %d"), lineno);
return NULL;
}
if (*cp == '"' && !unquote_c_style(&pattern, name, &states)) {
name = pattern.buf;
namelen = pattern.len;
} else {
namelen = strcspn(name, blank);
states = name + namelen;
}
if (strlen(ATTRIBUTE_MACRO_PREFIX) < namelen &&
starts_with(name, ATTRIBUTE_MACRO_PREFIX)) {
if (!(flags & READ_ATTR_MACRO_OK)) {
fprintf_ln(stderr, _("%s not allowed: %s:%d"),
name, src, lineno);
goto fail_return;
}
is_macro = 1;
name += strlen(ATTRIBUTE_MACRO_PREFIX);
name += strspn(name, blank);
namelen = strcspn(name, blank);
if (!attr_name_valid(name, namelen) || attr_name_reserved(name)) {
report_invalid_attr(name, namelen, src, lineno);
goto fail_return;
}
}
else
is_macro = 0;
states += strspn(states, blank);
/* First pass to count the attr_states */
for (cp = states, num_attr = 0; *cp; num_attr++) {
cp = parse_attr(src, lineno, cp, NULL);
if (!cp)
goto fail_return;
}
res = xcalloc(1, st_add3(sizeof(*res),
st_mult(sizeof(struct attr_state), num_attr),
is_macro ? 0 : namelen + 1));
if (is_macro) {
res->u.attr = git_attr_internal(name, namelen);
} else {
char *p = (char *)&(res->state[num_attr]);
memcpy(p, name, namelen);
res->u.pat.pattern = p;
parse_path_pattern(&res->u.pat.pattern,
&res->u.pat.patternlen,
&res->u.pat.flags,
&res->u.pat.nowildcardlen);
if (res->u.pat.flags & PATTERN_FLAG_NEGATIVE) {
warning(_("Negative patterns are ignored in git attributes\n"
"Use '\\!' for literal leading exclamation."));
goto fail_return;
}
}
res->is_macro = is_macro;
res->num_attr = num_attr;
/* Second pass to fill the attr_states */
for (cp = states, i = 0; *cp; i++) {
cp = parse_attr(src, lineno, cp, &(res->state[i]));
}
strbuf_release(&pattern);
return res;
fail_return:
strbuf_release(&pattern);
free(res);
return NULL;
}
/*
* Like info/exclude and .gitignore, the attribute information can
* come from many places.
*
* (1) .gitattributes file of the same directory;
* (2) .gitattributes file of the parent directory if (1) does not have
* any match; this goes recursively upwards, just like .gitignore.
* (3) $GIT_DIR/info/attributes, which overrides both of the above.
*
* In the same file, later entries override the earlier match, so in the
* global list, we would have entries from info/attributes the earliest
* (reading the file from top to bottom), .gitattributes of the root
* directory (again, reading the file from top to bottom) down to the
* current directory, and then scan the list backwards to find the first match.
* This is exactly the same as what is_excluded() does in dir.c to deal with
* .gitignore file and info/excludes file as a fallback.
*/
struct attr_stack {
struct attr_stack *prev;
char *origin;
size_t originlen;
unsigned num_matches;
unsigned alloc;
struct match_attr **attrs;
};
static void attr_stack_free(struct attr_stack *e)
{
unsigned i;
free(e->origin);
for (i = 0; i < e->num_matches; i++) {
struct match_attr *a = e->attrs[i];
size_t j;
for (j = 0; j < a->num_attr; j++) {
const char *setto = a->state[j].setto;
if (setto == ATTR__TRUE ||
setto == ATTR__FALSE ||
setto == ATTR__UNSET ||
setto == ATTR__UNKNOWN)
;
else
free((char *) setto);
}
free(a);
}
free(e->attrs);
free(e);
}
static void drop_attr_stack(struct attr_stack **stack)
{
while (*stack) {
struct attr_stack *elem = *stack;
*stack = elem->prev;
attr_stack_free(elem);
}
}
/* List of all attr_check structs; access should be surrounded by mutex */
static struct check_vector {
size_t nr;
size_t alloc;
struct attr_check **checks;
pthread_mutex_t mutex;
} check_vector;
static inline void vector_lock(void)
{
pthread_mutex_lock(&check_vector.mutex);
}
static inline void vector_unlock(void)
{
pthread_mutex_unlock(&check_vector.mutex);
}
static void check_vector_add(struct attr_check *c)
{
vector_lock();
ALLOC_GROW(check_vector.checks,
check_vector.nr + 1,
check_vector.alloc);
check_vector.checks[check_vector.nr++] = c;
vector_unlock();
}
static void check_vector_remove(struct attr_check *check)
{
int i;
vector_lock();
/* Find entry */
for (i = 0; i < check_vector.nr; i++)
if (check_vector.checks[i] == check)
break;
if (i >= check_vector.nr)
BUG("no entry found");
/* shift entries over */
for (; i < check_vector.nr - 1; i++)
check_vector.checks[i] = check_vector.checks[i + 1];
check_vector.nr--;
vector_unlock();
}
/* Iterate through all attr_check instances and drop their stacks */
static void drop_all_attr_stacks(void)
{
int i;
vector_lock();
for (i = 0; i < check_vector.nr; i++) {
drop_attr_stack(&check_vector.checks[i]->stack);
}
vector_unlock();
}
struct attr_check *attr_check_alloc(void)
{
struct attr_check *c = xcalloc(1, sizeof(struct attr_check));
/* save pointer to the check struct */
check_vector_add(c);
return c;
}
struct attr_check *attr_check_initl(const char *one, ...)
{
struct attr_check *check;
int cnt;
va_list params;
const char *param;
va_start(params, one);
for (cnt = 1; (param = va_arg(params, const char *)) != NULL; cnt++)
;
va_end(params);
check = attr_check_alloc();
check->nr = cnt;
check->alloc = cnt;
CALLOC_ARRAY(check->items, cnt);
check->items[0].attr = git_attr(one);
va_start(params, one);
for (cnt = 1; cnt < check->nr; cnt++) {
const struct git_attr *attr;
param = va_arg(params, const char *);
if (!param)
BUG("counted %d != ended at %d",
check->nr, cnt);
attr = git_attr(param);
if (!attr)
BUG("%s: not a valid attribute name", param);
check->items[cnt].attr = attr;
}
va_end(params);
return check;
}
struct attr_check *attr_check_dup(const struct attr_check *check)
{
struct attr_check *ret;
if (!check)
return NULL;
ret = attr_check_alloc();
ret->nr = check->nr;
ret->alloc = check->alloc;
DUP_ARRAY(ret->items, check->items, ret->nr);
return ret;
}
struct attr_check_item *attr_check_append(struct attr_check *check,
const struct git_attr *attr)
{
struct attr_check_item *item;
ALLOC_GROW(check->items, check->nr + 1, check->alloc);
item = &check->items[check->nr++];
item->attr = attr;
return item;
}
void attr_check_reset(struct attr_check *check)
{
check->nr = 0;
}
void attr_check_clear(struct attr_check *check)
{
FREE_AND_NULL(check->items);
check->alloc = 0;
check->nr = 0;
FREE_AND_NULL(check->all_attrs);
check->all_attrs_nr = 0;
drop_attr_stack(&check->stack);
}
void attr_check_free(struct attr_check *check)
{
if (check) {
/* Remove check from the check vector */
check_vector_remove(check);
attr_check_clear(check);
free(check);
}
}
static const char *builtin_attr[] = {
"[attr]binary -diff -merge -text",
NULL,
};
static void handle_attr_line(struct attr_stack *res,
const char *line,
const char *src,
int lineno,
unsigned flags)
{
struct match_attr *a;
a = parse_attr_line(line, src, lineno, flags);
if (!a)
return;
ALLOC_GROW_BY(res->attrs, res->num_matches, 1, res->alloc);
res->attrs[res->num_matches - 1] = a;
}
static struct attr_stack *read_attr_from_array(const char **list)
{
struct attr_stack *res;
const char *line;
int lineno = 0;
CALLOC_ARRAY(res, 1);
while ((line = *(list++)) != NULL)
handle_attr_line(res, line, "[builtin]", ++lineno,
READ_ATTR_MACRO_OK);
return res;
}
/*
* Callers into the attribute system assume there is a single, system-wide
* global state where attributes are read from and when the state is flipped by
* calling git_attr_set_direction(), the stack frames that have been
* constructed need to be discarded so that subsequent calls into the
* attribute system will lazily read from the right place. Since changing
* direction causes a global paradigm shift, it should not ever be called while
* another thread could potentially be calling into the attribute system.
*/
static enum git_attr_direction direction;
void git_attr_set_direction(enum git_attr_direction new_direction)
{
if (is_bare_repository() && new_direction != GIT_ATTR_INDEX)
BUG("non-INDEX attr direction in a bare repo");
if (new_direction != direction)
drop_all_attr_stacks();
direction = new_direction;
}
static struct attr_stack *read_attr_from_file(const char *path, unsigned flags)
{
struct strbuf buf = STRBUF_INIT;
int fd;
FILE *fp;
struct attr_stack *res;
int lineno = 0;
struct stat st;
if (flags & READ_ATTR_NOFOLLOW)
fd = open_nofollow(path, O_RDONLY);
else
fd = open(path, O_RDONLY);
if (fd < 0) {
warn_on_fopen_errors(path);
return NULL;
}
fp = xfdopen(fd, "r");
if (fstat(fd, &st)) {
warning_errno(_("cannot fstat gitattributes file '%s'"), path);
fclose(fp);
return NULL;
}
if (st.st_size >= ATTR_MAX_FILE_SIZE) {
warning(_("ignoring overly large gitattributes file '%s'"), path);
fclose(fp);
return NULL;
}
CALLOC_ARRAY(res, 1);
while (strbuf_getline(&buf, fp) != EOF) {
if (!lineno && starts_with(buf.buf, utf8_bom))
strbuf_remove(&buf, 0, strlen(utf8_bom));
handle_attr_line(res, buf.buf, path, ++lineno, flags);
}
fclose(fp);
strbuf_release(&buf);
return res;
}
static struct attr_stack *read_attr_from_buf(char *buf, size_t length,
const char *path, unsigned flags)
{
struct attr_stack *res;
char *sp;
int lineno = 0;
if (!buf)
return NULL;
if (length >= ATTR_MAX_FILE_SIZE) {
warning(_("ignoring overly large gitattributes blob '%s'"), path);
free(buf);
return NULL;
}
CALLOC_ARRAY(res, 1);
for (sp = buf; *sp;) {
char *ep;
int more;
ep = strchrnul(sp, '\n');
more = (*ep == '\n');
*ep = '\0';
handle_attr_line(res, sp, path, ++lineno, flags);
sp = ep + more;
}
free(buf);
return res;
}
static struct attr_stack *read_attr_from_blob(struct index_state *istate,
const struct object_id *tree_oid,
const char *path, unsigned flags)
{
struct object_id oid;
unsigned long sz;
enum object_type type;
void *buf;
unsigned short mode;
if (!tree_oid)
return NULL;
if (get_tree_entry(istate->repo, tree_oid, path, &oid, &mode))
return NULL;
buf = odb_read_object(istate->repo->objects, &oid, &type, &sz);
if (!buf || type != OBJ_BLOB) {
free(buf);
return NULL;
}
return read_attr_from_buf(buf, sz, path, flags);
}
static struct attr_stack *read_attr_from_index(struct index_state *istate,
const char *path, unsigned flags)
{
struct attr_stack *stack = NULL;
char *buf;
unsigned long size;
int sparse_dir_pos = -1;
if (!istate)
return NULL;
/*
* When handling sparse-checkouts, .gitattributes files
* may reside within a sparse directory. We distinguish
* whether a path exists directly in the index or not by
* evaluating if 'pos' is negative.
* If 'pos' is negative, the path is not directly present
* in the index and is likely within a sparse directory.
* For paths not in the index, The absolute value of 'pos'
* minus 1 gives us the position where the path would be
* inserted in lexicographic order within the index.
* We then subtract another 1 from this value
* (sparse_dir_pos = -pos - 2) to find the position of the
* last index entry which is lexicographically smaller than
* the path. This would be the sparse directory containing
* the path. By identifying the sparse directory containing
* the path, we can correctly read the attributes specified
* in the .gitattributes file from the tree object of the
* sparse directory.
*/
if (!path_in_cone_mode_sparse_checkout(path, istate)) {
int pos = index_name_pos_sparse(istate, path, strlen(path));
if (pos < 0)
sparse_dir_pos = -pos - 2;
}
if (sparse_dir_pos >= 0 &&
S_ISSPARSEDIR(istate->cache[sparse_dir_pos]->ce_mode) &&
!strncmp(istate->cache[sparse_dir_pos]->name, path, ce_namelen(istate->cache[sparse_dir_pos]))) {
const char *relative_path = path + ce_namelen(istate->cache[sparse_dir_pos]);
stack = read_attr_from_blob(istate, &istate->cache[sparse_dir_pos]->oid, relative_path, flags);
} else {
buf = read_blob_data_from_index(istate, path, &size);
if (buf)
stack = read_attr_from_buf(buf, size, path, flags);
}
return stack;
}
static struct attr_stack *read_attr(struct index_state *istate,
const struct object_id *tree_oid,
const char *path, unsigned flags)
{
struct attr_stack *res = NULL;
if (direction == GIT_ATTR_INDEX) {
res = read_attr_from_index(istate, path, flags);
} else if (tree_oid) {
res = read_attr_from_blob(istate, tree_oid, path, flags);
} else if (!is_bare_repository()) {
if (direction == GIT_ATTR_CHECKOUT) {
res = read_attr_from_index(istate, path, flags);
if (!res)
res = read_attr_from_file(path, flags);
} else if (direction == GIT_ATTR_CHECKIN) {
res = read_attr_from_file(path, flags);
if (!res)
/*
* There is no checked out .gitattributes file
* there, but we might have it in the index.
* We allow operation in a sparsely checked out
* work tree, so read from it.
*/
res = read_attr_from_index(istate, path, flags);
}
}
if (!res)
CALLOC_ARRAY(res, 1);
return res;
}
const char *git_attr_system_file(void)
{
static const char *system_wide;
if (!system_wide)
system_wide = system_path(ETC_GITATTRIBUTES);
return system_wide;
}
const char *git_attr_global_file(void)
{
struct repo_config_values *cfg = repo_config_values(the_repository);
if (!cfg->attributes_file)
cfg->attributes_file = xdg_config_home("attributes");
return cfg->attributes_file;
}
int git_attr_system_is_enabled(void)
{
return !git_env_bool("GIT_ATTR_NOSYSTEM", 0);
}
static GIT_PATH_FUNC(git_path_info_attributes, INFOATTRIBUTES_FILE)
static void push_stack(struct attr_stack **attr_stack_p,
struct attr_stack *elem, char *origin, size_t originlen)
{
if (elem) {
elem->origin = origin;
if (origin)
elem->originlen = originlen;
elem->prev = *attr_stack_p;
*attr_stack_p = elem;
}
}
static void bootstrap_attr_stack(struct index_state *istate,
const struct object_id *tree_oid,
struct attr_stack **stack)
{
struct attr_stack *e;
unsigned flags = READ_ATTR_MACRO_OK;
if (*stack)
return;
/* builtin frame */
e = read_attr_from_array(builtin_attr);
push_stack(stack, e, NULL, 0);
/* system-wide frame */
if (git_attr_system_is_enabled()) {
e = read_attr_from_file(git_attr_system_file(), flags);
push_stack(stack, e, NULL, 0);
}
/* home directory */
if (git_attr_global_file()) {
e = read_attr_from_file(git_attr_global_file(), flags);
push_stack(stack, e, NULL, 0);
}
/* root directory */
e = read_attr(istate, tree_oid, GITATTRIBUTES_FILE, flags | READ_ATTR_NOFOLLOW);
push_stack(stack, e, xstrdup(""), 0);
/* info frame */
if (startup_info->have_repository)
e = read_attr_from_file(git_path_info_attributes(), flags);
else
e = NULL;
if (!e)
CALLOC_ARRAY(e, 1);
push_stack(stack, e, NULL, 0);
}
static void prepare_attr_stack(struct index_state *istate,
const struct object_id *tree_oid,
const char *path, int dirlen,
struct attr_stack **stack)
{
struct attr_stack *info;
struct strbuf pathbuf = STRBUF_INIT;
/*
* At the bottom of the attribute stack is the built-in
* set of attribute definitions, followed by the contents
* of $(prefix)/etc/gitattributes and a file specified by
* core.attributesfile. Then, contents from
* .gitattributes files from directories closer to the
* root to the ones in deeper directories are pushed
* to the stack. Finally, at the very top of the stack
* we always keep the contents of $GIT_DIR/info/attributes.
*
* When checking, we use entries from near the top of the
* stack, preferring $GIT_DIR/info/attributes, then
* .gitattributes in deeper directories to shallower ones,
* and finally use the built-in set as the default.
*/
bootstrap_attr_stack(istate, tree_oid, stack);
/*
* Pop the "info" one that is always at the top of the stack.
*/
info = *stack;
*stack = info->prev;
/*
* Pop the ones from directories that are not the prefix of
* the path we are checking. Break out of the loop when we see
* the root one (whose origin is an empty string "") or the builtin
* one (whose origin is NULL) without popping it.
*/
while ((*stack)->origin) {
int namelen = (*stack)->originlen;
struct attr_stack *elem;
elem = *stack;
if (namelen <= dirlen &&
!strncmp(elem->origin, path, namelen) &&
(!namelen || path[namelen] == '/'))
break;
*stack = elem->prev;
attr_stack_free(elem);
}