Merge https://github.com/prati0100/git-gui
[git] / wrapper.c
1 /*
2  * Various trivial helper wrappers around standard functions
3  */
4 #include "cache.h"
5 #include "config.h"
6
7 static int memory_limit_check(size_t size, int gentle)
8 {
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;
14         }
15         if (size > limit) {
16                 if (gentle) {
17                         error("attempting to allocate %"PRIuMAX" over limit %"PRIuMAX,
18                               (uintmax_t)size, (uintmax_t)limit);
19                         return -1;
20                 } else
21                         die("attempting to allocate %"PRIuMAX" over limit %"PRIuMAX,
22                             (uintmax_t)size, (uintmax_t)limit);
23         }
24         return 0;
25 }
26
27 char *xstrdup(const char *str)
28 {
29         char *ret = strdup(str);
30         if (!ret)
31                 die("Out of memory, strdup failed");
32         return ret;
33 }
34
35 static void *do_xmalloc(size_t size, int gentle)
36 {
37         void *ret;
38
39         if (memory_limit_check(size, gentle))
40                 return NULL;
41         ret = malloc(size);
42         if (!ret && !size)
43                 ret = malloc(1);
44         if (!ret) {
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;
52                 }
53         }
54 #ifdef XMALLOC_POISON
55         memset(ret, 0xA5, size);
56 #endif
57         return ret;
58 }
59
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)
66 {
67         void *ret;
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;
78         return ret;
79 }
80
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
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 {
99         return memcpy(xmallocz(len), data, len);
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
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
116 void *xrealloc(void *ptr, size_t size)
117 {
118         void *ret;
119
120         if (!size) {
121                 free(ptr);
122                 return xmalloc(0);
123         }
124
125         memory_limit_check(size, 0);
126         ret = realloc(ptr, size);
127         if (!ret)
128                 die("Out of memory, realloc failed");
129         return ret;
130 }
131
132 void *xcalloc(size_t nmemb, size_t size)
133 {
134         void *ret;
135
136         if (unsigned_mult_overflows(nmemb, size))
137                 die("data too large to fit into virtual memory space");
138
139         memory_limit_check(size * nmemb, 0);
140         ret = calloc(nmemb, size);
141         if (!ret && (!nmemb || !size))
142                 ret = calloc(1, 1);
143         if (!ret)
144                 die("Out of memory, calloc failed");
145         return ret;
146 }
147
148 /*
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
151  * the absence of bugs, large chunks can result in bad latencies when
152  * you decide to kill the process.
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.
160  */
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
169
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
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
223 /*
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;
231         if (len > MAX_IO_SIZE)
232                 len = MAX_IO_SIZE;
233         while (1) {
234                 nr = read(fd, buf, len);
235                 if (nr < 0) {
236                         if (errno == EINTR)
237                                 continue;
238                         if (handle_nonblock(fd, POLLIN, errno))
239                                 continue;
240                 }
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;
253         if (len > MAX_IO_SIZE)
254                 len = MAX_IO_SIZE;
255         while (1) {
256                 nr = write(fd, buf, len);
257                 if (nr < 0) {
258                         if (errno == EINTR)
259                                 continue;
260                         if (handle_nonblock(fd, POLLOUT, errno))
261                                 continue;
262                 }
263
264                 return nr;
265         }
266 }
267
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
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);
293                 if (loaded < 0)
294                         return -1;
295                 if (loaded == 0)
296                         return total;
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
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
346 int xdup(int fd)
347 {
348         int ret = dup(fd);
349         if (ret < 0)
350                 die_errno("dup failed");
351         return ret;
352 }
353
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
375 FILE *xfdopen(int fd, const char *mode)
376 {
377         FILE *stream = fdopen(fd, mode);
378         if (stream == NULL)
379                 die_errno("Out of memory? fdopen failed");
380         return stream;
381 }
382
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
396 static void warn_on_inaccessible(const char *path)
397 {
398         warning_errno(_("unable to access '%s'"), path);
399 }
400
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
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
422 int xmkstemp(char *filename_template)
423 {
424         int fd;
425         char origtemplate[PATH_MAX];
426         strlcpy(origtemplate, filename_template, sizeof(origtemplate));
427
428         fd = mkstemp(filename_template);
429         if (fd < 0) {
430                 int saved_errno = errno;
431                 const char *nonrelative_template;
432
433                 if (strlen(filename_template) != strlen(origtemplate))
434                         filename_template = origtemplate;
435
436                 nonrelative_template = absolute_path(filename_template);
437                 errno = saved_errno;
438                 die_errno("Unable to create temporary file '%s'",
439                         nonrelative_template);
440         }
441         return fd;
442 }
443
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";
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;
458         uint64_t value;
459         struct timeval tv;
460         char *filename_template;
461         size_t len;
462         int fd, count;
463
464         len = strlen(pattern);
465
466         if (len < num_x + suffix_len) {
467                 errno = EINVAL;
468                 return -1;
469         }
470
471         if (strncmp(&pattern[len - num_x - suffix_len], x_pattern, num_x)) {
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);
481         value = ((uint64_t)tv.tv_usec << 16) ^ tv.tv_sec ^ getpid();
482         filename_template = &pattern[len - num_x - suffix_len];
483         for (count = 0; count < TMP_MAX; ++count) {
484                 uint64_t v = value;
485                 int i;
486                 /* Fill in the random bits. */
487                 for (i = 0; i < num_x; i++) {
488                         filename_template[i] = letters[v % num_letters];
489                         v /= num_letters;
490                 }
491
492                 fd = open(pattern, O_CREAT | O_EXCL | O_RDWR, mode);
493                 if (fd >= 0)
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
519 int xmkstemp_mode(char *filename_template, int mode)
520 {
521         int fd;
522         char origtemplate[PATH_MAX];
523         strlcpy(origtemplate, filename_template, sizeof(origtemplate));
524
525         fd = git_mkstemp_mode(filename_template, mode);
526         if (fd < 0) {
527                 int saved_errno = errno;
528                 const char *nonrelative_template;
529
530                 if (!filename_template[0])
531                         filename_template = origtemplate;
532
533                 nonrelative_template = absolute_path(filename_template);
534                 errno = saved_errno;
535                 die_errno("Unable to create temporary file '%s'",
536                         nonrelative_template);
537         }
538         return fd;
539 }
540
541 static int warn_if_unremovable(const char *op, const char *file, int rc)
542 {
543         int err;
544         if (!rc || errno == ENOENT)
545                 return 0;
546         err = errno;
547         warning_errno("unable to %s '%s'", op, file);
548         errno = err;
549         return rc;
550 }
551
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
561         strbuf_addf(err, "unable to unlink '%s': %s",
562                     file, strerror(errno));
563         return -1;
564 }
565
566 int unlink_or_warn(const char *file)
567 {
568         return warn_if_unremovable("unlink", file, unlink(file));
569 }
570
571 int rmdir_or_warn(const char *file)
572 {
573         return warn_if_unremovable("rmdir", file, rmdir(file));
574 }
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 }
580
581 static int access_error_is_ok(int err, unsigned flag)
582 {
583         return (is_missing_file_error(err) ||
584                 ((flag & ACCESS_EACCES_OK) && err == EACCES));
585 }
586
587 int access_or_warn(const char *path, int mode, unsigned flag)
588 {
589         int ret = access(path, mode);
590         if (ret && !access_error_is_ok(errno, flag))
591                 warn_on_inaccessible(path);
592         return ret;
593 }
594
595 int access_or_die(const char *path, int mode, unsigned flag)
596 {
597         int ret = access(path, mode);
598         if (ret && !access_error_is_ok(errno, flag))
599                 die_errno(_("unable to access '%s'"), path);
600         return ret;
601 }
602
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 }
610
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)
621                 BUG("your snprintf is broken");
622         if (len >= max)
623                 BUG("attempt to snprintf into too-small buffer");
624         return len;
625 }
626
627 void write_file_buf(const char *path, const char *buf, size_t len)
628 {
629         int fd = xopen(path, O_WRONLY | O_CREAT | O_TRUNC, 0666);
630         if (write_in_full(fd, buf, len) < 0)
631                 die_errno(_("could not write to '%s'"), path);
632         if (close(fd))
633                 die_errno(_("could not close '%s'"), path);
634 }
635
636 void write_file(const char *path, const char *fmt, ...)
637 {
638         va_list params;
639         struct strbuf sb = STRBUF_INIT;
640
641         va_start(params, fmt);
642         strbuf_vaddf(&sb, fmt, params);
643         va_end(params);
644
645         strbuf_complete_line(&sb);
646
647         write_file_buf(path, sb.buf, sb.len);
648         strbuf_release(&sb);
649 }
650
651 void sleep_millisec(int millisec)
652 {
653         poll(NULL, 0, millisec);
654 }
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 }
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 }