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