*/
#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
* *** 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
return tmp;
}
-/* Read one line a-la fgets. Works only on seekable streams */
-char* FAST_FUNC reads(int fd, char *buffer, size_t size)
-{
- char *p;
-
- if (size < 2)
- return NULL;
- size = full_read(fd, buffer, size-1);
- if ((ssize_t)size <= 0)
- return NULL;
-
- buffer[size] = '\0';
- p = strchr(buffer, '\n');
- if (p) {
- off_t offset;
- *p++ = '\0';
- /* avoid incorrect (unsigned) widening */
- offset = (off_t)(p - buffer) - (off_t)size;
- /* set fd position right after '\n' */
- if (offset && lseek(fd, offset, SEEK_CUR) == (off_t)-1)
- return NULL;
- }
- return buffer;
-}
-
// Reads one line a-la fgets (but doesn't save terminating '\n').
// Reads byte-by-byte. Useful when it is important to not read ahead.
// Bytes are appended to pfx (which must be malloced, or NULL).
{
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) {
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 */
if (size > 64*1024)
size = 64*1024;
}
- xrealloc(buf, total + 1);
+ buf = xrealloc(buf, total + 1);
buf[total] = '\0';
if (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;
}
free(buf);
return NULL;
}
- xrealloc(buf, size + 1);
+ buf = xrealloc(buf, size + 1);
buf[size] = '\0';
if (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);
return image;
}
-#endif