Root/tools/perf/util/path.c

1/*
2 * I'm tired of doing "vsnprintf()" etc just to open a
3 * file, so here's a "return static buffer with printf"
4 * interface for paths.
5 *
6 * It's obviously not thread-safe. Sue me. But it's quite
7 * useful for doing things like
8 *
9 * f = open(mkpath("%s/%s.perf", base, name), O_RDONLY);
10 *
11 * which is what it's designed for.
12 */
13#include "cache.h"
14
15static char bad_path[] = "/bad-path/";
16/*
17 * Two hacks:
18 */
19
20static const char *get_perf_dir(void)
21{
22    return ".";
23}
24
25size_t strlcpy(char *dest, const char *src, size_t size)
26{
27    size_t ret = strlen(src);
28
29    if (size) {
30        size_t len = (ret >= size) ? size - 1 : ret;
31        memcpy(dest, src, len);
32        dest[len] = '\0';
33    }
34    return ret;
35}
36
37
38static char *get_pathname(void)
39{
40    static char pathname_array[4][PATH_MAX];
41    static int idx;
42
43    return pathname_array[3 & ++idx];
44}
45
46static char *cleanup_path(char *path)
47{
48    /* Clean it up */
49    if (!memcmp(path, "./", 2)) {
50        path += 2;
51        while (*path == '/')
52            path++;
53    }
54    return path;
55}
56
57char *mksnpath(char *buf, size_t n, const char *fmt, ...)
58{
59    va_list args;
60    unsigned len;
61
62    va_start(args, fmt);
63    len = vsnprintf(buf, n, fmt, args);
64    va_end(args);
65    if (len >= n) {
66        strlcpy(buf, bad_path, n);
67        return buf;
68    }
69    return cleanup_path(buf);
70}
71
72static char *perf_vsnpath(char *buf, size_t n, const char *fmt, va_list args)
73{
74    const char *perf_dir = get_perf_dir();
75    size_t len;
76
77    len = strlen(perf_dir);
78    if (n < len + 1)
79        goto bad;
80    memcpy(buf, perf_dir, len);
81    if (len && !is_dir_sep(perf_dir[len-1]))
82        buf[len++] = '/';
83    len += vsnprintf(buf + len, n - len, fmt, args);
84    if (len >= n)
85        goto bad;
86    return cleanup_path(buf);
87bad:
88    strlcpy(buf, bad_path, n);
89    return buf;
90}
91
92char *perf_snpath(char *buf, size_t n, const char *fmt, ...)
93{
94    va_list args;
95    va_start(args, fmt);
96    (void)perf_vsnpath(buf, n, fmt, args);
97    va_end(args);
98    return buf;
99}
100
101char *perf_pathdup(const char *fmt, ...)
102{
103    char path[PATH_MAX];
104    va_list args;
105    va_start(args, fmt);
106    (void)perf_vsnpath(path, sizeof(path), fmt, args);
107    va_end(args);
108    return xstrdup(path);
109}
110
111char *mkpath(const char *fmt, ...)
112{
113    va_list args;
114    unsigned len;
115    char *pathname = get_pathname();
116
117    va_start(args, fmt);
118    len = vsnprintf(pathname, PATH_MAX, fmt, args);
119    va_end(args);
120    if (len >= PATH_MAX)
121        return bad_path;
122    return cleanup_path(pathname);
123}
124
125char *perf_path(const char *fmt, ...)
126{
127    const char *perf_dir = get_perf_dir();
128    char *pathname = get_pathname();
129    va_list args;
130    unsigned len;
131
132    len = strlen(perf_dir);
133    if (len > PATH_MAX-100)
134        return bad_path;
135    memcpy(pathname, perf_dir, len);
136    if (len && perf_dir[len-1] != '/')
137        pathname[len++] = '/';
138    va_start(args, fmt);
139    len += vsnprintf(pathname + len, PATH_MAX - len, fmt, args);
140    va_end(args);
141    if (len >= PATH_MAX)
142        return bad_path;
143    return cleanup_path(pathname);
144}
145
146
147/* perf_mkstemp() - create tmp file honoring TMPDIR variable */
148int perf_mkstemp(char *path, size_t len, const char *template)
149{
150    const char *tmp;
151    size_t n;
152
153    tmp = getenv("TMPDIR");
154    if (!tmp)
155        tmp = "/tmp";
156    n = snprintf(path, len, "%s/%s", tmp, template);
157    if (len <= n) {
158        errno = ENAMETOOLONG;
159        return -1;
160    }
161    return mkstemp(path);
162}
163
164
165const char *make_relative_path(const char *abs_path, const char *base)
166{
167    static char buf[PATH_MAX + 1];
168    int baselen;
169
170    if (!base)
171        return abs_path;
172
173    baselen = strlen(base);
174    if (prefixcmp(abs_path, base))
175        return abs_path;
176    if (abs_path[baselen] == '/')
177        baselen++;
178    else if (base[baselen - 1] != '/')
179        return abs_path;
180
181    strcpy(buf, abs_path + baselen);
182
183    return buf;
184}
185
186/*
187 * It is okay if dst == src, but they should not overlap otherwise.
188 *
189 * Performs the following normalizations on src, storing the result in dst:
190 * - Ensures that components are separated by '/' (Windows only)
191 * - Squashes sequences of '/'.
192 * - Removes "." components.
193 * - Removes ".." components, and the components the precede them.
194 * Returns failure (non-zero) if a ".." component appears as first path
195 * component anytime during the normalization. Otherwise, returns success (0).
196 *
197 * Note that this function is purely textual. It does not follow symlinks,
198 * verify the existence of the path, or make any system calls.
199 */
200int normalize_path_copy(char *dst, const char *src)
201{
202    char *dst0;
203
204    if (has_dos_drive_prefix(src)) {
205        *dst++ = *src++;
206        *dst++ = *src++;
207    }
208    dst0 = dst;
209
210    if (is_dir_sep(*src)) {
211        *dst++ = '/';
212        while (is_dir_sep(*src))
213            src++;
214    }
215
216    for (;;) {
217        char c = *src;
218
219        /*
220         * A path component that begins with . could be
221         * special:
222         * (1) "." and ends -- ignore and terminate.
223         * (2) "./" -- ignore them, eat slash and continue.
224         * (3) ".." and ends -- strip one and terminate.
225         * (4) "../" -- strip one, eat slash and continue.
226         */
227        if (c == '.') {
228            if (!src[1]) {
229                /* (1) */
230                src++;
231            } else if (is_dir_sep(src[1])) {
232                /* (2) */
233                src += 2;
234                while (is_dir_sep(*src))
235                    src++;
236                continue;
237            } else if (src[1] == '.') {
238                if (!src[2]) {
239                    /* (3) */
240                    src += 2;
241                    goto up_one;
242                } else if (is_dir_sep(src[2])) {
243                    /* (4) */
244                    src += 3;
245                    while (is_dir_sep(*src))
246                        src++;
247                    goto up_one;
248                }
249            }
250        }
251
252        /* copy up to the next '/', and eat all '/' */
253        while ((c = *src++) != '\0' && !is_dir_sep(c))
254            *dst++ = c;
255        if (is_dir_sep(c)) {
256            *dst++ = '/';
257            while (is_dir_sep(c))
258                c = *src++;
259            src--;
260        } else if (!c)
261            break;
262        continue;
263
264    up_one:
265        /*
266         * dst0..dst is prefix portion, and dst[-1] is '/';
267         * go up one level.
268         */
269        dst--; /* go to trailing '/' */
270        if (dst <= dst0)
271            return -1;
272        /* Windows: dst[-1] cannot be backslash anymore */
273        while (dst0 < dst && dst[-1] != '/')
274            dst--;
275    }
276    *dst = '\0';
277    return 0;
278}
279
280/*
281 * path = Canonical absolute path
282 * prefix_list = Colon-separated list of absolute paths
283 *
284 * Determines, for each path in prefix_list, whether the "prefix" really
285 * is an ancestor directory of path. Returns the length of the longest
286 * ancestor directory, excluding any trailing slashes, or -1 if no prefix
287 * is an ancestor. (Note that this means 0 is returned if prefix_list is
288 * "/".) "/foo" is not considered an ancestor of "/foobar". Directories
289 * are not considered to be their own ancestors. path must be in a
290 * canonical form: empty components, or "." or ".." components are not
291 * allowed. prefix_list may be null, which is like "".
292 */
293int longest_ancestor_length(const char *path, const char *prefix_list)
294{
295    char buf[PATH_MAX+1];
296    const char *ceil, *colon;
297    int len, max_len = -1;
298
299    if (prefix_list == NULL || !strcmp(path, "/"))
300        return -1;
301
302    for (colon = ceil = prefix_list; *colon; ceil = colon+1) {
303        for (colon = ceil; *colon && *colon != PATH_SEP; colon++);
304        len = colon - ceil;
305        if (len == 0 || len > PATH_MAX || !is_absolute_path(ceil))
306            continue;
307        strlcpy(buf, ceil, len+1);
308        if (normalize_path_copy(buf, buf) < 0)
309            continue;
310        len = strlen(buf);
311        if (len > 0 && buf[len-1] == '/')
312            buf[--len] = '\0';
313
314        if (!strncmp(path, buf, len) &&
315            path[len] == '/' &&
316            len > max_len) {
317            max_len = len;
318        }
319    }
320
321    return max_len;
322}
323
324/* strip arbitrary amount of directory separators at end of path */
325static inline int chomp_trailing_dir_sep(const char *path, int len)
326{
327    while (len && is_dir_sep(path[len - 1]))
328        len--;
329    return len;
330}
331
332/*
333 * If path ends with suffix (complete path components), returns the
334 * part before suffix (sans trailing directory separators).
335 * Otherwise returns NULL.
336 */
337char *strip_path_suffix(const char *path, const char *suffix)
338{
339    int path_len = strlen(path), suffix_len = strlen(suffix);
340
341    while (suffix_len) {
342        if (!path_len)
343            return NULL;
344
345        if (is_dir_sep(path[path_len - 1])) {
346            if (!is_dir_sep(suffix[suffix_len - 1]))
347                return NULL;
348            path_len = chomp_trailing_dir_sep(path, path_len);
349            suffix_len = chomp_trailing_dir_sep(suffix, suffix_len);
350        }
351        else if (path[--path_len] != suffix[--suffix_len])
352            return NULL;
353    }
354
355    if (path_len && !is_dir_sep(path[path_len - 1]))
356        return NULL;
357    return xstrndup(path, chomp_trailing_dir_sep(path, path_len));
358}
359

Archive Download this file



interactive