Most people should answer N.
+config WARN_SIMPLE_MSG
+ bool "Warn about single parameter bb_xx_msg calls"
+ default n
+ help
+ This will cause warnings to be shown for any instances of
+ bb_error_msg(), bb_error_msg_and_die(), bb_perror_msg(),
+ bb_perror_msg_and_die(), bb_herror_msg() or bb_herror_msg_and_die()
+ being called with a single parameter. In these cases the equivalent
+ bb_simple_xx_msg function should be used instead.
+ Note that use of STRERROR_FMT may give false positives.
+
+ If you aren't developing busybox, say N here.
+
choice
prompt "Additional debugging library"
default NO_DEBUG_LIB
/* Check that the input is sane */
if (!(option_mask32 & BBUNPK_OPT_FORCE) && isatty(STDIN_FILENO)) {
- bb_error_msg_and_die("compressed data not read from terminal, "
+ bb_simple_error_msg_and_die("compressed data not read from terminal, "
"use -f to force it");
}
if (n2 != n) {
if (n2 >= 0)
errno = 0; /* prevent bogus error message */
- bb_perror_msg(n2 >= 0 ? "short write" : bb_msg_write_error);
+ bb_simple_perror_msg(n2 >= 0 ? "short write" : bb_msg_write_error);
return -1;
}
}
while (1) {
count = full_read(STDIN_FILENO, rbuf, IOBUF_SIZE);
if (count < 0) {
- bb_perror_msg(bb_msg_read_error);
+ bb_simple_perror_msg(bb_msg_read_error);
total = -1;
break;
}
} else if (strncmp(version, ">=", offset_ch) == 0) {
edge->operator = VER_MORE_EQUAL;
} else {
- bb_error_msg_and_die("illegal operator");
+ bb_simple_error_msg_and_die("illegal operator");
}
}
/* skip to start of version numbers */
status = new_value_num;
break;
default:
- bb_error_msg_and_die("DEBUG ONLY: this shouldnt happen");
+ bb_simple_error_msg_and_die("DEBUG ONLY: this shouldnt happen");
}
new_status = xasprintf("%s %s %s", name_hashtable[want], name_hashtable[flag], name_hashtable[status]);
/* Create a separate backfile to dpkg */
if (rename("/var/lib/dpkg/status", "/var/lib/dpkg/status.udeb.bak") == -1) {
if (errno != ENOENT)
- bb_error_msg_and_die("can't create backup status file");
+ bb_simple_error_msg_and_die("can't create backup status file");
/* Its ok if renaming the status file fails because status
* file doesn't exist, maybe we are starting from scratch */
- bb_error_msg("no status file found, creating new one");
+ bb_simple_error_msg("no status file found, creating new one");
}
xrename("/var/lib/dpkg/status.udeb", "/var/lib/dpkg/status");
init_archive_deb_control(archive_handle);
deb_file[deb_count]->control_file = deb_extract_control_file_to_buffer(archive_handle, control_list);
if (deb_file[deb_count]->control_file == NULL) {
- bb_error_msg_and_die("can't extract control file");
+ bb_simple_error_msg_and_die("can't extract control file");
}
deb_file[deb_count]->filename = xstrdup(argv[0]);
package_num = fill_package_struct(deb_file[deb_count]->control_file);
argv++;
}
if (!deb_count)
- bb_error_msg_and_die("no package files specified");
+ bb_simple_error_msg_and_die("no package files specified");
deb_file[deb_count] = NULL;
/* Check that the deb file arguments are installable */
if (!(opt & OPT_force_ignore_depends)) {
if (!check_deps(deb_file, 0 /*, deb_count*/)) {
- bb_error_msg_and_die("dependency check failed");
+ bb_simple_error_msg_and_die("dependency check failed");
}
}
/* Diagnostic functions */
#ifdef DEBUG
static int verbose;
-# define Assert(cond,msg) { if (!(cond)) bb_error_msg(msg); }
+# define Assert(cond,msg) { if (!(cond)) bb_simple_error_msg(msg); }
# define Trace(x) fprintf x
# define Tracev(x) {if (verbose) fprintf x; }
# define Tracevv(x) {if (verbose > 1) fprintf x; }
/* check that the match is indeed a match */
if (memcmp(G1.window + match, G1.window + start, length) != 0) {
bb_error_msg(" start %d, match %d, length %d", start, match, length);
- bb_error_msg("invalid match");
+ bb_simple_error_msg("invalid match");
}
if (verbose > 1) {
bb_error_msg("\\[%d,%d]", start - match, length);
struct stat existing_sb;
if (lstat(dst_name, &existing_sb) == -1) {
if (errno != ENOENT) {
- bb_perror_msg_and_die("can't stat old file");
+ bb_simple_perror_msg_and_die("can't stat old file");
}
}
else if (existing_sb.st_mtime >= file_header->mtime) {
}
break;
default:
- bb_error_msg_and_die("unrecognized file type");
+ bb_simple_error_msg_and_die("unrecognized file type");
}
if (!S_ISLNK(file_header->mode)) {
break;
}
if (bd->headerCRC != bd->totalCRC) {
- bb_error_msg("CRC error");
+ bb_simple_error_msg("CRC error");
break;
}
error_msg = "corrupted data";
if (setjmp(error_jmp)) {
/* Error from deep inside zip machinery */
- bb_error_msg(error_msg);
+ bb_simple_error_msg(error_msg);
n = -1;
goto ret;
}
bytebuffer_offset = 0;
bytebuffer_size = full_read(gunzip_src_fd, &bytebuffer[count], bytebuffer_max - count);
if ((int)bytebuffer_size < 0) {
- bb_error_msg(bb_msg_read_error);
+ bb_simple_error_msg(bb_msg_read_error);
return 0;
}
bytebuffer_size += count;
if (full_read(xstate->src_fd, &magic2, 2) != 2) {
bad_magic:
- bb_error_msg("invalid magic");
+ bb_simple_error_msg("invalid magic");
return -1;
}
if (magic2 == COMPRESS_MAGIC) {
again:
if (!check_header_gzip(PASS_STATE xstate)) {
- bb_error_msg("corrupted data");
+ bb_simple_error_msg("corrupted data");
total = -1;
goto ret;
}
total += n;
if (!top_up(PASS_STATE 8)) {
- bb_error_msg("corrupted data");
+ bb_simple_error_msg("corrupted data");
total = -1;
goto ret;
}
/* Validate decompression - crc */
v32 = buffer_read_le_u32(PASS_STATE_ONLY);
if ((~gunzip_crc) != v32) {
- bb_error_msg("crc error");
+ bb_simple_error_msg("crc error");
total = -1;
goto ret;
}
/* Validate decompression - size */
v32 = buffer_read_le_u32(PASS_STATE_ONLY);
if ((uint32_t)gunzip_bytes_out != v32) {
- bb_error_msg("incorrect length");
+ bb_simple_error_msg("incorrect length");
total = -1;
}
/* xread isn't good here, we have to return - caller may want
* to do some cleanup (e.g. delete incomplete unpacked file etc) */
if (full_read(xstate->src_fd, inbuf, 1) != 1) {
- bb_error_msg("short read");
+ bb_simple_error_msg("short read");
goto err;
}
if (insize < (int) (IBUFSIZ + 64) - IBUFSIZ) {
rsize = safe_read(xstate->src_fd, inbuf + insize, IBUFSIZ);
if (rsize < 0)
- bb_error_msg_and_die(bb_msg_read_error);
+ bb_simple_error_msg_and_die(bb_msg_read_error);
insize += rsize;
}
if (oldcode == -1) {
if (code >= 256)
- bb_error_msg_and_die("corrupted data"); /* %ld", code); */
+ bb_simple_error_msg_and_die("corrupted data"); /* %ld", code); */
oldcode = code;
finchar = (int) oldcode;
outbuf[outpos++] = (unsigned char) finchar;
insize, posbits, p[-1], p[0], p[1], p[2], p[3],
(posbits & 07));
*/
- bb_error_msg("corrupted data");
+ bb_simple_error_msg("corrupted data");
goto err;
}
/* Generate output characters in reverse order */
while (code >= 256) {
if (stackp <= &htabof(0))
- bb_error_msg_and_die("corrupted data");
+ bb_simple_error_msg_and_die("corrupted data");
*--stackp = tab_suffixof(code);
code = tab_prefixof(code);
}
//TODO: return -1 instead
//This will make unlzma delete broken unpacked file on unpack errors
if (buffer_size <= 0)
- bb_error_msg_and_die("unexpected EOF");
+ bb_simple_error_msg_and_die("unexpected EOF");
rc->buffer_end = RC_BUFFER + buffer_size;
rc->ptr = RC_BUFFER;
}
if (full_read(xstate->src_fd, &header, sizeof(header)) != sizeof(header)
|| header.pos >= (9 * 5 * 5)
) {
- bb_error_msg("bad lzma header");
+ bb_simple_error_msg("bad lzma header");
return -1;
}
* potentially more detailed information).
* Do not fail silently.
*/
- bb_error_msg("corrupted data");
+ bb_simple_error_msg("corrupted data");
total_written = -1; /* failure */
}
rc_free(rc);
if (iobuf.in_pos == iobuf.in_size) {
int rd = safe_read(xstate->src_fd, membuf, BUFSIZ);
if (rd < 0) {
- bb_error_msg(bb_msg_read_error);
+ bb_simple_error_msg(bb_msg_read_error);
total = -1;
break;
}
continue;
}
if (xz_result != XZ_OK && xz_result != XZ_UNSUPPORTED_CHECK) {
- bb_error_msg("corrupted data");
+ bb_simple_error_msg("corrupted data");
total = -1;
break;
}
* on misformatted numbers bb_strtou returns all-ones */
err = bb_strtou(str, NULL, base);
if (err == -1)
- bb_error_msg_and_die("invalid ar header");
+ bb_simple_error_msg_and_die("invalid ar header");
return err;
}
archive_handle->offset += 60;
if (ar.formatted.magic[0] != '`' || ar.formatted.magic[1] != '\n')
- bb_error_msg_and_die("invalid ar header");
+ bb_simple_error_msg_and_die("invalid ar header");
/*
* Note that the fields MUST be read in reverse order as
return get_header_ar(archive_handle);
}
#else
- bb_error_msg_and_die("long filenames not supported");
+ bb_simple_error_msg_and_die("long filenames not supported");
#endif
}
/* Only size is always present, the rest may be missing in
long_offset = read_num(&ar.formatted.name[1], 10,
sizeof(ar.formatted.name) - 1);
if (long_offset >= archive_handle->ar__long_name_size) {
- bb_error_msg_and_die("can't resolve long filename");
+ bb_simple_error_msg_and_die("can't resolve long filename");
}
typed->name = xstrdup(archive_handle->ar__long_names + long_offset);
} else
goto create_hardlinks;
}
if (size != 110) {
- bb_error_msg_and_die("short read");
+ bb_simple_error_msg_and_die("short read");
}
archive_handle->offset += 110;
if (!is_prefixed_with(&cpio_header[0], "07070")
|| (cpio_header[5] != '1' && cpio_header[5] != '2')
) {
- bb_error_msg_and_die("unsupported cpio format, use newc or crc");
+ bb_simple_error_msg_and_die("unsupported cpio format, use newc or crc");
}
if (sscanf(cpio_header + 6,
&inode, &mode, &uid, &gid,
&nlink, &mtime, &size,
&major, &minor, &namesize) != 10)
- bb_error_msg_and_die("damaged cpio file");
+ bb_simple_error_msg_and_die("damaged cpio file");
file_header->mode = mode;
/* "cpio -R USER:GRP" support: */
if (archive_handle->cpio__owner.uid != (uid_t)-1L)
if (*end != '\0' && *end != ' ') {
int8_t first = str[0];
if (!(first & 0x80))
- bb_error_msg_and_die("corrupted octal value in tar header");
+ bb_simple_error_msg_and_die("corrupted octal value in tar header");
/*
* GNU tar uses "base-256 encoding" for very large numbers.
* Encoding is binary, with highest bit always set as a marker
|| errno != EINVAL
|| *end != ' '
) {
- bb_error_msg("malformed extended header, skipped");
+ bb_simple_error_msg("malformed extended header, skipped");
// More verbose version:
//bb_error_msg("malformed extended header at %"OFF_FMT"d, skipped",
// archive_handle->offset - (sz + len));
* the very first read fails. Grrr.
*/
if (archive_handle->offset == 0)
- bb_error_msg("short read");
+ bb_simple_error_msg("short read");
/* this merely signals end of archive, not exit(1): */
return EXIT_FAILURE;
}
if (i != 512) {
IF_FEATURE_TAR_AUTODETECT(goto autodetect;)
- bb_error_msg_and_die("short read");
+ bb_simple_error_msg_and_die("short read");
}
#else
goto err;
if (setup_unzip_on_fd(archive_handle->src_fd, /*fail_if_not_compressed:*/ 0) != 0)
err:
- bb_error_msg_and_die("invalid tar magic");
+ bb_simple_error_msg_and_die("invalid tar magic");
archive_handle->offset = 0;
goto again_after_align;
#endif
- bb_error_msg_and_die("invalid tar magic");
+ bb_simple_error_msg_and_die("invalid tar magic");
}
/* Do checksum on headers.
if (sum_u != sum
IF_FEATURE_TAR_OLDSUN_COMPATIBILITY(&& sum_s != sum)
) {
- bb_error_msg_and_die("invalid tar header checksum");
+ bb_simple_error_msg_and_die("invalid tar header checksum");
}
/* GET_OCTAL trashes subsequent field, therefore we call it
if (!xstate->signature_skipped) {
uint16_t magic2;
if (full_read(xstate->src_fd, &magic2, 2) != 2 || magic2 != magic16) {
- bb_error_msg("invalid magic");
+ bb_simple_error_msg("invalid magic");
return -1;
}
xstate->signature_skipped = 2;
} else {
nwrote = full_write(xstate->dst_fd, buf, bufsize);
if (nwrote != (ssize_t)bufsize) {
- bb_perror_msg("write");
+ bb_simple_perror_msg("write");
nwrote = -1;
goto ret;
}
/* No known magic seen */
if (fail_if_not_compressed)
- bb_error_msg_and_die("no gzip"
+ bb_simple_error_msg_and_die("no gzip"
IF_FEATURE_SEAMLESS_BZ2("/bzip2")
IF_FEATURE_SEAMLESS_XZ("/xz")
" magic");
if (errno == ESPIPE)
seek_by_read(fd, amount);
else
- bb_perror_msg_and_die("seek failure");
+ bb_simple_perror_msg_and_die("seek failure");
}
}
xread(ar_archive->src_fd, magic, AR_MAGIC_LEN);
if (!is_prefixed_with(magic, AR_MAGIC)) {
- bb_error_msg_and_die("invalid ar magic");
+ bb_simple_error_msg_and_die("invalid ar magic");
}
ar_archive->offset += AR_MAGIC_LEN;
*/
uint32_t c = fn(init, buf, len);
if (c != ref)
- bb_error_msg_and_die("checksum error");
+ bb_simple_error_msg_and_die("checksum error");
}
/**********************************************************************/
/* error if split file */
if (dst_len == 0xffffffffL)
/* should not happen - not yet implemented */
- bb_error_msg_and_die("this file is a split lzop file");
+ bb_simple_error_msg_and_die("this file is a split lzop file");
if (dst_len > MAX_BLOCK_SIZE)
- bb_error_msg_and_die("corrupted data");
+ bb_simple_error_msg_and_die("corrupted data");
/* read compressed block size */
src_len = read32();
if (src_len <= 0 || src_len > dst_len)
- bb_error_msg_and_die("corrupted data");
+ bb_simple_error_msg_and_die("corrupted data");
if (dst_len > block_size) {
if (b2) {
r = lzo1x_decompress_safe(b1, src_len, b2, &d /*, NULL*/);
if (r != 0 /*LZO_E_OK*/ || dst_len != d) {
- bb_error_msg_and_die("corrupted data");
+ bb_simple_error_msg_and_die("corrupted data");
}
dst = b2;
} else {
unsigned char magic[sizeof(lzop_magic)];
xread(0, magic, sizeof(magic));
if (memcmp(magic, lzop_magic, sizeof(lzop_magic)) != 0)
- bb_error_msg_and_die("bad magic number");
+ bb_simple_error_msg_and_die("bad magic number");
}
/**********************************************************************/
else if (option_mask32 & OPT_8)
level = 8;
#else
- bb_error_msg_and_die("high compression not compiled in");
+ bb_simple_error_msg_and_die("high compression not compiled in");
#endif
}
}
if (bb_copyfd_eof(rpm_fd, STDOUT_FILENO) < 0)
- bb_error_msg_and_die("error unpacking");
+ bb_simple_error_msg_and_die("error unpacking");
if (ENABLE_FEATURE_CLEAN_UP) {
close(rpm_fd);
/* If it is larger than 100 bytes, bail out */
if (header.linkname[sizeof(header.linkname)-1]) {
free(lpath);
- bb_error_msg("names longer than "NAME_SIZE_STR" chars not supported");
+ bb_simple_error_msg("names longer than "NAME_SIZE_STR" chars not supported");
return FALSE;
}
# endif
# if !ENABLE_FEATURE_TAR_GNU_EXTENSIONS
if (strlen(header_name) >= NAME_SIZE) {
- bb_error_msg("names longer than "NAME_SIZE_STR" chars not supported");
+ bb_simple_error_msg("names longer than "NAME_SIZE_STR" chars not supported");
return TRUE;
}
# endif
freeHardLinkInfo(&tbInfo->hlInfoHead);
if (errorFlag)
- bb_error_msg("error exit delayed from previous errors");
+ bb_simple_error_msg("error exit delayed from previous errors");
# if SEAMLESS_COMPRESSION
if (gzip) {
int status;
if (safe_waitpid(-1, &status, 0) == -1)
- bb_perror_msg("waitpid");
+ bb_simple_perror_msg("waitpid");
else if (!WIFEXITED(status) || WEXITSTATUS(status))
/* gzip was killed or has exited with nonzero! */
errorFlag = TRUE;
if (opt & OPT_CREATE) {
/* Make sure there is at least one file to tar up */
if (tar_handle->accept == NULL)
- bb_error_msg_and_die("empty archive");
+ bb_simple_error_msg_and_die("empty archive");
tar_fd = STDOUT_FILENO;
/* Mimicking GNU tar 1.15.1: */
static void die_if_bad_fnamesize(unsigned sz)
{
if (sz > 0xfff) /* more than 4k?! no funny business please */
- bb_error_msg_and_die("bad archive");
+ bb_simple_error_msg_and_die("bad archive");
}
static void unzip_skip(off_t skip)
xread(zip_fd, target, zip->fmt.ucmpsize);
} else {
#if 1
- bb_error_msg_and_die("compressed symlink is not supported");
+ bb_simple_error_msg_and_die("compressed symlink is not supported");
#else
transformer_state_t xstate;
init_transformer_state(&xstate);
if (zip->fmt.method == 8) {
/* Method 8 - inflate */
if (inflate_unzip(&xstate) < 0)
- bb_error_msg_and_die("inflate error");
+ bb_simple_error_msg_and_die("inflate error");
/* Validate decompression - crc */
if (zip->fmt.crc32 != (xstate.crc32 ^ 0xffffffffL)) {
- bb_error_msg_and_die("crc error");
+ bb_simple_error_msg_and_die("crc error");
}
}
#if ENABLE_FEATURE_UNZIP_BZIP2
*/
xstate.bytes_out = unpack_bz2_stream(&xstate);
if (xstate.bytes_out < 0)
- bb_error_msg_and_die("inflate error");
+ bb_simple_error_msg_and_die("inflate error");
}
#endif
#if ENABLE_FEATURE_UNZIP_LZMA
/* Not tested yet */
xstate.bytes_out = unpack_lzma_stream(&xstate);
if (xstate.bytes_out < 0)
- bb_error_msg_and_die("inflate error");
+ bb_simple_error_msg_and_die("inflate error");
}
#endif
#if ENABLE_FEATURE_UNZIP_XZ
/* Not tested yet */
xstate.bytes_out = unpack_xz_stream(&xstate);
if (xstate.bytes_out < 0)
- bb_error_msg_and_die("inflate error");
+ bb_simple_error_msg_and_die("inflate error");
}
#endif
else {
if (zip->fmt.ucmpsize != xstate.bytes_out) {
/* Don't die. Who knows, maybe len calculation
* was botched somewhere. After all, crc matched! */
- bb_error_msg("bad length");
+ bb_simple_error_msg("bad length");
}
}
{
fflush_all();
if (!fgets(buf80, 80, stdin)) {
- bb_perror_msg_and_die("can't read standard input");
+ bb_simple_perror_msg_and_die("can't read standard input");
}
}
if (unicode == PSF2_SEPARATOR) {
break;
} else if (unicode == PSF2_STARTSEQ) {
- bb_error_msg_and_die("unicode sequences not implemented");
+ bb_simple_error_msg_and_die("unicode sequences not implemented");
} else if (unicode >= 0xC0) {
if (unicode >= 0xFC)
unicode &= 0x01, maxct = 5;
unicode &= 0x1F, maxct = 1;
do {
if (tailsz <= 0 || *inbuf < 0x80 || *inbuf > 0xBF)
- bb_error_msg_and_die("illegal UTF-8 character");
+ bb_simple_error_msg_and_die("illegal UTF-8 character");
--tailsz;
unicode = (unicode << 6) + (*inbuf++ & 0x3F);
} while (--maxct > 0);
} else if (unicode >= 0x80) {
- bb_error_msg_and_die("illegal UTF-8 character");
+ bb_simple_error_msg_and_die("illegal UTF-8 character");
}
#else
return;
if (len >= sizeof(struct psf1_header) && PSF1_MAGIC_OK(psf1h(buffer))) {
if (psf1h(buffer)->mode > PSF1_MAXMODE)
- bb_error_msg_and_die("unsupported psf file mode");
+ bb_simple_error_msg_and_die("unsupported psf file mode");
if (psf1h(buffer)->mode & PSF1_MODE512)
fontsize = 512;
if (psf1h(buffer)->mode & PSF1_MODEHASTAB)
#if ENABLE_FEATURE_LOADFONT_PSF2
if (len >= sizeof(struct psf2_header) && PSF2_MAGIC_OK(psf2h(buffer))) {
if (psf2h(buffer)->version > PSF2_MAXVERSION)
- bb_error_msg_and_die("unsupported psf file version");
+ bb_simple_error_msg_and_die("unsupported psf file version");
fontsize = psf2h(buffer)->length;
if (psf2h(buffer)->flags & PSF2_HAS_UNICODE_TABLE)
has_table = 2;
} else
#endif
{
- bb_error_msg_and_die("input file: bad length or unsupported font type");
+ bb_simple_error_msg_and_die("input file: bad length or unsupported font type");
}
#if !defined(PIO_FONTX) || defined(__sparc__)
if (fontsize != 256)
- bb_error_msg_and_die("only fontsize 256 supported");
+ bb_simple_error_msg_and_die("only fontsize 256 supported");
#endif
table = font + fontsize * charsize;
buffer += len;
if (table > buffer || (!has_table && table != buffer))
- bb_error_msg_and_die("input file: bad length");
+ bb_simple_error_msg_and_die("input file: bad length");
do_loadfont(fd, font, height, width, charsize, fontsize);
buffer = xmalloc_read(STDIN_FILENO, &len);
// xmalloc_open_zipped_read_close(filename, &len);
if (!buffer)
- bb_perror_msg_and_die("error reading input font");
+ bb_simple_perror_msg_and_die("error reading input font");
do_load(get_console_fd_or_die(), buffer, len);
return EXIT_SUCCESS;
if (a < 0 || a >= E_TABSZ
|| b < 0 || b > 65535
) {
- bb_error_msg_and_die("map format");
+ bb_simple_error_msg_and_die("map format");
}
// patch map
unicodes[a] = b;
xread(STDIN_FILENO, flags, 7);
if (!is_prefixed_with(flags, BINARY_KEYMAP_MAGIC))
- bb_error_msg_and_die("not a valid binary keymap");
+ bb_simple_error_msg_and_die("not a valid binary keymap");
xread(STDIN_FILENO, flags, MAX_NR_KEYMAPS);
fd = open(DEV_CONSOLE, O_RDONLY | O_NONBLOCK);
if (fd >= 0 && !not_vt_fd(fd))
return fd;
- bb_error_msg_and_die("can't find open VT");
+ bb_simple_error_msg_and_die("can't find open VT");
}
static int find_free_vtno(void)
errno = 0;
/*xfunc_error_retval = 3; - do we need compat? */
if (ioctl(fd, VT_OPENQRY, &vtno) != 0 || vtno <= 0)
- bb_perror_msg_and_die("can't find open VT");
+ bb_simple_perror_msg_and_die("can't find open VT");
// Not really needed, grep for DAEMON_CLOSE_EXTRA_FDS
// if (fd > 2)
// close(fd);
{
int ret = tcsetattr(STDIN_FILENO, TCSAFLUSH, t);
if (ret) {
- bb_perror_msg("can't tcsetattr for stdin");
+ bb_simple_perror_msg("can't tcsetattr for stdin");
}
}
// flags, FILEUTILS_RMDEST, OPT_parents);
if (flags & OPT_parents) {
if (!(d_flags & 2)) {
- bb_error_msg_and_die("with --parents, the destination must be a directory");
+ bb_simple_error_msg_and_die("with --parents, the destination must be a directory");
}
}
if (flags & FILEUTILS_RMDEST) {
goto DO_COPY; /* NB: argc==2 -> *++argv==last */
}
} else if (flags & FILEUTILS_NO_TARGET_DIR) {
- bb_error_msg_and_die("too many arguments");
+ bb_simple_error_msg_and_die("too many arguments");
}
while (1) {
// argc -= optind;
argv += optind;
if (!(opt & (CUT_OPT_BYTE_FLGS | CUT_OPT_CHAR_FLGS | CUT_OPT_FIELDS_FLGS)))
- bb_error_msg_and_die("expected a list of bytes, characters, or fields");
+ bb_simple_error_msg_and_die("expected a list of bytes, characters, or fields");
if (opt & CUT_OPT_DELIM_FLGS) {
if (ltok[0] && ltok[1]) { /* more than 1 char? */
- bb_error_msg_and_die("the delimiter must be a single character");
+ bb_simple_error_msg_and_die("the delimiter must be a single character");
}
delim = ltok[0];
}
/* make sure we got some cut positions out of all that */
if (nlists == 0)
- bb_error_msg_and_die("missing list of positions");
+ bb_simple_error_msg_and_die("missing list of positions");
/* now that the lists are parsed, we need to sort them to make life
* easier on us when it comes time to print the chars / fields / lines
/* if setting time, set it */
if ((opt & OPT_SET) && stime(&ts.tv_sec) < 0) {
- bb_perror_msg("can't set date");
+ bb_simple_perror_msg("can't set date");
}
}
if (!argv[0]) {
mount_table = setmntent(bb_path_mtab_file, "r");
if (!mount_table)
- bb_perror_msg_and_die(bb_path_mtab_file);
+ bb_simple_perror_msg_and_die(bb_path_mtab_file);
}
while (1) {
/*r =*/ full_write(STDOUT_FILENO, buffer, out - buffer);
free(buffer);
if (/*WRONG:r < 0*/ errno) {
- bb_perror_msg(bb_msg_write_error);
+ bb_simple_perror_msg(bb_msg_write_error);
return 1;
}
return 0;
while (*argv && (strchr(*argv, '=') != NULL)) {
if (putenv(*argv) < 0) {
- bb_perror_msg_and_die("putenv");
+ bb_simple_perror_msg_and_die("putenv");
}
++argv;
}
/* Now close stdin also */
/* (if we didn't read from it, it's a no-op) */
if (fclose(stdin))
- bb_perror_msg_and_die(bb_msg_standard_input);
+ bb_simple_perror_msg_and_die(bb_msg_standard_input);
fflush_stdout_and_exit(exit_status);
}
arith_t li, ri;
if (!toarith(l) || !toarith(r))
- bb_error_msg_and_die("non-numeric argument");
+ bb_simple_error_msg_and_die("non-numeric argument");
li = l->u.i;
ri = r->u.i;
if (op == '+')
if (op == '*')
return li * ri;
if (ri == 0)
- bb_error_msg_and_die("division by zero");
+ bb_simple_error_msg_and_die("division by zero");
if (op == '/')
return li / ri;
return li % ri;
VALUE *v;
if (!*G.args)
- bb_error_msg_and_die("syntax error");
+ bb_simple_error_msg_and_die("syntax error");
if (nextarg("(")) {
G.args++;
v = eval();
if (!nextarg(")"))
- bb_error_msg_and_die("syntax error");
+ bb_simple_error_msg_and_die("syntax error");
G.args++;
return v;
}
if (nextarg(")"))
- bb_error_msg_and_die("syntax error");
+ bb_simple_error_msg_and_die("syntax error");
return str_value(*G.args++);
}
G.args++; /* We have a valid token, so get the next argument. */
if (key == 1) { /* quote */
if (!*G.args)
- bb_error_msg_and_die("syntax error");
+ bb_simple_error_msg_and_die("syntax error");
return str_value(*G.args++);
}
if (key == 2) { /* length */
xfunc_error_retval = 2; /* coreutils compat */
G.args = argv + 1;
if (*G.args == NULL) {
- bb_error_msg_and_die("too few arguments");
+ bb_simple_error_msg_and_die("too few arguments");
}
v = eval();
if (*G.args)
- bb_error_msg_and_die("syntax error");
+ bb_simple_error_msg_and_die("syntax error");
if (v->type == INTEGER)
printf("%" PF_REZ "d\n", PF_REZ_TYPE v->u.i);
else
}
} else if (n < 0) { /* error in get_groups() */
if (ENABLE_DESKTOP)
- bb_error_msg_and_die("can't get groups");
+ bb_simple_error_msg_and_die("can't get groups");
return EXIT_FAILURE;
}
if (ENABLE_FEATURE_CLEAN_UP)
args[2] = dest;
args[3] = NULL;
if (spawn_and_wait(args)) {
- bb_perror_msg("strip");
+ bb_simple_perror_msg("strip");
ret = EXIT_FAILURE;
}
}
argc -= optind;
if ((opts & LN_LINKFILE) && argc > 2) {
- bb_error_msg_and_die("-T accepts 2 args max");
+ bb_simple_error_msg_and_die("-T accepts 2 args max");
}
if (!argv[1]) {
return fflush_all();
}
- bb_perror_msg_and_die("getlogin");
+ bb_simple_perror_msg_and_die("getlogin");
}
}
if (filename_ptr == NULL) {
if (flags & FLAG_WARN) {
- bb_error_msg("invalid format");
+ bb_simple_error_msg("invalid format");
}
count_failed++;
return_value = EXIT_FAILURE;
}
if (ferror(stdout)) {
- bb_error_msg_and_die(bb_msg_write_error);
+ bb_simple_error_msg_and_die(bb_msg_write_error);
}
}
}
if (n_skip)
- bb_error_msg_and_die("can't skip past end of combined input");
+ bb_simple_error_msg_and_die("can't skip past end of combined input");
}
pseudo_start = o2;
argv[1] = NULL;
} else {
- bb_error_msg_and_die("the last two arguments must be offsets");
+ bb_simple_error_msg_and_die("the last two arguments must be offsets");
}
} else { /* >3 args */
- bb_error_msg_and_die("too many arguments");
+ bb_simple_error_msg_and_die("too many arguments");
}
if (pseudo_start >= 0) {
if (option_mask32 & OPT_N) {
end_offset = n_bytes_to_skip + max_bytes_to_format;
if (end_offset < n_bytes_to_skip)
- bb_error_msg_and_die("SKIP + SIZE is too large");
+ bb_simple_error_msg_and_die("SKIP + SIZE is too large");
}
if (G.n_specs == 0) {
dump(n_bytes_to_skip, end_offset);
if (fclose(stdin))
- bb_perror_msg_and_die(bb_msg_standard_input);
+ bb_simple_perror_msg_and_die(bb_msg_standard_input);
return G.exit_code;
}
if (opt & PASTE_OPT_DELIMITERS) {
if (!delims[0])
- bb_error_msg_and_die("-d '' is not supported");
+ bb_simple_error_msg_and_die("-d '' is not supported");
/* unknown mappings are not changed: "\z" -> '\\' 'z' */
/* trailing backslash, if any, is preserved */
del_cnt = strcpy_and_process_escape_sequences(delims, delims) - delims;
if (ENABLE_ASH_PRINTF
&& applet_name[0] != 'p'
) {
- bb_error_msg("usage: printf FORMAT [ARGUMENT...]");
+ bb_simple_error_msg("usage: printf FORMAT [ARGUMENT...]");
return 2; /* bash compat */
}
bb_show_usage();
const char *base = bb_get_last_path_component_strip(*argv);
if (DOT_OR_DOTDOT(base)) {
- bb_error_msg("can't remove '.' or '..'");
+ bb_simple_error_msg("can't remove '.' or '..'");
} else if (remove_file(*argv, flags) >= 0) {
continue;
}
/* Perform actual comparison */
switch (flags & (FLAG_n | FLAG_g | FLAG_M | FLAG_V)) {
default:
- bb_error_msg_and_die("unknown sort type");
+ bb_simple_error_msg_and_die("unknown sort type");
break;
#if defined(HAVE_STRVERSCMP) && HAVE_STRVERSCMP == 1
case FLAG_V:
{
unsigned long lu;
if (!isdigit((*str)[0]))
- bb_error_msg_and_die("bad field specification");
+ bb_simple_error_msg_and_die("bad field specification");
lu = strtoul(*str, str, 10);
if ((sizeof(long) > sizeof(int) && lu > INT_MAX) || !lu)
- bb_error_msg_and_die("bad field specification");
+ bb_simple_error_msg_and_die("bad field specification");
return lu;
}
#endif
#if ENABLE_FEATURE_SORT_BIG
if (opts & FLAG_t) {
if (!str_t[0] || str_t[1])
- bb_error_msg_and_die("bad -t parameter");
+ bb_simple_error_msg_and_die("bad -t parameter");
key_separator = str_t[0];
}
/* note: below this point we use option_mask32, not opts,
because comma isn't in OPT_STR */
idx = strchr(OPT_STR, *str_k);
if (!idx)
- bb_error_msg_and_die("unknown key option");
+ bb_simple_error_msg_and_die("unknown key option");
flag = 1 << (idx - OPT_STR);
if (flag & ~FLAG_allowed_for_k)
- bb_error_msg_and_die("unknown sort type");
+ bb_simple_error_msg_and_die("unknown sort type");
/* b after ',' means strip _trailing_ space */
if (i && flag == FLAG_b)
flag = FLAG_bb;
}
if (NAME_MAX < strlen(sfx) + suffix_len)
- bb_error_msg_and_die("suffix too long");
+ bb_simple_error_msg_and_die("suffix too long");
{
char *char_p = xzalloc(suffix_len + 1);
do {
if (!remaining) {
if (!pfx)
- bb_error_msg_and_die("suffixes exhausted");
+ bb_simple_error_msg_and_die("suffixes exhausted");
xmove_fd(xopen(pfx, O_WRONLY | O_CREAT | O_TRUNC), 1);
pfx = next_file(pfx, suffix_len);
remaining = cnt;
break;
case 'F':
if (file_name)
- bb_error_msg_and_die("only one device may be specified");
+ bb_simple_error_msg_and_die("only one device may be specified");
file_name = &arg[i+1]; /* "-Fdevice" ? */
if (!file_name[0]) { /* nope, "-F device" */
int p = k+1; /* argv[p] is argnext */
if ((stty_state & (STTY_verbose_output | STTY_recoverable_output)) ==
(STTY_verbose_output | STTY_recoverable_output)
) {
- bb_error_msg_and_die("-a and -g are mutually exclusive");
+ bb_simple_error_msg_and_die("-a and -g are mutually exclusive");
}
/* Specifying -a or -g with non-options is an error */
if ((stty_state & (STTY_verbose_output | STTY_recoverable_output))
&& !(stty_state & STTY_noargs)
) {
- bb_error_msg_and_die("modes may not be set when -a or -g is used");
+ bb_simple_error_msg_and_die("modes may not be set when -a or -g is used");
}
/* Now it is safe to start doing things */
r = full_read(fd, buf, count);
if (r < 0) {
- bb_perror_msg(bb_msg_read_error);
+ bb_simple_perror_msg(bb_msg_read_error);
G.exitcode = EXIT_FAILURE;
}
} while (++i < argc);
if (!nfiles)
- bb_error_msg_and_die("no files");
+ bb_simple_error_msg_and_die("no files");
/* prepare the buffer */
tailbufsize = BUFSIZ;
--argc;
if (!arg0[1]) { /* "[" ? */
if (NOT_LONE_CHAR(argv[argc], ']')) {
- bb_error_msg("missing ]");
+ bb_simple_error_msg("missing ]");
return 2;
}
} else { /* assuming "[[" */
if (strcmp(argv[argc], "]]") != 0) {
- bb_error_msg("missing ]]");
+ bb_simple_error_msg("missing ]]");
return 2;
}
}
str1_length = complement(str1, str1_length);
if (*argv) {
if (argv[0][0] == '\0')
- bb_error_msg_and_die("STRING2 cannot be empty");
+ bb_simple_error_msg_and_die("STRING2 cannot be empty");
str2_length = expand(*argv, &str2);
map(vector, str1, str1_length,
str2, str2_length);
read_chars = safe_read(STDIN_FILENO, str1, TR_BUFSIZ);
if (read_chars <= 0) {
if (read_chars < 0)
- bb_perror_msg_and_die(bb_msg_read_error);
+ bb_simple_perror_msg_and_die(bb_msg_read_error);
break;
}
in_index = 0;
continue;
}
if (encoded_len > 60) {
- bb_error_msg_and_die("line too long");
+ bb_simple_error_msg_and_die("line too long");
}
dst = line;
fwrite(line, 1, dst - line, dst_stream);
free(line);
}
- bb_error_msg_and_die("short file");
+ bb_simple_error_msg_and_die("short file");
}
#endif
/* fclose_if_not_stdin(src_stream); - redundant */
return EXIT_SUCCESS;
}
- bb_error_msg_and_die("no 'begin' line");
+ bb_simple_error_msg_and_die("no 'begin' line");
}
#endif
if (!size)
break;
if ((ssize_t)size < 0)
- bb_perror_msg_and_die(bb_msg_read_error);
+ bb_simple_perror_msg_and_die(bb_msg_read_error);
/* Encode the buffer we just read in */
bb_uuencode(dst_buf, src_buf, size, bb_uuenc_tbl_base64);
xwrite(STDOUT_FILENO, dst_buf, 4 * ((size + 2) / 3));
if (!size)
break;
if ((ssize_t)size < 0)
- bb_perror_msg_and_die(bb_msg_read_error);
+ bb_simple_perror_msg_and_die(bb_msg_read_error);
/* Encode the buffer we just read in */
bb_uuencode(dst_buf, src_buf, size, tbl);
bb_putchar('\n');
}
closedir(procdir);
if (!pid)
- bb_error_msg_and_die("nothing in /proc - not mounted?");
+ bb_simple_error_msg_and_die("nothing in /proc - not mounted?");
}
static int do_stop(void)
} else if (userspec) {
what = xasprintf("process(es) owned by '%s'", userspec);
} else {
- bb_error_msg_and_die("internal error, please report");
+ bb_simple_error_msg_and_die("internal error, please report");
}
if (!G.found_procs) {
/* run sanity checks on all the arguments given us */
if ((g.flags & OPT_SET) && (g.flags & (OPT_ADD|OPT_REM)))
- bb_error_msg_and_die("= is incompatible with - and +");
+ bb_simple_error_msg_and_die("= is incompatible with - and +");
if (g.rf & g.af)
- bb_error_msg_and_die("can't set and unset a flag");
+ bb_simple_error_msg_and_die("can't set and unset a flag");
if (!g.flags)
- bb_error_msg_and_die("must use '-v', =, - or +");
+ bb_simple_error_msg_and_die("must use '-v', =, - or +");
/* now run chattr on all the files passed to us */
do change_attributes(*argv, &g); while (*++argv);
if (errno == EINTR)
continue;
if (errno == ECHILD) { /* paranoia */
- bb_error_msg("wait: no more children");
+ bb_simple_error_msg("wait: no more children");
return -1;
}
- bb_perror_msg("wait");
+ bb_simple_perror_msg("wait");
continue;
}
prev = NULL;
if (G.fs_type_negated == -1)
G.fs_type_negated = negate;
if (G.fs_type_negated != negate)
- bb_error_msg_and_die(
+ bb_simple_error_msg_and_die(
"either all or none of the filesystem types passed to -t must be prefixed "
"with 'no' or '!'");
}
if (opn == '|') {
rsm->F = popen(R.s, "w");
if (rsm->F == NULL)
- bb_perror_msg_and_die("popen");
+ bb_simple_perror_msg_and_die("popen");
rsm->is_pipe = 1;
} else {
rsm->F = xfopen(R.s, opn=='w' ? "w" : "a");
argv += optind;
//argc -= optind;
if (opt & OPT_W)
- bb_error_msg("warning: option -W is ignored");
+ bb_simple_error_msg("warning: option -W is ignored");
if (opt & OPT_F) {
unescape_string_in_place(opt_F);
setvar_s(intvar[FS], opt_F);
xfunc_error_retval = 1;
if (gotstdin && (S_ISDIR(stb[0].st_mode) || S_ISDIR(stb[1].st_mode)))
- bb_error_msg_and_die("can't compare stdin to a directory");
+ bb_simple_error_msg_and_die("can't compare stdin to a directory");
/* Compare metadata to check if the files are the same physical file.
*
#if ENABLE_FEATURE_DIFF_DIR
diffdir(file, s_start);
#else
- bb_error_msg_and_die("no support for directory comparison");
+ bb_simple_error_msg_and_die("no support for directory comparison");
#endif
} else {
bool dirfile = S_ISDIR(stb[0].st_mode) || S_ISDIR(stb[1].st_mode);
if (*str == '\0') {
if (searchString[0] == '\0') {
- bb_error_msg("no previous search string");
+ bb_simple_error_msg("no previous search string");
return 0;
}
str = searchString;
case '\'':
cp++;
if ((unsigned)(*cp - 'a') >= 26) {
- bb_error_msg("bad mark name");
+ bb_simple_error_msg("bad mark name");
return NULL;
}
haveNum = TRUE;
LINE *newLp, *lp;
if ((num < 1) || (num > lastNum + 1)) {
- bb_error_msg("inserting at bad line number");
+ bb_simple_error_msg("inserting at bad line number");
return FALSE;
}
char *cp;
if ((num < 1) || (num > lastNum + 1)) {
- bb_error_msg("bad line for read");
+ bb_simple_error_msg("bad line for read");
return FALSE;
}
cp = buf;
if (isblank(*cp) || (*cp == '\0')) {
- bb_error_msg("bad delimiter for substitute");
+ bb_simple_error_msg("bad delimiter for substitute");
return;
}
cp = strchr(cp, delim);
if (cp == NULL) {
- bb_error_msg("missing 2nd delimiter for substitute");
+ bb_simple_error_msg("missing 2nd delimiter for substitute");
return;
}
printFlag = TRUE;
break;
default:
- bb_error_msg("unknown option for substitute");
+ bb_simple_error_msg("unknown option for substitute");
return;
}
if (*oldStr == '\0') {
if (searchString[0] == '\0') {
- bb_error_msg("no previous search string");
+ bb_simple_error_msg("no previous search string");
return;
}
oldStr = searchString;
case 'f':
if (*cp != '\0' && *cp != ' ') {
- bb_error_msg("bad file command");
+ bb_simple_error_msg("bad file command");
break;
}
cp = skip_whitespace(cp);
case 'k':
cp = skip_whitespace(cp);
if ((unsigned)(*cp - 'a') >= 26 || cp[1]) {
- bb_error_msg("bad mark name");
+ bb_simple_error_msg("bad mark name");
break;
}
marks[(unsigned)(*cp - 'a')] = num2;
case 'q':
cp = skip_whitespace(cp);
if (have1 || *cp) {
- bb_error_msg("bad quit command");
+ bb_simple_error_msg("bad quit command");
break;
}
if (!dirty)
case 'r':
if (*cp != '\0' && *cp != ' ') {
- bb_error_msg("bad read command");
+ bb_simple_error_msg("bad read command");
break;
}
cp = skip_whitespace(cp);
if (*cp == '\0') {
- bb_error_msg("no file name");
+ bb_simple_error_msg("no file name");
break;
}
if (!have1)
case 'w':
if (*cp != '\0' && *cp != ' ') {
- bb_error_msg("bad write command");
+ bb_simple_error_msg("bad write command");
break;
}
cp = skip_whitespace(cp);
if (*cp == '\0') {
cp = fileName;
if (!cp) {
- bb_error_msg("no file name specified");
+ bb_simple_error_msg("no file name specified");
break;
}
}
case '.':
if (have1) {
- bb_error_msg("no arguments allowed");
+ bb_simple_error_msg("no arguments allowed");
break;
}
printLines(curNum, curNum, FALSE);
break;
default:
- bb_error_msg("unimplemented command");
+ bb_simple_error_msg("unimplemented command");
break;
}
}
break;
}
if (fputs(line, dst_stream) == EOF) {
- bb_perror_msg_and_die("error writing to new file");
+ bb_simple_perror_msg_and_die("error writing to new file");
}
free(line);
lines_count--;
new_filename = extract_filename(patch_line, patch_level, "+++ ");
if (!new_filename) {
- bb_error_msg_and_die("invalid patch");
+ bb_simple_error_msg_and_die("invalid patch");
}
/* Get access rights from the file to be patched */
/* src_beg_line will be 0 if it's a new file */
count = src_beg_line - src_cur_line;
if (copy_lines(src_stream, dst_stream, count)) {
- bb_error_msg_and_die("bad src file");
+ bb_simple_error_msg_and_die("bad src file");
}
src_cur_line += count;
dst_cur_line += count;
*tempname = xasprintf("%sXXXXXX", name);
fd = mkstemp(*tempname);
- if(-1 == fd) bb_perror_msg_and_die("no temp file");
+ if(-1 == fd) bb_simple_perror_msg_and_die("no temp file");
// Set permissions of output file
fstat(fdin, &statbuf);
/* verify that the 's' or 'y' is followed by something. That something
* (typically a 'slash') is now our regexp delimiter... */
if (*cmdstr == '\0')
- bb_error_msg_and_die("bad format in substitution expression");
+ bb_simple_error_msg_and_die("bad format in substitution expression");
delimiter = *cmdstr_ptr++;
/* save the match string */
} else {
*regex = G.previous_regex_ptr;
if (!G.previous_regex_ptr)
- bb_error_msg_and_die("no previous regexp");
+ bb_simple_error_msg_and_die("no previous regexp");
}
/* Move position to next character after last delimiter */
pos += (next+1);
start = skip_whitespace(filecmdstr);
eol = strchrnul(start, '\n');
if (eol == start)
- bb_error_msg_and_die("empty filename");
+ bb_simple_error_msg_and_die("empty filename");
if (*eol) {
/* If lines glued together, put backslash back. */
goto out;
default:
dbg("s bad flags:'%s'", substr + idx);
- bb_error_msg_and_die("bad option in substitution expression");
+ bb_simple_error_msg_and_die("bad option in substitution expression");
}
}
out:
idx--; /* if 0, trigger error check below */
}
if (idx < 0)
- bb_error_msg_and_die("no address after comma");
+ bb_simple_error_msg_and_die("no address after comma");
sed_cmd->end_line_orig = sed_cmd->end_line;
}
/* last part (mandatory) will be a command */
if (!*cmdstr)
- bb_error_msg_and_die("missing command");
+ bb_simple_error_msg_and_die("missing command");
sed_cmd->cmd = *cmdstr++;
cmdstr = parse_cmd_args(sed_cmd, cmdstr);
if (!current_regex) {
current_regex = G.previous_regex_ptr;
if (!current_regex)
- bb_error_msg_and_die("no previous regexp");
+ bb_simple_error_msg_and_die("no previous regexp");
}
G.previous_regex_ptr = current_regex;
if (ferror(file)) {
xfunc_error_retval = 4; /* It's what gnu sed exits with... */
- bb_error_msg_and_die(bb_msg_write_error);
+ bb_simple_error_msg_and_die(bb_msg_write_error);
}
*last_puts_char = lpc;
}
}
sed_cmd = sed_cmd->next;
if (!sed_cmd)
- bb_error_msg_and_die("unterminated {");
+ bb_simple_error_msg_and_die("unterminated {");
}
}
continue;
goto again;
go_bottom_and_clear_to_eol();
cookmode(); // terminal to "cooked"
- bb_error_msg_and_die("can't read user input");
+ bb_simple_error_msg_and_die("can't read user input");
}
return c;
}
* coreutils expects {} to appear only once in "-exec +"
*/
if (all_subst != 1 && ap->filelist)
- bb_error_msg_and_die("only one '{}' allowed for -exec +");
+ bb_simple_error_msg_and_die("only one '{}' allowed for -exec +");
# endif
}
#endif
endarg = argv;
while (1) {
if (!*++endarg)
- bb_error_msg_and_die("unpaired '('");
+ bb_simple_error_msg_and_die("unpaired '('");
if (LONE_CHAR(*endarg, '('))
nested++;
else if (LONE_CHAR(*endarg, ')') && !--nested) {
}
/* Sanity check */
if (n_max_chars <= 0) {
- bb_error_msg_and_die("can't fit single argument within argument list size limit");
+ bb_simple_error_msg_and_die("can't fit single argument within argument list size limit");
}
buf = xzalloc(n_max_chars + 1);
if (!G.args[initial_idx]) { /* not even one ARG was added? */
if (*rem != '\0')
- bb_error_msg_and_die("argument line too long");
+ bb_simple_error_msg_and_die("argument line too long");
if (opt & OPT_NO_EMPTY)
break;
}
({ \
pid_t bb__xvfork_pid = vfork(); \
if (bb__xvfork_pid < 0) \
- bb_perror_msg_and_die("vfork"); \
+ bb_simple_perror_msg_and_die("vfork"); \
bb__xvfork_pid; \
})
#if BB_MMU
void xfunc_die(void) NORETURN FAST_FUNC;
void bb_show_usage(void) NORETURN FAST_FUNC;
void bb_error_msg(const char *s, ...) __attribute__ ((format (printf, 1, 2))) FAST_FUNC;
+void bb_simple_error_msg(const char *s) FAST_FUNC;
void bb_error_msg_and_die(const char *s, ...) __attribute__ ((noreturn, format (printf, 1, 2))) FAST_FUNC;
+void bb_simple_error_msg_and_die(const char *s) NORETURN FAST_FUNC;
void bb_perror_msg(const char *s, ...) __attribute__ ((format (printf, 1, 2))) FAST_FUNC;
void bb_simple_perror_msg(const char *s) FAST_FUNC;
void bb_perror_msg_and_die(const char *s, ...) __attribute__ ((noreturn, format (printf, 1, 2))) FAST_FUNC;
void bb_simple_perror_msg_and_die(const char *s) NORETURN FAST_FUNC;
void bb_herror_msg(const char *s, ...) __attribute__ ((format (printf, 1, 2))) FAST_FUNC;
+void bb_simple_herror_msg(const char *s) FAST_FUNC;
void bb_herror_msg_and_die(const char *s, ...) __attribute__ ((noreturn, format (printf, 1, 2))) FAST_FUNC;
+void bb_simple_herror_msg_and_die(const char *s) NORETURN FAST_FUNC;
void bb_perror_nomsg_and_die(void) NORETURN FAST_FUNC;
void bb_perror_nomsg(void) FAST_FUNC;
void bb_verror_msg(const char *s, va_list p, const char *strerr) FAST_FUNC;
#if ENABLE_FEATURE_SYSLOG_INFO
void bb_info_msg(const char *s, ...) __attribute__ ((format (printf, 1, 2))) FAST_FUNC;
+void bb_simple_info_msg(const char *s) FAST_FUNC;
void bb_vinfo_msg(const char *s, va_list p) FAST_FUNC;
#else
#define bb_info_msg bb_error_msg
+#define bb_simple_info_msg bb_simple_error_msg
#define bb_vinfo_msg(s,p) bb_verror_msg(s,p,NULL)
#endif
+#if ENABLE_WARN_SIMPLE_MSG
+/* If enabled, cause calls to bb_error_msg() et al that only take a single
+ * parameter to generate a warning.
+ */
+static inline void __attribute__ ((deprecated("use bb_simple_error_msg instead")))
+ bb_not_simple_error_msg(const char *s) { bb_simple_error_msg(s); }
+static inline void __attribute__ ((deprecated("use bb_simple_error_msg_and_die instead"))) NORETURN
+ bb_not_simple_error_msg_and_die(const char *s) { bb_simple_error_msg_and_die(s); }
+static inline void __attribute__ ((deprecated("use bb_simple_perror_msg instead")))
+ bb_not_simple_perror_msg(const char *s) { bb_simple_perror_msg(s); }
+static inline void __attribute__ ((deprecated("use bb_simple_perror_msg_and_die instead"))) NORETURN
+ bb_not_simple_perror_msg_and_die(const char *s) { bb_simple_perror_msg_and_die(s); }
+static inline void __attribute__ ((deprecated("use bb_simple_herror_msg instead")))
+ bb_not_simple_herror_msg(const char *s) { bb_simple_herror_msg(s); }
+static inline void __attribute__ ((deprecated("use bb_simple_herror_msg_and_die instead"))) NORETURN
+ bb_not_simple_herror_msg_and_die(const char *s) { bb_simple_herror_msg_and_die(s); }
+static inline void __attribute__ ((deprecated("use bb_simple_info_msg instead")))
+ bb_not_simple_info_msg(const char *s) { bb_simple_info_msg(s); }
+/* Override bb_error_msg() and related functions with macros that will
+ * substitute them for the equivalent bb_not_simple_error_msg() function when
+ * they are used with only a single parameter. Macro approach inspired by
+ * https://gustedt.wordpress.com/2010/06/08/detect-empty-macro-arguments and
+ * https://gustedt.wordpress.com/2010/06/03/default-arguments-for-c99
+ */
+#define _ARG18(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, ...) _17
+#define BB_MSG_KIND(...) _ARG18(__VA_ARGS__, , , , , , , , , , , , , , , , , _not_simple)
+#define _BB_MSG(name, kind, ...) bb##kind##name(__VA_ARGS__)
+#define BB_MSG(name, kind, ...) _BB_MSG(name, kind, __VA_ARGS__)
+#define bb_error_msg(...) BB_MSG(_error_msg, BB_MSG_KIND(__VA_ARGS__), __VA_ARGS__)
+#define bb_error_msg_and_die(...) BB_MSG(_error_msg_and_die, BB_MSG_KIND(__VA_ARGS__), __VA_ARGS__)
+#define bb_perror_msg(...) BB_MSG(_perror_msg, BB_MSG_KIND(__VA_ARGS__), __VA_ARGS__)
+#define bb_perror_msg_and_die(...) BB_MSG(_perror_msg_and_die, BB_MSG_KIND(__VA_ARGS__), __VA_ARGS__)
+#define bb_herror_msg(...) BB_MSG(_herror_msg, BB_MSG_KIND(__VA_ARGS__), __VA_ARGS__)
+#define bb_herror_msg_and_die(...) BB_MSG(_herror_msg_and_die, BB_MSG_KIND(__VA_ARGS__), __VA_ARGS__)
+#define bb_info_msg(...) BB_MSG(_info_msg, BB_MSG_KIND(__VA_ARGS__), __VA_ARGS__)
+#endif
+
/* We need to export XXX_main from libbusybox
* only if we build "individual" binaries
*/
bb_perror_msg_and_die("can't %smount tmpfs", "un");
}
#else
- bb_perror_msg_and_die("can't create temporary directory");
+ bb_simple_perror_msg_and_die("can't create temporary directory");
#endif
} else {
xchdir(tempdir);
if (getpid() != 1
&& (!ENABLE_LINUXRC || applet_name[0] != 'l') /* not linuxrc? */
) {
- bb_error_msg_and_die("must be run as PID 1");
+ bb_simple_error_msg_and_die("must be run as PID 1");
}
#ifdef RB_DISABLE_CAD
/* Turn off rebooting via CTL-ALT-DEL - we get a
/* same group / in group */
m >>= 3;
if (!(m & S_IXOTH)) /* is x bit not set? */
- bb_error_msg_and_die("you have no permission to run this applet");
+ bb_simple_error_msg_and_die("you have no permission to run this applet");
/* We set effective AND saved ids. If saved-id is not set
* like we do below, seteuid(0) can still later succeed! */
rgid = sct->m_ugid.gid;
/* else: we will set egid = rgid, thus dropping sgid effect */
if (setresgid(-1, rgid, rgid))
- bb_perror_msg_and_die("setresgid");
+ bb_simple_perror_msg_and_die("setresgid");
/* Are we directed to change uid
* (APPLET = s** USER.GROUP or APPLET = S** USER.GROUP)?
uid = sct->m_ugid.uid;
/* else: we will set euid = ruid, thus dropping suid effect */
if (setresuid(-1, uid, uid))
- bb_perror_msg_and_die("setresuid");
+ bb_simple_perror_msg_and_die("setresuid");
goto ret;
}
if (!onetime) {
onetime = 1;
- bb_error_msg("using fallback suid method");
+ bb_simple_error_msg("using fallback suid method");
}
}
# endif
/* Real uid is not 0. If euid isn't 0 too, suid bit
* is most probably not set on our executable */
if (geteuid())
- bb_error_msg_and_die("must be suid to work properly");
+ bb_simple_error_msg_and_die("must be suid to work properly");
} else if (APPLET_SUID(applet_no) == BB_SUID_DROP) {
/*
* Drop all privileges.
continue;
}
/* Some other error (should never happen on Linux) */
- bb_perror_msg_and_die("getgroups");
+ bb_simple_perror_msg_and_die("getgroups");
}
if (ngroups)
return EXIT_FAILURE;
}
- bb_error_msg("All tests passed");
+ bb_simple_error_msg("All tests passed");
return EXIT_SUCCESS;
}
caps->u32s = _LINUX_CAPABILITY_U32S_3;
break;
default:
- bb_error_msg_and_die("unsupported capability version");
+ bb_simple_error_msg_and_die("unsupported capability version");
}
if (capget(&caps->header, caps->data) != 0)
return;
}
- bb_perror_msg_and_die("can't set groups");
+ bb_simple_perror_msg_and_die("can't set groups");
}
xsetgid(pw->pw_gid);
) {
security_context_t con;
if (getfscreatecon(&con) == -1) {
- bb_perror_msg("getfscreatecon");
+ bb_simple_perror_msg("getfscreatecon");
return -1;
}
if (con) {
rd = safe_read(src_fd, buffer,
size > buffer_size ? buffer_size : size);
if (rd < 0) {
- bb_perror_msg(bb_msg_read_error);
+ bb_simple_perror_msg(bb_msg_read_error);
break;
}
read_ok:
ssize_t wr = full_write(dst_fd, buffer, rd);
if (wr < rd) {
if (!continue_on_write_error) {
- bb_perror_msg(bb_msg_write_error);
+ bb_simple_perror_msg(bb_msg_write_error);
break;
}
dst_fd = -1;
if (sz == (size >= 0 ? size : -size))
return;
if (sz != -1)
- bb_error_msg_and_die("short read");
+ bb_simple_error_msg_and_die("short read");
/* if sz == -1, bb_copyfd_XX already complained */
xfunc_die();
}
* including the terminating null byte.
*/
if (name - start >= LOGIN_NAME_MAX)
- bb_error_msg_and_die("name is too long");
+ bb_simple_error_msg_and_die("name is too long");
}
pr->bcnt = fu->bcnt;
if (fu->bcnt == 0) {
if (!prec)
- bb_error_msg_and_die("%%s needs precision or byte count");
+ bb_simple_error_msg_and_die("%%s needs precision or byte count");
pr->bcnt = atoi(prec);
}
} else
/* only one conversion character if byte count */
if (!(pr->flags & F_ADDRESS) && fu->bcnt && nconv++) {
- bb_error_msg_and_die("byte count with multiple conversion characters");
+ bb_simple_error_msg_and_die("byte count with multiple conversion characters");
}
}
/*
{
xfunc_error_retval = retval;
if (fflush(stdout))
- bb_perror_msg_and_die(bb_msg_standard_output);
+ bb_simple_perror_msg_and_die(bb_msg_standard_output);
/* In case we are in NOFORK applet. Do not exit() directly,
* but use xfunc_die() */
xfunc_die();
}
}
- bb_error_msg_and_die("can't open console");
+ bb_simple_error_msg_and_die("can't open console");
}
/* From <linux/vt.h> */
if (override) {
result = XATOOFF(override);
if (result >= (uoff_t)(MAXINT(off_t)) / override_units)
- bb_error_msg_and_die("image size is too big");
+ bb_simple_error_msg_and_die("image size is too big");
result *= override_units;
/* seek past end fails on block devices but works on files */
if (lseek(fd, result - 1, SEEK_SET) != (off_t)-1) {
*
* Picked 16k arbitrarily: */
if (result < 16*1024)
- bb_error_msg_and_die("image is too small");
+ bb_simple_error_msg_and_die("image is too small");
return result;
}
const char *name;
name = ptsname(p); /* find out the name of slave pty */
if (!name) {
- bb_perror_msg_and_die("ptsname error (is /dev/pts mounted?)");
+ bb_simple_perror_msg_and_die("ptsname error (is /dev/pts mounted?)");
}
safe_strncpy(line, name, GETPTY_BUFSIZE);
}
# else
/* find out the name of slave pty */
if (ptsname_r(p, line, GETPTY_BUFSIZE-1) != 0) {
- bb_perror_msg_and_die("ptsname error (is /dev/pts mounted?)");
+ bb_simple_perror_msg_and_die("ptsname error (is /dev/pts mounted?)");
}
line[GETPTY_BUFSIZE-1] = '\0';
# endif
}
}
#endif /* FEATURE_DEVPTS */
- bb_error_msg_and_die("can't find free pty");
+ bb_simple_error_msg_and_die("can't find free pty");
}
va_end(p);
xfunc_die();
}
+
+void FAST_FUNC bb_simple_herror_msg(const char *s)
+{
+ bb_herror_msg("%s", s);
+}
+
+void FAST_FUNC bb_simple_herror_msg_and_die(const char *s)
+{
+ bb_herror_msg_and_die("%s", s);
+}
/* Bummer. Fall back on trying the /proc filesystem */
if (!mountTable) mountTable = setmntent("/proc/mounts", "r");
if (!mountTable) {
- bb_perror_msg(bb_path_mtab_file);
+ bb_simple_perror_msg(bb_path_mtab_file);
return;
}
}
endmntent(mountTable);
} else if (errno != EROFS)
- bb_perror_msg(bb_path_mtab_file);
+ bb_simple_perror_msg(bb_path_mtab_file);
}
#endif
* instead of including libbb.h */
//#include "libbb.h"
#include "platform.h"
-extern void bb_perror_msg(const char *s, ...) FAST_FUNC;
+extern void bb_simple_perror_msg(const char *s) FAST_FUNC;
/* suppress gcc "no previous prototype" warning */
void FAST_FUNC bb_perror_nomsg(void);
void FAST_FUNC bb_perror_nomsg(void)
{
- bb_perror_msg(0);
+ bb_simple_perror_msg(0);
}
* instead of including libbb.h */
//#include "libbb.h"
#include "platform.h"
-extern void bb_perror_msg_and_die(const char *s, ...) FAST_FUNC;
+extern void bb_simple_perror_msg_and_die(const char *s) FAST_FUNC;
/* suppress gcc "no previous prototype" warning */
void FAST_FUNC bb_perror_nomsg_and_die(void);
void FAST_FUNC bb_perror_nomsg_and_die(void)
{
- bb_perror_msg_and_die(0);
+ bb_simple_perror_msg_and_die(0);
}
if (count) {
ssize_t size = full_read(fd, buf, count);
if ((size_t)size != count)
- bb_error_msg_and_die("short read");
+ bb_simple_error_msg_and_die("short read");
}
}
/* I doubt many callers would handle this correctly! */
if (errno == ENOMEM)
continue;
- bb_perror_msg("poll");
+ bb_simple_perror_msg("poll");
return n;
}
}
if (fgetfilecon(fdesc, &context) < 0) {
if (errno == ENODATA || errno == ENOTSUP)
return;
- bb_perror_msg_and_die("fgetfilecon failed");
+ bb_simple_perror_msg_and_die("fgetfilecon failed");
}
setfscreatecon_or_die(context);
freecon(context);
static void get_mono(struct timespec *ts)
{
if (syscall(__NR_clock_gettime, CLOCK_MONOTONIC, ts))
- bb_error_msg_and_die("clock_gettime(MONOTONIC) failed");
+ bb_simple_error_msg_and_die("clock_gettime(MONOTONIC) failed");
}
unsigned long long FAST_FUNC monotonic_ns(void)
{
return; /* No need to check */
if (getprevcon_raw(&context) < 0)
- bb_perror_msg_and_die("getprevcon failed");
+ bb_simple_perror_msg_and_die("getprevcon failed");
seuser = strtok(context, ":");
if (!seuser)
bb_error_msg_and_die("invalid context '%s'", context);
if (selinux_check_passwd_access(av) != 0)
die:
- bb_error_msg_and_die("SELinux: access denied");
+ bb_simple_error_msg_and_die("SELinux: access denied");
}
if (ENABLE_FEATURE_CLEAN_UP)
freecon(context);
if (*in_tail == '\0')
return;
/* No */
- bb_error_msg_and_die("truncated base64 input");
+ bb_simple_error_msg_and_die("truncated base64 input");
}
/* It was partial decode */
bb_vinfo_msg(s, p);
va_end(p);
}
+
+void FAST_FUNC bb_simple_info_msg(const char *s)
+{
+ bb_info_msg("%s", s);
+}
#endif
+
+void FAST_FUNC bb_simple_error_msg(const char *s)
+{
+ bb_error_msg("%s", s);
+}
+
+void FAST_FUNC bb_simple_error_msg_and_die(const char *s)
+{
+ bb_error_msg_and_die("%s", s);
+}
void FAST_FUNC bb_warn_ignoring_args(char *arg)
{
if (arg) {
- bb_error_msg("ignoring all arguments");
+ bb_simple_error_msg("ignoring all arguments");
}
}
#endif
int FAST_FUNC setsockopt_bindtodevice(int fd UNUSED_PARAM,
const char *iface UNUSED_PARAM)
{
- bb_error_msg("SO_BINDTODEVICE is not supported on this system");
+ bb_simple_error_msg("SO_BINDTODEVICE is not supported on this system");
return -1;
}
#endif
bb_perror_msg_and_die("%s (%s)",
"can't connect to remote host",
inet_ntoa(((struct sockaddr_in *)s_addr)->sin_addr));
- bb_perror_msg_and_die("can't connect to remote host");
+ bb_simple_perror_msg_and_die("can't connect to remote host");
}
}
n = safe_waitpid(pid, &exit_status, 0);
if (n < 0)
- bb_perror_msg_and_die("waitpid");
+ bb_simple_perror_msg_and_die("waitpid");
return exit_status;
}
void FAST_FUNC bb_die_memory_exhausted(void)
{
- bb_error_msg_and_die(bb_msg_memory_exhausted);
+ bb_simple_error_msg_and_die(bb_msg_memory_exhausted);
}
#ifndef DMALLOC
{
void *ptr = malloc(size);
if (ptr == NULL && size != 0)
- bb_error_msg(bb_msg_memory_exhausted);
+ bb_simple_error_msg(bb_msg_memory_exhausted);
return ptr;
}
char *t;
if (ENABLE_DEBUG && s == NULL)
- bb_error_msg_and_die("xstrndup bug");
+ bb_simple_error_msg_and_die("xstrndup bug");
/* We can just xmalloc(n+1) and strncpy into it, */
/* but think about xstrndup("abc", 10000) wastage! */
void FAST_FUNC xpipe(int filedes[2])
{
if (pipe(filedes))
- bb_perror_msg_and_die("can't create pipe");
+ bb_simple_perror_msg_and_die("can't create pipe");
}
void FAST_FUNC xdup2(int from, int to)
{
if (dup2(from, to) != to)
- bb_perror_msg_and_die("can't duplicate file descriptor");
+ bb_simple_perror_msg_and_die("can't duplicate file descriptor");
// " %d to %d", from, to);
}
* or some writes succeeded, then we hit an error.
* In either case, errno is set.
*/
- bb_perror_msg_and_die(
+ bb_simple_perror_msg_and_die(
size >= 0 ? "short write" : "write error"
);
}
void FAST_FUNC xclose(int fd)
{
if (close(fd))
- bb_perror_msg_and_die("close failed");
+ bb_simple_perror_msg_and_die("close failed");
}
// Die with an error message if we can't lseek to the right spot.
{
off_t off = lseek(fd, offset, whence);
if (off == (off_t)-1) {
- if (whence == SEEK_SET)
- bb_perror_msg_and_die("lseek(%"OFF_FMT"u)", offset);
- bb_perror_msg_and_die("lseek");
+ bb_perror_msg_and_die("lseek(%"OFF_FMT"u, %d)", offset, whence);
}
return off;
}
// setgid() will fail and we'll _still_be_root_, which is bad.)
void FAST_FUNC xsetgid(gid_t gid)
{
- if (setgid(gid)) bb_perror_msg_and_die("setgid");
+ if (setgid(gid)) bb_simple_perror_msg_and_die("setgid");
}
// Die with an error message if we can't set uid. (See xsetgid() for why.)
void FAST_FUNC xsetuid(uid_t uid)
{
- if (setuid(uid)) bb_perror_msg_and_die("setuid");
+ if (setuid(uid)) bb_simple_perror_msg_and_die("setuid");
}
void FAST_FUNC xsetegid(gid_t egid)
{
- if (setegid(egid)) bb_perror_msg_and_die("setegid");
+ if (setegid(egid)) bb_simple_perror_msg_and_die("setegid");
}
void FAST_FUNC xseteuid(uid_t euid)
{
- if (seteuid(euid)) bb_perror_msg_and_die("seteuid");
+ if (seteuid(euid)) bb_simple_perror_msg_and_die("seteuid");
}
// Die if we can't chdir to a new path.
void FAST_FUNC xfchdir(int fd)
{
if (fchdir(fd))
- bb_perror_msg_and_die("fchdir");
+ bb_simple_perror_msg_and_die("fchdir");
}
void FAST_FUNC xchroot(const char *path)
IF_FEATURE_IPV6(if (domain == AF_INET6) s = "INET6";)
bb_perror_msg_and_die("socket(AF_%s,%d,%d)", s, type, protocol);
#else
- bb_perror_msg_and_die("socket");
+ bb_simple_perror_msg_and_die("socket");
#endif
}
// Die with an error message if we can't bind a socket to an address.
void FAST_FUNC xbind(int sockfd, struct sockaddr *my_addr, socklen_t addrlen)
{
- if (bind(sockfd, my_addr, addrlen)) bb_perror_msg_and_die("bind");
+ if (bind(sockfd, my_addr, addrlen)) bb_simple_perror_msg_and_die("bind");
}
// Die with an error message if we can't listen for connections on a socket.
void FAST_FUNC xlisten(int s, int backlog)
{
- if (listen(s, backlog)) bb_perror_msg_and_die("listen");
+ if (listen(s, backlog)) bb_simple_perror_msg_and_die("listen");
}
/* Die with an error message if sendto failed.
if (ret < 0) {
if (ENABLE_FEATURE_CLEAN_UP)
close(s);
- bb_perror_msg_and_die("sendto");
+ bb_simple_perror_msg_and_die("sendto");
}
return ret;
}
#if ENABLE_SELINUX
int rc = is_selinux_enabled();
if (rc == 0) {
- bb_error_msg_and_die("SELinux is disabled");
+ bb_simple_error_msg_and_die("SELinux is disabled");
} else if (rc < 0) {
- bb_error_msg_and_die("is_selinux_enabled() failed");
+ bb_simple_error_msg_and_die("is_selinux_enabled() failed");
}
#else
- bb_error_msg_and_die("SELinux support is disabled");
+ bb_simple_error_msg_and_die("SELinux support is disabled");
#endif
}
pid_t pid;
pid = fork();
if (pid < 0) /* wtf? */
- bb_perror_msg_and_die("vfork"+1);
+ bb_simple_perror_msg_and_die("vfork"+1);
return pid;
}
#endif
if (errno == ERANGE)
continue;
free(cwd);
- bb_perror_msg("getcwd");
+ bb_simple_perror_msg("getcwd");
return NULL;
}
cwd = xrealloc(cwd, strlen(cwd) + 1);
{
struct hostent *retval = gethostbyname(name);
if (!retval)
- bb_herror_msg_and_die("%s", name);
+ bb_simple_herror_msg_and_die(name);
return retval;
}
/* need to be root */
if (geteuid()) {
- bb_error_msg_and_die(bb_msg_perm_denied_are_you_root);
+ bb_simple_error_msg_and_die(bb_msg_perm_denied_are_you_root);
}
/* Syntax:
* addgroup group
static void passwd_wrapper(const char *login_name)
{
BB_EXECLP("passwd", "passwd", "--", login_name, NULL);
- bb_error_msg_and_die("can't execute passwd, you must set password manually");
+ bb_simple_error_msg_and_die("can't execute passwd, you must set password manually");
}
//FIXME: upstream adduser has no short options! NOT COMPATIBLE!
/* got root? */
if (geteuid()) {
- bb_error_msg_and_die(bb_msg_perm_denied_are_you_root);
+ bb_simple_error_msg_and_die(bb_msg_perm_denied_are_you_root);
}
pw.pw_gecos = (char *)"Linux User,,,";
int opt;
if (getuid() != 0)
- bb_error_msg_and_die(bb_msg_perm_denied_are_you_root);
+ bb_simple_error_msg_and_die(bb_msg_perm_denied_are_you_root);
opt = getopt32long(argv, "^" "emc:R:" "\0" "m--ec:e--mc:c--em",
chpasswd_longopts,
pass = strchr(name, ':');
if (!pass)
- bb_error_msg_and_die("missing new password");
+ bb_simple_error_msg_and_die("missing new password");
*pass++ = '\0';
xuname2uid(name); /* dies if there is no such user */
#endif
if (geteuid() != 0)
- bb_error_msg_and_die(bb_msg_perm_denied_are_you_root);
+ bb_simple_error_msg_and_die(bb_msg_perm_denied_are_you_root);
name = argv[1];
member = NULL;
/* note: arg "0" turns into speed B0 */
G.numspeed++;
if (G.numspeed > MAX_SPEED)
- bb_error_msg_and_die("too many alternate speeds");
+ bb_simple_error_msg_and_die("too many alternate speeds");
}
debug("exiting parse_speeds\n");
}
* Make sure it is open for read/write.
*/
if ((fcntl(0, F_GETFL) & (O_RDWR|O_RDONLY|O_WRONLY)) != O_RDWR)
- bb_error_msg_and_die("stdin is not open for read/write");
+ bb_simple_error_msg_and_die("stdin is not open for read/write");
/* Try to get real tty name instead of "-" */
n = xmalloc_ttyname(0);
static void set_tty_attrs(void)
{
if (tcsetattr_stdin_TCSANOW(&G.tty_attrs) < 0)
- bb_perror_msg_and_die("tcsetattr");
+ bb_simple_perror_msg_and_die("tcsetattr");
}
/* We manipulate tty_attrs this way:
finalize_tty_attrs();
if (errno == EINTR || errno == EIO)
exit(EXIT_SUCCESS);
- bb_perror_msg_and_die(bb_msg_read_error);
+ bb_simple_perror_msg_and_die(bb_msg_read_error);
}
switch (c) {
// " sid %d pgid %d",
// pid, getppid(),
// getsid(0), getpgid(0));
- bb_perror_msg_and_die("setsid");
+ bb_simple_perror_msg_and_die("setsid");
/*
* When we can end up here?
* Example: setsid() fails when run alone in interactive shell:
tsid = tcgetsid(STDIN_FILENO);
if (tsid < 0 || pid != tsid) {
if (ioctl(STDIN_FILENO, TIOCSCTTY, /*force:*/ (long)1) < 0)
- bb_perror_msg_and_die("TIOCSCTTY");
+ bb_simple_perror_msg_and_die("TIOCSCTTY");
}
#ifdef __linux__
/* Make ourself a foreground process group within our session */
if (tcsetpgrp(STDIN_FILENO, pid) < 0)
- bb_perror_msg_and_die("tcsetpgrp");
+ bb_simple_perror_msg_and_die("tcsetpgrp");
#endif
/*
* 5 seconds seems to be a good value.
*/
if (tcgetattr(STDIN_FILENO, &G.tty_attrs) < 0)
- bb_perror_msg_and_die("tcgetattr");
+ bb_simple_perror_msg_and_die("tcgetattr");
/* Update the utmp file. This tty is ours now! */
update_utmp(pid, LOGIN_PROCESS, G.tty_name, "LOGIN", G.fakehost);
opt = getopt32(argv, "f:h:p", &opt_user, &opt_host);
if (opt & LOGIN_OPT_f) {
if (!run_by_root)
- bb_error_msg_and_die("-f is for root only");
+ bb_simple_error_msg_and_die("-f is for root only");
safe_strncpy(username, opt_user, sizeof(username));
}
argv += optind;
child_pid = vfork();
if (child_pid != 0) {
if (child_pid < 0)
- bb_perror_msg("vfork");
+ bb_simple_perror_msg("vfork");
else {
wait_for_exitstatus(child_pid);
update_utmp_DEAD_PROCESS(child_pid);
syslog(LOG_NOTICE, "%c %s %s:%s",
'-', tty, old_user, opt_username);
bb_do_delay(LOGIN_FAIL_DELAY);
- bb_error_msg_and_die("incorrect password");
+ bb_simple_error_msg_and_die("incorrect password");
}
if (ENABLE_FEATURE_CLEAN_UP && ENABLE_FEATURE_SU_SYSLOG) {
* probably a uucp account or has restricted access. Don't
* compromise the account by allowing access with a standard
* shell. */
- bb_error_msg("using restricted shell");
+ bb_simple_error_msg("using restricted shell");
opt_shell = NULL; /* ignore -s PROG */
}
/* else: user can run whatever he wants via "su -s PROG USER".
pwd = getpwuid(0);
if (!pwd) {
- bb_error_msg_and_die("no password entry for root");
+ bb_simple_error_msg_and_die("no password entry for root");
}
while (1) {
);
if (r < 0) {
/* ^D, ^C, timeout, or read error */
- bb_info_msg("normal startup");
+ bb_simple_info_msg("normal startup");
return 0;
}
if (r > 0) {
break;
}
bb_do_delay(LOGIN_FAIL_DELAY);
- bb_info_msg("Login incorrect");
+ bb_simple_info_msg("Login incorrect");
}
- bb_info_msg("starting shell for system maintenance");
+ bb_simple_info_msg("starting shell for system maintenance");
IF_SELINUX(renew_current_security_context());
{
#define err signo
if (SIGALRM == signo) {
- bb_error_msg_and_die("timed out");
+ bb_simple_error_msg_and_die("timed out");
}
// SIGCHLD. reap zombies
if (fname) {
size = fread((char *)src_buf, 1, SRC_BUF_SIZE, fp);
if ((ssize_t)size < 0)
- bb_perror_msg_and_die(bb_msg_read_error);
+ bb_simple_perror_msg_and_die(bb_msg_read_error);
} else {
size = len;
if (len > SRC_BUF_SIZE)
G.pass = xmalloc_reads(fd, /* maxsize: */ NULL);
}
if (!G.user || !*G.user || !G.pass)
- bb_error_msg_and_die("no username or password");
+ bb_simple_error_msg_and_die("no username or password");
}
fp = popen(delivery, "w");
unsetenv("FILENAME");
if (!fp) {
- bb_perror_msg("delivery helper");
+ bb_simple_perror_msg("delivery helper");
break;
}
} else
smtp_check(NULL, 250);
else
if (code != 250)
- bb_error_msg_and_die("SMTP init failed");
+ bb_simple_error_msg_and_die("SMTP init failed");
} else {
// vanilla connection
int fd;
{
fflush_all();
if (ferror(stdout) || ferror(stderr))
- bb_perror_msg_and_die("output error");
+ bb_simple_perror_msg_and_die("output error");
}
#if ENABLE_FEATURE_CLEAN_UP
static void quit(void)
{
if (ferror(stdin))
- bb_perror_msg_and_die("input error");
+ bb_simple_perror_msg_and_die("input error");
fflush_and_check();
dbg_exec("quit(): exiting with exitcode SUCCESS");
exit(0);
goto get_char;
if (c == EOF) {
if (ferror(fp))
- bb_perror_msg_and_die("input error");
+ bb_simple_perror_msg_and_die("input error");
// Note: EOF does not append '\n'
break;
}
ip = (void*)G.prog.exestack.v;
#if SANITY_CHECKS
if (G.prog.exestack.len != 1) // should have only main's IP
- bb_error_msg_and_die("BUG:call stack");
+ bb_simple_error_msg_and_die("BUG:call stack");
if (ip->func != BC_PROG_MAIN)
- bb_error_msg_and_die("BUG:not MAIN");
+ bb_simple_error_msg_and_die("BUG:not MAIN");
#endif
f = xc_program_func_BC_PROG_MAIN();
// bc discards strings, constants and code after each
if (IS_BC) {
#if SANITY_CHECKS
if (G.prog.results.len != 0) // should be empty
- bb_error_msg_and_die("BUG:data stack");
+ bb_simple_error_msg_and_die("BUG:data stack");
#endif
IF_BC(bc_vec_pop_all(&f->strs);)
IF_BC(bc_vec_pop_all(&f->consts);)
} else if (DIR_SAY == key) {
// just print argument verbatim
// TODO: should we use full_write() to avoid unistd/stdio conflict?
- bb_error_msg("%s", arg);
+ bb_simple_error_msg(arg);
}
// next, please!
argv++;
logmode = sv_logmode;
if (pid < 0) {
- bb_perror_msg("vfork");
+ bb_simple_perror_msg("vfork");
err:
pid = 0;
} /* else: PARENT, FORK SUCCESS */
bb_error_msg_and_die("can't execute '%s' for user %s", shell, user);
}
if (pid < 0) {
- bb_perror_msg("vfork");
+ bb_simple_perror_msg("vfork");
err:
pid = 0;
}
if (sanitize_env_if_suid()) { /* Clears dangerous stuff, sets PATH */
/* Run by non-root */
if (opt_ler & (OPT_u|OPT_c))
- bb_error_msg_and_die(bb_msg_you_must_be_root);
+ bb_simple_error_msg_and_die(bb_msg_you_must_be_root);
}
if (opt_ler & OPT_u) {
{
unsigned p = pointer;
if (p == 0)
- bb_error_msg_and_die("stack underflow");
+ bb_simple_error_msg_and_die("stack underflow");
return p - 1;
}
static void push(double a)
{
if (pointer >= STACK_SIZE)
- bb_error_msg_and_die("stack overflow");
+ bb_simple_error_msg_and_die("stack overflow");
stack[pointer++] = a;
}
/* Busybox stuff */
#if ENABLE_DEVFSD_VERBOSE || ENABLE_DEBUG
#define info_logger(p, fmt, args...) bb_info_msg(fmt, ## args)
+#define simple_info_logger(p, msg) bb_simple_info_msg(msg)
#define msg_logger(p, fmt, args...) bb_error_msg(fmt, ## args)
+#define simple_msg_logger(p, msg) bb_simple_error_msg(msg)
#define msg_logger_and_die(p, fmt, args...) bb_error_msg_and_die(fmt, ## args)
+#define simple_msg_logger_and_die(p, msg) bb_simple_error_msg_and_die(msg)
#define error_logger(p, fmt, args...) bb_perror_msg(fmt, ## args)
#define error_logger_and_die(p, fmt, args...) bb_perror_msg_and_die(fmt, ## args)
#else
#define info_logger(p, fmt, args...)
#define msg_logger(p, fmt, args...)
+#define simple_msg_logger(p, msg)
#define msg_logger_and_die(p, fmt, args...) exit(EXIT_FAILURE)
+#define simple_msg_logger_and_die(p, msg) exit(EXIT_FAILURE)
#define error_logger(p, fmt, args...)
#define error_logger_and_die(p, fmt, args...) exit(EXIT_FAILURE)
#endif
caught_sighup = FALSE;
return c_sighup;
}
- msg_logger_and_die(LOG_ERR, "read error on control file");
+ simple_msg_logger_and_die(LOG_ERR, "read error on control file");
} /* End Function do_servicing */
static void service_name(const struct devfsd_notify_struct *info)
action_compat(info, entry->action.what);
break;
default:
- msg_logger_and_die(LOG_ERR, "Unknown action");
+ simple_msg_logger_and_die(LOG_ERR, "Unknown action");
}
}
} /* End Function service_name */
}
return FALSE;
st_expr_expand_out:
- info_logger(LOG_INFO, bb_msg_small_buffer);
+ simple_info_logger(LOG_INFO, bb_msg_small_buffer);
return FALSE;
} /* End Function st_expr_expand */
return input + len;
}
if (ch != ':' || ptr[1] != '-') {
- info_logger(LOG_INFO, "illegal char in var name");
+ simple_info_logger(LOG_INFO, "illegal char in var name");
return NULL;
}
/* It's that handy "${var:-word}" expression. Check if var is defined */
*out_pos += len;
return input;
expand_variable_out:
- info_logger(LOG_INFO, bb_msg_small_buffer);
+ simple_info_logger(LOG_INFO, bb_msg_small_buffer);
return NULL;
} /* End Function expand_variable */
fd,
target & ~(off_t)(page_size - 1));
if (map_base == MAP_FAILED)
- bb_perror_msg_and_die("mmap");
+ bb_simple_perror_msg_and_die("mmap");
// printf("Memory mapped at address %p.\n", map_base);
read_result = *(volatile uint64_t*)virt_addr;
break;
default:
- bb_error_msg_and_die("bad width");
+ bb_simple_error_msg_and_die("bad width");
}
// printf("Value at address 0x%"OFF_FMT"X (%p): 0x%llX\n",
// target, virt_addr,
// read_result = *(volatile uint64_t*)virt_addr;
break;
default:
- bb_error_msg_and_die("bad width");
+ bb_simple_error_msg_and_die("bad width");
}
// printf("Written 0x%llX; readback 0x%llX\n",
// (unsigned long long)writeval,
if (ENABLE_FEATURE_CLEAN_UP) {
if (munmap(map_base, mapped_size) == -1)
- bb_perror_msg_and_die("munmap");
+ bb_simple_perror_msg_and_die("munmap");
close(fd);
}
(G.scr_var.yres_virtual ?: G.scr_var.yres) * G.scr_fix.line_length,
PROT_WRITE, MAP_SHARED, fbfd, 0);
if (G.addr == MAP_FAILED)
- bb_perror_msg_and_die("mmap");
+ bb_simple_perror_msg_and_die("mmap");
// point to the start of the visible screen
G.addr += G.scr_var.yoffset * G.scr_fix.line_length + G.scr_var.xoffset * G.bytes_per_pixel;
if (clmlen > 8)
clmlen = 8;
if (clmlen == 0)
- bb_error_msg_and_die("autoplacement selected and no empty space in oob");
+ bb_simple_error_msg_and_die("autoplacement selected and no empty space in oob");
} else {
/* Legacy mode */
switch (meminfo.oobsize) {
if (errno == EOPNOTSUPP) {
flags |= OPTION_N;
if (flags & IS_NAND)
- bb_error_msg_and_die("bad block check not available");
+ bb_simple_error_msg_and_die("bad block check not available");
} else {
- bb_perror_msg_and_die("MEMGETBADBLOCK error");
+ bb_simple_perror_msg_and_die("MEMGETBADBLOCK error");
}
}
}
like_std = 3;
} else
/* "Unknown device type:\n\tbits 15&14 of general configuration word 0 both set to 1.\n" */
- bb_error_msg_and_die("unknown device type");
+ bb_simple_error_msg_and_die("unknown device type");
printf("%sremovable media\n", !(val[GEN_CONFIG] & MEDIA_REMOVABLE) ? "non-" : "");
/* Info from the specific configuration word says whether or not the
sleep(1);
if (ioctl(fd, HDIO_DRIVE_CMD, NULL) && errno != EINVAL) { /* await completion */
if (ENABLE_IOCTL_HEX2STR_ERROR) /* To be coherent with ioctl_or_warn */
- bb_perror_msg("HDIO_DRIVE_CMD");
+ bb_simple_perror_msg("HDIO_DRIVE_CMD");
else
bb_perror_msg("ioctl %#x failed", HDIO_DRIVE_CMD);
}
char *buf = xmalloc(TIMING_BUF_BYTES);
if (mlock(buf, TIMING_BUF_BYTES))
- bb_perror_msg_and_die("mlock");
+ bb_simple_perror_msg_and_die("mlock");
/* Clear out the device request queues & give them time to complete.
* NB: *small* delay. User is expected to have a clue and to not run
char buf[512];
flush_buffer_cache();
if (-1 == read(fd, buf, sizeof(buf)))
- bb_perror_msg("read of 512 bytes failed");
+ bb_simple_perror_msg("read of 512 bytes failed");
}
#endif /* HDIO_DRIVE_CMD */
if (getset_mult || get_identity) {
if (ioctl(fd, HDIO_GET_MULTCOUNT, &multcount)) {
/* To be coherent with ioctl_or_warn. */
if (getset_mult && ENABLE_IOCTL_HEX2STR_ERROR)
- bb_perror_msg("HDIO_GET_MULTCOUNT");
+ bb_simple_perror_msg("HDIO_GET_MULTCOUNT");
else
bb_perror_msg("ioctl %#x failed", HDIO_GET_MULTCOUNT);
} else if (getset_mult) {
} else if (errno == -ENOMSG)
puts(" no identification info available");
else if (ENABLE_IOCTL_HEX2STR_ERROR) /* To be coherent with ioctl_or_warn */
- bb_perror_msg("HDIO_GET_IDENTITY");
+ bb_simple_perror_msg("HDIO_GET_IDENTITY");
else
bb_perror_msg("ioctl %#x failed", HDIO_GET_IDENTITY);
}
);
if (G.baseaddr == MAP_FAILED) {
restore_term();
- bb_perror_msg_and_die("mmap");
+ bb_simple_perror_msg_and_die("mmap");
}
G.current_byte = G.baseaddr + cur_pos;
static void check_funcs_test_end(int funcs, int pec, const char *err)
{
if (pec && !(funcs & (I2C_FUNC_SMBUS_PEC | I2C_FUNC_I2C)))
- bb_error_msg("warning: adapter does not support PEC");
+ bb_simple_error_msg("warning: adapter does not support PEC");
if (err)
bb_error_msg_and_die(
break;
#endif /* ENABLE_I2CDUMP */
default:
- bb_error_msg_and_die("internal error");
+ bb_simple_error_msg_and_die("internal error");
}
check_funcs_test_end(funcs, pec, err);
}
{
fprintf(stderr, "Continue? [y/N] ");
if (!bb_ask_y_confirmation())
- bb_error_msg_and_die("aborting");
+ bb_simple_error_msg_and_die("aborting");
}
/*
*/
static void confirm_action(int bus_addr, int mode, int data_addr, int pec)
{
- bb_error_msg("WARNING! This program can confuse your I2C bus");
+ bb_simple_error_msg("WARNING! This program can confuse your I2C bus");
/* Don't let the user break his/her EEPROMs */
if (bus_addr >= 0x50 && bus_addr <= 0x57 && pec) {
- bb_error_msg_and_die("this is I2C not smbus - using PEC on I2C "
+ bb_simple_error_msg_and_die("this is I2C not smbus - using PEC on I2C "
"devices may result in data loss, aborting");
}
if (mode == I2C_SMBUS_BYTE && data_addr >= 0 && pec)
- bb_error_msg("WARNING! May interpret a write byte command "
+ bb_simple_error_msg("WARNING! May interpret a write byte command "
"with PEC as a write byte data command");
if (pec)
- bb_error_msg("PEC checking enabled");
+ bb_simple_error_msg("PEC checking enabled");
confirm_or_abort();
}
case 'w': mode = I2C_SMBUS_WORD_DATA; break;
case 'c': mode = I2C_SMBUS_BYTE; break;
default:
- bb_error_msg("invalid mode");
+ bb_simple_error_msg("invalid mode");
bb_show_usage();
}
pec = argv[3][1] == 'p';
if (data_addr >= 0) {
status = i2c_smbus_write_byte(fd, data_addr);
if (status < 0)
- bb_error_msg("warning - write failed");
+ bb_simple_error_msg("warning - write failed");
}
status = i2c_smbus_read_byte(fd);
break;
close(fd);
if (status < 0)
- bb_perror_msg_and_die("read failed");
+ bb_simple_perror_msg_and_die("read failed");
printf("0x%0*x\n", mode == I2C_SMBUS_WORD_DATA ? 4 : 2, status);
case 'i': mode = I2C_SMBUS_I2C_BLOCK_DATA;
break;
default:
- bb_error_msg("invalid mode");
+ bb_simple_error_msg("invalid mode");
bb_show_usage();
}
|| mode == I2C_SMBUS_I2C_BLOCK_DATA
) {
if (pec && mode == I2C_SMBUS_I2C_BLOCK_DATA)
- bb_error_msg_and_die(
+ bb_simple_error_msg_and_die(
"PEC not supported for I2C "
"block writes");
if (opts & opt_m)
- bb_error_msg_and_die(
+ bb_simple_error_msg_and_die(
"mask not supported for block "
"writes");
}
}
if (tmpval < 0)
- bb_perror_msg_and_die("can't read old value");
+ bb_simple_perror_msg_and_die("can't read old value");
val = (val & mask) | (tmpval & ~mask);
break;
}
if (status < 0)
- bb_perror_msg_and_die("write failed");
+ bb_simple_perror_msg_and_die("write failed");
if (pec)
i2c_set_pec(fd, 0); /* Clear PEC. */
case 's': mode = I2C_SMBUS_BLOCK_DATA; break;
case 'i': mode = I2C_SMBUS_I2C_BLOCK_DATA; break;
default:
- bb_error_msg_and_die("invalid mode");
+ bb_simple_error_msg_and_die("invalid mode");
}
if (argv[2][1] == 'p') {
if (argv[2][0] == 'W' || argv[2][0] == 'i') {
- bb_error_msg_and_die(
+ bb_simple_error_msg_and_die(
"pec not supported for -W and -i");
} else {
pec = 1;
if (opts & opt_r) {
first = strtol(opt_r_str, &dash, 0);
if (dash == opt_r_str || *dash != '-' || first > 0xff)
- bb_error_msg_and_die("invalid range");
+ bb_simple_error_msg_and_die("invalid range");
last = xstrtou_range(++dash, 0, first, 0xff);
/* Range is not available for every mode. */
break;
/* Fall through */
default:
- bb_error_msg_and_die(
+ bb_simple_error_msg_and_die(
"range not compatible with selected mode");
}
}
if (mode == I2C_SMBUS_BYTE) {
res = i2c_smbus_write_byte(fd, first);
if (res < 0)
- bb_perror_msg_and_die("write start address");
+ bb_simple_perror_msg_and_die("write start address");
}
dump_data(fd, mode, first, last, block, blen);
get_funcs_matrix(fd, &funcs);
if (!(funcs & I2C_FUNC_I2C))
- bb_error_msg_and_die("adapter does not support I2C transfers");
+ bb_simple_error_msg_and_die("adapter does not support I2C transfers");
}
//usage:#define i2ctransfer_trivial_usage
char *end;
if (nmsgs >= I2C_RDWR_IOCTL_MAX_MSGS)
- bb_error_msg_and_die("too many messages, max: "I2C_RDWR_IOCTL_MAX_MSGS_STR);
+ bb_simple_error_msg_and_die("too many messages, max: "I2C_RDWR_IOCTL_MAX_MSGS_STR);
flags = 0;
arg_ptr = *argv;
// open inotify
pfd.fd = inotify_init();
if (pfd.fd < 0)
- bb_perror_msg_and_die("no kernel support");
+ bb_simple_perror_msg_and_die("no kernel support");
// setup watches
while (*++argv) {
if (block_offset >= meminfo->size) {
if (IS_NANDWRITE)
- bb_error_msg_and_die("not enough space in MTD device");
+ bb_simple_error_msg_and_die("not enough space in MTD device");
return block_offset; /* let the caller exit */
}
offs = block_offset;
meminfo_writesize = meminfo.writesize;
if (mtdoffset & (meminfo_writesize - 1))
- bb_error_msg_and_die("start address is not page aligned");
+ bb_simple_error_msg_and_die("start address is not page aligned");
filebuf = xmalloc(meminfo_writesize);
oobbuf = xmalloc(meminfo.oobsize);
}
if (cnt < meminfo_writesize) {
if (IS_NANDDUMP)
- bb_error_msg_and_die("short read");
+ bb_simple_error_msg_and_die("short read");
if (!(opts & OPT_p))
- bb_error_msg_and_die("input size is not rounded up to page size, "
+ bb_simple_error_msg_and_die("input size is not rounded up to page size, "
"use -p to zero pad");
/* zero pad to end of write block */
memset(filebuf + cnt, 0, meminfo_writesize - cnt);
/* We filled entire MTD, but did we reach EOF on input? */
if (full_read(STDIN_FILENO, filebuf, meminfo_writesize) != 0) {
/* no */
- bb_error_msg_and_die("not enough space in MTD device");
+ bb_simple_error_msg_and_die("not enough space in MTD device");
}
}
rf_fd = device_open("/dev/rfkill", mode);
if (rf_fd < 0)
- bb_perror_msg_and_die("/dev/rfkill");
+ bb_simple_perror_msg_and_die("/dev/rfkill");
if (rf_opt & OPT_l) {
while (full_read(rf_fd, &event, sizeof(event)) == RFKILL_EVENT_SIZE_V1) {
/* Write previously received block */
errno = 0;
if (full_write(file_fd, blockBuf, blockLength) != blockLength) {
- bb_perror_msg(bb_msg_write_error);
+ bb_simple_perror_msg(bb_msg_write_error);
goto fatal;
}
goto timeout;
if (blockNo != (255 - blockNoOnesCompl)) {
- bb_error_msg("bad block ones compl");
+ bb_simple_error_msg("bad block ones compl");
goto error;
}
do_crc = 0;
goto timeout;
}
- bb_error_msg("too many errors; giving up");
+ bb_simple_error_msg("too many errors; giving up");
fatal:
/* 5 CAN followed by 5 BS. Don't try too hard... */
safe_write(write_fd, "\030\030\030\030\030\010\010\010\010\010", 10);
* returns the child process, set the time the command finished. */
while ((caught = wait3(&resp->waitstatus, 0, &resp->ru)) != pid) {
if (caught == -1 && errno != EINTR) {
- bb_perror_msg("wait");
+ bb_simple_perror_msg("wait");
return;
}
}
// bb_error_msg_and_die("%s invalid maximum size calculated", "UBI");
} else
if (!(opts & OPTION_s))
- bb_error_msg_and_die("size not specified");
+ bb_simple_error_msg_and_die("size not specified");
if (!(opts & OPTION_N))
- bb_error_msg_and_die("name not specified");
+ bb_simple_error_msg_and_die("name not specified");
/* the structure is memset(0) above */
mkvol_req.vol_id = vol_id;
//usage: "\n -N VOLNAME Volume name"
if (do_rmvol) {
if (!(opts & (OPTION_n|OPTION_N)))
- bb_error_msg_and_die("volume id not specified");
+ bb_simple_error_msg_and_die("volume id not specified");
if (opts & OPTION_N) {
unsigned num = ubi_devnum_from_devname(ubi_ctrl);
//usage: "\n -s SIZE Size in bytes"
if (do_rsvol) {
if (!(opts & OPTION_s))
- bb_error_msg_and_die("size not specified");
+ bb_simple_error_msg_and_die("size not specified");
if (!(opts & OPTION_n))
- bb_error_msg_and_die("volume id not specified");
+ bb_simple_error_msg_and_die("volume id not specified");
rsvol_req.bytes = size_bytes; /* signed int64_t */
rsvol_req.vol_id = vol_id;
rnvol = xzalloc(sizeof(*rnvol));
rnvol->count = --argc;
if (argc > ARRAY_SIZE(rnvol->ents))
- bb_error_msg_and_die("too many renames requested");
+ bb_simple_error_msg_and_die("too many renames requested");
ubi_devname = argv[1];
ubi_devnum = ubi_devnum_from_devname(ubi_devname);
module_names = xrealloc(module_names, bufsize);
goto retry_modules_load;
}
- bb_perror_msg_and_die("QM_MODULES");
+ bb_simple_perror_msg_and_die("QM_MODULES");
}
n_ext_modules = nmod = ret;
syms = xrealloc(syms, bufsize);
goto retry_kern_sym_load;
}
- bb_perror_msg_and_die("kernel: QM_SYMBOLS");
+ bb_simple_perror_msg_and_die("kernel: QM_SYMBOLS");
}
nksyms = nsyms = ret;
ksyms = syms;
f->load_order_search_start = &f->load_order;
if (image_size < sizeof(f->header))
- bb_error_msg_and_die("error while loading ELF header");
+ bb_simple_error_msg_and_die("error while loading ELF header");
memcpy(&f->header, image, sizeof(f->header));
if (*(aliased_uint32_t*)(&f->header.e_ident) != ELFMAG_U32) {
- bb_error_msg_and_die("not an ELF file");
+ bb_simple_error_msg_and_die("not an ELF file");
}
if (f->header.e_ident[EI_CLASS] != ELFCLASSM
|| f->header.e_ident[EI_DATA] != (BB_BIG_ENDIAN ? ELFDATA2MSB : ELFDATA2LSB)
|| f->header.e_ident[EI_VERSION] != EV_CURRENT
|| !MATCH_MACHINE(f->header.e_machine)
) {
- bb_error_msg_and_die("ELF file not for this architecture");
+ bb_simple_error_msg_and_die("ELF file not for this architecture");
}
if (f->header.e_type != ET_REL) {
- bb_error_msg_and_die("ELF file not a relocatable object");
+ bb_simple_error_msg_and_die("ELF file not a relocatable object");
}
/* Read the section headers. */
section_headers = alloca(sizeof(ElfW(Shdr)) * shnum);
if (image_size < f->header.e_shoff + sizeof(ElfW(Shdr)) * shnum)
- bb_error_msg_and_die("error while loading section headers");
+ bb_simple_error_msg_and_die("error while loading section headers");
memcpy(section_headers, image + f->header.e_shoff, sizeof(ElfW(Shdr)) * shnum);
/* Read the section data. */
if (sec->header.sh_size > 0) {
sec->contents = xmalloc(sec->header.sh_size);
if (image_size < (sec->header.sh_offset + sec->header.sh_size))
- bb_error_msg_and_die("error while loading section data");
+ bb_simple_error_msg_and_die("error while loading section data");
memcpy(sec->contents, image + sec->header.sh_offset, sec->header.sh_size);
}
break;
#if SHT_RELM == SHT_REL
case SHT_RELA:
- bb_error_msg_and_die("RELA relocations not supported on this architecture");
+ bb_simple_error_msg_and_die("RELA relocations not supported on this architecture");
#else
case SHT_REL:
- bb_error_msg_and_die("REL relocations not supported on this architecture");
+ bb_simple_error_msg_and_die("REL relocations not supported on this architecture");
#endif
default:
if (sec->header.sh_type >= SHT_LOPROC) {
continue;
sec->contents = imagebase + (sec->header.sh_addr - base);
if (image_size < (sec->header.sh_offset + sec->header.sh_size)) {
- bb_error_msg("error reading ELF section data");
+ bb_simple_error_msg("error reading ELF section data");
return 0; /* need to delete half-loaded module! */
}
memcpy(sec->contents, image + sec->header.sh_offset, sec->header.sh_size);
if (m_has_modinfo) {
int m_version = new_get_module_version(f, m_strversion);
if (m_version == -1) {
- bb_error_msg_and_die("can't find the kernel version "
+ bb_simple_error_msg_and_die("can't find the kernel version "
"the module was compiled for");
}
}
#endif
if (query_module(NULL, 0, NULL, 0, NULL))
- bb_error_msg_and_die("old (unsupported) kernel");
+ bb_simple_error_msg_and_die("old (unsupported) kernel");
new_get_kernel_symbols();
k_crcs = new_is_kernel_checksummed();
/* Unload _all_ unused modules via NULL delete_module() call */
err = bb_delete_module(NULL, flags);
if (err && err != EFAULT)
- bb_perror_msg_and_die("rmmod");
+ bb_simple_perror_msg_and_die("rmmod");
return EXIT_SUCCESS;
}
/* Resolve the host name. */
host = *args;
if (ap->input(host, &sa) < 0) {
- bb_herror_msg_and_die("%s", host);
+ bb_simple_herror_msg_and_die(host);
}
/* If a host has more than one address, use the correct one! */
#ifdef HAVE_ATF_DONTPUB
req.arp_flags |= ATF_DONTPUB;
#else
- bb_error_msg("feature ATF_DONTPUB is not supported");
+ bb_simple_error_msg("feature ATF_DONTPUB is not supported");
#endif
args++;
break;
#ifdef HAVE_ATF_MAGIC
req.arp_flags |= ATF_MAGIC;
#else
- bb_error_msg("feature ATF_MAGIC is not supported");
+ bb_simple_error_msg("feature ATF_MAGIC is not supported");
#endif
args++;
break;
if (strcmp(*args, "255.255.255.255") != 0) {
host = *args;
if (ap->input(host, &sa) < 0) {
- bb_herror_msg_and_die("%s", host);
+ bb_simple_herror_msg_and_die(host);
}
memcpy(&req.arp_netmask, &sa, sizeof(struct sockaddr));
req.arp_flags |= ATF_NETMASK;
/* Call the kernel. */
if (flags & 2) {
if (option_mask32 & ARP_OPT_v)
- bb_error_msg("SIOCDARP(nopub)");
+ bb_simple_error_msg("SIOCDARP(nopub)");
err = ioctl(sockfd, SIOCDARP, &req);
if (err < 0) {
if (errno == ENXIO) {
printf("No ARP entry for %s\n", host);
return -1;
}
- bb_perror_msg_and_die("SIOCDARP(priv)");
+ bb_simple_perror_msg_and_die("SIOCDARP(priv)");
}
}
if ((flags & 1) && err) {
nopub:
req.arp_flags |= ATF_PUBL;
if (option_mask32 & ARP_OPT_v)
- bb_error_msg("SIOCDARP(pub)");
+ bb_simple_error_msg("SIOCDARP(pub)");
if (ioctl(sockfd, SIOCDARP, &req) < 0) {
if (errno == ENXIO) {
printf("No ARP entry for %s\n", host);
return -1;
}
- bb_perror_msg_and_die("SIOCDARP(pub)");
+ bb_simple_perror_msg_and_die("SIOCDARP(pub)");
}
}
return 0;
ioctl_or_perror_and_die(sockfd, SIOCGIFHWADDR, &ifr,
"can't get HW-Address for '%s'", ifname);
if (hw_set && (ifr.ifr_hwaddr.sa_family != hw->type)) {
- bb_error_msg_and_die("protocol type mismatch");
+ bb_simple_error_msg_and_die("protocol type mismatch");
}
memcpy(sa, &(ifr.ifr_hwaddr), sizeof(struct sockaddr));
host = *args++;
if (ap->input(host, &sa) < 0) {
- bb_herror_msg_and_die("%s", host);
+ bb_simple_herror_msg_and_die(host);
}
/* If a host has more than one address, use the correct one! */
memcpy(&req.arp_pa, &sa, sizeof(struct sockaddr));
/* Fetch the hardware address. */
if (*args == NULL) {
- bb_error_msg_and_die("need hardware address");
+ bb_simple_error_msg_and_die("need hardware address");
}
if (option_mask32 & ARP_OPT_D) {
arp_getdevhw(*args++, &req.arp_ha);
} else {
if (hw->input(*args++, &req.arp_ha) < 0) {
- bb_error_msg_and_die("invalid hardware address");
+ bb_simple_error_msg_and_die("invalid hardware address");
}
}
#ifdef HAVE_ATF_DONTPUB
flags |= ATF_DONTPUB;
#else
- bb_error_msg("feature ATF_DONTPUB is not supported");
+ bb_simple_error_msg("feature ATF_DONTPUB is not supported");
#endif
args++;
break;
#ifdef HAVE_ATF_MAGIC
flags |= ATF_MAGIC;
#else
- bb_error_msg("feature ATF_MAGIC is not supported");
+ bb_simple_error_msg("feature ATF_MAGIC is not supported");
#endif
args++;
break;
if (strcmp(*args, "255.255.255.255") != 0) {
host = *args;
if (ap->input(host, &sa) < 0) {
- bb_herror_msg_and_die("%s", host);
+ bb_simple_herror_msg_and_die(host);
}
memcpy(&req.arp_netmask, &sa, sizeof(struct sockaddr));
flags |= ATF_NETMASK;
/* Call the kernel. */
if (option_mask32 & ARP_OPT_v)
- bb_error_msg("SIOCSARP()");
+ bb_simple_error_msg("SIOCSARP()");
xioctl(sockfd, SIOCSARP, &req);
return 0;
}
if (name != NULL) {
/* Resolve the host name. */
if (ap->input(name, &sa) < 0) {
- bb_herror_msg_and_die("%s", name);
+ bb_simple_herror_msg_and_die(name);
}
host = xstrdup(ap->sprint(&sa, 1));
}
/* Now see what we have to do here... */
if (opts & (ARP_OPT_d | ARP_OPT_s)) {
if (argv[0] == NULL)
- bb_error_msg_and_die("need host name");
+ bb_simple_error_msg_and_die("need host name");
if (opts & ARP_OPT_s)
return arp_set(argv);
return arp_del(argv);
xconnect(probe_fd, (struct sockaddr *) &G.probe_saddr, sizeof(G.probe_saddr));
bb_getsockname(probe_fd, (struct sockaddr *) &G.probe_saddr, sizeof(G.probe_saddr));
if (G.probe_saddr.sin_family != AF_INET)
- bb_error_msg_and_die("no IP address configured");
+ bb_simple_error_msg_and_die("no IP address configured");
src = G.probe_saddr.sin_addr;
}
close(probe_fd);
/* Don't allow SIGALRMs while we process the reply */
sigprocmask(SIG_BLOCK, &G.sset, NULL);
if (cc < 0) {
- bb_perror_msg("recvfrom");
+ bb_simple_perror_msg("recvfrom");
continue;
}
recv_pack(G.packet, cc, &from);
head = (struct dns_head *)buf;
if (head->nquer == 0) {
- bb_error_msg("packet has 0 queries, ignored");
+ bb_simple_error_msg("packet has 0 queries, ignored");
return 0; /* don't reply */
}
if (head->flags & htons(0x8000)) { /* QR bit */
- bb_error_msg("response packet, ignored");
+ bb_simple_error_msg("response packet, ignored");
return 0; /* don't reply */
}
/* QR = 1 "response", RCODE = 4 "Not Implemented" */
* RCODE = 0 "success"
*/
if (OPT_verbose)
- bb_info_msg("returning positive reply");
+ bb_simple_info_msg("returning positive reply");
outr_flags = htons(0x8000 | 0x0400 | 0);
/* we have one answer */
head->nansw = htons(1);
continue;
}
if (OPT_verbose)
- bb_info_msg("got UDP packet");
+ bb_simple_info_msg("got UDP packet");
buf[r] = '\0'; /* paranoia */
r = process_packet(conf_data, conf_ttl, buf);
if (r <= 0)
byte_cnt = sscanf(ethoptarg, "%u.%u.%u.%u",
&passwd[0], &passwd[1], &passwd[2], &passwd[3]);
if (byte_cnt < 4) {
- bb_error_msg("can't read Wake-On-LAN pass");
+ bb_simple_error_msg("can't read Wake-On-LAN pass");
return 0;
}
// TODO: check invalid numbers >255??
/* This is necessary for broadcasts to work */
if (flags /* & 1 OPT_BROADCAST */) {
if (setsockopt_broadcast(s) != 0)
- bb_perror_msg("SO_BROADCAST");
+ bb_simple_perror_msg("SO_BROADCAST");
}
#if defined(PF_PACKET)
struct stat sbuf;
/* lstat would be wrong here! */
if (stat(local_path, &sbuf) < 0) {
- bb_perror_msg_and_die("stat");
+ bb_simple_perror_msg_and_die("stat");
}
if (sbuf.st_size > 0) {
beg_range = sbuf.st_size;
} else if (sethostname(s, strlen(s))) {
// if (errno == EPERM)
// bb_error_msg_and_die(bb_msg_perm_denied_are_you_root);
- bb_perror_msg_and_die("sethostname");
+ bb_simple_perror_msg_and_die("sethostname");
}
}
*/
if (verbose > 2)
- bb_error_msg("closed");
+ bb_simple_error_msg("closed");
_exit(xfunc_error_retval);
}
}
if (full_write(STDOUT_FILENO, iobuf, len) != len) {
if (verbose > 1)
- bb_perror_msg("error");
+ bb_simple_perror_msg("error");
log_and_exit();
}
}
if (count < 0) {
IF_FEATURE_USE_SENDFILE(fin:)
if (verbose > 1)
- bb_perror_msg("error");
+ bb_simple_perror_msg("error");
}
log_and_exit();
}
if (rmt_ip_str)
applet_name = rmt_ip_str;
if (verbose > 2)
- bb_error_msg("connected");
+ bb_simple_error_msg("connected");
}
if_ip_denied_send_HTTP_FORBIDDEN_and_exit(remote_ip);
if (opt & OPT_SETUID) {
if (ugid.gid != (gid_t)-1) {
if (setgroups(1, &ugid.gid) == -1)
- bb_perror_msg_and_die("setgroups");
+ bb_simple_perror_msg_and_die("setgroups");
xsetgid(ugid.gid);
}
xsetuid(ugid.uid);
#if ENABLE_FEATURE_IFCONFIG_STATUS
return display_interfaces(argv[0] ? argv[0] : show_all_param);
#else
- bb_error_msg_and_die("no support for status display");
+ bb_simple_error_msg_and_die("no support for status display");
#endif
}
if (!(ifrequest.ifr_flags & IFF_UP)) {
ifrequest.ifr_flags |= IFF_UP;
/* Let user know we mess up with interface */
- bb_info_msg("upping interface");
+ bb_simple_info_msg("upping interface");
if (network_ioctl(SIOCSIFFLAGS, &ifrequest, "setting interface flags") < 0) {
if (errno != ENODEV && errno != EADDRNOTAVAIL)
xfunc_die();
else if (option_mask32 & FLAG_IGNORE_FAIL_POSITIVE)
status = IFSTATUS_UP;
else if (G.api_mode[0] == 'a')
- bb_error_msg("can't detect link status");
+ bb_simple_error_msg("can't detect link status");
}
if (status != G.iface_last_status) {
goto ret;
if (errno == EINTR)
continue;
- bb_perror_msg("netlink: recv");
+ bb_simple_perror_msg("netlink: recv");
return -1;
}
mhdr = (struct nlmsghdr*)replybuf;
while (bytes > 0) {
if (!NLMSG_OK(mhdr, bytes)) {
- bb_error_msg("netlink packet too small or truncated");
+ bb_simple_error_msg("netlink packet too small or truncated");
return -1;
}
int attr_len;
if (mhdr->nlmsg_len < NLMSG_LENGTH(sizeof(struct ifinfomsg))) {
- bb_error_msg("netlink packet too small or truncated");
+ bb_simple_error_msg("netlink packet too small or truncated");
return -1;
}
}
if (pid_from_pidfile > 0 && kill(pid_from_pidfile, 0) == 0)
- bb_error_msg_and_die("daemon already running");
+ bb_simple_error_msg_and_die("daemon already running");
#endif
api_mode_found = strchr(api_modes, G.api_mode[0]);
) {
if (errno == EINTR)
continue;
- bb_perror_msg("poll");
+ bb_simple_perror_msg("poll");
goto exiting;
}
exiting:
remove_pidfile(pidfile_name);
- bb_error_msg_and_die("exiting");
+ bb_simple_error_msg_and_die("exiting");
}
if (executable_exists(ext_dhcp_clients[i].name))
return execute(ext_dhcp_clients[i].startcmd, ifd, exec);
}
- bb_error_msg("no dhcp clients found");
+ bb_simple_error_msg("no dhcp clients found");
return 0;
}
# elif ENABLE_UDHCPC
}
if (!result)
- bb_error_msg("warning: no dhcp clients found and stopped");
+ bb_simple_error_msg("warning: no dhcp clients found and stopped");
/* Sleep a bit, otherwise static_down tries to bring down interface too soon,
and it may come back up because udhcpc is still shutting down */
if (bb_getsockname(sep->se_fd, (struct sockaddr *) &ir_sin, sizeof(ir_sin)) < 0) {
//TODO: verify that such failure is even possible in Linux kernel
- bb_perror_msg("getsockname");
+ bb_simple_perror_msg("getsockname");
return;
}
}
if (setrlimit(RLIMIT_NOFILE, &rl) < 0) {
- bb_perror_msg("setrlimit");
+ bb_simple_perror_msg("setrlimit");
return;
}
fd = socket(sep->se_family, sep->se_socktype, 0);
if (fd < 0) {
- bb_perror_msg("socket");
+ bb_simple_perror_msg("socket");
return;
}
setsockopt_reuseaddr(fd);
n = bb_strtou(p, &p, 10);
if (n > INT_MAX) {
bad_ver_spec:
- bb_error_msg("bad rpc version");
+ bb_simple_error_msg("bad rpc version");
goto parse_err;
}
sep->se_rpcver_lo = sep->se_rpcver_hi = n;
if (*p != '\0')
goto bad_ver_spec;
#else
- bb_error_msg("no support for rpc services");
+ bb_simple_error_msg("no support for rpc services");
goto parse_err;
#endif
}
if (argv[0])
config_filename = argv[0];
if (config_filename == NULL)
- bb_error_msg_and_die("non-root must specify config file");
+ bb_simple_error_msg_and_die("non-root must specify config file");
if (!(opt & 2))
bb_daemonize_or_rexec(0, argv - optind);
else
ready_fd_cnt = select(maxsock + 1, &readable, NULL, NULL, NULL);
if (ready_fd_cnt < 0) {
if (errno != EINTR) {
- bb_perror_msg("select");
+ bb_simple_perror_msg("select");
sleep(1);
}
continue;
pid = vfork();
if (pid < 0) { /* fork error */
- bb_perror_msg("vfork"+1);
+ bb_simple_perror_msg("vfork"+1);
sleep(1);
restore_sigmask(&omask);
maybe_close(new_udp_fd);
}
if (real_uid != 0 && real_uid != pwd->pw_uid) {
/* a user running private inetd */
- bb_error_msg("non-root must run services as himself");
+ bb_simple_error_msg("non-root must run services as himself");
goto do_exit1;
}
if (pwd->pw_uid != real_uid) {
}
if (rlim_ofile.rlim_cur != rlim_ofile_cur)
if (setrlimit(RLIMIT_NOFILE, &rlim_ofile) < 0)
- bb_perror_msg("setrlimit");
+ bb_simple_perror_msg("setrlimit");
/* closelog(); - WRONG. we are after vfork,
* this may confuse syslog() internal state.
if (argv[1]) {
if (ENABLE_FEATURE_IPCALC_FANCY && have_netmask) {
- bb_error_msg_and_die("use prefix or netmask, not both");
+ bb_simple_error_msg_and_die("use prefix or netmask, not both");
}
if (inet_aton(argv[1], &s_netmask) == 0) {
bb_error_msg_and_die("bad netmask: %s", argv[1]);
/* Most probably someone gave us wrong fd type
* (for example, non-socket). Don't want
* to loop forever. */
- bb_perror_msg_and_die("accept");
+ bb_simple_perror_msg_and_die("accept");
}
DPRINTF("new_peer(%d)", newfd);
if (n < 0) {
if (errno != EINTR)
- bb_perror_msg("select");
+ bb_simple_perror_msg("select");
continue;
}
//memset(tb, 0, sizeof(tb)); - parse_rtattr does this
parse_rtattr(tb, IFLA_MAX, IFLA_RTA(ifi), len);
if (tb[IFLA_IFNAME] == NULL) {
- bb_error_msg("nil ifname");
+ bb_simple_error_msg("nil ifname");
return -1;
}
if (G_filter.label
static int flush_update(void)
{
if (rtnl_send_check(G_filter.rth, G_filter.flushb, G_filter.flushp) < 0) {
- bb_perror_msg("can't send flush request");
+ bb_simple_perror_msg("can't send flush request");
return -1;
}
G_filter.flushp = 0;
bb_error_msg_and_die(bb_msg_requires_arg, "flush");
}
if (G_filter.family == AF_PACKET) {
- bb_error_msg_and_die("can't flush link addresses");
+ bb_simple_error_msg_and_die("can't flush link addresses");
}
}
if (!d) {
/* There was no "dev IFACE", but we need that */
- bb_error_msg_and_die("need \"dev IFACE\"");
+ bb_simple_error_msg_and_die("need \"dev IFACE\"");
}
if (l && !is_prefixed_with(l, d)) {
bb_error_msg_and_die("\"dev\" (%s) must match \"label\" (%s)", d, l);
inet_prefix brd;
int i;
if (req.ifa.ifa_family != AF_INET) {
- bb_error_msg_and_die("broadcast can be set only for IPv4 addresses");
+ bb_simple_error_msg_and_die("broadcast can be set only for IPv4 addresses");
}
brd = peer;
if (brd.bitlen <= 30) {
static int flush_update(void)
{
if (rtnl_send_check(G_filter.rth, G_filter.flushb, G_filter.flushp) < 0) {
- bb_perror_msg("can't send flush request");
+ bb_simple_perror_msg("can't send flush request");
return -1;
}
G_filter.flushp = 0;
xrtnl_wilddump_request(&rth, G_filter.family, RTM_GETNEIGH);
G_filter.flushed = 0;
if (xrtnl_dump_filter(&rth, print_neigh, NULL) < 0) {
- bb_perror_msg_and_die("flush terminated");
+ bb_simple_perror_msg_and_die("flush terminated");
}
if (G_filter.flushed == 0) {
if (round == 0)
ndm.ndm_family = G_filter.family;
if (rtnl_dump_request(&rth, RTM_GETNEIGH, &ndm, sizeof(struct ndmsg)) < 0) {
- bb_perror_msg_and_die("can't send dump request");
+ bb_simple_perror_msg_and_die("can't send dump request");
}
if (xrtnl_dump_filter(&rth, print_neigh, NULL) < 0) {
- bb_error_msg_and_die("dump terminated");
+ bb_simple_error_msg_and_die("dump terminated");
}
return 0;
static int flush_update(void)
{
if (rtnl_send_check(G_filter.rth, G_filter.flushb, G_filter.flushp) < 0) {
- bb_perror_msg("can't send flush request");
+ bb_simple_perror_msg("can't send flush request");
return -1;
}
G_filter.flushp = 0;
}
if (write(flush_fd, "-1", 2) < 2) {
- bb_perror_msg("can't flush routing cache");
+ bb_simple_perror_msg("can't flush routing cache");
return;
}
close(flush_fd);
if (G_filter.tb != -1) {
xrtnl_wilddump_request(&rth, do_ipv6, RTM_GETROUTE);
} else if (rtnl_rtcache_request(&rth, do_ipv6) < 0) {
- bb_perror_msg_and_die("can't send dump request");
+ bb_simple_perror_msg_and_die("can't send dump request");
}
xrtnl_dump_filter(&rth, print_route, NULL);
}
if (req.r.rtm_dst_len == 0) {
- bb_error_msg_and_die("need at least destination address");
+ bb_simple_error_msg_and_die("need at least destination address");
}
xrtnl_open(&rth);
print_route(NULL, &req.n, NULL);
if (req.n.nlmsg_type != RTM_NEWROUTE) {
- bb_error_msg_and_die("not a route?");
+ bb_simple_error_msg_and_die("not a route?");
}
len -= NLMSG_LENGTH(sizeof(*r));
if (len < 0) {
tb[RTA_PREFSRC]->rta_type = RTA_SRC;
r->rtm_src_len = 8*RTA_PAYLOAD(tb[RTA_PREFSRC]);
} else if (!tb[RTA_SRC]) {
- bb_error_msg_and_die("can't connect the route");
+ bb_simple_error_msg_and_die("can't connect the route");
}
if (!odev && tb[RTA_OIF]) {
tb[RTA_OIF]->rta_type = 0;
if (p->iph.protocol == IPPROTO_IPIP || p->iph.protocol == IPPROTO_IPV6) {
if ((p->i_flags & GRE_KEY) || (p->o_flags & GRE_KEY)) {
- bb_error_msg_and_die("keys are not allowed with ipip and sit");
+ bb_simple_error_msg_and_die("keys are not allowed with ipip and sit");
}
}
p->o_flags |= GRE_KEY;
}
if (IN_MULTICAST(ntohl(p->iph.daddr)) && !p->iph.saddr) {
- bb_error_msg_and_die("broadcast tunnel requires a source address");
+ bb_simple_error_msg_and_die("broadcast tunnel requires a source address");
}
}
parse_args(argv, cmd, &p);
if (p.iph.ttl && p.iph.frag_off == 0) {
- bb_error_msg_and_die("ttl != 0 and noptmudisc are incompatible");
+ bb_simple_error_msg_and_die("ttl != 0 and noptmudisc are incompatible");
}
switch (p.iph.protocol) {
case IPPROTO_IPV6:
return do_add_ioctl(cmd, "sit0", &p);
default:
- bb_error_msg_and_die("can't determine tunnel mode (ipip, gre or sit)");
+ bb_simple_error_msg_and_die("can't determine tunnel mode (ipip, gre or sit)");
}
}
if (ptr == NULL ||
(*ptr++ = 0, sscanf(buf, "%s", name) != 1)
) {
- bb_error_msg("wrong format of /proc/net/dev");
+ bb_simple_error_msg("wrong format of /proc/net/dev");
return;
}
if (sscanf(ptr, "%lu%lu%lu%lu%lu%lu%lu%*d%lu%lu%lu%lu%lu%lu%lu",
if (h->nlmsg_type == NLMSG_ERROR) {
struct nlmsgerr *err = (struct nlmsgerr*)NLMSG_DATA(h);
if (h->nlmsg_len < NLMSG_LENGTH(sizeof(struct nlmsgerr)))
- bb_error_msg("ERROR truncated");
+ bb_simple_error_msg("ERROR truncated");
else
errno = -err->error;
return -1;
if (status < 0) {
if (errno == EINTR)
continue;
- bb_perror_msg("OVERRUN");
+ bb_simple_perror_msg("OVERRUN");
continue;
}
if (status == 0) {
- bb_error_msg("EOF on netlink");
+ bb_simple_error_msg("EOF on netlink");
goto ret;
}
if (msg.msg_namelen != sizeof(nladdr)) {
if (h->nlmsg_type == NLMSG_ERROR) {
struct nlmsgerr *l_err = (struct nlmsgerr*)NLMSG_DATA(h);
if (h->nlmsg_len < NLMSG_LENGTH(sizeof(struct nlmsgerr))) {
- bb_error_msg("ERROR truncated");
+ bb_simple_error_msg("ERROR truncated");
} else {
errno = -l_err->error;
- bb_perror_msg("RTNETLINK answers");
+ bb_simple_perror_msg("RTNETLINK answers");
}
goto ret;
}
h = NLMSG_NEXT(h, status);
}
if (msg.msg_flags & MSG_TRUNC) {
- bb_error_msg("message truncated");
+ bb_simple_error_msg("message truncated");
continue;
}
if (status) {
{
int ret = rtnl_dump_filter(rth, filter, arg1/*, NULL, NULL*/);
if (ret < 0)
- bb_error_msg_and_die("dump terminated");
+ bb_simple_error_msg_and_die("dump terminated");
return ret;
}
status = sendmsg(rtnl->fd, &msg, 0);
if (status < 0) {
- bb_perror_msg("can't talk to rtnetlink");
+ bb_simple_perror_msg("can't talk to rtnetlink");
goto ret;
}
if (errno == EINTR) {
continue;
}
- bb_perror_msg("OVERRUN");
+ bb_simple_perror_msg("OVERRUN");
continue;
}
if (status == 0) {
- bb_error_msg("EOF on netlink");
+ bb_simple_error_msg("EOF on netlink");
goto ret;
}
if (msg.msg_namelen != sizeof(nladdr)) {
if (l < 0 || len > status) {
if (msg.msg_flags & MSG_TRUNC) {
- bb_error_msg("truncated message");
+ bb_simple_error_msg("truncated message");
goto ret;
}
bb_error_msg_and_die("malformed message: len=%d!", len);
if (h->nlmsg_type == NLMSG_ERROR) {
struct nlmsgerr *err = (struct nlmsgerr*)NLMSG_DATA(h);
if (l < (int)sizeof(struct nlmsgerr)) {
- bb_error_msg("ERROR truncated");
+ bb_simple_error_msg("ERROR truncated");
} else {
errno = - err->error;
if (errno == 0) {
}
goto ret_0;
}
- bb_perror_msg("RTNETLINK answers");
+ bb_simple_perror_msg("RTNETLINK answers");
}
goto ret;
}
goto ret_0;
}
- bb_error_msg("unexpected reply!");
+ bb_simple_error_msg("unexpected reply!");
status -= NLMSG_ALIGN(len);
h = (struct nlmsghdr*)((char*)h + NLMSG_ALIGN(len));
}
if (msg.msg_flags & MSG_TRUNC) {
- bb_error_msg("message truncated");
+ bb_simple_error_msg("message truncated");
continue;
}
if (status) {
char** FAST_FUNC next_arg(char **argv)
{
if (!*++argv)
- bb_error_msg_and_die("command line is not complete, try \"help\"");
+ bb_simple_error_msg_and_die("command line is not complete, try \"help\"");
return argv;
}
if (memcmp(&nbd_header.magic1, "NBDMAGIC",
sizeof(nbd_header.magic1)) != 0
) {
- bb_error_msg_and_die("login failed");
+ bb_simple_error_msg_and_die("login failed");
}
if (memcmp(&nbd_header.magic2,
"\x00\x00\x42\x02\x81\x86\x12\x53",
} else if (memcmp(&nbd_header.magic2, "IHAVEOPT", 8) == 0) {
proto_new = 1;
} else {
- bb_error_msg_and_die("login failed");
+ bb_simple_error_msg_and_die("login failed");
}
if (!proto_new) {
}
if (ioctl(nbd, BLKROSET, &ro) < 0) {
- bb_perror_msg_and_die("BLKROSET");
+ bb_simple_perror_msg_and_die("BLKROSET");
}
if (timeout) {
if (ioctl(nbd, NBD_SET_TIMEOUT, (unsigned long) timeout)) {
- bb_perror_msg_and_die("NBD_SET_TIMEOUT");
+ bb_simple_perror_msg_and_die("NBD_SET_TIMEOUT");
}
}
if (ioctl(nbd, NBD_SET_SOCK, sock)) {
- bb_perror_msg_and_die("NBD_SET_SOCK");
+ bb_simple_perror_msg_and_die("NBD_SET_SOCK");
}
//if (swap) mlockall(MCL_CURRENT|MCL_FUTURE);
static void timeout(int signum UNUSED_PARAM)
{
- bb_error_msg_and_die("timed out");
+ bb_simple_error_msg_and_die("timed out");
}
int nc_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
accept_again:
cfd = accept(sfd, NULL, 0);
if (cfd < 0)
- bb_perror_msg_and_die("accept");
+ bb_simple_perror_msg_and_die("accept");
if (!execparam)
close(sfd);
} else {
int nread;
if (safe_poll(pfds, 2, -1) < 0)
- bb_perror_msg_and_die("poll");
+ bb_simple_perror_msg_and_die("poll");
fdidx = 0;
while (1) {
#define Debug(...) do { } while (0)
#endif
-#define holler_error(...) do { if (o_verbose) bb_error_msg(__VA_ARGS__); } while (0)
-#define holler_perror(...) do { if (o_verbose) bb_perror_msg(__VA_ARGS__); } while (0)
+#define holler_error(msg) do { if (o_verbose) bb_simple_error_msg(msg); } while (0)
+#define holler_perror(msg) do { if (o_verbose) bb_simple_perror_msg(msg); } while (0)
/* catch: no-brainer interrupt handler */
static void catch(int sig)
rr = recv_from_to(netfd, NULL, 0, MSG_PEEK, /*was bigbuf_net, BIGSIZ*/
&remend.u.sa, &ouraddr->u.sa, ouraddr->len);
if (rr < 0)
- bb_perror_msg_and_die("recvfrom");
+ bb_simple_perror_msg_and_die("recvfrom");
unarm();
} else
- bb_error_msg_and_die("timeout");
+ bb_simple_error_msg_and_die("timeout");
/* Now we learned *to which IP* peer has connected, and we want to anchor
our socket on it, so that our outbound packets will have correct local IP.
Unfortunately, bind() on already bound socket will fail now (EINVAL):
remend.len = LSA_SIZEOF_SA;
rr = accept(netfd, &remend.u.sa, &remend.len);
if (rr < 0)
- bb_perror_msg_and_die("accept");
+ bb_simple_perror_msg_and_die("accept");
if (themaddr) {
int sv_port, port, r;
}
unarm();
} else
- bb_error_msg_and_die("timeout");
+ bb_simple_error_msg_and_die("timeout");
if (is_persistent && proggie) {
/* -l -k -e PROG */
rr = write(netfd, bigbuf_in, 1);
if (rr != 1)
- bb_perror_msg("udptest first write");
+ bb_simple_perror_msg("udptest first write");
if (o_wait)
sleep(o_wait); // can be interrupted! while (t) nanosleep(&t)?
if (rr <= 0) {
if (rr < 0 && o_verbose > 1) {
/* nc 1.10 doesn't do this */
- bb_perror_msg("net read");
+ bb_simple_perror_msg("net read");
}
pfds[1].fd = -1; /* don't poll for netfd anymore */
fds_open--;
/* apparently UDP can listen ON "port 0",
but that's not useful */
if (!o_lport)
- bb_error_msg_and_die("UDP listen needs nonzero -p port");
+ bb_simple_error_msg_and_die("UDP listen needs nonzero -p port");
}
#endif
return;
if (prg_cache_loaded == 1)
- bb_error_msg("can't scan /proc - are you root?");
+ bb_simple_error_msg("can't scan /proc - are you root?");
else
- bb_error_msg("showing only processes with your user ID");
+ bb_simple_error_msg("showing only processes with your user ID");
}
#else
recvlen = read(pfd.fd, reply, sizeof(reply));
if (recvlen < 0) {
- bb_perror_msg("read");
+ bb_simple_perror_msg("read");
next:
tcur = monotonic_ms();
continue;
ret = send_to_from(fd, msg, len, MSG_DONTWAIT, to, from, addrlen);
}
if (ret != len) {
- bb_perror_msg("send failed");
+ bb_simple_perror_msg("send failed");
return -1;
}
return 0;
dtime = tvc.tv_sec + (1.0e-6 * tvc.tv_usec) + offset;
d_to_tv(dtime, &tvn);
if (settimeofday(&tvn, NULL) == -1)
- bb_perror_msg_and_die("settimeofday");
+ bb_simple_perror_msg_and_die("settimeofday");
VERB2 {
tval = tvc.tv_sec;
/* Starting from 1 is ok here */
for (i = 1; i < num_survivors; i++) {
if (G.last_update_peer == survivor[i].p) {
- VERB5 bb_error_msg("keeping old synced peer");
+ VERB5 bb_simple_error_msg("keeping old synced peer");
p = G.last_update_peer;
goto keep_old;
}
#else
set_new_values(STATE_SYNC, offset, recv_time);
#endif
- VERB4 bb_error_msg("transitioning to FREQ, datapoint ignored");
+ VERB4 bb_simple_error_msg("transitioning to FREQ, datapoint ignored");
return 0; /* "leave poll interval as is" */
#if 0 /* this is dead code for now */
VERB4 {
memset(&tmx, 0, sizeof(tmx));
if (adjtimex(&tmx) < 0)
- bb_perror_msg_and_die("adjtimex");
+ bb_simple_perror_msg_and_die("adjtimex");
bb_error_msg("p adjtimex freq:%ld offset:%+ld status:0x%x tc:%ld",
tmx.freq, tmx.offset, tmx.status, tmx.constant);
}
//tmx.maxerror = (uint32_t)((sys_rootdelay / 2 + sys_rootdisp) * 1e6);
rc = adjtimex(&tmx);
if (rc < 0)
- bb_perror_msg_and_die("adjtimex");
+ bb_simple_perror_msg_and_die("adjtimex");
/* NB: here kernel returns constant == G.poll_exp, not == G.poll_exp - 4.
* Not sure why. Perhaps it is normal.
*/
if (size < 0) {
if (errno == EAGAIN)
goto bail;
- bb_perror_msg_and_die("recv");
+ bb_simple_perror_msg_and_die("recv");
}
addr = xmalloc_sockaddr2dotted_noport(from);
bb_error_msg("malformed packet received from %s: size %u", addr, (int)size);
srand(getpid());
if (getuid())
- bb_error_msg_and_die(bb_msg_you_must_be_root);
+ bb_simple_error_msg_and_die(bb_msg_you_must_be_root);
/* Set some globals */
G.discipline_jitter = G_precision_sec;
/* supports 'sha' and 'sha1' formats */
hash_type = HASH_SHA1;
else
- bb_error_msg_and_die("only MD5 and SHA1 keys supported");
+ bb_simple_error_msg_and_die("only MD5 and SHA1 keys supported");
/* man ntp.keys:
* MD5 The key is 1 to 16 printable characters terminated by an EOL,
* whitespace, or a # (which is the "start of comment" character).
if (p->p_fd == -1) {
/* Time to send new req */
if (--cnt == 0) {
- VERB4 bb_error_msg("disabling burst mode");
+ VERB4 bb_simple_error_msg("disabling burst mode");
G.polladj_count = 0;
G.poll_exp = MINPOLL;
}
sock = socket(AF_INET, SOCK_RAW, 1); /* 1 == ICMP */
if (sock < 0) {
if (errno == EPERM)
- bb_error_msg_and_die(bb_msg_perm_denied_are_you_root);
- bb_perror_msg_and_die(bb_msg_can_not_create_raw_socket);
+ bb_simple_error_msg_and_die(bb_msg_perm_denied_are_you_root);
+ bb_simple_perror_msg_and_die(bb_msg_can_not_create_raw_socket);
}
xmove_fd(sock, pingsock);
#endif
if (c < 0) {
if (errno != EINTR)
- bb_perror_msg("recvfrom");
+ bb_simple_perror_msg("recvfrom");
continue;
}
if (c >= 76) { /* ip + icmp */
#endif
if (c < 0) {
if (errno != EINTR)
- bb_perror_msg("recvfrom");
+ bb_simple_perror_msg("recvfrom");
continue;
}
if (c >= ICMP_MINLEN) { /* icmp6_hdr */
* it doesn't matter */
sz = xsendto(pingsock, G.snd_packet, size_pkt, &pingaddr.sa, sizeof(pingaddr));
if (sz != size_pkt)
- bb_error_msg_and_die(bb_msg_write_error);
+ bb_simple_error_msg_and_die(bb_msg_write_error);
if (pingcount == 0 || G.ntransmitted < pingcount) {
/* Didn't send all pings yet - schedule next in -i SEC interval */
if (source_lsa) {
if (setsockopt(pingsock, IPPROTO_IP, IP_MULTICAST_IF,
&source_lsa->u.sa, source_lsa->len))
- bb_error_msg_and_die("can't set multicast source interface");
+ bb_simple_error_msg_and_die("can't set multicast source interface");
xbind(pingsock, &source_lsa->u.sa, source_lsa->len);
}
(struct sockaddr *) &from, &fromlen);
if (c < 0) {
if (errno != EINTR)
- bb_perror_msg("recvfrom");
+ bb_simple_perror_msg("recvfrom");
continue;
}
c = unpack4(G.rcv_packet, c, &from);
c = recvmsg(pingsock, &msg, 0);
if (c < 0) {
if (errno != EINTR)
- bb_perror_msg("recvfrom");
+ bb_simple_perror_msg("recvfrom");
continue;
}
for (mp = CMSG_FIRSTHDR(&msg); mp; mp = CMSG_NXTHDR(&msg, mp)) {
}
mask = ((struct sockaddr_in *) &rt->rt_dst)->sin_addr.s_addr;
if (mask & ~(uint32_t)mask_in_addr(*rt)) {
- bb_error_msg_and_die("netmask and route address conflict");
+ bb_simple_error_msg_and_die("netmask and route address conflict");
}
}
if ((r < 0) && feof(fp)) { /* EOF with no (nonspace) chars read. */
break;
}
- bb_perror_msg_and_die(bb_msg_read_error);
+ bb_simple_perror_msg_and_die(bb_msg_read_error);
}
if (!(flgs & RTF_UP)) { /* Skip interfaces that are down. */
break;
}
ERROR:
- bb_perror_msg_and_die(bb_msg_read_error);
+ bb_simple_perror_msg_and_die(bb_msg_read_error);
}
/* Do the addr6x shift-and-insert changes to ':'-delimit addresses.
ret = tcsetattr(serial_fd, TCSANOW, state);
if (ret != 0) {
- bb_perror_msg("tcsetattr");
+ bb_simple_perror_msg("tcsetattr");
return 1; /* used as exitcode */
}
return ret; /* 0 */
/* Save current tty state */
if (tcgetattr(serial_fd, &G.saved_state) != 0)
- bb_perror_msg_and_die("tcgetattr");
+ bb_simple_perror_msg_and_die("tcgetattr");
/* Save line discipline */
xioctl(serial_fd, TIOCGETD, &G.saved_disc);
client = 0;
if ((getuid() == 0) && !(opts & OPT_u)) {
xfunc_error_retval = 100;
- bb_error_msg_and_die(bb_msg_you_must_be_root);
+ bb_simple_error_msg_and_die(bb_msg_you_must_be_root);
}
if (opts & OPT_u)
if (!uidgid_get(&sslugid, ssluser, 1)) {
sig_block(SIGCHLD);
if (conn < 0) {
if (errno != EINTR)
- bb_perror_msg(tcp ? "accept" : "recv");
+ bb_simple_perror_msg(tcp ? "accept" : "recv");
goto again2;
}
xmove_fd(tcp ? conn : sock, 0);
pid = vfork();
if (pid == -1) {
- bb_perror_msg("vfork");
+ bb_simple_perror_msg("vfork");
goto again;
}
free(ts);
close(fd);
/* sock will be closed by caller */
- bb_perror_msg("vfork");
+ bb_simple_perror_msg("vfork");
return NULL;
}
if (pid > 0) {
/* fill in packet if the filename fits into xbuf */
len = strlen(remote_file) + 1;
if (2 + len + sizeof("octet") >= io_bufsize) {
- bb_error_msg("remote filename is too long");
+ bb_simple_error_msg("remote filename is too long");
goto ret;
}
strcpy(cp, remote_file);
/* Need to add option to pkt */
if ((&xbuf[io_bufsize - 1] - cp) < sizeof("blksize NNNNN tsize ") + sizeof(off_t)*3) {
- bb_error_msg("remote filename is too long");
+ bb_simple_error_msg("remote filename is too long");
goto ret;
}
expect_OACK = 1;
retries--;
if (retries == 0) {
tftp_progress_done();
- bb_error_msg("timeout");
+ bb_simple_error_msg("timeout");
goto ret; /* no err packet sent */
}
* must be ignored by the client and server
* as if it were never requested." */
if (blksize != TFTP_BLKSIZE_DEFAULT)
- bb_error_msg("falling back to blocksize "TFTP_BLKSIZE_DEFAULT_STR);
+ bb_simple_error_msg("falling back to blocksize "TFTP_BLKSIZE_DEFAULT_STR);
blksize = TFTP_BLKSIZE_DEFAULT;
io_bufsize = TFTP_BLKSIZE_DEFAULT + 4;
}
strcpy(G_error_pkt_str, bb_msg_read_error);
send_err_pkt:
if (G_error_pkt_str[0])
- bb_error_msg("%s", G_error_pkt_str);
+ bb_simple_error_msg(G_error_pkt_str);
G.error_pkt[1] = TFTP_ERROR;
xsendto(socket_fd, G.error_pkt, 4 + 1 + strlen(G_error_pkt_str),
&peer_lsa->u.sa, peer_lsa->len);
// than INSIZE bytes will first hash the key using H and then use the
// resultant OUTSIZE byte string as the actual key to HMAC."
if (key_size > SHA_INSIZE) {
- bb_error_msg_and_die("HMAC key>64"); //does not happen (yet?)
+ bb_simple_error_msg_and_die("HMAC key>64"); //does not happen (yet?)
// md5sha_ctx_t ctx;
// begin(&ctx);
// md5sha_hash(&ctx, key, key_size);
}
}
if (sz < 0)
- bb_error_msg_and_die("encrypted data too short");
+ bb_simple_error_msg_and_die("encrypted data too short");
//dump_hex("<< %s\n", tls->inbuf, RECHDR_LEN + sz);
dbg("ECDSA key\n");
//UNUSED: tls->flags |= GOT_CERT_ECDSA_KEY_ALG;
} else
- bb_error_msg_and_die("not RSA or ECDSA cert");
+ bb_simple_error_msg_and_die("not RSA or ECDSA cert");
}
if (tls->flags & GOT_CERT_RSA_KEY_ALG) {
/* So far we only support curve_x25519 */
move_from_unaligned32(t32, keybuf);
if (t32 != htonl(0x03001d20))
- bb_error_msg_and_die("elliptic curve is not x25519");
+ bb_simple_error_msg_and_die("elliptic curve is not x25519");
memcpy(tls->hsd->ecc_pub_key32, keybuf + 4, 32);
tls->flags |= GOT_EC_KEY;
if (!(tls->flags & NEED_EC_KEY)) {
/* RSA */
if (!(tls->flags & GOT_CERT_RSA_KEY_ALG))
- bb_error_msg("server cert is not RSA");
+ bb_simple_error_msg("server cert is not RSA");
tls_get_random(rsa_premaster, sizeof(rsa_premaster));
if (TLS_DEBUG_FIXED_SECRETS)
uint8_t privkey[CURVE25519_KEYSIZE]; //[32]
if (!(tls->flags & GOT_EC_KEY))
- bb_error_msg("server did not provide EC key");
+ bb_simple_error_msg("server did not provide EC key");
/* Generate random private key, see RFC 7748 */
tls_get_random(privkey, sizeof(privkey));
int nread;
if (safe_poll(pfds, 2, -1) < 0)
- bb_perror_msg_and_die("poll");
+ bb_simple_perror_msg_and_die("poll");
if (pfds[0].revents) {
void *buf;
#define matrixCryptoGetPrngData(buf, len, userPtr) (tls_get_random(buf, len), PS_SUCCESS)
#define psFree(p, pool) free(p)
-#define psTraceCrypto(...) bb_error_msg_and_die(__VA_ARGS__)
+#define psTraceCrypto(msg) bb_simple_error_msg_and_die(msg)
/* Secure zerofill */
#define memset_s(A,B,C,D) memset((A),(C),(D))
* probe (e.g., on a multi-homed host).
*/
if (getuid() != 0)
- bb_error_msg_and_die(bb_msg_you_must_be_root);
+ bb_simple_error_msg_and_die(bb_msg_you_must_be_root);
}
if (op & OPT_WAITTIME)
waittime = xatou_range(waittime_str, 1, 24 * 60 * 60);
if (af == AF_INET)
if (setsockopt(sndsock, IPPROTO_IP, IP_MULTICAST_IF,
&source_lsa->u.sa, source_lsa->len))
- bb_error_msg_and_die("can't set multicast source interface");
+ bb_simple_error_msg_and_die("can't set multicast source interface");
//TODO: we can query source port we bound to,
// and check it in replies... if we care enough
xbind(sndsock, &source_lsa->u.sa, source_lsa->len);
/* read IP and port */
source_lsa = get_sock_lsa(probe_fd);
if (source_lsa == NULL)
- bb_error_msg_and_die("can't get probe addr");
+ bb_simple_error_msg_and_die("can't get probe addr");
close(probe_fd);
s = socket(PF_PACKET, SOCK_PACKET, htons(ETH_P_ARP));
if (s == -1) {
- bb_perror_msg(bb_msg_can_not_create_raw_socket);
+ bb_simple_perror_msg(bb_msg_can_not_create_raw_socket);
return -1;
}
if (setsockopt_broadcast(s) == -1) {
- bb_perror_msg("can't enable bcast on raw socket");
+ bb_simple_perror_msg("can't enable bcast on raw socket");
goto ret;
}
while (1) {
if (rem <= 0) {
complain:
- bb_error_msg("bad packet, malformed option field");
+ bb_simple_error_msg("bad packet, malformed option field");
return NULL;
}
# define IF_UDHCP_VERBOSE(...) __VA_ARGS__
extern unsigned dhcp_verbose;
# define log1(...) do { if (dhcp_verbose >= 1) bb_info_msg(__VA_ARGS__); } while (0)
+# define log1s(msg) do { if (dhcp_verbose >= 1) bb_simple_info_msg(msg); } while (0)
# if CONFIG_UDHCP_DEBUG >= 2
void udhcp_dump_packet(struct dhcp_packet *packet) FAST_FUNC;
# define log2(...) do { if (dhcp_verbose >= 2) bb_info_msg(__VA_ARGS__); } while (0)
+# define log2s(msg) do { if (dhcp_verbose >= 2) bb_simple_info_msg(msg); } while (0)
# else
# define udhcp_dump_packet(...) ((void)0)
# define log2(...) ((void)0)
+# define log2s(msg) ((void)0)
# endif
# if CONFIG_UDHCP_DEBUG >= 3
# define log3(...) do { if (dhcp_verbose >= 3) bb_info_msg(__VA_ARGS__); } while (0)
+# define log3s(msg) do { if (dhcp_verbose >= 3) bb_simple_info_msg(msg); } while (0)
# else
# define log3(...) ((void)0)
+# define log3s(msg) ((void)0)
# endif
#else
# define IF_UDHCP_VERBOSE(...)
# define udhcp_dump_packet(...) ((void)0)
# define log1(...) ((void)0)
+# define log1s(msg) ((void)0)
# define log2(...) ((void)0)
+# define log2s(msg) ((void)0)
# define log3(...) ((void)0)
+# define log3s(msg) ((void)0)
#endif
+#if defined(__mips__)
+/*
+ * The 'simple' message functions have a negative impact on the size of the
+ * DHCP code when compiled for MIPS, so don't use them in this case.
+ */
+#define bb_simple_info_msg bb_info_msg
+#define bb_simple_error_msg bb_error_msg
+#define bb_simple_perror_msg_and_die bb_perror_msg_and_die
+#undef log1s
+#define log1s log1
+#endif
/*** Other shared functions ***/
found:
val_len = (option[2] << 8) | option[3];
if (val_len + &option[D6_OPT_DATA] > option_end) {
- bb_error_msg("option data exceeds option length");
+ bb_simple_error_msg("option data exceeds option length");
return NULL;
}
return xasprintf("%s=%.*s", name, val_len, (char*)option + 4);
bytes = safe_read(fd, &packet, sizeof(packet));
if (bytes < 0) {
- log1("packet read error, ignoring");
+ log1s("packet read error, ignoring");
/* NB: possible down interface, etc. Caller should pause. */
return bytes; /* returns -1 */
}
if (bytes < (int) (sizeof(packet.ip6) + sizeof(packet.udp))) {
- log1("packet is too short, ignoring");
+ log1s("packet is too short, ignoring");
return -2;
}
if (bytes < sizeof(packet.ip6) + ntohs(packet.ip6.ip6_plen)) {
/* packet is bigger than sizeof(packet), we did partial read */
- log1("oversized packet, ignoring");
+ log1s("oversized packet, ignoring");
return -2;
}
/* || bytes > (int) sizeof(packet) - can't happen */
|| packet.udp.len != packet.ip6.ip6_plen
) {
- log1("unrelated/bogus packet, ignoring");
+ log1s("unrelated/bogus packet, ignoring");
return -2;
}
}
#endif
- log1("created raw socket");
+ log1s("created raw socket");
return fd;
}
/* Called only on SIGUSR1 */
static void perform_renew(void)
{
- bb_info_msg("performing DHCP renew");
+ bb_simple_info_msg("performing DHCP renew");
switch (client_data.state) {
case BOUND:
change_listen_mode(LISTEN_KERNEL);
|| client_data.state == REBINDING
|| client_data.state == RENEW_REQUESTED
) {
- bb_info_msg("unicasting a release");
+ bb_simple_info_msg("unicasting a release");
send_d6_release(server_ipv6, our_cur_ipv6); /* unicast */
}
- bb_info_msg("entering released state");
+ bb_simple_info_msg("entering released state");
/*
* We can be here on: SIGUSR2,
* or on exit (SIGTERM) and -R "release on quit" is specified.
/* Create pidfile */
write_pidfile(client_data.pidfile);
/* Goes to stdout (unless NOMMU) and possibly syslog */
- bb_info_msg("started, v"BB_VER);
+ bb_simple_info_msg("started, v"BB_VER);
client_data.state = INIT_SELECTING;
d6_run_script_no_option("deconfig");
continue;
}
/* Else: an error occured, panic! */
- bb_perror_msg_and_die("poll");
+ bb_simple_perror_msg_and_die("poll");
}
}
d6_run_script_no_option("leasefail");
#if BB_MMU /* -b is not supported on NOMMU */
if (opt & OPT_b) { /* background if no lease */
- bb_info_msg("no lease, forking to background");
+ bb_simple_info_msg("no lease, forking to background");
client_background();
/* do not background again! */
opt = ((opt & ~(OPT_b|OPT_n)) | OPT_f);
} else
#endif
if (opt & OPT_n) { /* abort if no lease */
- bb_info_msg("no lease, failing");
+ bb_simple_info_msg("no lease, failing");
retval = 1;
goto ret;
}
client_data.state = RENEWING;
client_data.first_secs = 0; /* make secs field count from 0 */
change_listen_mode(LISTEN_KERNEL);
- log1("entering renew state");
+ log1s("entering renew state");
/* fall right through */
case RENEW_REQUESTED: /* manual (SIGUSR1) renew */
case_RENEW_REQUESTED:
continue;
}
/* Timed out, enter rebinding state */
- log1("entering rebinding state");
+ log1s("entering rebinding state");
client_data.state = REBINDING;
/* fall right through */
case REBINDING:
continue;
}
/* Timed out, enter init state */
- bb_info_msg("lease lost, entering init state");
+ bb_simple_info_msg("lease lost, entering init state");
d6_run_script_no_option("deconfig");
client_data.state = INIT_SELECTING;
client_data.first_secs = 0; /* make secs field count from 0 */
}
option = d6_copy_option(packet.d6_options, packet_end, D6_OPT_SERVERID);
if (!option) {
- bb_info_msg("no server ID, ignoring packet");
+ bb_simple_info_msg("no server ID, ignoring packet");
continue;
/* still selecting - this server looks bad */
}
memset(packet, 0, sizeof(*packet));
bytes = safe_read(fd, packet, sizeof(*packet));
if (bytes < 0) {
- log1("packet read error, ignoring");
+ log1s("packet read error, ignoring");
return bytes; /* returns -1 */
}
if (bytes < offsetof(struct d6_packet, d6_options)) {
- bb_info_msg("packet with bad magic, ignoring");
+ bb_simple_info_msg("packet with bad magic, ignoring");
return -2;
}
log1("received %s", "a packet");
setsockopt_reuseaddr(fd);
if (setsockopt_broadcast(fd) == -1)
- bb_perror_msg_and_die("SO_BROADCAST");
+ bb_simple_perror_msg_and_die("SO_BROADCAST");
/* NB: bug 1032 says this doesn't work on ethernet aliases (ethN:M) */
if (setsockopt_bindtodevice(fd, inf))
if (bytes < 0) {
if (errno == EINTR)
continue;
- log1("packet read error, ignoring");
+ log1s("packet read error, ignoring");
/* NB: possible down interface, etc. Caller should pause. */
return bytes; /* returns -1 */
}
}
if (bytes < (int) (sizeof(packet.ip) + sizeof(packet.udp))) {
- log1("packet is too short, ignoring");
+ log1s("packet is too short, ignoring");
return -2;
}
if (bytes < ntohs(packet.ip.tot_len)) {
/* packet is bigger than sizeof(packet), we did partial read */
- log1("oversized packet, ignoring");
+ log1s("oversized packet, ignoring");
return -2;
}
/* || bytes > (int) sizeof(packet) - can't happen */
|| ntohs(packet.udp.len) != (uint16_t)(bytes - sizeof(packet.ip))
) {
- log1("unrelated/bogus packet, ignoring");
+ log1s("unrelated/bogus packet, ignoring");
return -2;
}
check = packet.ip.check;
packet.ip.check = 0;
if (check != inet_cksum((uint16_t *)&packet.ip, sizeof(packet.ip))) {
- log1("bad IP header checksum, ignoring");
+ log1s("bad IP header checksum, ignoring");
return -2;
}
check = packet.udp.check;
packet.udp.check = 0;
if (check && check != inet_cksum((uint16_t *)&packet, bytes)) {
- log1("packet with bad UDP checksum received, ignoring");
+ log1s("packet with bad UDP checksum received, ignoring");
return -2;
}
skip_udp_sum_check:
if (packet.data.cookie != htonl(DHCP_MAGIC)) {
- bb_info_msg("packet with bad magic, ignoring");
+ bb_simple_info_msg("packet with bad magic, ignoring");
return -2;
}
if (setsockopt_1(fd, SOL_PACKET, PACKET_AUXDATA) != 0) {
if (errno != ENOPROTOOPT)
- log1("can't set PACKET_AUXDATA on raw socket");
+ log1s("can't set PACKET_AUXDATA on raw socket");
}
- log1("created raw socket");
+ log1s("created raw socket");
return fd;
}
/* Called only on SIGUSR1 */
static void perform_renew(void)
{
- bb_info_msg("performing DHCP renew");
+ bb_simple_info_msg("performing DHCP renew");
switch (client_data.state) {
case BOUND:
change_listen_mode(LISTEN_KERNEL);
inet_ntoa(temp_addr), buffer);
send_release(server_addr, requested_ip); /* unicast */
}
- bb_info_msg("entering released state");
+ bb_simple_info_msg("entering released state");
/*
* We can be here on: SIGUSR2,
* or on exit (SIGTERM) and -R "release on quit" is specified.
);
if (opt & (OPT_h|OPT_H)) {
//msg added 2011-11
- bb_error_msg("option -h NAME is deprecated, use -x hostname:NAME");
+ bb_simple_error_msg("option -h NAME is deprecated, use -x hostname:NAME");
client_data.hostname = alloc_dhcp_option(DHCP_HOST_NAME, str_h, 0);
}
if (opt & OPT_F) {
/* Create pidfile */
write_pidfile(client_data.pidfile);
/* Goes to stdout (unless NOMMU) and possibly syslog */
- bb_info_msg("started, v"BB_VER);
+ bb_simple_info_msg("started, v"BB_VER);
/* We want random_xid to be random... */
srand(monotonic_us());
continue;
}
/* Else: an error occurred, panic! */
- bb_perror_msg_and_die("poll");
+ bb_simple_perror_msg_and_die("poll");
}
}
udhcp_run_script(NULL, "leasefail");
#if BB_MMU /* -b is not supported on NOMMU */
if (opt & OPT_b) { /* background if no lease */
- bb_info_msg("no lease, forking to background");
+ bb_simple_info_msg("no lease, forking to background");
client_background();
/* do not background again! */
opt = ((opt & ~(OPT_b|OPT_n)) | OPT_f);
} else
#endif
if (opt & OPT_n) { /* abort if no lease */
- bb_info_msg("no lease, failing");
+ bb_simple_info_msg("no lease, failing");
retval = 1;
goto ret;
}
client_data.state = RENEWING;
client_data.first_secs = 0; /* make secs field count from 0 */
change_listen_mode(LISTEN_KERNEL);
- log1("entering renew state");
+ log1s("entering renew state");
/* fall right through */
case RENEW_REQUESTED: /* manual (SIGUSR1) renew */
case_RENEW_REQUESTED:
*/
}
/* Timed out or error, enter rebinding state */
- log1("entering rebinding state");
+ log1s("entering rebinding state");
client_data.state = REBINDING;
/* fall right through */
case REBINDING:
continue;
}
/* Timed out, enter init state */
- bb_info_msg("lease lost, entering init state");
+ bb_simple_info_msg("lease lost, entering init state");
udhcp_run_script(NULL, "deconfig");
client_data.state = INIT_SELECTING;
client_data.first_secs = 0; /* make secs field count from 0 */
|| memcmp(packet.chaddr, client_data.client_mac, 6) != 0
) {
//FIXME: need to also check that last 10 bytes are zero
- log1("chaddr does not match, ignoring packet"); // log2?
+ log1("chaddr does not match%s", ", ignoring packet"); // log2?
continue;
}
message = udhcp_get_option(&packet, DHCP_MESSAGE_TYPE);
if (message == NULL) {
- bb_info_msg("no message type option, ignoring packet");
+ bb_info_msg("no message type option%s", ", ignoring packet");
continue;
}
server_addr = 0;
temp = udhcp_get_option32(&packet, DHCP_SERVER_ID);
if (!temp) {
- bb_info_msg("no server ID, using 0.0.0.0");
+ bb_simple_info_msg("no server ID, using 0.0.0.0");
} else {
/* it IS unaligned sometimes, don't "optimize" */
move_from_unaligned32(server_addr, temp);
temp = udhcp_get_option32(&packet, DHCP_LEASE_TIME);
if (!temp) {
- bb_info_msg("no lease time with ACK, using 1 hour lease");
+ bb_simple_info_msg("no lease time with ACK, using 1 hour lease");
lease_seconds = 60 * 60;
} else {
/* it IS unaligned sometimes, don't "optimize" */
client_data.interface,
arpping_ms)
) {
- bb_info_msg("offered address is in use "
+ bb_simple_info_msg("offered address is in use "
"(got ARP reply), declining");
send_decline(/*xid,*/ server_addr, packet.yiaddr);
if (!temp) {
non_matching_svid:
log1("received DHCP NAK with wrong"
- " server ID, ignoring packet");
+ " server ID%s", ", ignoring packet");
continue;
}
move_from_unaligned32(svid, temp);
|| (dhcp_pkt->flags & htons(BROADCAST_FLAG))
|| dhcp_pkt->ciaddr == 0
) {
- log1("broadcasting packet to client");
+ log1s("broadcasting packet to client");
ciaddr = INADDR_BROADCAST;
chaddr = MAC_BCAST_ADDR;
} else {
- log1("unicasting packet to client ciaddr");
+ log1s("unicasting packet to client ciaddr");
ciaddr = dhcp_pkt->ciaddr;
chaddr = dhcp_pkt->chaddr;
}
/* Send a packet to gateway_nip using the kernel ip stack */
static void send_packet_to_relay(struct dhcp_packet *dhcp_pkt)
{
- log1("forwarding packet to relay");
+ log1s("forwarding packet to relay");
udhcp_send_kernel_packet(dhcp_pkt,
server_data.server_nip, SERVER_PORT,
}
if (!packet.yiaddr) {
- bb_error_msg("no free IP addresses. OFFER abandoned");
+ bb_simple_error_msg("no free IP addresses. OFFER abandoned");
return;
}
/* Reserve the IP for a short time hoping to get DHCPREQUEST soon */
p_host_name ? (unsigned char)p_host_name[OPT_LEN - OPT_DATA] : 0
);
if (!lease) {
- bb_error_msg("no free IP addresses. OFFER abandoned");
+ bb_simple_error_msg("no free IP addresses. OFFER abandoned");
return;
}
}
write_pidfile(server_data.pidfile);
/* if (!..) bb_perror_msg("can't create pidfile %s", pidfile); */
- bb_info_msg("started, v"BB_VER);
+ bb_simple_info_msg("started, v"BB_VER);
option = udhcp_find_option(server_data.options, DHCP_LEASE_TIME);
server_data.max_lease_sec = DEFAULT_LEASE_TIME;
if (errno == EINTR)
goto new_tv;
/* < 0 and not EINTR: should not happen */
- bb_perror_msg_and_die("poll");
+ bb_simple_perror_msg_and_die("poll");
}
if (pfds[0].revents) switch (udhcp_sp_read()) {
continue;
}
if (packet.hlen != 6) {
- bb_info_msg("MAC length != 6, ignoring packet");
+ bb_info_msg("MAC length != 6%s", ", ignoring packet");
continue;
}
if (packet.op != BOOTREQUEST) {
- bb_info_msg("not a REQUEST, ignoring packet");
+ bb_info_msg("not a REQUEST%s", ", ignoring packet");
continue;
}
state = udhcp_get_option(&packet, DHCP_MESSAGE_TYPE);
if (state == NULL || state[0] < DHCP_MINTYPE || state[0] > DHCP_MAXTYPE) {
- bb_info_msg("no or bad message type option, ignoring packet");
+ bb_info_msg("no or bad message type option%s", ", ignoring packet");
continue;
}
move_from_unaligned32(server_id_network_order, server_id_opt);
if (server_id_network_order != server_data.server_nip) {
/* client talks to somebody else */
- log1("server ID doesn't match, ignoring");
+ log1("server ID doesn't match%s", ", ignoring");
continue;
}
}
if (!requested_ip_opt) {
requested_nip = packet.ciaddr;
if (requested_nip == 0) {
- log1("no requested IP and no ciaddr, ignoring");
+ log1("no requested IP and no ciaddr%s", ", ignoring");
break;
}
}
err = sendto(sock, msg, msg_len, 0, (struct sockaddr*) to, sizeof(*to));
err -= msg_len;
if (err)
- bb_perror_msg("sendto");
+ bb_simple_perror_msg("sendto");
return err;
}
bb_show_usage();
if (argv[3]) {
if (!inet_aton(argv[3], &server_addr.sin_addr))
- bb_perror_msg_and_die("bad server IP");
+ bb_simple_perror_msg_and_die("bad server IP");
}
iface_list = make_iface_list(argv + 1, &num_sockets);
memset(packet, 0, sizeof(*packet));
bytes = safe_read(fd, packet, sizeof(*packet));
if (bytes < 0) {
- log1("packet read error, ignoring");
+ log1s("packet read error, ignoring");
return bytes; /* returns -1 */
}
if (bytes < offsetof(struct dhcp_packet, options)
|| packet->cookie != htonl(DHCP_MAGIC)
) {
- bb_info_msg("packet with bad magic, ignoring");
+ bb_simple_info_msg("packet with bad magic, ignoring");
return -2;
}
log1("received %s", "a packet");
int sv = errno;
unsigned char ch = sig; /* use char, avoid dealing with partial writes */
if (write(WRITE_FD, &ch, 1) != 1)
- bb_perror_msg("can't send signal");
+ bb_simple_perror_msg("can't send signal");
errno = sv;
}
setsockopt_reuseaddr(fd);
if (setsockopt_broadcast(fd) == -1)
- bb_perror_msg_and_die("SO_BROADCAST");
+ bb_simple_perror_msg_and_die("SO_BROADCAST");
/* SO_BINDTODEVICE doesn't work on ethernet aliases (ethN:M) */
colon = strrchr(inf, ':');
{
/* This is theoretically unsafe (uses stdio and malloc in signal handler) */
if (G.die_if_timed_out)
- bb_error_msg_and_die("download timed out");
+ bb_simple_error_msg_and_die("download timed out");
}
static void set_alarm(void)
{
set_alarm();
if (fgets(G.wget_buf, sizeof(G.wget_buf), fp) == NULL)
- bb_perror_msg_and_die("error getting response");
+ bb_simple_perror_msg_and_die("error getting response");
clear_alarm();
buf_ptr = strchrnul(G.wget_buf, '\n');
static void reset_beg_range_to_zero(void)
{
- bb_error_msg("restart failed");
+ bb_simple_error_msg("restart failed");
G.beg_range = 0;
xlseek(G.output_fd, 0, SEEK_SET);
/* Done at the end instead: */
if (socketpair(AF_UNIX, SOCK_STREAM, 0, sp) != 0)
/* Kernel can have AF_UNIX support disabled */
- bb_perror_msg_and_die("socketpair");
+ bb_simple_perror_msg_and_die("socketpair");
if (!strchr(host, ':'))
host = allocated = xasprintf("%s:%u", host, port);
if (!(option_mask32 & WGET_OPT_NO_CHECK_CERT)) {
option_mask32 |= WGET_OPT_NO_CHECK_CERT;
- bb_error_msg("note: TLS certificate validation not implemented");
+ bb_simple_error_msg("note: TLS certificate validation not implemented");
}
servername = xstrdup(host);
if (socketpair(AF_UNIX, SOCK_STREAM, 0, sp) != 0)
/* Kernel can have AF_UNIX support disabled */
- bb_perror_msg_and_die("socketpair");
+ bb_simple_perror_msg_and_die("socketpair");
fflush_all();
pid = BB_MMU ? xfork() : xvfork();
#endif
if (ftpcmd(NULL, NULL, sfp) != 220)
- bb_error_msg_and_die("%s", G.wget_buf);
+ bb_simple_error_msg_and_die(G.wget_buf);
/* note: ftpcmd() sanitizes G.wget_buf, ok to print */
/* Split username:password pair */
if (errno != EAGAIN) {
if (ferror(dfp)) {
progress_meter(PROGRESS_END);
- bb_perror_msg_and_die(bb_msg_read_error);
+ bb_simple_perror_msg_and_die(bb_msg_read_error);
}
break; /* EOF, not error */
}
# if ENABLE_FEATURE_WGET_TIMEOUT
if (second_cnt != 0 && --second_cnt == 0) {
progress_meter(PROGRESS_END);
- bb_error_msg_and_die("download timed out");
+ bb_simple_error_msg_and_die("download timed out");
}
# endif
/* We used to loop back to poll here,
G.got_clen = 1; /* makes it show 100% even for download of (formerly) unknown size */
progress_meter(PROGRESS_END);
if (G.content_len != 0) {
- bb_perror_msg_and_die("connection closed prematurely");
+ bb_simple_perror_msg_and_die("connection closed prematurely");
/* GNU wget says "DATE TIME (NN MB/s) - Connection closed at byte NNN. Retrying." */
}
}
if (key == KEY_location && status >= 300) {
if (--redir_limit == 0)
- bb_error_msg_and_die("too many redirections");
+ bb_simple_error_msg_and_die("too many redirections");
fclose(sfp);
if (str[0] == '/') {
free(redirected_path);
if (inet_aton(l_opt, &net) == 0
|| (net.s_addr & htonl(IN_CLASSB_NET)) != net.s_addr
) {
- bb_error_msg_and_die("invalid network address");
+ bb_simple_error_msg_and_die("invalid network address");
}
G.localnet_ip = ntohl(net.s_addr);
}
if (inet_aton(r_opt, &ip) == 0
|| (ntohl(ip.s_addr) & IN_CLASSB_NET) != G.localnet_ip
) {
- bb_error_msg_and_die("invalid link address");
+ bb_simple_error_msg_and_die("invalid link address");
}
chosen_nip = ip.s_addr;
}
// Read ARP packet
if (safe_read(sock_fd, &p, sizeof(p)) < 0) {
- bb_perror_msg_and_die(bb_msg_read_error);
+ bb_simple_perror_msg_and_die(bb_msg_read_error);
}
if (p.eth.ether_type != htons(ETHERTYPE_ARP))
// LPR ------------------------
//
if (opts & LPR_V)
- bb_error_msg("connected to server");
+ bb_simple_error_msg("connected to server");
job = getpid() % 1000;
hostname = safe_gethostname();
* Standard lpr works around it by refusing to send such jobs:
*/
if (st.st_size == 0) {
- bb_error_msg("nothing to print");
+ bb_simple_error_msg("nothing to print");
continue;
}
// send control file
if (opts & LPR_V)
- bb_error_msg("sending control file");
+ bb_simple_error_msg("sending control file");
/* "Acknowledgement processing must occur as usual
* after the command is sent." */
cflen = (unsigned)strlen(controlfile);
// send data file, with name "dfaXXX"
if (opts & LPR_V)
- bb_error_msg("sending data file");
+ bb_simple_error_msg("sending data file");
fdprintf(fd, "\x3" "%"OFF_FMT"u d%s\n", st.st_size, remote_filename);
get_response_or_say_and_die(fd, "sending data file");
if (bb_copyfd_size(dfd, fd, st.st_size) != st.st_size) {
// We're screwed. We sent less bytes than we advertised.
- bb_error_msg_and_die("local file changed size?!");
+ bb_simple_error_msg_and_die("local file changed size?!");
}
write(fd, "", 1); // send ACK
get_response_or_say_and_die(fd, "sending data file");
// say job accepted
if (opts & LPR_V)
- bb_error_msg("job accepted");
+ bb_simple_error_msg("job accepted");
// next, please!
job = (job + 1) % 1000;
#if ENABLE_KILL || ENABLE_KILLALL
/* Pid or name is required for kill/killall */
if (!arg) {
- bb_error_msg("you need to specify whom to kill");
+ bb_simple_error_msg("you need to specify whom to kill");
return EXIT_FAILURE;
}
/* Get CPU number */
unsigned n = xatoi_positive(t);
if (n >= G.cpu_nr)
- bb_error_msg_and_die("not that many processors");
+ bb_simple_error_msg_and_die("not that many processors");
n++;
G.cpu_bitmap[n >> 3] |= 1 << (n & 7);
}
}
} else {
bb_putchar('\n');
- bb_error_msg("no stats available; run as root or"
+ bb_simple_error_msg("no stats available; run as root or"
" enable the timer_stats module");
}
}
/* Print warning when we don't have superuser privileges */
if (geteuid() != 0)
- bb_error_msg("run as root to collect enough information");
+ bb_simple_error_msg("run as root to collect enough information");
/* Get number of CPUs */
G.total_cpus = get_cpu_count();
else {
dump_by_user(find_proc(1), uid);
if (!G.dumped) {
- bb_error_msg_and_die("no processes found");
+ bb_simple_error_msg_and_die("no processes found");
}
}
#endif
} /* end of "while we read /proc" */
if (ntop == 0) {
- bb_error_msg("no process info in /proc");
+ bb_simple_error_msg("no process info in /proc");
break;
}
else
r.rlim_cur = l;
if (setrlimit(what, &r) == -1)
- bb_perror_msg_and_die("setrlimit");
+ bb_simple_perror_msg_and_die("setrlimit");
}
int chpst_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
if (opt & OPT_n) {
errno = 0;
if (nice(xatoi(nicestr)) == -1)
- bb_perror_msg_and_die("nice");
+ bb_simple_perror_msg_and_die("nice");
}
if (opt & OPT_u) {
if (setgroups(1, &ugid.gid) == -1)
- bb_perror_msg_and_die("setgroups");
+ bb_simple_perror_msg_and_die("setgroups");
xsetgid(ugid.gid);
xsetuid(ugid.uid);
}
}
static void pause_nomem(void)
{
- bb_error_msg(PAUSE"out of memory");
+ bb_simple_error_msg(PAUSE"out of memory");
sleep(3);
}
static void pause1cannot(const char *m0)
context_string = context_str(context);
if (!context_string) {
- bb_error_msg("can't obtain security context in text expression");
+ bb_simple_error_msg("can't obtain security context in text expression");
goto skip;
}
/* specified_context is never NULL -
* "-1" in opt_complementary prevents this. */
if (!argv[0])
- bb_error_msg_and_die("too few arguments");
+ bb_simple_error_msg_and_die("too few arguments");
}
for (i = 0; (fname = argv[i]) != NULL; i++) {
rc = is_selinux_enabled();
if (rc < 0)
- bb_error_msg_and_die("is_selinux_enabled() failed");
+ bb_simple_error_msg_and_die("is_selinux_enabled() failed");
if (rc == 1) {
rc = security_getenforce();
if (rc < 0)
- bb_error_msg_and_die("getenforce() failed");
+ bb_simple_error_msg_and_die("getenforce() failed");
if (rc)
puts("Enforcing");
rc = security_get_boolean_names(&names, &len);
if (rc)
- bb_perror_msg_and_die("can't get boolean names");
+ bb_simple_perror_msg_and_die("can't get boolean names");
if (!len) {
puts("No booleans");
rc = selinux_mkload_policy(1);
if (rc < 0) {
- bb_perror_msg_and_die("can't load policy");
+ bb_simple_perror_msg_and_die("can't load policy");
}
return 0;
security_context_t cur_context;
if (getcon(&cur_context))
- bb_error_msg_and_die("can't get current context");
+ bb_simple_error_msg_and_die("can't get current context");
if (compute_trans) {
security_context_t file_context, new_context;
command);
if (security_compute_create(cur_context, file_context,
SECCLASS_PROCESS, &new_context))
- bb_error_msg_and_die("unable to compute a new context");
+ bb_simple_error_msg_and_die("unable to compute a new context");
cur_context = new_context;
}
if (!(opts & OPTS_CONTEXT_COMPONENT)) {
context = *argv++;
if (!argv[0])
- bb_error_msg_and_die("no command given");
+ bb_simple_error_msg_and_die("no command given");
}
if (context) {
return 0;
error:
- bb_perror_msg_and_die("libselinux returns unknown state");
+ bb_simple_perror_msg_and_die("libselinux returns unknown state");
}
continue;
rc = security_setenforce(i & 1);
if (rc < 0)
- bb_perror_msg_and_die("setenforce() failed");
+ bb_simple_perror_msg_and_die("setenforce() failed");
return 0;
}
{
nerr++;
if (nerr > 9 && !FLAG_d_debug) {
- bb_error_msg_and_die("exiting after 10 errors");
+ bb_simple_error_msg_and_die("exiting after 10 errors");
}
}
}
if (security_set_boolean(argv[1], value) < 0)
- bb_error_msg_and_die("can't set boolean");
+ bb_simple_error_msg_and_die("can't set boolean");
return 0;
}
if (msg)
bb_error_msg("syntax error: %s", msg);
else
- bb_error_msg("syntax error");
+ bb_simple_error_msg("syntax error");
die_if_script();
}
fp->cur = fp->buf;
n = safe_read(fp->fd, fp->buf, sizeof(fp->buf));
if (n < 0) {
- bb_perror_msg("read error");
+ bb_simple_perror_msg("read error");
n = 0;
}
fp->end = fp->buf + n;
eq_sign = strchr(str, '=');
if (HUSH_DEBUG && !eq_sign)
- bb_error_msg_and_die("BUG in setvar");
+ bb_simple_error_msg_and_die("BUG in setvar");
name_len = eq_sign - str + 1; /* including '=' */
cur_pp = &G.top_var;
eq = strchr(*s, '=');
if (HUSH_DEBUG && !eq)
- bb_error_msg_and_die("BUG in varexp4");
+ bb_simple_error_msg_and_die("BUG in varexp4");
var_pp = get_ptr_to_local_var(*s, eq - *s);
if (var_pp) {
var_p = *var_pp;
//TODO: this is the place to catch ">&file" bashism (redirect both fd 1 and 2)
- bb_error_msg("ambiguous redirect");
+ bb_simple_error_msg("ambiguous redirect");
return REDIRFD_SYNTAX_ERR;
}
} else {
if (HUSH_DEBUG)
if (list[1])
- bb_error_msg_and_die("BUG in varexp2");
+ bb_simple_error_msg_and_die("BUG in varexp2");
/* actually, just move string 2*sizeof(char*) bytes back */
overlapping_strcpy((char*)list, list[0]);
if (do_unbackslash)
if (argv[0][0] == '/')
execve(argv[0], argv, pp);
xfunc_error_retval = 127;
- bb_error_msg_and_die("can't re-execute the shell");
+ bb_simple_error_msg_and_die("can't re-execute the shell");
}
#endif /* !BB_MMU */
G.var_nest_level--;
debug_printf_env("var_nest_level-- %u\n", G.var_nest_level);
if (HUSH_DEBUG && (int)G.var_nest_level < 0)
- bb_error_msg_and_die("BUG: nesting underflow");
+ bb_simple_error_msg_and_die("BUG: nesting underflow");
remove_nested_vars();
}
childpid = waitpid(-1, &status, attributes);
if (childpid <= 0) {
if (childpid && errno != ECHILD)
- bb_perror_msg("waitpid");
+ bb_simple_perror_msg("waitpid");
#if ENABLE_HUSH_FAST
else { /* Until next SIGCHLD, waitpid's are useless */
G.we_have_children = (childpid == 0);
argv_expanded = NULL;
if (command->pid < 0) { /* [v]fork failed */
/* Clearly indicate, was it fork or vfork */
- bb_perror_msg(BB_MMU ? "vfork"+1 : "vfork");
+ bb_simple_perror_msg(BB_MMU ? "vfork"+1 : "vfork");
} else {
pi->alive_cmds++;
#if ENABLE_HUSH_JOB
}
if ((uintptr_t)r > 1) {
- bb_error_msg("%s", r);
+ bb_simple_error_msg(r);
r = (char*)(uintptr_t)1;
}
if (opts == (unsigned)-1)
return EXIT_FAILURE;
if (opts == 3) {
- bb_error_msg("unset: -v and -f are exclusive");
+ bb_simple_error_msg("unset: -v and -f are exclusive");
return EXIT_FAILURE;
}
argv += optind;
optstring = *++argv;
if (!optstring || !(var = *++argv)) {
- bb_error_msg("usage: getopts OPTSTRING VAR [ARGS]");
+ bb_simple_error_msg("usage: getopts OPTSTRING VAR [ARGS]");
return EXIT_FAILURE;
}
}
if (!argv[1]) { /* no second arg */
- bb_error_msg("trap: invalid arguments");
+ bb_simple_error_msg("trap: invalid arguments");
return EXIT_FAILURE;
}
/* It is "%%", "%+" or "%" - current job */
jobnum = G.last_jobid;
if (jobnum == 0) {
- bb_error_msg("no current job");
+ bb_simple_error_msg("no current job");
return NULL;
}
}
delete_finished_job(pi);
return EXIT_SUCCESS;
}
- bb_perror_msg("kill (SIGCONT)");
+ bb_simple_perror_msg("kill (SIGCONT)");
}
if (argv[0][0] == 'f') {
limit.rlim_cur = val;
//bb_error_msg("setrlimit(%d, %lld, %lld)", limits_tbl[i].cmd, (long long)limit.rlim_cur, (long long)limit.rlim_max);
if (setrlimit(limits_tbl[i].cmd, &limit) < 0) {
- bb_perror_msg("error setting limit");
+ bb_simple_perror_msg("error setting limit");
return EXIT_FAILURE;
}
}
if (n < 0) {
if (errno == EINTR)
continue;
- bb_perror_msg(READ_ERROR);
+ bb_simple_perror_msg(READ_ERROR);
break;
}
start[n] = '\0';
}
#else
/* On Linux, shmdt is not mandatory on exit */
-# define error_exit(str) bb_perror_msg_and_die(str)
+# define error_exit(str) bb_simple_perror_msg_and_die(str)
#endif
/*
G.shmid = shmget(KEY_ID, G.shm_size, IPC_CREAT | 0644);
if (G.shmid == -1) {
- bb_perror_msg_and_die("shmget");
+ bb_simple_perror_msg_and_die("shmget");
}
G.shbuf = shmat(G.shmid, NULL, 0);
if (G.shbuf == (void*) -1L) { /* shmat has bizarre error return */
- bb_perror_msg_and_die("shmat");
+ bb_simple_perror_msg_and_die("shmat");
}
memset(G.shbuf, 0, G.shm_size);
if (G.s_semid != -1)
return;
}
- bb_perror_msg_and_die("semget");
+ bb_simple_perror_msg_and_die("semget");
}
}
int len;
if (semop(G.s_semid, G.SMwdn, 3) == -1) {
- bb_perror_msg_and_die("SMwdn");
+ bb_simple_perror_msg_and_die("SMwdn");
}
/* Circular Buffer Algorithm:
goto again;
}
if (semop(G.s_semid, G.SMwup, 1) == -1) {
- bb_perror_msg_and_die("SMwup");
+ bb_simple_perror_msg_and_die("SMwup");
}
if (DEBUG)
printf("tail:%d\n", G.shbuf->tail);
const char *args[] = { "run-parts", handler, NULL };
// log the event
- bb_error_msg("%s", event);
+ bb_simple_error_msg(event);
// spawn handler
// N.B. run-parts would require scripts to have #!/bin/sh
opts = getopt32(argv, "cs:+n:+r", &len, &level);
if (opts & OPT_n) {
if (klogctl(8, NULL, (long) level))
- bb_perror_msg_and_die("klogctl");
+ bb_simple_perror_msg_and_die("klogctl");
return EXIT_SUCCESS;
}
buf = xmalloc(len);
len = klogctl(3 + (opts & OPT_c), buf, len); /* read ring buffer */
if (len < 0)
- bb_perror_msg_and_die("klogctl");
+ bb_simple_perror_msg_and_die("klogctl");
if (len == 0)
return EXIT_SUCCESS;
sg_io_hdr_t io_hdr;
if ((ioctl(dev_fd, SG_GET_VERSION_NUM, &i) < 0) || (i < 30000))
- bb_error_msg_and_die("not a sg device or old sg driver");
+ bb_simple_error_msg_and_die("not a sg device or old sg driver");
memset(&io_hdr, 0, sizeof(sg_io_hdr_t));
io_hdr.interface_id = 'S';
read_bytes = safe_read(fd, data, n);
if (read_bytes != n) {
if (read_bytes < 0) {
- bb_perror_msg(bb_msg_read_error);
+ bb_simple_perror_msg(bb_msg_read_error);
}
bb_error_msg_and_die("problem reading cylinder %d, "
"expected %d, read %d", cyl, n, read_bytes);
* we support can't record more than 32 bit
* sector counts or offsets
*/
- bb_error_msg("device has more than 2^32 sectors, can't use all of them");
+ bb_simple_error_msg("device has more than 2^32 sectors, can't use all of them");
v64 = (uint32_t)-1L;
}
return v64;
) {
argv++;
if (argv[1])
- bb_error_msg_and_die("-c takes only one argument");
+ bb_simple_error_msg_and_die("-c takes only one argument");
opt |= OPT_c;
}
{
if (termios_set)
tcsetattr_stdin_TCSANOW(&sv_termios);
- bb_error_msg_and_die("%s", str);
+ bb_simple_error_msg_and_die(str);
}
static void push_filename(const char *name)
}
tokptr[tlen] = '\0';
if (tlen == 0)
- bb_error_msg_and_die("empty long option specified");
+ bb_simple_error_msg_and_die("empty long option specified");
}
long_options = xrealloc_vector(long_options, 4, long_nr);
long_options[long_nr].has_arg = arg_opt;
puts(" --");
return 0;
}
- bb_error_msg_and_die("missing optstring argument");
+ bb_simple_error_msg_and_die("missing optstring argument");
}
if (argv[1][0] != '-' || compatible) {
if (!optstr) {
optstr = argv[++n];
if (!optstr)
- bb_error_msg_and_die("missing optstring argument");
+ bb_simple_error_msg_and_die("missing optstring argument");
}
argv[n] = name ? name : argv[0];
tv.tv_sec = read_rtc(pp_rtcname, NULL, utc);
tv.tv_usec = 0;
if (settimeofday(&tv, &tz))
- bb_perror_msg_and_die("settimeofday");
+ bb_simple_perror_msg_and_die("settimeofday");
}
static void from_sys_clock(const char **pp_rtcname, int utc)
if (!utc)
tv.tv_sec += tz.tz_minuteswest * 60;
if (settimeofday(&tv, &tz))
- bb_perror_msg_and_die("settimeofday");
+ bb_simple_perror_msg_and_die("settimeofday");
}
//usage:#define hwclock_trivial_usage
struct ipc_perm *ipcp = &shmds.shm_perm;
if (shmctl(shmid, IPC_STAT, &shmds) == -1) {
- bb_perror_msg("shmctl");
+ bb_simple_perror_msg("shmctl");
return;
}
struct ipc_perm *ipcp = &buf.msg_perm;
if (msgctl(msqid, IPC_STAT, &buf) == -1) {
- bb_perror_msg("msgctl");
+ bb_simple_perror_msg("msgctl");
return;
}
arg.buf = &semds;
if (semctl(semid, 0, IPC_STAT, arg)) {
- bb_perror_msg("semctl");
+ bb_simple_perror_msg("semctl");
return;
}
zcnt = semctl(semid, i, GETZCNT, arg);
pid = semctl(semid, i, GETPID, arg);
if (val < 0 || ncnt < 0 || zcnt < 0 || pid < 0) {
- bb_perror_msg_and_die("semctl");
+ bb_simple_perror_msg_and_die("semctl");
}
printf("%-10u %-10d %-10d %-10d %-10d\n", i, val, ncnt, zcnt, pid);
}
pos = lseek(file, pos - sizeof(ut), SEEK_SET);
while ((n = full_read(file, &ut, sizeof(ut))) > 0) {
if (n != sizeof(ut)) {
- bb_perror_msg_and_die("short read");
+ bb_simple_perror_msg_and_die("short read");
}
n = index_in_strings(_ut_lin, ut.ut_line);
if (n == _TILDE) { /* '~' */
n = get_free_loop();
if (n == -1)
- bb_error_msg_and_die("no free loop devices");
+ bb_simple_error_msg_and_die("no free loop devices");
if (n < 0) /* n == -2: no /dev/loop-control, use legacy method */
n = 0;
/* or: n >= 0: the number of next free loopdev, just verify it */
do {
if (n > MAX_LOOP_NUM)
- bb_error_msg_and_die("no free loop devices");
+ bb_simple_error_msg_and_die("no free loop devices");
sprintf(dev, LOOP_FORMAT, n++);
s = query_loop(dev);
free(s);
#if DEBUG_LVL >= 1
# define dbg1(...) do { if (G.verbose) bb_error_msg(__VA_ARGS__); } while(0)
+# define dbg1s(msg) do { if (G.verbose) bb_simple_error_msg(msg); } while(0)
#else
# define dbg1(...) ((void)0)
+# define dbg1s(msg) ((void)0)
#endif
#if DEBUG_LVL >= 2
# define dbg2(...) do { if (G.verbose >= 2) bb_error_msg(__VA_ARGS__); } while(0)
+# define dbg2s(msg) do { if (G.verbose >= 2) bb_simple_error_msg(msg); } while(0)
#else
# define dbg2(...) ((void)0)
+# define dbg2s(msg) ((void)0)
#endif
#if DEBUG_LVL >= 3
# define dbg3(...) do { if (G.verbose >= 3) bb_error_msg(__VA_ARGS__); } while(0)
+# define dbg3s(msg) do { if (G.verbose >= 3) bb_simple_error_msg(msg); } while(0)
#else
# define dbg3(...) ((void)0)
+# define dbg3s(msg) ((void)0)
#endif
/* seed file: write out seq ASAP */
xwrite_str(seq_fd, utoa(expected_seq));
xlseek(seq_fd, 0, SEEK_SET);
- dbg2("first seq written");
+ dbg2s("first seq written");
break;
}
seqbufnum = atoll(seqbuf);
len = safe_read(fd, netbuf, sizeof(netbuf) - 1);
if (len < 0) {
- bb_perror_msg_and_die("read");
+ bb_simple_perror_msg_and_die("read");
}
end = netbuf + len;
*end = '\0';
*/
if (!isatty(STDIN_FILENO))
- bb_error_msg_and_die("not a tty");
+ bb_simple_error_msg_and_die("not a tty");
xfstat(STDIN_FILENO, &sb, "stdin");
if (c == 0) {
// N.B. what if we format a file? find_mount_point will return false negative since
// it is loop block device which is mounted!
if (find_mount_point(argv[0], 0))
- bb_error_msg_and_die("can't format mounted filesystem");
+ bb_simple_error_msg_and_die("can't format mounted filesystem");
// get size in kbytes
kilobytes = get_volume_size_in_bytes(fd, argv[1], 1024, /*extend:*/ !(option_mask32 & OPT_n)) / 1024;
kilobytes >>= (blocksize_log2 - EXT2_MIN_BLOCK_LOG_SIZE);
nblocks = kilobytes;
if (nblocks != kilobytes)
- bb_error_msg_and_die("block count doesn't fit in 32 bits");
+ bb_simple_error_msg_and_die("block count doesn't fit in 32 bits");
#define kilobytes kilobytes_unused_after_this
// Experimentally, standard mke2fs won't work on images smaller than 60k
if (nblocks < 60)
- bb_error_msg_and_die("need >= 60 blocks");
+ bb_simple_error_msg_and_die("need >= 60 blocks");
// How many reserved blocks?
if (reserved_percent > 50)
int blk;
if (G.used_good_blocks + 1 >= MAX_GOOD_BLOCKS)
- bb_error_msg_and_die("too many bad blocks");
+ bb_simple_error_msg_and_die("too many bad blocks");
if (G.used_good_blocks)
blk = G.good_blocks_table[G.used_good_blocks - 1] + 1;
else
while (blk < SB_ZONES && zone_in_use(blk))
blk++;
if (blk >= SB_ZONES)
- bb_error_msg_and_die("not enough good blocks");
+ bb_simple_error_msg_and_die("not enough good blocks");
G.good_blocks_table[G.used_good_blocks] = blk;
G.used_good_blocks++;
return blk;
goto end_bad;
}
}
- bb_error_msg_and_die("too many bad blocks");
+ bb_simple_error_msg_and_die("too many bad blocks");
end_bad:
if (ind)
write_block(ind, (char *) ind_block);
}
}
/* Could make triple indirect block here */
- bb_error_msg_and_die("too many bad blocks");
+ bb_simple_error_msg_and_die("too many bad blocks");
end_bad:
if (ind)
write_block(ind, (char *) ind_block);
if (got == try)
continue;
if (G.currently_testing < SB_FIRSTZONE)
- bb_error_msg_and_die("bad blocks before data-area: cannot make fs");
+ bb_simple_error_msg_and_die("bad blocks before data-area: cannot make fs");
mark_zone(G.currently_testing);
G.badblocks++;
G.currently_testing++;
SB_ZMAPS = sb_zmaps;
/* new SB_ZMAPS, need to recalc NORM_FIRSTZONE */
} while (--i);
- bb_error_msg_and_die("incompatible size/inode count, try different -i N");
+ bb_simple_error_msg_and_die("incompatible size/inode count, try different -i N");
got_it:
SB_FIRSTZONE = norm_firstzone;
G.magic = MINIX1_SUPER_MAGIC2;
if (INODE_SIZE1 * MINIX1_INODES_PER_BLOCK != BLOCK_SIZE)
- bb_error_msg_and_die("bad inode size");
+ bb_simple_error_msg_and_die("bad inode size");
#if ENABLE_FEATURE_MINIX2
if (INODE_SIZE2 * MINIX2_INODES_PER_BLOCK != BLOCK_SIZE)
- bb_error_msg_and_die("bad inode size");
+ bb_simple_error_msg_and_die("bad inode size");
#endif
opt = getopt32(argv, "ci:l:n:+v", &str_i, &listfile, &G.namelen);
#if ENABLE_FEATURE_MINIX2
version2 = 1;
#else
- bb_error_msg_and_die("not compiled with minix v2 support");
+ bb_simple_error_msg_and_die("not compiled with minix v2 support");
#endif
}
/* Check if it is mounted */
if (find_mount_point(G.device_name, 0))
- bb_error_msg_and_die("can't format mounted filesystem");
+ bb_simple_error_msg_and_die("can't format mounted filesystem");
xmove_fd(xopen(G.device_name, O_RDWR), dev_fd);
G.total_blocks = get_volume_size_in_bytes(dev_fd, argv[1], 1024, /*extend:*/ 1) / 1024;
if (G.total_blocks < 10)
- bb_error_msg_and_die("must have at least 10 blocks");
+ bb_simple_error_msg_and_die("must have at least 10 blocks");
if (version2) {
G.magic = MINIX2_SUPER_MAGIC2;
// N.B. what if we format a file? find_mount_point will return false negative since
// it is loop block device which is mounted!
if (find_mount_point(argv[0], 0))
- bb_error_msg_and_die("can't format mounted filesystem");
+ bb_simple_error_msg_and_die("can't format mounted filesystem");
// open the device, get size in blocks
blocks = get_volume_size_in_bytes(fd, argv[1], blocksize, /*extend:*/ 1) / blocksize;
if (!S_ISBLK(st.st_mode)) {
if (!S_ISREG(st.st_mode)) {
if (!argv[1])
- bb_error_msg_and_die("image size must be specified");
+ bb_simple_error_msg_and_die("image size must be specified");
}
// not a block device, skip bad sectors check
opts &= ~OPT_c;
// "mkdosfs -v -F 32 image5k 5" is the minimum:
// 2 sectors for FATs and 2 data sectors
if ((off_t)(volume_size_sect - reserved_sect) < 4)
- bb_error_msg_and_die("the image is too small for FAT32");
+ bb_simple_error_msg_and_die("the image is too small for FAT32");
sect_per_fat = 1;
while (1) {
while (1) {
}
next:
if (sect_per_clust == 128)
- bb_error_msg_and_die("can't make FAT32 with >128 sectors/cluster");
+ bb_simple_error_msg_and_die("can't make FAT32 with >128 sectors/cluster");
sect_per_clust *= 2;
sect_per_fat = (sect_per_fat / 2) | 1;
}
}
return;
error:
- bb_perror_msg_and_die("SELinux relabeling failed");
+ bb_simple_perror_msg_and_die("SELinux relabeling failed");
}
#else
# define mkswap_selinux_setcontext(fd, path) ((void)0)
mountTable = setmntent(bb_path_mtab_file, "r");
if (!mountTable) {
- bb_perror_msg(bb_path_mtab_file);
+ bb_simple_perror_msg(bb_path_mtab_file);
return;
}
}
endmntent(mountTable);
} else if (errno != EROFS)
- bb_perror_msg(bb_path_mtab_file);
+ bb_simple_perror_msg(bb_path_mtab_file);
if (ENABLE_FEATURE_CLEAN_UP) {
for (i = 0; i < count; i++) {
// Abort entirely if permission denied.
if (rc && errno == EPERM)
- bb_error_msg_and_die(bb_msg_perm_denied_are_you_root);
+ bb_simple_error_msg_and_die(bb_msg_perm_denied_are_you_root);
// If the mount was successful, and we're maintaining an old-style
// mtab file by hand, add the new entry to it now.
int i;
if (!mountTable) {
- bb_perror_msg(bb_path_mtab_file);
+ bb_simple_perror_msg(bb_path_mtab_file);
goto ret;
}
s = strchr(hostname, ',');
if (s) {
*s = '\0';
- bb_error_msg("warning: multiple hostnames not supported");
+ bb_simple_error_msg("warning: multiple hostnames not supported");
}
server_addr.sin_family = AF_INET;
if (!inet_aton(hostname, &server_addr.sin_addr)) {
hp = gethostbyname(hostname);
if (hp == NULL) {
- bb_herror_msg("%s", hostname);
+ bb_simple_herror_msg(hostname);
goto fail;
}
if (hp->h_length != (int)sizeof(struct in_addr)) {
- bb_error_msg_and_die("only IPv4 is supported");
+ bb_simple_error_msg_and_die("only IPv4 is supported");
}
memcpy(&server_addr.sin_addr, hp->h_addr_list[0], sizeof(struct in_addr));
}
else if (is_prefixed_with(opteq, "udp"))
tcp = 0;
else
- bb_error_msg("warning: unrecognized proto= option");
+ bb_simple_error_msg("warning: unrecognized proto= option");
continue;
case 20: // "addr" - ignore
continue;
if (nfs_mount_version >= 3)
nolock = !val;
else
- bb_error_msg("warning: option nolock is not supported");
+ bb_simple_error_msg("warning: option nolock is not supported");
break;
case 11: //rdirplus
nordirplus = !val;
} else {
hp = gethostbyname(mounthost);
if (hp == NULL) {
- bb_herror_msg("%s", mounthost);
+ bb_simple_herror_msg(mounthost);
goto fail;
}
if (hp->h_length != (int)sizeof(struct in_addr)) {
- bb_error_msg_and_die("only IPv4 is supported");
+ bb_simple_error_msg_and_die("only IPv4 is supported");
}
mount_server_addr.sin_family = AF_INET;
memcpy(&mount_server_addr.sin_addr, hp->h_addr_list[0], sizeof(struct in_addr));
/* Create nfs socket for kernel */
if (tcp) {
if (nfs_mount_version < 3) {
- bb_error_msg("NFS over TCP is not supported");
+ bb_simple_error_msg("NFS over TCP is not supported");
goto fail;
}
fsock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
} else
fsock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
if (fsock < 0) {
- bb_perror_msg("nfs socket");
+ bb_simple_perror_msg("nfs socket");
goto fail;
}
if (bindresvport(fsock, 0) < 0) {
- bb_perror_msg("nfs bindresvport");
+ bb_simple_perror_msg("nfs bindresvport");
goto fail;
}
if (port == 0) {
);
if (loopfd < 0) {
if (errno == EPERM || errno == EACCES)
- bb_error_msg(bb_msg_perm_denied_are_you_root);
+ bb_simple_error_msg(bb_msg_perm_denied_are_you_root);
else
- bb_perror_msg("can't setup loop device");
+ bb_simple_perror_msg("can't setup loop device");
return errno;
}
// argument when we get it.
if (argv[1]) {
if (nonroot)
- bb_error_msg_and_die(bb_msg_you_must_be_root);
+ bb_simple_error_msg_and_die(bb_msg_you_must_be_root);
mtpair->mnt_fsname = argv[0];
mtpair->mnt_dir = argv[1];
mtpair->mnt_type = fstype;
cmdopt_flags = parse_mount_options(cmdopts, NULL);
if (nonroot && (cmdopt_flags & ~MS_SILENT)) // Non-root users cannot specify flags
- bb_error_msg_and_die(bb_msg_you_must_be_root);
+ bb_simple_error_msg_and_die(bb_msg_you_must_be_root);
// If we have a shared subtree flag, don't worry about fstab or mtab.
if (ENABLE_FEATURE_MOUNT_FLAGS
// No, mount -a won't mount anything,
// even user mounts, for mere humans
if (nonroot)
- bb_error_msg_and_die(bb_msg_you_must_be_root);
+ bb_simple_error_msg_and_die(bb_msg_you_must_be_root);
// Does type match? (NULL matches always)
if (!fstype_matches(mtcur->mnt_type, fstype))
// fstab must have "users" or "user"
l = parse_mount_options(mtcur->mnt_opts, NULL);
if (!(l & MOUNT_USERS))
- bb_error_msg_and_die(bb_msg_you_must_be_root);
+ bb_simple_error_msg_and_die(bb_msg_you_must_be_root);
}
//util-linux-2.12 does not do this check.
if (opts & OPT_setgid) {
if (setgroups(0, NULL) < 0 && setgroups_failed)
- bb_perror_msg_and_die("setgroups");
+ bb_simple_perror_msg_and_die("setgroups");
xsetgid(gid);
}
if (opts & OPT_setuid)
static void socket_timeout(int sig UNUSED_PARAM)
{
- bb_error_msg_and_die("timeout connecting to time server");
+ bb_simple_error_msg_and_die("timeout connecting to time server");
}
static time_t askremotedate(const char *host)
if (!(flags & 2)) { /* no -p (-s may be present) */
if (time(NULL) == remote_time)
- bb_error_msg("current time matches remote time");
+ bb_simple_error_msg("current time matches remote time");
else
if (stime(&remote_time) < 0)
- bb_perror_msg_and_die("can't set time of day");
+ bb_simple_perror_msg_and_die("can't set time of day");
}
if (flags != 1) /* not lone -s */
small++;
}
if (big > small) {
- bb_error_msg("assuming reversed byte order, "
+ bb_simple_error_msg("assuming reversed byte order, "
"use -n to force native byte order");
BUILD_BUG_ON(sizeof(*p) > 8);
for (p = buf; p < buf+len; p++) {
}
if (indx >= len)
- bb_error_msg_and_die("profile address out of range. "
+ bb_simple_error_msg_and_die("profile address out of range. "
"Wrong map file?");
this = 0;
do {
ssize_t ret = safe_read(fd, &data, sizeof(data));
if (ret < 0) {
- bb_perror_msg("rtc read");
+ bb_simple_perror_msg("rtc read");
break;
}
} while (!(data & RTC_AF));
}
if (capset(&caps.header, caps.data) != 0)
- bb_perror_msg_and_die("capset");
+ bb_simple_perror_msg_and_die("capset");
}
static void set_ambient_caps(char *string)
idx = parse_cap(cap);
if (cap[0] == '+') {
if (prctl(PR_CAP_AMBIENT, PR_CAP_AMBIENT_RAISE, idx, 0, 0) < 0)
- bb_perror_msg("cap_ambient_raise");
+ bb_simple_perror_msg("cap_ambient_raise");
} else {
if (prctl(PR_CAP_AMBIENT, PR_CAP_AMBIENT_LOWER, idx, 0, 0) < 0)
- bb_perror_msg("cap_ambient_lower");
+ bb_simple_perror_msg("cap_ambient_lower");
}
cap = strtok(NULL, ",");
}
unsigned idx = CAP_TO_INDEX(i);
if (idx >= caps.u32s) {
printf("\nindex: %u u32s: %u capability: %u\n", idx, caps.u32s, i);
- bb_error_msg_and_die("unsupported capability");
+ bb_simple_error_msg_and_die("unsupported capability");
}
if (caps.data[idx].inheritable & CAP_TO_MASK(i)) {
printf_cap(fmt, i);
getcaps(&caps);
caps.data[CAP_TO_INDEX(cap_idx)].inheritable &= ~CAP_TO_MASK(cap_idx);
if (capset(&caps.header, caps.data) != 0)
- bb_perror_msg_and_die("capset");
+ bb_simple_perror_msg_and_die("capset");
}
static void drop_bounding_set(int cap_idx)
if ((unsigned)stfs.f_type != RAMFS_MAGIC
&& (unsigned)stfs.f_type != TMPFS_MAGIC
) {
- bb_error_msg_and_die("root filesystem is not ramfs/tmpfs");
+ bb_simple_error_msg_and_die("root filesystem is not ramfs/tmpfs");
}
if (!dry_run) {
// Overmount / with newdir and chroot into it
if (mount(".", "/", NULL, MS_MOVE, NULL)) {
// For example, fails when newroot is not a mountpoint
- bb_perror_msg_and_die("error moving root");
+ bb_simple_perror_msg_and_die("error moving root");
}
}
xchroot(".");
MAP_PRIVATE | MAP_ANON,
/* ignored: */ -1, 0);
if (netbuf == MAP_FAILED)
- bb_perror_msg_and_die("mmap");
+ bb_simple_perror_msg_and_die("mmap");
// Here we block, possibly for a very long time
len = safe_read(fd, netbuf, BUFFER_SIZE - 1);
if (len < 0)
- bb_perror_msg_and_die("read");
+ bb_simple_perror_msg_and_die("read");
end = netbuf + len;
*end = '\0';
if (setgrp_str) {
if (strcmp(setgrp_str, "allow") == 0) {
if (opts & OPT_map_root) {
- bb_error_msg_and_die(
+ bb_simple_error_msg_and_die(
"--setgroups=allow and --map-root-user "
"are mutually exclusive"
);
projects / oweals / busybox.git / commitdiff