Andrew's git - gitweb.git/blob

   1/*
   2 * Various trivial helper wrappers around standard functions
   3 */
   4#include "cache.h"
   5
   6char *xstrdup(const char *str)
   7{
   8        char *ret = strdup(str);
   9        if (!ret) {
  10                release_pack_memory(strlen(str) + 1, -1);
  11                ret = strdup(str);
  12                if (!ret)
  13                        die("Out of memory, strdup failed");
  14        }
  15        return ret;
  16}
  17
  18void *xmalloc(size_t size)
  19{
  20        void *ret = malloc(size);
  21        if (!ret && !size)
  22                ret = malloc(1);
  23        if (!ret) {
  24                release_pack_memory(size, -1);
  25                ret = malloc(size);
  26                if (!ret && !size)
  27                        ret = malloc(1);
  28                if (!ret)
  29                        die("Out of memory, malloc failed");
  30        }
  31#ifdef XMALLOC_POISON
  32        memset(ret, 0xA5, size);
  33#endif
  34        return ret;
  35}
  36
  37/*
  38 * xmemdupz() allocates (len + 1) bytes of memory, duplicates "len" bytes of
  39 * "data" to the allocated memory, zero terminates the allocated memory,
  40 * and returns a pointer to the allocated memory. If the allocation fails,
  41 * the program dies.
  42 */
  43void *xmemdupz(const void *data, size_t len)
  44{
  45        char *p = xmalloc(len + 1);
  46        memcpy(p, data, len);
  47        p[len] = '\0';
  48        return p;
  49}
  50
  51char *xstrndup(const char *str, size_t len)
  52{
  53        char *p = memchr(str, '\0', len);
  54        return xmemdupz(str, p ? p - str : len);
  55}
  56
  57void *xrealloc(void *ptr, size_t size)
  58{
  59        void *ret = realloc(ptr, size);
  60        if (!ret && !size)
  61                ret = realloc(ptr, 1);
  62        if (!ret) {
  63                release_pack_memory(size, -1);
  64                ret = realloc(ptr, size);
  65                if (!ret && !size)
  66                        ret = realloc(ptr, 1);
  67                if (!ret)
  68                        die("Out of memory, realloc failed");
  69        }
  70        return ret;
  71}
  72
  73void *xcalloc(size_t nmemb, size_t size)
  74{
  75        void *ret = calloc(nmemb, size);
  76        if (!ret && (!nmemb || !size))
  77                ret = calloc(1, 1);
  78        if (!ret) {
  79                release_pack_memory(nmemb * size, -1);
  80                ret = calloc(nmemb, size);
  81                if (!ret && (!nmemb || !size))
  82                        ret = calloc(1, 1);
  83                if (!ret)
  84                        die("Out of memory, calloc failed");
  85        }
  86        return ret;
  87}
  88
  89void *xmmap(void *start, size_t length,
  90        int prot, int flags, int fd, off_t offset)
  91{
  92        void *ret = mmap(start, length, prot, flags, fd, offset);
  93        if (ret == MAP_FAILED) {
  94                if (!length)
  95                        return NULL;
  96                release_pack_memory(length, fd);
  97                ret = mmap(start, length, prot, flags, fd, offset);
  98                if (ret == MAP_FAILED)
  99                        die("Out of memory? mmap failed: %s", strerror(errno));
 100        }
 101        return ret;
 102}
 103
 104/*
 105 * xread() is the same a read(), but it automatically restarts read()
 106 * operations with a recoverable error (EAGAIN and EINTR). xread()
 107 * DOES NOT GUARANTEE that "len" bytes is read even if the data is available.
 108 */
 109ssize_t xread(int fd, void *buf, size_t len)
 110{
 111        ssize_t nr;
 112        while (1) {
 113                nr = read(fd, buf, len);
 114                if ((nr < 0) && (errno == EAGAIN || errno == EINTR))
 115                        continue;
 116                return nr;
 117        }
 118}
 119
 120/*
 121 * xwrite() is the same a write(), but it automatically restarts write()
 122 * operations with a recoverable error (EAGAIN and EINTR). xwrite() DOES NOT
 123 * GUARANTEE that "len" bytes is written even if the operation is successful.
 124 */
 125ssize_t xwrite(int fd, const void *buf, size_t len)
 126{
 127        ssize_t nr;
 128        while (1) {
 129                nr = write(fd, buf, len);
 130                if ((nr < 0) && (errno == EAGAIN || errno == EINTR))
 131                        continue;
 132                return nr;
 133        }
 134}
 135
 136int xdup(int fd)
 137{
 138        int ret = dup(fd);
 139        if (ret < 0)
 140                die("dup failed: %s", strerror(errno));
 141        return ret;
 142}
 143
 144FILE *xfdopen(int fd, const char *mode)
 145{
 146        FILE *stream = fdopen(fd, mode);
 147        if (stream == NULL)
 148                die("Out of memory? fdopen failed: %s", strerror(errno));
 149        return stream;
 150}
 151
 152int xmkstemp(char *template)
 153{
 154        int fd;
 155
 156        fd = mkstemp(template);
 157        if (fd < 0)
 158                die("Unable to create temporary file: %s", strerror(errno));
 159        return fd;
 160}