blob: 7b804125ab197f893cf064e0f89d3c189a1dc282 [file] [log] [blame]
Denis Vlasenkoea620772006-10-14 02:23:43 +00001/* vi: set sw=4 ts=4: */
2/*
3 * Utility routines.
4 *
5 * Copyright (C) 1999-2004 by Erik Andersen <andersen@codepoet.org>
6 *
7 * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
8 */
9
10#include "libbb.h"
11
Denis Vlasenkodefc1ea2008-06-27 02:52:20 +000012ssize_t FAST_FUNC safe_read(int fd, void *buf, size_t count)
Denis Vlasenkoea620772006-10-14 02:23:43 +000013{
14 ssize_t n;
15
16 do {
17 n = read(fd, buf, count);
18 } while (n < 0 && errno == EINTR);
19
20 return n;
21}
22
Denis Vlasenkoe376d452008-02-20 22:23:24 +000023/* Suppose that you are a shell. You start child processes.
24 * They work and eventually exit. You want to get user input.
25 * You read stdin. But what happens if last child switched
26 * its stdin into O_NONBLOCK mode?
27 *
28 * *** SURPRISE! It will affect the parent too! ***
29 * *** BIG SURPRISE! It stays even after child exits! ***
30 *
31 * This is a design bug in UNIX API.
32 * fcntl(0, F_SETFL, fcntl(0, F_GETFL, 0) | O_NONBLOCK);
33 * will set nonblocking mode not only on _your_ stdin, but
34 * also on stdin of your parent, etc.
35 *
36 * In general,
37 * fd2 = dup(fd1);
38 * fcntl(fd2, F_SETFL, fcntl(fd2, F_GETFL, 0) | O_NONBLOCK);
39 * sets both fd1 and fd2 to O_NONBLOCK. This includes cases
40 * where duping is done implicitly by fork() etc.
41 *
42 * We need
43 * fcntl(fd2, F_SETFD, fcntl(fd2, F_GETFD, 0) | O_NONBLOCK);
44 * (note SETFD, not SETFL!) but such thing doesn't exist.
45 *
46 * Alternatively, we need nonblocking_read(fd, ...) which doesn't
47 * require O_NONBLOCK dance at all. Actually, it exists:
48 * n = recv(fd, buf, len, MSG_DONTWAIT);
49 * "MSG_DONTWAIT:
50 * Enables non-blocking operation; if the operation
51 * would block, EAGAIN is returned."
52 * but recv() works only for sockets!
53 *
54 * So far I don't see any good solution, I can only propose
55 * that affected readers should be careful and use this routine,
56 * which detects EAGAIN and uses poll() to wait on the fd.
Denis Vlasenko081efd12008-02-20 22:57:24 +000057 * Thankfully, poll() doesn't care about O_NONBLOCK flag.
Denis Vlasenkoe376d452008-02-20 22:23:24 +000058 */
Denis Vlasenkodefc1ea2008-06-27 02:52:20 +000059ssize_t FAST_FUNC nonblock_safe_read(int fd, void *buf, size_t count)
Denis Vlasenkoe376d452008-02-20 22:23:24 +000060{
61 struct pollfd pfd[1];
62 ssize_t n;
63
64 while (1) {
65 n = safe_read(fd, buf, count);
66 if (n >= 0 || errno != EAGAIN)
67 return n;
68 /* fd is in O_NONBLOCK mode. Wait using poll and repeat */
69 pfd[0].fd = fd;
70 pfd[0].events = POLLIN;
71 safe_poll(pfd, 1, -1);
72 }
73}
74
Denis Vlasenkoea620772006-10-14 02:23:43 +000075/*
76 * Read all of the supplied buffer from a file.
77 * This does multiple reads as necessary.
78 * Returns the amount read, or -1 on an error.
79 * A short read is returned on an end of file.
80 */
Denis Vlasenkodefc1ea2008-06-27 02:52:20 +000081ssize_t FAST_FUNC full_read(int fd, void *buf, size_t len)
Denis Vlasenkoea620772006-10-14 02:23:43 +000082{
83 ssize_t cc;
84 ssize_t total;
85
86 total = 0;
87
88 while (len) {
89 cc = safe_read(fd, buf, len);
90
Denis Vlasenko394eebe2008-02-25 20:30:24 +000091 if (cc < 0) {
92 if (total) {
93 /* we already have some! */
94 /* user can do another read to know the error code */
95 return total;
96 }
97 return cc; /* read() returns -1 on failure. */
98 }
Denis Vlasenkoea620772006-10-14 02:23:43 +000099 if (cc == 0)
100 break;
Denis Vlasenkoea620772006-10-14 02:23:43 +0000101 buf = ((char *)buf) + cc;
102 total += cc;
103 len -= cc;
104 }
105
106 return total;
107}
108
109// Die with an error message if we can't read the entire buffer.
Denis Vlasenkodefc1ea2008-06-27 02:52:20 +0000110void FAST_FUNC xread(int fd, void *buf, size_t count)
Denis Vlasenkoea620772006-10-14 02:23:43 +0000111{
112 if (count) {
113 ssize_t size = full_read(fd, buf, count);
Denis Vlasenko77ad97f2008-05-13 02:27:31 +0000114 if ((size_t)size != count)
Denis Vlasenkoea620772006-10-14 02:23:43 +0000115 bb_error_msg_and_die("short read");
116 }
117}
118
119// Die with an error message if we can't read one character.
Denis Vlasenkodefc1ea2008-06-27 02:52:20 +0000120unsigned char FAST_FUNC xread_char(int fd)
Denis Vlasenkoea620772006-10-14 02:23:43 +0000121{
122 char tmp;
Denis Vlasenkoea620772006-10-14 02:23:43 +0000123 xread(fd, &tmp, 1);
Denis Vlasenkoea620772006-10-14 02:23:43 +0000124 return tmp;
125}
126
127// Read one line a-la fgets. Works only on seekable streams
Denis Vlasenkodefc1ea2008-06-27 02:52:20 +0000128char* FAST_FUNC reads(int fd, char *buffer, size_t size)
Denis Vlasenkoea620772006-10-14 02:23:43 +0000129{
130 char *p;
131
132 if (size < 2)
133 return NULL;
134 size = full_read(fd, buffer, size-1);
135 if ((ssize_t)size <= 0)
136 return NULL;
137
138 buffer[size] = '\0';
139 p = strchr(buffer, '\n');
140 if (p) {
141 off_t offset;
142 *p++ = '\0';
Denis Vlasenkob141b9b2006-10-31 22:46:08 +0000143 // avoid incorrect (unsigned) widening
Denis Vlasenko8ee649a2008-03-26 20:04:27 +0000144 offset = (off_t)(p - buffer) - (off_t)size;
Denis Vlasenko3a34d0c2007-01-12 22:10:34 +0000145 // set fd position right after '\n'
Denis Vlasenkoea620772006-10-14 02:23:43 +0000146 if (offset && lseek(fd, offset, SEEK_CUR) == (off_t)-1)
147 return NULL;
148 }
149 return buffer;
150}
151
Denis Vlasenko8ee649a2008-03-26 20:04:27 +0000152// Reads one line a-la fgets (but doesn't save terminating '\n').
153// Reads byte-by-byte. Useful when it is important to not read ahead.
Denis Vlasenkoe376d452008-02-20 22:23:24 +0000154// Bytes are appended to pfx (which must be malloced, or NULL).
Denis Vlasenkodefc1ea2008-06-27 02:52:20 +0000155char* FAST_FUNC xmalloc_reads(int fd, char *buf, size_t *maxsz_p)
Denis Vlasenkod67cef22007-06-13 06:47:47 +0000156{
157 char *p;
Denis Vlasenko0b6c6a92008-03-24 00:04:42 +0000158 size_t sz = buf ? strlen(buf) : 0;
159 size_t maxsz = maxsz_p ? *maxsz_p : MAXINT(size_t);
Denis Vlasenkod67cef22007-06-13 06:47:47 +0000160
161 goto jump_in;
Denis Vlasenko0b6c6a92008-03-24 00:04:42 +0000162 while (sz < maxsz) {
Denis Vlasenko77ad97f2008-05-13 02:27:31 +0000163 if ((size_t)(p - buf) == sz) {
Denis Vlasenkod67cef22007-06-13 06:47:47 +0000164 jump_in:
165 buf = xrealloc(buf, sz + 128);
166 p = buf + sz;
167 sz += 128;
168 }
Denis Vlasenkoe376d452008-02-20 22:23:24 +0000169 /* nonblock_safe_read() because we are used by e.g. shells */
170 if (nonblock_safe_read(fd, p, 1) != 1) { /* EOF/error */
Denis Vlasenkof99afb52008-02-24 23:32:36 +0000171 if (p == buf) { /* we read nothing */
Denis Vlasenkod67cef22007-06-13 06:47:47 +0000172 free(buf);
173 return NULL;
174 }
175 break;
176 }
177 if (*p == '\n')
178 break;
179 p++;
180 }
Denis Vlasenko8ee649a2008-03-26 20:04:27 +0000181 *p = '\0';
Denis Vlasenko0b6c6a92008-03-24 00:04:42 +0000182 if (maxsz_p)
Denis Vlasenko8ee649a2008-03-26 20:04:27 +0000183 *maxsz_p = p - buf;
184 p++;
Denis Vlasenkod67cef22007-06-13 06:47:47 +0000185 return xrealloc(buf, p - buf);
186}
187
Denis Vlasenkodefc1ea2008-06-27 02:52:20 +0000188ssize_t FAST_FUNC read_close(int fd, void *buf, size_t size)
Denis Vlasenkoea620772006-10-14 02:23:43 +0000189{
Denis Vlasenko98ebab82007-06-30 14:47:41 +0000190 /*int e;*/
Denis Vlasenkoea620772006-10-14 02:23:43 +0000191 size = full_read(fd, buf, size);
Denis Vlasenko98ebab82007-06-30 14:47:41 +0000192 /*e = errno;*/
Denis Vlasenkoea620772006-10-14 02:23:43 +0000193 close(fd);
Denis Vlasenko98ebab82007-06-30 14:47:41 +0000194 /*errno = e;*/
Denis Vlasenkoea620772006-10-14 02:23:43 +0000195 return size;
196}
197
Denis Vlasenkodefc1ea2008-06-27 02:52:20 +0000198ssize_t FAST_FUNC open_read_close(const char *filename, void *buf, size_t size)
Denis Vlasenkoea620772006-10-14 02:23:43 +0000199{
200 int fd = open(filename, O_RDONLY);
201 if (fd < 0)
202 return fd;
203 return read_close(fd, buf, size);
204}
205
Denis Vlasenkofe733a92008-06-24 16:08:22 +0000206// Read (potentially big) files in one go. File size is estimated
207// by stat.
Denis Vlasenkodefc1ea2008-06-27 02:52:20 +0000208void* FAST_FUNC xmalloc_open_read_close(const char *filename, size_t *sizep)
Denis Vlasenkoea620772006-10-14 02:23:43 +0000209{
210 char *buf;
Denis Vlasenko25cfe492008-04-20 01:27:59 +0000211 size_t size;
Denis Vlasenkod67cef22007-06-13 06:47:47 +0000212 int fd;
213 off_t len;
Denis Vlasenko0a144622008-04-20 14:45:43 +0000214 struct stat st;
215
216 fd = open(filename, O_RDONLY);
217 if (fd < 0)
218 return NULL;
219
220 st.st_size = 0; /* in case fstat fail, define to 0 */
221 fstat(fd, &st);
222 /* /proc/N/stat files report len 0 here */
223 /* In order to make such files readable, we add small const */
224 len = st.st_size | 0x3ff; /* read only 1k on unseekable files */
225 size = sizep ? *sizep : INT_MAX;
226 if (len < size)
227 size = len;
228 buf = xmalloc(size + 1);
229 size = read_close(fd, buf, size);
230 if ((ssize_t)size < 0) {
231 free(buf);
232 return NULL;
233 }
234 xrealloc(buf, size + 1);
235 buf[size] = '\0';
236
237 if (sizep)
238 *sizep = size;
239 return buf;
240}
241
242#ifdef USING_LSEEK_TO_GET_SIZE
243/* Alternatively, file size can be obtained by lseek to the end.
244 * The code is slightly bigger. Retained in case fstat approach
245 * will not work for some weird cases (/proc, block devices, etc).
246 * (NB: lseek also can fail to work for some weird files) */
247
248// Read (potentially big) files in one go. File size is estimated by
249// lseek to end.
Denis Vlasenkodefc1ea2008-06-27 02:52:20 +0000250void* FAST_FUNC xmalloc_open_read_close(const char *filename, size_t *sizep)
Denis Vlasenko0a144622008-04-20 14:45:43 +0000251{
252 char *buf;
253 size_t size;
254 int fd;
255 off_t len;
Denis Vlasenkod67cef22007-06-13 06:47:47 +0000256
Denis Vlasenkof3745ea2008-04-19 19:32:08 +0000257 fd = open(filename, O_RDONLY);
258 if (fd < 0)
259 return NULL;
Denis Vlasenko25cfe492008-04-20 01:27:59 +0000260
Denis Vlasenkob131b272006-12-17 17:30:01 +0000261 /* /proc/N/stat files report len 0 here */
262 /* In order to make such files readable, we add small const */
Denis Vlasenko25cfe492008-04-20 01:27:59 +0000263 size = 0x3ff; /* read only 1k on unseekable files */
264 len = lseek(fd, 0, SEEK_END) | 0x3ff; /* + up to 1k */
265 if (len != (off_t)-1) {
266 xlseek(fd, 0, SEEK_SET);
267 size = sizep ? *sizep : INT_MAX;
268 if (len < size)
269 size = len;
270 }
271
Denis Vlasenkob131b272006-12-17 17:30:01 +0000272 buf = xmalloc(size + 1);
Denis Vlasenkoea620772006-10-14 02:23:43 +0000273 size = read_close(fd, buf, size);
Denis Vlasenko25cfe492008-04-20 01:27:59 +0000274 if ((ssize_t)size < 0) {
275 free(buf);
276 return NULL;
277 }
Denis Vlasenkob131b272006-12-17 17:30:01 +0000278 xrealloc(buf, size + 1);
Denis Vlasenkoea620772006-10-14 02:23:43 +0000279 buf[size] = '\0';
Denis Vlasenko25cfe492008-04-20 01:27:59 +0000280
Denis Vlasenkod67cef22007-06-13 06:47:47 +0000281 if (sizep)
282 *sizep = size;
Denis Vlasenkoea620772006-10-14 02:23:43 +0000283 return buf;
284}
Denis Vlasenko0a144622008-04-20 14:45:43 +0000285#endif
Denis Vlasenkof3745ea2008-04-19 19:32:08 +0000286
Denis Vlasenkodefc1ea2008-06-27 02:52:20 +0000287void* FAST_FUNC xmalloc_xopen_read_close(const char *filename, size_t *sizep)
Denis Vlasenkof3745ea2008-04-19 19:32:08 +0000288{
289 void *buf = xmalloc_open_read_close(filename, sizep);
290 if (!buf)
291 bb_perror_msg_and_die("can't read '%s'", filename);
292 return buf;
293}