1
2
3
4
5
6
7
8
9
10
11
12
13#include "cache.h"
14
15static char bad_path[] = "/bad-path/";
16
17
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
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
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
188
189
190
191
192
193
194
195
196
197
198
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
221
222
223
224
225
226
227 if (c == '.') {
228 if (!src[1]) {
229
230 src++;
231 } else if (is_dir_sep(src[1])) {
232
233 src += 2;
234 while (is_dir_sep(*src))
235 src++;
236 continue;
237 } else if (src[1] == '.') {
238 if (!src[2]) {
239
240 src += 2;
241 goto up_one;
242 } else if (is_dir_sep(src[2])) {
243
244 src += 3;
245 while (is_dir_sep(*src))
246 src++;
247 goto up_one;
248 }
249 }
250 }
251
252
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
267
268
269 dst--;
270 if (dst <= dst0)
271 return -1;
272
273 while (dst0 < dst && dst[-1] != '/')
274 dst--;
275 }
276 *dst = '\0';
277 return 0;
278}
279
280
281
282
283
284
285
286
287
288
289
290
291
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
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
334
335
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