]>
Commit | Line | Data |
---|---|---|
f859c846 JH |
1 | #include "cache.h" |
2 | ||
92604b46 | 3 | static struct cache_def { |
f859c846 | 4 | char path[PATH_MAX]; |
92604b46 KB |
5 | int len; |
6 | int flags; | |
7 | } cache; | |
c40641b7 | 8 | |
92604b46 KB |
9 | /* |
10 | * Returns the length (on a path component basis) of the longest | |
11 | * common prefix match of 'name' and the cached path string. | |
12 | */ | |
13 | static inline int longest_match_lstat_cache(int len, const char *name) | |
c40641b7 | 14 | { |
92604b46 KB |
15 | int max_len, match_len = 0, i = 0; |
16 | ||
17 | max_len = len < cache.len ? len : cache.len; | |
18 | while (i < max_len && name[i] == cache.path[i]) { | |
19 | if (name[i] == '/') | |
20 | match_len = i; | |
21 | i++; | |
22 | } | |
23 | /* Is the cached path string a substring of 'name'? */ | |
24 | if (i == cache.len && cache.len < len && name[cache.len] == '/') | |
25 | match_len = cache.len; | |
26 | /* Is 'name' a substring of the cached path string? */ | |
27 | else if ((i == len && len < cache.len && cache.path[len] == '/') || | |
28 | (i == len && len == cache.len)) | |
29 | match_len = len; | |
30 | return match_len; | |
c40641b7 LT |
31 | } |
32 | ||
92604b46 | 33 | static inline void reset_lstat_cache(void) |
c40641b7 | 34 | { |
92604b46 KB |
35 | cache.path[0] = '\0'; |
36 | cache.len = 0; | |
37 | cache.flags = 0; | |
c40641b7 LT |
38 | } |
39 | ||
92604b46 KB |
40 | #define FL_DIR (1 << 0) |
41 | #define FL_SYMLINK (1 << 1) | |
42 | #define FL_LSTATERR (1 << 2) | |
43 | #define FL_ERR (1 << 3) | |
44 | ||
45 | /* | |
46 | * Check if name 'name' of length 'len' has a symlink leading | |
47 | * component, or if the directory exists and is real. | |
48 | * | |
49 | * To speed up the check, some information is allowed to be cached. | |
50 | * This can be indicated by the 'track_flags' argument. | |
51 | */ | |
52 | static int lstat_cache(int len, const char *name, | |
53 | int track_flags) | |
c40641b7 | 54 | { |
92604b46 KB |
55 | int match_len, last_slash, last_slash_dir; |
56 | int match_flags, ret_flags, save_flags, max_len; | |
c40641b7 | 57 | struct stat st; |
f859c846 | 58 | |
c40641b7 | 59 | /* |
92604b46 KB |
60 | * Check to see if we have a match from the cache for the |
61 | * symlink path type. | |
c40641b7 | 62 | */ |
92604b46 KB |
63 | match_len = last_slash = longest_match_lstat_cache(len, name); |
64 | match_flags = cache.flags & track_flags & FL_SYMLINK; | |
65 | if (match_flags && match_len == cache.len) | |
66 | return match_flags; | |
c40641b7 | 67 | /* |
92604b46 KB |
68 | * If we now have match_len > 0, we would know that the |
69 | * matched part will always be a directory. | |
70 | * | |
71 | * Also, if we are tracking directories and 'name' is a | |
72 | * substring of the cache on a path component basis, we can | |
73 | * return immediately. | |
c40641b7 | 74 | */ |
92604b46 KB |
75 | match_flags = track_flags & FL_DIR; |
76 | if (match_flags && len == match_len) | |
77 | return match_flags; | |
c40641b7 | 78 | |
92604b46 KB |
79 | /* |
80 | * Okay, no match from the cache so far, so now we have to | |
81 | * check the rest of the path components. | |
82 | */ | |
83 | ret_flags = FL_DIR; | |
84 | last_slash_dir = last_slash; | |
85 | max_len = len < PATH_MAX ? len : PATH_MAX; | |
86 | while (match_len < max_len) { | |
87 | do { | |
88 | cache.path[match_len] = name[match_len]; | |
89 | match_len++; | |
90 | } while (match_len < max_len && name[match_len] != '/'); | |
91 | if (match_len >= max_len) | |
92 | break; | |
93 | last_slash = match_len; | |
94 | cache.path[last_slash] = '\0'; | |
f859c846 | 95 | |
92604b46 KB |
96 | if (lstat(cache.path, &st)) { |
97 | ret_flags = FL_LSTATERR; | |
98 | } else if (S_ISDIR(st.st_mode)) { | |
99 | last_slash_dir = last_slash; | |
c40641b7 | 100 | continue; |
92604b46 KB |
101 | } else if (S_ISLNK(st.st_mode)) { |
102 | ret_flags = FL_SYMLINK; | |
103 | } else { | |
104 | ret_flags = FL_ERR; | |
f859c846 | 105 | } |
c40641b7 | 106 | break; |
f859c846 | 107 | } |
92604b46 KB |
108 | |
109 | /* | |
110 | * At the end update the cache. Note that max 2 different | |
111 | * path types, FL_SYMLINK and FL_DIR, can be cached for the | |
112 | * moment! | |
113 | */ | |
114 | save_flags = ret_flags & track_flags & FL_SYMLINK; | |
115 | if (save_flags && last_slash > 0 && last_slash < PATH_MAX) { | |
116 | cache.path[last_slash] = '\0'; | |
117 | cache.len = last_slash; | |
118 | cache.flags = save_flags; | |
119 | } else if (track_flags & FL_DIR && | |
120 | last_slash_dir > 0 && last_slash_dir < PATH_MAX) { | |
121 | /* | |
122 | * We have a separate test for the directory case, | |
123 | * since it could be that we have found a symlink and | |
124 | * the track_flags says that we cannot cache this | |
125 | * fact, so the cache would then have been left empty | |
126 | * in this case. | |
127 | * | |
128 | * But if we are allowed to track real directories, we | |
129 | * can still cache the path components before the last | |
130 | * one (the found symlink component). | |
131 | */ | |
132 | cache.path[last_slash_dir] = '\0'; | |
133 | cache.len = last_slash_dir; | |
134 | cache.flags = FL_DIR; | |
135 | } else { | |
136 | reset_lstat_cache(); | |
137 | } | |
138 | return ret_flags; | |
139 | } | |
140 | ||
141 | /* | |
142 | * Return non-zero if path 'name' has a leading symlink component | |
143 | */ | |
144 | int has_symlink_leading_path(int len, const char *name) | |
145 | { | |
146 | return lstat_cache(len, name, | |
147 | FL_SYMLINK|FL_DIR) & | |
148 | FL_SYMLINK; | |
f859c846 | 149 | } |