wrapper.c

   1 /*
   2  * Various trivial helper wrappers around standard functions
   3  */
   4 #include "cache.h"
   5 #include "config.h"
   6
   7 static void do_nothing(size_t size)
   8 {
   9 }
  10
  11 static void (*try_to_free_routine)(size_t size) = do_nothing;
  12
  13 static int memory_limit_check(size_t size, int gentle)
  14 {
  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;
  20         }
  21         if (size > limit) {
  22                 if (gentle) {
  23                         error("attempting to allocate %"PRIuMAX" over limit %"PRIuMAX,
  24                               (uintmax_t)size, (uintmax_t)limit);
  25                         return -1;
  26                 } else
  27                         die("attempting to allocate %"PRIuMAX" over limit %"PRIuMAX,
  28                             (uintmax_t)size, (uintmax_t)limit);
  29         }
  30         return 0;
  31 }
  32
  33 try_to_free_t set_try_to_free_routine(try_to_free_t routine)
  34 {
  35         try_to_free_t old = try_to_free_routine;
  36         if (!routine)
  37                 routine = do_nothing;
  38         try_to_free_routine = routine;
  39         return old;
  40 }
  41
  42 char *xstrdup(const char *str)
  43 {
  44         char *ret = strdup(str);
  45         if (!ret) {
  46                 try_to_free_routine(strlen(str) + 1);
  47                 ret = strdup(str);
  48                 if (!ret)
  49                         die("Out of memory, strdup failed");
  50         }
  51         return ret;
  52 }
  53
  54 static void *do_xmalloc(size_t size, int gentle)
  55 {
  56         void *ret;
  57
  58         if (memory_limit_check(size, gentle))
  59                 return NULL;
  60         ret = malloc(size);
  61         if (!ret && !size)
  62                 ret = malloc(1);
  63         if (!ret) {
  64                 try_to_free_routine(size);
  65                 ret = malloc(size);
  66                 if (!ret && !size)
  67                         ret = malloc(1);
  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                 }
  78         }
  79 #ifdef XMALLOC_POISON
  80         memset(ret, 0xA5, size);
  81 #endif
  82         return ret;
  83 }
  84
  85 void *xmalloc(size_t size)
  86 {
  87         return do_xmalloc(size, 0);
  88 }
  89
  90 static void *do_xmallocz(size_t size, int gentle)
  91 {
  92         void *ret;
  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;
 103         return ret;
 104 }
 105
 106 void *xmallocz(size_t size)
 107 {
 108         return do_xmallocz(size, 0);
 109 }
 110
 111 void *xmallocz_gently(size_t size)
 112 {
 113         return do_xmallocz(size, 1);
 114 }
 115
 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  */
 122 void *xmemdupz(const void *data, size_t len)
 123 {
 124         return memcpy(xmallocz(len), data, len);
 125 }
 126
 127 char *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
 133 void *xrealloc(void *ptr, size_t size)
 134 {
 135         void *ret;
 136
 137         memory_limit_check(size, 0);
 138         ret = realloc(ptr, size);
 139         if (!ret && !size)
 140                 ret = realloc(ptr, 1);
 141         if (!ret) {
 142                 try_to_free_routine(size);
 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
 152 void *xcalloc(size_t nmemb, size_t size)
 153 {
 154         void *ret;
 155
 156         if (unsigned_mult_overflows(nmemb, size))
 157                 die("data too large to fit into virtual memory space");
 158
 159         memory_limit_check(size * nmemb, 0);
 160         ret = calloc(nmemb, size);
 161         if (!ret && (!nmemb || !size))
 162                 ret = calloc(1, 1);
 163         if (!ret) {
 164                 try_to_free_routine(nmemb * size);
 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
 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
 177  * the absence of bugs, large chunks can result in bad latencies when
 178  * you decide to kill the process.
 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.
 186  */
 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
 195
 196 /**
 197  * xopen() is the same as open(), but it die()s if the open() fails.
 198  */
 199 int 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
 231 static 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
 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  */
 254 ssize_t xread(int fd, void *buf, size_t len)
 255 {
 256         ssize_t nr;
 257         if (len > MAX_IO_SIZE)
 258             len = MAX_IO_SIZE;
 259         while (1) {
 260                 nr = read(fd, buf, len);
 261                 if (nr < 0) {
 262                         if (errno == EINTR)
 263                                 continue;
 264                         if (handle_nonblock(fd, POLLIN, errno))
 265                                 continue;
 266                 }
 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  */
 276 ssize_t xwrite(int fd, const void *buf, size_t len)
 277 {
 278         ssize_t nr;
 279         if (len > MAX_IO_SIZE)
 280             len = MAX_IO_SIZE;
 281         while (1) {
 282                 nr = write(fd, buf, len);
 283                 if (nr < 0) {
 284                         if (errno == EINTR)
 285                                 continue;
 286                         if (handle_nonblock(fd, POLLOUT, errno))
 287                                 continue;
 288                 }
 289
 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  */
 299 ssize_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))
 307                         continue;
 308                 return nr;
 309         }
 310 }
 311
 312 ssize_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);
 319                 if (loaded < 0)
 320                         return -1;
 321                 if (loaded == 0)
 322                         return total;
 323                 count -= loaded;
 324                 p += loaded;
 325                 total += loaded;
 326         }
 327
 328         return total;
 329 }
 330
 331 ssize_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
 352 ssize_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
 372 int xdup(int fd)
 373 {
 374         int ret = dup(fd);
 375         if (ret < 0)
 376                 die_errno("dup failed");
 377         return ret;
 378 }
 379
 380 /**
 381  * xfopen() is the same as fopen(), but it die()s if the fopen() fails.
 382  */
 383 FILE *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
 401 FILE *xfdopen(int fd, const char *mode)
 402 {
 403         FILE *stream = fdopen(fd, mode);
 404         if (stream == NULL)
 405                 die_errno("Out of memory? fdopen failed");
 406         return stream;
 407 }
 408
 409 FILE *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
 422 int xmkstemp(char *template)
 423 {
 424         int fd;
 425         char origtemplate[PATH_MAX];
 426         strlcpy(origtemplate, template, sizeof(origtemplate));
 427
 428         fd = mkstemp(template);
 429         if (fd < 0) {
 430                 int saved_errno = errno;
 431                 const char *nonrelative_template;
 432
 433                 if (strlen(template) != strlen(origtemplate))
 434                         template = origtemplate;
 435
 436                 nonrelative_template = absolute_path(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 = 62;
 456         uint64_t value;
 457         struct timeval tv;
 458         char *template;
 459         size_t len;
 460         int fd, count;
 461
 462         len = strlen(pattern);
 463
 464         if (len < 6 + suffix_len) {
 465                 errno = EINVAL;
 466                 return -1;
 467         }
 468
 469         if (strncmp(&pattern[len - 6 - suffix_len], "XXXXXX", 6)) {
 470                 errno = EINVAL;
 471                 return -1;
 472         }
 473
 474         /*
 475          * Replace pattern's XXXXXX characters with randomness.
 476          * Try TMP_MAX different filenames.
 477          */
 478         gettimeofday(&tv, NULL);
 479         value = ((size_t)(tv.tv_usec << 16)) ^ tv.tv_sec ^ getpid();
 480         template = &pattern[len - 6 - suffix_len];
 481         for (count = 0; count < TMP_MAX; ++count) {
 482                 uint64_t v = value;
 483                 /* Fill in the random bits. */
 484                 template[0] = letters[v % num_letters]; v /= num_letters;
 485                 template[1] = letters[v % num_letters]; v /= num_letters;
 486                 template[2] = letters[v % num_letters]; v /= num_letters;
 487                 template[3] = letters[v % num_letters]; v /= num_letters;
 488                 template[4] = letters[v % num_letters]; v /= num_letters;
 489                 template[5] = letters[v % num_letters]; v /= num_letters;
 490
 491                 fd = open(pattern, O_CREAT | O_EXCL | O_RDWR, mode);
 492                 if (fd >= 0)
 493                         return fd;
 494                 /*
 495                  * Fatal error (EPERM, ENOSPC etc).
 496                  * It doesn't make sense to loop.
 497                  */
 498                 if (errno != EEXIST)
 499                         break;
 500                 /*
 501                  * This is a random value.  It is only necessary that
 502                  * the next TMP_MAX values generated by adding 7777 to
 503                  * VALUE are different with (module 2^32).
 504                  */
 505                 value += 7777;
 506         }
 507         /* We return the null string if we can't find a unique file name.  */
 508         pattern[0] = '\0';
 509         return -1;
 510 }
 511
 512 int git_mkstemp_mode(char *pattern, int mode)
 513 {
 514         /* mkstemp is just mkstemps with no suffix */
 515         return git_mkstemps_mode(pattern, 0, mode);
 516 }
 517
 518 int xmkstemp_mode(char *template, int mode)
 519 {
 520         int fd;
 521         char origtemplate[PATH_MAX];
 522         strlcpy(origtemplate, template, sizeof(origtemplate));
 523
 524         fd = git_mkstemp_mode(template, mode);
 525         if (fd < 0) {
 526                 int saved_errno = errno;
 527                 const char *nonrelative_template;
 528
 529                 if (!template[0])
 530                         template = origtemplate;
 531
 532                 nonrelative_template = absolute_path(template);
 533                 errno = saved_errno;
 534                 die_errno("Unable to create temporary file '%s'",
 535                         nonrelative_template);
 536         }
 537         return fd;
 538 }
 539
 540 static int warn_if_unremovable(const char *op, const char *file, int rc)
 541 {
 542         int err;
 543         if (!rc || errno == ENOENT)
 544                 return 0;
 545         err = errno;
 546         warning_errno("unable to %s %s", op, file);
 547         errno = err;
 548         return rc;
 549 }
 550
 551 int unlink_or_msg(const char *file, struct strbuf *err)
 552 {
 553         int rc = unlink(file);
 554
 555         assert(err);
 556
 557         if (!rc || errno == ENOENT)
 558                 return 0;
 559
 560         strbuf_addf(err, "unable to unlink %s: %s",
 561                     file, strerror(errno));
 562         return -1;
 563 }
 564
 565 int unlink_or_warn(const char *file)
 566 {
 567         return warn_if_unremovable("unlink", file, unlink(file));
 568 }
 569
 570 int rmdir_or_warn(const char *file)
 571 {
 572         return warn_if_unremovable("rmdir", file, rmdir(file));
 573 }
 574
 575 int remove_or_warn(unsigned int mode, const char *file)
 576 {
 577         return S_ISGITLINK(mode) ? rmdir_or_warn(file) : unlink_or_warn(file);
 578 }
 579
 580 void warn_on_inaccessible(const char *path)
 581 {
 582         warning_errno(_("unable to access '%s'"), path);
 583 }
 584
 585 static int access_error_is_ok(int err, unsigned flag)
 586 {
 587         return err == ENOENT || err == ENOTDIR ||
 588                 ((flag & ACCESS_EACCES_OK) && err == EACCES);
 589 }
 590
 591 int access_or_warn(const char *path, int mode, unsigned flag)
 592 {
 593         int ret = access(path, mode);
 594         if (ret && !access_error_is_ok(errno, flag))
 595                 warn_on_inaccessible(path);
 596         return ret;
 597 }
 598
 599 int access_or_die(const char *path, int mode, unsigned flag)
 600 {
 601         int ret = access(path, mode);
 602         if (ret && !access_error_is_ok(errno, flag))
 603                 die_errno(_("unable to access '%s'"), path);
 604         return ret;
 605 }
 606
 607 char *xgetcwd(void)
 608 {
 609         struct strbuf sb = STRBUF_INIT;
 610         if (strbuf_getcwd(&sb))
 611                 die_errno(_("unable to get current working directory"));
 612         return strbuf_detach(&sb, NULL);
 613 }
 614
 615 int xsnprintf(char *dst, size_t max, const char *fmt, ...)
 616 {
 617         va_list ap;
 618         int len;
 619
 620         va_start(ap, fmt);
 621         len = vsnprintf(dst, max, fmt, ap);
 622         va_end(ap);
 623
 624         if (len < 0)
 625                 die("BUG: your snprintf is broken");
 626         if (len >= max)
 627                 die("BUG: attempt to snprintf into too-small buffer");
 628         return len;
 629 }
 630
 631 void write_file_buf(const char *path, const char *buf, size_t len)
 632 {
 633         int fd = xopen(path, O_WRONLY | O_CREAT | O_TRUNC, 0666);
 634         if (write_in_full(fd, buf, len) != len)
 635                 die_errno(_("could not write to %s"), path);
 636         if (close(fd))
 637                 die_errno(_("could not close %s"), path);
 638 }
 639
 640 void write_file(const char *path, const char *fmt, ...)
 641 {
 642         va_list params;
 643         struct strbuf sb = STRBUF_INIT;
 644
 645         va_start(params, fmt);
 646         strbuf_vaddf(&sb, fmt, params);
 647         va_end(params);
 648
 649         strbuf_complete_line(&sb);
 650
 651         write_file_buf(path, sb.buf, sb.len);
 652         strbuf_release(&sb);
 653 }
 654
 655 void sleep_millisec(int millisec)
 656 {
 657         poll(NULL, 0, millisec);
 658 }
 659
 660 int xgethostname(char *buf, size_t len)
 661 {
 662         /*
 663          * If the full hostname doesn't fit in buf, POSIX does not
 664          * specify whether the buffer will be null-terminated, so to
 665          * be safe, do it ourselves.
 666          */
 667         int ret = gethostname(buf, len);
 668         if (!ret)
 669                 buf[len - 1] = 0;
 670         return ret;
 671 }