Changeset 1765 in MondoRescue for branches/2.2.5/mindi-busybox/libbb/xfuncs.c

Timestamp:

Nov 4, 2007, 3:16:40 AM (16 years ago)

Author:

Bruno Cornec

Message:

Update to busybox 1.7.2

File:

• branches/2.2.5/mindi-busybox/libbb/xfuncs.c (modified) (8 diffs)

branches/2.2.5/mindi-busybox/libbb/xfuncs.c

@@ -4 +4 @@
  *
  * Copyright (C) 1999-2004 by Erik Andersen <andersen@codepoet.org>
+ * Copyright (C) 2006 Rob Landley
+ * Copyright (C) 2006 Denis Vlasenko
  *
- * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
+ * Licensed under GPL version 2, see file LICENSE in this tarball for details.
  */
 
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <sys/wait.h>
-#include <stdio.h>
-#include <string.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <fcntl.h>
-#include "busybox.h"
+#include "libbb.h"
+
+/* All the functions starting with "x" call bb_error_msg_and_die() if they
+ * fail, so callers never need to check for errors.  If it returned, it
+ * succeeded. */
 
 #ifndef DMALLOC
-#ifdef L_xmalloc
+/* dmalloc provides variants of these that do abort() on failure.
+ * Since dmalloc's prototypes overwrite the impls here as they are
+ * included after these prototypes in libbb.h, all is well.
+ */
+// Warn if we can't allocate size bytes of memory.
+void *malloc_or_warn(size_t size)
+{
+    void *ptr = malloc(size);
+    if (ptr == NULL && size != 0)
+        bb_error_msg(bb_msg_memory_exhausted);
+    return ptr;
+}
+
+// Die if we can't allocate size bytes of memory.
 void *xmalloc(size_t size)
 {
@@ -27 +38 @@
     return ptr;
 }
-#endif
-
-#ifdef L_xrealloc
+
+// Die if we can't resize previously allocated memory.  (This returns a pointer
+// to the new memory, which may or may not be the same as the old memory.
+// It'll copy the contents to a new chunk and free the old one if necessary.)
 void *xrealloc(void *ptr, size_t size)
 {
@@ -37 +49 @@
     return ptr;
 }
-#endif
-
-#ifdef L_xzalloc
+#endif /* DMALLOC */
+
+// Die if we can't allocate and zero size bytes of memory.
 void *xzalloc(size_t size)
 {
@@ -46 +58 @@
     return ptr;
 }
-#endif
-
-#ifdef L_xcalloc
-void *xcalloc(size_t nmemb, size_t size)
-{
-    void *ptr = calloc(nmemb, size);
-    if (ptr == NULL && nmemb != 0 && size != 0)
-        bb_error_msg_and_die(bb_msg_memory_exhausted);
-    return ptr;
-}
-#endif
-#endif /* DMALLOC */
-
-#ifdef L_xstrdup
-char * bb_xstrdup (const char *s)
+
+// Die if we can't copy a string to freshly allocated memory.
+char * xstrdup(const char *s)
 {
     char *t;
@@ -67 +67 @@
         return NULL;
 
-    t = strdup (s);
+    t = strdup(s);
 
     if (t == NULL)
@@ -74 +74 @@
     return t;
 }
-#endif
-
-#ifdef L_xstrndup
-char * bb_xstrndup (const char *s, int n)
-{
+
+// Die if we can't allocate n+1 bytes (space for the null terminator) and copy
+// the (possibly truncated to length n) string into it.
+char * xstrndup(const char *s, int n)
+{
+    int m;
     char *t;
 
     if (ENABLE_DEBUG && s == NULL)
-        bb_error_msg_and_die("bb_xstrndup bug");
-
-    t = xmalloc(++n);
-
-    return safe_strncpy(t,s,n);
-}
-#endif
-
-#ifdef L_xfopen
-FILE *bb_xfopen(const char *path, const char *mode)
-{
-    FILE *fp;
-    if ((fp = fopen(path, mode)) == NULL)
-        bb_perror_msg_and_die("%s", path);
+        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';
+
+    return memcpy(t, s, n);
+}
+
+// Die if we can't open a file and return a FILE * to it.
+// Notice we haven't got xfread(), This is for use with fscanf() and friends.
+FILE *xfopen(const char *path, const char *mode)
+{
+    FILE *fp = fopen(path, mode);
+    if (fp == NULL)
+        bb_perror_msg_and_die("can't open '%s'", path);
     return fp;
 }
-#endif
-
-#ifdef L_xopen
-int bb_xopen(const char *pathname, int flags)
-{
-    return bb_xopen3(pathname, flags, 0777);
-}
-#endif
-
-#ifdef L_xopen3
-int bb_xopen3(const char *pathname, int flags, int mode)
+
+// Die if we can't open a file and return a fd.
+int xopen3(const char *pathname, int flags, int mode)
 {
     int ret;
@@ -114 +118 @@
     ret = open(pathname, flags, mode);
     if (ret < 0) {
-        bb_perror_msg_and_die("%s", pathname);
+        bb_perror_msg_and_die("can't open '%s'", pathname);
     }
     return ret;
 }
-#endif
-
-#ifdef L_xread
-ssize_t bb_xread(int fd, void *buf, size_t count)
-{
-    ssize_t size;
-
-    size = read(fd, buf, count);
-    if (size < 0) {
-        bb_perror_msg_and_die(bb_msg_read_error);
-    }
-    return(size);
-}
-#endif
-
-#ifdef L_xread_all
-void bb_xread_all(int fd, void *buf, size_t count)
-{
-    ssize_t size;
-
-    while (count) {
-        if ((size = bb_xread(fd, buf, count)) == 0) {   /* EOF */
-            bb_error_msg_and_die("Short read");
-        }
-        count -= size;
-        buf = ((char *) buf) + size;
-    }
-    return;
-}
-#endif
-
-#ifdef L_xread_char
-unsigned char bb_xread_char(int fd)
-{
-    char tmp;
-
-    bb_xread_all(fd, &tmp, 1);
-
-    return(tmp);
-}
-#endif
-
-#ifdef L_xferror
-void bb_xferror(FILE *fp, const char *fn)
+
+// Die if we can't open an existing file and return a fd.
+int xopen(const char *pathname, int flags)
+{
+    return xopen3(pathname, flags, 0666);
+}
+
+// Warn if we can't open a file and return a fd.
+int open3_or_warn(const char *pathname, int flags, int mode)
+{
+    int ret;
+
+    ret = open(pathname, flags, mode);
+    if (ret < 0) {
+        bb_perror_msg("can't open '%s'", pathname);
+    }
+    return ret;
+}
+
+// Warn if we can't open a file and return a fd.
+int open_or_warn(const char *pathname, int flags)
+{
+    return open3_or_warn(pathname, flags, 0666);
+}
+
+void xpipe(int filedes[2])
+{
+    if (pipe(filedes))
+        bb_perror_msg_and_die("can't create pipe");
+}
+
+void xunlink(const char *pathname)
+{
+    if (unlink(pathname))
+        bb_perror_msg_and_die("can't remove file '%s'", pathname);
+}
+
+// Turn on nonblocking I/O on a fd
+int ndelay_on(int fd)
+{
+    return fcntl(fd, F_SETFL, fcntl(fd,F_GETFL) | O_NONBLOCK);
+}
+
+int ndelay_off(int fd)
+{
+    return fcntl(fd, F_SETFL, fcntl(fd,F_GETFL) & ~O_NONBLOCK);
+}
+
+void xdup2(int from, int to)
+{
+    if (dup2(from, to) != to)
+        bb_perror_msg_and_die("can't duplicate file descriptor");
+}
+
+// "Renumber" opened fd
+void xmove_fd(int from, int to)
+{
+    if (from == to)
+        return;
+    xdup2(from, to);
+    close(from);
+}
+
+// Die with an error message if we can't write the entire buffer.
+void xwrite(int fd, const void *buf, size_t count)
+{
+    if (count) {
+        ssize_t size = full_write(fd, buf, count);
+        if (size != count)
+            bb_error_msg_and_die("short write");
+    }
+}
+
+// Die with an error message if we can't lseek to the right spot.
+off_t xlseek(int fd, off_t offset, int whence)
+{
+    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");
+    }
+    return off;
+}
+
+// Die with supplied filename if this FILE * has ferror set.
+void die_if_ferror(FILE *fp, const char *fn)
 {
     if (ferror(fp)) {
-        bb_error_msg_and_die("%s", fn);
-    }
-}
-#endif
-
-#ifdef L_xferror_stdout
-void bb_xferror_stdout(void)
-{
-    bb_xferror(stdout, bb_msg_standard_output);
-}
-#endif
-
-#ifdef L_xfflush_stdout
-void bb_xfflush_stdout(void)
+        /* ferror doesn't set useful errno */
+        bb_error_msg_and_die("%s: I/O error", fn);
+    }
+}
+
+// Die with an error message if stdout has ferror set.
+void die_if_ferror_stdout(void)
+{
+    die_if_ferror(stdout, bb_msg_standard_output);
+}
+
+// Die with an error message if we have trouble flushing stdout.
+void xfflush_stdout(void)
 {
     if (fflush(stdout)) {
@@ -183 +229 @@
     }
 }
+
+void sig_block(int sig)
+{
+    sigset_t ss;
+    sigemptyset(&ss);
+    sigaddset(&ss, sig);
+    sigprocmask(SIG_BLOCK, &ss, NULL);
+}
+
+void sig_unblock(int sig)
+{
+    sigset_t ss;
+    sigemptyset(&ss);
+    sigaddset(&ss, sig);
+    sigprocmask(SIG_UNBLOCK, &ss, NULL);
+}
+
+#if 0
+void sig_blocknone(void)
+{
+    sigset_t ss;
+    sigemptyset(&ss);
+    sigprocmask(SIG_SETMASK, &ss, NULL);
+}
 #endif
 
-#ifdef L_spawn
-// This does a fork/exec in one call, using vfork().
-pid_t bb_spawn(char **argv)
-{
-    static int failed;
-    pid_t pid;
-    void *app = find_applet_by_name(argv[0]);
-
-    // Be nice to nommu machines.
-    failed = 0;
-    pid = vfork();
-    if (pid < 0) return pid;
-    if (!pid) {
-        execvp(app ? CONFIG_BUSYBOX_EXEC_PATH : *argv, argv);
-
-        // We're sharing a stack with blocked parent, let parent know we failed
-        // and then exit to unblock parent (but don't run atexit() stuff, which
-        // would screw up parent.)
-
-        failed = -1;
-        _exit(0);
-    }
-    return failed ? failed : pid;
-}
+void sig_catch(int sig, void (*f)(int))
+{
+    struct sigaction sa;
+    sa.sa_handler = f;
+    sa.sa_flags = 0;
+    sigemptyset(&sa.sa_mask);
+    sigaction(sig, &sa, NULL);
+}
+
+void sig_pause(void)
+{
+    sigset_t ss;
+    sigemptyset(&ss);
+    sigsuspend(&ss);
+}
+
+
+void xsetenv(const char *key, const char *value)
+{
+    if (setenv(key, value, 1))
+        bb_error_msg_and_die(bb_msg_memory_exhausted);
+}
+
+// Converts unsigned long long value into compact 4-char
+// representation. Examples: "1234", "1.2k", " 27M", "123T"
+// Fifth char is always '\0'
+void smart_ulltoa5(unsigned long long ul, char buf[5])
+{
+    const char *fmt;
+    char c;
+    unsigned v,idx = 0;
+    ul *= 10;
+    if (ul > 9999*10) { // do not scale if 9999 or less
+        while (ul >= 10000) {
+            ul /= 1024;
+            idx++;
+        }
+    }
+    v = ul; // ullong divisions are expensive, avoid them
+
+    fmt = " 123456789";
+    if (!idx) {     // 9999 or less: use 1234 format
+        c = buf[0] = " 123456789"[v/10000];
+        if (c != ' ') fmt = "0123456789";
+        c = buf[1] = fmt[v/1000%10];
+        if (c != ' ') fmt = "0123456789";
+        buf[2] = fmt[v/100%10];
+        buf[3] = "0123456789"[v/10%10];
+    } else {
+        if (v >= 10*10) {   // scaled value is >=10: use 123M format
+            c = buf[0] = " 123456789"[v/1000];
+            if (c != ' ') fmt = "0123456789";
+            buf[1] = fmt[v/100%10];
+            buf[2] = "0123456789"[v/10%10];
+        } else {    // scaled value is <10: use 1.2M format
+            buf[0] = "0123456789"[v/10];
+            buf[1] = '.';
+            buf[2] = "0123456789"[v%10];
+        }
+        // see http://en.wikipedia.org/wiki/Tera
+        buf[3] = " kMGTPEZY"[idx];
+    }
+    buf[4] = '\0';
+}
+
+// Convert unsigned integer to ascii, writing into supplied buffer.
+// A truncated result contains the first few digits of the result ala strncpy.
+// Returns a pointer past last generated digit, does _not_ store NUL.
+void BUG_sizeof_unsigned_not_4(void);
+char *utoa_to_buf(unsigned n, char *buf, unsigned buflen)
+{
+    unsigned i, out, res;
+    if (sizeof(unsigned) != 4)
+        BUG_sizeof_unsigned_not_4();
+    if (buflen) {
+        out = 0;
+        for (i = 1000000000; i; i /= 10) {
+            res = n / i;
+            if (res || out || i == 1) {
+                if (!--buflen) break;
+                out++;
+                n -= res*i;
+                *buf++ = '0' + res;
+            }
+        }
+    }
+    return buf;
+}
+
+// Convert signed integer to ascii, like utoa_to_buf()
+char *itoa_to_buf(int n, char *buf, unsigned buflen)
+{
+    if (buflen && n<0) {
+        n = -n;
+        *buf++ = '-';
+        buflen--;
+    }
+    return utoa_to_buf((unsigned)n, buf, buflen);
+}
+
+// The following two functions use a static buffer, so calling either one a
+// second time will overwrite previous results.
+//
+// The largest 32 bit integer is -2 billion plus null terminator, or 12 bytes.
+// Int should always be 32 bits on any remotely Unix-like system, see
+// http://www.unix.org/whitepapers/64bit.html for the reasons why.
+
+static char local_buf[12];
+
+// Convert unsigned integer to ascii using a static buffer (returned).
+char *utoa(unsigned n)
+{
+    *(utoa_to_buf(n, local_buf, sizeof(local_buf))) = '\0';
+
+    return local_buf;
+}
+
+// Convert signed integer to ascii using a static buffer (returned).
+char *itoa(int n)
+{
+    *(itoa_to_buf(n, local_buf, sizeof(local_buf))) = '\0';
+
+    return local_buf;
+}
+
+// Emit a string of hex representation of bytes
+char *bin2hex(char *p, const char *cp, int count)
+{
+    while (count) {
+        unsigned char c = *cp++;
+        /* put lowercase hex digits */
+        *p++ = 0x20 | bb_hexdigits_upcase[c >> 4];
+        *p++ = 0x20 | bb_hexdigits_upcase[c & 0xf];
+        count--;
+    }
+    return p;
+}
+
+// Die with an error message if we can't set gid.  (Because resource limits may
+// limit this user to a given number of processes, and if that fills up the
+// setgid() will fail and we'll _still_be_root_, which is bad.)
+void xsetgid(gid_t gid)
+{
+    if (setgid(gid)) bb_perror_msg_and_die("setgid");
+}
+
+// Die with an error message if we can't set uid.  (See xsetgid() for why.)
+void xsetuid(uid_t uid)
+{
+    if (setuid(uid)) bb_perror_msg_and_die("setuid");
+}
+
+// Return how long the file at fd is, if there's any way to determine it.
+off_t fdlength(int fd)
+{
+    off_t bottom = 0, top = 0, pos;
+    long size;
+
+    // If the ioctl works for this, return it.
+
+    if (ioctl(fd, BLKGETSIZE, &size) >= 0) return size*512;
+
+    // FIXME: explain why lseek(SEEK_END) is not used here!
+
+    // If not, do a binary search for the last location we can read.  (Some
+    // block devices don't do BLKGETSIZE right.)
+
+    do {
+        char temp;
+
+        pos = bottom + (top - bottom) / 2;
+
+        // If we can read from the current location, it's bigger.
+
+        if (lseek(fd, pos, SEEK_SET)>=0 && safe_read(fd, &temp, 1)==1) {
+            if (bottom == top) bottom = top = (top+1) * 2;
+            else bottom = pos;
+
+        // If we can't, it's smaller.
+
+        } else {
+            if (bottom == top) {
+                if (!top) return 0;
+                bottom = top/2;
+            }
+            else top = pos;
+        }
+    } while (bottom + 1 != top);
+
+    return pos + 1;
+}
+
+// Die with an error message if we can't malloc() enough space and do an
+// sprintf() into that space.
+char *xasprintf(const char *format, ...)
+{
+    va_list p;
+    int r;
+    char *string_ptr;
+
+#if 1
+    // GNU extension
+    va_start(p, format);
+    r = vasprintf(&string_ptr, format, p);
+    va_end(p);
+#else
+    // Bloat for systems that haven't got the GNU extension.
+    va_start(p, format);
+    r = vsnprintf(NULL, 0, format, p);
+    va_end(p);
+    string_ptr = xmalloc(r+1);
+    va_start(p, format);
+    r = vsnprintf(string_ptr, r+1, format, p);
+    va_end(p);
 #endif
 
-#ifdef L_xspawn
-pid_t bb_xspawn(char **argv)
-{
-    pid_t pid = bb_spawn(argv);
-    if (pid < 0) bb_perror_msg_and_die("%s", *argv);
-    return pid;
-}
+    if (r < 0) bb_error_msg_and_die(bb_msg_memory_exhausted);
+    return string_ptr;
+}
+
+#if 0 /* If we will ever meet a libc which hasn't [f]dprintf... */
+int fdprintf(int fd, const char *format, ...)
+{
+    va_list p;
+    int r;
+    char *string_ptr;
+
+#if 1
+    // GNU extension
+    va_start(p, format);
+    r = vasprintf(&string_ptr, format, p);
+    va_end(p);
+#else
+    // Bloat for systems that haven't got the GNU extension.
+    va_start(p, format);
+    r = vsnprintf(NULL, 0, format, p) + 1;
+    va_end(p);
+    string_ptr = malloc(r);
+    if (string_ptr) {
+        va_start(p, format);
+        r = vsnprintf(string_ptr, r, format, p);
+        va_end(p);
+    }
 #endif
 
-#ifdef L_wait4
-int wait4pid(int pid)
-{
-    int status;
-
-    if (pid == -1 || waitpid(pid, &status, 0) == -1) return -1;
-    if (WIFEXITED(status)) return WEXITSTATUS(status);
-    if (WIFSIGNALED(status)) return WTERMSIG(status);
-    return 0;
-}
-#endif  
-
-#ifdef L_setuid
-void xsetgid(gid_t gid)
-{
-    if (setgid(gid)) bb_error_msg_and_die("setgid");
-}
-
-void xsetuid(uid_t uid)
-{
-    if (setuid(uid)) bb_error_msg_and_die("setuid");
+    if (r >= 0) {
+        full_write(fd, string_ptr, r);
+        free(string_ptr);
+    }
+    return r;
 }
 #endif
+
+// Die with an error message if we can't copy an entire FILE * to stdout, then
+// close that file.
+void xprint_and_close_file(FILE *file)
+{
+    fflush(stdout);
+    // copyfd outputs error messages for us.
+    if (bb_copyfd_eof(fileno(file), 1) == -1)
+        xfunc_die();
+
+    fclose(file);
+}
+
+// Die if we can't chdir to a new path.
+void xchdir(const char *path)
+{
+    if (chdir(path))
+        bb_perror_msg_and_die("chdir(%s)", path);
+}
+
+// Print a warning message if opendir() fails, but don't die.
+DIR *warn_opendir(const char *path)
+{
+    DIR *dp;
+
+    dp = opendir(path);
+    if (!dp)
+        bb_perror_msg("can't open '%s'", path);
+    return dp;
+}
+
+// Die with an error message if opendir() fails.
+DIR *xopendir(const char *path)
+{
+    DIR *dp;
+
+    dp = opendir(path);
+    if (!dp)
+        bb_perror_msg_and_die("can't open '%s'", path);
+    return dp;
+}
+
+// Die with an error message if we can't open a new socket.
+int xsocket(int domain, int type, int protocol)
+{
+    int r = socket(domain, type, protocol);
+
+    if (r < 0) {
+        /* Hijack vaguely related config option */
+#if ENABLE_VERBOSE_RESOLUTION_ERRORS
+        const char *s = "INET";
+        if (domain == AF_PACKET) s = "PACKET";
+        if (domain == AF_NETLINK) s = "NETLINK";
+USE_FEATURE_IPV6(if (domain == AF_INET6) s = "INET6";)
+        bb_perror_msg_and_die("socket(AF_%s)", s);
+#else
+        bb_perror_msg_and_die("socket");
+#endif
+    }
+
+    return r;
+}
+
+// Die with an error message if we can't bind a socket to an address.
+void xbind(int sockfd, struct sockaddr *my_addr, socklen_t addrlen)
+{
+    if (bind(sockfd, my_addr, addrlen)) bb_perror_msg_and_die("bind");
+}
+
+// Die with an error message if we can't listen for connections on a socket.
+void xlisten(int s, int backlog)
+{
+    if (listen(s, backlog)) bb_perror_msg_and_die("listen");
+}
+
+/* Die with an error message if sendto failed.
+ * Return bytes sent otherwise  */
+ssize_t xsendto(int s, const  void *buf, size_t len, const struct sockaddr *to,
+                socklen_t tolen)
+{
+    ssize_t ret = sendto(s, buf, len, 0, to, tolen);
+    if (ret < 0) {
+        if (ENABLE_FEATURE_CLEAN_UP)
+            close(s);
+        bb_perror_msg_and_die("sendto");
+    }
+    return ret;
+}
+
+// xstat() - a stat() which dies on failure with meaningful error message
+void xstat(const char *name, struct stat *stat_buf)
+{
+    if (stat(name, stat_buf))
+        bb_perror_msg_and_die("can't stat '%s'", name);
+}
+
+// selinux_or_die() - die if SELinux is disabled.
+void selinux_or_die(void)
+{
+#if ENABLE_SELINUX
+    int rc = is_selinux_enabled();
+    if (rc == 0) {
+        bb_error_msg_and_die("SELinux is disabled");
+    } else if (rc < 0) {
+        bb_error_msg_and_die("is_selinux_enabled() failed");
+    }
+#else
+    bb_error_msg_and_die("SELinux support is disabled");
+#endif
+}
+
+/* It is perfectly ok to pass in a NULL for either width or for
+ * height, in which case that value will not be set.  */
+int get_terminal_width_height(int fd, int *width, int *height)
+{
+    struct winsize win = { 0, 0, 0, 0 };
+    int ret = ioctl(fd, TIOCGWINSZ, &win);
+
+    if (height) {
+        if (!win.ws_row) {
+            char *s = getenv("LINES");
+            if (s) win.ws_row = atoi(s);
+        }
+        if (win.ws_row <= 1 || win.ws_row >= 30000)
+            win.ws_row = 24;
+        *height = (int) win.ws_row;
+    }
+
+    if (width) {
+        if (!win.ws_col) {
+            char *s = getenv("COLUMNS");
+            if (s) win.ws_col = atoi(s);
+        }
+        if (win.ws_col <= 1 || win.ws_col >= 30000)
+            win.ws_col = 80;
+        *width = (int) win.ws_col;
+    }
+
+    return ret;
+}
+
+void ioctl_or_perror_and_die(int fd, int request, void *argp, const char *fmt,...)
+{
+    va_list p;
+
+    if (ioctl(fd, request, argp) < 0) {
+        va_start(p, fmt);
+        bb_verror_msg(fmt, p, strerror(errno));
+        /* xfunc_die can actually longjmp, so be nice */
+        va_end(p);
+        xfunc_die();
+    }
+}
+
+int ioctl_or_perror(int fd, int request, void *argp, const char *fmt,...)
+{
+    va_list p;
+    int ret = ioctl(fd, request, argp);
+
+    if (ret < 0) {
+        va_start(p, fmt);
+        bb_verror_msg(fmt, p, strerror(errno));
+        va_end(p);
+    }
+    return ret;
+}
+
+#if ENABLE_IOCTL_HEX2STR_ERROR
+int bb_ioctl_or_warn(int fd, int request, void *argp, const char *ioctl_name)
+{
+    int ret;
+
+    ret = ioctl(fd, request, argp);
+    if (ret < 0)
+        bb_perror_msg("%s", ioctl_name);
+    return ret;
+}
+void bb_xioctl(int fd, int request, void *argp, const char *ioctl_name)
+{
+    if (ioctl(fd, request, argp) < 0)
+        bb_perror_msg_and_die("%s", ioctl_name);
+}
+#else
+int bb_ioctl_or_warn(int fd, int request, void *argp)
+{
+    int ret;
+
+    ret = ioctl(fd, request, argp);
+    if (ret < 0)
+        bb_perror_msg("ioctl %#x failed", request);
+    return ret;
+}
+void bb_xioctl(int fd, int request, void *argp)
+{
+    if (ioctl(fd, request, argp) < 0)
+        bb_perror_msg_and_die("ioctl %#x failed", request);
+}
+#endif