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
  37void *xmallocz(size_t size)
  38{
  39        void *ret;
  40        if (size + 1 < size)
  41                die("Data too large to fit into virtual memory space.");
  42        ret = xmalloc(size + 1);
  43        ((char*)ret)[size] = 0;
  44        return ret;
  45}
  46
  47/*
  48 * xmemdupz() allocates (len + 1) bytes of memory, duplicates "len" bytes of
  49 * "data" to the allocated memory, zero terminates the allocated memory,
  50 * and returns a pointer to the allocated memory. If the allocation fails,
  51 * the program dies.
  52 */
  53void *xmemdupz(const void *data, size_t len)
  54{
  55        return memcpy(xmallocz(len), data, len);
  56}
  57
  58char *xstrndup(const char *str, size_t len)
  59{
  60        char *p = memchr(str, '\0', len);
  61        return xmemdupz(str, p ? p - str : len);
  62}
  63
  64void *xrealloc(void *ptr, size_t size)
  65{
  66        void *ret = realloc(ptr, size);
  67        if (!ret && !size)
  68                ret = realloc(ptr, 1);
  69        if (!ret) {
  70                release_pack_memory(size, -1);
  71                ret = realloc(ptr, size);
  72                if (!ret && !size)
  73                        ret = realloc(ptr, 1);
  74                if (!ret)
  75                        die("Out of memory, realloc failed");
  76        }
  77        return ret;
  78}
  79
  80void *xcalloc(size_t nmemb, size_t size)
  81{
  82        void *ret = calloc(nmemb, size);
  83        if (!ret && (!nmemb || !size))
  84                ret = calloc(1, 1);
  85        if (!ret) {
  86                release_pack_memory(nmemb * size, -1);
  87                ret = calloc(nmemb, size);
  88                if (!ret && (!nmemb || !size))
  89                        ret = calloc(1, 1);
  90                if (!ret)
  91                        die("Out of memory, calloc failed");
  92        }
  93        return ret;
  94}
  95
  96void *xmmap(void *start, size_t length,
  97        int prot, int flags, int fd, off_t offset)
  98{
  99        void *ret = mmap(start, length, prot, flags, fd, offset);
 100        if (ret == MAP_FAILED) {
 101                if (!length)
 102                        return NULL;
 103                release_pack_memory(length, fd);
 104                ret = mmap(start, length, prot, flags, fd, offset);
 105                if (ret == MAP_FAILED)
 106                        die_errno("Out of memory? mmap failed");
 107        }
 108        return ret;
 109}
 110
 111/*
 112 * xread() is the same a read(), but it automatically restarts read()
 113 * operations with a recoverable error (EAGAIN and EINTR). xread()
 114 * DOES NOT GUARANTEE that "len" bytes is read even if the data is available.
 115 */
 116ssize_t xread(int fd, void *buf, size_t len)
 117{
 118        ssize_t nr;
 119        while (1) {
 120                nr = read(fd, buf, len);
 121                if ((nr < 0) && (errno == EAGAIN || errno == EINTR))
 122                        continue;
 123                return nr;
 124        }
 125}
 126
 127/*
 128 * xwrite() is the same a write(), but it automatically restarts write()
 129 * operations with a recoverable error (EAGAIN and EINTR). xwrite() DOES NOT
 130 * GUARANTEE that "len" bytes is written even if the operation is successful.
 131 */
 132ssize_t xwrite(int fd, const void *buf, size_t len)
 133{
 134        ssize_t nr;
 135        while (1) {
 136                nr = write(fd, buf, len);
 137                if ((nr < 0) && (errno == EAGAIN || errno == EINTR))
 138                        continue;
 139                return nr;
 140        }
 141}
 142
 143ssize_t read_in_full(int fd, void *buf, size_t count)
 144{
 145        char *p = buf;
 146        ssize_t total = 0;
 147
 148        while (count > 0) {
 149                ssize_t loaded = xread(fd, p, count);
 150                if (loaded <= 0)
 151                        return total ? total : loaded;
 152                count -= loaded;
 153                p += loaded;
 154                total += loaded;
 155        }
 156
 157        return total;
 158}
 159
 160ssize_t write_in_full(int fd, const void *buf, size_t count)
 161{
 162        const char *p = buf;
 163        ssize_t total = 0;
 164
 165        while (count > 0) {
 166                ssize_t written = xwrite(fd, p, count);
 167                if (written < 0)
 168                        return -1;
 169                if (!written) {
 170                        errno = ENOSPC;
 171                        return -1;
 172                }
 173                count -= written;
 174                p += written;
 175                total += written;
 176        }
 177
 178        return total;
 179}
 180
 181int xdup(int fd)
 182{
 183        int ret = dup(fd);
 184        if (ret < 0)
 185                die_errno("dup failed");
 186        return ret;
 187}
 188
 189FILE *xfdopen(int fd, const char *mode)
 190{
 191        FILE *stream = fdopen(fd, mode);
 192        if (stream == NULL)
 193                die_errno("Out of memory? fdopen failed");
 194        return stream;
 195}
 196
 197int xmkstemp(char *template)
 198{
 199        int fd;
 200
 201        fd = mkstemp(template);
 202        if (fd < 0)
 203                die_errno("Unable to create temporary file");
 204        return fd;
 205}
 206
 207/*
 208 * zlib wrappers to make sure we don't silently miss errors
 209 * at init time.
 210 */
 211void git_inflate_init(z_streamp strm)
 212{
 213        const char *err;
 214
 215        switch (inflateInit(strm)) {
 216        case Z_OK:
 217                return;
 218
 219        case Z_MEM_ERROR:
 220                err = "out of memory";
 221                break;
 222        case Z_VERSION_ERROR:
 223                err = "wrong version";
 224                break;
 225        default:
 226                err = "error";
 227        }
 228        die("inflateInit: %s (%s)", err, strm->msg ? strm->msg : "no message");
 229}
 230
 231void git_inflate_end(z_streamp strm)
 232{
 233        if (inflateEnd(strm) != Z_OK)
 234                error("inflateEnd: %s", strm->msg ? strm->msg : "failed");
 235}
 236
 237int git_inflate(z_streamp strm, int flush)
 238{
 239        int ret = inflate(strm, flush);
 240        const char *err;
 241
 242        switch (ret) {
 243        /* Out of memory is fatal. */
 244        case Z_MEM_ERROR:
 245                die("inflate: out of memory");
 246
 247        /* Data corruption errors: we may want to recover from them (fsck) */
 248        case Z_NEED_DICT:
 249                err = "needs dictionary"; break;
 250        case Z_DATA_ERROR:
 251                err = "data stream error"; break;
 252        case Z_STREAM_ERROR:
 253                err = "stream consistency error"; break;
 254        default:
 255                err = "unknown error"; break;
 256
 257        /* Z_BUF_ERROR: normal, needs more space in the output buffer */
 258        case Z_BUF_ERROR:
 259        case Z_OK:
 260        case Z_STREAM_END:
 261                return ret;
 262        }
 263        error("inflate: %s (%s)", err, strm->msg ? strm->msg : "no message");
 264        return ret;
 265}
 266
 267int odb_mkstemp(char *template, size_t limit, const char *pattern)
 268{
 269        int fd;
 270
 271        snprintf(template, limit, "%s/%s",
 272                 get_object_directory(), pattern);
 273        fd = mkstemp(template);
 274        if (0 <= fd)
 275                return fd;
 276
 277        /* slow path */
 278        /* some mkstemp implementations erase template on failure */
 279        snprintf(template, limit, "%s/%s",
 280                 get_object_directory(), pattern);
 281        safe_create_leading_directories(template);
 282        return xmkstemp(template);
 283}
 284
 285int odb_pack_keep(char *name, size_t namesz, unsigned char *sha1)
 286{
 287        int fd;
 288
 289        snprintf(name, namesz, "%s/pack/pack-%s.keep",
 290                 get_object_directory(), sha1_to_hex(sha1));
 291        fd = open(name, O_RDWR|O_CREAT|O_EXCL, 0600);
 292        if (0 <= fd)
 293                return fd;
 294
 295        /* slow path */
 296        safe_create_leading_directories(name);
 297        return open(name, O_RDWR|O_CREAT|O_EXCL, 0600);
 298}
 299
 300int unlink_or_warn(const char *file)
 301{
 302        int rc = unlink(file);
 303
 304        if (rc < 0) {
 305                int err = errno;
 306                if (ENOENT != err) {
 307                        warning("unable to unlink %s: %s",
 308                                file, strerror(errno));
 309                        errno = err;
 310                }
 311        }
 312        return rc;
 313}
 314