1#include "cache.h"
23
static struct cache_def {
4char path[PATH_MAX + 1];
5int len;
6int flags;
7int track_flags;
8int prefix_len_stat_func;
9} cache;
1011
/*
12* Returns the length (on a path component basis) of the longest
13* common prefix match of 'name' and the cached path string.
14*/
15static inline int longest_match_lstat_cache(int len, const char *name,
16int *previous_slash)
17{
18int max_len, match_len = 0, match_len_prev = 0, i = 0;
1920
max_len = len < cache.len ? len : cache.len;
21while (i < max_len && name[i] == cache.path[i]) {
22if (name[i] == '/') {
23match_len_prev = match_len;
24match_len = i;
25}
26i++;
27}
28/*
29* Is the cached path string a substring of 'name', is 'name'
30* a substring of the cached path string, or is 'name' and the
31* cached path string the exact same string?
32*/
33if (i >= max_len && ((len > cache.len && name[cache.len] == '/') ||
34(len < cache.len && cache.path[len] == '/') ||
35(len == cache.len))) {
36match_len_prev = match_len;
37match_len = i;
38}
39*previous_slash = match_len_prev;
40return match_len;
41}
4243
static inline void reset_lstat_cache(void)
44{
45cache.path[0] = '\0';
46cache.len = 0;
47cache.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}
5354
#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)
6061
/*
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*/
73static int lstat_cache(int len, const char *name,
74int track_flags, int prefix_len_stat_func)
75{
76int match_len, last_slash, last_slash_dir, previous_slash;
77int match_flags, ret_flags, save_flags, max_len, ret;
78struct stat st;
7980
if (cache.track_flags != track_flags ||
81cache.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*/
87reset_lstat_cache();
88cache.track_flags = track_flags;
89cache.prefix_len_stat_func = prefix_len_stat_func;
90match_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*/
96match_len = last_slash =
97longest_match_lstat_cache(len, name, &previous_slash);
98match_flags = cache.flags & track_flags & (FL_NOENT|FL_SYMLINK);
99if (match_flags && match_len == cache.len)
100return match_flags;
101/*
102* If we now have match_len > 0, we would know that
103* the matched part will always be a directory.
104*
105* Also, if we are tracking directories and 'name' is
106* a substring of the cache on a path component basis,
107* we can return immediately.
108*/
109match_flags = track_flags & FL_DIR;
110if (match_flags && len == match_len)
111return match_flags;
112}
113114
/*
115* Okay, no match from the cache so far, so now we have to
116* check the rest of the path components.
117*/
118ret_flags = FL_DIR;
119last_slash_dir = last_slash;
120max_len = len < PATH_MAX ? len : PATH_MAX;
121while (match_len < max_len) {
122do {
123cache.path[match_len] = name[match_len];
124match_len++;
125} while (match_len < max_len && name[match_len] != '/');
126if (match_len >= max_len && !(track_flags & FL_FULLPATH))
127break;
128last_slash = match_len;
129cache.path[last_slash] = '\0';
130131
if (last_slash <= prefix_len_stat_func)
132ret = stat(cache.path, &st);
133else
134ret = lstat(cache.path, &st);
135136
if (ret) {
137ret_flags = FL_LSTATERR;
138if (errno == ENOENT)
139ret_flags |= FL_NOENT;
140} else if (S_ISDIR(st.st_mode)) {
141last_slash_dir = last_slash;
142continue;
143} else if (S_ISLNK(st.st_mode)) {
144ret_flags = FL_SYMLINK;
145} else {
146ret_flags = FL_ERR;
147}
148break;
149}
150151
/*
152* At the end update the cache. Note that max 3 different
153* path types, FL_NOENT, FL_SYMLINK and FL_DIR, can be cached
154* for the moment!
155*/
156save_flags = ret_flags & track_flags & (FL_NOENT|FL_SYMLINK);
157if (save_flags && last_slash > 0 && last_slash <= PATH_MAX) {
158cache.path[last_slash] = '\0';
159cache.len = last_slash;
160cache.flags = save_flags;
161} else if ((track_flags & FL_DIR) &&
162last_slash_dir > 0 && last_slash_dir <= PATH_MAX) {
163/*
164* We have a separate test for the directory case,
165* since it could be that we have found a symlink or a
166* non-existing directory and the track_flags says
167* that we cannot cache this fact, so the cache would
168* then have been left empty in this case.
169*
170* But if we are allowed to track real directories, we
171* can still cache the path components before the last
172* one (the found symlink or non-existing component).
173*/
174cache.path[last_slash_dir] = '\0';
175cache.len = last_slash_dir;
176cache.flags = FL_DIR;
177} else {
178reset_lstat_cache();
179}
180return ret_flags;
181}
182183
/*
184* Invalidate the given 'name' from the cache, if 'name' matches
185* completely with the cache.
186*/
187void invalidate_lstat_cache(int len, const char *name)
188{
189int match_len, previous_slash;
190191
match_len = longest_match_lstat_cache(len, name, &previous_slash);
192if (len == match_len) {
193if ((cache.track_flags & FL_DIR) && previous_slash > 0) {
194cache.path[previous_slash] = '\0';
195cache.len = previous_slash;
196cache.flags = FL_DIR;
197} else
198reset_lstat_cache();
199}
200}
201202
/*
203* Completely clear the contents of the cache
204*/
205void clear_lstat_cache(void)
206{
207reset_lstat_cache();
208}
209210
#define USE_ONLY_LSTAT 0
211212
/*
213* Return non-zero if path 'name' has a leading symlink component
214*/
215int has_symlink_leading_path(int len, const char *name)
216{
217return lstat_cache(len, name,
218FL_SYMLINK|FL_DIR, USE_ONLY_LSTAT) &
219FL_SYMLINK;
220}
221222
/*
223* Return non-zero if path 'name' has a leading symlink component or
224* if some leading path component does not exists.
225*/
226int has_symlink_or_noent_leading_path(int len, const char *name)
227{
228return lstat_cache(len, name,
229FL_SYMLINK|FL_NOENT|FL_DIR, USE_ONLY_LSTAT) &
230(FL_SYMLINK|FL_NOENT);
231}
232233
/*
234* Return non-zero if all path components of 'name' exists as a
235* directory. If prefix_len > 0, we will test with the stat()
236* function instead of the lstat() function for a prefix length of
237* 'prefix_len', thus we then allow for symlinks in the prefix part as
238* long as those points to real existing directories.
239*/
240int has_dirs_only_path(int len, const char *name, int prefix_len)
241{
242return lstat_cache(len, name,
243FL_DIR|FL_FULLPATH, prefix_len) &
244FL_DIR;
245}