/* 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(int fd, size_t *maxsz_p) { char *buf; size_t size, rd_size, total; 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; total = 0; buf = NULL; 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; } #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) bb_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; }