* Copyright (C) 2006 Rob Landley
* Copyright (C) 2006 Denys Vlasenko
*
- * Licensed under GPL version 2, see file LICENSE in this tarball for details.
+ * 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);
+
+ if (t == NULL)
+ bb_die_memory_exhausted();
- return memcpy(t, s, n);
+ return t;
+}
+
+void* FAST_FUNC xmemdup(const void *s, int n)
+{
+ return memcpy(xmalloc(n), s, n);
}
// Die if we can't open a file and return a FILE* to it.
return ret;
}
-// Die if we can't open an existing file and return a fd.
+// Die if we can't open a file and return a fd.
int FAST_FUNC xopen(const char *pathname, int flags)
{
return xopen3(pathname, flags, 0666);
}
-/* Die if we can't open an existing file readonly with O_NONBLOCK
- * and return the fd.
- * Note that for ioctl O_RDONLY is sufficient.
- */
-int FAST_FUNC xopen_nonblocking(const char *pathname)
-{
- return xopen(pathname, O_RDONLY | O_NONBLOCK);
-}
-
// Warn if we can't open a file and return a fd.
int FAST_FUNC open3_or_warn(const char *pathname, int flags, int mode)
{
return open3_or_warn(pathname, flags, 0666);
}
+/* Die if we can't open an existing file readonly with O_NONBLOCK
+ * and return the fd.
+ * Note that for ioctl O_RDONLY is sufficient.
+ */
+int FAST_FUNC xopen_nonblocking(const char *pathname)
+{
+ return xopen(pathname, O_RDONLY | O_NONBLOCK);
+}
+
+int FAST_FUNC xopen_as_uid_gid(const char *pathname, int flags, uid_t u, gid_t g)
+{
+ int fd;
+ uid_t old_euid = geteuid();
+ gid_t old_egid = getegid();
+
+ xsetegid(g);
+ xseteuid(u);
+
+ fd = xopen(pathname, flags);
+
+ xseteuid(old_euid);
+ xsetegid(old_egid);
+
+ return fd;
+}
+
void FAST_FUNC xunlink(const char *pathname)
{
if (unlink(pathname))
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;
}
+int FAST_FUNC xmkstemp(char *template)
+{
+ int fd = mkstemp(template);
+ if (fd < 0)
+ bb_perror_msg_and_die("can't create temp file '%s'", template);
+ return fd;
+}
+
// Die with supplied filename if this FILE* has ferror set.
void FAST_FUNC die_if_ferror(FILE *fp, const char *fn)
{
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_simple_perror_msg_and_die("setegid");
+}
+
+void FAST_FUNC xseteuid(uid_t euid)
+{
+ if (seteuid(euid)) bb_simple_perror_msg_and_die("seteuid");
}
// Die if we can't chdir to a new path.
void FAST_FUNC xchdir(const char *path)
{
if (chdir(path))
- bb_perror_msg_and_die("chdir(%s)", path);
+ bb_perror_msg_and_die("can't change directory to '%s'", path);
+}
+
+void FAST_FUNC xfchdir(int fd)
+{
+ if (fchdir(fd))
+ bb_simple_perror_msg_and_die("fchdir");
}
void FAST_FUNC xchroot(const char *path)
{
if (chroot(path))
- bb_perror_msg_and_die("can't change root directory to %s", path);
+ bb_perror_msg_and_die("can't change root directory to '%s'", path);
+ xchdir("/");
}
// Print a warning message if opendir() fails, but don't die.
/* Hijack vaguely related config option */
#if ENABLE_VERBOSE_RESOLUTION_ERRORS
const char *s = "INET";
+# ifdef AF_PACKET
if (domain == AF_PACKET) s = "PACKET";
+# endif
+# ifdef AF_NETLINK
if (domain == AF_NETLINK) s = "NETLINK";
+# endif
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;
}
bb_perror_msg_and_die("can't stat '%s'", name);
}
+void FAST_FUNC xfstat(int fd, struct stat *stat_buf, const char *errmsg)
+{
+ /* errmsg is usually a file name, but not always:
+ * xfstat may be called in a spot where file name is no longer
+ * available, and caller may give e.g. "can't stat input file" string.
+ */
+ if (fstat(fd, stat_buf))
+ bb_simple_perror_msg_and_die(errmsg);
+}
+
// selinux_or_die() - die if SELinux is disabled.
void FAST_FUNC selinux_or_die(void)
{
#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
}
char* FAST_FUNC xmalloc_ttyname(int fd)
{
- char *buf = xzalloc(128);
- int r = ttyname_r(fd, buf, 127);
- if (r) {
- free(buf);
- buf = NULL;
- }
- return buf;
+ char buf[128];
+ int r = ttyname_r(fd, buf, sizeof(buf) - 1);
+ if (r)
+ return NULL;
+ return xstrdup(buf);
}
void FAST_FUNC generate_uuid(uint8_t *buf)
/* variant = 10x */
buf[4 + 2 + 2] = (buf[4 + 2 + 2] & 0x3f) | 0x80;
}
+
+#if BB_MMU
+pid_t FAST_FUNC xfork(void)
+{
+ pid_t pid;
+ pid = fork();
+ if (pid < 0) /* wtf? */
+ bb_simple_perror_msg_and_die("vfork"+1);
+ return pid;
+}
+#endif
+
+void FAST_FUNC xvfork_parent_waits_and_exits(void)
+{
+ pid_t pid;
+
+ fflush_all();
+ pid = xvfork();
+ if (pid > 0) {
+ /* Parent */
+ int exit_status = wait_for_exitstatus(pid);
+ if (WIFSIGNALED(exit_status))
+ kill_myself_with_sig(WTERMSIG(exit_status));
+ _exit(WEXITSTATUS(exit_status));
+ }
+ /* Child continues */
+}