*
* Licensed under GPLv2, see file LICENSE in this source tree.
*/
-
/* We need to have separate xfuncs.c and xfuncs_printf.c because
* with current linkers, even with section garbage collection,
* if *.o module references any of XXXprintf functions, you pull in
* which do not pull in printf, directly or indirectly.
* xfunc_printf.c contains those which do.
*/
-
#include "libbb.h"
* fail, so callers never need to check for errors. If it returned, it
* succeeded. */
+void FAST_FUNC bb_die_memory_exhausted(void)
+{
+ bb_simple_error_msg_and_die(bb_msg_memory_exhausted);
+}
+
#ifndef DMALLOC
/* dmalloc provides variants of these that do abort() on failure.
* Since dmalloc's prototypes overwrite the impls here as they are
{
void *ptr = malloc(size);
if (ptr == NULL && size != 0)
- bb_error_msg(bb_msg_memory_exhausted);
+ bb_simple_error_msg(bb_msg_memory_exhausted);
return ptr;
}
{
void *ptr = malloc(size);
if (ptr == NULL && size != 0)
- bb_error_msg_and_die(bb_msg_memory_exhausted);
+ bb_die_memory_exhausted();
return ptr;
}
{
ptr = realloc(ptr, size);
if (ptr == NULL && size != 0)
- bb_error_msg_and_die(bb_msg_memory_exhausted);
+ bb_die_memory_exhausted();
return ptr;
}
#endif /* DMALLOC */
t = strdup(s);
if (t == NULL)
- bb_error_msg_and_die(bb_msg_memory_exhausted);
+ bb_die_memory_exhausted();
return t;
}
// the (possibly truncated to length n) string into it.
char* FAST_FUNC xstrndup(const char *s, int n)
{
- int m;
char *t;
if (ENABLE_DEBUG && s == NULL)
- bb_error_msg_and_die("xstrndup bug");
-
- /* We can just xmalloc(n+1) and strncpy into it, */
- /* but think about xstrndup("abc", 10000) wastage! */
- m = n;
- t = (char*) s;
- while (m) {
- if (!*t) break;
- m--;
- t++;
- }
- n -= m;
- t = xmalloc(n + 1);
- t[n] = '\0';
+ bb_simple_error_msg_and_die("xstrndup bug");
+
+ t = strndup(s, n);
- return memcpy(t, s, n);
+ if (t == NULL)
+ bb_die_memory_exhausted();
+
+ return t;
}
void* FAST_FUNC xmemdup(const void *s, int n)
void FAST_FUNC xpipe(int filedes[2])
{
if (pipe(filedes))
- bb_perror_msg_and_die("can't create pipe");
+ bb_simple_perror_msg_and_die("can't create pipe");
}
void FAST_FUNC xdup2(int from, int to)
{
if (dup2(from, to) != to)
- bb_perror_msg_and_die("can't duplicate file descriptor");
+ bb_simple_perror_msg_and_die("can't duplicate file descriptor");
+ // " %d to %d", from, to);
}
// "Renumber" opened fd
{
if (count) {
ssize_t size = full_write(fd, buf, count);
- if ((size_t)size != count)
- bb_error_msg_and_die("short write");
+ if ((size_t)size != count) {
+ /*
+ * Two cases: write error immediately;
+ * or some writes succeeded, then we hit an error.
+ * In either case, errno is set.
+ */
+ bb_simple_perror_msg_and_die(
+ size >= 0 ? "short write" : "write error"
+ );
+ }
}
}
void FAST_FUNC xwrite_str(int fd, const char *str)
void FAST_FUNC xclose(int fd)
{
if (close(fd))
- bb_perror_msg_and_die("close failed");
+ bb_simple_perror_msg_and_die("close failed");
}
// Die with an error message if we can't lseek to the right spot.
{
off_t off = lseek(fd, offset, whence);
if (off == (off_t)-1) {
- if (whence == SEEK_SET)
- bb_perror_msg_and_die("lseek(%"OFF_FMT"u)", offset);
- bb_perror_msg_and_die("lseek");
+ bb_perror_msg_and_die("lseek(%"OFF_FMT"u, %d)", offset, whence);
}
return off;
}
va_end(p);
if (r < 0)
- bb_error_msg_and_die(bb_msg_memory_exhausted);
+ bb_die_memory_exhausted();
return string_ptr;
}
void FAST_FUNC xsetenv(const char *key, const char *value)
{
if (setenv(key, value, 1))
- bb_error_msg_and_die(bb_msg_memory_exhausted);
+ bb_die_memory_exhausted();
}
/* Handles "VAR=VAL" strings, even those which are part of environ
*/
void FAST_FUNC bb_unsetenv(const char *var)
{
- char *tp = strchr(var, '=');
-
- if (!tp) {
- unsetenv(var);
- return;
+ char onstack[128 - 16]; /* smaller stack setup code on x86 */
+ char *tp;
+
+ tp = strchr(var, '=');
+ if (tp) {
+ /* In case var was putenv'ed, we can't replace '='
+ * with NUL and unsetenv(var) - it won't work,
+ * env is modified by the replacement, unsetenv
+ * sees "VAR" instead of "VAR=VAL" and does not remove it!
+ * Horror :(
+ */
+ unsigned sz = tp - var;
+ if (sz < sizeof(onstack)) {
+ ((char*)mempcpy(onstack, var, sz))[0] = '\0';
+ tp = NULL;
+ var = onstack;
+ } else {
+ /* unlikely: very long var name */
+ var = tp = xstrndup(var, sz);
+ }
}
-
- /* In case var was putenv'ed, we can't replace '='
- * with NUL and unsetenv(var) - it won't work,
- * env is modified by the replacement, unsetenv
- * sees "VAR" instead of "VAR=VAL" and does not remove it!
- * horror :( */
- tp = xstrndup(var, tp - var);
- unsetenv(tp);
+ unsetenv(var);
free(tp);
}
// setgid() will fail and we'll _still_be_root_, which is bad.)
void FAST_FUNC xsetgid(gid_t gid)
{
- if (setgid(gid)) bb_perror_msg_and_die("setgid");
+ if (setgid(gid)) bb_simple_perror_msg_and_die("setgid");
}
// Die with an error message if we can't set uid. (See xsetgid() for why.)
void FAST_FUNC xsetuid(uid_t uid)
{
- if (setuid(uid)) bb_perror_msg_and_die("setuid");
+ if (setuid(uid)) bb_simple_perror_msg_and_die("setuid");
}
void FAST_FUNC xsetegid(gid_t egid)
{
- if (setegid(egid)) bb_perror_msg_and_die("setegid");
+ if (setegid(egid)) bb_simple_perror_msg_and_die("setegid");
}
void FAST_FUNC xseteuid(uid_t euid)
{
- if (seteuid(euid)) bb_perror_msg_and_die("seteuid");
+ if (seteuid(euid)) bb_simple_perror_msg_and_die("seteuid");
}
// Die if we can't chdir to a new path.
void FAST_FUNC xfchdir(int fd)
{
if (fchdir(fd))
- bb_perror_msg_and_die("fchdir");
+ bb_simple_perror_msg_and_die("fchdir");
}
void FAST_FUNC xchroot(const char *path)
IF_FEATURE_IPV6(if (domain == AF_INET6) s = "INET6";)
bb_perror_msg_and_die("socket(AF_%s,%d,%d)", s, type, protocol);
#else
- bb_perror_msg_and_die("socket");
+ bb_simple_perror_msg_and_die("socket");
#endif
}
// Die with an error message if we can't bind a socket to an address.
void FAST_FUNC xbind(int sockfd, struct sockaddr *my_addr, socklen_t addrlen)
{
- if (bind(sockfd, my_addr, addrlen)) bb_perror_msg_and_die("bind");
+ if (bind(sockfd, my_addr, addrlen)) bb_simple_perror_msg_and_die("bind");
}
// Die with an error message if we can't listen for connections on a socket.
void FAST_FUNC xlisten(int s, int backlog)
{
- if (listen(s, backlog)) bb_perror_msg_and_die("listen");
+ if (listen(s, backlog)) bb_simple_perror_msg_and_die("listen");
}
/* Die with an error message if sendto failed.
if (ret < 0) {
if (ENABLE_FEATURE_CLEAN_UP)
close(s);
- bb_perror_msg_and_die("sendto");
+ bb_simple_perror_msg_and_die("sendto");
}
return ret;
}
#if ENABLE_SELINUX
int rc = is_selinux_enabled();
if (rc == 0) {
- bb_error_msg_and_die("SELinux is disabled");
+ bb_simple_error_msg_and_die("SELinux is disabled");
} else if (rc < 0) {
- bb_error_msg_and_die("is_selinux_enabled() failed");
+ bb_simple_error_msg_and_die("is_selinux_enabled() failed");
}
#else
- bb_error_msg_and_die("SELinux support is disabled");
+ bb_simple_error_msg_and_die("SELinux support is disabled");
#endif
}
pid_t pid;
pid = fork();
if (pid < 0) /* wtf? */
- bb_perror_msg_and_die("vfork"+1);
+ bb_simple_perror_msg_and_die("vfork"+1);
return pid;
}
#endif
projects / oweals / busybox.git / blobdiff