]>
Commit | Line | Data |
---|---|---|
1 | #include "cache.h" | |
2 | ||
3 | /* | |
4 | * Returns the length (on a path component basis) of the longest | |
5 | * common prefix match of 'name_a' and 'name_b'. | |
6 | */ | |
7 | static int longest_path_match(const char *name_a, int len_a, | |
8 | const char *name_b, int len_b, | |
9 | int *previous_slash) | |
10 | { | |
11 | int max_len, match_len = 0, match_len_prev = 0, i = 0; | |
12 | ||
13 | max_len = len_a < len_b ? len_a : len_b; | |
14 | while (i < max_len && name_a[i] == name_b[i]) { | |
15 | if (name_a[i] == '/') { | |
16 | match_len_prev = match_len; | |
17 | match_len = i; | |
18 | } | |
19 | i++; | |
20 | } | |
21 | /* | |
22 | * Is 'name_b' a substring of 'name_a', the other way around, | |
23 | * or is 'name_a' and 'name_b' the exact same string? | |
24 | */ | |
25 | if (i >= max_len && ((len_a > len_b && name_a[len_b] == '/') || | |
26 | (len_a < len_b && name_b[len_a] == '/') || | |
27 | (len_a == len_b))) { | |
28 | match_len_prev = match_len; | |
29 | match_len = i; | |
30 | } | |
31 | *previous_slash = match_len_prev; | |
32 | return match_len; | |
33 | } | |
34 | ||
35 | static struct cache_def { | |
36 | char path[PATH_MAX + 1]; | |
37 | int len; | |
38 | int flags; | |
39 | int track_flags; | |
40 | int prefix_len_stat_func; | |
41 | } cache; | |
42 | ||
43 | static inline void reset_lstat_cache(void) | |
44 | { | |
45 | cache.path[0] = '\0'; | |
46 | cache.len = 0; | |
47 | cache.flags = 0; | |
48 | /* | |
49 | * The track_flags and prefix_len_stat_func members is only | |
50 | * set by the safeguard rule inside lstat_cache() | |
51 | */ | |
52 | } | |
53 | ||
54 | #define FL_DIR (1 << 0) | |
55 | #define FL_NOENT (1 << 1) | |
56 | #define FL_SYMLINK (1 << 2) | |
57 | #define FL_LSTATERR (1 << 3) | |
58 | #define FL_ERR (1 << 4) | |
59 | #define FL_FULLPATH (1 << 5) | |
60 | ||
61 | /* | |
62 | * Check if name 'name' of length 'len' has a symlink leading | |
63 | * component, or if the directory exists and is real, or not. | |
64 | * | |
65 | * To speed up the check, some information is allowed to be cached. | |
66 | * This can be indicated by the 'track_flags' argument, which also can | |
67 | * be used to indicate that we should check the full path. | |
68 | * | |
69 | * The 'prefix_len_stat_func' parameter can be used to set the length | |
70 | * of the prefix, where the cache should use the stat() function | |
71 | * instead of the lstat() function to test each path component. | |
72 | */ | |
73 | static int lstat_cache(int len, const char *name, | |
74 | int track_flags, int prefix_len_stat_func) | |
75 | { | |
76 | int match_len, last_slash, last_slash_dir, previous_slash; | |
77 | int match_flags, ret_flags, save_flags, max_len, ret; | |
78 | struct stat st; | |
79 | ||
80 | if (cache.track_flags != track_flags || | |
81 | cache.prefix_len_stat_func != prefix_len_stat_func) { | |
82 | /* | |
83 | * As a safeguard rule we clear the cache if the | |
84 | * values of track_flags and/or prefix_len_stat_func | |
85 | * does not match with the last supplied values. | |
86 | */ | |
87 | reset_lstat_cache(); | |
88 | cache.track_flags = track_flags; | |
89 | cache.prefix_len_stat_func = prefix_len_stat_func; | |
90 | match_len = last_slash = 0; | |
91 | } else { | |
92 | /* | |
93 | * Check to see if we have a match from the cache for | |
94 | * the 2 "excluding" path types. | |
95 | */ | |
96 | match_len = last_slash = | |
97 | longest_path_match(name, len, cache.path, cache.len, | |
98 | &previous_slash); | |
99 | match_flags = cache.flags & track_flags & (FL_NOENT|FL_SYMLINK); | |
100 | if (match_flags && match_len == cache.len) | |
101 | return match_flags; | |
102 | /* | |
103 | * If we now have match_len > 0, we would know that | |
104 | * the matched part will always be a directory. | |
105 | * | |
106 | * Also, if we are tracking directories and 'name' is | |
107 | * a substring of the cache on a path component basis, | |
108 | * we can return immediately. | |
109 | */ | |
110 | match_flags = track_flags & FL_DIR; | |
111 | if (match_flags && len == match_len) | |
112 | return match_flags; | |
113 | } | |
114 | ||
115 | /* | |
116 | * Okay, no match from the cache so far, so now we have to | |
117 | * check the rest of the path components. | |
118 | */ | |
119 | ret_flags = FL_DIR; | |
120 | last_slash_dir = last_slash; | |
121 | max_len = len < PATH_MAX ? len : PATH_MAX; | |
122 | while (match_len < max_len) { | |
123 | do { | |
124 | cache.path[match_len] = name[match_len]; | |
125 | match_len++; | |
126 | } while (match_len < max_len && name[match_len] != '/'); | |
127 | if (match_len >= max_len && !(track_flags & FL_FULLPATH)) | |
128 | break; | |
129 | last_slash = match_len; | |
130 | cache.path[last_slash] = '\0'; | |
131 | ||
132 | if (last_slash <= prefix_len_stat_func) | |
133 | ret = stat(cache.path, &st); | |
134 | else | |
135 | ret = lstat(cache.path, &st); | |
136 | ||
137 | if (ret) { | |
138 | ret_flags = FL_LSTATERR; | |
139 | if (errno == ENOENT) | |
140 | ret_flags |= FL_NOENT; | |
141 | } else if (S_ISDIR(st.st_mode)) { | |
142 | last_slash_dir = last_slash; | |
143 | continue; | |
144 | } else if (S_ISLNK(st.st_mode)) { | |
145 | ret_flags = FL_SYMLINK; | |
146 | } else { | |
147 | ret_flags = FL_ERR; | |
148 | } | |
149 | break; | |
150 | } | |
151 | ||
152 | /* | |
153 | * At the end update the cache. Note that max 3 different | |
154 | * path types, FL_NOENT, FL_SYMLINK and FL_DIR, can be cached | |
155 | * for the moment! | |
156 | */ | |
157 | save_flags = ret_flags & track_flags & (FL_NOENT|FL_SYMLINK); | |
158 | if (save_flags && last_slash > 0 && last_slash <= PATH_MAX) { | |
159 | cache.path[last_slash] = '\0'; | |
160 | cache.len = last_slash; | |
161 | cache.flags = save_flags; | |
162 | } else if ((track_flags & FL_DIR) && | |
163 | last_slash_dir > 0 && last_slash_dir <= PATH_MAX) { | |
164 | /* | |
165 | * We have a separate test for the directory case, | |
166 | * since it could be that we have found a symlink or a | |
167 | * non-existing directory and the track_flags says | |
168 | * that we cannot cache this fact, so the cache would | |
169 | * then have been left empty in this case. | |
170 | * | |
171 | * But if we are allowed to track real directories, we | |
172 | * can still cache the path components before the last | |
173 | * one (the found symlink or non-existing component). | |
174 | */ | |
175 | cache.path[last_slash_dir] = '\0'; | |
176 | cache.len = last_slash_dir; | |
177 | cache.flags = FL_DIR; | |
178 | } else { | |
179 | reset_lstat_cache(); | |
180 | } | |
181 | return ret_flags; | |
182 | } | |
183 | ||
184 | /* | |
185 | * Invalidate the given 'name' from the cache, if 'name' matches | |
186 | * completely with the cache. | |
187 | */ | |
188 | void invalidate_lstat_cache(int len, const char *name) | |
189 | { | |
190 | int match_len, previous_slash; | |
191 | ||
192 | match_len = longest_path_match(name, len, cache.path, cache.len, | |
193 | &previous_slash); | |
194 | if (len == match_len) { | |
195 | if ((cache.track_flags & FL_DIR) && previous_slash > 0) { | |
196 | cache.path[previous_slash] = '\0'; | |
197 | cache.len = previous_slash; | |
198 | cache.flags = FL_DIR; | |
199 | } else | |
200 | reset_lstat_cache(); | |
201 | } | |
202 | } | |
203 | ||
204 | /* | |
205 | * Completely clear the contents of the cache | |
206 | */ | |
207 | void clear_lstat_cache(void) | |
208 | { | |
209 | reset_lstat_cache(); | |
210 | } | |
211 | ||
212 | #define USE_ONLY_LSTAT 0 | |
213 | ||
214 | /* | |
215 | * Return non-zero if path 'name' has a leading symlink component | |
216 | */ | |
217 | int has_symlink_leading_path(int len, const char *name) | |
218 | { | |
219 | return lstat_cache(len, name, | |
220 | FL_SYMLINK|FL_DIR, USE_ONLY_LSTAT) & | |
221 | FL_SYMLINK; | |
222 | } | |
223 | ||
224 | /* | |
225 | * Return non-zero if path 'name' has a leading symlink component or | |
226 | * if some leading path component does not exists. | |
227 | */ | |
228 | int has_symlink_or_noent_leading_path(int len, const char *name) | |
229 | { | |
230 | return lstat_cache(len, name, | |
231 | FL_SYMLINK|FL_NOENT|FL_DIR, USE_ONLY_LSTAT) & | |
232 | (FL_SYMLINK|FL_NOENT); | |
233 | } | |
234 | ||
235 | /* | |
236 | * Return non-zero if all path components of 'name' exists as a | |
237 | * directory. If prefix_len > 0, we will test with the stat() | |
238 | * function instead of the lstat() function for a prefix length of | |
239 | * 'prefix_len', thus we then allow for symlinks in the prefix part as | |
240 | * long as those points to real existing directories. | |
241 | */ | |
242 | int has_dirs_only_path(int len, const char *name, int prefix_len) | |
243 | { | |
244 | return lstat_cache(len, name, | |
245 | FL_DIR|FL_FULLPATH, prefix_len) & | |
246 | FL_DIR; | |
247 | } |