blob: 575446536098c259e98bb01529a58e4a99a9b500 [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
12ssize_t safe_read(int fd, void *buf, size_t count)
13{
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 */
59ssize_t nonblock_safe_read(int fd, void *buf, size_t count)
60{
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 */
81ssize_t full_read(int fd, void *buf, size_t len)
82{
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.
110void xread(int fd, void *buf, size_t count)
111{
112 if (count) {
113 ssize_t size = full_read(fd, buf, count);
114 if (size != count)
115 bb_error_msg_and_die("short read");
116 }
117}
118
119// Die with an error message if we can't read one character.
120unsigned char xread_char(int fd)
121{
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
128char *reads(int fd, char *buffer, size_t size)
129{
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
144 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 Vlasenkod67cef22007-06-13 06:47:47 +0000152// Read one line a-la fgets. Reads byte-by-byte.
153// 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 Vlasenkod67cef22007-06-13 06:47:47 +0000155char *xmalloc_reads(int fd, char *buf)
156{
157 char *p;
158 int sz = buf ? strlen(buf) : 0;
159
160 goto jump_in;
161 while (1) {
162 if (p - buf == sz) {
163 jump_in:
164 buf = xrealloc(buf, sz + 128);
165 p = buf + sz;
166 sz += 128;
167 }
Denis Vlasenkoe376d452008-02-20 22:23:24 +0000168 /* nonblock_safe_read() because we are used by e.g. shells */
169 if (nonblock_safe_read(fd, p, 1) != 1) { /* EOF/error */
Denis Vlasenkof99afb52008-02-24 23:32:36 +0000170 if (p == buf) { /* we read nothing */
Denis Vlasenkod67cef22007-06-13 06:47:47 +0000171 free(buf);
172 return NULL;
173 }
174 break;
175 }
176 if (*p == '\n')
177 break;
178 p++;
179 }
180 *p++ = '\0';
181 return xrealloc(buf, p - buf);
182}
183
Denis Vlasenkoea620772006-10-14 02:23:43 +0000184ssize_t read_close(int fd, void *buf, size_t size)
185{
Denis Vlasenko98ebab82007-06-30 14:47:41 +0000186 /*int e;*/
Denis Vlasenkoea620772006-10-14 02:23:43 +0000187 size = full_read(fd, buf, size);
Denis Vlasenko98ebab82007-06-30 14:47:41 +0000188 /*e = errno;*/
Denis Vlasenkoea620772006-10-14 02:23:43 +0000189 close(fd);
Denis Vlasenko98ebab82007-06-30 14:47:41 +0000190 /*errno = e;*/
Denis Vlasenkoea620772006-10-14 02:23:43 +0000191 return size;
192}
193
194ssize_t open_read_close(const char *filename, void *buf, size_t size)
195{
196 int fd = open(filename, O_RDONLY);
197 if (fd < 0)
198 return fd;
199 return read_close(fd, buf, size);
200}
201
Denis Vlasenkod67cef22007-06-13 06:47:47 +0000202// Read (potentially big) files in one go. File size is estimated by
203// lseek to end.
Denis Vlasenkoea620772006-10-14 02:23:43 +0000204void *xmalloc_open_read_close(const char *filename, size_t *sizep)
205{
206 char *buf;
207 size_t size = sizep ? *sizep : INT_MAX;
Denis Vlasenkod67cef22007-06-13 06:47:47 +0000208 int fd;
209 off_t len;
210
211 fd = xopen(filename, O_RDONLY);
Denis Vlasenkob131b272006-12-17 17:30:01 +0000212 /* /proc/N/stat files report len 0 here */
213 /* In order to make such files readable, we add small const */
Denis Vlasenkod67cef22007-06-13 06:47:47 +0000214 len = xlseek(fd, 0, SEEK_END) | 0x3ff; /* + up to 1k */
Denis Vlasenkoea620772006-10-14 02:23:43 +0000215 xlseek(fd, 0, SEEK_SET);
Denis Vlasenkod67cef22007-06-13 06:47:47 +0000216 if (len < size)
217 size = len;
Denis Vlasenkob131b272006-12-17 17:30:01 +0000218 buf = xmalloc(size + 1);
Denis Vlasenkoea620772006-10-14 02:23:43 +0000219 size = read_close(fd, buf, size);
220 if ((ssize_t)size < 0)
Denis Vlasenko8e858e22007-03-07 09:35:43 +0000221 bb_perror_msg_and_die("'%s'", filename);
Denis Vlasenkob131b272006-12-17 17:30:01 +0000222 xrealloc(buf, size + 1);
Denis Vlasenkoea620772006-10-14 02:23:43 +0000223 buf[size] = '\0';
Denis Vlasenkod67cef22007-06-13 06:47:47 +0000224 if (sizep)
225 *sizep = size;
Denis Vlasenkoea620772006-10-14 02:23:43 +0000226 return buf;
227}