t4038: Remove non-portable '-a' option passed to test_cmp
[git/git.git] / wrapper.c
CommitLineData
112db553
LT
1/*
2 * Various trivial helper wrappers around standard functions
3 */
4#include "cache.h"
b2141fc1 5#include "config.h"
112db553 6
e0500293 7static void do_nothing(size_t size)
a9a74636 8{
a9a74636
NP
9}
10
e0500293 11static void (*try_to_free_routine)(size_t size) = do_nothing;
a9a74636 12
f8bb1d94 13static int memory_limit_check(size_t size, int gentle)
d41489a6 14{
9927d962
SP
15 static size_t limit = 0;
16 if (!limit) {
17 limit = git_env_ulong("GIT_ALLOC_LIMIT", 0);
18 if (!limit)
19 limit = SIZE_MAX;
d41489a6 20 }
f0d89001 21 if (size > limit) {
f8bb1d94 22 if (gentle) {
f0d89001
JH
23 error("attempting to allocate %"PRIuMAX" over limit %"PRIuMAX,
24 (uintmax_t)size, (uintmax_t)limit);
f8bb1d94
NTND
25 return -1;
26 } else
f0d89001
JH
27 die("attempting to allocate %"PRIuMAX" over limit %"PRIuMAX,
28 (uintmax_t)size, (uintmax_t)limit);
f8bb1d94
NTND
29 }
30 return 0;
d41489a6
NTND
31}
32
851c34b0 33try_to_free_t set_try_to_free_routine(try_to_free_t routine)
a9a74636 34{
851c34b0 35 try_to_free_t old = try_to_free_routine;
00b0d7f7
JH
36 if (!routine)
37 routine = do_nothing;
851c34b0
JS
38 try_to_free_routine = routine;
39 return old;
a9a74636
NP
40}
41
112db553
LT
42char *xstrdup(const char *str)
43{
44 char *ret = strdup(str);
45 if (!ret) {
a9a74636 46 try_to_free_routine(strlen(str) + 1);
112db553
LT
47 ret = strdup(str);
48 if (!ret)
49 die("Out of memory, strdup failed");
50 }
51 return ret;
52}
53
f8bb1d94 54static void *do_xmalloc(size_t size, int gentle)
112db553 55{
d41489a6
NTND
56 void *ret;
57
f8bb1d94
NTND
58 if (memory_limit_check(size, gentle))
59 return NULL;
d41489a6 60 ret = malloc(size);
112db553
LT
61 if (!ret && !size)
62 ret = malloc(1);
63 if (!ret) {
a9a74636 64 try_to_free_routine(size);
112db553
LT
65 ret = malloc(size);
66 if (!ret && !size)
67 ret = malloc(1);
f8bb1d94
NTND
68 if (!ret) {
69 if (!gentle)
70 die("Out of memory, malloc failed (tried to allocate %lu bytes)",
71 (unsigned long)size);
72 else {
73 error("Out of memory, malloc failed (tried to allocate %lu bytes)",
74 (unsigned long)size);
75 return NULL;
76 }
77 }
112db553
LT
78 }
79#ifdef XMALLOC_POISON
80 memset(ret, 0xA5, size);
81#endif
82 return ret;
83}
84
f8bb1d94
NTND
85void *xmalloc(size_t size)
86{
87 return do_xmalloc(size, 0);
88}
89
90static void *do_xmallocz(size_t size, int gentle)
5bf9219d
IL
91{
92 void *ret;
f8bb1d94
NTND
93 if (unsigned_add_overflows(size, 1)) {
94 if (gentle) {
95 error("Data too large to fit into virtual memory space.");
96 return NULL;
97 } else
98 die("Data too large to fit into virtual memory space.");
99 }
100 ret = do_xmalloc(size + 1, gentle);
101 if (ret)
102 ((char*)ret)[size] = 0;
5bf9219d
IL
103 return ret;
104}
105
f8bb1d94
NTND
106void *xmallocz(size_t size)
107{
108 return do_xmallocz(size, 0);
109}
110
111void *xmallocz_gently(size_t size)
112{
113 return do_xmallocz(size, 1);
114}
115
112db553
LT
116/*
117 * xmemdupz() allocates (len + 1) bytes of memory, duplicates "len" bytes of
118 * "data" to the allocated memory, zero terminates the allocated memory,
119 * and returns a pointer to the allocated memory. If the allocation fails,
120 * the program dies.
121 */
122void *xmemdupz(const void *data, size_t len)
123{
5bf9219d 124 return memcpy(xmallocz(len), data, len);
112db553
LT
125}
126
127char *xstrndup(const char *str, size_t len)
128{
129 char *p = memchr(str, '\0', len);
130 return xmemdupz(str, p ? p - str : len);
131}
132
133void *xrealloc(void *ptr, size_t size)
134{
d41489a6
NTND
135 void *ret;
136
f8bb1d94 137 memory_limit_check(size, 0);
d41489a6 138 ret = realloc(ptr, size);
112db553
LT
139 if (!ret && !size)
140 ret = realloc(ptr, 1);
141 if (!ret) {
a9a74636 142 try_to_free_routine(size);
112db553
LT
143 ret = realloc(ptr, size);
144 if (!ret && !size)
145 ret = realloc(ptr, 1);
146 if (!ret)
147 die("Out of memory, realloc failed");
148 }
149 return ret;
150}
151
152void *xcalloc(size_t nmemb, size_t size)
153{
d41489a6
NTND
154 void *ret;
155
e7792a74
JK
156 if (unsigned_mult_overflows(nmemb, size))
157 die("data too large to fit into virtual memory space");
158
f8bb1d94 159 memory_limit_check(size * nmemb, 0);
d41489a6 160 ret = calloc(nmemb, size);
112db553
LT
161 if (!ret && (!nmemb || !size))
162 ret = calloc(1, 1);
163 if (!ret) {
a9a74636 164 try_to_free_routine(nmemb * size);
112db553
LT
165 ret = calloc(nmemb, size);
166 if (!ret && (!nmemb || !size))
167 ret = calloc(1, 1);
168 if (!ret)
169 die("Out of memory, calloc failed");
170 }
171 return ret;
172}
173
0b6806b9
SP
174/*
175 * Limit size of IO chunks, because huge chunks only cause pain. OS X
176 * 64-bit is buggy, returning EINVAL if len >= INT_MAX; and even in
382d20e3 177 * the absence of bugs, large chunks can result in bad latencies when
0b6806b9 178 * you decide to kill the process.
a983e6ac
JH
179 *
180 * We pick 8 MiB as our default, but if the platform defines SSIZE_MAX
181 * that is smaller than that, clip it to SSIZE_MAX, as a call to
182 * read(2) or write(2) larger than that is allowed to fail. As the last
183 * resort, we allow a port to pass via CFLAGS e.g. "-DMAX_IO_SIZE=value"
184 * to override this, if the definition of SSIZE_MAX given by the platform
185 * is broken.
0b6806b9 186 */
a983e6ac
JH
187#ifndef MAX_IO_SIZE
188# define MAX_IO_SIZE_DEFAULT (8*1024*1024)
189# if defined(SSIZE_MAX) && (SSIZE_MAX < MAX_IO_SIZE_DEFAULT)
190# define MAX_IO_SIZE SSIZE_MAX
191# else
192# define MAX_IO_SIZE MAX_IO_SIZE_DEFAULT
193# endif
194#endif
0b6806b9 195
3ff53df7
PT
196/**
197 * xopen() is the same as open(), but it die()s if the open() fails.
198 */
199int xopen(const char *path, int oflag, ...)
200{
201 mode_t mode = 0;
202 va_list ap;
203
204 /*
205 * va_arg() will have undefined behavior if the specified type is not
206 * compatible with the argument type. Since integers are promoted to
207 * ints, we fetch the next argument as an int, and then cast it to a
208 * mode_t to avoid undefined behavior.
209 */
210 va_start(ap, oflag);
211 if (oflag & O_CREAT)
212 mode = va_arg(ap, int);
213 va_end(ap);
214
215 for (;;) {
216 int fd = open(path, oflag, mode);
217 if (fd >= 0)
218 return fd;
219 if (errno == EINTR)
220 continue;
221
222 if ((oflag & O_RDWR) == O_RDWR)
223 die_errno(_("could not open '%s' for reading and writing"), path);
224 else if ((oflag & O_WRONLY) == O_WRONLY)
225 die_errno(_("could not open '%s' for writing"), path);
226 else
227 die_errno(_("could not open '%s' for reading"), path);
228 }
229}
230
d751dd11
EW
231static int handle_nonblock(int fd, short poll_events, int err)
232{
233 struct pollfd pfd;
234
235 if (err != EAGAIN && err != EWOULDBLOCK)
236 return 0;
237
238 pfd.fd = fd;
239 pfd.events = poll_events;
240
241 /*
242 * no need to check for errors, here;
243 * a subsequent read/write will detect unrecoverable errors
244 */
245 poll(&pfd, 1, -1);
246 return 1;
247}
248
112db553
LT
249/*
250 * xread() is the same a read(), but it automatically restarts read()
251 * operations with a recoverable error (EAGAIN and EINTR). xread()
252 * DOES NOT GUARANTEE that "len" bytes is read even if the data is available.
253 */
254ssize_t xread(int fd, void *buf, size_t len)
255{
256 ssize_t nr;
0b6806b9
SP
257 if (len > MAX_IO_SIZE)
258 len = MAX_IO_SIZE;
112db553
LT
259 while (1) {
260 nr = read(fd, buf, len);
1079c4be
SB
261 if (nr < 0) {
262 if (errno == EINTR)
263 continue;
d751dd11 264 if (handle_nonblock(fd, POLLIN, errno))
c22f6202 265 continue;
1079c4be 266 }
112db553
LT
267 return nr;
268 }
269}
270
271/*
272 * xwrite() is the same a write(), but it automatically restarts write()
273 * operations with a recoverable error (EAGAIN and EINTR). xwrite() DOES NOT
274 * GUARANTEE that "len" bytes is written even if the operation is successful.
275 */
276ssize_t xwrite(int fd, const void *buf, size_t len)
277{
278 ssize_t nr;
0b6806b9
SP
279 if (len > MAX_IO_SIZE)
280 len = MAX_IO_SIZE;
112db553
LT
281 while (1) {
282 nr = write(fd, buf, len);
ef1cf016
EW
283 if (nr < 0) {
284 if (errno == EINTR)
285 continue;
d751dd11 286 if (handle_nonblock(fd, POLLOUT, errno))
ef1cf016 287 continue;
ef1cf016
EW
288 }
289
9aa91af0
YM
290 return nr;
291 }
292}
293
294/*
295 * xpread() is the same as pread(), but it automatically restarts pread()
296 * operations with a recoverable error (EAGAIN and EINTR). xpread() DOES
297 * NOT GUARANTEE that "len" bytes is read even if the data is available.
298 */
299ssize_t xpread(int fd, void *buf, size_t len, off_t offset)
300{
301 ssize_t nr;
302 if (len > MAX_IO_SIZE)
303 len = MAX_IO_SIZE;
304 while (1) {
305 nr = pread(fd, buf, len, offset);
306 if ((nr < 0) && (errno == EAGAIN || errno == EINTR))
112db553
LT
307 continue;
308 return nr;
309 }
310}
311
559e840b
JH
312ssize_t read_in_full(int fd, void *buf, size_t count)
313{
314 char *p = buf;
315 ssize_t total = 0;
316
317 while (count > 0) {
318 ssize_t loaded = xread(fd, p, count);
56d7c27a
JK
319 if (loaded < 0)
320 return -1;
321 if (loaded == 0)
322 return total;
559e840b
JH
323 count -= loaded;
324 p += loaded;
325 total += loaded;
326 }
327
328 return total;
329}
330
331ssize_t write_in_full(int fd, const void *buf, size_t count)
332{
333 const char *p = buf;
334 ssize_t total = 0;
335
336 while (count > 0) {
337 ssize_t written = xwrite(fd, p, count);
338 if (written < 0)
339 return -1;
340 if (!written) {
341 errno = ENOSPC;
342 return -1;
343 }
344 count -= written;
345 p += written;
346 total += written;
347 }
348
349 return total;
350}
351
426ddeea
YM
352ssize_t pread_in_full(int fd, void *buf, size_t count, off_t offset)
353{
354 char *p = buf;
355 ssize_t total = 0;
356
357 while (count > 0) {
358 ssize_t loaded = xpread(fd, p, count, offset);
359 if (loaded < 0)
360 return -1;
361 if (loaded == 0)
362 return total;
363 count -= loaded;
364 p += loaded;
365 total += loaded;
366 offset += loaded;
367 }
368
369 return total;
370}
371
112db553
LT
372int xdup(int fd)
373{
374 int ret = dup(fd);
375 if (ret < 0)
d824cbba 376 die_errno("dup failed");
112db553
LT
377 return ret;
378}
379
260eec29
PT
380/**
381 * xfopen() is the same as fopen(), but it die()s if the fopen() fails.
382 */
383FILE *xfopen(const char *path, const char *mode)
384{
385 for (;;) {
386 FILE *fp = fopen(path, mode);
387 if (fp)
388 return fp;
389 if (errno == EINTR)
390 continue;
391
392 if (*mode && mode[1] == '+')
393 die_errno(_("could not open '%s' for reading and writing"), path);
394 else if (*mode == 'w' || *mode == 'a')
395 die_errno(_("could not open '%s' for writing"), path);
396 else
397 die_errno(_("could not open '%s' for reading"), path);
398 }
399}
400
112db553
LT
401FILE *xfdopen(int fd, const char *mode)
402{
403 FILE *stream = fdopen(fd, mode);
404 if (stream == NULL)
d824cbba 405 die_errno("Out of memory? fdopen failed");
112db553
LT
406 return stream;
407}
408
79d7582e
JS
409FILE *fopen_for_writing(const char *path)
410{
411 FILE *ret = fopen(path, "w");
412
413 if (!ret && errno == EPERM) {
414 if (!unlink(path))
415 ret = fopen(path, "w");
416 else
417 errno = EPERM;
418 }
419 return ret;
420}
421
382fb07f
NTND
422static void warn_on_inaccessible(const char *path)
423{
424 warning_errno(_("unable to access '%s'"), path);
425}
426
11dc1fcb
NTND
427int warn_on_fopen_errors(const char *path)
428{
429 if (errno != ENOENT && errno != ENOTDIR) {
430 warn_on_inaccessible(path);
431 return -1;
432 }
433
434 return 0;
435}
436
e9d983f1
NTND
437FILE *fopen_or_warn(const char *path, const char *mode)
438{
439 FILE *fp = fopen(path, mode);
440
441 if (fp)
442 return fp;
443
444 warn_on_fopen_errors(path);
445 return NULL;
446}
447
eb78e23f 448int xmkstemp(char *filename_template)
112db553
LT
449{
450 int fd;
6cf6bb3e 451 char origtemplate[PATH_MAX];
eb78e23f 452 strlcpy(origtemplate, filename_template, sizeof(origtemplate));
112db553 453
eb78e23f 454 fd = mkstemp(filename_template);
6cf6bb3e
AE
455 if (fd < 0) {
456 int saved_errno = errno;
457 const char *nonrelative_template;
458
eb78e23f
BW
459 if (strlen(filename_template) != strlen(origtemplate))
460 filename_template = origtemplate;
6cf6bb3e 461
eb78e23f 462 nonrelative_template = absolute_path(filename_template);
6cf6bb3e
AE
463 errno = saved_errno;
464 die_errno("Unable to create temporary file '%s'",
465 nonrelative_template);
466 }
112db553
LT
467 return fd;
468}
39c68542 469
33f23936
JN
470/* Adapted from libiberty's mkstemp.c. */
471
472#undef TMP_MAX
473#define TMP_MAX 16384
474
475int git_mkstemps_mode(char *pattern, int suffix_len, int mode)
476{
477 static const char letters[] =
478 "abcdefghijklmnopqrstuvwxyz"
479 "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
480 "0123456789";
481 static const int num_letters = 62;
482 uint64_t value;
483 struct timeval tv;
eb78e23f 484 char *filename_template;
33f23936
JN
485 size_t len;
486 int fd, count;
487
488 len = strlen(pattern);
489
490 if (len < 6 + suffix_len) {
491 errno = EINVAL;
492 return -1;
493 }
494
495 if (strncmp(&pattern[len - 6 - suffix_len], "XXXXXX", 6)) {
496 errno = EINVAL;
497 return -1;
498 }
499
500 /*
501 * Replace pattern's XXXXXX characters with randomness.
502 * Try TMP_MAX different filenames.
503 */
504 gettimeofday(&tv, NULL);
729a9b55 505 value = ((uint64_t)tv.tv_usec << 16) ^ tv.tv_sec ^ getpid();
eb78e23f 506 filename_template = &pattern[len - 6 - suffix_len];
33f23936
JN
507 for (count = 0; count < TMP_MAX; ++count) {
508 uint64_t v = value;
509 /* Fill in the random bits. */
eb78e23f
BW
510 filename_template[0] = letters[v % num_letters]; v /= num_letters;
511 filename_template[1] = letters[v % num_letters]; v /= num_letters;
512 filename_template[2] = letters[v % num_letters]; v /= num_letters;
513 filename_template[3] = letters[v % num_letters]; v /= num_letters;
514 filename_template[4] = letters[v % num_letters]; v /= num_letters;
515 filename_template[5] = letters[v % num_letters]; v /= num_letters;
33f23936
JN
516
517 fd = open(pattern, O_CREAT | O_EXCL | O_RDWR, mode);
a2cb86c1 518 if (fd >= 0)
33f23936
JN
519 return fd;
520 /*
521 * Fatal error (EPERM, ENOSPC etc).
522 * It doesn't make sense to loop.
523 */
524 if (errno != EEXIST)
525 break;
526 /*
527 * This is a random value. It is only necessary that
528 * the next TMP_MAX values generated by adding 7777 to
529 * VALUE are different with (module 2^32).
530 */
531 value += 7777;
532 }
533 /* We return the null string if we can't find a unique file name. */
534 pattern[0] = '\0';
535 return -1;
536}
537
538int git_mkstemp_mode(char *pattern, int mode)
539{
540 /* mkstemp is just mkstemps with no suffix */
541 return git_mkstemps_mode(pattern, 0, mode);
542}
543
eb78e23f 544int xmkstemp_mode(char *filename_template, int mode)
b862b61c
MM
545{
546 int fd;
6cf6bb3e 547 char origtemplate[PATH_MAX];
eb78e23f 548 strlcpy(origtemplate, filename_template, sizeof(origtemplate));
b862b61c 549
eb78e23f 550 fd = git_mkstemp_mode(filename_template, mode);
6cf6bb3e
AE
551 if (fd < 0) {
552 int saved_errno = errno;
553 const char *nonrelative_template;
554
eb78e23f
BW
555 if (!filename_template[0])
556 filename_template = origtemplate;
6cf6bb3e 557
eb78e23f 558 nonrelative_template = absolute_path(filename_template);
6cf6bb3e
AE
559 errno = saved_errno;
560 die_errno("Unable to create temporary file '%s'",
561 nonrelative_template);
562 }
b862b61c
MM
563 return fd;
564}
565
10e13ec8 566static int warn_if_unremovable(const char *op, const char *file, int rc)
fc71db39 567{
1054af7d
RS
568 int err;
569 if (!rc || errno == ENOENT)
570 return 0;
571 err = errno;
0a288d1e 572 warning_errno("unable to %s '%s'", op, file);
1054af7d 573 errno = err;
fc71db39
AR
574 return rc;
575}
576
9ccc0c08
RS
577int unlink_or_msg(const char *file, struct strbuf *err)
578{
579 int rc = unlink(file);
580
581 assert(err);
582
583 if (!rc || errno == ENOENT)
584 return 0;
585
0a288d1e 586 strbuf_addf(err, "unable to unlink '%s': %s",
9ccc0c08
RS
587 file, strerror(errno));
588 return -1;
589}
590
10e13ec8
PC
591int unlink_or_warn(const char *file)
592{
593 return warn_if_unremovable("unlink", file, unlink(file));
594}
d1723296
PC
595
596int rmdir_or_warn(const char *file)
597{
598 return warn_if_unremovable("rmdir", file, rmdir(file));
599}
80d706af
PC
600
601int remove_or_warn(unsigned int mode, const char *file)
602{
603 return S_ISGITLINK(mode) ? rmdir_or_warn(file) : unlink_or_warn(file);
604}
2f705875 605
4698c8fe
JN
606static int access_error_is_ok(int err, unsigned flag)
607{
c7054209
JH
608 return (is_missing_file_error(err) ||
609 ((flag & ACCESS_EACCES_OK) && err == EACCES));
4698c8fe
JN
610}
611
612int access_or_warn(const char *path, int mode, unsigned flag)
ba8bd830
JK
613{
614 int ret = access(path, mode);
4698c8fe 615 if (ret && !access_error_is_ok(errno, flag))
55b38a48 616 warn_on_inaccessible(path);
ba8bd830
JK
617 return ret;
618}
619
4698c8fe 620int access_or_die(const char *path, int mode, unsigned flag)
96b9e0e3
JN
621{
622 int ret = access(path, mode);
4698c8fe 623 if (ret && !access_error_is_ok(errno, flag))
96b9e0e3
JN
624 die_errno(_("unable to access '%s'"), path);
625 return ret;
626}
627
aa14e980
RS
628char *xgetcwd(void)
629{
630 struct strbuf sb = STRBUF_INIT;
631 if (strbuf_getcwd(&sb))
632 die_errno(_("unable to get current working directory"));
633 return strbuf_detach(&sb, NULL);
634}
316e53e6 635
7b03c89e
JK
636int xsnprintf(char *dst, size_t max, const char *fmt, ...)
637{
638 va_list ap;
639 int len;
640
641 va_start(ap, fmt);
642 len = vsnprintf(dst, max, fmt, ap);
643 va_end(ap);
644
645 if (len < 0)
033abf97 646 BUG("your snprintf is broken");
7b03c89e 647 if (len >= max)
033abf97 648 BUG("attempt to snprintf into too-small buffer");
7b03c89e
JK
649 return len;
650}
651
52563d7e 652void write_file_buf(const char *path, const char *buf, size_t len)
316e53e6 653{
52563d7e 654 int fd = xopen(path, O_WRONLY | O_CREAT | O_TRUNC, 0666);
06f46f23 655 if (write_in_full(fd, buf, len) < 0)
0a288d1e 656 die_errno(_("could not write to '%s'"), path);
52563d7e 657 if (close(fd))
0a288d1e 658 die_errno(_("could not close '%s'"), path);
316e53e6 659}
2024d317 660
ef22318c 661void write_file(const char *path, const char *fmt, ...)
12d6ce1d 662{
12d6ce1d 663 va_list params;
316e53e6 664 struct strbuf sb = STRBUF_INIT;
12d6ce1d
JH
665
666 va_start(params, fmt);
ef22318c 667 strbuf_vaddf(&sb, fmt, params);
12d6ce1d 668 va_end(params);
12d6ce1d 669
ef22318c 670 strbuf_complete_line(&sb);
12d6ce1d 671
52563d7e 672 write_file_buf(path, sb.buf, sb.len);
ef22318c 673 strbuf_release(&sb);
12d6ce1d
JH
674}
675
2024d317
JS
676void sleep_millisec(int millisec)
677{
678 poll(NULL, 0, millisec);
679}
5781a9a2
DT
680
681int xgethostname(char *buf, size_t len)
682{
683 /*
684 * If the full hostname doesn't fit in buf, POSIX does not
685 * specify whether the buffer will be null-terminated, so to
686 * be safe, do it ourselves.
687 */
688 int ret = gethostname(buf, len);
689 if (!ret)
690 buf[len - 1] = 0;
691 return ret;
692}
e3b1e3bd
PB
693
694int is_empty_or_missing_file(const char *filename)
695{
696 struct stat st;
697
698 if (stat(filename, &st) < 0) {
699 if (errno == ENOENT)
700 return 1;
701 die_errno(_("could not stat %s"), filename);
702 }
703
704 return !st.st_size;
705}