1 /* vi: set sw=4 ts=4: */
5 * Copyright (C) 1999-2004 by Erik Andersen <andersen@codepoet.org>
6 * Copyright (C) 2006 Rob Landley
7 * Copyright (C) 2006 Denys Vlasenko
9 * Licensed under GPLv2, see file LICENSE in this source tree.
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.
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.
22 * TODO: move xmalloc() and xatonum() here.
27 /* Turn on nonblocking I/O on a fd */
28 void FAST_FUNC
ndelay_on(int fd
)
30 int flags
= fcntl(fd
, F_GETFL
);
31 if (flags
& O_NONBLOCK
)
33 fcntl(fd
, F_SETFL
, flags
| O_NONBLOCK
);
36 void FAST_FUNC
ndelay_off(int fd
)
38 int flags
= fcntl(fd
, F_GETFL
);
39 if (!(flags
& O_NONBLOCK
))
41 fcntl(fd
, F_SETFL
, flags
& ~O_NONBLOCK
);
44 void FAST_FUNC
close_on_exec_on(int fd
)
46 fcntl(fd
, F_SETFD
, FD_CLOEXEC
);
49 char* FAST_FUNC
strncpy_IFNAMSIZ(char *dst
, const char *src
)
52 enum { IFNAMSIZ
= 16 };
54 return strncpy(dst
, src
, IFNAMSIZ
);
58 /* Convert unsigned integer to ascii, writing into supplied buffer.
59 * A truncated result contains the first few digits of the result ala strncpy.
60 * Returns a pointer past last generated digit, does _not_ store NUL.
62 void BUG_sizeof(void);
63 char* FAST_FUNC
utoa_to_buf(unsigned n
, char *buf
, unsigned buflen
)
70 // 2^32-1 = 4294967295
72 #if UINT_MAX > 4294967295 /* prevents warning about "const too large" */
75 // 2^64-1 = 18446744073709551615
76 i
= 10000000000000000000;
83 if (res
|| out
|| i
== 1) {
94 /* Convert signed integer to ascii, like utoa_to_buf() */
95 char* FAST_FUNC
itoa_to_buf(int n
, char *buf
, unsigned buflen
)
104 return utoa_to_buf((unsigned)n
, buf
, buflen
);
107 // The following two functions use a static buffer, so calling either one a
108 // second time will overwrite previous results.
110 // The largest 32 bit integer is -2 billion plus NUL, or 1+10+1=12 bytes.
111 // It so happens that sizeof(int) * 3 is enough for 32+ bit ints.
112 // (sizeof(int) * 3 + 2 is correct for any width, even 8-bit)
114 static char local_buf
[sizeof(int) * 3];
116 /* Convert unsigned integer to ascii using a static buffer (returned). */
117 char* FAST_FUNC
utoa(unsigned n
)
119 *(utoa_to_buf(n
, local_buf
, sizeof(local_buf
) - 1)) = '\0';
124 /* Convert signed integer to ascii using a static buffer (returned). */
125 char* FAST_FUNC
itoa(int n
)
127 *(itoa_to_buf(n
, local_buf
, sizeof(local_buf
) - 1)) = '\0';
132 /* Emit a string of hex representation of bytes */
133 char* FAST_FUNC
bin2hex(char *p
, const char *cp
, int count
)
136 unsigned char c
= *cp
++;
137 /* put lowercase hex digits */
138 *p
++ = 0x20 | bb_hexdigits_upcase
[c
>> 4];
139 *p
++ = 0x20 | bb_hexdigits_upcase
[c
& 0xf];
145 /* Convert "[x]x[:][x]x[:][x]x[:][x]x" hex string to binary, no more than COUNT bytes */
146 char* FAST_FUNC
hex2bin(char *dst
, const char *str
, int count
)
149 while (*str
&& count
) {
154 else if ((c
|0x20) >= 'a' && (c
|0x20) <= 'f')
155 val
= (c
|0x20) - ('a' - 10);
162 else if ((c
|0x20) >= 'a' && (c
|0x20) <= 'f')
163 val
|= (c
|0x20) - ('a' - 10);
164 else if (c
== ':' || c
== '\0')
176 errno
= (*str
? ERANGE
: 0);
180 /* Return how long the file at fd is, if there's any way to determine it. */
182 off_t FAST_FUNC
fdlength(int fd
)
184 off_t bottom
= 0, top
= 0, pos
;
187 // If the ioctl works for this, return it.
189 if (ioctl(fd
, BLKGETSIZE
, &size
) >= 0) return size
*512;
191 // FIXME: explain why lseek(SEEK_END) is not used here!
193 // If not, do a binary search for the last location we can read. (Some
194 // block devices don't do BLKGETSIZE right.)
199 pos
= bottom
+ (top
- bottom
) / 2;
201 // If we can read from the current location, it's bigger.
203 if (lseek(fd
, pos
, SEEK_SET
)>=0 && safe_read(fd
, &temp
, 1)==1) {
204 if (bottom
== top
) bottom
= top
= (top
+1) * 2;
207 // If we can't, it's smaller.
216 } while (bottom
+ 1 != top
);
222 int FAST_FUNC
bb_putchar_stderr(char ch
)
224 return write(STDERR_FILENO
, &ch
, 1);
227 ssize_t FAST_FUNC
full_write1_str(const char *str
)
229 return full_write(STDOUT_FILENO
, str
, strlen(str
));
232 ssize_t FAST_FUNC
full_write2_str(const char *str
)
234 return full_write(STDERR_FILENO
, str
, strlen(str
));
237 static int wh_helper(int value
, int def_val
, const char *env_name
, int *err
)
240 char *s
= getenv(env_name
);
243 /* If LINES/COLUMNS are set, pretend that there is
244 * no error getting w/h, this prevents some ugly
245 * cursor tricks by our callers */
249 if (value
<= 1 || value
>= 30000)
254 /* It is perfectly ok to pass in a NULL for either width or for
255 * height, in which case that value will not be set. */
256 int FAST_FUNC
get_terminal_width_height(int fd
, unsigned *width
, unsigned *height
)
263 /* I've seen ioctl returning 0, but row/col is (still?) 0.
264 * We treat that as an error too. */
265 err
= ioctl(fd
, TIOCGWINSZ
, &win
) != 0 || win
.ws_row
== 0;
267 *height
= wh_helper(win
.ws_row
, 24, "LINES", &err
);
269 *width
= wh_helper(win
.ws_col
, 80, "COLUMNS", &err
);
273 int FAST_FUNC
tcsetattr_stdin_TCSANOW(const struct termios
*tp
)
275 return tcsetattr(STDIN_FILENO
, TCSANOW
, tp
);
278 pid_t FAST_FUNC
safe_waitpid(pid_t pid
, int *wstat
, int options
)
283 r
= waitpid(pid
, wstat
, options
);
284 while ((r
== -1) && (errno
== EINTR
));
288 pid_t FAST_FUNC
wait_any_nohang(int *wstat
)
290 return safe_waitpid(-1, wstat
, WNOHANG
);
293 // Wait for the specified child PID to exit, returning child's error return.
294 int FAST_FUNC
wait4pid(pid_t pid
)
299 /*errno = ECHILD; -- wrong. */
300 /* we expect errno to be already set from failed [v]fork/exec */
303 if (safe_waitpid(pid
, &status
, 0) == -1)
305 if (WIFEXITED(status
))
306 return WEXITSTATUS(status
);
307 if (WIFSIGNALED(status
))
308 return WTERMSIG(status
) + 0x180;
312 char * FAST_FUNC
unparse_uuid(const uint8_t *uu
, char *out
)
314 char uuid_string
[32];
316 bin2hex(uuid_string
, (char *)uu
, 16);
317 /* f.e. UUID=dfd9c173-be52-4d27-99a5-c34c6c2ff55f */
318 sprintf(out
, "%.8s-%.4s-%.4s-%.4s-%.12s",
328 static unsigned char fromhex(char c
)
332 return ((c
|0x20) - 'a' + 10);
335 /* Parse & verify UUID string */
336 int FAST_FUNC
parse_uuid(const char *s
, uint8_t *uuid
)
340 if (strlen(s
) != 36 || s
[8] != '-' || s
[13] != '-'
341 || s
[18] != '-' || s
[23] != '-'
345 for (i
= 0; i
< 16; i
++) {
348 if (!isxdigit(s
[0]) || !isxdigit(s
[1]))
350 uuid
[i
] = ((fromhex(s
[0]) << 4) | fromhex(s
[1]));