diff options
Diffstat (limited to 'cmd')
| -rw-r--r-- | cmd/Kconfig | 8 | ||||
| -rw-r--r-- | cmd/Makefile | 1 | ||||
| -rw-r--r-- | cmd/printf.c | 647 | ||||
| -rw-r--r-- | cmd/printf.h | 8 | ||||
| -rw-r--r-- | cmd/setexpr.c | 37 |
5 files changed, 697 insertions, 4 deletions
diff --git a/cmd/Kconfig b/cmd/Kconfig index e40d390f88..f1bcf9ebde 100644 --- a/cmd/Kconfig +++ b/cmd/Kconfig @@ -1414,6 +1414,14 @@ config CMD_SETEXPR Also supports loading the value at a memory location into a variable. If CONFIG_REGEX is enabled, setexpr also supports a gsub function. +config CMD_SETEXPR_FMT + bool "setexpr_fmt" + default n + depends on CMD_SETEXPR + help + Evaluate format string expression and store result in an environment + variable. + endmenu menu "Android support commands" diff --git a/cmd/Makefile b/cmd/Makefile index 9d10e07f0e..ed3669411e 100644 --- a/cmd/Makefile +++ b/cmd/Makefile @@ -141,6 +141,7 @@ obj-$(CONFIG_CMD_SF) += sf.o obj-$(CONFIG_CMD_SCSI) += scsi.o disk.o obj-$(CONFIG_CMD_SHA1SUM) += sha1sum.o obj-$(CONFIG_CMD_SETEXPR) += setexpr.o +obj-$(CONFIG_CMD_SETEXPR_FMT) += printf.o obj-$(CONFIG_CMD_SPI) += spi.o obj-$(CONFIG_CMD_STRINGS) += strings.o obj-$(CONFIG_CMD_SMC) += smccc.o diff --git a/cmd/printf.c b/cmd/printf.c new file mode 100644 index 0000000000..e024676743 --- /dev/null +++ b/cmd/printf.c @@ -0,0 +1,647 @@ +// SPDX-License-Identifier: GPL-2.0+ +/* + * Copyright (C) 2021 Weidmüller Interface GmbH & Co. KG + * Roland Gaudig <roland.gaudig@weidmueller.com> + * + * Copyright 1999 Dave Cinege + * Portions copyright (C) 1990-1996 Free Software Foundation, Inc. + * + * Licensed under GPLv2 or later, see file LICENSE in this source tree. + */ +/* + * This file provides a shell printf like format string expansion as required + * for the setexpr <name> fmt <format> <value> command. + * This source file was mostly taken from the BusyBox project (www.busybox.net) + * In contrast to the original sources the output is not written to stdout + * anymore but into a char array, which can be used as input for the env_set() + * function. + */ +/* Usage: printf format [argument...] + * + * A front end to the printf function that lets it be used from the shell. + * + * Backslash escapes: + * + * \" = double quote + * \\ = backslash + * \a = alert (bell) + * \b = backspace + * \c = produce no further output + * \f = form feed + * \n = new line + * \r = carriage return + * \t = horizontal tab + * \v = vertical tab + * \0ooo = octal number (ooo is 0 to 3 digits) + * \xhhh = hexadecimal number (hhh is 1 to 3 digits) + * + * Additional directive: + * + * %b = print an argument string, interpreting backslash escapes + * + * The 'format' argument is re-used as many times as necessary + * to convert all of the given arguments. + * + * David MacKenzie <djm@gnu.ai.mit.edu> + */ +/* 19990508 Busy Boxed! Dave Cinege */ + +//config:config PRINTF +//config: bool "printf (3.8 kb)" +//config: default y +//config: help +//config: printf is used to format and print specified strings. +//config: It's similar to 'echo' except it has more options. + +//applet:IF_PRINTF(APPLET_NOFORK(printf, printf, BB_DIR_USR_BIN, BB_SUID_DROP, printf)) + +//kbuild:lib-$(CONFIG_PRINTF) += printf.o +//kbuild:lib-$(CONFIG_ASH_PRINTF) += printf.o +//kbuild:lib-$(CONFIG_HUSH_PRINTF) += printf.o + +//usage:#define printf_trivial_usage +//usage: "FORMAT [ARG]..." +//usage:#define printf_full_usage "\n\n" +//usage: "Format and print ARG(s) according to FORMAT (a-la C printf)" +//usage: +//usage:#define printf_example_usage +//usage: "$ printf \"Val=%d\\n\" 5\n" +//usage: "Val=5\n" + +/* A note on bad input: neither bash 3.2 nor coreutils 6.10 stop on it. + * They report it: + * bash: printf: XXX: invalid number + * printf: XXX: expected a numeric value + * bash: printf: 123XXX: invalid number + * printf: 123XXX: value not completely converted + * but then they use 0 (or partially converted numeric prefix) as a value + * and continue. They exit with 1 in this case. + * Both accept insane field width/precision (e.g. %9999999999.9999999999d). + * Both print error message and assume 0 if %*.*f width/precision is "bad" + * (but negative numbers are not "bad"). + * Both accept negative numbers for %u specifier. + * + * We try to be compatible. + */ + +#include <common.h> +#include <ctype.h> +#include <errno.h> +#include <stddef.h> +#include <stdio.h> +#include <stdlib.h> + +#define WANT_HEX_ESCAPES 0 +#define PRINT_CONVERSION_ERROR 1 +#define PRINT_TRUNCATED_ERROR 2 +#define PRINT_SIZE_ERROR 4 + +struct print_inf { + char *str; + size_t size; + size_t offset; + unsigned int error; +}; + +typedef void (*converter)(const char *arg, void *result); + +/** + * printf_str() - print formatted into char array with length checks + * + * This function povides a printf like function for printing into a char array + * with checking the boundaries. + * Unlike snprintf, all checks are performed inside this function and status + * reports are stored inside the print_inf struct. That way, this function can + * be used almost as drop-in replacement without needing much code changes. + * Unlike snprintf errors are not reported by return value, but inside the + * error member of struct print_inf. The output stored inside the struct + * print_inf str member shall only be used when the error member is 0. + * + * @inf: Info structure for print operation + * @char: format string with optional arguments + */ +static void printf_str(struct print_inf *inf, char *format, ...) +{ + va_list args; + int i; + + if (!inf) + return; + + /* Do not write anything if previous error is pending */ + if (inf->error) + return; + + /* Check if end of receiving buffer is already reached */ + if (inf->offset >= inf->size) { + inf->error |= PRINT_SIZE_ERROR; + return; + } + + size_t remaining = inf->size - inf->offset; + + va_start(args, format); + i = vsnprintf(inf->str + inf->offset, remaining, format, args); + va_end(args); + + if (i >= remaining) + inf->error |= PRINT_TRUNCATED_ERROR; + else if (i < 0) + inf->error |= PRINT_CONVERSION_ERROR; + else + inf->offset += i; +} + +/** + * putchar_str() - Print single character into char array with length checks + * + * This function provices a putchar like function, which stores the output + * into a char array with checking boundaries. + * + * @inf: Info structure for print operation + * @char: Single character to be printed + */ +static void putchar_str(struct print_inf *inf, char c) +{ + printf_str(inf, "%c", c); +} + +static char process_escape_sequence(const char **ptr) +{ + const char *q; + unsigned int num_digits; + unsigned int n; + unsigned int base; + + num_digits = 0; + n = 0; + base = 8; + q = *ptr; + + if (WANT_HEX_ESCAPES && *q == 'x') { + ++q; + base = 16; + ++num_digits; + } + + /* bash requires leading 0 in octal escapes: + * \02 works, \2 does not (prints \ and 2). + * We treat \2 as a valid octal escape sequence. + */ + do { + unsigned int r; + unsigned int d = (unsigned char)(*q) - '0'; +#if WANT_HEX_ESCAPES + if (d >= 10) { + d = (unsigned char)tolower(*q) - 'a'; + //d += 10; + /* The above would map 'A'-'F' and 'a'-'f' to 10-15, + * however, some chars like '@' would map to 9 < base. + * Do not allow that, map invalid chars to N > base: + */ + if ((int)d >= 0) + d += 10; + } +#endif + if (d >= base) { + if (WANT_HEX_ESCAPES && base == 16) { + --num_digits; + if (num_digits == 0) { + /* \x<bad_char>: return '\', + * leave ptr pointing to x + */ + return '\\'; + } + } + break; + } + + r = n * base + d; + if (r > 255) + break; + + n = r; + ++q; + } while (++num_digits < 3); + + if (num_digits == 0) { + /* Not octal or hex escape sequence. + * Is it one-letter one? + */ + /* bash builtin "echo -e '\ec'" interprets \e as ESC, + * but coreutils "/bin/echo -e '\ec'" does not. + * Manpages tend to support coreutils way. + * Update: coreutils added support for \e on 28 Oct 2009. + */ + static const char charmap[] = { + 'a', 'b', 'e', 'f', 'n', 'r', 't', 'v', '\\', '\0', + '\a', '\b', 27, '\f', '\n', '\r', '\t', '\v', '\\', '\\', + }; + + const char *p = charmap; + + do { + if (*p == *q) { + q++; + break; + } + } while (*++p != '\0'); + /* p points to found escape char or NUL, + * advance it and find what it translates to. + * Note that \NUL and unrecognized sequence \z return '\' + * and leave ptr pointing to NUL or z. + */ + n = p[sizeof(charmap) / 2]; + } + + *ptr = q; + + return (char)n; +} + +static char *skip_whitespace(const char *s) +{ + /* In POSIX/C locale (the only locale we care about: do we REALLY want + * to allow Unicode whitespace in, say, .conf files? nuts!) + * isspace is only these chars: "\t\n\v\f\r" and space. + * "\t\n\v\f\r" happen to have ASCII codes 9,10,11,12,13. + * Use that. + */ + while (*s == ' ' || (unsigned char)(*s - 9) <= (13 - 9)) + s++; + + return (char *)s; +} + +/* Like strcpy but can copy overlapping strings. */ +static void overlapping_strcpy(char *dst, const char *src) +{ + /* Cheap optimization for dst == src case - + * better to have it here than in many callers. + */ + if (dst != src) { + while ((*dst = *src) != '\0') { + dst++; + src++; + } + } +} + +static int multiconvert(const char *arg, void *result, converter convert) +{ + if (*arg == '"' || *arg == '\'') + sprintf((char *)arg + strlen(arg), "%u", (unsigned char)arg[1]); + //errno = 0; + convert(arg, result); + /* Unlike their Posix counterparts, simple_strtoll and + * simple_strtoull do not set errno + * + * if (errno) { + * printf("error invalid number '%s'", arg); + * return 1; + * } + */ + return 0; +} + +static void conv_strtoull(const char *arg, void *result) +{ + /* both coreutils 6.10 and bash 3.2: + * $ printf '%x\n' -2 + * fffffffffffffffe + * Mimic that: + */ + if (arg[0] == '-') { + *(unsigned long long *)result = simple_strtoll(arg, NULL, 16); + return; + } + /* Allow leading '+' - simple_strtoull() by itself does not allow it, + * and probably shouldn't (other callers might require purely numeric + * inputs to be allowed. + */ + if (arg[0] == '+') + arg++; + *(unsigned long long *)result = simple_strtoull(arg, NULL, 16); +} + +static void conv_strtoll(const char *arg, void *result) +{ + if (arg[0] == '+') + arg++; + *(long long *)result = simple_strtoll(arg, NULL, 16); +} + +/* Callers should check errno to detect errors */ +static unsigned long long my_xstrtoull(const char *arg) +{ + unsigned long long result; + + if (multiconvert(arg, &result, conv_strtoull)) + result = 0; + return result; +} + +static long long my_xstrtoll(const char *arg) +{ + long long result; + + if (multiconvert(arg, &result, conv_strtoll)) + result = 0; + return result; +} + +/* Handles %b; return 1 if output is to be short-circuited by \c */ +static int print_esc_string(struct print_inf *inf, const char *str) +{ + char c; + + while ((c = *str) != '\0') { + str++; + if (c == '\\') { + /* %b also accepts 4-digit octals of the form \0### */ + if (*str == '0') { + if ((unsigned char)(str[1] - '0') < 8) { + /* 2nd char is 0..7: skip leading '0' */ + str++; + } + } else if (*str == 'c') { + return 1; + } + { + /* optimization: don't force arg to be on-stack, + * use another variable for that. + */ + const char *z = str; + + c = process_escape_sequence(&z); + str = z; + } + } + putchar_str(inf, c); + } + + return 0; +} + +static void print_direc(struct print_inf *inf, char *format, unsigned int fmt_length, + int field_width, int precision, + const char *argument) +{ + long long llv; + char saved; + char *have_prec, *have_width; + + saved = format[fmt_length]; + format[fmt_length] = '\0'; + + have_prec = strstr(format, ".*"); + have_width = strchr(format, '*'); + if (have_width - 1 == have_prec) + have_width = NULL; + + /* multiconvert sets errno = 0, but %s needs it cleared */ + errno = 0; + + switch (format[fmt_length - 1]) { + case 'c': + printf_str(inf, format, *argument); + break; + case 'd': + case 'i': + llv = my_xstrtoll(skip_whitespace(argument)); + print_long: + if (!have_width) { + if (!have_prec) + printf_str(inf, format, llv); + else + printf_str(inf, format, precision, llv); + } else { + if (!have_prec) + printf_str(inf, format, field_width, llv); + else + printf_str(inf, format, field_width, precision, llv); + } + break; + case 'o': + case 'u': + case 'x': + case 'X': + llv = my_xstrtoull(skip_whitespace(argument)); + /* cheat: unsigned long and long have same width, so... */ + goto print_long; + case 's': + /* Are char* and long long the same? */ + if (sizeof(argument) == sizeof(llv)) { + llv = (long long)(ptrdiff_t)argument; + goto print_long; + } else { + /* Hope compiler will optimize it out by moving call + * instruction after the ifs... + */ + if (!have_width) { + if (!have_prec) + printf_str(inf, format, argument, + /*unused:*/ argument, argument); + else + printf_str(inf, format, precision, + argument, /*unused:*/ argument); + } else { + if (!have_prec) + printf_str(inf, format, field_width, + argument, /*unused:*/ argument); + else + printf_str(inf, format, field_width, + precision, argument); + } + break; + } + break; + } /* switch */ + + format[fmt_length] = saved; +} + +/* Handle params for "%*.*f". Negative numbers are ok (compat). */ +static int get_width_prec(const char *str) +{ + long v = simple_strtol(str, NULL, 10); + + /* Unlike its Posix counterpart, simple_strtol does not set errno + * + * if (errno) { + * printf("error invalid number '%s'", str); + * v = 0; + * } + */ + return (int)v; +} + +/* Print the text in FORMAT, using ARGV for arguments to any '%' directives. + * Return advanced ARGV. + */ +static char **print_formatted(struct print_inf *inf, char *f, char **argv, int *conv_err) +{ + char *direc_start; /* Start of % directive. */ + unsigned int direc_length; /* Length of % directive. */ + int field_width; /* Arg to first '*' */ + int precision; /* Arg to second '*' */ + char **saved_argv = argv; + + for (; *f; ++f) { + switch (*f) { + case '%': + direc_start = f++; + direc_length = 1; + field_width = 0; + precision = 0; + if (*f == '%') { + putchar_str(inf, '%'); + break; + } + if (*f == 'b') { + if (*argv) { + if (print_esc_string(inf, *argv)) + return saved_argv; /* causes main() to exit */ + ++argv; + } + break; + } + if (*f && strchr("-+ #", *f)) { + ++f; + ++direc_length; + } + if (*f == '*') { + ++f; + ++direc_length; + if (*argv) + field_width = get_width_prec(*argv++); + } else { + while (isdigit(*f)) { + ++f; + ++direc_length; + } + } + if (*f == '.') { + ++f; + ++direc_length; + if (*f == '*') { + ++f; + ++direc_length; + if (*argv) + precision = get_width_prec(*argv++); + } else { + while (isdigit(*f)) { + ++f; + ++direc_length; + } + } + } + + /* Remove "lLhz" size modifiers, repeatedly. + * bash does not like "%lld", but coreutils + * happily takes even "%Llllhhzhhzd"! + * We are permissive like coreutils + */ + while ((*f | 0x20) == 'l' || *f == 'h' || *f == 'z') + overlapping_strcpy(f, f + 1); + /* Add "ll" if integer modifier, then print */ + { + static const char format_chars[] = "diouxXcs"; + char *p = strchr(format_chars, *f); + /* needed - try "printf %" without it */ + if (!p || *f == '\0') { + printf("`%s': invalid format\n", direc_start); + /* causes main() to exit with error */ + return saved_argv - 1; + } + ++direc_length; + if (p - format_chars <= 5) { + /* it is one of "diouxX" */ + p = malloc(direc_length + 3); + if (!p) { + /* exit with error */ + return saved_argv - 1; + } + memcpy(p, direc_start, direc_length); + p[direc_length + 1] = p[direc_length - 1]; + p[direc_length - 1] = 'l'; + p[direc_length] = 'l'; + //bb_error_msg("<%s>", p); + direc_length += 2; + direc_start = p; + } else { + p = NULL; + } + if (*argv) { + print_direc(inf, direc_start, direc_length, + field_width, precision, *argv++); + } else { + print_direc(inf, direc_start, direc_length, + field_width, precision, ""); + } + *conv_err |= errno; + free(p); + } + break; + case '\\': + if (*++f == 'c') + return saved_argv; /* causes main() to exit */ + putchar_str(inf, process_escape_sequence((const char **)&f)); + f--; + break; + default: + putchar_str(inf, *f); + } + } + + return argv; +} + +/** + * printf_setexpr() - Implements the setexpr <name> fmt <format> command + * + * This function implements the format string evaluation for the + * setexpr <name> fmt <format> <value> command. + * + * @str: Output string of the evaluated expression + * @size: Length of @str buffer + * @argc: Number of arguments + * @argv: Argument list + * @return: 0 if OK, 1 on error + */ +int printf_setexpr(char *str, size_t size, int argc, char *const *argv) +{ + int conv_err; + char *format; + char **argv2; + struct print_inf inf = { + .str = str, + .size = size, + .offset = 0, + .error = 0, + }; + + if (!str || !size) + return 1; + + inf.str[0] = '\0'; + + format = argv[0]; + argv2 = (char **)argv + 1; + + conv_err = 0; + argv = argv2; + /* In case any print_str call raises an error inf.error will be + * set after print_formatted returns. + */ + argv2 = print_formatted(&inf, format, (char **)argv, &conv_err); + + /* coreutils compat (bash doesn't do this): + *if (*argv) + * fprintf(stderr, "excess args ignored"); + */ + + return (argv2 < argv) || /* if true, print_formatted errored out */ + conv_err || /* print_formatted saw invalid number */ + inf.error; /* print_str reported error */ +} diff --git a/cmd/printf.h b/cmd/printf.h new file mode 100644 index 0000000000..dcaff6d097 --- /dev/null +++ b/cmd/printf.h @@ -0,0 +1,8 @@ +/* SPDX-License-Identifier: GPL-2.0+ */ + +#ifndef __PRINTF_H +#define __PRINTF_H + +int printf_setexpr(char *str, size_t size, int argc, char *const *argv); + +#endif diff --git a/cmd/setexpr.c b/cmd/setexpr.c index e828be3970..1eb67e2eff 100644 --- a/cmd/setexpr.c +++ b/cmd/setexpr.c @@ -11,11 +11,15 @@ #include <common.h> #include <config.h> #include <command.h> +#include <ctype.h> #include <env.h> #include <log.h> #include <malloc.h> #include <mapmem.h> #include <linux/sizes.h> +#include "printf.h" + +#define MAX_STR_LEN 128 /** * struct expr_arg: Holds an argument to an expression @@ -370,15 +374,16 @@ static int do_setexpr(struct cmd_tbl *cmdtp, int flag, int argc, int w; /* - * We take 3, 5, or 6 arguments: + * We take 3, 5, or 6 arguments, except fmt operation, which + * takes 4 to 8 arguments (limited by _maxargs): * 3 : setexpr name value * 5 : setexpr name val1 op val2 * setexpr name [g]sub r s * 6 : setexpr name [g]sub r s t + * setexpr name fmt format [val1] [val2] [val3] [val4] */ - /* > 6 already tested by max command args */ - if ((argc < 3) || (argc == 4)) + if (argc < 3) return CMD_RET_USAGE; w = cmd_get_data_size(argv[0], 4); @@ -386,6 +391,24 @@ static int do_setexpr(struct cmd_tbl *cmdtp, int flag, int argc, if (get_arg(argv[2], w, &aval)) return CMD_RET_FAILURE; + /* format string assignment: "setexpr name fmt %d value" */ + if (strcmp(argv[2], "fmt") == 0 && IS_ENABLED(CONFIG_CMD_SETEXPR_FMT)) { + char str[MAX_STR_LEN]; + int result; + + if (argc == 3) + return CMD_RET_USAGE; + + result = printf_setexpr(str, sizeof(str), argc - 3, &argv[3]); + if (result) + return result; + + return env_set(argv[1], str); + } + + if (argc == 4 || argc > 6) + return CMD_RET_USAGE; + /* plain assignment: "setexpr name value" */ if (argc == 3) { if (w == CMD_DATA_SIZE_STR) { @@ -495,7 +518,7 @@ static int do_setexpr(struct cmd_tbl *cmdtp, int flag, int argc, } U_BOOT_CMD( - setexpr, 6, 0, do_setexpr, + setexpr, 8, 0, do_setexpr, "set environment variable as the result of eval expression", "[.b, .w, .l, .s] name [*]value1 <op> [*]value2\n" " - set environment variable 'name' to the result of the evaluated\n" @@ -505,6 +528,12 @@ U_BOOT_CMD( " memory addresses (*)\n" "setexpr[.b, .w, .l] name [*]value\n" " - load a value into a variable" +#ifdef CONFIG_CMD_SETEXPR_FMT + "\n" + "setexpr name fmt <format> [value1] [value2] [value3] [value4]\n" + " - set environment variable 'name' to the result of the bash like\n" + " format string evaluation of value." +#endif #ifdef CONFIG_REGEX "\n" "setexpr name gsub r s [t]\n" |