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 57static char *perf_vsnpath(char *buf, size_t n, const char *fmt, va_list args) 58{ 59 const char *perf_dir = get_perf_dir(); 60 size_t len; 61 62 len = strlen(perf_dir); 63 if (n < len + 1) 64 goto bad; 65 memcpy(buf, perf_dir, len); 66 if (len && !is_dir_sep(perf_dir[len-1])) 67 buf[len++] = '/'; 68 len += vsnprintf(buf + len, n - len, fmt, args); 69 if (len >= n) 70 goto bad; 71 return cleanup_path(buf); 72bad: 73 strlcpy(buf, bad_path, n); 74 return buf; 75} 76 77char *perf_pathdup(const char *fmt, ...) 78{ 79 char path[PATH_MAX]; 80 va_list args; 81 va_start(args, fmt); 82 (void)perf_vsnpath(path, sizeof(path), fmt, args); 83 va_end(args); 84 return xstrdup(path); 85} 86 87char *mkpath(const char *fmt, ...) 88{ 89 va_list args; 90 unsigned len; 91 char *pathname = get_pathname(); 92 93 va_start(args, fmt); 94 len = vsnprintf(pathname, PATH_MAX, fmt, args); 95 va_end(args); 96 if (len >= PATH_MAX) 97 return bad_path; 98 return cleanup_path(pathname); 99} 100 101char *perf_path(const char *fmt, ...) 102{ 103 const char *perf_dir = get_perf_dir(); 104 char *pathname = get_pathname(); 105 va_list args; 106 unsigned len; 107 108 len = strlen(perf_dir); 109 if (len > PATH_MAX-100) 110 return bad_path; 111 memcpy(pathname, perf_dir, len); 112 if (len && perf_dir[len-1] != '/') 113 pathname[len++] = '/'; 114 va_start(args, fmt); 115 len += vsnprintf(pathname + len, PATH_MAX - len, fmt, args); 116 va_end(args); 117 if (len >= PATH_MAX) 118 return bad_path; 119 return cleanup_path(pathname); 120} 121 122/* strip arbitrary amount of directory separators at end of path */ 123static inline int chomp_trailing_dir_sep(const char *path, int len) 124{ 125 while (len && is_dir_sep(path[len - 1])) 126 len--; 127 return len; 128} 129 130/* 131 * If path ends with suffix (complete path components), returns the 132 * part before suffix (sans trailing directory separators). 133 * Otherwise returns NULL. 134 */ 135char *strip_path_suffix(const char *path, const char *suffix) 136{ 137 int path_len = strlen(path), suffix_len = strlen(suffix); 138 139 while (suffix_len) { 140 if (!path_len) 141 return NULL; 142 143 if (is_dir_sep(path[path_len - 1])) { 144 if (!is_dir_sep(suffix[suffix_len - 1])) 145 return NULL; 146 path_len = chomp_trailing_dir_sep(path, path_len); 147 suffix_len = chomp_trailing_dir_sep(suffix, suffix_len); 148 } 149 else if (path[--path_len] != suffix[--suffix_len]) 150 return NULL; 151 } 152 153 if (path_len && !is_dir_sep(path[path_len - 1])) 154 return NULL; 155 return strndup(path, chomp_trailing_dir_sep(path, path_len)); 156} 157