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 Denis Vlasenko 8 * 9 * Licensed under GPL version 2, see file LICENSE in this tarball for details. 10 */ 11 12#include "libbb.h" 13 14/* All the functions starting with "x" call bb_error_msg_and_die() if they 15 * fail, so callers never need to check for errors. If it returned, it 16 * succeeded. */ 17 18#ifndef DMALLOC 19/* dmalloc provides variants of these that do abort() on failure. 20 * Since dmalloc's prototypes overwrite the impls here as they are 21 * included after these prototypes in libbb.h, all is well. 22 */ 23// Warn if we can't allocate size bytes of memory. 24void *malloc_or_warn(size_t size) 25{ 26 void *ptr = malloc(size); 27 if (ptr == NULL && size != 0) 28 bb_error_msg(bb_msg_memory_exhausted); 29 return ptr; 30} 31 32// Die if we can't allocate size bytes of memory. 33void *xmalloc(size_t size) 34{ 35 void *ptr = malloc(size); 36 if (ptr == NULL && size != 0) 37 bb_error_msg_and_die(bb_msg_memory_exhausted); 38 return ptr; 39} 40 41// Die if we can't resize previously allocated memory. (This returns a pointer 42// to the new memory, which may or may not be the same as the old memory. 43// It'll copy the contents to a new chunk and free the old one if necessary.) 44void *xrealloc(void *ptr, size_t size) 45{ 46 ptr = realloc(ptr, size); 47 if (ptr == NULL && size != 0) 48 bb_error_msg_and_die(bb_msg_memory_exhausted); 49 return ptr; 50} 51#endif /* DMALLOC */ 52 53// Die if we can't allocate and zero size bytes of memory. 54void *xzalloc(size_t size) 55{ 56 void *ptr = xmalloc(size); 57 memset(ptr, 0, size); 58 return ptr; 59} 60 61// Die if we can't copy a string to freshly allocated memory. 62char * xstrdup(const char *s) 63{ 64 char *t; 65 66 if (s == NULL) 67 return NULL; 68 69 t = strdup(s); 70 71 if (t == NULL) 72 bb_error_msg_and_die(bb_msg_memory_exhausted); 73 74 return t; 75} 76 77// Die if we can't allocate n+1 bytes (space for the null terminator) and copy 78// the (possibly truncated to length n) string into it. 79char * xstrndup(const char *s, int n) 80{ 81 int m; 82 char *t; 83 84 if (ENABLE_DEBUG && s == NULL) 85 bb_error_msg_and_die("xstrndup bug"); 86 87 /* We can just xmalloc(n+1) and strncpy into it, */ 88 /* but think about xstrndup("abc", 10000) wastage! */ 89 m = n; 90 t = (char*) s; 91 while (m) { 92 if (!*t) break; 93 m--; 94 t++; 95 } 96 n -= m; 97 t = xmalloc(n + 1); 98 t[n] = '\0'; 99 100 return memcpy(t, s, n); 101} 102 103// Die if we can't open a file and return a FILE * to it. 104// Notice we haven't got xfread(), This is for use with fscanf() and friends. 105FILE *xfopen(const char *path, const char *mode) 106{ 107 FILE *fp = fopen(path, mode); 108 if (fp == NULL) 109 bb_perror_msg_and_die("can't open '%s'", path); 110 return fp; 111} 112 113// Die if we can't open a file and return a fd. 114int xopen3(const char *pathname, int flags, int mode) 115{ 116 int ret; 117 118 ret = open(pathname, flags, mode); 119 if (ret < 0) { 120 bb_perror_msg_and_die("can't open '%s'", pathname); 121 } 122 return ret; 123} 124 125// Die if we can't open an existing file and return a fd. 126int xopen(const char *pathname, int flags) 127{ 128 return xopen3(pathname, flags, 0666); 129} 130 131// Warn if we can't open a file and return a fd. 132int open3_or_warn(const char *pathname, int flags, int mode) 133{ 134 int ret; 135 136 ret = open(pathname, flags, mode); 137 if (ret < 0) { 138 bb_perror_msg("can't open '%s'", pathname); 139 } 140 return ret; 141} 142 143// Warn if we can't open a file and return a fd. 144int open_or_warn(const char *pathname, int flags) 145{ 146 return open3_or_warn(pathname, flags, 0666); 147} 148 149void xpipe(int filedes[2]) 150{ 151 if (pipe(filedes)) 152 bb_perror_msg_and_die("can't create pipe"); 153} 154 155void xunlink(const char *pathname) 156{ 157 if (unlink(pathname)) 158 bb_perror_msg_and_die("can't remove file '%s'", pathname); 159} 160 161// Turn on nonblocking I/O on a fd 162int ndelay_on(int fd) 163{ 164 return fcntl(fd, F_SETFL, fcntl(fd,F_GETFL) | O_NONBLOCK); 165} 166 167int ndelay_off(int fd) 168{ 169 return fcntl(fd, F_SETFL, fcntl(fd,F_GETFL) & ~O_NONBLOCK); 170} 171 172void xdup2(int from, int to) 173{ 174 if (dup2(from, to) != to) 175 bb_perror_msg_and_die("can't duplicate file descriptor"); 176} 177 178// "Renumber" opened fd 179void xmove_fd(int from, int to) 180{ 181 if (from == to) 182 return; 183 xdup2(from, to); 184 close(from); 185} 186 187// Die with an error message if we can't write the entire buffer. 188void xwrite(int fd, const void *buf, size_t count) 189{ 190 if (count) { 191 ssize_t size = full_write(fd, buf, count); 192 if (size != count) 193 bb_error_msg_and_die("short write"); 194 } 195} 196 197// Die with an error message if we can't lseek to the right spot. 198off_t xlseek(int fd, off_t offset, int whence) 199{ 200 off_t off = lseek(fd, offset, whence); 201 if (off == (off_t)-1) { 202 if (whence == SEEK_SET) 203 bb_perror_msg_and_die("lseek(%"OFF_FMT"u)", offset); 204 bb_perror_msg_and_die("lseek"); 205 } 206 return off; 207} 208 209// Die with supplied filename if this FILE * has ferror set. 210void die_if_ferror(FILE *fp, const char *fn) 211{ 212 if (ferror(fp)) { 213 /* ferror doesn't set useful errno */ 214 bb_error_msg_and_die("%s: I/O error", fn); 215 } 216} 217 218// Die with an error message if stdout has ferror set. 219void die_if_ferror_stdout(void) 220{ 221 die_if_ferror(stdout, bb_msg_standard_output); 222} 223 224// Die with an error message if we have trouble flushing stdout. 225void xfflush_stdout(void) 226{ 227 if (fflush(stdout)) { 228 bb_perror_msg_and_die(bb_msg_standard_output); 229 } 230} 231 232void sig_block(int sig) 233{ 234 sigset_t ss; 235 sigemptyset(&ss); 236 sigaddset(&ss, sig); 237 sigprocmask(SIG_BLOCK, &ss, NULL); 238} 239 240void sig_unblock(int sig) 241{ 242 sigset_t ss; 243 sigemptyset(&ss); 244 sigaddset(&ss, sig); 245 sigprocmask(SIG_UNBLOCK, &ss, NULL); 246} 247 248 249void sig_catch(int sig, void (*f)(int)) 250{ 251 struct sigaction sa; 252 sa.sa_handler = f; 253 sa.sa_flags = 0; 254 sigemptyset(&sa.sa_mask); 255 sigaction(sig, &sa, NULL); 256} 257 258void sig_pause(void) 259{ 260 sigset_t ss; 261 sigemptyset(&ss); 262 sigsuspend(&ss); 263} 264 265 266void xsetenv(const char *key, const char *value) 267{ 268 if (setenv(key, value, 1)) 269 bb_error_msg_and_die(bb_msg_memory_exhausted); 270} 271 272// Converts unsigned long long value into compact 4-char 273// representation. Examples: "1234", "1.2k", " 27M", "123T" 274// Fifth char is always '\0' 275void smart_ulltoa5(unsigned long long ul, char buf[5]) 276{ 277 const char *fmt; 278 char c; 279 unsigned v,idx = 0; 280 ul *= 10; 281 if (ul > 9999*10) { // do not scale if 9999 or less 282 while (ul >= 10000) { 283 ul /= 1024; 284 idx++; 285 } 286 } 287 v = ul; // ullong divisions are expensive, avoid them 288 289 fmt = " 123456789"; 290 if (!idx) { // 9999 or less: use 1234 format 291 c = buf[0] = " 123456789"[v/10000]; 292 if (c != ' ') fmt = "0123456789"; 293 c = buf[1] = fmt[v/1000%10]; 294 if (c != ' ') fmt = "0123456789"; 295 buf[2] = fmt[v/100%10]; 296 buf[3] = "0123456789"[v/10%10]; 297 } else { 298 if (v >= 10*10) { // scaled value is >=10: use 123M format 299 c = buf[0] = " 123456789"[v/1000]; 300 if (c != ' ') fmt = "0123456789"; 301 buf[1] = fmt[v/100%10]; 302 buf[2] = "0123456789"[v/10%10]; 303 } else { // scaled value is <10: use 1.2M format 304 buf[0] = "0123456789"[v/10]; 305 buf[1] = '.'; 306 buf[2] = "0123456789"[v%10]; 307 } 308 // see http://en.wikipedia.org/wiki/Tera 309 buf[3] = " kMGTPEZY"[idx]; 310 } 311 buf[4] = '\0'; 312} 313 314// Convert unsigned integer to ascii, writing into supplied buffer. 315// A truncated result contains the first few digits of the result ala strncpy. 316// Returns a pointer past last generated digit, does _not_ store NUL. 317void BUG_sizeof_unsigned_not_4(void); 318char *utoa_to_buf(unsigned n, char *buf, unsigned buflen) 319{ 320 unsigned i, out, res; 321 if (sizeof(unsigned) != 4) 322 BUG_sizeof_unsigned_not_4(); 323 if (buflen) { 324 out = 0; 325 for (i = 1000000000; i; i /= 10) { 326 res = n / i; 327 if (res || out || i == 1) { 328 if (!--buflen) break; 329 out++; 330 n -= res*i; 331 *buf++ = '0' + res; 332 } 333 } 334 } 335 return buf; 336} 337 338// Convert signed integer to ascii, like utoa_to_buf() 339char *itoa_to_buf(int n, char *buf, unsigned buflen) 340{ 341 if (buflen && n<0) { 342 n = -n; 343 *buf++ = '-'; 344 buflen--; 345 } 346 return utoa_to_buf((unsigned)n, buf, buflen); 347} 348 349// The following two functions use a static buffer, so calling either one a 350// second time will overwrite previous results. 351// 352// The largest 32 bit integer is -2 billion plus null terminator, or 12 bytes. 353// Int should always be 32 bits on any remotely Unix-like system, see 354// http://www.unix.org/whitepapers/64bit.html for the reasons why. 355 356static char local_buf[12]; 357 358// Convert unsigned integer to ascii using a static buffer (returned). 359char *utoa(unsigned n) 360{ 361 *(utoa_to_buf(n, local_buf, sizeof(local_buf))) = '\0'; 362 363 return local_buf; 364} 365 366// Convert signed integer to ascii using a static buffer (returned). 367char *itoa(int n) 368{ 369 *(itoa_to_buf(n, local_buf, sizeof(local_buf))) = '\0'; 370 371 return local_buf; 372} 373 374// Emit a string of hex representation of bytes 375char *bin2hex(char *p, const char *cp, int count) 376{ 377 while (count) { 378 unsigned char c = *cp++; 379 /* put lowercase hex digits */ 380 *p++ = 0x20 | bb_hexdigits_upcase[c >> 4]; 381 *p++ = 0x20 | bb_hexdigits_upcase[c & 0xf]; 382 count--; 383 } 384 return p; 385} 386 387// Die with an error message if we can't set gid. (Because resource limits may 388// limit this user to a given number of processes, and if that fills up the 389// setgid() will fail and we'll _still_be_root_, which is bad.) 390void xsetgid(gid_t gid) 391{ 392 if (setgid(gid)) bb_perror_msg_and_die("setgid"); 393} 394 395// Die with an error message if we can't set uid. (See xsetgid() for why.) 396void xsetuid(uid_t uid) 397{ 398 if (setuid(uid)) bb_perror_msg_and_die("setuid"); 399} 400 401// Return how long the file at fd is, if there's any way to determine it. 402off_t fdlength(int fd) 403{ 404 off_t bottom = 0, top = 0, pos; 405 long size; 406 407 // If the ioctl works for this, return it. 408 409 if (ioctl(fd, BLKGETSIZE, &size) >= 0) return size*512; 410 411 412 // If not, do a binary search for the last location we can read. (Some 413 // block devices don't do BLKGETSIZE right.) 414 415 do { 416 char temp; 417 418 pos = bottom + (top - bottom) / 2; 419 420 // If we can read from the current location, it's bigger. 421 422 if (lseek(fd, pos, SEEK_SET)>=0 && safe_read(fd, &temp, 1)==1) { 423 if (bottom == top) bottom = top = (top+1) * 2; 424 else bottom = pos; 425 426 // If we can't, it's smaller. 427 428 } else { 429 if (bottom == top) { 430 if (!top) return 0; 431 bottom = top/2; 432 } 433 else top = pos; 434 } 435 } while (bottom + 1 != top); 436 437 return pos + 1; 438} 439 440// Die with an error message if we can't malloc() enough space and do an 441// sprintf() into that space. 442char *xasprintf(const char *format, ...) 443{ 444 va_list p; 445 int r; 446 char *string_ptr; 447 448 // GNU extension 449 va_start(p, format); 450 r = vasprintf(&string_ptr, format, p); 451 va_end(p); 452 453 if (r < 0) bb_error_msg_and_die(bb_msg_memory_exhausted); 454 return string_ptr; 455} 456 457 458// Die with an error message if we can't copy an entire FILE * to stdout, then 459// close that file. 460void xprint_and_close_file(FILE *file) 461{ 462 fflush(stdout); 463 // copyfd outputs error messages for us. 464 if (bb_copyfd_eof(fileno(file), 1) == -1) 465 xfunc_die(); 466 467 fclose(file); 468} 469 470// Die if we can't chdir to a new path. 471void xchdir(const char *path) 472{ 473 if (chdir(path)) 474 bb_perror_msg_and_die("chdir(%s)", path); 475} 476 477// Print a warning message if opendir() fails, but don't die. 478DIR *warn_opendir(const char *path) 479{ 480 DIR *dp; 481 482 dp = opendir(path); 483 if (!dp) 484 bb_perror_msg("can't open '%s'", path); 485 return dp; 486} 487 488// Die with an error message if opendir() fails. 489DIR *xopendir(const char *path) 490{ 491 DIR *dp; 492 493 dp = opendir(path); 494 if (!dp) 495 bb_perror_msg_and_die("can't open '%s'", path); 496 return dp; 497} 498 499// Die with an error message if we can't open a new socket. 500int xsocket(int domain, int type, int protocol) 501{ 502 int r = socket(domain, type, protocol); 503 504 if (r < 0) { 505 /* Hijack vaguely related config option */ 506#if ENABLE_VERBOSE_RESOLUTION_ERRORS 507 const char *s = "INET"; 508 if (domain == AF_PACKET) s = "PACKET"; 509 if (domain == AF_NETLINK) s = "NETLINK"; 510USE_FEATURE_IPV6(if (domain == AF_INET6) s = "INET6";) 511 bb_perror_msg_and_die("socket(AF_%s)", s); 512#else 513 bb_perror_msg_and_die("socket"); 514#endif 515 } 516 517 return r; 518} 519 520// Die with an error message if we can't bind a socket to an address. 521void xbind(int sockfd, struct sockaddr *my_addr, socklen_t addrlen) 522{ 523 if (bind(sockfd, my_addr, addrlen)) bb_perror_msg_and_die("bind"); 524} 525 526// Die with an error message if we can't listen for connections on a socket. 527void xlisten(int s, int backlog) 528{ 529 if (listen(s, backlog)) bb_perror_msg_and_die("listen"); 530} 531 532/* Die with an error message if sendto failed. 533 * Return bytes sent otherwise */ 534ssize_t xsendto(int s, const void *buf, size_t len, const struct sockaddr *to, 535 socklen_t tolen) 536{ 537 ssize_t ret = sendto(s, buf, len, 0, to, tolen); 538 if (ret < 0) { 539 if (ENABLE_FEATURE_CLEAN_UP) 540 close(s); 541 bb_perror_msg_and_die("sendto"); 542 } 543 return ret; 544} 545 546// xstat() - a stat() which dies on failure with meaningful error message 547void xstat(const char *name, struct stat *stat_buf) 548{ 549 if (stat(name, stat_buf)) 550 bb_perror_msg_and_die("can't stat '%s'", name); 551} 552 553// selinux_or_die() - die if SELinux is disabled. 554void selinux_or_die(void) 555{ 556#if ENABLE_SELINUX 557 int rc = is_selinux_enabled(); 558 if (rc == 0) { 559 bb_error_msg_and_die("SELinux is disabled"); 560 } else if (rc < 0) { 561 bb_error_msg_and_die("is_selinux_enabled() failed"); 562 } 563#else 564 bb_error_msg_and_die("SELinux support is disabled"); 565#endif 566} 567 568/* It is perfectly ok to pass in a NULL for either width or for 569 * height, in which case that value will not be set. */ 570int get_terminal_width_height(int fd, int *width, int *height) 571{ 572 struct winsize win = { 0, 0, 0, 0 }; 573 int ret = ioctl(fd, TIOCGWINSZ, &win); 574 575 if (height) { 576 if (!win.ws_row) { 577 char *s = getenv("LINES"); 578 if (s) win.ws_row = atoi(s); 579 } 580 if (win.ws_row <= 1 || win.ws_row >= 30000) 581 win.ws_row = 24; 582 *height = (int) win.ws_row; 583 } 584 585 if (width) { 586 if (!win.ws_col) { 587 char *s = getenv("COLUMNS"); 588 if (s) win.ws_col = atoi(s); 589 } 590 if (win.ws_col <= 1 || win.ws_col >= 30000) 591 win.ws_col = 80; 592 *width = (int) win.ws_col; 593 } 594 595 return ret; 596} 597 598void ioctl_or_perror_and_die(int fd, int request, void *argp, const char *fmt,...) 599{ 600 va_list p; 601 602 if (ioctl(fd, request, argp) < 0) { 603 va_start(p, fmt); 604 bb_verror_msg(fmt, p, strerror(errno)); 605 /* xfunc_die can actually longjmp, so be nice */ 606 va_end(p); 607 xfunc_die(); 608 } 609} 610 611int ioctl_or_perror(int fd, int request, void *argp, const char *fmt,...) 612{ 613 va_list p; 614 int ret = ioctl(fd, request, argp); 615 616 if (ret < 0) { 617 va_start(p, fmt); 618 bb_verror_msg(fmt, p, strerror(errno)); 619 va_end(p); 620 } 621 return ret; 622} 623 624#if ENABLE_IOCTL_HEX2STR_ERROR 625int bb_ioctl_or_warn(int fd, int request, void *argp, const char *ioctl_name) 626{ 627 int ret; 628 629 ret = ioctl(fd, request, argp); 630 if (ret < 0) 631 bb_perror_msg("%s", ioctl_name); 632 return ret; 633} 634void bb_xioctl(int fd, int request, void *argp, const char *ioctl_name) 635{ 636 if (ioctl(fd, request, argp) < 0) 637 bb_perror_msg_and_die("%s", ioctl_name); 638} 639#else 640int bb_ioctl_or_warn(int fd, int request, void *argp) 641{ 642 int ret; 643 644 ret = ioctl(fd, request, argp); 645 if (ret < 0) 646 bb_perror_msg("ioctl %#x failed", request); 647 return ret; 648} 649void bb_xioctl(int fd, int request, void *argp) 650{ 651 if (ioctl(fd, request, argp) < 0) 652 bb_perror_msg_and_die("ioctl %#x failed", request); 653} 654#endif 655