blob: 45650edba528c58168656adacc314b71275f3062
1 | /* vi: set sw=4 ts=4: */ |
2 | /* |
3 | * Utility routines. |
4 | * |
5 | * Copyright (C) 1999-2004 by Erik Andersen <andersen@codepoet.org> |
6 | * Copyright (C) 2006 Rob Landley |
7 | * Copyright (C) 2006 Denys Vlasenko |
8 | * |
9 | * Licensed under GPLv2, see file LICENSE in this source tree. |
10 | */ |
11 | |
12 | /* We need to have separate xfuncs.c and xfuncs_printf.c because |
13 | * with current linkers, even with section garbage collection, |
14 | * if *.o module references any of XXXprintf functions, you pull in |
15 | * entire printf machinery. Even if you do not use the function |
16 | * which uses XXXprintf. |
17 | * |
18 | * xfuncs.c contains functions (not necessarily xfuncs) |
19 | * which do not pull in printf, directly or indirectly. |
20 | * xfunc_printf.c contains those which do. |
21 | * |
22 | * TODO: move xmalloc() and xatonum() here. |
23 | */ |
24 | |
25 | #include "libbb.h" |
26 | |
27 | /* Turn on nonblocking I/O on a fd */ |
28 | int FAST_FUNC ndelay_on(int fd) |
29 | { |
30 | int flags = fcntl(fd, F_GETFL); |
31 | if (flags & O_NONBLOCK) |
32 | return flags; |
33 | fcntl(fd, F_SETFL, flags | O_NONBLOCK); |
34 | return flags; |
35 | } |
36 | |
37 | int FAST_FUNC ndelay_off(int fd) |
38 | { |
39 | int flags = fcntl(fd, F_GETFL); |
40 | if (!(flags & O_NONBLOCK)) |
41 | return flags; |
42 | fcntl(fd, F_SETFL, flags & ~O_NONBLOCK); |
43 | return flags; |
44 | } |
45 | |
46 | void FAST_FUNC close_on_exec_on(int fd) |
47 | { |
48 | fcntl(fd, F_SETFD, FD_CLOEXEC); |
49 | } |
50 | |
51 | char* FAST_FUNC strncpy_IFNAMSIZ(char *dst, const char *src) |
52 | { |
53 | #ifndef IFNAMSIZ |
54 | enum { IFNAMSIZ = 16 }; |
55 | #endif |
56 | return strncpy(dst, src, IFNAMSIZ); |
57 | } |
58 | |
59 | |
60 | /* Convert unsigned integer to ascii, writing into supplied buffer. |
61 | * A truncated result contains the first few digits of the result ala strncpy. |
62 | * Returns a pointer past last generated digit, does _not_ store NUL. |
63 | */ |
64 | void BUG_sizeof(void); |
65 | char* FAST_FUNC utoa_to_buf(unsigned n, char *buf, unsigned buflen) |
66 | { |
67 | unsigned i, out, res; |
68 | |
69 | if (buflen) { |
70 | out = 0; |
71 | if (sizeof(n) == 4) |
72 | // 2^32-1 = 4294967295 |
73 | i = 1000000000; |
74 | #if UINT_MAX > 4294967295 /* prevents warning about "const too large" */ |
75 | else |
76 | if (sizeof(n) == 8) |
77 | // 2^64-1 = 18446744073709551615 |
78 | i = 10000000000000000000; |
79 | #endif |
80 | else |
81 | BUG_sizeof(); |
82 | for (; i; i /= 10) { |
83 | res = n / i; |
84 | n = n % i; |
85 | if (res || out || i == 1) { |
86 | if (--buflen == 0) |
87 | break; |
88 | out++; |
89 | *buf++ = '0' + res; |
90 | } |
91 | } |
92 | } |
93 | return buf; |
94 | } |
95 | |
96 | /* Convert signed integer to ascii, like utoa_to_buf() */ |
97 | char* FAST_FUNC itoa_to_buf(int n, char *buf, unsigned buflen) |
98 | { |
99 | if (!buflen) |
100 | return buf; |
101 | if (n < 0) { |
102 | n = -n; |
103 | *buf++ = '-'; |
104 | buflen--; |
105 | } |
106 | return utoa_to_buf((unsigned)n, buf, buflen); |
107 | } |
108 | |
109 | // The following two functions use a static buffer, so calling either one a |
110 | // second time will overwrite previous results. |
111 | // |
112 | // The largest 32 bit integer is -2 billion plus NUL, or 1+10+1=12 bytes. |
113 | // It so happens that sizeof(int) * 3 is enough for 32+ bit ints. |
114 | // (sizeof(int) * 3 + 2 is correct for any width, even 8-bit) |
115 | |
116 | static char local_buf[sizeof(int) * 3]; |
117 | |
118 | /* Convert unsigned integer to ascii using a static buffer (returned). */ |
119 | char* FAST_FUNC utoa(unsigned n) |
120 | { |
121 | *(utoa_to_buf(n, local_buf, sizeof(local_buf) - 1)) = '\0'; |
122 | |
123 | return local_buf; |
124 | } |
125 | |
126 | /* Convert signed integer to ascii using a static buffer (returned). */ |
127 | char* FAST_FUNC itoa(int n) |
128 | { |
129 | *(itoa_to_buf(n, local_buf, sizeof(local_buf) - 1)) = '\0'; |
130 | |
131 | return local_buf; |
132 | } |
133 | |
134 | /* Emit a string of hex representation of bytes */ |
135 | char* FAST_FUNC bin2hex(char *p, const char *cp, int count) |
136 | { |
137 | while (count) { |
138 | unsigned char c = *cp++; |
139 | /* put lowercase hex digits */ |
140 | *p++ = 0x20 | bb_hexdigits_upcase[c >> 4]; |
141 | *p++ = 0x20 | bb_hexdigits_upcase[c & 0xf]; |
142 | count--; |
143 | } |
144 | return p; |
145 | } |
146 | |
147 | /* Convert "[x]x[:][x]x[:][x]x[:][x]x" hex string to binary, no more than COUNT bytes */ |
148 | char* FAST_FUNC hex2bin(char *dst, const char *str, int count) |
149 | { |
150 | errno = EINVAL; |
151 | while (*str && count) { |
152 | uint8_t val; |
153 | uint8_t c = *str++; |
154 | if (isdigit(c)) |
155 | val = c - '0'; |
156 | else if ((c|0x20) >= 'a' && (c|0x20) <= 'f') |
157 | val = (c|0x20) - ('a' - 10); |
158 | else |
159 | return NULL; |
160 | val <<= 4; |
161 | c = *str; |
162 | if (isdigit(c)) |
163 | val |= c - '0'; |
164 | else if ((c|0x20) >= 'a' && (c|0x20) <= 'f') |
165 | val |= (c|0x20) - ('a' - 10); |
166 | else if (c == ':' || c == '\0') |
167 | val >>= 4; |
168 | else |
169 | return NULL; |
170 | |
171 | *dst++ = val; |
172 | if (c != '\0') |
173 | str++; |
174 | if (*str == ':') |
175 | str++; |
176 | count--; |
177 | } |
178 | errno = (*str ? ERANGE : 0); |
179 | return dst; |
180 | } |
181 | |
182 | /* Return how long the file at fd is, if there's any way to determine it. */ |
183 | #ifdef UNUSED |
184 | off_t FAST_FUNC fdlength(int fd) |
185 | { |
186 | off_t bottom = 0, top = 0, pos; |
187 | long size; |
188 | |
189 | // If the ioctl works for this, return it. |
190 | |
191 | if (ioctl(fd, BLKGETSIZE, &size) >= 0) return size*512; |
192 | |
193 | // FIXME: explain why lseek(SEEK_END) is not used here! |
194 | |
195 | // If not, do a binary search for the last location we can read. (Some |
196 | // block devices don't do BLKGETSIZE right.) |
197 | |
198 | do { |
199 | char temp; |
200 | |
201 | pos = bottom + (top - bottom) / 2; |
202 | |
203 | // If we can read from the current location, it's bigger. |
204 | |
205 | if (lseek(fd, pos, SEEK_SET)>=0 && safe_read(fd, &temp, 1)==1) { |
206 | if (bottom == top) bottom = top = (top+1) * 2; |
207 | else bottom = pos; |
208 | |
209 | // If we can't, it's smaller. |
210 | } else { |
211 | if (bottom == top) { |
212 | if (!top) return 0; |
213 | bottom = top/2; |
214 | } |
215 | else top = pos; |
216 | } |
217 | } while (bottom + 1 != top); |
218 | |
219 | return pos + 1; |
220 | } |
221 | #endif |
222 | |
223 | int FAST_FUNC bb_putchar_stderr(char ch) |
224 | { |
225 | return write(STDERR_FILENO, &ch, 1); |
226 | } |
227 | |
228 | ssize_t FAST_FUNC full_write1_str(const char *str) |
229 | { |
230 | return full_write(STDOUT_FILENO, str, strlen(str)); |
231 | } |
232 | |
233 | ssize_t FAST_FUNC full_write2_str(const char *str) |
234 | { |
235 | return full_write(STDERR_FILENO, str, strlen(str)); |
236 | } |
237 | |
238 | static int wh_helper(int value, int def_val, const char *env_name, int *err) |
239 | { |
240 | /* Envvars override even if "value" from ioctl is valid (>0). |
241 | * Rationale: it's impossible to guess what user wants. |
242 | * For example: "man CMD | ...": should "man" format output |
243 | * to stdout's width? stdin's width? /dev/tty's width? 80 chars? |
244 | * We _cant_ know it. If "..." saves text for e.g. email, |
245 | * then it's probably 80 chars. |
246 | * If "..." is, say, "grep -v DISCARD | $PAGER", then user |
247 | * would prefer his tty's width to be used! |
248 | * |
249 | * Since we don't know, at least allow user to do this: |
250 | * "COLUMNS=80 man CMD | ..." |
251 | */ |
252 | char *s = getenv(env_name); |
253 | if (s) { |
254 | value = atoi(s); |
255 | /* If LINES/COLUMNS are set, pretend that there is |
256 | * no error getting w/h, this prevents some ugly |
257 | * cursor tricks by our callers */ |
258 | *err = 0; |
259 | } |
260 | |
261 | if (value <= 1 || value >= 30000) |
262 | value = def_val; |
263 | return value; |
264 | } |
265 | |
266 | /* It is perfectly ok to pass in a NULL for either width or for |
267 | * height, in which case that value will not be set. */ |
268 | int FAST_FUNC get_terminal_width_height(int fd, unsigned *width, unsigned *height) |
269 | { |
270 | struct winsize win; |
271 | int err; |
272 | int close_me = -1; |
273 | |
274 | if (fd == -1) { |
275 | if (isatty(STDOUT_FILENO)) |
276 | fd = STDOUT_FILENO; |
277 | else |
278 | if (isatty(STDERR_FILENO)) |
279 | fd = STDERR_FILENO; |
280 | else |
281 | if (isatty(STDIN_FILENO)) |
282 | fd = STDIN_FILENO; |
283 | else |
284 | close_me = fd = open("/dev/tty", O_RDONLY); |
285 | } |
286 | |
287 | win.ws_row = 0; |
288 | win.ws_col = 0; |
289 | /* I've seen ioctl returning 0, but row/col is (still?) 0. |
290 | * We treat that as an error too. */ |
291 | err = ioctl(fd, TIOCGWINSZ, &win) != 0 || win.ws_row == 0; |
292 | if (height) |
293 | *height = wh_helper(win.ws_row, 24, "LINES", &err); |
294 | if (width) |
295 | *width = wh_helper(win.ws_col, 80, "COLUMNS", &err); |
296 | |
297 | if (close_me >= 0) |
298 | close(close_me); |
299 | |
300 | return err; |
301 | } |
302 | int FAST_FUNC get_terminal_width(int fd) |
303 | { |
304 | unsigned width; |
305 | get_terminal_width_height(fd, &width, NULL); |
306 | return width; |
307 | } |
308 | |
309 | int FAST_FUNC tcsetattr_stdin_TCSANOW(const struct termios *tp) |
310 | { |
311 | return tcsetattr(STDIN_FILENO, TCSANOW, tp); |
312 | } |
313 | |
314 | pid_t FAST_FUNC safe_waitpid(pid_t pid, int *wstat, int options) |
315 | { |
316 | pid_t r; |
317 | |
318 | do |
319 | r = waitpid(pid, wstat, options); |
320 | while ((r == -1) && (errno == EINTR)); |
321 | return r; |
322 | } |
323 | |
324 | pid_t FAST_FUNC wait_any_nohang(int *wstat) |
325 | { |
326 | return safe_waitpid(-1, wstat, WNOHANG); |
327 | } |
328 | |
329 | // Wait for the specified child PID to exit, returning child's error return. |
330 | int FAST_FUNC wait4pid(pid_t pid) |
331 | { |
332 | int status; |
333 | |
334 | if (pid <= 0) { |
335 | /*errno = ECHILD; -- wrong. */ |
336 | /* we expect errno to be already set from failed [v]fork/exec */ |
337 | return -1; |
338 | } |
339 | if (safe_waitpid(pid, &status, 0) == -1) |
340 | return -1; |
341 | if (WIFEXITED(status)) |
342 | return WEXITSTATUS(status); |
343 | if (WIFSIGNALED(status)) |
344 | return WTERMSIG(status) + 0x180; |
345 | return 0; |
346 | } |
347 | |
348 | // Useful when we do know that pid is valid, and we just want to wait |
349 | // for it to exit. Not existing pid is fatal. waitpid() status is not returned. |
350 | int FAST_FUNC wait_for_exitstatus(pid_t pid) |
351 | { |
352 | int exit_status, n; |
353 | |
354 | n = safe_waitpid(pid, &exit_status, 0); |
355 | if (n < 0) |
356 | bb_perror_msg_and_die("waitpid"); |
357 | return exit_status; |
358 | } |
359 |