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
);