Linus Torvalds | 112db55 | 2008-06-22 12:19:25 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Various trivial helper wrappers around standard functions |
| 3 | */ |
| 4 | #include "cache.h" |
Brandon Williams | b2141fc | 2017-06-14 11:07:36 -0700 | [diff] [blame] | 5 | #include "config.h" |
Linus Torvalds | 112db55 | 2008-06-22 12:19:25 -0700 | [diff] [blame] | 6 | |
Nguyễn Thái Ngọc Duy | f8bb1d9 | 2014-08-16 10:08:02 +0700 | [diff] [blame] | 7 | static int memory_limit_check(size_t size, int gentle) |
Nguyễn Thái Ngọc Duy | d41489a | 2012-03-07 17:54:16 +0700 | [diff] [blame] | 8 | { |
Steffen Prohaska | 9927d96 | 2014-08-26 17:23:22 +0200 | [diff] [blame] | 9 | static size_t limit = 0; |
| 10 | if (!limit) { |
| 11 | limit = git_env_ulong("GIT_ALLOC_LIMIT", 0); |
| 12 | if (!limit) |
| 13 | limit = SIZE_MAX; |
Nguyễn Thái Ngọc Duy | d41489a | 2012-03-07 17:54:16 +0700 | [diff] [blame] | 14 | } |
Junio C Hamano | f0d8900 | 2014-10-08 13:05:32 -0700 | [diff] [blame] | 15 | if (size > limit) { |
Nguyễn Thái Ngọc Duy | f8bb1d9 | 2014-08-16 10:08:02 +0700 | [diff] [blame] | 16 | if (gentle) { |
Junio C Hamano | f0d8900 | 2014-10-08 13:05:32 -0700 | [diff] [blame] | 17 | error("attempting to allocate %"PRIuMAX" over limit %"PRIuMAX, |
| 18 | (uintmax_t)size, (uintmax_t)limit); |
Nguyễn Thái Ngọc Duy | f8bb1d9 | 2014-08-16 10:08:02 +0700 | [diff] [blame] | 19 | return -1; |
| 20 | } else |
Junio C Hamano | f0d8900 | 2014-10-08 13:05:32 -0700 | [diff] [blame] | 21 | die("attempting to allocate %"PRIuMAX" over limit %"PRIuMAX, |
| 22 | (uintmax_t)size, (uintmax_t)limit); |
Nguyễn Thái Ngọc Duy | f8bb1d9 | 2014-08-16 10:08:02 +0700 | [diff] [blame] | 23 | } |
| 24 | return 0; |
Nguyễn Thái Ngọc Duy | d41489a | 2012-03-07 17:54:16 +0700 | [diff] [blame] | 25 | } |
| 26 | |
Linus Torvalds | 112db55 | 2008-06-22 12:19:25 -0700 | [diff] [blame] | 27 | char *xstrdup(const char *str) |
| 28 | { |
| 29 | char *ret = strdup(str); |
Jeff King | 9827d4c | 2019-08-12 16:50:21 -0400 | [diff] [blame] | 30 | if (!ret) |
| 31 | die("Out of memory, strdup failed"); |
Linus Torvalds | 112db55 | 2008-06-22 12:19:25 -0700 | [diff] [blame] | 32 | return ret; |
| 33 | } |
| 34 | |
Nguyễn Thái Ngọc Duy | f8bb1d9 | 2014-08-16 10:08:02 +0700 | [diff] [blame] | 35 | static void *do_xmalloc(size_t size, int gentle) |
Linus Torvalds | 112db55 | 2008-06-22 12:19:25 -0700 | [diff] [blame] | 36 | { |
Nguyễn Thái Ngọc Duy | d41489a | 2012-03-07 17:54:16 +0700 | [diff] [blame] | 37 | void *ret; |
| 38 | |
Nguyễn Thái Ngọc Duy | f8bb1d9 | 2014-08-16 10:08:02 +0700 | [diff] [blame] | 39 | if (memory_limit_check(size, gentle)) |
| 40 | return NULL; |
Nguyễn Thái Ngọc Duy | d41489a | 2012-03-07 17:54:16 +0700 | [diff] [blame] | 41 | ret = malloc(size); |
Linus Torvalds | 112db55 | 2008-06-22 12:19:25 -0700 | [diff] [blame] | 42 | if (!ret && !size) |
| 43 | ret = malloc(1); |
| 44 | if (!ret) { |
Jeff King | 9827d4c | 2019-08-12 16:50:21 -0400 | [diff] [blame] | 45 | if (!gentle) |
| 46 | die("Out of memory, malloc failed (tried to allocate %lu bytes)", |
| 47 | (unsigned long)size); |
| 48 | else { |
| 49 | error("Out of memory, malloc failed (tried to allocate %lu bytes)", |
| 50 | (unsigned long)size); |
| 51 | return NULL; |
Nguyễn Thái Ngọc Duy | f8bb1d9 | 2014-08-16 10:08:02 +0700 | [diff] [blame] | 52 | } |
Linus Torvalds | 112db55 | 2008-06-22 12:19:25 -0700 | [diff] [blame] | 53 | } |
| 54 | #ifdef XMALLOC_POISON |
| 55 | memset(ret, 0xA5, size); |
| 56 | #endif |
| 57 | return ret; |
| 58 | } |
| 59 | |
Nguyễn Thái Ngọc Duy | f8bb1d9 | 2014-08-16 10:08:02 +0700 | [diff] [blame] | 60 | void *xmalloc(size_t size) |
| 61 | { |
| 62 | return do_xmalloc(size, 0); |
| 63 | } |
| 64 | |
| 65 | static void *do_xmallocz(size_t size, int gentle) |
Ilari Liusvaara | 5bf9219 | 2010-01-26 20:24:12 +0200 | [diff] [blame] | 66 | { |
| 67 | void *ret; |
Nguyễn Thái Ngọc Duy | f8bb1d9 | 2014-08-16 10:08:02 +0700 | [diff] [blame] | 68 | if (unsigned_add_overflows(size, 1)) { |
| 69 | if (gentle) { |
| 70 | error("Data too large to fit into virtual memory space."); |
| 71 | return NULL; |
| 72 | } else |
| 73 | die("Data too large to fit into virtual memory space."); |
| 74 | } |
| 75 | ret = do_xmalloc(size + 1, gentle); |
| 76 | if (ret) |
| 77 | ((char*)ret)[size] = 0; |
Ilari Liusvaara | 5bf9219 | 2010-01-26 20:24:12 +0200 | [diff] [blame] | 78 | return ret; |
| 79 | } |
| 80 | |
Nguyễn Thái Ngọc Duy | f8bb1d9 | 2014-08-16 10:08:02 +0700 | [diff] [blame] | 81 | void *xmallocz(size_t size) |
| 82 | { |
| 83 | return do_xmallocz(size, 0); |
| 84 | } |
| 85 | |
| 86 | void *xmallocz_gently(size_t size) |
| 87 | { |
| 88 | return do_xmallocz(size, 1); |
| 89 | } |
| 90 | |
Linus Torvalds | 112db55 | 2008-06-22 12:19:25 -0700 | [diff] [blame] | 91 | /* |
| 92 | * xmemdupz() allocates (len + 1) bytes of memory, duplicates "len" bytes of |
| 93 | * "data" to the allocated memory, zero terminates the allocated memory, |
| 94 | * and returns a pointer to the allocated memory. If the allocation fails, |
| 95 | * the program dies. |
| 96 | */ |
| 97 | void *xmemdupz(const void *data, size_t len) |
| 98 | { |
Ilari Liusvaara | 5bf9219 | 2010-01-26 20:24:12 +0200 | [diff] [blame] | 99 | return memcpy(xmallocz(len), data, len); |
Linus Torvalds | 112db55 | 2008-06-22 12:19:25 -0700 | [diff] [blame] | 100 | } |
| 101 | |
| 102 | char *xstrndup(const char *str, size_t len) |
| 103 | { |
| 104 | char *p = memchr(str, '\0', len); |
| 105 | return xmemdupz(str, p ? p - str : len); |
| 106 | } |
| 107 | |
brian m. carlson | 14570dc | 2020-05-25 19:58:50 +0000 | [diff] [blame] | 108 | int xstrncmpz(const char *s, const char *t, size_t len) |
| 109 | { |
| 110 | int res = strncmp(s, t, len); |
| 111 | if (res) |
| 112 | return res; |
| 113 | return s[len] == '\0' ? 0 : 1; |
| 114 | } |
| 115 | |
Linus Torvalds | 112db55 | 2008-06-22 12:19:25 -0700 | [diff] [blame] | 116 | void *xrealloc(void *ptr, size_t size) |
| 117 | { |
Nguyễn Thái Ngọc Duy | d41489a | 2012-03-07 17:54:16 +0700 | [diff] [blame] | 118 | void *ret; |
| 119 | |
Jeff King | 6479ea4 | 2020-09-02 03:54:39 -0400 | [diff] [blame] | 120 | if (!size) { |
| 121 | free(ptr); |
| 122 | return xmalloc(0); |
| 123 | } |
| 124 | |
Nguyễn Thái Ngọc Duy | f8bb1d9 | 2014-08-16 10:08:02 +0700 | [diff] [blame] | 125 | memory_limit_check(size, 0); |
Nguyễn Thái Ngọc Duy | d41489a | 2012-03-07 17:54:16 +0700 | [diff] [blame] | 126 | ret = realloc(ptr, size); |
Jeff King | 9827d4c | 2019-08-12 16:50:21 -0400 | [diff] [blame] | 127 | if (!ret) |
| 128 | die("Out of memory, realloc failed"); |
Linus Torvalds | 112db55 | 2008-06-22 12:19:25 -0700 | [diff] [blame] | 129 | return ret; |
| 130 | } |
| 131 | |
| 132 | void *xcalloc(size_t nmemb, size_t size) |
| 133 | { |
Nguyễn Thái Ngọc Duy | d41489a | 2012-03-07 17:54:16 +0700 | [diff] [blame] | 134 | void *ret; |
| 135 | |
Jeff King | e7792a7 | 2016-02-22 17:43:18 -0500 | [diff] [blame] | 136 | if (unsigned_mult_overflows(nmemb, size)) |
| 137 | die("data too large to fit into virtual memory space"); |
| 138 | |
Nguyễn Thái Ngọc Duy | f8bb1d9 | 2014-08-16 10:08:02 +0700 | [diff] [blame] | 139 | memory_limit_check(size * nmemb, 0); |
Nguyễn Thái Ngọc Duy | d41489a | 2012-03-07 17:54:16 +0700 | [diff] [blame] | 140 | ret = calloc(nmemb, size); |
Linus Torvalds | 112db55 | 2008-06-22 12:19:25 -0700 | [diff] [blame] | 141 | if (!ret && (!nmemb || !size)) |
| 142 | ret = calloc(1, 1); |
Jeff King | 9827d4c | 2019-08-12 16:50:21 -0400 | [diff] [blame] | 143 | if (!ret) |
| 144 | die("Out of memory, calloc failed"); |
Linus Torvalds | 112db55 | 2008-06-22 12:19:25 -0700 | [diff] [blame] | 145 | return ret; |
| 146 | } |
| 147 | |
Linus Torvalds | 112db55 | 2008-06-22 12:19:25 -0700 | [diff] [blame] | 148 | /* |
Steffen Prohaska | 0b6806b | 2013-08-20 08:43:54 +0200 | [diff] [blame] | 149 | * Limit size of IO chunks, because huge chunks only cause pain. OS X |
| 150 | * 64-bit is buggy, returning EINVAL if len >= INT_MAX; and even in |
Masanari Iida | 382d20e | 2013-11-13 00:17:42 +0900 | [diff] [blame] | 151 | * the absence of bugs, large chunks can result in bad latencies when |
Steffen Prohaska | 0b6806b | 2013-08-20 08:43:54 +0200 | [diff] [blame] | 152 | * you decide to kill the process. |
Junio C Hamano | a983e6a | 2015-02-11 13:13:10 -0800 | [diff] [blame] | 153 | * |
| 154 | * We pick 8 MiB as our default, but if the platform defines SSIZE_MAX |
| 155 | * that is smaller than that, clip it to SSIZE_MAX, as a call to |
| 156 | * read(2) or write(2) larger than that is allowed to fail. As the last |
| 157 | * resort, we allow a port to pass via CFLAGS e.g. "-DMAX_IO_SIZE=value" |
| 158 | * to override this, if the definition of SSIZE_MAX given by the platform |
| 159 | * is broken. |
Steffen Prohaska | 0b6806b | 2013-08-20 08:43:54 +0200 | [diff] [blame] | 160 | */ |
Junio C Hamano | a983e6a | 2015-02-11 13:13:10 -0800 | [diff] [blame] | 161 | #ifndef MAX_IO_SIZE |
| 162 | # define MAX_IO_SIZE_DEFAULT (8*1024*1024) |
| 163 | # if defined(SSIZE_MAX) && (SSIZE_MAX < MAX_IO_SIZE_DEFAULT) |
| 164 | # define MAX_IO_SIZE SSIZE_MAX |
| 165 | # else |
| 166 | # define MAX_IO_SIZE MAX_IO_SIZE_DEFAULT |
| 167 | # endif |
| 168 | #endif |
Steffen Prohaska | 0b6806b | 2013-08-20 08:43:54 +0200 | [diff] [blame] | 169 | |
Paul Tan | 3ff53df | 2015-08-04 21:51:22 +0800 | [diff] [blame] | 170 | /** |
| 171 | * xopen() is the same as open(), but it die()s if the open() fails. |
| 172 | */ |
| 173 | int xopen(const char *path, int oflag, ...) |
| 174 | { |
| 175 | mode_t mode = 0; |
| 176 | va_list ap; |
| 177 | |
| 178 | /* |
| 179 | * va_arg() will have undefined behavior if the specified type is not |
| 180 | * compatible with the argument type. Since integers are promoted to |
| 181 | * ints, we fetch the next argument as an int, and then cast it to a |
| 182 | * mode_t to avoid undefined behavior. |
| 183 | */ |
| 184 | va_start(ap, oflag); |
| 185 | if (oflag & O_CREAT) |
| 186 | mode = va_arg(ap, int); |
| 187 | va_end(ap); |
| 188 | |
| 189 | for (;;) { |
| 190 | int fd = open(path, oflag, mode); |
| 191 | if (fd >= 0) |
| 192 | return fd; |
| 193 | if (errno == EINTR) |
| 194 | continue; |
| 195 | |
| 196 | if ((oflag & O_RDWR) == O_RDWR) |
| 197 | die_errno(_("could not open '%s' for reading and writing"), path); |
| 198 | else if ((oflag & O_WRONLY) == O_WRONLY) |
| 199 | die_errno(_("could not open '%s' for writing"), path); |
| 200 | else |
| 201 | die_errno(_("could not open '%s' for reading"), path); |
| 202 | } |
| 203 | } |
| 204 | |
Eric Wong | d751dd1 | 2016-07-10 08:20:46 +0000 | [diff] [blame] | 205 | static int handle_nonblock(int fd, short poll_events, int err) |
| 206 | { |
| 207 | struct pollfd pfd; |
| 208 | |
| 209 | if (err != EAGAIN && err != EWOULDBLOCK) |
| 210 | return 0; |
| 211 | |
| 212 | pfd.fd = fd; |
| 213 | pfd.events = poll_events; |
| 214 | |
| 215 | /* |
| 216 | * no need to check for errors, here; |
| 217 | * a subsequent read/write will detect unrecoverable errors |
| 218 | */ |
| 219 | poll(&pfd, 1, -1); |
| 220 | return 1; |
| 221 | } |
| 222 | |
Steffen Prohaska | 0b6806b | 2013-08-20 08:43:54 +0200 | [diff] [blame] | 223 | /* |
Linus Torvalds | 112db55 | 2008-06-22 12:19:25 -0700 | [diff] [blame] | 224 | * xread() is the same a read(), but it automatically restarts read() |
| 225 | * operations with a recoverable error (EAGAIN and EINTR). xread() |
| 226 | * DOES NOT GUARANTEE that "len" bytes is read even if the data is available. |
| 227 | */ |
| 228 | ssize_t xread(int fd, void *buf, size_t len) |
| 229 | { |
| 230 | ssize_t nr; |
Steffen Prohaska | 0b6806b | 2013-08-20 08:43:54 +0200 | [diff] [blame] | 231 | if (len > MAX_IO_SIZE) |
Denton Liu | 7cd54d3 | 2020-03-27 22:57:34 -0400 | [diff] [blame] | 232 | len = MAX_IO_SIZE; |
Linus Torvalds | 112db55 | 2008-06-22 12:19:25 -0700 | [diff] [blame] | 233 | while (1) { |
| 234 | nr = read(fd, buf, len); |
Stefan Beller | 1079c4b | 2015-12-15 16:04:07 -0800 | [diff] [blame] | 235 | if (nr < 0) { |
| 236 | if (errno == EINTR) |
| 237 | continue; |
Eric Wong | d751dd1 | 2016-07-10 08:20:46 +0000 | [diff] [blame] | 238 | if (handle_nonblock(fd, POLLIN, errno)) |
Eric Wong | c22f620 | 2016-06-27 03:56:35 +0000 | [diff] [blame] | 239 | continue; |
Stefan Beller | 1079c4b | 2015-12-15 16:04:07 -0800 | [diff] [blame] | 240 | } |
Linus Torvalds | 112db55 | 2008-06-22 12:19:25 -0700 | [diff] [blame] | 241 | return nr; |
| 242 | } |
| 243 | } |
| 244 | |
| 245 | /* |
| 246 | * xwrite() is the same a write(), but it automatically restarts write() |
| 247 | * operations with a recoverable error (EAGAIN and EINTR). xwrite() DOES NOT |
| 248 | * GUARANTEE that "len" bytes is written even if the operation is successful. |
| 249 | */ |
| 250 | ssize_t xwrite(int fd, const void *buf, size_t len) |
| 251 | { |
| 252 | ssize_t nr; |
Steffen Prohaska | 0b6806b | 2013-08-20 08:43:54 +0200 | [diff] [blame] | 253 | if (len > MAX_IO_SIZE) |
Denton Liu | 7cd54d3 | 2020-03-27 22:57:34 -0400 | [diff] [blame] | 254 | len = MAX_IO_SIZE; |
Linus Torvalds | 112db55 | 2008-06-22 12:19:25 -0700 | [diff] [blame] | 255 | while (1) { |
| 256 | nr = write(fd, buf, len); |
Eric Wong | ef1cf01 | 2016-06-26 23:21:12 +0000 | [diff] [blame] | 257 | if (nr < 0) { |
| 258 | if (errno == EINTR) |
| 259 | continue; |
Eric Wong | d751dd1 | 2016-07-10 08:20:46 +0000 | [diff] [blame] | 260 | if (handle_nonblock(fd, POLLOUT, errno)) |
Eric Wong | ef1cf01 | 2016-06-26 23:21:12 +0000 | [diff] [blame] | 261 | continue; |
Eric Wong | ef1cf01 | 2016-06-26 23:21:12 +0000 | [diff] [blame] | 262 | } |
| 263 | |
Linus Torvalds | 112db55 | 2008-06-22 12:19:25 -0700 | [diff] [blame] | 264 | return nr; |
| 265 | } |
| 266 | } |
| 267 | |
Yiannis Marangos | 9aa91af | 2014-04-10 21:54:12 +0300 | [diff] [blame] | 268 | /* |
| 269 | * xpread() is the same as pread(), but it automatically restarts pread() |
| 270 | * operations with a recoverable error (EAGAIN and EINTR). xpread() DOES |
| 271 | * NOT GUARANTEE that "len" bytes is read even if the data is available. |
| 272 | */ |
| 273 | ssize_t xpread(int fd, void *buf, size_t len, off_t offset) |
| 274 | { |
| 275 | ssize_t nr; |
| 276 | if (len > MAX_IO_SIZE) |
| 277 | len = MAX_IO_SIZE; |
| 278 | while (1) { |
| 279 | nr = pread(fd, buf, len, offset); |
| 280 | if ((nr < 0) && (errno == EAGAIN || errno == EINTR)) |
| 281 | continue; |
| 282 | return nr; |
| 283 | } |
| 284 | } |
| 285 | |
Junio C Hamano | 559e840 | 2008-07-20 16:13:05 -0700 | [diff] [blame] | 286 | ssize_t read_in_full(int fd, void *buf, size_t count) |
| 287 | { |
| 288 | char *p = buf; |
| 289 | ssize_t total = 0; |
| 290 | |
| 291 | while (count > 0) { |
| 292 | ssize_t loaded = xread(fd, p, count); |
Jeff King | 56d7c27 | 2011-05-26 12:30:27 -0400 | [diff] [blame] | 293 | if (loaded < 0) |
| 294 | return -1; |
| 295 | if (loaded == 0) |
| 296 | return total; |
Junio C Hamano | 559e840 | 2008-07-20 16:13:05 -0700 | [diff] [blame] | 297 | count -= loaded; |
| 298 | p += loaded; |
| 299 | total += loaded; |
| 300 | } |
| 301 | |
| 302 | return total; |
| 303 | } |
| 304 | |
| 305 | ssize_t write_in_full(int fd, const void *buf, size_t count) |
| 306 | { |
| 307 | const char *p = buf; |
| 308 | ssize_t total = 0; |
| 309 | |
| 310 | while (count > 0) { |
| 311 | ssize_t written = xwrite(fd, p, count); |
| 312 | if (written < 0) |
| 313 | return -1; |
| 314 | if (!written) { |
| 315 | errno = ENOSPC; |
| 316 | return -1; |
| 317 | } |
| 318 | count -= written; |
| 319 | p += written; |
| 320 | total += written; |
| 321 | } |
| 322 | |
| 323 | return total; |
| 324 | } |
| 325 | |
Yiannis Marangos | 426ddee | 2014-04-10 21:31:21 +0300 | [diff] [blame] | 326 | ssize_t pread_in_full(int fd, void *buf, size_t count, off_t offset) |
| 327 | { |
| 328 | char *p = buf; |
| 329 | ssize_t total = 0; |
| 330 | |
| 331 | while (count > 0) { |
| 332 | ssize_t loaded = xpread(fd, p, count, offset); |
| 333 | if (loaded < 0) |
| 334 | return -1; |
| 335 | if (loaded == 0) |
| 336 | return total; |
| 337 | count -= loaded; |
| 338 | p += loaded; |
| 339 | total += loaded; |
| 340 | offset += loaded; |
| 341 | } |
| 342 | |
| 343 | return total; |
| 344 | } |
| 345 | |
Linus Torvalds | 112db55 | 2008-06-22 12:19:25 -0700 | [diff] [blame] | 346 | int xdup(int fd) |
| 347 | { |
| 348 | int ret = dup(fd); |
| 349 | if (ret < 0) |
Thomas Rast | d824cbb | 2009-06-27 17:58:46 +0200 | [diff] [blame] | 350 | die_errno("dup failed"); |
Linus Torvalds | 112db55 | 2008-06-22 12:19:25 -0700 | [diff] [blame] | 351 | return ret; |
| 352 | } |
| 353 | |
Paul Tan | 260eec2 | 2015-08-04 21:51:23 +0800 | [diff] [blame] | 354 | /** |
| 355 | * xfopen() is the same as fopen(), but it die()s if the fopen() fails. |
| 356 | */ |
| 357 | FILE *xfopen(const char *path, const char *mode) |
| 358 | { |
| 359 | for (;;) { |
| 360 | FILE *fp = fopen(path, mode); |
| 361 | if (fp) |
| 362 | return fp; |
| 363 | if (errno == EINTR) |
| 364 | continue; |
| 365 | |
| 366 | if (*mode && mode[1] == '+') |
| 367 | die_errno(_("could not open '%s' for reading and writing"), path); |
| 368 | else if (*mode == 'w' || *mode == 'a') |
| 369 | die_errno(_("could not open '%s' for writing"), path); |
| 370 | else |
| 371 | die_errno(_("could not open '%s' for reading"), path); |
| 372 | } |
| 373 | } |
| 374 | |
Linus Torvalds | 112db55 | 2008-06-22 12:19:25 -0700 | [diff] [blame] | 375 | FILE *xfdopen(int fd, const char *mode) |
| 376 | { |
| 377 | FILE *stream = fdopen(fd, mode); |
| 378 | if (stream == NULL) |
Thomas Rast | d824cbb | 2009-06-27 17:58:46 +0200 | [diff] [blame] | 379 | die_errno("Out of memory? fdopen failed"); |
Linus Torvalds | 112db55 | 2008-06-22 12:19:25 -0700 | [diff] [blame] | 380 | return stream; |
| 381 | } |
| 382 | |
Johannes Schindelin | 79d7582 | 2016-01-06 14:09:43 +0100 | [diff] [blame] | 383 | FILE *fopen_for_writing(const char *path) |
| 384 | { |
| 385 | FILE *ret = fopen(path, "w"); |
| 386 | |
| 387 | if (!ret && errno == EPERM) { |
| 388 | if (!unlink(path)) |
| 389 | ret = fopen(path, "w"); |
| 390 | else |
| 391 | errno = EPERM; |
| 392 | } |
| 393 | return ret; |
| 394 | } |
| 395 | |
Nguyễn Thái Ngọc Duy | 382fb07 | 2017-05-08 17:40:37 +0700 | [diff] [blame] | 396 | static void warn_on_inaccessible(const char *path) |
| 397 | { |
| 398 | warning_errno(_("unable to access '%s'"), path); |
| 399 | } |
| 400 | |
Nguyễn Thái Ngọc Duy | 11dc1fc | 2017-05-03 17:16:49 +0700 | [diff] [blame] | 401 | int warn_on_fopen_errors(const char *path) |
| 402 | { |
| 403 | if (errno != ENOENT && errno != ENOTDIR) { |
| 404 | warn_on_inaccessible(path); |
| 405 | return -1; |
| 406 | } |
| 407 | |
| 408 | return 0; |
| 409 | } |
| 410 | |
Nguyễn Thái Ngọc Duy | e9d983f | 2017-05-03 17:16:50 +0700 | [diff] [blame] | 411 | FILE *fopen_or_warn(const char *path, const char *mode) |
| 412 | { |
| 413 | FILE *fp = fopen(path, mode); |
| 414 | |
| 415 | if (fp) |
| 416 | return fp; |
| 417 | |
| 418 | warn_on_fopen_errors(path); |
| 419 | return NULL; |
| 420 | } |
| 421 | |
Brandon Williams | eb78e23 | 2018-02-14 10:59:56 -0800 | [diff] [blame] | 422 | int xmkstemp(char *filename_template) |
Linus Torvalds | 112db55 | 2008-06-22 12:19:25 -0700 | [diff] [blame] | 423 | { |
| 424 | int fd; |
Arnout Engelen | 6cf6bb3 | 2010-12-18 22:28:00 +0100 | [diff] [blame] | 425 | char origtemplate[PATH_MAX]; |
Brandon Williams | eb78e23 | 2018-02-14 10:59:56 -0800 | [diff] [blame] | 426 | strlcpy(origtemplate, filename_template, sizeof(origtemplate)); |
Linus Torvalds | 112db55 | 2008-06-22 12:19:25 -0700 | [diff] [blame] | 427 | |
Brandon Williams | eb78e23 | 2018-02-14 10:59:56 -0800 | [diff] [blame] | 428 | fd = mkstemp(filename_template); |
Arnout Engelen | 6cf6bb3 | 2010-12-18 22:28:00 +0100 | [diff] [blame] | 429 | if (fd < 0) { |
| 430 | int saved_errno = errno; |
| 431 | const char *nonrelative_template; |
| 432 | |
Brandon Williams | eb78e23 | 2018-02-14 10:59:56 -0800 | [diff] [blame] | 433 | if (strlen(filename_template) != strlen(origtemplate)) |
| 434 | filename_template = origtemplate; |
Arnout Engelen | 6cf6bb3 | 2010-12-18 22:28:00 +0100 | [diff] [blame] | 435 | |
Brandon Williams | eb78e23 | 2018-02-14 10:59:56 -0800 | [diff] [blame] | 436 | nonrelative_template = absolute_path(filename_template); |
Arnout Engelen | 6cf6bb3 | 2010-12-18 22:28:00 +0100 | [diff] [blame] | 437 | errno = saved_errno; |
| 438 | die_errno("Unable to create temporary file '%s'", |
| 439 | nonrelative_template); |
| 440 | } |
Linus Torvalds | 112db55 | 2008-06-22 12:19:25 -0700 | [diff] [blame] | 441 | return fd; |
| 442 | } |
Linus Torvalds | 39c6854 | 2009-01-07 19:54:47 -0800 | [diff] [blame] | 443 | |
Jonathan Nieder | 33f2393 | 2010-11-06 06:46:31 -0500 | [diff] [blame] | 444 | /* Adapted from libiberty's mkstemp.c. */ |
| 445 | |
| 446 | #undef TMP_MAX |
| 447 | #define TMP_MAX 16384 |
| 448 | |
| 449 | int git_mkstemps_mode(char *pattern, int suffix_len, int mode) |
| 450 | { |
| 451 | static const char letters[] = |
| 452 | "abcdefghijklmnopqrstuvwxyz" |
| 453 | "ABCDEFGHIJKLMNOPQRSTUVWXYZ" |
| 454 | "0123456789"; |
Jeff King | 53d687b | 2019-10-02 11:32:07 -0400 | [diff] [blame] | 455 | static const int num_letters = ARRAY_SIZE(letters) - 1; |
| 456 | static const char x_pattern[] = "XXXXXX"; |
| 457 | static const int num_x = ARRAY_SIZE(x_pattern) - 1; |
Jonathan Nieder | 33f2393 | 2010-11-06 06:46:31 -0500 | [diff] [blame] | 458 | uint64_t value; |
| 459 | struct timeval tv; |
Brandon Williams | eb78e23 | 2018-02-14 10:59:56 -0800 | [diff] [blame] | 460 | char *filename_template; |
Jonathan Nieder | 33f2393 | 2010-11-06 06:46:31 -0500 | [diff] [blame] | 461 | size_t len; |
| 462 | int fd, count; |
| 463 | |
| 464 | len = strlen(pattern); |
| 465 | |
Jeff King | 53d687b | 2019-10-02 11:32:07 -0400 | [diff] [blame] | 466 | if (len < num_x + suffix_len) { |
Jonathan Nieder | 33f2393 | 2010-11-06 06:46:31 -0500 | [diff] [blame] | 467 | errno = EINVAL; |
| 468 | return -1; |
| 469 | } |
| 470 | |
Jeff King | 53d687b | 2019-10-02 11:32:07 -0400 | [diff] [blame] | 471 | if (strncmp(&pattern[len - num_x - suffix_len], x_pattern, num_x)) { |
Jonathan Nieder | 33f2393 | 2010-11-06 06:46:31 -0500 | [diff] [blame] | 472 | errno = EINVAL; |
| 473 | return -1; |
| 474 | } |
| 475 | |
| 476 | /* |
| 477 | * Replace pattern's XXXXXX characters with randomness. |
| 478 | * Try TMP_MAX different filenames. |
| 479 | */ |
| 480 | gettimeofday(&tv, NULL); |
Carlo Marcelo Arenas Belón | 729a9b5 | 2019-06-16 11:40:03 -0700 | [diff] [blame] | 481 | value = ((uint64_t)tv.tv_usec << 16) ^ tv.tv_sec ^ getpid(); |
Jeff King | 53d687b | 2019-10-02 11:32:07 -0400 | [diff] [blame] | 482 | filename_template = &pattern[len - num_x - suffix_len]; |
Jonathan Nieder | 33f2393 | 2010-11-06 06:46:31 -0500 | [diff] [blame] | 483 | for (count = 0; count < TMP_MAX; ++count) { |
| 484 | uint64_t v = value; |
Alex Henrie | 54a80a9 | 2019-09-30 20:29:36 -0600 | [diff] [blame] | 485 | int i; |
Jonathan Nieder | 33f2393 | 2010-11-06 06:46:31 -0500 | [diff] [blame] | 486 | /* Fill in the random bits. */ |
Jeff King | 53d687b | 2019-10-02 11:32:07 -0400 | [diff] [blame] | 487 | for (i = 0; i < num_x; i++) { |
Alex Henrie | 54a80a9 | 2019-09-30 20:29:36 -0600 | [diff] [blame] | 488 | filename_template[i] = letters[v % num_letters]; |
| 489 | v /= num_letters; |
| 490 | } |
Jonathan Nieder | 33f2393 | 2010-11-06 06:46:31 -0500 | [diff] [blame] | 491 | |
| 492 | fd = open(pattern, O_CREAT | O_EXCL | O_RDWR, mode); |
Dale R. Worley | a2cb86c | 2013-07-12 10:58:35 +0200 | [diff] [blame] | 493 | if (fd >= 0) |
Jonathan Nieder | 33f2393 | 2010-11-06 06:46:31 -0500 | [diff] [blame] | 494 | return fd; |
| 495 | /* |
| 496 | * Fatal error (EPERM, ENOSPC etc). |
| 497 | * It doesn't make sense to loop. |
| 498 | */ |
| 499 | if (errno != EEXIST) |
| 500 | break; |
| 501 | /* |
| 502 | * This is a random value. It is only necessary that |
| 503 | * the next TMP_MAX values generated by adding 7777 to |
| 504 | * VALUE are different with (module 2^32). |
| 505 | */ |
| 506 | value += 7777; |
| 507 | } |
| 508 | /* We return the null string if we can't find a unique file name. */ |
| 509 | pattern[0] = '\0'; |
| 510 | return -1; |
| 511 | } |
| 512 | |
| 513 | int git_mkstemp_mode(char *pattern, int mode) |
| 514 | { |
| 515 | /* mkstemp is just mkstemps with no suffix */ |
| 516 | return git_mkstemps_mode(pattern, 0, mode); |
| 517 | } |
| 518 | |
Brandon Williams | eb78e23 | 2018-02-14 10:59:56 -0800 | [diff] [blame] | 519 | int xmkstemp_mode(char *filename_template, int mode) |
Matthieu Moy | b862b61 | 2010-02-22 23:32:13 +0100 | [diff] [blame] | 520 | { |
| 521 | int fd; |
Arnout Engelen | 6cf6bb3 | 2010-12-18 22:28:00 +0100 | [diff] [blame] | 522 | char origtemplate[PATH_MAX]; |
Brandon Williams | eb78e23 | 2018-02-14 10:59:56 -0800 | [diff] [blame] | 523 | strlcpy(origtemplate, filename_template, sizeof(origtemplate)); |
Matthieu Moy | b862b61 | 2010-02-22 23:32:13 +0100 | [diff] [blame] | 524 | |
Brandon Williams | eb78e23 | 2018-02-14 10:59:56 -0800 | [diff] [blame] | 525 | fd = git_mkstemp_mode(filename_template, mode); |
Arnout Engelen | 6cf6bb3 | 2010-12-18 22:28:00 +0100 | [diff] [blame] | 526 | if (fd < 0) { |
| 527 | int saved_errno = errno; |
| 528 | const char *nonrelative_template; |
| 529 | |
Brandon Williams | eb78e23 | 2018-02-14 10:59:56 -0800 | [diff] [blame] | 530 | if (!filename_template[0]) |
| 531 | filename_template = origtemplate; |
Arnout Engelen | 6cf6bb3 | 2010-12-18 22:28:00 +0100 | [diff] [blame] | 532 | |
Brandon Williams | eb78e23 | 2018-02-14 10:59:56 -0800 | [diff] [blame] | 533 | nonrelative_template = absolute_path(filename_template); |
Arnout Engelen | 6cf6bb3 | 2010-12-18 22:28:00 +0100 | [diff] [blame] | 534 | errno = saved_errno; |
| 535 | die_errno("Unable to create temporary file '%s'", |
| 536 | nonrelative_template); |
| 537 | } |
Matthieu Moy | b862b61 | 2010-02-22 23:32:13 +0100 | [diff] [blame] | 538 | return fd; |
| 539 | } |
| 540 | |
Peter Collingbourne | 10e13ec | 2010-03-26 15:25:32 +0000 | [diff] [blame] | 541 | static int warn_if_unremovable(const char *op, const char *file, int rc) |
Alex Riesen | fc71db3 | 2009-04-29 23:21:46 +0200 | [diff] [blame] | 542 | { |
Ronnie Sahlberg | 1054af7 | 2014-07-16 11:01:18 -0700 | [diff] [blame] | 543 | int err; |
| 544 | if (!rc || errno == ENOENT) |
| 545 | return 0; |
| 546 | err = errno; |
Simon Ruderich | 0a288d1 | 2017-11-01 15:44:44 +0100 | [diff] [blame] | 547 | warning_errno("unable to %s '%s'", op, file); |
Ronnie Sahlberg | 1054af7 | 2014-07-16 11:01:18 -0700 | [diff] [blame] | 548 | errno = err; |
Alex Riesen | fc71db3 | 2009-04-29 23:21:46 +0200 | [diff] [blame] | 549 | return rc; |
| 550 | } |
| 551 | |
Ronnie Sahlberg | 9ccc0c0 | 2014-07-16 11:20:36 -0700 | [diff] [blame] | 552 | int unlink_or_msg(const char *file, struct strbuf *err) |
| 553 | { |
| 554 | int rc = unlink(file); |
| 555 | |
| 556 | assert(err); |
| 557 | |
| 558 | if (!rc || errno == ENOENT) |
| 559 | return 0; |
| 560 | |
Simon Ruderich | 0a288d1 | 2017-11-01 15:44:44 +0100 | [diff] [blame] | 561 | strbuf_addf(err, "unable to unlink '%s': %s", |
Ronnie Sahlberg | 9ccc0c0 | 2014-07-16 11:20:36 -0700 | [diff] [blame] | 562 | file, strerror(errno)); |
| 563 | return -1; |
| 564 | } |
| 565 | |
Peter Collingbourne | 10e13ec | 2010-03-26 15:25:32 +0000 | [diff] [blame] | 566 | int unlink_or_warn(const char *file) |
| 567 | { |
| 568 | return warn_if_unremovable("unlink", file, unlink(file)); |
| 569 | } |
Peter Collingbourne | d172329 | 2010-03-26 15:25:33 +0000 | [diff] [blame] | 570 | |
| 571 | int rmdir_or_warn(const char *file) |
| 572 | { |
| 573 | return warn_if_unremovable("rmdir", file, rmdir(file)); |
| 574 | } |
Peter Collingbourne | 80d706a | 2010-03-26 15:25:34 +0000 | [diff] [blame] | 575 | |
| 576 | int remove_or_warn(unsigned int mode, const char *file) |
| 577 | { |
| 578 | return S_ISGITLINK(mode) ? rmdir_or_warn(file) : unlink_or_warn(file); |
| 579 | } |
Jeff King | 2f70587 | 2012-05-21 19:10:20 -0400 | [diff] [blame] | 580 | |
Jonathan Nieder | 4698c8f | 2013-04-12 14:03:18 -0700 | [diff] [blame] | 581 | static int access_error_is_ok(int err, unsigned flag) |
| 582 | { |
Junio C Hamano | c705420 | 2017-05-30 09:23:33 +0900 | [diff] [blame] | 583 | return (is_missing_file_error(err) || |
| 584 | ((flag & ACCESS_EACCES_OK) && err == EACCES)); |
Jonathan Nieder | 4698c8f | 2013-04-12 14:03:18 -0700 | [diff] [blame] | 585 | } |
| 586 | |
| 587 | int access_or_warn(const char *path, int mode, unsigned flag) |
Jeff King | ba8bd83 | 2012-08-21 02:10:59 -0400 | [diff] [blame] | 588 | { |
| 589 | int ret = access(path, mode); |
Jonathan Nieder | 4698c8f | 2013-04-12 14:03:18 -0700 | [diff] [blame] | 590 | if (ret && !access_error_is_ok(errno, flag)) |
Junio C Hamano | 55b38a4 | 2012-08-21 14:52:07 -0700 | [diff] [blame] | 591 | warn_on_inaccessible(path); |
Jeff King | ba8bd83 | 2012-08-21 02:10:59 -0400 | [diff] [blame] | 592 | return ret; |
| 593 | } |
| 594 | |
Jonathan Nieder | 4698c8f | 2013-04-12 14:03:18 -0700 | [diff] [blame] | 595 | int access_or_die(const char *path, int mode, unsigned flag) |
Jonathan Nieder | 96b9e0e | 2012-10-13 17:04:02 -0700 | [diff] [blame] | 596 | { |
| 597 | int ret = access(path, mode); |
Jonathan Nieder | 4698c8f | 2013-04-12 14:03:18 -0700 | [diff] [blame] | 598 | if (ret && !access_error_is_ok(errno, flag)) |
Jonathan Nieder | 96b9e0e | 2012-10-13 17:04:02 -0700 | [diff] [blame] | 599 | die_errno(_("unable to access '%s'"), path); |
| 600 | return ret; |
| 601 | } |
| 602 | |
René Scharfe | aa14e98 | 2014-07-28 20:29:50 +0200 | [diff] [blame] | 603 | char *xgetcwd(void) |
| 604 | { |
| 605 | struct strbuf sb = STRBUF_INIT; |
| 606 | if (strbuf_getcwd(&sb)) |
| 607 | die_errno(_("unable to get current working directory")); |
| 608 | return strbuf_detach(&sb, NULL); |
| 609 | } |
Nguyễn Thái Ngọc Duy | 316e53e | 2014-11-30 15:24:45 +0700 | [diff] [blame] | 610 | |
Jeff King | 7b03c89 | 2015-09-24 17:05:37 -0400 | [diff] [blame] | 611 | int xsnprintf(char *dst, size_t max, const char *fmt, ...) |
| 612 | { |
| 613 | va_list ap; |
| 614 | int len; |
| 615 | |
| 616 | va_start(ap, fmt); |
| 617 | len = vsnprintf(dst, max, fmt, ap); |
| 618 | va_end(ap); |
| 619 | |
| 620 | if (len < 0) |
Johannes Schindelin | 033abf9 | 2018-05-02 11:38:39 +0200 | [diff] [blame] | 621 | BUG("your snprintf is broken"); |
Jeff King | 7b03c89 | 2015-09-24 17:05:37 -0400 | [diff] [blame] | 622 | if (len >= max) |
Johannes Schindelin | 033abf9 | 2018-05-02 11:38:39 +0200 | [diff] [blame] | 623 | BUG("attempt to snprintf into too-small buffer"); |
Jeff King | 7b03c89 | 2015-09-24 17:05:37 -0400 | [diff] [blame] | 624 | return len; |
| 625 | } |
| 626 | |
Jeff King | 52563d7 | 2016-07-08 05:12:22 -0400 | [diff] [blame] | 627 | void write_file_buf(const char *path, const char *buf, size_t len) |
Nguyễn Thái Ngọc Duy | 316e53e | 2014-11-30 15:24:45 +0700 | [diff] [blame] | 628 | { |
Jeff King | 52563d7 | 2016-07-08 05:12:22 -0400 | [diff] [blame] | 629 | int fd = xopen(path, O_WRONLY | O_CREAT | O_TRUNC, 0666); |
Jeff King | 06f46f2 | 2017-09-13 13:16:03 -0400 | [diff] [blame] | 630 | if (write_in_full(fd, buf, len) < 0) |
Simon Ruderich | 0a288d1 | 2017-11-01 15:44:44 +0100 | [diff] [blame] | 631 | die_errno(_("could not write to '%s'"), path); |
Jeff King | 52563d7 | 2016-07-08 05:12:22 -0400 | [diff] [blame] | 632 | if (close(fd)) |
Simon Ruderich | 0a288d1 | 2017-11-01 15:44:44 +0100 | [diff] [blame] | 633 | die_errno(_("could not close '%s'"), path); |
Jeff King | 52563d7 | 2016-07-08 05:12:22 -0400 | [diff] [blame] | 634 | } |
| 635 | |
Jeff King | ef22318 | 2016-07-08 05:09:34 -0400 | [diff] [blame] | 636 | void write_file(const char *path, const char *fmt, ...) |
Nguyễn Thái Ngọc Duy | 316e53e | 2014-11-30 15:24:45 +0700 | [diff] [blame] | 637 | { |
Jeff King | ef22318 | 2016-07-08 05:09:34 -0400 | [diff] [blame] | 638 | va_list params; |
Nguyễn Thái Ngọc Duy | 316e53e | 2014-11-30 15:24:45 +0700 | [diff] [blame] | 639 | struct strbuf sb = STRBUF_INIT; |
Jeff King | ef22318 | 2016-07-08 05:09:34 -0400 | [diff] [blame] | 640 | |
| 641 | va_start(params, fmt); |
Nguyễn Thái Ngọc Duy | 316e53e | 2014-11-30 15:24:45 +0700 | [diff] [blame] | 642 | strbuf_vaddf(&sb, fmt, params); |
Jeff King | ef22318 | 2016-07-08 05:09:34 -0400 | [diff] [blame] | 643 | va_end(params); |
| 644 | |
Junio C Hamano | e7ffa38 | 2015-08-24 09:39:48 -0700 | [diff] [blame] | 645 | strbuf_complete_line(&sb); |
Jeff King | 52563d7 | 2016-07-08 05:12:22 -0400 | [diff] [blame] | 646 | |
| 647 | write_file_buf(path, sb.buf, sb.len); |
Nguyễn Thái Ngọc Duy | 316e53e | 2014-11-30 15:24:45 +0700 | [diff] [blame] | 648 | strbuf_release(&sb); |
Junio C Hamano | 12d6ce1 | 2015-08-24 13:03:07 -0700 | [diff] [blame] | 649 | } |
| 650 | |
Johannes Sixt | 2024d31 | 2015-06-05 21:45:05 +0200 | [diff] [blame] | 651 | void sleep_millisec(int millisec) |
| 652 | { |
| 653 | poll(NULL, 0, millisec); |
| 654 | } |
David Turner | 5781a9a | 2017-04-18 17:57:43 -0400 | [diff] [blame] | 655 | |
| 656 | int xgethostname(char *buf, size_t len) |
| 657 | { |
| 658 | /* |
| 659 | * If the full hostname doesn't fit in buf, POSIX does not |
| 660 | * specify whether the buffer will be null-terminated, so to |
| 661 | * be safe, do it ourselves. |
| 662 | */ |
| 663 | int ret = gethostname(buf, len); |
| 664 | if (!ret) |
| 665 | buf[len - 1] = 0; |
| 666 | return ret; |
| 667 | } |
Pranit Bauva | e3b1e3b | 2019-01-02 07:38:32 -0800 | [diff] [blame] | 668 | |
| 669 | int is_empty_or_missing_file(const char *filename) |
| 670 | { |
| 671 | struct stat st; |
| 672 | |
| 673 | if (stat(filename, &st) < 0) { |
| 674 | if (errno == ENOENT) |
| 675 | return 1; |
| 676 | die_errno(_("could not stat %s"), filename); |
| 677 | } |
| 678 | |
| 679 | return !st.st_size; |
| 680 | } |
Jeff King | 00611d8 | 2021-02-16 09:44:22 -0500 | [diff] [blame] | 681 | |
| 682 | int open_nofollow(const char *path, int flags) |
| 683 | { |
| 684 | #ifdef O_NOFOLLOW |
| 685 | return open(path, flags | O_NOFOLLOW); |
| 686 | #else |
| 687 | struct stat st; |
| 688 | if (lstat(path, &st) < 0) |
| 689 | return -1; |
| 690 | if (S_ISLNK(st.st_mode)) { |
| 691 | errno = ELOOP; |
| 692 | return -1; |
| 693 | } |
| 694 | return open(path, flags); |
| 695 | #endif |
| 696 | } |