2 * Various trivial helper wrappers around standard functions
6 static void try_to_free_builtin(size_t size)
8 release_pack_memory(size, -1);
11 static void (*try_to_free_routine)(size_t size) = try_to_free_builtin;
13 try_to_free_t set_try_to_free_routine(try_to_free_t routine)
15 try_to_free_t old = try_to_free_routine;
16 try_to_free_routine = routine;
20 char *xstrdup(const char *str)
22 char *ret = strdup(str);
24 try_to_free_routine(strlen(str) + 1);
27 die("Out of memory, strdup failed");
32 void *xmalloc(size_t size)
34 void *ret = malloc(size);
38 try_to_free_routine(size);
43 die("Out of memory, malloc failed (tried to allocate %lu bytes)",
47 memset(ret, 0xA5, size);
52 void *xmallocz(size_t size)
56 die("Data too large to fit into virtual memory space.");
57 ret = xmalloc(size + 1);
58 ((char*)ret)[size] = 0;
63 * xmemdupz() allocates (len + 1) bytes of memory, duplicates "len" bytes of
64 * "data" to the allocated memory, zero terminates the allocated memory,
65 * and returns a pointer to the allocated memory. If the allocation fails,
68 void *xmemdupz(const void *data, size_t len)
70 return memcpy(xmallocz(len), data, len);
73 char *xstrndup(const char *str, size_t len)
75 char *p = memchr(str, '\0', len);
76 return xmemdupz(str, p ? p - str : len);
79 void *xrealloc(void *ptr, size_t size)
81 void *ret = realloc(ptr, size);
83 ret = realloc(ptr, 1);
85 try_to_free_routine(size);
86 ret = realloc(ptr, size);
88 ret = realloc(ptr, 1);
90 die("Out of memory, realloc failed");
95 void *xcalloc(size_t nmemb, size_t size)
97 void *ret = calloc(nmemb, size);
98 if (!ret && (!nmemb || !size))
101 try_to_free_routine(nmemb * size);
102 ret = calloc(nmemb, size);
103 if (!ret && (!nmemb || !size))
106 die("Out of memory, calloc failed");
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.
116 ssize_t xread(int fd, void *buf, size_t len)
120 nr = read(fd, buf, len);
121 if ((nr < 0) && (errno == EAGAIN || errno == EINTR))
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.
132 ssize_t xwrite(int fd, const void *buf, size_t len)
136 nr = write(fd, buf, len);
137 if ((nr < 0) && (errno == EAGAIN || errno == EINTR))
143 ssize_t read_in_full(int fd, void *buf, size_t count)
149 ssize_t loaded = xread(fd, p, count);
151 return total ? total : loaded;
160 ssize_t write_in_full(int fd, const void *buf, size_t count)
166 ssize_t written = xwrite(fd, p, count);
185 die_errno("dup failed");
189 FILE *xfdopen(int fd, const char *mode)
191 FILE *stream = fdopen(fd, mode);
193 die_errno("Out of memory? fdopen failed");
197 int xmkstemp(char *template)
201 fd = mkstemp(template);
203 die_errno("Unable to create temporary file");
207 int xmkstemp_mode(char *template, int mode)
211 fd = git_mkstemp_mode(template, mode);
213 die_errno("Unable to create temporary file");
218 * zlib wrappers to make sure we don't silently miss errors
221 void git_inflate_init(z_streamp strm)
225 switch (inflateInit(strm)) {
230 err = "out of memory";
232 case Z_VERSION_ERROR:
233 err = "wrong version";
238 die("inflateInit: %s (%s)", err, strm->msg ? strm->msg : "no message");
241 void git_inflate_end(z_streamp strm)
243 if (inflateEnd(strm) != Z_OK)
244 error("inflateEnd: %s", strm->msg ? strm->msg : "failed");
247 int git_inflate(z_streamp strm, int flush)
249 int ret = inflate(strm, flush);
253 /* Out of memory is fatal. */
255 die("inflate: out of memory");
257 /* Data corruption errors: we may want to recover from them (fsck) */
259 err = "needs dictionary"; break;
261 err = "data stream error"; break;
263 err = "stream consistency error"; break;
265 err = "unknown error"; break;
267 /* Z_BUF_ERROR: normal, needs more space in the output buffer */
273 error("inflate: %s (%s)", err, strm->msg ? strm->msg : "no message");
277 static int warn_if_unremovable(const char *op, const char *file, int rc)
282 warning("unable to %s %s: %s",
283 op, file, strerror(errno));
290 int unlink_or_warn(const char *file)
292 return warn_if_unremovable("unlink", file, unlink(file));
295 int rmdir_or_warn(const char *file)
297 return warn_if_unremovable("rmdir", file, rmdir(file));
300 int remove_or_warn(unsigned int mode, const char *file)
302 return S_ISGITLINK(mode) ? rmdir_or_warn(file) : unlink_or_warn(file);