Eric Andersen | aad1a88 | 2001-03-16 22:47:14 +0000 | [diff] [blame] | 1 | /* vi: set sw=4 ts=4: */ |
| 2 | /* |
| 3 | * Utility routines. |
| 4 | * |
Eric Andersen | c7bda1c | 2004-03-15 08:29:22 +0000 | [diff] [blame] | 5 | * Copyright (C) 1999-2004 by Erik Andersen <andersen@codepoet.org> |
Rob Landley | d921b2e | 2006-08-03 15:41:12 +0000 | [diff] [blame] | 6 | * Copyright (C) 2006 Rob Landley |
Denis Vlasenko | d18f52b | 2008-03-02 12:53:15 +0000 | [diff] [blame] | 7 | * Copyright (C) 2006 Denys Vlasenko |
Eric Andersen | aad1a88 | 2001-03-16 22:47:14 +0000 | [diff] [blame] | 8 | * |
Rob Landley | fbdf121 | 2006-09-20 22:06:01 +0000 | [diff] [blame] | 9 | * Licensed under GPL version 2, see file LICENSE in this tarball for details. |
Eric Andersen | aad1a88 | 2001-03-16 22:47:14 +0000 | [diff] [blame] | 10 | */ |
| 11 | |
Denis Vlasenko | b12b1c8 | 2008-04-09 00:33:23 +0000 | [diff] [blame] | 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 | |
Denis Vlasenko | b6adbf1 | 2007-05-26 19:00:18 +0000 | [diff] [blame] | 25 | #include "libbb.h" |
Eric Andersen | aad1a88 | 2001-03-16 22:47:14 +0000 | [diff] [blame] | 26 | |
Denis Vlasenko | b12b1c8 | 2008-04-09 00:33:23 +0000 | [diff] [blame] | 27 | /* Turn on nonblocking I/O on a fd */ |
Denis Vlasenko | defc1ea | 2008-06-27 02:52:20 +0000 | [diff] [blame] | 28 | int FAST_FUNC ndelay_on(int fd) |
Denis Vlasenko | 75f8d08 | 2006-11-22 15:54:52 +0000 | [diff] [blame] | 29 | { |
Denys Vlasenko | ab19ede | 2009-11-11 21:05:42 +0100 | [diff] [blame] | 30 | return fcntl(fd, F_SETFL, fcntl(fd, F_GETFL) | O_NONBLOCK); |
Denis Vlasenko | 75f8d08 | 2006-11-22 15:54:52 +0000 | [diff] [blame] | 31 | } |
| 32 | |
Denis Vlasenko | defc1ea | 2008-06-27 02:52:20 +0000 | [diff] [blame] | 33 | int FAST_FUNC ndelay_off(int fd) |
Denis Vlasenko | a5b3e76 | 2006-12-24 07:15:50 +0000 | [diff] [blame] | 34 | { |
Denys Vlasenko | ab19ede | 2009-11-11 21:05:42 +0100 | [diff] [blame] | 35 | return fcntl(fd, F_SETFL, fcntl(fd, F_GETFL) & ~O_NONBLOCK); |
Denis Vlasenko | a5b3e76 | 2006-12-24 07:15:50 +0000 | [diff] [blame] | 36 | } |
| 37 | |
Denis Vlasenko | defc1ea | 2008-06-27 02:52:20 +0000 | [diff] [blame] | 38 | int FAST_FUNC close_on_exec_on(int fd) |
Denis Vlasenko | a27a11b | 2007-08-18 14:16:39 +0000 | [diff] [blame] | 39 | { |
Denis Vlasenko | b12b1c8 | 2008-04-09 00:33:23 +0000 | [diff] [blame] | 40 | return fcntl(fd, F_SETFD, FD_CLOEXEC); |
Denis Vlasenko | a27a11b | 2007-08-18 14:16:39 +0000 | [diff] [blame] | 41 | } |
| 42 | |
Denis Vlasenko | 360d966 | 2008-12-02 18:18:50 +0000 | [diff] [blame] | 43 | char* FAST_FUNC strncpy_IFNAMSIZ(char *dst, const char *src) |
| 44 | { |
| 45 | #ifndef IFNAMSIZ |
| 46 | enum { IFNAMSIZ = 16 }; |
| 47 | #endif |
| 48 | return strncpy(dst, src, IFNAMSIZ); |
| 49 | } |
| 50 | |
Denis Vlasenko | 56ea65c | 2008-01-06 03:26:53 +0000 | [diff] [blame] | 51 | |
Denis Vlasenko | 450196c | 2007-03-28 21:57:12 +0000 | [diff] [blame] | 52 | // Convert unsigned integer to ascii, writing into supplied buffer. |
| 53 | // A truncated result contains the first few digits of the result ala strncpy. |
| 54 | // Returns a pointer past last generated digit, does _not_ store NUL. |
Denis Vlasenko | aae0311 | 2006-11-05 00:44:39 +0000 | [diff] [blame] | 55 | void BUG_sizeof_unsigned_not_4(void); |
Denis Vlasenko | defc1ea | 2008-06-27 02:52:20 +0000 | [diff] [blame] | 56 | char* FAST_FUNC utoa_to_buf(unsigned n, char *buf, unsigned buflen) |
Rob Landley | 5b88a38 | 2006-07-10 07:41:34 +0000 | [diff] [blame] | 57 | { |
Denis Vlasenko | aae0311 | 2006-11-05 00:44:39 +0000 | [diff] [blame] | 58 | unsigned i, out, res; |
| 59 | if (sizeof(unsigned) != 4) |
| 60 | BUG_sizeof_unsigned_not_4(); |
Rob Landley | 22d3958 | 2006-07-11 00:44:36 +0000 | [diff] [blame] | 61 | if (buflen) { |
Denis Vlasenko | aae0311 | 2006-11-05 00:44:39 +0000 | [diff] [blame] | 62 | out = 0; |
| 63 | for (i = 1000000000; i; i /= 10) { |
| 64 | res = n / i; |
| 65 | if (res || out || i == 1) { |
| 66 | if (!--buflen) break; |
Rob Landley | 22d3958 | 2006-07-11 00:44:36 +0000 | [diff] [blame] | 67 | out++; |
| 68 | n -= res*i; |
| 69 | *buf++ = '0' + res; |
| 70 | } |
Rob Landley | 5b88a38 | 2006-07-10 07:41:34 +0000 | [diff] [blame] | 71 | } |
| 72 | } |
Denis Vlasenko | 10457b9 | 2007-03-27 22:01:31 +0000 | [diff] [blame] | 73 | return buf; |
Rob Landley | 5b88a38 | 2006-07-10 07:41:34 +0000 | [diff] [blame] | 74 | } |
| 75 | |
Denis Vlasenko | b12b1c8 | 2008-04-09 00:33:23 +0000 | [diff] [blame] | 76 | /* Convert signed integer to ascii, like utoa_to_buf() */ |
Denis Vlasenko | defc1ea | 2008-06-27 02:52:20 +0000 | [diff] [blame] | 77 | char* FAST_FUNC itoa_to_buf(int n, char *buf, unsigned buflen) |
Rob Landley | 5b88a38 | 2006-07-10 07:41:34 +0000 | [diff] [blame] | 78 | { |
Denis Vlasenko | 6c10657 | 2008-04-19 19:05:12 +0000 | [diff] [blame] | 79 | if (buflen && n < 0) { |
Rob Landley | 5b88a38 | 2006-07-10 07:41:34 +0000 | [diff] [blame] | 80 | n = -n; |
| 81 | *buf++ = '-'; |
Rob Landley | 22d3958 | 2006-07-11 00:44:36 +0000 | [diff] [blame] | 82 | buflen--; |
Rob Landley | 5b88a38 | 2006-07-10 07:41:34 +0000 | [diff] [blame] | 83 | } |
Denis Vlasenko | 10457b9 | 2007-03-27 22:01:31 +0000 | [diff] [blame] | 84 | return utoa_to_buf((unsigned)n, buf, buflen); |
Rob Landley | 5b88a38 | 2006-07-10 07:41:34 +0000 | [diff] [blame] | 85 | } |
| 86 | |
Rob Landley | da9d1d0 | 2006-09-14 19:52:07 +0000 | [diff] [blame] | 87 | // The following two functions use a static buffer, so calling either one a |
| 88 | // second time will overwrite previous results. |
| 89 | // |
| 90 | // The largest 32 bit integer is -2 billion plus null terminator, or 12 bytes. |
Denis Vlasenko | b12b1c8 | 2008-04-09 00:33:23 +0000 | [diff] [blame] | 91 | // It so happens that sizeof(int) * 3 is enough for 32+ bits. |
| 92 | // (sizeof(int) * 3 + 2 is correct for any width, even 8-bit) |
Rob Landley | da9d1d0 | 2006-09-14 19:52:07 +0000 | [diff] [blame] | 93 | |
Denis Vlasenko | b12b1c8 | 2008-04-09 00:33:23 +0000 | [diff] [blame] | 94 | static char local_buf[sizeof(int) * 3]; |
Rob Landley | 23b61be | 2006-08-04 20:20:03 +0000 | [diff] [blame] | 95 | |
Rob Landley | da9d1d0 | 2006-09-14 19:52:07 +0000 | [diff] [blame] | 96 | // Convert unsigned integer to ascii using a static buffer (returned). |
Denis Vlasenko | defc1ea | 2008-06-27 02:52:20 +0000 | [diff] [blame] | 97 | char* FAST_FUNC utoa(unsigned n) |
Rob Landley | 23b61be | 2006-08-04 20:20:03 +0000 | [diff] [blame] | 98 | { |
Denis Vlasenko | 10457b9 | 2007-03-27 22:01:31 +0000 | [diff] [blame] | 99 | *(utoa_to_buf(n, local_buf, sizeof(local_buf))) = '\0'; |
Rob Landley | 23b61be | 2006-08-04 20:20:03 +0000 | [diff] [blame] | 100 | |
| 101 | return local_buf; |
| 102 | } |
| 103 | |
Denis Vlasenko | b12b1c8 | 2008-04-09 00:33:23 +0000 | [diff] [blame] | 104 | /* Convert signed integer to ascii using a static buffer (returned). */ |
Denis Vlasenko | defc1ea | 2008-06-27 02:52:20 +0000 | [diff] [blame] | 105 | char* FAST_FUNC itoa(int n) |
Rob Landley | 5b88a38 | 2006-07-10 07:41:34 +0000 | [diff] [blame] | 106 | { |
Denis Vlasenko | 10457b9 | 2007-03-27 22:01:31 +0000 | [diff] [blame] | 107 | *(itoa_to_buf(n, local_buf, sizeof(local_buf))) = '\0'; |
Rob Landley | 5b88a38 | 2006-07-10 07:41:34 +0000 | [diff] [blame] | 108 | |
| 109 | return local_buf; |
| 110 | } |
Rob Landley | df822f2 | 2006-07-15 23:00:46 +0000 | [diff] [blame] | 111 | |
Denis Vlasenko | b12b1c8 | 2008-04-09 00:33:23 +0000 | [diff] [blame] | 112 | /* Emit a string of hex representation of bytes */ |
Denis Vlasenko | defc1ea | 2008-06-27 02:52:20 +0000 | [diff] [blame] | 113 | char* FAST_FUNC bin2hex(char *p, const char *cp, int count) |
Denis Vlasenko | 3a34d0c | 2007-01-12 22:10:34 +0000 | [diff] [blame] | 114 | { |
| 115 | while (count) { |
| 116 | unsigned char c = *cp++; |
| 117 | /* put lowercase hex digits */ |
Denis Vlasenko | 98c0bba | 2007-01-26 23:31:05 +0000 | [diff] [blame] | 118 | *p++ = 0x20 | bb_hexdigits_upcase[c >> 4]; |
| 119 | *p++ = 0x20 | bb_hexdigits_upcase[c & 0xf]; |
Denis Vlasenko | 3a34d0c | 2007-01-12 22:10:34 +0000 | [diff] [blame] | 120 | count--; |
| 121 | } |
| 122 | return p; |
| 123 | } |
| 124 | |
Denys Vlasenko | 4836331 | 2010-04-04 15:29:32 +0200 | [diff] [blame] | 125 | /* Convert "[x]x[:][x]x[:][x]x[:][x]x" hex string to binary, no more than COUNT bytes */ |
| 126 | char* FAST_FUNC hex2bin(char *dst, const char *str, int count) |
| 127 | { |
| 128 | errno = EINVAL; |
| 129 | while (*str && count) { |
| 130 | uint8_t val; |
| 131 | uint8_t c = *str++; |
| 132 | if (isdigit(c)) |
| 133 | val = c - '0'; |
| 134 | else if ((c|0x20) >= 'a' && (c|0x20) <= 'f') |
| 135 | val = (c|0x20) - ('a' - 10); |
| 136 | else |
| 137 | return NULL; |
| 138 | val <<= 4; |
| 139 | c = *str; |
| 140 | if (isdigit(c)) |
| 141 | val |= c - '0'; |
| 142 | else if ((c|0x20) >= 'a' && (c|0x20) <= 'f') |
| 143 | val |= (c|0x20) - ('a' - 10); |
| 144 | else if (c == ':' || c == '\0') |
| 145 | val >>= 4; |
| 146 | else |
| 147 | return NULL; |
| 148 | |
| 149 | *dst++ = val; |
| 150 | if (c != '\0') |
| 151 | str++; |
| 152 | if (*str == ':') |
| 153 | str++; |
| 154 | count--; |
| 155 | } |
| 156 | errno = (*str ? ERANGE : 0); |
| 157 | return dst; |
| 158 | } |
| 159 | |
Denis Vlasenko | b12b1c8 | 2008-04-09 00:33:23 +0000 | [diff] [blame] | 160 | /* Return how long the file at fd is, if there's any way to determine it. */ |
Denis Vlasenko | b5c60fc | 2008-01-27 23:41:34 +0000 | [diff] [blame] | 161 | #ifdef UNUSED |
Denis Vlasenko | defc1ea | 2008-06-27 02:52:20 +0000 | [diff] [blame] | 162 | off_t FAST_FUNC fdlength(int fd) |
Rob Landley | 5343747 | 2006-07-16 08:14:35 +0000 | [diff] [blame] | 163 | { |
| 164 | off_t bottom = 0, top = 0, pos; |
| 165 | long size; |
| 166 | |
Rob Landley | da9d1d0 | 2006-09-14 19:52:07 +0000 | [diff] [blame] | 167 | // If the ioctl works for this, return it. |
Rob Landley | 5343747 | 2006-07-16 08:14:35 +0000 | [diff] [blame] | 168 | |
| 169 | if (ioctl(fd, BLKGETSIZE, &size) >= 0) return size*512; |
| 170 | |
Denis Vlasenko | 621204b | 2006-10-27 09:03:24 +0000 | [diff] [blame] | 171 | // FIXME: explain why lseek(SEEK_END) is not used here! |
| 172 | |
Rob Landley | da9d1d0 | 2006-09-14 19:52:07 +0000 | [diff] [blame] | 173 | // If not, do a binary search for the last location we can read. (Some |
| 174 | // block devices don't do BLKGETSIZE right.) |
Rob Landley | 5343747 | 2006-07-16 08:14:35 +0000 | [diff] [blame] | 175 | |
| 176 | do { |
| 177 | char temp; |
| 178 | |
Denis Vlasenko | d25a264 | 2006-09-05 09:36:19 +0000 | [diff] [blame] | 179 | pos = bottom + (top - bottom) / 2; |
Rob Landley | 5343747 | 2006-07-16 08:14:35 +0000 | [diff] [blame] | 180 | |
Rob Landley | da9d1d0 | 2006-09-14 19:52:07 +0000 | [diff] [blame] | 181 | // If we can read from the current location, it's bigger. |
Rob Landley | 5343747 | 2006-07-16 08:14:35 +0000 | [diff] [blame] | 182 | |
Denis Vlasenko | ea62077 | 2006-10-14 02:23:43 +0000 | [diff] [blame] | 183 | if (lseek(fd, pos, SEEK_SET)>=0 && safe_read(fd, &temp, 1)==1) { |
Rob Landley | 5343747 | 2006-07-16 08:14:35 +0000 | [diff] [blame] | 184 | if (bottom == top) bottom = top = (top+1) * 2; |
| 185 | else bottom = pos; |
| 186 | |
Rob Landley | da9d1d0 | 2006-09-14 19:52:07 +0000 | [diff] [blame] | 187 | // If we can't, it's smaller. |
Rob Landley | 5343747 | 2006-07-16 08:14:35 +0000 | [diff] [blame] | 188 | |
| 189 | } else { |
| 190 | if (bottom == top) { |
| 191 | if (!top) return 0; |
| 192 | bottom = top/2; |
| 193 | } |
| 194 | else top = pos; |
| 195 | } |
| 196 | } while (bottom + 1 != top); |
| 197 | |
| 198 | return pos + 1; |
| 199 | } |
Denis Vlasenko | b5c60fc | 2008-01-27 23:41:34 +0000 | [diff] [blame] | 200 | #endif |
Rob Landley | d921b2e | 2006-08-03 15:41:12 +0000 | [diff] [blame] | 201 | |
Denis Vlasenko | 4e12b1a | 2008-12-23 23:36:47 +0000 | [diff] [blame] | 202 | char* FAST_FUNC xmalloc_ttyname(int fd) |
| 203 | { |
| 204 | char *buf = xzalloc(128); |
| 205 | int r = ttyname_r(fd, buf, 127); |
| 206 | if (r) { |
| 207 | free(buf); |
| 208 | buf = NULL; |
| 209 | } |
| 210 | return buf; |
| 211 | } |
| 212 | |
Denys Vlasenko | c175c46 | 2010-04-18 22:09:30 -0700 | [diff] [blame] | 213 | static int wh_helper(int value, int def_val, const char *env_name, int *err) |
| 214 | { |
| 215 | if (value == 0) { |
| 216 | char *s = getenv(env_name); |
| 217 | if (s) { |
| 218 | value = atoi(s); |
| 219 | /* If LINES/COLUMNS are set, pretent that there is |
| 220 | * no error getting w/h, this prevents some ugly |
| 221 | * cursor tricks by our callers */ |
| 222 | *err = 0; |
| 223 | } |
| 224 | } |
| 225 | if (value <= 1 || value >= 30000) |
| 226 | value = def_val; |
| 227 | return value; |
| 228 | } |
| 229 | |
Rob Landley | fbdf121 | 2006-09-20 22:06:01 +0000 | [diff] [blame] | 230 | /* It is perfectly ok to pass in a NULL for either width or for |
Denis Vlasenko | 621204b | 2006-10-27 09:03:24 +0000 | [diff] [blame] | 231 | * height, in which case that value will not be set. */ |
Denis Vlasenko | defc1ea | 2008-06-27 02:52:20 +0000 | [diff] [blame] | 232 | int FAST_FUNC get_terminal_width_height(int fd, unsigned *width, unsigned *height) |
Rob Landley | fbdf121 | 2006-09-20 22:06:01 +0000 | [diff] [blame] | 233 | { |
Denys Vlasenko | c175c46 | 2010-04-18 22:09:30 -0700 | [diff] [blame] | 234 | struct winsize win; |
| 235 | int err; |
Denis Vlasenko | 621204b | 2006-10-27 09:03:24 +0000 | [diff] [blame] | 236 | |
Denys Vlasenko | c175c46 | 2010-04-18 22:09:30 -0700 | [diff] [blame] | 237 | win.ws_row = 0; |
| 238 | win.ws_col = 0; |
| 239 | /* I've seen ioctl returning 0, but row/col is (still?) 0. |
| 240 | * We treat that as an error too. */ |
| 241 | err = ioctl(fd, TIOCGWINSZ, &win) != 0 || win.ws_row == 0; |
| 242 | if (height) |
| 243 | *height = wh_helper(win.ws_row, 24, "LINES", &err); |
| 244 | if (width) |
| 245 | *width = wh_helper(win.ws_col, 80, "COLUMNS", &err); |
| 246 | return err; |
Rob Landley | fbdf121 | 2006-09-20 22:06:01 +0000 | [diff] [blame] | 247 | } |
Denis Vlasenko | 202ac50 | 2008-11-05 13:20:58 +0000 | [diff] [blame] | 248 | |
| 249 | int FAST_FUNC tcsetattr_stdin_TCSANOW(const struct termios *tp) |
| 250 | { |
| 251 | return tcsetattr(STDIN_FILENO, TCSANOW, tp); |
| 252 | } |
Vladimir Dronnikov | db67a20 | 2009-10-15 09:24:25 +0200 | [diff] [blame] | 253 | |
| 254 | void FAST_FUNC generate_uuid(uint8_t *buf) |
| 255 | { |
| 256 | /* http://www.ietf.org/rfc/rfc4122.txt |
| 257 | * 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 |
| 258 | * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
| 259 | * | time_low | |
| 260 | * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
| 261 | * | time_mid | time_hi_and_version | |
| 262 | * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
| 263 | * |clk_seq_and_variant | node (0-1) | |
| 264 | * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
| 265 | * | node (2-5) | |
| 266 | * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
| 267 | * IOW, uuid has this layout: |
| 268 | * uint32_t time_low (big endian) |
| 269 | * uint16_t time_mid (big endian) |
| 270 | * uint16_t time_hi_and_version (big endian) |
| 271 | * version is a 4-bit field: |
| 272 | * 1 Time-based |
| 273 | * 2 DCE Security, with embedded POSIX UIDs |
| 274 | * 3 Name-based (MD5) |
| 275 | * 4 Randomly generated |
| 276 | * 5 Name-based (SHA-1) |
| 277 | * uint16_t clk_seq_and_variant (big endian) |
| 278 | * variant is a 3-bit field: |
| 279 | * 0xx Reserved, NCS backward compatibility |
| 280 | * 10x The variant specified in rfc4122 |
| 281 | * 110 Reserved, Microsoft backward compatibility |
| 282 | * 111 Reserved for future definition |
| 283 | * uint8_t node[6] |
| 284 | * |
| 285 | * For version 4, these bits are set/cleared: |
| 286 | * time_hi_and_version & 0x0fff | 0x4000 |
| 287 | * clk_seq_and_variant & 0x3fff | 0x8000 |
| 288 | */ |
| 289 | pid_t pid; |
| 290 | int i; |
| 291 | |
| 292 | i = open("/dev/urandom", O_RDONLY); |
| 293 | if (i >= 0) { |
| 294 | read(i, buf, 16); |
| 295 | close(i); |
| 296 | } |
| 297 | /* Paranoia. /dev/urandom may be missing. |
| 298 | * rand() is guaranteed to generate at least [0, 2^15) range, |
| 299 | * but lowest bits in some libc are not so "random". */ |
| 300 | srand(monotonic_us()); |
| 301 | pid = getpid(); |
| 302 | while (1) { |
| 303 | for (i = 0; i < 16; i++) |
| 304 | buf[i] ^= rand() >> 5; |
| 305 | if (pid == 0) |
| 306 | break; |
| 307 | srand(pid); |
| 308 | pid = 0; |
| 309 | } |
| 310 | |
| 311 | /* version = 4 */ |
| 312 | buf[4 + 2 ] = (buf[4 + 2 ] & 0x0f) | 0x40; |
| 313 | /* variant = 10x */ |
| 314 | buf[4 + 2 + 2] = (buf[4 + 2 + 2] & 0x3f) | 0x80; |
| 315 | } |