busybox/libbb/read_printf.c

239 lines
6.1 KiB
C
Raw Normal View History

/* vi: set sw=4 ts=4: */
/*
* Utility routines.
*
* Copyright (C) 1999-2004 by Erik Andersen <andersen@codepoet.org>
*
* Licensed under GPLv2 or later, see file LICENSE in this source tree.
*/
#include "libbb.h"
/* Suppose that you are a shell. You start child processes.
* They work and eventually exit. You want to get user input.
* You read stdin. But what happens if last child switched
* its stdin into O_NONBLOCK mode?
*
* *** SURPRISE! It will affect the parent too! ***
* *** BIG SURPRISE! It stays even after child exits! ***
*
* This is a design bug in UNIX API.
* 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) | 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) | O_NONBLOCK);
* (note SETFD, not SETFL!) but such thing doesn't exist.
*
* Alternatively, we need nonblocking_read(fd, ...) which doesn't
* require O_NONBLOCK dance at all. Actually, it exists:
* n = recv(fd, buf, len, MSG_DONTWAIT);
* "MSG_DONTWAIT:
* Enables non-blocking operation; if the operation
* would block, EAGAIN is returned."
* but recv() works only for sockets!
*
* So far I don't see any good solution, I can only propose
* that affected readers should be careful and use this routine,
* which detects EAGAIN and uses poll() to wait on the fd.
* Thankfully, poll() doesn't care about O_NONBLOCK flag.
*/
ssize_t FAST_FUNC nonblock_immune_read(int fd, void *buf, size_t count)
{
struct pollfd pfd[1];
ssize_t n;
while (1) {
n = safe_read(fd, buf, count);
if (n >= 0 || errno != EAGAIN)
return n;
/* fd is in O_NONBLOCK mode. Wait using poll and repeat */
pfd[0].fd = fd;
pfd[0].events = POLLIN;
/* note: safe_poll pulls in printf */
safe_poll(pfd, 1, -1);
}
}
// 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* FAST_FUNC xmalloc_reads(int fd, size_t *maxsz_p)
{
char *p;
char *buf = NULL;
size_t sz = 0;
size_t maxsz = maxsz_p ? *maxsz_p : (INT_MAX - 4095);
goto jump_in;
while (sz < maxsz) {
if ((size_t)(p - buf) == sz) {
jump_in:
buf = xrealloc(buf, sz + 128);
p = buf + sz;
sz += 128;
}
if (nonblock_immune_read(fd, p, 1) != 1) {
/* EOF/error */
if (p == buf) { /* we read nothing */
free(buf);
return NULL;
}
break;
}
if (*p == '\n')
break;
p++;
}
*p = '\0';
if (maxsz_p)
*maxsz_p = p - buf;
p++;
return xrealloc(buf, p - buf);
}
// Read (potentially big) files in one go. File size is estimated
// by stat. Extra '\0' byte is appended.
void* FAST_FUNC xmalloc_read_with_initial_buf(int fd, size_t *maxsz_p, char *buf, size_t total)
{
size_t size, rd_size;
size_t to_read;
struct stat st;
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 */
fstat(fd, &st);
/* /proc/N/stat files report st_size 0 */
/* In order to make such files readable, we add small const */
size = (st.st_size | 0x3ff) + 1;
while (1) {
if (to_read < size)
size = to_read;
buf = xrealloc(buf, total + size + 1);
rd_size = full_read(fd, buf + total, size);
if ((ssize_t)rd_size == (ssize_t)(-1)) { /* error */
free(buf);
return NULL;
}
total += rd_size;
if (rd_size < size) /* EOF */
break;
if (to_read <= rd_size)
break;
to_read -= rd_size;
/* grow by 1/8, but in [1k..64k] bounds */
size = ((total / 8) | 0x3ff) + 1;
if (size > 64*1024)
size = 64*1024;
}
buf = xrealloc(buf, total + 1);
buf[total] = '\0';
if (maxsz_p)
*maxsz_p = total;
return buf;
}
void* FAST_FUNC xmalloc_read(int fd, size_t *maxsz_p)
{
return xmalloc_read_with_initial_buf(fd, maxsz_p, NULL, 0);
}
#ifdef USING_LSEEK_TO_GET_SIZE
/* Alternatively, file size can be obtained by lseek to the end.
* The code is slightly bigger. Retained in case fstat approach
* will not work for some weird cases (/proc, block devices, etc).
* (NB: lseek also can fail to work for some weird files) */
// Read (potentially big) files in one go. File size is estimated by
// lseek to end.
void* FAST_FUNC xmalloc_open_read_close(const char *filename, size_t *maxsz_p)
{
char *buf;
size_t size;
int fd;
off_t len;
fd = open(filename, O_RDONLY);
if (fd < 0)
return NULL;
/* /proc/N/stat files report len 0 here */
/* In order to make such files readable, we add small const */
size = 0x3ff; /* read only 1k on unseekable files */
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 - 4095);
if (len < size)
size = len;
}
buf = xmalloc(size + 1);
size = read_close(fd, buf, size);
if ((ssize_t)size < 0) {
free(buf);
return NULL;
}
buf = xrealloc(buf, size + 1);
buf[size] = '\0';
if (maxsz_p)
*maxsz_p = size;
return buf;
}
#endif
// Read (potentially big) files in one go. File size is estimated
// by stat.
void* FAST_FUNC xmalloc_open_read_close(const char *filename, size_t *maxsz_p)
{
char *buf;
int fd;
fd = open(filename, O_RDONLY);
if (fd < 0)
return NULL;
buf = xmalloc_read(fd, maxsz_p);
close(fd);
return buf;
}
/* Die with an error message if we can't read the entire buffer. */
void FAST_FUNC xread(int fd, void *buf, size_t count)
{
if (count) {
ssize_t size = full_read(fd, buf, count);
if ((size_t)size != count)
libbb: reduce the overhead of single parameter bb_error_msg() calls Back in 2007, commit 0c97c9d43707 ("'simple' error message functions by Loic Grenie") introduced bb_simple_perror_msg() to allow for a lower overhead call to bb_perror_msg() when only a string was being printed with no parameters. This saves space for some CPU architectures because it avoids the overhead of a call to a variadic function. However there has never been a simple version of bb_error_msg(), and since 2007 many new calls to bb_perror_msg() have been added that only take a single parameter and so could have been using bb_simple_perror_message(). This changeset introduces 'simple' versions of bb_info_msg(), bb_error_msg(), bb_error_msg_and_die(), bb_herror_msg() and bb_herror_msg_and_die(), and replaces all calls that only take a single parameter, or use something like ("%s", arg), with calls to the corresponding 'simple' version. Since it is likely that single parameter calls to the variadic functions may be accidentally reintroduced in the future a new debugging config option WARN_SIMPLE_MSG has been introduced. This uses some macro magic which will cause any such calls to generate a warning, but this is turned off by default to avoid use of the unpleasant macros in normal circumstances. This is a large changeset due to the number of calls that have been replaced. The only files that contain changes other than simple substitution of function calls are libbb.h, libbb/herror_msg.c, libbb/verror_msg.c and libbb/xfuncs_printf.c. In miscutils/devfsd.c, networking/udhcp/common.h and util-linux/mdev.c additonal macros have been added for logging so that single parameter and multiple parameter logging variants exist. The amount of space saved varies considerably by architecture, and was found to be as follows (for 'defconfig' using GCC 7.4): Arm: -92 bytes MIPS: -52 bytes PPC: -1836 bytes x86_64: -938 bytes Note that for the MIPS architecture only an exception had to be made disabling the 'simple' calls for 'udhcp' (in networking/udhcp/common.h) because it made these files larger on MIPS. Signed-off-by: James Byrne <james.byrne@origamienergy.com> Signed-off-by: Denys Vlasenko <vda.linux@googlemail.com>
2019-07-02 15:05:03 +05:30
bb_simple_error_msg_and_die("short read");
}
}
/* Die with an error message if we can't read one character. */
unsigned char FAST_FUNC xread_char(int fd)
{
char tmp;
xread(fd, &tmp, 1);
return tmp;
}
void* FAST_FUNC xmalloc_xopen_read_close(const char *filename, size_t *maxsz_p)
{
void *buf = xmalloc_open_read_close(filename, maxsz_p);
if (!buf)
bb_perror_msg_and_die("can't read '%s'", filename);
return buf;
}