wrapper.con commit Merge branch 'jc/pull-rebase-ff' into maint (e4ec408)
   1/*
   2 * Various trivial helper wrappers around standard functions
   3 */
   4#include "cache.h"
   5
   6static void do_nothing(size_t size)
   7{
   8}
   9
  10static void (*try_to_free_routine)(size_t size) = do_nothing;
  11
  12static int memory_limit_check(size_t size, int gentle)
  13{
  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;
  19        }
  20        if (size > limit) {
  21                if (gentle) {
  22                        error("attempting to allocate %"PRIuMAX" over limit %"PRIuMAX,
  23                              (uintmax_t)size, (uintmax_t)limit);
  24                        return -1;
  25                } else
  26                        die("attempting to allocate %"PRIuMAX" over limit %"PRIuMAX,
  27                            (uintmax_t)size, (uintmax_t)limit);
  28        }
  29        return 0;
  30}
  31
  32try_to_free_t set_try_to_free_routine(try_to_free_t routine)
  33{
  34        try_to_free_t old = try_to_free_routine;
  35        if (!routine)
  36                routine = do_nothing;
  37        try_to_free_routine = routine;
  38        return old;
  39}
  40
  41char *xstrdup(const char *str)
  42{
  43        char *ret = strdup(str);
  44        if (!ret) {
  45                try_to_free_routine(strlen(str) + 1);
  46                ret = strdup(str);
  47                if (!ret)
  48                        die("Out of memory, strdup failed");
  49        }
  50        return ret;
  51}
  52
  53static void *do_xmalloc(size_t size, int gentle)
  54{
  55        void *ret;
  56
  57        if (memory_limit_check(size, gentle))
  58                return NULL;
  59        ret = malloc(size);
  60        if (!ret && !size)
  61                ret = malloc(1);
  62        if (!ret) {
  63                try_to_free_routine(size);
  64                ret = malloc(size);
  65                if (!ret && !size)
  66                        ret = malloc(1);
  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                }
  77        }
  78#ifdef XMALLOC_POISON
  79        memset(ret, 0xA5, size);
  80#endif
  81        return ret;
  82}
  83
  84void *xmalloc(size_t size)
  85{
  86        return do_xmalloc(size, 0);
  87}
  88
  89static void *do_xmallocz(size_t size, int gentle)
  90{
  91        void *ret;
  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;
 102        return ret;
 103}
 104
 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
 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{
 123        return memcpy(xmallocz(len), data, len);
 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{
 134        void *ret;
 135
 136        memory_limit_check(size, 0);
 137        ret = realloc(ptr, size);
 138        if (!ret && !size)
 139                ret = realloc(ptr, 1);
 140        if (!ret) {
 141                try_to_free_routine(size);
 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{
 153        void *ret;
 154
 155        if (unsigned_mult_overflows(nmemb, size))
 156                die("data too large to fit into virtual memory space");
 157
 158        memory_limit_check(size * nmemb, 0);
 159        ret = calloc(nmemb, size);
 160        if (!ret && (!nmemb || !size))
 161                ret = calloc(1, 1);
 162        if (!ret) {
 163                try_to_free_routine(nmemb * size);
 164                ret = calloc(nmemb, size);
 165                if (!ret && (!nmemb || !size))
 166                        ret = calloc(1, 1);
 167                if (!ret)
 168                        die("Out of memory, calloc failed");
 169        }
 170        return ret;
 171}
 172
 173/*
 174 * Limit size of IO chunks, because huge chunks only cause pain.  OS X
 175 * 64-bit is buggy, returning EINVAL if len >= INT_MAX; and even in
 176 * the absence of bugs, large chunks can result in bad latencies when
 177 * you decide to kill the process.
 178 *
 179 * We pick 8 MiB as our default, but if the platform defines SSIZE_MAX
 180 * that is smaller than that, clip it to SSIZE_MAX, as a call to
 181 * read(2) or write(2) larger than that is allowed to fail.  As the last
 182 * resort, we allow a port to pass via CFLAGS e.g. "-DMAX_IO_SIZE=value"
 183 * to override this, if the definition of SSIZE_MAX given by the platform
 184 * is broken.
 185 */
 186#ifndef MAX_IO_SIZE
 187# define MAX_IO_SIZE_DEFAULT (8*1024*1024)
 188# if defined(SSIZE_MAX) && (SSIZE_MAX < MAX_IO_SIZE_DEFAULT)
 189#  define MAX_IO_SIZE SSIZE_MAX
 190# else
 191#  define MAX_IO_SIZE MAX_IO_SIZE_DEFAULT
 192# endif
 193#endif
 194
 195/**
 196 * xopen() is the same as open(), but it die()s if the open() fails.
 197 */
 198int xopen(const char *path, int oflag, ...)
 199{
 200        mode_t mode = 0;
 201        va_list ap;
 202
 203        /*
 204         * va_arg() will have undefined behavior if the specified type is not
 205         * compatible with the argument type. Since integers are promoted to
 206         * ints, we fetch the next argument as an int, and then cast it to a
 207         * mode_t to avoid undefined behavior.
 208         */
 209        va_start(ap, oflag);
 210        if (oflag & O_CREAT)
 211                mode = va_arg(ap, int);
 212        va_end(ap);
 213
 214        for (;;) {
 215                int fd = open(path, oflag, mode);
 216                if (fd >= 0)
 217                        return fd;
 218                if (errno == EINTR)
 219                        continue;
 220
 221                if ((oflag & O_RDWR) == O_RDWR)
 222                        die_errno(_("could not open '%s' for reading and writing"), path);
 223                else if ((oflag & O_WRONLY) == O_WRONLY)
 224                        die_errno(_("could not open '%s' for writing"), path);
 225                else
 226                        die_errno(_("could not open '%s' for reading"), path);
 227        }
 228}
 229
 230static int handle_nonblock(int fd, short poll_events, int err)
 231{
 232        struct pollfd pfd;
 233
 234        if (err != EAGAIN && err != EWOULDBLOCK)
 235                return 0;
 236
 237        pfd.fd = fd;
 238        pfd.events = poll_events;
 239
 240        /*
 241         * no need to check for errors, here;
 242         * a subsequent read/write will detect unrecoverable errors
 243         */
 244        poll(&pfd, 1, -1);
 245        return 1;
 246}
 247
 248/*
 249 * xread() is the same a read(), but it automatically restarts read()
 250 * operations with a recoverable error (EAGAIN and EINTR). xread()
 251 * DOES NOT GUARANTEE that "len" bytes is read even if the data is available.
 252 */
 253ssize_t xread(int fd, void *buf, size_t len)
 254{
 255        ssize_t nr;
 256        if (len > MAX_IO_SIZE)
 257            len = MAX_IO_SIZE;
 258        while (1) {
 259                nr = read(fd, buf, len);
 260                if (nr < 0) {
 261                        if (errno == EINTR)
 262                                continue;
 263                        if (handle_nonblock(fd, POLLIN, errno))
 264                                continue;
 265                }
 266                return nr;
 267        }
 268}
 269
 270/*
 271 * xwrite() is the same a write(), but it automatically restarts write()
 272 * operations with a recoverable error (EAGAIN and EINTR). xwrite() DOES NOT
 273 * GUARANTEE that "len" bytes is written even if the operation is successful.
 274 */
 275ssize_t xwrite(int fd, const void *buf, size_t len)
 276{
 277        ssize_t nr;
 278        if (len > MAX_IO_SIZE)
 279            len = MAX_IO_SIZE;
 280        while (1) {
 281                nr = write(fd, buf, len);
 282                if (nr < 0) {
 283                        if (errno == EINTR)
 284                                continue;
 285                        if (handle_nonblock(fd, POLLOUT, errno))
 286                                continue;
 287                }
 288
 289                return nr;
 290        }
 291}
 292
 293/*
 294 * xpread() is the same as pread(), but it automatically restarts pread()
 295 * operations with a recoverable error (EAGAIN and EINTR). xpread() DOES
 296 * NOT GUARANTEE that "len" bytes is read even if the data is available.
 297 */
 298ssize_t xpread(int fd, void *buf, size_t len, off_t offset)
 299{
 300        ssize_t nr;
 301        if (len > MAX_IO_SIZE)
 302                len = MAX_IO_SIZE;
 303        while (1) {
 304                nr = pread(fd, buf, len, offset);
 305                if ((nr < 0) && (errno == EAGAIN || errno == EINTR))
 306                        continue;
 307                return nr;
 308        }
 309}
 310
 311ssize_t read_in_full(int fd, void *buf, size_t count)
 312{
 313        char *p = buf;
 314        ssize_t total = 0;
 315
 316        while (count > 0) {
 317                ssize_t loaded = xread(fd, p, count);
 318                if (loaded < 0)
 319                        return -1;
 320                if (loaded == 0)
 321                        return total;
 322                count -= loaded;
 323                p += loaded;
 324                total += loaded;
 325        }
 326
 327        return total;
 328}
 329
 330ssize_t write_in_full(int fd, const void *buf, size_t count)
 331{
 332        const char *p = buf;
 333        ssize_t total = 0;
 334
 335        while (count > 0) {
 336                ssize_t written = xwrite(fd, p, count);
 337                if (written < 0)
 338                        return -1;
 339                if (!written) {
 340                        errno = ENOSPC;
 341                        return -1;
 342                }
 343                count -= written;
 344                p += written;
 345                total += written;
 346        }
 347
 348        return total;
 349}
 350
 351ssize_t pread_in_full(int fd, void *buf, size_t count, off_t offset)
 352{
 353        char *p = buf;
 354        ssize_t total = 0;
 355
 356        while (count > 0) {
 357                ssize_t loaded = xpread(fd, p, count, offset);
 358                if (loaded < 0)
 359                        return -1;
 360                if (loaded == 0)
 361                        return total;
 362                count -= loaded;
 363                p += loaded;
 364                total += loaded;
 365                offset += loaded;
 366        }
 367
 368        return total;
 369}
 370
 371int xdup(int fd)
 372{
 373        int ret = dup(fd);
 374        if (ret < 0)
 375                die_errno("dup failed");
 376        return ret;
 377}
 378
 379/**
 380 * xfopen() is the same as fopen(), but it die()s if the fopen() fails.
 381 */
 382FILE *xfopen(const char *path, const char *mode)
 383{
 384        for (;;) {
 385                FILE *fp = fopen(path, mode);
 386                if (fp)
 387                        return fp;
 388                if (errno == EINTR)
 389                        continue;
 390
 391                if (*mode && mode[1] == '+')
 392                        die_errno(_("could not open '%s' for reading and writing"), path);
 393                else if (*mode == 'w' || *mode == 'a')
 394                        die_errno(_("could not open '%s' for writing"), path);
 395                else
 396                        die_errno(_("could not open '%s' for reading"), path);
 397        }
 398}
 399
 400FILE *xfdopen(int fd, const char *mode)
 401{
 402        FILE *stream = fdopen(fd, mode);
 403        if (stream == NULL)
 404                die_errno("Out of memory? fdopen failed");
 405        return stream;
 406}
 407
 408FILE *fopen_for_writing(const char *path)
 409{
 410        FILE *ret = fopen(path, "w");
 411
 412        if (!ret && errno == EPERM) {
 413                if (!unlink(path))
 414                        ret = fopen(path, "w");
 415                else
 416                        errno = EPERM;
 417        }
 418        return ret;
 419}
 420
 421int xmkstemp(char *template)
 422{
 423        int fd;
 424        char origtemplate[PATH_MAX];
 425        strlcpy(origtemplate, template, sizeof(origtemplate));
 426
 427        fd = mkstemp(template);
 428        if (fd < 0) {
 429                int saved_errno = errno;
 430                const char *nonrelative_template;
 431
 432                if (strlen(template) != strlen(origtemplate))
 433                        template = origtemplate;
 434
 435                nonrelative_template = absolute_path(template);
 436                errno = saved_errno;
 437                die_errno("Unable to create temporary file '%s'",
 438                        nonrelative_template);
 439        }
 440        return fd;
 441}
 442
 443/* git_mkstemp() - create tmp file honoring TMPDIR variable */
 444int git_mkstemp(char *path, size_t len, const char *template)
 445{
 446        const char *tmp;
 447        size_t n;
 448
 449        tmp = getenv("TMPDIR");
 450        if (!tmp)
 451                tmp = "/tmp";
 452        n = snprintf(path, len, "%s/%s", tmp, template);
 453        if (len <= n) {
 454                errno = ENAMETOOLONG;
 455                return -1;
 456        }
 457        return mkstemp(path);
 458}
 459
 460/* Adapted from libiberty's mkstemp.c. */
 461
 462#undef TMP_MAX
 463#define TMP_MAX 16384
 464
 465int git_mkstemps_mode(char *pattern, int suffix_len, int mode)
 466{
 467        static const char letters[] =
 468                "abcdefghijklmnopqrstuvwxyz"
 469                "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
 470                "0123456789";
 471        static const int num_letters = 62;
 472        uint64_t value;
 473        struct timeval tv;
 474        char *template;
 475        size_t len;
 476        int fd, count;
 477
 478        len = strlen(pattern);
 479
 480        if (len < 6 + suffix_len) {
 481                errno = EINVAL;
 482                return -1;
 483        }
 484
 485        if (strncmp(&pattern[len - 6 - suffix_len], "XXXXXX", 6)) {
 486                errno = EINVAL;
 487                return -1;
 488        }
 489
 490        /*
 491         * Replace pattern's XXXXXX characters with randomness.
 492         * Try TMP_MAX different filenames.
 493         */
 494        gettimeofday(&tv, NULL);
 495        value = ((size_t)(tv.tv_usec << 16)) ^ tv.tv_sec ^ getpid();
 496        template = &pattern[len - 6 - suffix_len];
 497        for (count = 0; count < TMP_MAX; ++count) {
 498                uint64_t v = value;
 499                /* Fill in the random bits. */
 500                template[0] = letters[v % num_letters]; v /= num_letters;
 501                template[1] = letters[v % num_letters]; v /= num_letters;
 502                template[2] = letters[v % num_letters]; v /= num_letters;
 503                template[3] = letters[v % num_letters]; v /= num_letters;
 504                template[4] = letters[v % num_letters]; v /= num_letters;
 505                template[5] = letters[v % num_letters]; v /= num_letters;
 506
 507                fd = open(pattern, O_CREAT | O_EXCL | O_RDWR, mode);
 508                if (fd >= 0)
 509                        return fd;
 510                /*
 511                 * Fatal error (EPERM, ENOSPC etc).
 512                 * It doesn't make sense to loop.
 513                 */
 514                if (errno != EEXIST)
 515                        break;
 516                /*
 517                 * This is a random value.  It is only necessary that
 518                 * the next TMP_MAX values generated by adding 7777 to
 519                 * VALUE are different with (module 2^32).
 520                 */
 521                value += 7777;
 522        }
 523        /* We return the null string if we can't find a unique file name.  */
 524        pattern[0] = '\0';
 525        return -1;
 526}
 527
 528int git_mkstemp_mode(char *pattern, int mode)
 529{
 530        /* mkstemp is just mkstemps with no suffix */
 531        return git_mkstemps_mode(pattern, 0, mode);
 532}
 533
 534#ifdef NO_MKSTEMPS
 535int gitmkstemps(char *pattern, int suffix_len)
 536{
 537        return git_mkstemps_mode(pattern, suffix_len, 0600);
 538}
 539#endif
 540
 541int xmkstemp_mode(char *template, int mode)
 542{
 543        int fd;
 544        char origtemplate[PATH_MAX];
 545        strlcpy(origtemplate, template, sizeof(origtemplate));
 546
 547        fd = git_mkstemp_mode(template, mode);
 548        if (fd < 0) {
 549                int saved_errno = errno;
 550                const char *nonrelative_template;
 551
 552                if (!template[0])
 553                        template = origtemplate;
 554
 555                nonrelative_template = absolute_path(template);
 556                errno = saved_errno;
 557                die_errno("Unable to create temporary file '%s'",
 558                        nonrelative_template);
 559        }
 560        return fd;
 561}
 562
 563static int warn_if_unremovable(const char *op, const char *file, int rc)
 564{
 565        int err;
 566        if (!rc || errno == ENOENT)
 567                return 0;
 568        err = errno;
 569        warning_errno("unable to %s %s", op, file);
 570        errno = err;
 571        return rc;
 572}
 573
 574int unlink_or_msg(const char *file, struct strbuf *err)
 575{
 576        int rc = unlink(file);
 577
 578        assert(err);
 579
 580        if (!rc || errno == ENOENT)
 581                return 0;
 582
 583        strbuf_addf(err, "unable to unlink %s: %s",
 584                    file, strerror(errno));
 585        return -1;
 586}
 587
 588int unlink_or_warn(const char *file)
 589{
 590        return warn_if_unremovable("unlink", file, unlink(file));
 591}
 592
 593int rmdir_or_warn(const char *file)
 594{
 595        return warn_if_unremovable("rmdir", file, rmdir(file));
 596}
 597
 598int remove_or_warn(unsigned int mode, const char *file)
 599{
 600        return S_ISGITLINK(mode) ? rmdir_or_warn(file) : unlink_or_warn(file);
 601}
 602
 603void warn_on_inaccessible(const char *path)
 604{
 605        warning_errno(_("unable to access '%s'"), path);
 606}
 607
 608static int access_error_is_ok(int err, unsigned flag)
 609{
 610        return err == ENOENT || err == ENOTDIR ||
 611                ((flag & ACCESS_EACCES_OK) && err == EACCES);
 612}
 613
 614int access_or_warn(const char *path, int mode, unsigned flag)
 615{
 616        int ret = access(path, mode);
 617        if (ret && !access_error_is_ok(errno, flag))
 618                warn_on_inaccessible(path);
 619        return ret;
 620}
 621
 622int access_or_die(const char *path, int mode, unsigned flag)
 623{
 624        int ret = access(path, mode);
 625        if (ret && !access_error_is_ok(errno, flag))
 626                die_errno(_("unable to access '%s'"), path);
 627        return ret;
 628}
 629
 630char *xgetcwd(void)
 631{
 632        struct strbuf sb = STRBUF_INIT;
 633        if (strbuf_getcwd(&sb))
 634                die_errno(_("unable to get current working directory"));
 635        return strbuf_detach(&sb, NULL);
 636}
 637
 638int xsnprintf(char *dst, size_t max, const char *fmt, ...)
 639{
 640        va_list ap;
 641        int len;
 642
 643        va_start(ap, fmt);
 644        len = vsnprintf(dst, max, fmt, ap);
 645        va_end(ap);
 646
 647        if (len < 0)
 648                die("BUG: your snprintf is broken");
 649        if (len >= max)
 650                die("BUG: attempt to snprintf into too-small buffer");
 651        return len;
 652}
 653
 654void write_file_buf(const char *path, const char *buf, size_t len)
 655{
 656        int fd = xopen(path, O_WRONLY | O_CREAT | O_TRUNC, 0666);
 657        if (write_in_full(fd, buf, len) != len)
 658                die_errno(_("could not write to %s"), path);
 659        if (close(fd))
 660                die_errno(_("could not close %s"), path);
 661}
 662
 663void write_file(const char *path, const char *fmt, ...)
 664{
 665        va_list params;
 666        struct strbuf sb = STRBUF_INIT;
 667
 668        va_start(params, fmt);
 669        strbuf_vaddf(&sb, fmt, params);
 670        va_end(params);
 671
 672        strbuf_complete_line(&sb);
 673
 674        write_file_buf(path, sb.buf, sb.len);
 675        strbuf_release(&sb);
 676}
 677
 678void sleep_millisec(int millisec)
 679{
 680        poll(NULL, 0, millisec);
 681}