traceroute: fix help text to not show -6 when traceroute6 is off

[oweals/busybox.git] / libbb / read.c

diff --git a/libbb/read.c b/libbb/read.c
index 18f62838ec69a91888fd9baba0f216e576c78d0e..06ce29718e9e5bb24219a01be9a67a2116074037 100644 (file)
--- a/libbb/read.c
+++ b/libbb/read.c
@@ -8,7 +8,14 @@
  */
 
 #include "libbb.h"
-#if ENABLE_FEATURE_MODPROBE_SMALL_ZIPPED
+
+#define ZIPPED (ENABLE_FEATURE_SEAMLESS_LZMA \
+       || ENABLE_FEATURE_SEAMLESS_BZ2 \
+       || ENABLE_FEATURE_SEAMLESS_GZ \
+       /* || ENABLE_FEATURE_SEAMLESS_Z */ \
+)
+
+#if ZIPPED
 #include "unarchive.h"
 #endif
 
@@ -32,18 +39,18 @@ ssize_t FAST_FUNC safe_read(int fd, void *buf, size_t count)
  * *** BIG SURPRISE! It stays even after child exits! ***
  *
  * This is a design bug in UNIX API.
- *      fcntl(0, F_SETFL, fcntl(0, F_GETFL, 0) | O_NONBLOCK);
+ *      fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
  * will set nonblocking mode not only on _your_ stdin, but
  * also on stdin of your parent, etc.
  *
  * In general,
  *      fd2 = dup(fd1);
- *      fcntl(fd2, F_SETFL, fcntl(fd2, F_GETFL, 0) | O_NONBLOCK);
+ *      fcntl(fd2, F_SETFL, fcntl(fd2, F_GETFL) | O_NONBLOCK);
  * sets both fd1 and fd2 to O_NONBLOCK. This includes cases
  * where duping is done implicitly by fork() etc.
  *
  * We need
- *      fcntl(fd2, F_SETFD, fcntl(fd2, F_GETFD, 0) | O_NONBLOCK);
+ *      fcntl(fd2, F_SETFD, fcntl(fd2, F_GETFD) | O_NONBLOCK);
  * (note SETFD, not SETFL!) but such thing doesn't exist.
  *
  * Alternatively, we need nonblocking_read(fd, ...) which doesn't
@@ -134,7 +141,7 @@ char* FAST_FUNC xmalloc_reads(int fd, char *buf, size_t *maxsz_p)
 {
        char *p;
        size_t sz = buf ? strlen(buf) : 0;
-       size_t maxsz = maxsz_p ? *maxsz_p : MAXINT(size_t);
+       size_t maxsz = maxsz_p ? *maxsz_p : (INT_MAX - 4095);
 
        goto jump_in;
        while (sz < maxsz) {
@@ -191,7 +198,7 @@ void* FAST_FUNC xmalloc_read(int fd, size_t *maxsz_p)
        size_t to_read;
        struct stat st;
 
-       to_read = maxsz_p ? *maxsz_p : MAXINT(ssize_t); /* max to read */
+       to_read = maxsz_p ? *maxsz_p : (INT_MAX - 4095); /* max to read */
 
        /* Estimate file size */
        st.st_size = 0; /* in case fstat fails, assume 0 */
@@ -222,7 +229,7 @@ void* FAST_FUNC xmalloc_read(int fd, size_t *maxsz_p)
                if (size > 64*1024)
                        size = 64*1024;
        }
-       xrealloc(buf, total + 1);
+       buf = xrealloc(buf, total + 1);
        buf[total] = '\0';
 
        if (maxsz_p)
@@ -255,7 +262,7 @@ void* FAST_FUNC xmalloc_open_read_close(const char *filename, size_t *maxsz_p)
        len = lseek(fd, 0, SEEK_END) | 0x3ff; /* + up to 1k */
        if (len != (off_t)-1) {
                xlseek(fd, 0, SEEK_SET);
-               size = maxsz_p ? *maxsz_p : INT_MAX;
+               size = maxsz_p ? *maxsz_p : (INT_MAX - 4095);
                if (len < size)
                        size = len;
        }
@@ -266,7 +273,7 @@ void* FAST_FUNC xmalloc_open_read_close(const char *filename, size_t *maxsz_p)
                free(buf);
                return NULL;
        }
-       xrealloc(buf, size + 1);
+       buf = xrealloc(buf, size + 1);
        buf[size] = '\0';
 
        if (maxsz_p)
@@ -299,24 +306,85 @@ void* FAST_FUNC xmalloc_xopen_read_close(const char *filename, size_t *maxsz_p)
        return buf;
 }
 
-#if ENABLE_FEATURE_MODPROBE_SMALL_ZIPPED
+int FAST_FUNC open_zipped(const char *fname)
+{
+#if !ZIPPED
+       return open(fname, O_RDONLY);
+#else
+       unsigned char magic[2];
+       char *sfx;
+       int fd;
+#if BB_MMU
+       IF_DESKTOP(long long) int FAST_FUNC (*xformer)(int src_fd, int dst_fd);
+       enum { xformer_prog = 0 };
+#else
+       enum { xformer = 0 };
+       const char *xformer_prog;
+#endif
+
+       fd = open(fname, O_RDONLY);
+       if (fd < 0)
+               return fd;
+
+       sfx = strrchr(fname, '.');
+       if (sfx) {
+               if (ENABLE_FEATURE_SEAMLESS_LZMA && strcmp(sfx, ".lzma") == 0)
+                       /* .lzma has no header/signature, just trust it */
+                       open_transformer(fd, unpack_lzma_stream, "unlzma");
+               else
+               if ((ENABLE_FEATURE_SEAMLESS_GZ && strcmp(sfx, ".gz") == 0)
+                || (ENABLE_FEATURE_SEAMLESS_BZ2 && strcmp(sfx, ".bz2") == 0)
+               ) {
+                       /* .gz and .bz2 both have 2-byte signature, and their
+                        * unpack_XXX_stream wants this header skipped. */
+                       xread(fd, &magic, 2);
+#if ENABLE_FEATURE_SEAMLESS_GZ
+#if BB_MMU
+                       xformer = unpack_gz_stream;
+#else
+                       xformer_prog = "gunzip";
+#endif
+#endif
+                       if (!ENABLE_FEATURE_SEAMLESS_GZ
+                        || magic[0] != 0x1f || magic[1] != 0x8b
+                       ) {
+                               if (!ENABLE_FEATURE_SEAMLESS_BZ2
+                                || magic[0] != 'B' || magic[1] != 'Z'
+                               ) {
+                                       bb_error_msg_and_die("no gzip"
+                                               IF_FEATURE_SEAMLESS_BZ2("/bzip2")
+                                               " magic");
+                               }
+#if BB_MMU
+                               xformer = unpack_bz2_stream;
+#else
+                               xformer_prog = "bunzip2";
+#endif
+                       } else {
+#if !BB_MMU
+                               /* NOMMU version of open_transformer execs
+                                * an external unzipper that wants
+                                * file position at the start of the file */
+                               xlseek(fd, 0, SEEK_SET);
+#endif
+                       }
+                       open_transformer(fd, xformer, xformer_prog);
+               }
+       }
+
+       return fd;
+#endif
+}
+
 void* FAST_FUNC xmalloc_open_zipped_read_close(const char *fname, size_t *maxsz_p)
 {
+       int fd;
        char *image;
-       char *suffix;
 
-       int fd = open(fname, O_RDONLY);
+       fd = open_zipped(fname);
        if (fd < 0)
                return NULL;
 
-       suffix = strrchr(fname, '.');
-       if (suffix) {
-               if (strcmp(suffix, ".gz") == 0)
-                       open_transformer(fd, unpack_gz_stream, "gunzip");
-               else if (strcmp(suffix, ".bz2") == 0)
-                       open_transformer(fd, unpack_bz2_stream, "bunzip2");
-       }
-
        image = xmalloc_read(fd, maxsz_p);
        if (!image)
                bb_perror_msg("read error from '%s'", fname);
@@ -324,4 +392,3 @@ void* FAST_FUNC xmalloc_open_zipped_read_close(const char *fname, size_t *maxsz_
 
        return image;
 }
-#endif