Modernize U-Boot shell
v4 cover Modernize U-Boot shell
Hi.
First I hope you are fine and the same for your relatives.
During 2021 summer, Sean Anderson wrote a contribution to add a new shell, based on LIL, to U-Boot [1][2].
While one of the goals of this contribution was to address the fact actual U-Boot shell, which is based on Busybox hush, is old there was a discussion about adding a new shell versus updating the actual one [3][4].
So, in this series, with Harald Seiler, we updated the actual U-Boot shell to reflect what is currently in Busybox source code.
Basically, this contribution is about taking a snapshot of Busybox shell/hush.c file (as it exists in commit 37460f5da) and adapt it to suit U-Boot needs.
This contribution was written to be as backward-compatible as possible to avoid breaking the existing.
So, the 2021 hush flavor offers the same as the actual, that is to say:
1. Variable expansion.
2. Instruction lists (;, && and ||).
3. If, then and else.
4. Loops (for, while and until).
No new features offered by Busybox hush were implemented (e.g. functions).
It is possible to change the parser at runtime using the "parser" command:
=> parser print
old
=> parser set 2021
2021> parser print
2021
2021> parser set old
=>
The default parser is the old one.
In terms of testing, new unit tests were added to ut to ensure the new behavior is the same as the old one and it does not add regression. Nonetheless, if old behavior was buggy and fixed upstream, the fix is then added to U-Boot [5].
In sandbox, all of these tests pass smoothly:
=> printenv board
board=sandbox
=> ut hush
Running 20 hush tests
...
Failures: 0
=> parser set 2021
2021> ut hush
Running 20 hush tests
...
Failures: 0
Thanks to the effort of Harald Seiler, I was successful booting a board:
2021> printenv board_rev
board_rev=iMX8MP
2021> boot
...
root@iMX8MPboard:~# fw_printenv board_rev board_rev=iMX8MP
I also tested another board where both parser were successful to boot it:
=> printenv fdtfile fdtfile=amlogic/meson-gxl-s905x-libretech-cc.dtb
=> boot
...
root@lepotato:~#
root@lepotato:~# reboot ... => parser set 2021 2021> printenv fdtfile fdtfile=amlogic/meson-gxl-s905x-libretech-cc.dtb 2021> boot ... root@lepotato:~#
Sadly, I was not able to have the CI passes smoothly...
To pass it and be aware of all the troubles, I added the 3 last commits as "trick" commits.
So, I would like to have your opinion on these commits and particularly on the underlying problems:
1. When I added a test to ensure variable expansion behavior is correct, I added some tests which should print "unknown command" (to test the shell behavior when a bad output is given).
Sadly, having "unknown command" printed will make the CI fails.
I think we can simply remove this "negative" test but what do you think?
2. When running ut setexpr setexpr_test_str from test.py the test fails while running the following assert:
ut_assertok(ut_check_delta(start_mem));
I am able to reproduce it while running within test.py but not from sandbox. So, I would like to have your reviews or to get a bit of help to know how I can better debug this specific case?
3. The keymile board is the only board to call get_local_var(), set_local_var() and unset_local_var().
Sadly, these functions are static in this contribution.
I could have change all of them to introduce code like this:*_local_var(/*...*/)
{
if (gd->flags & GD_FLG_HUSH_OLD_PARSER)
return *_local_var_old(/*...*/);
if (gd->flags & GD_FLG_HUSH_2021_PARSER)
return *_local_var_2021(/*...*/);
}But this would have mean renaming all old hush functions calls and I did not want to change the old hush particularly to avoid breaking things. Instead, I change the keymile board to use environment variable instead of local ones.
Do you think this a good change or I should change the old hush instead?
For all these reasons, I marked this contribution as RFC to indeed collect your opinions.
My goal is not to change suddenly actual shell to this one, we clearly need a transition period to think about it.
I think it is better to see this contribution as a proof of concept which shows it is possible to update the actual shell.
If you want to review it - your review will really be appreciated - here are some information regarding the commits:
* commits marked as "test:" deal with unit tests.
* commit "cli: Add Busybox upstream hush.c file." copies Busybox shell/hush.c into U-Boot tree, this explain why this commit contains around 12000 additions.
* commit "cli: Port Busybox 2021 hush to U-Boot." modifies previously added file to permit us to use this as new shell.
The really good idea of #include'ing Busybox code into a wrapper file to define some particular functions while minimizing modifications to upstream code comes from Harald Seiler.
* commit "cmd: Add new parser command" adds a new command which permits selecting parser at runtime.
I am not really satisfied with the fact it calls cli_init() and cli_loop() each time the parser is set, so your reviews would be welcomed.
* Other commits focus on enabling features we need (e.g. if).
Changes since v2:
* Added a small fix to compile sandbox with NO_SDL=1.
* Added a command to change parser at runtime.
* Added 2021 parser function to all run_command*().
Changes since v3:
* Various bug fixes pointed by the CI.
* Added upstream busybox hush commits until 6th February 2022.
Francis Laniel (27):
video: sandbox: Add dummy function for sandbox_sdl_remove_display().
test: Add framework to test hush behavior
test: hush: Test hush if/else
test/py: hush_if_test: Remove the test file
test: hush: Test hush variable expansion
test: hush: Test hush commands list
test: hush: Test hush loops
cli: Add Busybox upstream hush.c file
cli: Port Busybox 2021 hush to U-Boot
cli: Add menu for hush parser
global_data.h: add GD_FLG_HUSH_OLD_PARSER flag.
cmd: Add new parser command.
cli: Enables using hush 2021 parser as command line parser
cli: hush_2021: Enable variables expansion for hush 2021
cli: hush_2021: Add functions to be called from run_command()
cli: add hush 2021 as parser for run_command*().
test: hush: Fix instructions list tests for hush 2021
test: hush: Fix variable expansion tests for hush 2021
cli: hush_2021: Enable using \< and \> as string compare operators
cli: hush_2021: Enable if keyword
test: hush: Fix if tests for hush 2021
cli: hush_2021: Enable loops
test: hush: Fix loop tests for hush 2021
cli: hush_2021: Add upstream commits up to 6th February 2022. for test purpose only: Comment out dollar tests which prints error
messages.
for test purpose only: Comment out failed function which fails only in
CI.
board: keymile: common: Use environment to store IVM_* variables.
Tom Rini (1):
Modernize U-Boot shell
arch/sandbox/include/asm/sdl.h | 5 + board/keymile/common/common.c | 8 +- board/keymile/common/ivm.c | 9 +- cmd/Kconfig | 21 + cmd/Makefile | 2 + cmd/parser.c | 125 + common/Makefile | 3 +- common/cli.c | 81 +- common/cli_hush_2021.c | 303 + common/cli_hush_upstream.c | 12910 +++++++++++++++++++++++++++ include/asm-generic/global_data.h | 8 + include/cli_hush.h | 49 +- include/test/hush.h | 15 + include/test/suites.h | 1 + test/Makefile | 3 + test/cmd/setexpr.c | 2 +- test/cmd_ut.c | 6 + test/hush/Makefile | 10 + test/hush/cmd_ut_hush.c | 20 + test/hush/dollar.c | 226 + test/hush/if.c | 353 + test/hush/list.c | 140 + test/hush/loop.c | 90 + test/py/tests/test_hush_if_test.py | 184 - 24 files changed, 14364 insertions(+), 210 deletions(-) create mode 100644 cmd/parser.c create mode 100644 common/cli_hush_2021.c create mode 100644 common/cli_hush_upstream.c create mode 100644 include/test/hush.h create mode 100644 test/hush/Makefile create mode 100644 test/hush/cmd_ut_hush.c create mode 100644 test/hush/dollar.c create mode 100644 test/hush/if.c create mode 100644 test/hush/list.c create mode 100644 test/hush/loop.c delete mode 100644 test/py/tests/test_hush_if_test.py
Best regards and thank you in advance for your reviews.
---
[1] https://lists.denx.de/pipermail/u-boot/2021-July/453347.html
[2] https://runtimeterror.com/tech/lil/
[3] https://lists.denx.de/pipermail/u-boot/2021-July/453790.html
[4] https://lists.denx.de/pipermail/u-boot/2021-July/453848.html
[5] https://lists.denx.de/pipermail/u-boot/2021-August/458569.html
--
2.25.1
RFC PATCH v4 1/28 video: sandbox: Add dummy function for sandbox_sdl_remove_display().
We need to defined a dummy version of this function when compiling with NO_SDL=1.
Otherwise, we would face compilation error.
--- arch/sandbox/include/asm/sdl.h | 5 +++++ 1 file changed, 5 insertions(+)
arch/sandbox/include/asm/sdl.h +5 -0
@@ -94,6 +94,11 @@ static inline int sandbox_sdl_init_display(int width, int height, int log2_bpp,return -ENODEV ; } +static inline int sandbox_sdl_remove_display (void ) +{ +return -ENODEV ; +} +static inline int sandbox_sdl_sync (void *lcd_base) {return -ENODEV ;
Signature · 1 line
2.25.1
RFC PATCH v4 2/28 test: Add framework to test hush behavior
In reply to Francis LanielIntroduce a new subcommand to ut: ut hush.
For the moment, this command does nothing, future commits will add tests which will be run on command call.
Note that CONFIG_HUSH_PARSER must be defined to compile this new subcommand.
--- include/test/hush.h | 15 +++++++++++++++ include/test/suites.h | 1 + test/Makefile | 3 +++ test/cmd_ut.c | 6 ++++++ test/hush/Makefile | 6 ++++++ test/hush/cmd_ut_hush.c | 20 ++++++++++++++++++++ 6 files changed, 51 insertions(+) create mode 100644 include/test/hush.h create mode 100644 test/hush/Makefile create mode 100644 test/hush/cmd_ut_hush.c
include/test/hush.h new file +15 -0
@@ -0,0 +1,15 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* +* (C) Copyright 2021 +* Francis Laniel, Amarula Solutions, [email protected] +*/ + +#ifndef __TEST_HUSH_H__ +#define __TEST_HUSH_H__ + +#include <test/test.h> + +/* Declare a new environment test */ +#define HUSH_TEST (_name, _flags) UNIT_TEST(_name, _flags, hush_test) + +#endif /* __TEST_HUSH_H__ */
include/test/suites.h +1 -0
@@ -38,6 +38,7 @@ int do_ut_compression(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[]);int do_ut_dm (struct cmd_tbl *cmdtp,int flag,int argc,char *const argv[]);int do_ut_env (struct cmd_tbl *cmdtp,int flag,int argc,char *const argv[]); +int do_ut_hush (struct cmd_tbl *cmdtp,int flag,int argc,char *const argv[]);int do_ut_lib (struct cmd_tbl *cmdtp,int flag,int argc,char *const argv[]);int do_ut_log (struct cmd_tbl *cmdtp,int flag,int argc,char *const argv[]);int do_ut_mem (struct cmd_tbl *cmdtp,int flag,int argc,char *const argv[]);
test/Makefile +3 -0
@@ -16,6 +16,9 @@ obj-$(CONFIG_$(SPL_)CMDLINE) += cmd_ut.o obj-$(CONFIG_$(SPL_)CMDLINE) += command_ut.o obj-$(CONFIG_$(SPL_)UT_COMPRESSION) += compression.o obj-y += dm/ +ifneq ($(CONFIG_HUSH_PARSER),) +obj-$(CONFIG_$(SPL_)CMDLINE) += hush/ +endif obj-$(CONFIG_$(SPL_)CMDLINE) += print_ut.o obj-$(CONFIG_$(SPL_)CMDLINE) += str_ut.o obj-$(CONFIG_UT_TIME) += time_ut.o
test/cmd_ut.c +6 -0
@@ -74,6 +74,9 @@ static struct cmd_tbl cmd_ut_sub[] = {#ifdef CONFIG_CMD_ADDRMAP U_BOOT_CMD_MKENT(addrmap, CONFIG_SYS_MAXARGS, 1, do_ut_addrmap, "", ""),#endif +#if CONFIG_IS_ENABLED (HUSH_PARSER ) + U_BOOT_CMD_MKENT(hush, CONFIG_SYS_MAXARGS, 1, do_ut_hush, "", ""), +#endif }; static int do_ut_all(struct cmd_tbl *cmdtp, int flag, int argc,
@@ -155,6 +158,9 @@ static char ut_help_text[] =#endif #ifdef CONFIG_CMD_ADDRMAP "ut addrmap - Very basic test of addrmap command\n" +#endif +#if CONFIG_IS_ENABLED (HUSH_PARSER ) + "ut hush [test-name] - Test hush behavior\n"#endif ;#endif /* CONFIG_SYS_LONGHELP */
test/hush/Makefile new file +6 -0
@@ -0,0 +1,6 @@ +# SPDX-License-Identifier: GPL-2.0+ +# +# (C) Copyright 2021 +# Francis Laniel, Amarula Solutions, [email protected] + +obj-y += cmd_ut_hush.o
test/hush/cmd_ut_hush.c new file +20 -0
@@ -0,0 +1,20 @@ +// SPDX-License-Identifier: GPL-2.0 +/* +* (C) Copyright 2021 +* Francis Laniel, Amarula Solutions, [email protected] +*/ + +#include <common.h> +#include <command.h> +#include <test/hush.h> +#include <test/suites.h> +#include <test/ut.h> + +int do_ut_hush (struct cmd_tbl *cmdtp,int flag,int argc,char *const argv[]) +{ +struct unit_test *tests =UNIT_TEST_SUITE_START (hush_test); +const int n_ents =UNIT_TEST_SUITE_COUNT (hush_test); + +return cmd_ut_category ("hush" ,"hush_test_" , + tests, n_ents, argc, argv); +}
Signature · 1 line
2.25.1
RFC PATCH v4 3/28 test: hush: Test hush if/else
In reply to Francis LanielAs asked in 9c6bf1715f6a ("test/py: hush_if_test: Add tests to cover octal/hex values"), this commit translates test_hush_if_test.py to a C test.
--- test/hush/Makefile | 1 + test/hush/if.c | 308 +++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 309 insertions(+) create mode 100644 test/hush/if.c
test/hush/Makefile +1 -0
@@ -4,3 +4,4 @@ # Francis Laniel, Amarula Solutions, [email protected] obj-y += cmd_ut_hush.o +obj-y += if.o
test/hush/if.c new file +308 -0
308 lines not on this page · raw message
Signature · 1 line
2.25.1
RFC PATCH v4 4/28 test/py: hush_if_test: Remove the test file
In reply to Francis Lanielce40f44eb336 ("test: hush: Test hush if/else") translated this test to a C test, so this python file is no more needed.
--- test/py/tests/test_hush_if_test.py | 184 ----------------------------- 1 file changed, 184 deletions(-) delete mode 100644 test/py/tests/test_hush_if_test.py
test/py/tests/test_hush_if_test.py deleted +0 -184
@@ -1,184 +0,0 @@ -# SPDX-License-Identifier: GPL-2.0 -# Copyright (c) 2015-2016, NVIDIA CORPORATION. All rights reserved. - -# Test operation of the "if" shell command. - -import os -import os.path -import pytest - -# TODO: These tests should be converted to a C test. -# For more information please take a look at the thread -# https://lists.denx.de/pipermail/u-boot/2019-October/388732.html - -pytestmark = pytest.mark.buildconfigspec('hush_parser') - -# The list of "if test" conditions to test. -subtests = ( - # Base if functionality. - - ('true', True), - ('false', False), - - # Basic operators. - - ('test aaa = aaa', True), - ('test aaa = bbb', False), - - ('test aaa != bbb', True), - ('test aaa != aaa', False), - - ('test aaa < bbb', True), - ('test bbb < aaa', False), - - ('test bbb > aaa', True), - ('test aaa > bbb', False), - - ('test 123 -eq 123', True), - ('test 123 -eq 456', False), - - ('test 123 -ne 456', True), - ('test 123 -ne 123', False), - - ('test 123 -lt 456', True), - ('test 123 -lt 123', False), - ('test 456 -lt 123', False), - - ('test 123 -le 456', True), - ('test 123 -le 123', True), - ('test 456 -le 123', False), - - ('test 456 -gt 123', True), - ('test 123 -gt 123', False), - ('test 123 -gt 456', False), - - ('test 456 -ge 123', True), - ('test 123 -ge 123', True), - ('test 123 -ge 456', False), - - # Octal tests - - ('test 010 -eq 010', True), - ('test 010 -eq 011', False), - - ('test 010 -ne 011', True), - ('test 010 -ne 010', False), - - # Hexadecimal tests - - ('test 0x2000000 -gt 0x2000001', False), - ('test 0x2000000 -gt 0x2000000', False), - ('test 0x2000000 -gt 0x1ffffff', True), - - # Mixed tests - - ('test 010 -eq 10', False), - ('test 010 -ne 10', True), - ('test 0xa -eq 10', True), - ('test 0xa -eq 012', True), - - ('test 2000000 -gt 0x1ffffff', False), - ('test 0x2000000 -gt 1ffffff', True), - ('test 0x2000000 -lt 1ffffff', False), - ('test 0x2000000 -eq 2000000', False), - ('test 0x2000000 -ne 2000000', True), - - ('test -z ""', True), - ('test -z "aaa"', False), - - ('test -n "aaa"', True), - ('test -n ""', False), - - # Inversion of simple tests. - - ('test ! aaa = aaa', False), - ('test ! aaa = bbb', True), - ('test ! ! aaa = aaa', True), - ('test ! ! aaa = bbb', False), - - # Binary operators. - - ('test aaa != aaa -o bbb != bbb', False), - ('test aaa != aaa -o bbb = bbb', True), - ('test aaa = aaa -o bbb != bbb', True), - ('test aaa = aaa -o bbb = bbb', True), - - ('test aaa != aaa -a bbb != bbb', False), - ('test aaa != aaa -a bbb = bbb', False), - ('test aaa = aaa -a bbb != bbb', False), - ('test aaa = aaa -a bbb = bbb', True), - - # Inversion within binary operators. - - ('test ! aaa != aaa -o ! bbb != bbb', True), - ('test ! aaa != aaa -o ! bbb = bbb', True), - ('test ! aaa = aaa -o ! bbb != bbb', True), - ('test ! aaa = aaa -o ! bbb = bbb', False), - - ('test ! ! aaa != aaa -o ! ! bbb != bbb', False), - ('test ! ! aaa != aaa -o ! ! bbb = bbb', True), - ('test ! ! aaa = aaa -o ! ! bbb != bbb', True), - ('test ! ! aaa = aaa -o ! ! bbb = bbb', True), -) - -def exec_hush_if(u_boot_console, expr, result): - """Execute a shell "if" command, and validate its result.""" - - config = u_boot_console.config.buildconfig - maxargs = int(config.get('config_sys_maxargs', '0')) - args = len(expr.split(' ')) - 1 - if args > maxargs: - u_boot_console.log.warning('CONFIG_SYS_MAXARGS too low; need ' + - str(args)) - pytest.skip() - - cmd = 'if ' + expr + '; then echo true; else echo false; fi' - response = u_boot_console.run_command(cmd) - assert response.strip() == str(result).lower() - [email protected]('cmd_echo') [email protected]('expr,result', subtests) -def test_hush_if_test(u_boot_console, expr, result): - """Test a single "if test" condition.""" - - exec_hush_if(u_boot_console, expr, result) - -def test_hush_z(u_boot_console): - """Test the -z operator""" - u_boot_console.run_command('setenv ut_var_nonexistent') - u_boot_console.run_command('setenv ut_var_exists 1') - exec_hush_if(u_boot_console, 'test -z "$ut_var_nonexistent"', True) - exec_hush_if(u_boot_console, 'test -z "$ut_var_exists"', False) - u_boot_console.run_command('setenv ut_var_exists') - -# We might test this on real filesystems via UMS, DFU, 'save', etc. -# Of those, only UMS currently allows file removal though. [email protected]('cmd_echo') [email protected]('sandbox') -def test_hush_if_test_host_file_exists(u_boot_console): - """Test the "if test -e" shell command.""" - - test_file = u_boot_console.config.result_dir + \ - '/creating_this_file_breaks_u_boot_tests' - - try: - os.unlink(test_file) - except: - pass - assert not os.path.exists(test_file) - - expr = 'test -e hostfs - ' + test_file - exec_hush_if(u_boot_console, expr, False) - - try: - with open(test_file, 'wb'): - pass - assert os.path.exists(test_file) - - expr = 'test -e hostfs - ' + test_file - exec_hush_if(u_boot_console, expr, True) - finally: - os.unlink(test_file) - - expr = 'test -e hostfs - ' + test_file - exec_hush_if(u_boot_console, expr, False)
Signature · 1 line
2.25.1
RFC PATCH v4 5/28 test: hush: Test hush variable expansion
In reply to Francis LanielVerifies shell variables are replaced by their values.
--- test/hush/Makefile | 1 + test/hush/dollar.c | 167 +++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 168 insertions(+) create mode 100644 test/hush/dollar.c
test/hush/Makefile +1 -0
@@ -5,3 +5,4 @@ obj-y += cmd_ut_hush.o obj-y += if.o +obj-y += dollar.o
test/hush/dollar.c new file +167 -0
167 lines not on this page · raw message
Signature · 1 line
2.25.1
RFC PATCH v4 6/28 test: hush: Test hush commands list
In reply to Francis LanielVerifies behavior of commands separated by ';', '&&' and '||'.
--- test/hush/Makefile | 1 + test/hush/list.c | 79 ++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 80 insertions(+) create mode 100644 test/hush/list.c
test/hush/Makefile +1 -0
@@ -6,3 +6,4 @@ obj-y += cmd_ut_hush.o obj-y += if.o obj-y += dollar.o +obj-y += list.o
test/hush/list.c new file +79 -0
79 lines not on this page · raw message
Signature · 1 line
2.25.1
RFC PATCH v4 7/28 test: hush: Test hush loops
In reply to Francis LanielThe added tests verifies correct behavior of for, while and until loops.
--- test/hush/Makefile | 1 + test/hush/loop.c | 64 ++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 65 insertions(+) create mode 100644 test/hush/loop.c
test/hush/Makefile +1 -0
@@ -7,3 +7,4 @@ obj-y += cmd_ut_hush.o obj-y += if.o obj-y += dollar.o obj-y += list.o +obj-y += loop.o
test/hush/loop.c new file +64 -0
64 lines not on this page · raw message
Signature · 1 line
2.25.1
RFC PATCH v4 8/28 cli: Add Busybox upstream hush.c file
In reply to Francis LanielThis commit adds new file cli_hush_2021_upstream.c, it is a copy of Busybox hush file it was of time to Busybox commit 37460f5da.
--- common/cli_hush_upstream.c | 12162 +++++++++++++++++++++++++++++++++++ 1 file changed, 12162 insertions(+) create mode 100644 common/cli_hush_upstream.c
common/cli_hush_upstream.c new file +12162 -0
@@ -0,0 +1,12162 @@ +/* vi: set sw=4 ts=4: */ +/* +* A prototype Bourne shell grammar parser. +* Intended to follow the original Thompson and Ritchie +* "small and simple is beautiful" philosophy, which +* incidentally is a good match to today's BusyBox. +* +* Copyright (C) 2000,2001 Larry Doolittle <[email protected]> +* Copyright (C) 2008,2009 Denys Vlasenko <[email protected]> +* +* Licensed under GPLv2 or later, see file LICENSE in this source tree. +* +* Credits: +* The parser routines proper are all original material, first +* written Dec 2000 and Jan 2001 by Larry Doolittle. The +* execution engine, the builtins, and much of the underlying +* support has been adapted from busybox-0.49pre's lash, which is +* Copyright (C) 1999-2004 by Erik Andersen <[email protected]> +* written by Erik Andersen <[email protected]>. That, in turn, +* is based in part on ladsh.c, by Michael K. Johnson and Erik W. +* Troan, which they placed in the public domain. I don't know +* how much of the Johnson/Troan code has survived the repeated +* rewrites. +* +* Other credits: +* o_addchr derived from similar w_addchar function in glibc-2.2. +* parse_redirect, redirect_opt_num, and big chunks of main +* and many builtins derived from contributions by Erik Andersen. +* Miscellaneous bugfixes from Matt Kraai. +* +* There are two big (and related) architecture differences between +* this parser and the lash parser. One is that this version is +* actually designed from the ground up to understand nearly all +* of the Bourne grammar. The second, consequential change is that +* the parser and input reader have been turned inside out. Now, +* the parser is in control, and asks for input as needed. The old +* way had the input reader in control, and it asked for parsing to +* take place as needed. The new way makes it much easier to properly +* handle the recursion implicit in the various substitutions, especially +* across continuation lines. +* +* TODOs: +* grep for "TODO" and fix (some of them are easy) +* make complex ${var%...} constructs support optional +* make here documents optional +* special variables (done: PWD, PPID, RANDOM) +* follow IFS rules more precisely, including update semantics +* tilde expansion +* aliases +* "command" missing features: +* command -p CMD: run CMD using default $PATH +* (can use this to override standalone shell as well?) +* command BLTIN: disables special-ness (e.g. errors do not abort) +* command -V CMD1 CMD2 CMD3 (multiple args) (not in standard) +* builtins mandated by standards we don't support: +* [un]alias, fc: +* fc -l[nr] [BEG] [END]: list range of commands in history +* fc [-e EDITOR] [BEG] [END]: edit/rerun range of commands +* fc -s [PAT=REP] [CMD]: rerun CMD, replacing PAT with REP +* +* Bash compat TODO: +* redirection of stdout+stderr: &> and >& +* reserved words: function select +* advanced test: [[ ]] +* process substitution: <(list) and >(list) +* let EXPR [EXPR...] +* Each EXPR is an arithmetic expression (ARITHMETIC EVALUATION) +* If the last arg evaluates to 0, let returns 1; 0 otherwise. +* NB: let `echo 'a=a + 1'` - error (IOW: multi-word expansion is used) +* ((EXPR)) +* The EXPR is evaluated according to ARITHMETIC EVALUATION. +* This is exactly equivalent to let "EXPR". +* $[EXPR]: synonym for $((EXPR)) +* indirect expansion: ${!VAR} +* substring op on @: ${@:n:m} +* +* Won't do: +* Some builtins mandated by standards: +* newgrp [GRP]: not a builtin in bash but a suid binary +* which spawns a new shell with new group ID +* +* Status of [[ support: +* [[ args ]] are CMD_SINGLEWORD_NOGLOB: +* v='a b'; [[ $v = 'a b' ]]; echo 0:$? +* [[ /bin/n* ]]; echo 0:$? +* = is glob match operator, not equality operator: STR = GLOB +* == same as = +* =~ is regex match operator: STR =~ REGEX +* TODO: +* quoting needs to be considered (-f is an operator, "-f" and ""-f are not; etc) +* in word = GLOB, quoting should be significant on char-by-char basis: a*cd"*" +*/ +//config:config HUSH +//config: bool "hush (68 kb)" +//config: default y +//config: select SHELL_HUSH +//config: help +//config: hush is a small shell. It handles the normal flow control +//config: constructs such as if/then/elif/else/fi, for/in/do/done, while loops, +//config: case/esac. Redirections, here documents, $((arithmetic)) +//config: and functions are supported. +//config: +//config: It will compile and work on no-mmu systems. +//config: +//config: It does not handle select, aliases, tilde expansion, +//config: &>file and >&file redirection of stdout+stderr. +//config: +// This option is visible (has a description) to make it possible to select +// a "scripted" applet (such as NOLOGIN) but avoid selecting any shells: +//config:config SHELL_HUSH +//config: bool "Internal shell for embedded script support" +//config: default n +//config: +//config:# hush options +//config:# It's only needed to get "nice" menuconfig indenting. +//config:if SHELL_HUSH || HUSH || SH_IS_HUSH || BASH_IS_HUSH +//config: +//config:config HUSH_BASH_COMPAT +//config: bool "bash-compatible extensions" +//config: default y +//config: depends on SHELL_HUSH +//config: +//config:config HUSH_BRACE_EXPANSION +//config: bool "Brace expansion" +//config: default y +//config: depends on HUSH_BASH_COMPAT +//config: help +//config: Enable {abc,def} extension. +//config: +//config:config HUSH_BASH_SOURCE_CURDIR +//config: bool "'source' and '.' builtins search current directory after $PATH" +//config: default n # do not encourage non-standard behavior +//config: depends on HUSH_BASH_COMPAT +//config: help +//config: This is not compliant with standards. Avoid if possible. +//config: +//config:config HUSH_LINENO_VAR +//config: bool "$LINENO variable (bashism)" +//config: default y +//config: depends on SHELL_HUSH +//config: +//config:config HUSH_INTERACTIVE +//config: bool "Interactive mode" +//config: default y +//config: depends on SHELL_HUSH +//config: help +//config: Enable interactive mode (prompt and command editing). +//config: Without this, hush simply reads and executes commands +//config: from stdin just like a shell script from a file. +//config: No prompt, no PS1/PS2 magic shell variables. +//config: +//config:config HUSH_SAVEHISTORY +//config: bool "Save command history to .hush_history" +//config: default y +//config: depends on HUSH_INTERACTIVE && FEATURE_EDITING_SAVEHISTORY +//config: +//config:config HUSH_JOB +//config: bool "Job control" +//config: default y +//config: depends on HUSH_INTERACTIVE +//config: help +//config: Enable job control: Ctrl-Z backgrounds, Ctrl-C interrupts current +//config: command (not entire shell), fg/bg builtins work. Without this option, +//config: "cmd &" still works by simply spawning a process and immediately +//config: prompting for next command (or executing next command in a script), +//config: but no separate process group is formed. +//config: +//config:config HUSH_TICK +//config: bool "Support command substitution" +//config: default y +//config: depends on SHELL_HUSH +//config: help +//config: Enable `command` and $(command). +//config: +//config:config HUSH_IF +//config: bool "Support if/then/elif/else/fi" +//config: default y +//config: depends on SHELL_HUSH +//config: +//config:config HUSH_LOOPS +//config: bool "Support for, while and until loops" +//config: default y +//config: depends on SHELL_HUSH +//config: +//config:config HUSH_CASE +//config: bool "Support case ... esac statement" +//config: default y +//config: depends on SHELL_HUSH +//config: help +//config: Enable case ... esac statement. +400 bytes. +//config: +//config:config HUSH_FUNCTIONS +//config: bool "Support funcname() { commands; } syntax" +//config: default y +//config: depends on SHELL_HUSH +//config: help +//config: Enable support for shell functions. +800 bytes. +//config: +//config:config HUSH_LOCAL +//config: bool "local builtin" +//config: default y +//config: depends on HUSH_FUNCTIONS +//config: help +//config: Enable support for local variables in functions. +//config: +//config:config HUSH_RANDOM_SUPPORT +//config: bool "Pseudorandom generator and $RANDOM variable" +//config: default y +//config: depends on SHELL_HUSH +//config: help +//config: Enable pseudorandom generator and dynamic variable "$RANDOM". +//config: Each read of "$RANDOM" will generate a new pseudorandom value. +//config: +//config:config HUSH_MODE_X +//config: bool "Support 'hush -x' option and 'set -x' command" +//config: default y +//config: depends on SHELL_HUSH +//config: help +//config: This instructs hush to print commands before execution. +//config: Adds ~300 bytes. +//config: +//config:config HUSH_ECHO +//config: bool "echo builtin" +//config: default y +//config: depends on SHELL_HUSH +//config: +//config:config HUSH_PRINTF +//config: bool "printf builtin" +//config: default y +//config: depends on SHELL_HUSH +//config: +//config:config HUSH_TEST +//config: bool "test builtin" +//config: default y +//config: depends on SHELL_HUSH +//config: +//config:config HUSH_HELP +//config: bool "help builtin" +//config: default y +//config: depends on SHELL_HUSH +//config: +//config:config HUSH_EXPORT +//config: bool "export builtin" +//config: default y +//config: depends on SHELL_HUSH +//config: +//config:config HUSH_EXPORT_N +//config: bool "Support 'export -n' option" +//config: default y +//config: depends on HUSH_EXPORT +//config: help +//config: export -n unexports variables. It is a bash extension. +//config: +//config:config HUSH_READONLY +//config: bool "readonly builtin" +//config: default y +//config: depends on SHELL_HUSH +//config: help +//config: Enable support for read-only variables. +//config: +//config:config HUSH_KILL +//config: bool "kill builtin (supports kill %jobspec)" +//config: default y +//config: depends on SHELL_HUSH +//config: +//config:config HUSH_WAIT +//config: bool "wait builtin" +//config: default y +//config: depends on SHELL_HUSH +//config: +//config:config HUSH_COMMAND +//config: bool "command builtin" +//config: default y +//config: depends on SHELL_HUSH +//config: +//config:config HUSH_TRAP +//config: bool "trap builtin" +//config: default y +//config: depends on SHELL_HUSH +//config: +//config:config HUSH_TYPE +//config: bool "type builtin" +//config: default y +//config: depends on SHELL_HUSH +//config: +//config:config HUSH_TIMES +//config: bool "times builtin" +//config: default y +//config: depends on SHELL_HUSH +//config: +//config:config HUSH_READ +//config: bool "read builtin" +//config: default y +//config: depends on SHELL_HUSH +//config: +//config:config HUSH_SET +//config: bool "set builtin" +//config: default y +//config: depends on SHELL_HUSH +//config: +//config:config HUSH_UNSET +//config: bool "unset builtin" +//config: default y +//config: depends on SHELL_HUSH +//config: +//config:config HUSH_ULIMIT +//config: bool "ulimit builtin" +//config: default y +//config: depends on SHELL_HUSH +//config: +//config:config HUSH_UMASK +//config: bool "umask builtin" +//config: default y +//config: depends on SHELL_HUSH +//config: +//config:config HUSH_GETOPTS +//config: bool "getopts builtin" +//config: default y +//config: depends on SHELL_HUSH +//config: +//config:config HUSH_MEMLEAK +//config: bool "memleak builtin (debugging)" +//config: default n +//config: depends on SHELL_HUSH +//config: +//config:endif # hush options + +//applet:IF_HUSH(APPLET(hush, BB_DIR_BIN, BB_SUID_DROP)) +// APPLET_ODDNAME:name main location suid_type help +//applet:IF_SH_IS_HUSH( APPLET_ODDNAME(sh, hush, BB_DIR_BIN, BB_SUID_DROP, hush)) +//applet:IF_BASH_IS_HUSH(APPLET_ODDNAME(bash, hush, BB_DIR_BIN, BB_SUID_DROP, hush)) + +//kbuild:lib-$(CONFIG_SHELL_HUSH) += hush.o match.o shell_common.o +//kbuild:lib-$(CONFIG_HUSH_RANDOM_SUPPORT) += random.o + +/* -i (interactive) is also accepted, +* but does nothing, therefore not shown in help. +* NOMMU-specific options are not meant to be used by users, +* therefore we don't show them either. +*/ +//usage:#define hush_trivial_usage +//usage: "[-enxl] [-c 'SCRIPT' [ARG0 ARGS] | FILE [ARGS] | -s [ARGS]]" +//usage:#define hush_full_usage "\n\n" +//usage: "Unix shell interpreter" + +#if !(defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) \ + || defined(__APPLE__) \ + ) +# include <malloc.h> /* for malloc_trim */ +#endif +#include <glob.h> +/* #include <dmalloc.h> */ +#if ENABLE_HUSH_CASE +# include <fnmatch.h> +#endif +#include <sys/times.h> +#include <sys/utsname.h> /* for setting $HOSTNAME */ + +#include "busybox.h" /* for APPLET_IS_NOFORK/NOEXEC */ +#include "unicode.h" +#include "shell_common.h" +#include "math.h" +#include "match.h" +#if ENABLE_HUSH_RANDOM_SUPPORT +# include "random.h" +#else +# define CLEAR_RANDOM_T (rnd) ((void)0) +#endif +#ifndef O_CLOEXEC +# define O_CLOEXEC 0 +#endif +#ifndef F_DUPFD_CLOEXEC +# define F_DUPFD_CLOEXEC F_DUPFD +#endif + +#if ENABLE_FEATURE_SH_EMBEDDED_SCRIPTS && !(ENABLE_ASH ||ENABLE_SH_IS_ASH ||ENABLE_BASH_IS_ASH ) +# include "embedded_scripts.h" +#else +# define NUM_SCRIPTS 0 +#endif + +/* So far, all bash compat is controlled by one config option */ +/* Separate defines document which part of code implements what */ +#define BASH_PATTERN_SUBST ENABLE_HUSH_BASH_COMPAT +#define BASH_SUBSTR ENABLE_HUSH_BASH_COMPAT +#define BASH_SOURCE ENABLE_HUSH_BASH_COMPAT +#define BASH_DOLLAR_SQUOTE ENABLE_HUSH_BASH_COMPAT +#define BASH_HOSTNAME_VAR ENABLE_HUSH_BASH_COMPAT +#define BASH_EPOCH_VARS ENABLE_HUSH_BASH_COMPAT +#define BASH_TEST2 (ENABLE_HUSH_BASH_COMPAT && ENABLE_HUSH_TEST) +#define BASH_READ_D ENABLE_HUSH_BASH_COMPAT + + +/* Build knobs */ +#define LEAK_HUNTING 0 +#define BUILD_AS_NOMMU 0 +/* Enable/disable sanity checks. Ok to enable in production, +* only adds a bit of bloat. Set to >1 to get non-production level verbosity. +* Keeping 1 for now even in released versions. +*/ +#define HUSH_DEBUG 1 +/* Slightly bigger (+200 bytes), but faster hush. +* So far it only enables a trick with counting SIGCHLDs and forks, +* which allows us to do fewer waitpid's. +* (we can detect a case where neither forks were done nor SIGCHLDs happened +* and therefore waitpid will return the same result as last time) +*/ +#define ENABLE_HUSH_FAST 0 +/* TODO: implement simplified code for users which do not need ${var%...} ops +* So far ${var%...} ops are always enabled: +*/ +#define ENABLE_HUSH_DOLLAR_OPS 1 + + +#if BUILD_AS_NOMMU +# undef BB_MMU +# undef USE_FOR_NOMMU +# undef USE_FOR_MMU +# define BB_MMU 0 +# define USE_FOR_NOMMU (...) __VA_ARGS__ +# define USE_FOR_MMU (...) +#endif + +#include "NUM_APPLETS.h" +#if NUM_APPLETS ==1 +/* STANDALONE does not make sense, and won't compile */ +# undef CONFIG_FEATURE_SH_STANDALONE +# undef ENABLE_FEATURE_SH_STANDALONE +# undef IF_FEATURE_SH_STANDALONE +# undef IF_NOT_FEATURE_SH_STANDALONE +# define ENABLE_FEATURE_SH_STANDALONE 0 +# define IF_FEATURE_SH_STANDALONE (...) +# define IF_NOT_FEATURE_SH_STANDALONE (...) __VA_ARGS__ +#endif + +#if !ENABLE_HUSH_INTERACTIVE +# undef ENABLE_FEATURE_EDITING +# define ENABLE_FEATURE_EDITING 0 +# undef ENABLE_FEATURE_EDITING_FANCY_PROMPT +# define ENABLE_FEATURE_EDITING_FANCY_PROMPT 0 +# undef ENABLE_FEATURE_EDITING_SAVE_ON_EXIT +# define ENABLE_FEATURE_EDITING_SAVE_ON_EXIT 0 +#endif + +/* Do we support ANY keywords? */ +#if ENABLE_HUSH_IF ||ENABLE_HUSH_LOOPS ||ENABLE_HUSH_CASE +# define HAS_KEYWORDS 1 +# define IF_HAS_KEYWORDS (...) __VA_ARGS__ +# define IF_HAS_NO_KEYWORDS (...) +#else +# define HAS_KEYWORDS 0 +# define IF_HAS_KEYWORDS (...) +# define IF_HAS_NO_KEYWORDS (...) __VA_ARGS__ +#endif + +/* If you comment out one of these below, it will be #defined later +* to perform debug printfs to stderr: */ +#define debug_printf (...) do {} while (0) +/* Finer-grained debug switches */ +#define debug_printf_parse (...) do {} while (0) +#define debug_printf_heredoc (...) do {} while (0) +#define debug_print_tree (a, b) do {} while (0) +#define debug_printf_exec (...) do {} while (0) +#define debug_printf_env (...) do {} while (0) +#define debug_printf_jobs (...) do {} while (0) +#define debug_printf_expand (...) do {} while (0) +#define debug_printf_varexp (...) do {} while (0) +#define debug_printf_glob (...) do {} while (0) +#define debug_printf_redir (...) do {} while (0) +#define debug_printf_list (...) do {} while (0) +#define debug_printf_subst (...) do {} while (0) +#define debug_printf_prompt (...) do {} while (0) +#define debug_printf_clean (...) do {} while (0) + +#define ERR_PTR ((void*)(long)1) + +#define JOB_STATUS_FORMAT "[%u] %-22s %.40s\n" + +#define _SPECIAL_VARS_STR "_*@$!?#-" +#define SPECIAL_VARS_STR ("_*@$!?#-" + 1) +#define NUMERIC_SPECVARS_STR ("_*@$!?#-" + 3) +#if BASH_PATTERN_SUBST +/* Support / and // replace ops */ +/* Note that // is stored as \ in "encoded" string representation */ +# define VAR_ENCODED_SUBST_OPS "\\/%#:-=+?" +# define VAR_SUBST_OPS ("\\/%#:-=+?" + 1) +# define MINUS_PLUS_EQUAL_QUESTION ("\\/%#:-=+?" + 5) +#else +# define VAR_ENCODED_SUBST_OPS "%#:-=+?" +# define VAR_SUBST_OPS "%#:-=+?" +# define MINUS_PLUS_EQUAL_QUESTION ("%#:-=+?" + 3) +#endif + +#define SPECIAL_VAR_SYMBOL_STR "\3" +#define SPECIAL_VAR_SYMBOL 3 +/* The "variable" with name "\1" emits string "\3". Testcase: "echo ^C" */ +#define SPECIAL_VAR_QUOTED_SVS 1 + +struct variable ; + +static const char hush_version_str[] ALIGN1 = "HUSH_VERSION="BB_VER; + +/* This supports saving pointers malloced in vfork child, +* to be freed in the parent. +*/ +#if !BB_MMU +typedef struct nommu_save_t { +struct variable *old_vars; +char **argv; +char **argv_from_re_execing; +}nommu_save_t ; +#endif + +enum { +RES_NONE =0 , +#if ENABLE_HUSH_IF +RES_IF , +RES_THEN , +RES_ELIF , +RES_ELSE , +RES_FI , +#endif +#if ENABLE_HUSH_LOOPS +RES_FOR , +RES_WHILE , +RES_UNTIL , +RES_DO , +RES_DONE , +#endif +#if ENABLE_HUSH_LOOPS ||ENABLE_HUSH_CASE +RES_IN , +#endif +#if ENABLE_HUSH_CASE +RES_CASE , +/* three pseudo-keywords support contrived "case" syntax: */ +RES_CASE_IN ,/* "case ... IN", turns into RES_MATCH when IN is observed */ +RES_MATCH ,/* "word)" */ +RES_CASE_BODY ,/* "this command is inside CASE" */ +RES_ESAC , +#endif +RES_XXXX , +RES_SNTX +}; + +typedef struct o_string { +char *data; +int length;/* position where data is appended */ +int maxlen; +int o_expflags; +/* At least some part of the string was inside '' or "", +* possibly empty one: word"", wo''rd etc. */ +smallint has_quoted_part; +smallint has_empty_slot; +smallint ended_in_ifs; +}o_string ; +enum { +EXP_FLAG_SINGLEWORD =0x80 ,/* must be 0x80 */ +EXP_FLAG_GLOB =0x2 , +/* Protect newly added chars against globbing +* by prepending \ to *, ?, [, \ */ +EXP_FLAG_ESC_GLOB_CHARS =0x1 , +}; +/* Used for initialization: o_string foo = NULL_O_STRING; */ +#define NULL_O_STRING { NULL } + +#ifndef debug_printf_parse +static const char *const assignment_flag[] = { +"MAYBE_ASSIGNMENT" , +"DEFINITELY_ASSIGNMENT" , +"NOT_ASSIGNMENT" , +"WORD_IS_KEYWORD" , +}; +#endif + +/* We almost can use standard FILE api, but we need an ability to move +* its fd when redirects coincide with it. No api exists for that +* (RFE for it at https://sourceware.org/bugzilla/show_bug.cgi?id=21902). +* HFILE is our internal alternative. Only supports reading. +* Since we now can, we incorporate linked list of all opened HFILEs +* into the struct (used to be a separate mini-list). +*/ +typedef struct HFILE { +char *cur; +char *end; +struct HFILE *next_hfile; +int fd; +char buf[1024 ]; +}HFILE ; + +typedef struct in_str { +const char *p; +int peek_buf[2 ]; +int last_char; +HFILE *file; +}in_str ; + +/* The descrip member of this structure is only used to make +* debugging output pretty */ +static const struct { +int32_t mode; +signed char default_fd; +char descrip[3 ]; +} redir_table[] ALIGN4 = { + {O_RDONLY ,0 ,"<" }, + {O_CREAT |O_TRUNC |O_WRONLY ,1 ,">" }, + {O_CREAT |O_APPEND |O_WRONLY ,1 ,">>" }, + {O_CREAT |O_RDWR ,1 ,"<>" }, + {O_RDONLY ,0 ,"<<" }, +/* Should not be needed. Bogus default_fd helps in debugging */ +/* { O_RDONLY, 77, "<<" }, */ +}; + +struct redir_struct { +struct redir_struct *next; +char *rd_filename;/* filename */ +int rd_fd;/* fd to redirect */ +/* fd to redirect to, or -3 if rd_fd is to be closed (n>&-) */ +int rd_dup; +smallint rd_type;/* (enum redir_type) */ +/* note: for heredocs, rd_filename contains heredoc delimiter, +* and subsequently heredoc itself; and rd_dup is a bitmask: +* bit 0: do we need to trim leading tabs? +* bit 1: is heredoc quoted (<<'delim' syntax) ? +*/ +}; +typedef enum redir_type { +REDIRECT_INPUT =0 , +REDIRECT_OVERWRITE =1 , +REDIRECT_APPEND =2 , +REDIRECT_IO =3 , +REDIRECT_HEREDOC =4 , +REDIRECT_HEREDOC2 =5 ,/* REDIRECT_HEREDOC after heredoc is loaded */ + +REDIRFD_CLOSE =-3 , +REDIRFD_SYNTAX_ERR =-2 , +REDIRFD_TO_FILE =-1 , +/* otherwise, rd_fd is redirected to rd_dup */ + +HEREDOC_SKIPTABS =1 , +HEREDOC_QUOTED =2 , +}redir_type ; + + +struct command { +pid_t pid;/* 0 if exited */ +unsigned assignment_cnt;/* how many argv[i] are assignments? */ +#if ENABLE_HUSH_LINENO_VAR +unsigned lineno; +#endif +smallint cmd_type;/* CMD_xxx */ +#define CMD_NORMAL 0 +#define CMD_SUBSHELL 1 +#if BASH_TEST2 +/* used for "[[ EXPR ]]" */ +# define CMD_TEST2_SINGLEWORD_NOGLOB 2 +#endif +#if BASH_TEST2 ||ENABLE_HUSH_LOCAL ||ENABLE_HUSH_EXPORT ||ENABLE_HUSH_READONLY +/* used to prevent word splitting and globbing in "export v=t*" */ +# define CMD_SINGLEWORD_NOGLOB 3 +#endif +#if ENABLE_HUSH_FUNCTIONS +# define CMD_FUNCDEF 4 +#endif + +smalluint cmd_exitcode; +/* if non-NULL, this "command" is { list }, ( list ), or a compound statement */ +struct pipe *group; +#if !BB_MMU +char *group_as_string; +#endif +#if ENABLE_HUSH_FUNCTIONS +struct function *child_func; +/* This field is used to prevent a bug here: +* while...do f1() {a;}; f1; f1() {b;}; f1; done +* When we execute "f1() {a;}" cmd, we create new function and clear +* cmd->group, cmd->group_as_string, cmd->argv[0]. +* When we execute "f1() {b;}", we notice that f1 exists, +* and that its "parent cmd" struct is still "alive", +* we put those fields back into cmd->xxx +* (struct function has ->parent_cmd ptr to facilitate that). +* When we loop back, we can execute "f1() {a;}" again and set f1 correctly. +* Without this trick, loop would execute a;b;b;b;... +* instead of correct sequence a;b;a;b;... +* When command is freed, it severs the link +* (sets ->child_func->parent_cmd to NULL). +*/ +#endif +char **argv;/* command name and arguments */ +/* argv vector may contain variable references (^Cvar^C, ^C0^C etc) +* and on execution these are substituted with their values. +* Substitution can make _several_ words out of one argv[n]! +* Example: argv[0]=='.^C*^C.' here: echo .$*. +* References of the form ^C`cmd arg^C are `cmd arg` substitutions. +*/ +struct redir_struct *redirects;/* I/O redirections */ +}; +/* Is there anything in this command at all? */ +#define IS_NULL_CMD (cmd) \ + (!(cmd)->group && !(cmd)->argv && !(cmd)->redirects) + +struct pipe { +struct pipe *next; +int num_cmds;/* total number of commands in pipe */ +int alive_cmds;/* number of commands running (not exited) */ +int stopped_cmds;/* number of commands alive, but stopped */ +#if ENABLE_HUSH_JOB +unsigned jobid;/* job number */ +pid_t pgrp;/* process group ID for the job */ +char *cmdtext;/* name of job */ +#endif +struct command *cmds;/* array of commands in pipe */ +smallint followup;/* PIPE_BG, PIPE_SEQ, PIPE_OR, PIPE_AND */ + IF_HAS_KEYWORDS(smallint pi_inverted;) /* "! cmd | cmd" */ + IF_HAS_KEYWORDS(smallint res_word;) /* needed for if, for, while, until... */ +}; +typedef enum pipe_style { +PIPE_SEQ =0 , +PIPE_AND =1 , +PIPE_OR =2 , +PIPE_BG =3 , +}pipe_style ; +/* Is there anything in this pipe at all? */ +#define IS_NULL_PIPE (pi) \ + ((pi)->num_cmds == 0 IF_HAS_KEYWORDS( && (pi)->res_word == RES_NONE)) + +/* This holds pointers to the various results of parsing */ +struct parse_context { +/* linked list of pipes */ +struct pipe *list_head; +/* last pipe (being constructed right now) */ +struct pipe *pipe; +/* last command in pipe (being constructed right now) */ +struct command *command; +/* last redirect in command->redirects list */ +struct redir_struct *pending_redirect; +o_string word; +#if !BB_MMU +o_string as_string; +#endif +smallint is_assignment;/* 0:maybe, 1:yes, 2:no, 3:keyword */ +#if HAS_KEYWORDS +smallint ctx_res_w; +smallint ctx_inverted;/* "! cmd | cmd" */ +#if ENABLE_HUSH_CASE +smallint ctx_dsemicolon;/* ";;" seen */ +#endif +/* bitmask of FLAG_xxx, for figuring out valid reserved words */ +int old_flag; +/* group we are enclosed in: +* example: "if pipe1; pipe2; then pipe3; fi" +* when we see "if" or "then", we malloc and copy current context, +* and make ->stack point to it. then we parse pipeN. +* when closing "then" / fi" / whatever is found, +* we move list_head into ->stack->command->group, +* copy ->stack into current context, and delete ->stack. +* (parsing of { list } and ( list ) doesn't use this method) +*/ +struct parse_context *stack; +#endif +}; +enum { +MAYBE_ASSIGNMENT =0 , +DEFINITELY_ASSIGNMENT =1 , +NOT_ASSIGNMENT =2 , +/* Not an assignment, but next word may be: "if v=xyz cmd;" */ +WORD_IS_KEYWORD =3 , +}; + +/* On program start, environ points to initial environment. +* putenv adds new pointers into it, unsetenv removes them. +* Neither of these (de)allocates the strings. +* setenv allocates new strings in malloc space and does putenv, +* and thus setenv is unusable (leaky) for shell's purposes */ +#define setenv (...) setenv_is_leaky_dont_use() +struct variable { +struct variable *next; +char *varstr;/* points to "name=" portion */ +int max_len;/* if > 0, name is part of initial env; else name is malloced */ +uint16_t var_nest_level; +smallint flg_export;/* putenv should be done on this var */ +smallint flg_read_only; +}; + +enum { +BC_BREAK =1 , +BC_CONTINUE =2 , +}; + +#if ENABLE_HUSH_FUNCTIONS +struct function { +struct function *next; +char *name; +struct command *parent_cmd; +struct pipe *body; +# if !BB_MMU +char *body_as_string; +# endif +}; +#endif + + +/* set -/+o OPT support. (TODO: make it optional) +* bash supports the following opts: +* allexport off +* braceexpand on +* emacs on +* errexit off +* errtrace off +* functrace off +* hashall on +* histexpand off +* history on +* ignoreeof off +* interactive-comments on +* keyword off +* monitor on +* noclobber off +* noexec off +* noglob off +* nolog off +* notify off +* nounset off +* onecmd off +* physical off +* pipefail off +* posix off +* privileged off +* verbose off +* vi off +* xtrace off +*/ +static const char o_opt_strings[] ALIGN1 = +"pipefail\0" +"noexec\0" +"errexit\0" +#if ENABLE_HUSH_MODE_X +"xtrace\0" +#endif + ; +enum { +OPT_O_PIPEFAIL , +OPT_O_NOEXEC , +OPT_O_ERREXIT , +#if ENABLE_HUSH_MODE_X +OPT_O_XTRACE , +#endif +NUM_OPT_O +}; + +/* "Globals" within this file */ +/* Sorted roughly by size (smaller offsets == smaller code) */ +struct globals { +/* interactive_fd != 0 means we are an interactive shell. +* If we are, then saved_tty_pgrp can also be != 0, meaning +* that controlling tty is available. With saved_tty_pgrp == 0, +* job control still works, but terminal signals +* (^C, ^Z, ^Y, ^\) won't work at all, and background +* process groups can only be created with "cmd &". +* With saved_tty_pgrp != 0, hush will use tcsetpgrp() +* to give tty to the foreground process group, +* and will take it back when the group is stopped (^Z) +* or killed (^C). +*/ +#if ENABLE_HUSH_INTERACTIVE +/* 'interactive_fd' is a fd# open to ctty, if we have one +* _AND_ if we decided to act interactively */ +int interactive_fd; + IF_NOT_FEATURE_EDITING_FANCY_PROMPT(char *PS1;) +# define G_interactive_fd (G.interactive_fd) +#else +# define G_interactive_fd 0 +#endif +#if ENABLE_FEATURE_EDITING +line_input_t *line_input_state; +#endif +pid_t root_pid; +pid_t root_ppid; +pid_t last_bg_pid; +#if ENABLE_HUSH_RANDOM_SUPPORT +random_t random_gen; +#endif +#if ENABLE_HUSH_JOB +int run_list_level; +unsigned last_jobid; +pid_t saved_tty_pgrp; +struct pipe *job_list; +# define G_saved_tty_pgrp (G.saved_tty_pgrp) +#else +# define G_saved_tty_pgrp 0 +#endif +/* How deeply are we in context where "set -e" is ignored */ +int errexit_depth; +/* "set -e" rules (do we follow them correctly?): +* Exit if pipe, list, or compound command exits with a non-zero status. +* Shell does not exit if failed command is part of condition in +* if/while, part of && or || list except the last command, any command +* in a pipe but the last, or if the command's return value is being +* inverted with !. If a compound command other than a subshell returns a +* non-zero status because a command failed while -e was being ignored, the +* shell does not exit. A trap on ERR, if set, is executed before the shell +* exits [ERR is a bashism]. +* +* If a compound command or function executes in a context where -e is +* ignored, none of the commands executed within are affected by the -e +* setting. If a compound command or function sets -e while executing in a +* context where -e is ignored, that setting does not have any effect until +* the compound command or the command containing the function call completes. +*/ + +char o_opt[NUM_OPT_O ]; +#if ENABLE_HUSH_MODE_X +# define G_x_mode (G.o_opt[OPT_O_XTRACE]) +#else +# define G_x_mode 0 +#endif +char opt_s; +char opt_c; +#if ENABLE_HUSH_INTERACTIVE +smallint promptmode;/* 0: PS1, 1: PS2 */ +#endif +smallint flag_SIGINT; +#if ENABLE_HUSH_LOOPS +smallint flag_break_continue; +#endif +#if ENABLE_HUSH_FUNCTIONS +/* 0: outside of a function (or sourced file) +* -1: inside of a function, ok to use return builtin +* 1: return is invoked, skip all till end of func +*/ +smallint flag_return_in_progress; +# define G_flag_return_in_progress (G.flag_return_in_progress) +#else +# define G_flag_return_in_progress 0 +#endif +smallint exiting;/* used to prevent EXIT trap recursion */ +/* These support $? */ +smalluint last_exitcode; +smalluint expand_exitcode; +smalluint last_bg_pid_exitcode; +#if ENABLE_HUSH_SET +/* are global_argv and global_argv[1..n] malloced? (note: not [0]) */ +smalluint global_args_malloced; +# define G_global_args_malloced (G.global_args_malloced) +#else +# define G_global_args_malloced 0 +#endif +#if ENABLE_HUSH_BASH_COMPAT +int dead_job_exitcode;/* for "wait -n" */ +#endif +/* how many non-NULL argv's we have. NB: $# + 1 */ +int global_argc; +char **global_argv; +#if !BB_MMU +char *argv0_for_re_execing; +#endif +#if ENABLE_HUSH_LOOPS +unsigned depth_break_continue; +unsigned depth_of_loop; +#endif +#if ENABLE_HUSH_GETOPTS +unsigned getopt_count; +#endif +const char *ifs; +char *ifs_whitespace;/* = G.ifs or malloced */ +const char *cwd; +struct variable *top_var; +char **expanded_assignments; +struct variable **shadowed_vars_pp; +unsigned var_nest_level; +#if ENABLE_HUSH_FUNCTIONS +# if ENABLE_HUSH_LOCAL +unsigned func_nest_level;/* solely to prevent "local v" in non-functions */ +# endif +struct function *top_func; +#endif +/* Signal and trap handling */ +#if ENABLE_HUSH_FAST +unsigned count_SIGCHLD; +unsigned handled_SIGCHLD; +smallint we_have_children; +#endif +#if ENABLE_HUSH_LINENO_VAR +unsigned parse_lineno; +unsigned execute_lineno; +#endif +HFILE *HFILE_list; +HFILE *HFILE_stdin; +/* Which signals have non-DFL handler (even with no traps set)? +* Set at the start to: +* (SIGQUIT + maybe SPECIAL_INTERACTIVE_SIGS + maybe SPECIAL_JOBSTOP_SIGS) +* SPECIAL_INTERACTIVE_SIGS are cleared after fork. +* The rest is cleared right before execv syscalls. +* Other than these two times, never modified. +*/ +unsigned special_sig_mask; +#if ENABLE_HUSH_JOB +unsigned fatal_sig_mask; +# define G_fatal_sig_mask (G.fatal_sig_mask) +#else +# define G_fatal_sig_mask 0 +#endif +#if ENABLE_HUSH_TRAP +int pre_trap_exitcode; +# if ENABLE_HUSH_FUNCTIONS +int return_exitcode; +# endif +char **traps;/* char *traps[NSIG] */ +# define G_traps G.traps +#else +# define G_traps ((char**)NULL) +#endif +sigset_t pending_set; +#if ENABLE_HUSH_MEMLEAK +unsigned long memleak_value; +#endif +#if ENABLE_HUSH_MODE_X +unsigned x_mode_depth; +/* "set -x" output should not be redirectable with subsequent 2>FILE. +* We dup fd#2 to x_mode_fd when "set -x" is executed, and use it +* for all subsequent output. +*/ +int x_mode_fd; +o_string x_mode_buf; +#endif +#if HUSH_DEBUG >=2 +int debug_indent; +#endif +struct sigaction sa; +char optstring_buf[sizeof ("eixcs" )]; +#if BASH_EPOCH_VARS +char epoch_buf[sizeof ("%llu.nnnnnn" ) +sizeof (long long )*3 ]; +#endif +#if ENABLE_FEATURE_EDITING +char user_input_buf[CONFIG_FEATURE_EDITING_MAX_LEN ]; +#endif +}; +#define G (*ptr_to_globals) +/* Not #defining name to G.name - this quickly gets unwieldy +* (too many defines). Also, I actually prefer to see when a variable +* is global, thus "G." prefix is a useful hint */ +#define INIT_G () do { \ + SET_PTR_TO_GLOBALS(xzalloc(sizeof(G))); \ +/* memset(&G.sa, 0, sizeof(G.sa)); */ \ +sigfillset (&G .sa.sa_mask); \ +G .sa.sa_flags =SA_RESTART ; \ +} while (0) + + +/* Function prototypes for builtins */ +static int builtin_cd(char **argv) FAST_FUNC; +#if ENABLE_HUSH_ECHO +static int builtin_echo(char **argv) FAST_FUNC; +#endif +static int builtin_eval(char **argv) FAST_FUNC; +static int builtin_exec(char **argv) FAST_FUNC; +static int builtin_exit(char **argv) FAST_FUNC; +#if ENABLE_HUSH_EXPORT +static int builtin_export(char **argv) FAST_FUNC; +#endif +#if ENABLE_HUSH_READONLY +static int builtin_readonly(char **argv) FAST_FUNC; +#endif +#if ENABLE_HUSH_JOB +static int builtin_fg_bg(char **argv) FAST_FUNC; +static int builtin_jobs(char **argv) FAST_FUNC; +#endif +#if ENABLE_HUSH_GETOPTS +static int builtin_getopts(char **argv) FAST_FUNC; +#endif +#if ENABLE_HUSH_HELP +static int builtin_help(char **argv) FAST_FUNC; +#endif +#if MAX_HISTORY &&ENABLE_FEATURE_EDITING +static int builtin_history(char **argv) FAST_FUNC; +#endif +#if ENABLE_HUSH_LOCAL +static int builtin_local(char **argv) FAST_FUNC; +#endif +#if ENABLE_HUSH_MEMLEAK +static int builtin_memleak(char **argv) FAST_FUNC; +#endif +#if ENABLE_HUSH_PRINTF +static int builtin_printf(char **argv) FAST_FUNC; +#endif +static int builtin_pwd(char **argv) FAST_FUNC; +#if ENABLE_HUSH_READ +static int builtin_read(char **argv) FAST_FUNC; +#endif +#if ENABLE_HUSH_SET +static int builtin_set(char **argv) FAST_FUNC; +#endif +static int builtin_shift(char **argv) FAST_FUNC; +static int builtin_source(char **argv) FAST_FUNC; +#if ENABLE_HUSH_TEST ||BASH_TEST2 +static int builtin_test(char **argv) FAST_FUNC; +#endif +#if ENABLE_HUSH_TRAP +static int builtin_trap(char **argv) FAST_FUNC; +#endif +#if ENABLE_HUSH_TYPE +static int builtin_type(char **argv) FAST_FUNC; +#endif +#if ENABLE_HUSH_TIMES +static int builtin_times(char **argv) FAST_FUNC; +#endif +static int builtin_true(char **argv) FAST_FUNC; +#if ENABLE_HUSH_UMASK +static int builtin_umask(char **argv) FAST_FUNC; +#endif +#if ENABLE_HUSH_UNSET +static int builtin_unset(char **argv) FAST_FUNC; +#endif +#if ENABLE_HUSH_KILL +static int builtin_kill(char **argv) FAST_FUNC; +#endif +#if ENABLE_HUSH_WAIT +static int builtin_wait(char **argv) FAST_FUNC; +#endif +#if ENABLE_HUSH_LOOPS +static int builtin_break(char **argv) FAST_FUNC; +static int builtin_continue(char **argv) FAST_FUNC; +#endif +#if ENABLE_HUSH_FUNCTIONS +static int builtin_return(char **argv) FAST_FUNC; +#endif + +/* Table of built-in functions. They can be forked or not, depending on +* context: within pipes, they fork. As simple commands, they do not. +* When used in non-forking context, they can change global variables +* in the parent shell process. If forked, of course they cannot. +* For example, 'unset foo | whatever' will parse and run, but foo will +* still be set at the end. */ +struct built_in_command { +const char *b_cmd; + int (*b_function)(char **argv) FAST_FUNC; +#if ENABLE_HUSH_HELP +const char *b_descr; +# define BLTIN (cmd, func, help) { cmd, func, help } +#else +# define BLTIN (cmd, func, help) { cmd, func } +#endif +}; + +static const struct built_in_command bltins1[] ALIGN_PTR = { +BLTIN ("." , builtin_source ,"Run commands in file" ), +BLTIN (":" , builtin_true ,NULL ), +#if ENABLE_HUSH_JOB +BLTIN ("bg" , builtin_fg_bg ,"Resume job in background" ), +#endif +#if ENABLE_HUSH_LOOPS +BLTIN ("break" , builtin_break ,"Exit loop" ), +#endif +BLTIN ("cd" , builtin_cd ,"Change directory" ), +#if ENABLE_HUSH_LOOPS +BLTIN ("continue" , builtin_continue,"Start new loop iteration" ), +#endif +BLTIN ("eval" , builtin_eval ,"Construct and run shell command" ), +BLTIN ("exec" , builtin_exec ,"Execute command, don't return to shell" ), +BLTIN ("exit" , builtin_exit ,NULL ), +#if ENABLE_HUSH_EXPORT +BLTIN ("export" , builtin_export ,"Set environment variables" ), +#endif +#if ENABLE_HUSH_JOB +BLTIN ("fg" , builtin_fg_bg ,"Bring job to foreground" ), +#endif +#if ENABLE_HUSH_GETOPTS +BLTIN ("getopts" , builtin_getopts ,NULL ), +#endif +#if ENABLE_HUSH_HELP +BLTIN ("help" , builtin_help ,NULL ), +#endif +#if MAX_HISTORY && ENABLE_FEATURE_EDITING +BLTIN ("history" , builtin_history ,"Show history" ), +#endif +#if ENABLE_HUSH_JOB +BLTIN ("jobs" , builtin_jobs ,"List jobs" ), +#endif +#if ENABLE_HUSH_KILL +BLTIN ("kill" , builtin_kill ,"Send signals to processes" ), +#endif +#if ENABLE_HUSH_LOCAL +BLTIN ("local" , builtin_local ,"Set local variables" ), +#endif +#if ENABLE_HUSH_MEMLEAK +BLTIN ("memleak" , builtin_memleak ,NULL ), +#endif +#if ENABLE_HUSH_READ +BLTIN ("read" , builtin_read ,"Input into variable" ), +#endif +#if ENABLE_HUSH_READONLY +BLTIN ("readonly" , builtin_readonly,"Make variables read-only" ), +#endif +#if ENABLE_HUSH_FUNCTIONS +BLTIN ("return" , builtin_return ,"Return from function" ), +#endif +#if ENABLE_HUSH_SET +BLTIN ("set" , builtin_set ,"Set positional parameters" ), +#endif +BLTIN ("shift" , builtin_shift ,"Shift positional parameters" ), +#if BASH_SOURCE +BLTIN ("source" , builtin_source ,NULL ), +#endif +#if ENABLE_HUSH_TIMES +BLTIN ("times" , builtin_times ,NULL ), +#endif +#if ENABLE_HUSH_TRAP +BLTIN ("trap" , builtin_trap ,"Trap signals" ), +#endif +BLTIN ("true" , builtin_true ,NULL ), +#if ENABLE_HUSH_TYPE +BLTIN ("type" , builtin_type ,"Show command type" ), +#endif +#if ENABLE_HUSH_ULIMIT +BLTIN ("ulimit" , shell_builtin_ulimit,"Control resource limits" ), +#endif +#if ENABLE_HUSH_UMASK +BLTIN ("umask" , builtin_umask ,"Set file creation mask" ), +#endif +#if ENABLE_HUSH_UNSET +BLTIN ("unset" , builtin_unset ,"Unset variables" ), +#endif +#if ENABLE_HUSH_WAIT +BLTIN ("wait" , builtin_wait ,"Wait for process to finish" ), +#endif +}; +/* These builtins won't be used if we are on NOMMU and need to re-exec +* (it's cheaper to run an external program in this case): +*/ +static const struct built_in_command bltins2[] ALIGN_PTR = { +#if ENABLE_HUSH_TEST +BLTIN ("[" , builtin_test ,NULL ), +#endif +#if BASH_TEST2 +BLTIN ("[[" , builtin_test ,NULL ), +#endif +#if ENABLE_HUSH_ECHO +BLTIN ("echo" , builtin_echo ,NULL ), +#endif +#if ENABLE_HUSH_PRINTF +BLTIN ("printf" , builtin_printf ,NULL ), +#endif +BLTIN ("pwd" , builtin_pwd ,NULL ), +#if ENABLE_HUSH_TEST +BLTIN ("test" , builtin_test ,NULL ), +#endif +}; + + +/* Debug printouts. +*/ +#if HUSH_DEBUG >=2 +/* prevent disasters with G.debug_indent < 0 */ +# define indent () fdprintf(2, "%*s", (G.debug_indent * 2) & 0xff, "") +# define debug_enter () (G.debug_indent++) +# define debug_leave () (G.debug_indent--) +#else +# define indent () ((void)0) +# define debug_enter () ((void)0) +# define debug_leave () ((void)0) +#endif + +#ifndef debug_printf +# define debug_printf (...) (indent(), fdprintf(2, __VA_ARGS__)) +#endif + +#ifndef debug_printf_parse +# define debug_printf_parse (...) (indent(), fdprintf(2, __VA_ARGS__)) +#endif + +#ifndef debug_printf_heredoc +# define debug_printf_heredoc (...) (indent(), fdprintf(2, __VA_ARGS__)) +#endif + +#ifndef debug_printf_exec +#define debug_printf_exec (...) (indent(), fdprintf(2, __VA_ARGS__)) +#endif + +#ifndef debug_printf_env +# define debug_printf_env (...) (indent(), fdprintf(2, __VA_ARGS__)) +#endif + +#ifndef debug_printf_jobs +# define debug_printf_jobs (...) (indent(), fdprintf(2, __VA_ARGS__)) +# define DEBUG_JOBS 1 +#else +# define DEBUG_JOBS 0 +#endif + +#ifndef debug_printf_expand +# define debug_printf_expand (...) (indent(), fdprintf(2, __VA_ARGS__)) +# define DEBUG_EXPAND 1 +#else +# define DEBUG_EXPAND 0 +#endif + +#ifndef debug_printf_varexp +# define debug_printf_varexp (...) (indent(), fdprintf(2, __VA_ARGS__)) +#endif + +#ifndef debug_printf_glob +# define debug_printf_glob (...) (indent(), fdprintf(2, __VA_ARGS__)) +# define DEBUG_GLOB 1 +#else +# define DEBUG_GLOB 0 +#endif + +#ifndef debug_printf_redir +# define debug_printf_redir (...) (indent(), fdprintf(2, __VA_ARGS__)) +#endif + +#ifndef debug_printf_list +# define debug_printf_list (...) (indent(), fdprintf(2, __VA_ARGS__)) +#endif + +#ifndef debug_printf_subst +# define debug_printf_subst (...) (indent(), fdprintf(2, __VA_ARGS__)) +#endif + +#ifndef debug_printf_prompt +# define debug_printf_prompt (...) (indent(), fdprintf(2, __VA_ARGS__)) +#endif + +#ifndef debug_printf_clean +# define debug_printf_clean (...) (indent(), fdprintf(2, __VA_ARGS__)) +# define DEBUG_CLEAN 1 +#else +# define DEBUG_CLEAN 0 +#endif + +#if DEBUG_EXPAND +static void debug_print_strings (const char *prefix,char **vv) +{ +indent (); +fdprintf (2 ,"%s:\n" , prefix); +while (*vv) +fdprintf (2 ," '%s'\n" , *vv++); +} +#else +# define debug_print_strings (prefix, vv) ((void)0) +#endif + + +/* Leak hunting. Use hush_leaktool.sh for post-processing. +*/ +#if LEAK_HUNTING +static void *xxmalloc (int lineno,size_t size) +{ +void *ptr =xmalloc ((size +0xff ) & ~0xff ); +fdprintf (2 ,"line %d: malloc %p\n" , lineno, ptr); +return ptr; +} +static void *xxrealloc (int lineno,void *ptr,size_t size) +{ + ptr =xrealloc (ptr, (size +0xff ) & ~0xff ); +fdprintf (2 ,"line %d: realloc %p\n" , lineno, ptr); +return ptr; +} +static char *xxstrdup (int lineno,const char *str) +{ +char *ptr =xstrdup (str); +fdprintf (2 ,"line %d: strdup %p\n" , lineno, ptr); +return ptr; +} +static void xxfree (void *ptr) +{ +fdprintf (2 ,"free %p\n" , ptr); +free (ptr); +} +# define xmalloc (s) xxmalloc(__LINE__, s) +# define xrealloc (p, s) xxrealloc(__LINE__, p, s) +# define xstrdup (s) xxstrdup(__LINE__, s) +# define free (p) xxfree(p) +#endif + + +/* Syntax and runtime errors. They always abort scripts. +* In interactive use they usually discard unparsed and/or unexecuted commands +* and return to the prompt. +* HUSH_DEBUG >= 2 prints line number in this file where it was detected. +*/ +#if HUSH_DEBUG <2 +# define msg_and_die_if_script (lineno, ...) msg_and_die_if_script(__VA_ARGS__) +# define syntax_error (lineno, msg) syntax_error(msg) +# define syntax_error_at (lineno, msg) syntax_error_at(msg) +# define syntax_error_unterm_ch (lineno, ch) syntax_error_unterm_ch(ch) +# define syntax_error_unterm_str (lineno, s) syntax_error_unterm_str(s) +# define syntax_error_unexpected_ch (lineno, ch) syntax_error_unexpected_ch(ch) +#endif + +static void die_if_script (void ) +{ +if (!G_interactive_fd) { +if (G .last_exitcode)/* sometines it's 2, not 1 (bash compat) */ + xfunc_error_retval =G .last_exitcode; +xfunc_die (); + } +} + +static void msg_and_die_if_script (unsigned lineno,const char *fmt, ...) +{ +va_list p; + +#if HUSH_DEBUG >=2 +bb_error_msg ("hush.c:%u" , lineno); +#endif +va_start (p, fmt); +bb_verror_msg (fmt, p,NULL ); +va_end (p); +die_if_script (); +} + +static void syntax_error (unsigned lineno UNUSED_PARAM ,const char *msg) +{ +if (msg) +bb_error_msg ("syntax error: %s" , msg); +else +bb_simple_error_msg ("syntax error" ); +die_if_script (); +} + +static void syntax_error_at (unsigned lineno UNUSED_PARAM ,const char *msg) +{ +bb_error_msg ("syntax error at '%s'" , msg); +die_if_script (); +} + +static void syntax_error_unterm_str (unsigned lineno UNUSED_PARAM ,const char *s) +{ +bb_error_msg ("syntax error: unterminated %s" , s); +//? source4.tests fails: in bash, echo ${^} in script does not terminate the script +// die_if_script(); +} + +static void syntax_error_unterm_ch (unsigned lineno,char ch) +{ +char msg[2 ] = { ch,'\0' }; +syntax_error_unterm_str (lineno, msg); +} + +static void syntax_error_unexpected_ch (unsigned lineno UNUSED_PARAM ,int ch) +{ +char msg[2 ]; + msg[0 ] = ch; + msg[1 ] ='\0' ; +#if HUSH_DEBUG >=2 +bb_error_msg ("hush.c:%u" , lineno); +#endif +bb_error_msg ("syntax error: unexpected %s" , ch ==EOF ?"EOF" : msg); +die_if_script (); +} + +#if HUSH_DEBUG <2 +# undef msg_and_die_if_script +# undef syntax_error +# undef syntax_error_at +# undef syntax_error_unterm_ch +# undef syntax_error_unterm_str +# undef syntax_error_unexpected_ch +#else +# define msg_and_die_if_script (...) msg_and_die_if_script(__LINE__, __VA_ARGS__) +# define syntax_error (msg) syntax_error(__LINE__, msg) +# define syntax_error_at (msg) syntax_error_at(__LINE__, msg) +# define syntax_error_unterm_ch (ch) syntax_error_unterm_ch(__LINE__, ch) +# define syntax_error_unterm_str (s) syntax_error_unterm_str(__LINE__, s) +# define syntax_error_unexpected_ch (ch) syntax_error_unexpected_ch(__LINE__, ch) +#endif + + +/* Utility functions +*/ +/* Replace each \x with x in place, return ptr past NUL. */ +static char *unbackslash (char *src) +{ +char *dst = src =strchrnul (src,'\\' ); +while (1 ) { +if (*src =='\\' ) { + src++; +if (*src !='\0' ) { +/* \x -> x */ + *dst++ = *src++; +continue ; + } +/* else: "\<nul>". Do not delete this backslash. +* Testcase: eval 'echo ok\' +*/ + *dst++ ='\\' ; +/* fallthrough */ + } +if ((*dst++ = *src++) =='\0' ) +break ; + } +return dst; +} + +static char **add_strings_to_strings (char **strings,char **add,int need_to_dup) +{ +int i; +unsigned count1; +unsigned count2; +char **v; + + v = strings; + count1 =0 ; +if (v) { +while (*v) { + count1++; + v++; + } + } + count2 =0 ; + v = add; +while (*v) { + count2++; + v++; + } + v =xrealloc (strings, (count1 + count2 +1 ) *sizeof (char *)); + v[count1 + count2] =NULL ; + i = count2; +while (--i >=0 ) + v[count1 + i] = (need_to_dup ?xstrdup (add[i]) : add[i]); +return v; +} +#if LEAK_HUNTING +static char **xx_add_strings_to_strings (int lineno,char **strings,char **add,int need_to_dup) +{ +char **ptr =add_strings_to_strings (strings, add, need_to_dup); +fdprintf (2 ,"line %d: add_strings_to_strings %p\n" , lineno, ptr); +return ptr; +} +#define add_strings_to_strings (strings, add, need_to_dup) \ + xx_add_strings_to_strings(__LINE__, strings, add, need_to_dup) +#endif + +/* Note: takes ownership of "add" ptr (it is not strdup'ed) */ +static char **add_string_to_strings (char **strings,char *add) +{ +char *v[2 ]; + v[0 ] = add; + v[1 ] =NULL ; +return add_strings_to_strings (strings, v,/*dup:*/ 0 ); +} +#if LEAK_HUNTING +static char **xx_add_string_to_strings (int lineno,char **strings,char *add) +{ +char **ptr =add_string_to_strings (strings, add); +fdprintf (2 ,"line %d: add_string_to_strings %p\n" , lineno, ptr); +return ptr; +} +#define add_string_to_strings (strings, add) \ + xx_add_string_to_strings(__LINE__, strings, add) +#endif + +static void free_strings (char **strings) +{ +char **v; + +if (!strings) +return ; + v = strings; +while (*v) { +free (*v); + v++; + } +free (strings); +} + +static int dup_CLOEXEC (int fd,int avoid_fd) +{ +int newfd; + repeat: + newfd =fcntl (fd,F_DUPFD_CLOEXEC , avoid_fd +1 ); +if (newfd >=0 ) { +if (F_DUPFD_CLOEXEC ==F_DUPFD )/* if old libc (w/o F_DUPFD_CLOEXEC) */ +fcntl (newfd,F_SETFD ,FD_CLOEXEC ); + }else {/* newfd < 0 */ +if (errno ==EBUSY ) + goto repeat; +if (errno ==EINTR ) + goto repeat; + } +return newfd; +} + +static int xdup_CLOEXEC_and_close (int fd,int avoid_fd) +{ +int newfd; + repeat: + newfd =fcntl (fd,F_DUPFD_CLOEXEC , avoid_fd +1 ); +if (newfd <0 ) { +if (errno ==EBUSY ) + goto repeat; +if (errno ==EINTR ) + goto repeat; +/* fd was not open? */ +if (errno ==EBADF ) +return fd; +xfunc_die (); + } +if (F_DUPFD_CLOEXEC ==F_DUPFD )/* if old libc (w/o F_DUPFD_CLOEXEC) */ +fcntl (newfd,F_SETFD ,FD_CLOEXEC ); +close (fd); +return newfd; +} + + +/* Manipulating HFILEs */ +static HFILE *hfopen (const char *name) +{ +HFILE *fp; +int fd; + + fd =STDIN_FILENO ; +if (name) { + fd =open (name,O_RDONLY |O_CLOEXEC ); +if (fd <0 ) +return NULL ; +if (O_CLOEXEC ==0 )/* ancient libc */ +close_on_exec_on (fd); + } + + fp =xmalloc (sizeof (*fp)); +if (name ==NULL ) +G .HFILE_stdin = fp; + fp->fd = fd; + fp->cur = fp->end = fp->buf; + fp->next_hfile =G .HFILE_list; +G .HFILE_list = fp; +return fp; +} +static void hfclose (HFILE *fp) +{ +HFILE **pp = &G .HFILE_list; +while (*pp) { +HFILE *cur = *pp; +if (cur == fp) { + *pp = cur->next_hfile; +break ; + } + pp = &cur->next_hfile; + } +if (fp->fd >=0 ) +close (fp->fd); +free (fp); +} +static int refill_HFILE_and_getc (HFILE *fp) +{ +int n; + +if (fp->fd <0 ) { +/* Already saw EOF */ +return EOF ; + } +#if ENABLE_HUSH_INTERACTIVE && !ENABLE_FEATURE_EDITING +/* If user presses ^C, read() restarts after SIGINT (we use SA_RESTART). +* IOW: ^C will not immediately stop line input. +* But poll() is different: it does NOT restart after signals. +*/ +if (fp ==G .HFILE_stdin) { +struct pollfd pfd[1 ]; + pfd[0 ].fd = fp->fd; + pfd[0 ].events =POLLIN ; + n =poll (pfd,1 ,-1 ); +if (n <0 +/*&& errno == EINTR - assumed true */ + &&sigismember (&G .pending_set,SIGINT ) + ) { +return '\0' ; + } + } +#else +/* if FEATURE_EDITING=y, we do not use this routine for interactive input */ +#endif +/* Try to buffer more input */ + n =safe_read (fp->fd, fp->buf,sizeof (fp->buf)); +if (n <0 ) { +bb_simple_perror_msg ("read error" ); + n =0 ; + } + fp->cur = fp->buf; + fp->end = fp->buf + n; +if (n ==0 ) { +/* EOF/error */ +close (fp->fd); + fp->fd =-1 ; +return EOF ; + } +return (unsigned char )(*fp->cur++); +} +/* Inlined for common case of non-empty buffer. +*/ +static ALWAYS_INLINE int hfgetc(HFILE *fp) +{ +if (fp->cur < fp->end) +return (unsigned char )(*fp->cur++); +/* Buffer empty */ +return refill_HFILE_and_getc (fp); +} +static int move_HFILEs_on_redirect (int fd,int avoid_fd) +{ +HFILE *fl =G .HFILE_list; +while (fl) { +if (fd == fl->fd) { +/* We use it only on script files, they are all CLOEXEC */ + fl->fd =xdup_CLOEXEC_and_close (fd, avoid_fd); +debug_printf_redir ("redirect_fd %d: matches a script fd, moving it to %d\n" , fd, fl->fd); +return 1 ;/* "found and moved" */ + } + fl = fl->next_hfile; + } +#if ENABLE_HUSH_MODE_X +if (G .x_mode_fd >0 && fd ==G .x_mode_fd) { +G .x_mode_fd =xdup_CLOEXEC_and_close (fd, avoid_fd); +return 1 ;/* "found and moved" */ + } +#endif +return 0 ;/* "not in the list" */ +} +#if ENABLE_FEATURE_SH_STANDALONE &&BB_MMU +static void close_all_HFILE_list (void ) +{ +HFILE *fl =G .HFILE_list; +while (fl) { +/* hfclose would also free HFILE object. +* It is disastrous if we share memory with a vforked parent. +* I'm not sure we never come here after vfork. +* Therefore just close fd, nothing more. +* +* ">" instead of ">=": we don't close fd#0, +* interactive shell uses hfopen(NULL) as stdin input +* which has fl->fd == 0, but fd#0 gets redirected in pipes. +* If we'd close it here, then e.g. interactive "set | sort" +* with NOFORKed sort, would have sort's input fd closed. +*/ +if (fl->fd >0 ) +/*hfclose(fl); - unsafe */ +close (fl->fd); + fl = fl->next_hfile; + } +} +#endif +static int fd_in_HFILEs (int fd) +{ +HFILE *fl =G .HFILE_list; +while (fl) { +if (fl->fd == fd) +return 1 ; + fl = fl->next_hfile; + } +return 0 ; +} + + +/* Helpers for setting new $n and restoring them back +*/ +typedef struct save_arg_t { +char *sv_argv0; +char **sv_g_argv; +int sv_g_argc; + IF_HUSH_SET(smallint sv_g_malloced;) +}save_arg_t ; + +static void save_and_replace_G_args (save_arg_t *sv,char **argv) +{ + sv->sv_argv0 = argv[0 ]; + sv->sv_g_argv =G .global_argv; + sv->sv_g_argc =G .global_argc; + IF_HUSH_SET(sv->sv_g_malloced = G.global_args_malloced;) + + argv[0] = G.global_argv[0]; /* retain $0 */ +G .global_argv = argv; + IF_HUSH_SET(G.global_args_malloced = 0;) + + G.global_argc = 1 + string_array_len(argv + 1); +} + +static void restore_G_args (save_arg_t *sv,char **argv) +{ +#if ENABLE_HUSH_SET +if (G .global_args_malloced) { +/* someone ran "set -- arg1 arg2 ...", undo */ +char **pp =G .global_argv; +while (*++pp)/* note: does not free $0 */ +free (*pp); +free (G .global_argv); + } +#endif + argv[0 ] = sv->sv_argv0; +G .global_argv = sv->sv_g_argv; +G .global_argc = sv->sv_g_argc; + IF_HUSH_SET(G.global_args_malloced = sv->sv_g_malloced;) +} + + +/* Basic theory of signal handling in shell +* ======================================== +* This does not describe what hush does, rather, it is current understanding +* what it _should_ do. If it doesn't, it's a bug. +* http://www.opengroup.org/onlinepubs/9699919799/utilities/V3_chap02.html#trap +* +* Signals are handled only after each pipe ("cmd | cmd | cmd" thing) +* is finished or backgrounded. It is the same in interactive and +* non-interactive shells, and is the same regardless of whether +* a user trap handler is installed or a shell special one is in effect. +* ^C or ^Z from keyboard seems to execute "at once" because it usually +* backgrounds (i.e. stops) or kills all members of currently running +* pipe. +* +* Wait builtin is interruptible by signals for which user trap is set +* or by SIGINT in interactive shell. +* +* Trap handlers will execute even within trap handlers. (right?) +* +* User trap handlers are forgotten when subshell ("(cmd)") is entered, +* except for handlers set to '' (empty string). +* +* If job control is off, backgrounded commands ("cmd &") +* have SIGINT, SIGQUIT set to SIG_IGN. +* +* Commands which are run in command substitution ("`cmd`") +* have SIGTTIN, SIGTTOU, SIGTSTP set to SIG_IGN. +* +* Ordinary commands have signals set to SIG_IGN/DFL as inherited +* by the shell from its parent. +* +* Signals which differ from SIG_DFL action +* (note: child (i.e., [v]forked) shell is not an interactive shell): +* +* SIGQUIT: ignore +* SIGTERM (interactive): ignore +* SIGHUP (interactive): +* send SIGCONT to stopped jobs, send SIGHUP to all jobs and exit +* SIGTTIN, SIGTTOU, SIGTSTP (if job control is on): ignore +* Note that ^Z is handled not by trapping SIGTSTP, but by seeing +* that all pipe members are stopped. Try this in bash: +* while :; do :; done - ^Z does not background it +* (while :; do :; done) - ^Z backgrounds it +* SIGINT (interactive): wait for last pipe, ignore the rest +* of the command line, show prompt. NB: ^C does not send SIGINT +* to interactive shell while shell is waiting for a pipe, +* since shell is bg'ed (is not in foreground process group). +* Example 1: this waits 5 sec, but does not execute ls: +* "echo $$; sleep 5; ls -l" + "kill -INT <pid>" +* Example 2: this does not wait and does not execute ls: +* "echo $$; sleep 5 & wait; ls -l" + "kill -INT <pid>" +* Example 3: this does not wait 5 sec, but executes ls: +* "sleep 5; ls -l" + press ^C +* Example 4: this does not wait and does not execute ls: +* "sleep 5 & wait; ls -l" + press ^C +* +* (What happens to signals which are IGN on shell start?) +* (What happens with signal mask on shell start?) +* +* Old implementation +* ================== +* We use in-kernel pending signal mask to determine which signals were sent. +* We block all signals which we don't want to take action immediately, +* i.e. we block all signals which need to have special handling as described +* above, and all signals which have traps set. +* After each pipe execution, we extract any pending signals via sigtimedwait() +* and act on them. +* +* unsigned special_sig_mask: a mask of such "special" signals +* sigset_t blocked_set: current blocked signal set +* +* "trap - SIGxxx": +* clear bit in blocked_set unless it is also in special_sig_mask +* "trap 'cmd' SIGxxx": +* set bit in blocked_set (even if 'cmd' is '') +* after [v]fork, if we plan to be a shell: +* unblock signals with special interactive handling +* (child shell is not interactive), +* unset all traps except '' (note: regardless of child shell's type - {}, (), etc) +* after [v]fork, if we plan to exec: +* POSIX says fork clears pending signal mask in child - no need to clear it. +* Restore blocked signal set to one inherited by shell just prior to exec. +* +* Note: as a result, we do not use signal handlers much. The only uses +* are to count SIGCHLDs +* and to restore tty pgrp on signal-induced exit. +* +* Note 2 (compat): +* Standard says "When a subshell is entered, traps that are not being ignored +* are set to the default actions". bash interprets it so that traps which +* are set to '' (ignore) are NOT reset to defaults. We do the same. +* +* Problem: the above approach makes it unwieldy to catch signals while +* we are in read builtin, or while we read commands from stdin: +* masked signals are not visible! +* +* New implementation +* ================== +* We record each signal we are interested in by installing signal handler +* for them - a bit like emulating kernel pending signal mask in userspace. +* We are interested in: signals which need to have special handling +* as described above, and all signals which have traps set. +* Signals are recorded in pending_set. +* After each pipe execution, we extract any pending signals +* and act on them. +* +* unsigned special_sig_mask: a mask of shell-special signals. +* unsigned fatal_sig_mask: a mask of signals on which we restore tty pgrp. +* char *traps[sig] if trap for sig is set (even if it's ''). +* sigset_t pending_set: set of sigs we received. +* +* "trap - SIGxxx": +* if sig is in special_sig_mask, set handler back to: +* record_pending_signo, or to IGN if it's a tty stop signal +* if sig is in fatal_sig_mask, set handler back to sigexit. +* else: set handler back to SIG_DFL +* "trap 'cmd' SIGxxx": +* set handler to record_pending_signo. +* "trap '' SIGxxx": +* set handler to SIG_IGN. +* after [v]fork, if we plan to be a shell: +* set signals with special interactive handling to SIG_DFL +* (because child shell is not interactive), +* unset all traps except '' (note: regardless of child shell's type - {}, (), etc) +* after [v]fork, if we plan to exec: +* POSIX says fork clears pending signal mask in child - no need to clear it. +* +* To make wait builtin interruptible, we handle SIGCHLD as special signal, +* otherwise (if we leave it SIG_DFL) sigsuspend in wait builtin will not wake up on it. +* +* Note (compat): +* Standard says "When a subshell is entered, traps that are not being ignored +* are set to the default actions". bash interprets it so that traps which +* are set to '' (ignore) are NOT reset to defaults. We do the same. +*/ +enum { +SPECIAL_INTERACTIVE_SIGS =0 + | (1 <<SIGTERM ) + | (1 <<SIGINT ) + | (1 <<SIGHUP ) + , + SPECIAL_JOBSTOP_SIGS = 0 +#if ENABLE_HUSH_JOB + | (1 <<SIGTTIN ) + | (1 <<SIGTTOU ) + | (1 <<SIGTSTP ) +#endif + , +}; + +static void record_pending_signo (int sig) +{ +sigaddset (&G .pending_set, sig); +#if ENABLE_HUSH_FAST +if (sig ==SIGCHLD ) { +G .count_SIGCHLD++; +//bb_error_msg("[%d] SIGCHLD_handler: G.count_SIGCHLD:%d G.handled_SIGCHLD:%d", getpid(), G.count_SIGCHLD, G.handled_SIGCHLD); + } +#endif +} + +static sighandler_t install_sighandler (int sig,sighandler_t handler) +{ +struct sigaction old_sa; + +/* We could use signal() to install handlers... almost: +* except that we need to mask ALL signals while handlers run. +* I saw signal nesting in strace, race window isn't small. +* SA_RESTART is also needed, but in Linux, signal() +* sets SA_RESTART too. +*/ +/* memset(&G.sa, 0, sizeof(G.sa)); - already done */ +/* sigfillset(&G.sa.sa_mask); - already done */ +/* G.sa.sa_flags = SA_RESTART; - already done */ +G .sa.sa_handler = handler; +sigaction (sig, &G .sa, &old_sa); +return old_sa.sa_handler; +} + +static void hush_exit(int exitcode) NORETURN; + +static void restore_ttypgrp_and__exit(void) NORETURN; +static void restore_ttypgrp_and__exit (void ) +{ +/* xfunc has failed! die die die */ +/* no EXIT traps, this is an escape hatch! */ +G .exiting =1 ; +hush_exit (xfunc_error_retval); +} + +#if ENABLE_HUSH_JOB + +/* Needed only on some libc: +* It was observed that on exit(), fgetc'ed buffered data +* gets "unwound" via lseek(fd, -NUM, SEEK_CUR). +* With the net effect that even after fork(), not vfork(), +* exit() in NOEXECed applet in "sh SCRIPT": +* noexec_applet_here +* echo END_OF_SCRIPT +* lseeks fd in input FILE object from EOF to "e" in "echo END_OF_SCRIPT". +* This makes "echo END_OF_SCRIPT" executed twice. +* Similar problems can be seen with msg_and_die_if_script() -> xfunc_die() +* and in `cmd` handling. +* If set as die_func(), this makes xfunc_die() exit via _exit(), not exit(): +*/ +static void fflush_and__exit(void) NORETURN; +static void fflush_and__exit (void ) +{ +fflush_all (); +_exit (xfunc_error_retval); +} + +/* After [v]fork, in child: do not restore tty pgrp on xfunc death */ +# define disable_restore_tty_pgrp_on_exit () (die_func = fflush_and__exit) +/* After [v]fork, in parent: restore tty pgrp on xfunc death */ +# define enable_restore_tty_pgrp_on_exit () (die_func = restore_ttypgrp_and__exit) + +/* Restores tty foreground process group, and exits. +* May be called as signal handler for fatal signal +* (will resend signal to itself, producing correct exit state) +* or called directly with -EXITCODE. +* We also call it if xfunc is exiting. +*/ +static void sigexit(int sig) NORETURN; +static void sigexit (int sig) +{ +/* Careful: we can end up here after [v]fork. Do not restore +* tty pgrp then, only top-level shell process does that */ +if (G_saved_tty_pgrp &&getpid () ==G .root_pid) { +/* Disable all signals: job control, SIGPIPE, etc. +* Mostly paranoid measure, to prevent infinite SIGTTOU. +*/ +sigprocmask_allsigs (SIG_BLOCK ); +tcsetpgrp (G_interactive_fd, G_saved_tty_pgrp); + } + +/* Not a signal, just exit */ +if (sig <=0 ) +_exit (- sig); + +kill_myself_with_sig (sig);/* does not return */ +} +#else + +# define disable_restore_tty_pgrp_on_exit () ((void)0) +# define enable_restore_tty_pgrp_on_exit () ((void)0) + +#endif + +static sighandler_t pick_sighandler (unsigned sig) +{ +sighandler_t handler =SIG_DFL ; +if (sig <sizeof (unsigned )*8 ) { +unsigned sigmask = (1 << sig); + +#if ENABLE_HUSH_JOB +/* is sig fatal? */ +if (G_fatal_sig_mask & sigmask) + handler = sigexit; + else +#endif +/* sig has special handling? */ +if (G .special_sig_mask & sigmask) { + handler = record_pending_signo; +/* TTIN/TTOU/TSTP can't be set to record_pending_signo +* in order to ignore them: they will be raised +* in an endless loop when we try to do some +* terminal ioctls! We do have to _ignore_ these. +*/ +if (SPECIAL_JOBSTOP_SIGS & sigmask) + handler =SIG_IGN ; + } + } +return handler; +} + +/* Restores tty foreground process group, and exits. */ +static void hush_exit (int exitcode) +{ +#if ENABLE_FEATURE_EDITING_SAVE_ON_EXIT +save_history (G .line_input_state);/* may be NULL */ +#endif + +fflush_all (); +if (G .exiting <=0 && G_traps && G_traps[0 ] && G_traps[0 ][0 ]) { +char *argv[3 ]; +/* argv[0] is unused */ + argv[1 ] =xstrdup (G_traps[0 ]);/* copy, since EXIT trap handler may modify G_traps[0] */ + argv[2 ] =NULL ; +G .exiting =1 ;/* prevent EXIT trap recursion */ +/* Note: G_traps[0] is not cleared! +* "trap" will still show it, if executed +* in the handler */ +builtin_eval (argv); + } + +#if ENABLE_FEATURE_CLEAN_UP + { +struct variable *cur_var; +if (G .cwd != bb_msg_unknown) +free ((char *)G .cwd); + cur_var =G .top_var; +while (cur_var) { +struct variable *tmp = cur_var; +if (!cur_var->max_len) +free (cur_var->varstr); + cur_var = cur_var->next; +free (tmp); + } + } +#endif + +fflush_all (); +#if ENABLE_HUSH_JOB +sigexit (- (exitcode &0xff )); +#else +_exit (exitcode); +#endif +} + +//TODO: return a mask of ALL handled sigs? +static int check_and_run_traps (void ) +{ +int last_sig =0 ; + +while (1 ) { +int sig; + +if (sigisemptyset (&G .pending_set)) +break ; + sig =0 ; +do { + sig++; +if (sigismember (&G .pending_set, sig)) { +sigdelset (&G .pending_set, sig); + goto got_sig; + } + }while (sig <NSIG ); +break ; + got_sig: +#if ENABLE_HUSH_TRAP +if (G_traps && G_traps[sig]) { +debug_printf_exec ("%s: sig:%d handler:'%s'\n" , __func__, sig,G .traps[sig]); +if (G_traps[sig][0 ]) { +/* We have user-defined handler */ +smalluint save_rcode; +int save_pre; +char *argv[3 ]; +/* argv[0] is unused */ + argv[1 ] =xstrdup (G_traps[sig]); +/* why strdup? trap can modify itself: trap 'trap "echo oops" INT' INT */ + argv[2 ] =NULL ; + save_pre =G .pre_trap_exitcode; +G .pre_trap_exitcode = save_rcode =G .last_exitcode; +builtin_eval (argv); +free (argv[1 ]); +G .pre_trap_exitcode = save_pre; +G .last_exitcode = save_rcode; +# if ENABLE_HUSH_FUNCTIONS +if (G .return_exitcode >=0 ) { +debug_printf_exec ("trap exitcode:%d\n" ,G .return_exitcode); +G .last_exitcode =G .return_exitcode; + } +# endif + last_sig = sig; + }/* else: "" trap, ignoring signal */ +continue ; + } +#endif +/* not a trap: special action */ +switch (sig) { +case SIGINT : +debug_printf_exec ("%s: sig:%d default SIGINT handler\n" , __func__, sig); +G .flag_SIGINT =1 ; + last_sig = sig; +break ; +#if ENABLE_HUSH_JOB +case SIGHUP : { +//TODO: why are we doing this? ash and dash don't do this, +//they have no handler for SIGHUP at all, +//they rely on kernel to send SIGHUP+SIGCONT to orphaned process groups +struct pipe *job; +debug_printf_exec ("%s: sig:%d default SIGHUP handler\n" , __func__, sig); +/* bash is observed to signal whole process groups, +* not individual processes */ +for (job =G .job_list; job; job = job->next) { +if (job->pgrp <=0 ) +continue ; +debug_printf_exec ("HUPing pgrp %d\n" , job->pgrp); +if (kill (- job->pgrp,SIGHUP ) ==0 ) +kill (- job->pgrp,SIGCONT ); + } +sigexit (SIGHUP ); + } +#endif +#if ENABLE_HUSH_FAST +case SIGCHLD : +debug_printf_exec ("%s: sig:%d default SIGCHLD handler\n" , __func__, sig); +G .count_SIGCHLD++; +//bb_error_msg("[%d] check_and_run_traps: G.count_SIGCHLD:%d G.handled_SIGCHLD:%d", getpid(), G.count_SIGCHLD, G.handled_SIGCHLD); +/* Note: +* We don't do 'last_sig = sig' here -> NOT returning this sig. +* This simplifies wait builtin a bit. +*/ +break ; +#endif +default :/* ignored: */ +debug_printf_exec ("%s: sig:%d default handling is to ignore\n" , __func__, sig); +/* SIGTERM, SIGQUIT, SIGTTIN, SIGTTOU, SIGTSTP */ +/* Note: +* We don't do 'last_sig = sig' here -> NOT returning this sig. +* Example: wait is not interrupted by TERM +* in interactive shell, because TERM is ignored. +*/ +break ; + } + } +return last_sig; +} + + +static const char *get_cwd (int force) +{ +if (force ||G .cwd ==NULL ) { +/* xrealloc_getcwd_or_warn(arg) calls free(arg), +* we must not try to free(bb_msg_unknown) */ +if (G .cwd == bb_msg_unknown) +G .cwd =NULL ; +G .cwd =xrealloc_getcwd_or_warn ((char *)G .cwd); +if (!G .cwd) +G .cwd = bb_msg_unknown; + } +return G .cwd; +} + + +/* +* Shell and environment variable support +*/ +static struct variable **get_ptr_to_local_var (const char *name,unsigned len) +{ +struct variable **pp; +struct variable *cur; + + pp = &G .top_var; +while ((cur = *pp) !=NULL ) { +if (strncmp (cur->varstr, name, len) ==0 && cur->varstr[len] =='=' ) +return pp; + pp = &cur->next; + } +return NULL ; +} + +static const char* FAST_FUNC get_local_var_value(const char *name) +{ +struct variable **vpp; +unsigned len =strlen (name); + +if (G .expanded_assignments) { +char **cpp =G .expanded_assignments; +while (*cpp) { +char *cp = *cpp; +if (strncmp (cp, name, len) ==0 && cp[len] =='=' ) +return cp + len +1 ; + cpp++; + } + } + + vpp =get_ptr_to_local_var (name, len); +if (vpp) +return (*vpp)->varstr + len +1 ; + +if (strcmp (name,"PPID" ) ==0 ) +return utoa (G .root_ppid); +// bash compat: UID? EUID? +#if ENABLE_HUSH_RANDOM_SUPPORT +if (strcmp (name,"RANDOM" ) ==0 ) +return utoa (next_random (&G .random_gen)); +#endif +#if ENABLE_HUSH_LINENO_VAR +if (strcmp (name,"LINENO" ) ==0 ) +return utoa (G .execute_lineno); +#endif +#if BASH_EPOCH_VARS + { +const char *fmt =NULL ; +if (strcmp (name,"EPOCHSECONDS" ) ==0 ) + fmt ="%llu" ; +else if (strcmp (name,"EPOCHREALTIME" ) ==0 ) + fmt ="%llu.%06u" ; +if (fmt) { +struct timeval tv; +xgettimeofday (&tv); +sprintf (G .epoch_buf, fmt, (unsigned long long )tv.tv_sec, + (unsigned )tv.tv_usec); +return G .epoch_buf; + } + } +#endif +return NULL ; +} + +#if ENABLE_HUSH_GETOPTS +static void handle_changed_special_names (const char *name,unsigned name_len) +{ +if (name_len ==6 ) { +if (strncmp (name,"OPTIND" ,6 ) ==0 ) { +G .getopt_count =0 ; +return ; + } + } +} +#else +/* Do not even bother evaluating arguments */ +# define handle_changed_special_names (...) ((void)0) +#endif + +/* str holds "NAME=VAL" and is expected to be malloced. +* We take ownership of it. +*/ +#define SETFLAG_EXPORT (1 << 0) +#define SETFLAG_UNEXPORT (1 << 1) +#define SETFLAG_MAKE_RO (1 << 2) +#define SETFLAG_VARLVL_SHIFT 3 +static int set_local_var (char *str,unsigned flags) +{ +struct variable **cur_pp; +struct variable *cur; +char *free_me =NULL ; +char *eq_sign; +int name_len; +int retval; +unsigned local_lvl = (flags >>SETFLAG_VARLVL_SHIFT ); + + eq_sign =strchr (str,'=' ); +if (HUSH_DEBUG && !eq_sign) +bb_simple_error_msg_and_die ("BUG in setvar" ); + + name_len = eq_sign - str +1 ;/* including '=' */ + cur_pp = &G .top_var; +while ((cur = *cur_pp) !=NULL ) { +if (strncmp (cur->varstr, str, name_len) !=0 ) { + cur_pp = &cur->next; +continue ; + } + +/* We found an existing var with this name */ +if (cur->flg_read_only) { +bb_error_msg ("%s: readonly variable" , str); +free (str); +//NOTE: in bash, assignment in "export READONLY_VAR=Z" fails, and sets $?=1, +//but export per se succeeds (does put the var in env). We don't mimic that. +return -1 ; + } +if (flags &SETFLAG_UNEXPORT ) {// && cur->flg_export ? +debug_printf_env ("%s: unsetenv '%s'\n" , __func__, str); + *eq_sign ='\0' ; +unsetenv (str); + *eq_sign ='=' ; + } +if (cur->var_nest_level < local_lvl) { +/* bash 3.2.33(1) and exported vars: +* # export z=z +* # f() { local z=a; env | grep ^z; } +* # f +* z=a +* # env | grep ^z +* z=z +*/ +if (cur->flg_export) + flags |=SETFLAG_EXPORT ; +/* New variable is local ("local VAR=VAL" or +* "VAR=VAL cmd") +* and existing one is global, or local +* on a lower level that new one. +* Remove it from global variable list: +*/ + *cur_pp = cur->next; +if (G .shadowed_vars_pp) { +/* Save in "shadowed" list */ +debug_printf_env ("shadowing %s'%s'/%u by '%s'/%u\n" , + cur->flg_export ?"exported " :"" , + cur->varstr, cur->var_nest_level, str, local_lvl + ); + cur->next = *G .shadowed_vars_pp; + *G .shadowed_vars_pp = cur; + }else { +/* Came from pseudo_exec_argv(), no need to save: delete it */ +debug_printf_env ("shadow-deleting %s'%s'/%u by '%s'/%u\n" , + cur->flg_export ?"exported " :"" , + cur->varstr, cur->var_nest_level, str, local_lvl + ); +if (cur->max_len ==0 )/* allocated "VAR=VAL"? */ + free_me = cur->varstr;/* then free it later */ +free (cur); + } +break ; + } + +if (strcmp (cur->varstr + name_len, eq_sign +1 ) ==0 ) { +debug_printf_env ("assignement '%s' does not change anything\n" , str); + free_and_exp: +free (str); + goto exp; + } + +/* Replace the value in the found "struct variable" */ +if (cur->max_len !=0 ) { +if (cur->max_len >=strnlen (str, cur->max_len +1 )) { +/* This one is from startup env, reuse space */ +debug_printf_env ("reusing startup env for '%s'\n" , str); +strcpy (cur->varstr, str); + goto free_and_exp; + } +/* Can't reuse */ + cur->max_len =0 ; + goto set_str_and_exp; + } +/* max_len == 0 signifies "malloced" var, which we can +* (and have to) free. But we can't free(cur->varstr) here: +* if cur->flg_export is 1, it is in the environment. +* We should either unsetenv+free, or wait until putenv, +* then putenv(new)+free(old). +*/ + free_me = cur->varstr; + goto set_str_and_exp; + } + +/* Not found or shadowed - create new variable struct */ +debug_printf_env ("%s: alloc new var '%s'/%u\n" , __func__, str, local_lvl); + cur =xzalloc (sizeof (*cur)); + cur->var_nest_level = local_lvl; + cur->next = *cur_pp; + *cur_pp = cur; + + set_str_and_exp: + cur->varstr = str; + exp: +#if !BB_MMU ||ENABLE_HUSH_READONLY +if (flags &SETFLAG_MAKE_RO ) { + cur->flg_read_only =1 ; + } +#endif +if (flags &SETFLAG_EXPORT ) + cur->flg_export =1 ; + retval =0 ; +if (cur->flg_export) { +if (flags &SETFLAG_UNEXPORT ) { + cur->flg_export =0 ; +/* unsetenv was already done */ + }else { +debug_printf_env ("%s: putenv '%s'/%u\n" , __func__, cur->varstr, cur->var_nest_level); + retval =putenv (cur->varstr); +/* fall through to "free(free_me)" - +* only now we can free old exported malloced string +*/ + } + } +free (free_me); + +handle_changed_special_names (cur->varstr, name_len -1 ); + +return retval; +} + +static void FAST_FUNC set_local_var_from_halves(const char *name, const char *val) +{ +char *var =xasprintf ("%s=%s" , name, val); +set_local_var (var,/*flag:*/ 0 ); +} + +/* Used at startup and after each cd */ +static void set_pwd_var (unsigned flag) +{ +set_local_var (xasprintf ("PWD=%s" ,get_cwd (/*force:*/ 1 )), flag); +} + +#if ENABLE_HUSH_UNSET ||ENABLE_HUSH_GETOPTS +static int unset_local_var_len (const char *name,int name_len) +{ +struct variable *cur; +struct variable **cur_pp; + + cur_pp = &G .top_var; +while ((cur = *cur_pp) !=NULL ) { +if (strncmp (cur->varstr, name, name_len) ==0 + && cur->varstr[name_len] =='=' + ) { +if (cur->flg_read_only) { +bb_error_msg ("%s: readonly variable" , name); +return EXIT_FAILURE ; + } + + *cur_pp = cur->next; +debug_printf_env ("%s: unsetenv '%s'\n" , __func__, cur->varstr); +bb_unsetenv (cur->varstr); +if (!cur->max_len) +free (cur->varstr); +free (cur); + +break ; + } + cur_pp = &cur->next; + } + +/* Handle "unset LINENO" et al even if did not find the variable to unset */ +handle_changed_special_names (name, name_len); + +return EXIT_SUCCESS ; +} + +static int unset_local_var (const char *name) +{ +return unset_local_var_len (name,strlen (name)); +} +#endif + + +/* +* Helpers for "var1=val1 var2=val2 cmd" feature +*/ +static void add_vars (struct variable *var) +{ +struct variable *next; + +while (var) { + next = var->next; + var->next =G .top_var; +G .top_var = var; +if (var->flg_export) { +debug_printf_env ("%s: restoring exported '%s'/%u\n" , __func__, var->varstr, var->var_nest_level); +putenv (var->varstr); + }else { +debug_printf_env ("%s: restoring variable '%s'/%u\n" , __func__, var->varstr, var->var_nest_level); + } + var = next; + } +} + +/* We put strings[i] into variable table and possibly putenv them. +* If variable is read only, we can free the strings[i] +* which attempts to overwrite it. +* The strings[] vector itself is freed. +*/ +static void set_vars_and_save_old (char **strings) +{ +char **s; + +if (!strings) +return ; + + s = strings; +while (*s) { +struct variable *var_p; +struct variable **var_pp; +char *eq; + + eq =strchr (*s,'=' ); +if (HUSH_DEBUG && !eq) +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; +if (var_p->flg_read_only) { +char **p; +bb_error_msg ("%s: readonly variable" , *s); +/* +* "VAR=V BLTIN" unsets VARs after BLTIN completes. +* If VAR is readonly, leaving it in the list +* after asssignment error (msg above) +* causes doubled error message later, on unset. +*/ +debug_printf_env ("removing/freeing '%s' element\n" , *s); +free (*s); + p = s; +do { *p = p[1 ]; p++; }while (*p); + goto next; + } +/* below, set_local_var() with nest level will +* "shadow" (remove) this variable from +* global linked list. +*/ + } +debug_printf_env ("%s: env override '%s'/%u\n" , __func__, *s,G .var_nest_level); +set_local_var (*s, (G .var_nest_level <<SETFLAG_VARLVL_SHIFT ) |SETFLAG_EXPORT ); + s++; + next: ; + } +free (strings); +} + + +/* +* Unicode helper +*/ +static void reinit_unicode_for_hush (void ) +{ +/* Unicode support should be activated even if LANG is set +* _during_ shell execution, not only if it was set when +* shell was started. Therefore, re-check LANG every time: +*/ +if (ENABLE_FEATURE_CHECK_UNICODE_IN_ENV + ||ENABLE_UNICODE_USING_LOCALE + ) { +const char *s =get_local_var_value ("LC_ALL" ); +if (!s) s =get_local_var_value ("LC_CTYPE" ); +if (!s) s =get_local_var_value ("LANG" ); +reinit_unicode (s); + } +} + +/* +* in_str support (strings, and "strings" read from files). +*/ + +#if ENABLE_HUSH_INTERACTIVE +/* To test correct lineedit/interactive behavior, type from command line: +* echo $P\ +* \ +* AT\ +* H\ +* \ +* It exercises a lot of corner cases. +*/ +static const char *setup_prompt_string (void ) +{ +const char *prompt_str; + +debug_printf_prompt ("%s promptmode:%d\n" , __func__,G .promptmode); + +# if ENABLE_FEATURE_EDITING_FANCY_PROMPT + prompt_str =get_local_var_value (G .promptmode ==0 ?"PS1" :"PS2" ); +if (!prompt_str) + prompt_str ="" ; +# else + prompt_str ="> " ;/* if PS2, else... */ +if (G .promptmode ==0 ) {/* PS1 */ +/* No fancy prompts supported, (re)generate "CURDIR $ " by hand */ +free (G .PS1); +/* bash uses $PWD value, even if it is set by user. +* It uses current dir only if PWD is unset. +* We always use current dir. */ + prompt_str =G .PS1 =xasprintf ("%s %c " ,get_cwd (0 ), (geteuid () !=0 ) ?'$' :'#' ); + } +# endif +debug_printf ("prompt_str '%s'\n" , prompt_str); +return prompt_str; +} +static int get_user_input (struct in_str *i) +{ +# if ENABLE_FEATURE_EDITING +/* In EDITING case, this function reads next input line, +* saves it in i->p, then returns 1st char of it. +*/ +int r; +const char *prompt_str; + + prompt_str =setup_prompt_string (); +for (;;) { +reinit_unicode_for_hush (); +G .flag_SIGINT =0 ; +/* buglet: SIGINT will not make new prompt to appear _at once_, +* only after <Enter>. (^C works immediately) */ + r =read_line_input (G .line_input_state, prompt_str, +G .user_input_buf,CONFIG_FEATURE_EDITING_MAX_LEN -1 + ); +/* read_line_input intercepts ^C, "convert" it to SIGINT */ +if (r ==0 ) { +raise (SIGINT ); + } +check_and_run_traps (); +if (r !=0 && !G .flag_SIGINT) +break ; +/* ^C or SIGINT: repeat */ +/* bash prints ^C even on real SIGINT (non-kbd generated) */ +write (STDOUT_FILENO ,"^C\n" ,3 ); +G .last_exitcode =128 |SIGINT ; + } +if (r <0 ) { +/* EOF/error detected */ +/* ^D on interactive input goes to next line before exiting: */ +write (STDOUT_FILENO ,"\n" ,1 ); + i->p =NULL ; + i->peek_buf[0 ] = r =EOF ; +return r; + } + i->p =G .user_input_buf; +return (unsigned char )*i->p++; +# else +/* In !EDITING case, this function gets called for every char. +* Buffering happens deeper in the call chain, in hfgetc(i->file). +*/ +int r; + +for (;;) { +G .flag_SIGINT =0 ; +if (i->last_char =='\0' || i->last_char =='\n' ) { +const char *prompt_str =setup_prompt_string (); +/* Why check_and_run_traps here? Try this interactively: +* $ trap 'echo INT' INT; (sleep 2; kill -INT $$) & +* $ <[enter], repeatedly...> +* Without check_and_run_traps, handler never runs. +*/ +check_and_run_traps (); +fputs_stdout (prompt_str); +fflush_all (); + } + r =hfgetc (i->file); +/* In !ENABLE_FEATURE_EDITING we don't use read_line_input, +* no ^C masking happens during fgetc, no special code for ^C: +* it generates SIGINT as usual. +*/ +check_and_run_traps (); +if (r !='\0' && !G .flag_SIGINT) +break ; +if (G .flag_SIGINT) { +/* ^C or SIGINT: repeat */ +/* bash prints ^C even on real SIGINT (non-kbd generated) */ +/* kernel prints "^C" itself, just print newline: */ +write (STDOUT_FILENO ,"\n" ,1 ); +G .last_exitcode =128 |SIGINT ; + } + } +return r; +# endif +} +/* This is the magic location that prints prompts +* and gets data back from the user */ +static int fgetc_interactive (struct in_str *i) +{ +int ch; +/* If it's interactive stdin, get new line. */ +if (G_interactive_fd && i->file ==G .HFILE_stdin) { +/* Returns first char (or EOF), the rest is in i->p[] */ + ch =get_user_input (i); +G .promptmode =1 ;/* PS2 */ +debug_printf_prompt ("%s promptmode=%d\n" , __func__,G .promptmode); + }else { +/* Not stdin: script file, sourced file, etc */ +do ch =hfgetc (i->file);while (ch =='\0' ); + } +return ch; +} +#else /* !INTERACTIVE */ +static ALWAYS_INLINE int fgetc_interactive(struct in_str *i) +{ +int ch; +do ch =hfgetc (i->file);while (ch =='\0' ); +return ch; +} +#endif /* !INTERACTIVE */ + +static int i_getch (struct in_str *i) +{ +int ch; + +if (!i->file) { +/* string-based in_str */ + ch = (unsigned char )*i->p; +if (ch !='\0' ) { + i->p++; + i->last_char = ch; +return ch; + } +return EOF ; + } + +/* FILE-based in_str */ + +#if ENABLE_FEATURE_EDITING +/* This can be stdin, check line editing char[] buffer */ +if (i->p && *i->p !='\0' ) { + ch = (unsigned char )*i->p++; + goto out; + } +#endif +/* peek_buf[] is an int array, not char. Can contain EOF. */ + ch = i->peek_buf[0 ]; +if (ch !=0 ) { +int ch2 = i->peek_buf[1 ]; + i->peek_buf[0 ] = ch2; +if (ch2 ==0 )/* very likely, avoid redundant write */ + goto out; + i->peek_buf[1 ] =0 ; + goto out; + } + + ch =fgetc_interactive (i); + out: +debug_printf ("file_get: got '%c' %d\n" , ch, ch); + i->last_char = ch; +#if ENABLE_HUSH_LINENO_VAR +if (ch =='\n' ) { +G .parse_lineno++; +debug_printf_parse ("G.parse_lineno++ = %u\n" ,G .parse_lineno); + } +#endif +return ch; +} + +static int i_peek (struct in_str *i) +{ +int ch; + +if (!i->file) { +/* string-based in_str */ +/* Doesn't report EOF on NUL. None of the callers care. */ +return (unsigned char )*i->p; + } + +/* FILE-based in_str */ + +#if ENABLE_FEATURE_EDITING &&ENABLE_HUSH_INTERACTIVE +/* This can be stdin, check line editing char[] buffer */ +if (i->p && *i->p !='\0' ) +return (unsigned char )*i->p; +#endif +/* peek_buf[] is an int array, not char. Can contain EOF. */ + ch = i->peek_buf[0 ]; +if (ch !=0 ) +return ch; + +/* Need to get a new char */ + ch =fgetc_interactive (i); +debug_printf ("file_peek: got '%c' %d\n" , ch, ch); + +/* Save it by either rolling back line editing buffer, or in i->peek_buf[0] */ +#if ENABLE_FEATURE_EDITING &&ENABLE_HUSH_INTERACTIVE +if (i->p) { + i->p -=1 ; +return ch; + } +#endif + i->peek_buf[0 ] = ch; +/*i->peek_buf[1] = 0; - already is */ +return ch; +} + +/* Only ever called if i_peek() was called, and did not return EOF. +* IOW: we know the previous peek saw an ordinary char, not EOF, not NUL, +* not end-of-line. Therefore we never need to read a new editing line here. +*/ +static int i_peek2 (struct in_str *i) +{ +int ch; + +/* There are two cases when i->p[] buffer exists. +* (1) it's a string in_str. +* (2) It's a file, and we have a saved line editing buffer. +* In both cases, we know that i->p[0] exists and not NUL, and +* the peek2 result is in i->p[1]. +*/ +if (i->p) +return (unsigned char )i->p[1 ]; + +/* Now we know it is a file-based in_str. */ + +/* peek_buf[] is an int array, not char. Can contain EOF. */ +/* Is there 2nd char? */ + ch = i->peek_buf[1 ]; +if (ch ==0 ) { +/* We did not read it yet, get it now */ +do ch =hfgetc (i->file);while (ch =='\0' ); + i->peek_buf[1 ] = ch; + } + +debug_printf ("file_peek2: got '%c' %d\n" , ch, ch); +return ch; +} + +static int i_getch_and_eat_bkslash_nl (struct in_str *input) +{ +for (;;) { +int ch, ch2; + + ch =i_getch (input); +if (ch !='\\' ) +return ch; + ch2 =i_peek (input); +if (ch2 !='\n' ) +return ch; +/* backslash+newline, skip it */ +i_getch (input); + } +} + +/* Note: this function _eats_ \<newline> pairs, safe to use plain +* i_getch() after it instead of i_getch_and_eat_bkslash_nl(). +*/ +static int i_peek_and_eat_bkslash_nl (struct in_str *input) +{ +for (;;) { +int ch, ch2; + + ch =i_peek (input); +if (ch !='\\' ) +return ch; + ch2 =i_peek2 (input); +if (ch2 !='\n' ) +return ch; +/* backslash+newline, skip it */ +i_getch (input); +i_getch (input); + } +} + +static void setup_file_in_str (struct in_str *i,HFILE *fp) +{ +memset (i,0 ,sizeof (*i)); + i->file = fp; +/* i->p = NULL; */ +} + +static void setup_string_in_str (struct in_str *i,const char *s) +{ +memset (i,0 ,sizeof (*i)); +/*i->file = NULL */ ; + i->p = s; +} + + +/* +* o_string support +*/ +#define B_CHUNK (32 * sizeof(char*)) + +static void o_reset_to_empty_unquoted (o_string *o) +{ + o->length =0 ; + o->has_quoted_part =0 ; +if (o->data) + o->data[0 ] ='\0' ; +} + +static void o_free_and_set_NULL (o_string *o) +{ +free (o->data); +memset (o,0 ,sizeof (*o)); +} + +static ALWAYS_INLINE void o_free(o_string *o) +{ +free (o->data); +} + +static void o_grow_by (o_string *o,int len) +{ +if (o->length + len > o->maxlen) { + o->maxlen += (2 * len) | (B_CHUNK -1 ); + o->data =xrealloc (o->data,1 + o->maxlen); + } +} + +static void o_addchr (o_string *o,int ch) +{ +debug_printf ("o_addchr: '%c' o->length=%d o=%p\n" , ch, o->length, o); +if (o->length < o->maxlen) { +/* likely. avoid o_grow_by() call */ + add: + o->data[o->length] = ch; + o->length++; + o->data[o->length] ='\0' ; +return ; + } +o_grow_by (o,1 ); + goto add; +} + +#if 0 +/* Valid only if we know o_string is not empty */ +static void o_delchr (o_string *o) +{ + o->length--; + o->data[o->length] ='\0' ; +} +#endif + +static void o_addblock (o_string *o,const char *str,int len) +{ +o_grow_by (o, len); + ((char *)mempcpy (&o->data[o->length], str, len))[0 ] ='\0' ; + o->length += len; +} + +static void o_addstr (o_string *o,const char *str) +{ +o_addblock (o, str,strlen (str)); +} + +static void o_addstr_with_NUL (o_string *o,const char *str) +{ +o_addblock (o, str,strlen (str) +1 ); +} + +#if !BB_MMU +static void nommu_addchr (o_string *o,int ch) +{ +if (o) +o_addchr (o, ch); +} +#else +# define nommu_addchr (o, str) ((void)0) +#endif + +#if ENABLE_HUSH_MODE_X +static void x_mode_addchr (int ch) +{
Lines of this file are not shown. View the raw message.
The rest of this diff is not shown. View the raw message.
Signature · 1 line
2.25.1
Part of the diff is not shown here. View the raw message.
RFC PATCH v4 9/28 cli: Port Busybox 2021 hush to U-Boot
In reply to Francis LanielAdds new file cli_hush_2021.c, it is a copy of Busybox hush file as it was of time to commit 37460f5da.
This commit modifies Busybox hush to not compile some part specific to Busybox and adds some code needed by U-Boot.
The modifications consists mainly on adding code #if(n)def guards.
For the moment, this refurbished flavor of hush only permits running command without any keywords (i.e., if and for are not recognized) or variable expansion (i.e., echo $foo prints foo and not value stored in variable foo).
A new file was also added to define some functions specific to U-Boot.
--- common/cli_hush_2021.c | 286 +++++++++++++++++++++ common/cli_hush_upstream.c | 494 ++++++++++++++++++++++++++++++++++++- 2 files changed, 779 insertions(+), 1 deletion(-) create mode 100644 common/cli_hush_2021.c
common/cli_hush_2021.c new file +286 -0
@@ -0,0 +1,286 @@ +// SPDX-License-Identifier: GPL-2.0+ +/* +* This file defines the compilation unit for the new hush shell version. The +* actual implementation from upstream BusyBox can be found in +* `cli_hush_2021_upstream.c` which is included at the end of this file. +* +* This "wrapper" technique is used to keep the changes to the upstream version +* as minmal as possible. Instead, all defines and redefines necessary are done +* here, outside the upstream sources. This will hopefully make upgrades to +* newer revisions much easier. +* +* Copyright (c) 2021, Harald Seiler, DENX Software Engineering, [email protected] +*/ + +#include <common.h> /* readline */ +#include <env.h> +#include <malloc.h> /* malloc, free, realloc*/ +#include <linux/ctype.h> /* isalpha, isdigit */ +#include <console.h> +#include <bootretry.h> +#include <cli.h> +#include <cli_hush.h> +#include <command.h> /* find_cmd */ +#include <asm/global_data.h> + +/* +* BusyBox Version: UPDATE THIS WHEN PULLING NEW UPSTREAM REVISION! +*/ +#define BB_VER "1.34.0.git37460f5daff9" + +/* +* Define hush features by the names used upstream. +*/ +#define ENABLE_HUSH_INTERACTIVE 1 +#define ENABLE_FEATURE_EDITING 1 +#define ENABLE_HUSH_IF 1 +#define ENABLE_HUSH_LOOPS 1 +/* No MMU in U-Boot */ +#define BB_MMU 0 +#define USE_FOR_NOMMU (...) __VA_ARGS__ +#define USE_FOR_MMU (...) + +/* +* Size-saving "small" ints (arch-dependent) +*/ +#if CONFIG_IS_ENABLED (X86 ) ||CONFIG_IS_ENABLED (X86_64 ) ||CONFIG_IS_ENABLED (MIPS ) +/* add other arches which benefit from this... */ +typedef signed char smallint ; +typedef unsigned char smalluint ; +#else +/* for arches where byte accesses generate larger code: */ +typedef int smallint ; +typedef unsigned smalluint ; +#endif + +/* +* Alignment defines used by BusyBox. +*/ +#define ALIGN1 __attribute__((aligned(1))) +#define ALIGN2 __attribute__((aligned(2))) +#define ALIGN4 __attribute__((aligned(4))) +#define ALIGN8 __attribute__((aligned(8))) +#define ALIGN_PTR __attribute__((aligned(sizeof(void*)))) + +/* +* Miscellaneous compiler/platform defines. +*/ +#define FAST_FUNC /* not used in U-Boot */ +#define UNUSED_PARAM __always_unused +#define ALWAYS_INLINE __always_inline +#define NOINLINE noinline + +/* +* Defines to provide equivalents to what libc/BusyBox defines. +*/ +#define EOF (-1) +#define EXIT_SUCCESS 0 +#define EXIT_FAILURE 1 + +/* +* Stubs to provide libc/BusyBox functions based on U-Boot equivalents where it +* makes sense. +*/ +#define utoa simple_itoa + +static void __noreturn xfunc_die (void ) +{ +panic ("HUSH died!" ); +} + +#define bb_error_msg_and_die (format, ...) do { \ +panic("HUSH: " format, __VA_ARGS__); \ +} while (0); + +#define bb_simple_error_msg_and_die (msg) do { \ +panic_str("HUSH: " msg); \ +} while (0); + +/* fdprintf() is used for debug output. */ +static int __maybe_unused fdprintf (int fd,const char *format, ...) +{ +va_list args; +uint i; + +assert (fd ==2 ); + +va_start (args, format); + i =vprintf (format, args); +va_end (args); + +return i; +} + +static void bb_verror_msg (const char *s,va_list p,const char * strerr) +{ +/* TODO: what to do with strerr arg? */ +vprintf (s, p); +} + +static void bb_error_msg (const char *s, ...) +{ +va_list p; + +va_start (p, s); +bb_verror_msg (s, p,NULL ); +va_end (p); +} + +static void bb_simple_error_msg (const char *s) +{ +bb_error_msg ("%s" , s); +} + +static void *xmalloc (size_t size) +{ +void *p =NULL ; +if (!(p =malloc (size))) +panic ("out of memory" ); +return p; +} + +static void *xzalloc (size_t size) +{ +void *p =xmalloc (size); +memset (p,0 , size); +return p; +} + +static void *xrealloc (void *ptr,size_t size) +{ +void *p =NULL ; +if (!(p =realloc (ptr, size))) +panic ("out of memory" ); +return p; +} + +static void *xmemdup (const void *s,int n) +{ +return memcpy (xmalloc (n), s, n); +} + +#define xstrdup strdup +#define xstrndup strndup + +static void *mempcpy (void *dest,const void *src,size_t len) +{ +return memcpy (dest, src, len) + len; +} + +/* 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 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; +} + +static char *skip_non_whitespace (const char *s) +{ +while (*s !='\0' && *s !=' ' && (unsigned char )(*s -9 ) > (13 -9 )) + s++; + +return (char *) s; +} + +#define is_name (c) ((c) == '_' || isalpha((unsigned char)(c))) +#define is_in_name (c) ((c) == '_' || isalnum((unsigned char)(c))) + +static const char *endofname (const char *name) +{ +if (!is_name (*name)) +return name; +while (*++name) { +if (!is_in_name (*name)) +break ; + } +return name; +} + +struct in_str ; +static int u_boot_cli_readline (struct in_str *i); + +struct in_str ; +static int u_boot_cli_readline (struct in_str *i); + +/* +* BusyBox globals which are needed for hush. +*/ +static uint8_t xfunc_error_retval; + +static const char defifsvar[]__aligned(1) ="IFS= \t\n" ; +#define defifs (defifsvar + 4) + +/* +* This define is used for changes that need be done directly in the upstream +* sources still. Ideally, its use should be minimized as much as possible. +*/ +#define __U_BOOT__ + +/* +* +* +-- Include of the upstream sources --+ * +* V V +*/ +#include "cli_hush_upstream.c" +/* +* A A +* +-- Include of the upstream sources --+ * +* +*/ + +int u_boot_hush_start_2021 (void ) +{ +INIT_G (); +return 0 ; +} + +static int u_boot_cli_readline (struct in_str *i) +{ +char *prompt; +char __maybe_unused *ps_prompt =NULL ; + +if (!G .promptmode) + prompt =CONFIG_SYS_PROMPT ; +#ifdef CONFIG_SYS_PROMPT_HUSH_PS2 + else + prompt =CONFIG_SYS_PROMPT_HUSH_PS2 ; +#else +/* TODO: default value? */ +#error "SYS_PROMPT_HUSH_PS2 is not defined!" +#endif + +if (CONFIG_IS_ENABLED (CMDLINE_PS_SUPPORT )) { +if (!G .promptmode) + ps_prompt =env_get ("PS1" ); +else + ps_prompt =env_get ("PS2" ); + +if (ps_prompt) + prompt = ps_prompt; + } + +return cli_readline (prompt); +}
common/cli_hush_upstream.c +493 -1
1,753 lines not on this page · raw message
Signature · 1 line
2.25.1
RFC PATCH v4 10/28 cli: Add menu for hush parser
In reply to Francis LanielFor the moment, the menu contains only entry: HUSH_OLD_PARSER which is the default.
The goal is to prepare the field to add a new hush parser which guarantees actual behavior is still correct.
--- cmd/Kconfig | 21 +++++++++++++++++++++ common/Makefile | 3 ++- 2 files changed, 23 insertions(+), 1 deletion(-)
cmd/Kconfig +21 -0
@@ -23,6 +23,27 @@ config HUSH_PARSER If disabled, you get the old, much simpler behaviour with a somewhat smaller memory footprint. +menu "Hush flavor to use" + depends on HUSH_PARSER + + config HUSH_OLD_PARSER + bool "Use hush old parser" + default y + help + This option enables the old flavor of hush based on hush Busybox from + 2005. + + It is actually the default U-Boot shell when decided to use hush as shell. + + config HUSH_2021_PARSER + bool "Use hush 2021 parser" + help + This option enables the new flavor of hush based on hush Busybox from + 2021. + + For the moment, it is highly experimental and should be used at own risks. +endmenu + config CMDLINE_EDITING bool "Enable command line editing" depends on CMDLINE
common/Makefile +2 -1
@@ -8,7 +8,8 @@ ifndef CONFIG_SPL_BUILD obj-y += init/ obj-y += main.o obj-y += exports.o -obj-$(CONFIG_HUSH_PARSER) += cli_hush.o +obj-$(CONFIG_HUSH_OLD_PARSER) += cli_hush.o +obj-$(CONFIG_HUSH_2021_PARSER) += cli_hush_2021.o obj-$(CONFIG_AUTOBOOT) += autoboot.o # # boards
Signature · 1 line
2.25.1
RFC PATCH v4 11/28 global_data.h: add GD_FLG_HUSH_OLD_PARSER flag.
In reply to Francis LanielThis flag is used to indicate we are using the hush parser.
--- common/cli.c | 2 ++ include/asm-generic/global_data.h | 4 ++++ 2 files changed, 6 insertions(+)
common/cli.c +2 -0
@@ -239,6 +239,8 @@ void cli_loop(void)void cli_init (void ) {#ifdef CONFIG_HUSH_PARSER +if (!(gd->flags &GD_FLG_HUSH_OLD_PARSER )) + gd->flags |=GD_FLG_HUSH_OLD_PARSER ;u_boot_hush_start ();#endif
include/asm-generic/global_data.h +4 -0
@@ -635,6 +635,10 @@ enum gd_flags {* @GD_FLG_SMP_READY: SMP initialization is complete */ GD_FLG_SMP_READY =0x80000 , +/** +* @GD_FLG_HUSH_OLD_PARSER: Use hush old parser. +*/ + GD_FLG_HUSH_OLD_PARSER = 0x100000, };#endif /* __ASSEMBLY__ */
Signature · 1 line
2.25.1
RFC PATCH v4 12/28 cmd: Add new parser command.
In reply to Francis LanielThis command can be used to print the current parser with 'parser print'. It can also be used to set the current parser with 'parser set'. For the moment, only one value is valid for set: old.
--- cmd/Makefile | 2 + cmd/parser.c | 113 +++++++++++++++++++++++++++++++++++++++++++++++++++ common/cli.c | 3 +- 3 files changed, 117 insertions(+), 1 deletion(-) create mode 100644 cmd/parser.c
cmd/Makefile +2 -0
@@ -205,6 +205,8 @@ obj-$(CONFIG_CMD_AVB) += avb.o # Foundries.IO SCP03 obj-$(CONFIG_CMD_SCP03) += scp03.o +obj-$(CONFIG_HUSH_PARSER) += parser.o + obj-$(CONFIG_ARM) += arm/ obj-$(CONFIG_RISCV) += riscv/ obj-$(CONFIG_SANDBOX) += sandbox/
cmd/parser.c new file +113 -0
113 lines not on this page · raw message
common/cli.c +2 -1
@@ -239,7 +239,8 @@ void cli_loop(void)void cli_init (void ) {#ifdef CONFIG_HUSH_PARSER -if (!(gd->flags &GD_FLG_HUSH_OLD_PARSER )) +if (!(gd->flags &GD_FLG_HUSH_OLD_PARSER ) + &&CONFIG_IS_ENABLED (HUSH_OLD_PARSER )) gd->flags |=GD_FLG_HUSH_OLD_PARSER ;u_boot_hush_start ();#endif
Signature · 1 line
2.25.1
RFC PATCH v4 13/28 cli: Enables using hush 2021 parser as command line parser
In reply to Francis LanielIf one defines HUSH_2021_PARSER, it is then possible to use 2021 parser with:
=> parser get
old
=> parser set 2021
2021> parser get
2021
--- cmd/parser.c | 14 ++++++++- common/cli.c | 38 ++++++++++++++++++++---- include/asm-generic/global_data.h | 4 +++ include/cli_hush.h | 49 ++++++++++++++++++++++++++++++- 4 files changed, 97 insertions(+), 8 deletions(-)
cmd/parser.c +13 -1
@@ -12,6 +12,8 @@ static const char *gd_flags_to_parser(void) {if (gd->flags &GD_FLG_HUSH_OLD_PARSER )return "old" ; +if (gd->flags &GD_FLG_HUSH_2021_PARSER ) +return "2021" ;return NULL ; }
@@ -34,12 +36,15 @@ static int parser_string_to_gd_flags(const char *parser) {if (!strcmp (parser,"old" ))return GD_FLG_HUSH_OLD_PARSER ; +if (!strcmp (parser,"2021" )) +return GD_FLG_HUSH_2021_PARSER ;return -1 ; }static void reset_parser_gd_flags (void ) { gd->flags &= ~GD_FLG_HUSH_OLD_PARSER ; + gd->flags &= ~GD_FLG_HUSH_2021_PARSER ; } static int do_parser_set(struct cmd_tbl *cmdtp, int flag, int argc,
@@ -64,6 +69,13 @@ static int do_parser_set(struct cmd_tbl *cmdtp, int flag, int argc,printf ("Want to set current parser to old, but its code was not compiled!\n" );return CMD_RET_FAILURE ; } + +if (parser_flag ==GD_FLG_HUSH_2021_PARSER + && !CONFIG_IS_ENABLED (HUSH_2021_PARSER )) { +printf ("Want to set current parser to 2021, but its code was not compiled!\n" ); +return CMD_RET_FAILURE ; + } +reset_parser_gd_flags (); gd->flags |= parser_flag;
@@ -101,7 +113,7 @@ static int do_parser(struct cmd_tbl *cmdtp, int flag, int argc,#if CONFIG_IS_ENABLED (SYS_LONGHELP )static char parser_help_text[] ="get - print current parser\n" -"set - set the current parser, possible value is: old" +"set - set the current parser, possible values are: old, 2021" ;#endif
common/cli.c +32 -6
@@ -40,12 +40,15 @@ int run_command(const char *cmd, int flag)return 1 ;return 0 ; -#else +#elif CONFIG_IS_ENABLED (HUSH_OLD_PARSER )int hush_flags =FLAG_PARSE_SEMICOLON |FLAG_EXIT_FROM_LOOP ;if (flag &CMD_FLAG_ENV ) hush_flags |=FLAG_CONT_ON_NEWLINE ;return parse_string_outer (cmd, hush_flags); +#else /* HUSH_2021_PARSER */ +/* Not yet implemented. */ +return 1 ;#endif }
@@ -105,7 +108,12 @@ int run_command_list(const char *cmd, int len, int flag) buff[len] ='\0' ; }#ifdef CONFIG_HUSH_PARSER +#if CONFIG_IS_ENABLED (HUSH_OLD_PARSER ) rcode =parse_string_outer (buff,FLAG_PARSE_SEMICOLON ); +#else /* HUSH_2021_PARSER */ +/* Not yet implemented. */ + rcode =1 ; +#endif #else /* * This function will overwrite any \n it sees with a \0, which
@@ -225,8 +233,13 @@ err:void cli_loop (void ) {bootstage_mark (BOOTSTAGE_ID_ENTER_CLI_LOOP ); -#ifdef CONFIG_HUSH_PARSER -parse_file_outer (); +#if CONFIG_IS_ENABLED (HUSH_PARSER ) +if (gd->flags &GD_FLG_HUSH_2021_PARSER ) +parse_and_run_file (); +else if (gd->flags &GD_FLG_HUSH_OLD_PARSER ) +parse_file_outer (); + +printf ("Problem\n" );/* This point is never reached */ for (;;);#elif defined(CONFIG_CMDLINE )
@@ -239,10 +252,23 @@ void cli_loop(void)void cli_init (void ) {#ifdef CONFIG_HUSH_PARSER +/* This if block is used to initialize hush parser gd flag. */ if (!(gd->flags &GD_FLG_HUSH_OLD_PARSER ) - &&CONFIG_IS_ENABLED (HUSH_OLD_PARSER )) - gd->flags |=GD_FLG_HUSH_OLD_PARSER ; -u_boot_hush_start (); + && !(gd->flags &GD_FLG_HUSH_2021_PARSER )) { +if (CONFIG_IS_ENABLED (HUSH_OLD_PARSER )) + gd->flags |=GD_FLG_HUSH_OLD_PARSER ; +else if (CONFIG_IS_ENABLED (HUSH_2021_PARSER )) + gd->flags |=GD_FLG_HUSH_2021_PARSER ; + } + +if (gd->flags &GD_FLG_HUSH_OLD_PARSER ) { +u_boot_hush_start (); + }else if (gd->flags &GD_FLG_HUSH_2021_PARSER ) { +u_boot_hush_start_2021 (); + }else { +printf ("No valid hush parser to use, cli will not initialized!\n" ); +return ; + }#endif #if defined(CONFIG_HUSH_INIT_VAR )
include/asm-generic/global_data.h +4 -0
@@ -639,6 +639,10 @@ enum gd_flags {* @GD_FLG_HUSH_OLD_PARSER: Use hush old parser. */ GD_FLG_HUSH_OLD_PARSER =0x100000 , +/** +* @GD_FLG_HUSH_2021_PARSER: Use hush 2021 parser. +*/ +GD_FLG_HUSH_2021_PARSER =0x200000 };#endif /* __ASSEMBLY__ */
include/cli_hush.h +48 -1
59 lines not on this page · raw message
Signature · 1 line
2.25.1
RFC PATCH v4 14/28 cli: hush_2021: Enable variables expansion for hush 2021
In reply to Francis LanielEnables variables expansion for hush 2021, both for local and environment variables.
So the following commands:
foo=bar
echo $foo
setenv bar foo
echo $bar
leads to "bar" and "foo" being printed on console output.
--- common/cli_hush_2021.c | 17 +++++++ common/cli_hush_upstream.c | 91 +++++++++++++++++++++++++++++++++++--- 2 files changed, 103 insertions(+), 5 deletions(-)
common/cli_hush_2021.c +17 -0
@@ -219,6 +219,23 @@ static const char* endofname(const char *name)return name; } +/** +* list_size() - returns the number of elements in char ** before NULL. +* +* Argument must contain NULL to signalize its end. +* +* @list The list to count the number of element. +* @return The number of element in list. +*/ +static size_t list_size (char **list) +{ +size_t size; + +for (size =0 ; list[size] !=NULL ; size++); + +return size; +} +struct in_str ;static int u_boot_cli_readline (struct in_str *i);
common/cli_hush_upstream.c +86 -5
171 lines not on this page · raw message
Signature · 1 line
2.25.1
RFC PATCH v4 15/28 cli: hush_2021: Add functions to be called from run_command()
In reply to Francis Lanielrun_command() is called internally by the command run and it can also be called directly from U-Boot code, e.g. to do unit tests.
This commit adds this path to go to hush 2021.
--- common/cli_hush_upstream.c | 66 ++++++++++++++++++++++++++++++++++++-- 1 file changed, 63 insertions(+), 3 deletions(-)
common/cli_hush_upstream.c +63 -3
@@ -1012,6 +1012,7 @@ struct globals {#ifdef __U_BOOT__int flag_repeat;int do_repeat; +int run_command_flags;#endif /* __U_BOOT__ */ char *ifs_whitespace;/* = G.ifs or malloced */ #ifndef __U_BOOT__
@@ -3006,7 +3007,24 @@ static int i_getch(struct in_str *i)if (i->p && *i->p !='\0' ) { ch = (unsigned char )*i->p++; goto out; +#ifndef __U_BOOT__ } +#else /* __U_BOOT__ */ +/* +* There are two ways for command to be called: +* 1. The first one is when they are typed by the user. +* 2. The second one is through run_command() (NOTE command run +* internally calls run_command()). +* +* In the second case, we do not get input from the user, so once we +* get a '\0', it means we need to stop. +* NOTE G.run_command_flags is only set on run_command call stack, so +* we use this to know if we come from user input or run_command(). + */ + }else if (i->p && *i->p =='\0' &&G .run_command_flags){ +return EOF ; + } +#endif /* __U_BOOT__ */ #endif #ifndef __U_BOOT__/* peek_buf[] is an int array, not char. Can contain EOF. */
@@ -3165,7 +3183,6 @@ static void setup_file_in_str(struct in_str *i)#endif /* !__U_BOOT__ */ } -#ifndef __U_BOOT__static void setup_string_in_str (struct in_str *i,const char *s) {memset (i,0 ,sizeof (*i));
@@ -3173,7 +3190,6 @@ static void setup_string_in_str(struct in_str *i, const char *s) i->p = s; } -#endif /* !__U_BOOT__ */ /* * o_string support
@@ -7912,7 +7928,11 @@ static int run_and_free_list(struct pipe *pi);* NUL: parse all, execute, return * ';': parse till ';' or newline, execute, repeat till EOF */ +#ifndef __U_BOOT__ static void parse_and_run_stream(struct in_str *inp, int end_trigger) +#else /* __U_BOOT__ */ +static int parse_and_run_stream(struct in_str *inp, int end_trigger) +#endif /* __U_BOOT__ */ {/* Why we need empty flag? * An obscure corner case "false; ``; echo $?":
@@ -7921,7 +7941,11 @@ static void parse_and_run_stream(struct in_str *inp, int end_trigger)* this breaks "false; echo `echo $?`" case. */ bool empty =1 ; +#ifndef __U_BOOT__while (1 ) { +#else /* __U_BOOT__ */ + do { +#endif /* __U_BOOT__ */ struct pipe *pipe_list; #if ENABLE_HUSH_INTERACTIVE
@@ -7958,21 +7982,57 @@ static void parse_and_run_stream(struct in_str *inp, int end_trigger) empty =0 ;if (G_flag_return_in_progress ==1 )break ; +#ifndef __U_BOOT__ } +#else /* __U_BOOT__ */ +/* +* This do/while is needed by run_command to avoid looping on a command +* with syntax error. +*/ + }while (!(G .run_command_flags &FLAG_EXIT_FROM_LOOP )); + +return G .last_exitcode; +#endif /* __U_BOOT__ */ }#ifndef __U_BOOT__ static void parse_and_run_string(const char *s) +#else /* __U_BOOT__ */ +static int parse_and_run_string (const char *s) +#endif /* __U_BOOT__ */ {struct in_str input;//IF_HUSH_LINENO_VAR(unsigned sv = G.parse_lineno;) setup_string_in_str (&input, s); +#ifndef __U_BOOT__parse_and_run_stream (&input,'\0' ); +#else /* __U_BOOT__ */ +return parse_and_run_stream (&input,'\0' ); +#endif /* __U_BOOT__ */ //IF_HUSH_LINENO_VAR(G.parse_lineno = sv;) } -#endif /* !__U_BOOT__ */ +#ifdef __U_BOOT__ +int parse_string_outer (const char *cmd,int flags) +{ +int ret; +int old_flags; + +/* +* Keep old values of run_command to be able to restore them once +* command was executed. +*/ + old_flags =G .run_command_flags; +G .run_command_flags = flags; + + ret =parse_and_run_string (cmd); + +G .run_command_flags = old_flags; + +return ret; +} +#endif /* __U_BOOT__ */ #ifndef __U_BOOT__static void parse_and_run_file (HFILE *fp) #else /* __U_BOOT__ */
Signature · 1 line
2.25.1
RFC PATCH v4 16/28 cli: add hush 2021 as parser for run_command*().
In reply to Francis LanielEnables using, in code, hush 2021 as parser for run_command function family. It also enables the command run to be used by CLI user of hush 2021.
--- common/cli.c | 60 ++++++++++++++++++++++++++++---------- common/cli_hush_upstream.c | 2 +- 2 files changed, 46 insertions(+), 16 deletions(-)
common/cli.c +45 -15
@@ -40,14 +40,31 @@ int run_command(const char *cmd, int flag)return 1 ;return 0 ; -#elif CONFIG_IS_ENABLED (HUSH_OLD_PARSER ) -int hush_flags =FLAG_PARSE_SEMICOLON |FLAG_EXIT_FROM_LOOP ; +#elif CONFIG_IS_ENABLED (HUSH_PARSER ) +if (gd->flags &GD_FLG_HUSH_OLD_PARSER ) { +int hush_flags =FLAG_PARSE_SEMICOLON |FLAG_EXIT_FROM_LOOP ; -if (flag &CMD_FLAG_ENV ) - hush_flags |=FLAG_CONT_ON_NEWLINE ; -return parse_string_outer (cmd, hush_flags); -#else /* HUSH_2021_PARSER */ -/* Not yet implemented. */ +if (flag &CMD_FLAG_ENV ) + hush_flags |=FLAG_CONT_ON_NEWLINE ; +return parse_string_outer (cmd, hush_flags); + }else if (gd->flags &GD_FLG_HUSH_2021_PARSER ) { +/* +* Possible values for flags are the following: +* FLAG_EXIT_FROM_LOOP: This flags ensures we exit from loop in +* parse_and_run_stream() after first iteration while normal +* behavior, * i.e. when called from cli_loop(), is to loop +* infinitely. +* FLAG_PARSE_SEMICOLON: Hush 2021 parses ';' and does not stop +* first time it sees one. So, I think we do not need this flag. +* FLAG_REPARSING: For the moment, I do not understand the goal +* of this flag. +* FLAG_CONT_ON_NEWLINE: This flag seems to be used to continue +* parsing even when reading '\n' when coming from +* run_command(). In this case, Hush 2021 reads until it finds +* '\0'. So, I think we do not need this flag. +*/ +return parse_string_outer_2021 (cmd,FLAG_EXIT_FROM_LOOP ); + }return 1 ;#endif }
@@ -64,12 +81,24 @@ int run_command_repeatable(const char *cmd, int flag)#ifndef CONFIG_HUSH_PARSER return cli_simple_run_command (cmd, flag);#else +int ret; +if (gd->flags &GD_FLG_HUSH_OLD_PARSER ) { + ret =parse_string_outer (cmd, +FLAG_PARSE_SEMICOLON + |FLAG_EXIT_FROM_LOOP ); + }else if (gd->flags &GD_FLG_HUSH_2021_PARSER ) { + ret =parse_string_outer_2021 (cmd, +FLAG_PARSE_SEMICOLON + |FLAG_EXIT_FROM_LOOP ); + }else { + ret =1 ; + } +/* * parse_string_outer() returns 1 for failure, so clean up * its result. */ -if (parse_string_outer (cmd, -FLAG_PARSE_SEMICOLON |FLAG_EXIT_FROM_LOOP )) +if (ret)return -1 ;return 0 ;
@@ -108,12 +137,13 @@ int run_command_list(const char *cmd, int len, int flag) buff[len] ='\0' ; }#ifdef CONFIG_HUSH_PARSER -#if CONFIG_IS_ENABLED (HUSH_OLD_PARSER ) - rcode =parse_string_outer (buff,FLAG_PARSE_SEMICOLON ); -#else /* HUSH_2021_PARSER */ -/* Not yet implemented. */ - rcode =1 ; -#endif +if (gd->flags &GD_FLG_HUSH_OLD_PARSER ) { + rcode =parse_string_outer (buff,FLAG_PARSE_SEMICOLON ); + }else if (gd->flags &GD_FLG_HUSH_2021_PARSER ) { + rcode =parse_string_outer_2021 (buff,FLAG_PARSE_SEMICOLON ); + }else { + rcode =1 ; + }#else /* * This function will overwrite any \n it sees with a \0, which
common/cli_hush_upstream.c +1 -1
@@ -8014,7 +8014,7 @@ static int parse_and_run_string(const char *s) }#ifdef __U_BOOT__ -int parse_string_outer (const char *cmd,int flags) +int parse_string_outer_2021 (const char *cmd,int flags) {int ret;int old_flags;
Signature · 1 line
2.25.1
RFC PATCH v4 17/28 test: hush: Fix instructions list tests for hush 2021
In reply to Francis LanielModifies the expected result for hush 2021.
Indeed, there were bugs in actual U-Boot hush which were fixed in upstream Busybox.
As hush 2021 is based on upstream Busybox, these bugs no longer exist.
--- test/hush/list.c | 69 +++++++++++++++++++++++++++++++++++++++++++++--- 1 file changed, 65 insertions(+), 4 deletions(-)
test/hush/list.c +65 -4
@@ -9,6 +9,7 @@#include <env_attr.h> #include <test/hush.h> #include <test/ut.h> +#include <asm/global_data.h> static int hush_test_semicolon (struct unit_test_state *uts) {
@@ -46,12 +47,43 @@ static int hush_test_or(struct unit_test_state *uts) }HUSH_TEST (hush_test_or,0 ); +DECLARE_GLOBAL_DATA_PTR ; +static int hush_test_and_or (struct unit_test_state *uts) {/* A && B || C truth table. */ ut_asserteq (1 ,run_command ("false && false || false" ,0 )); -ut_asserteq (1 ,run_command ("false && false || true" ,0 )); -ut_asserteq (1 ,run_command ("false && true || true" ,0 )); + +if (gd->flags &GD_FLG_HUSH_OLD_PARSER ) { +ut_asserteq (1 ,run_command ("false && false || true" ,0 )); + }else if (gd->flags &GD_FLG_HUSH_2021_PARSER ) { +/* +* This difference seems to come from a bug solved in Busybox +* hush. +* +* Indeed, the following expression can be seen like this: +* (false && false) || true +* So, (false && false) returns 1, the second false is not +* executed, and true is executed because of ||. +*/ +ut_assertok (run_command ("false && false || true" ,0 )); + } + +if (gd->flags &GD_FLG_HUSH_OLD_PARSER ) { +ut_asserteq (1 ,run_command ("false && true || true" ,0 )); + }else if (gd->flags &GD_FLG_HUSH_2021_PARSER ) { +/* +* This difference seems to come from a bug solved in Busybox +* hush. +* +* Indeed, the following expression can be seen like this: +* (false && true) || true +* So, (false && true) returns 1, the true is not executed, and +* true is executed because of ||. +*/ +ut_assertok (run_command ("false && true || true" ,0 )); + } +ut_asserteq (1 ,run_command ("false && true || false" ,0 ));ut_assertok (run_command ("true && true || false" ,0 ));ut_asserteq (1 ,run_command ("true && false || false" ,0 ));
@@ -69,8 +101,37 @@ static int hush_test_or_and(struct unit_test_state *uts)ut_asserteq (1 ,run_command ("false || false && true" ,0 ));ut_assertok (run_command ("false || true && true" ,0 ));ut_asserteq (1 ,run_command ("false || true && false" ,0 )); -ut_assertok (run_command ("true || true && false" ,0 )); -ut_assertok (run_command ("true || false && false" ,0 )); + +if (gd->flags &GD_FLG_HUSH_OLD_PARSER ) { +ut_assertok (run_command ("true || true && false" ,0 )); + }else if (gd->flags &GD_FLG_HUSH_2021_PARSER ) { +/* +* This difference seems to come from a bug solved in Busybox +* hush. +* +* Indeed, the following expression can be seen like this: +* (true || true) && false +* So, (true || true) returns 0, the second true is not +* executed, and then false is executed because of &&. +*/ +ut_asserteq (1 ,run_command ("true || true && false" ,0 )); + } + +if (gd->flags &GD_FLG_HUSH_OLD_PARSER ) { +ut_assertok (run_command ("true || false && false" ,0 )); + }else if (gd->flags &GD_FLG_HUSH_2021_PARSER ) { +/* +* This difference seems to come from a bug solved in Busybox +* hush. +* +* Indeed, the following expression can be seen like this: +* (true || false) && false +* So, (true || false) returns 0, the false is not executed, and +* then false is executed because of &&. +*/ +ut_asserteq (1 ,run_command ("true || false && false" ,0 )); + } +ut_assertok (run_command ("true || false && true" ,0 ));ut_assertok (run_command ("true || true && true" ,0 ));
Signature · 1 line
2.25.1
RFC PATCH v4 18/28 test: hush: Fix variable expansion tests for hush 2021
In reply to Francis LanielModifies the expected result for hush 2021.
Indeed, there were bugs in actual U-Boot hush which were fixed in upstream Busybox.
As hush 2021 is based on upstream Busybox, these bugs no longer exist.
--- test/hush/dollar.c | 79 ++++++++++++++++++++++++++++++++++++++++------ 1 file changed, 69 insertions(+), 10 deletions(-)
test/hush/dollar.c +69 -10
@@ -9,6 +9,9 @@#include <env_attr.h> #include <test/hush.h> #include <test/ut.h> +#include <asm/global_data.h> + +DECLARE_GLOBAL_DATA_PTR ;static int hush_test_simple_dollar (struct unit_test_state *uts) {
@@ -51,13 +54,29 @@ static int hush_test_simple_dollar(struct unit_test_state *uts)ut_asserteq (1 ,run_command ("dollar_foo='bar quux" ,0 ));/* Next line contains error message */ ut_assert_skipline (); -ut_assert_console_end (); + +if (gd->flags &GD_FLG_HUSH_2021_PARSER ) { +/* +* For some strange reasons, the console is not empty after +* running above command. +* So, we reset it to not have side effects for other tests. +*/ +console_record_reset_enable (); + }else if (gd->flags &GD_FLG_HUSH_OLD_PARSER ) { +ut_assert_console_end (); + }ut_asserteq (1 ,run_command ("dollar_foo=bar quux\"" ,0 ));/* Two next lines contain error message */ ut_assert_skipline ();ut_assert_skipline (); -ut_assert_console_end (); + +if (gd->flags &GD_FLG_HUSH_2021_PARSER ) { +/* See above comments. */ +console_record_reset_enable (); + }else if (gd->flags &GD_FLG_HUSH_OLD_PARSER ) { +ut_assert_console_end (); + }ut_assertok (run_command ("dollar_foo='bar \"quux'" ,0 ));
@@ -71,17 +90,35 @@ static int hush_test_simple_dollar(struct unit_test_state *uts)*/ console_record_reset_enable (); -ut_asserteq (1 ,run_command ("dollar_foo=\"bar 'quux\"" ,0 )); -/* Next line contains error message */ -ut_assert_skipline (); -ut_assert_console_end (); +if (gd->flags &GD_FLG_HUSH_2021_PARSER ) { +/* +* Old parser returns an error because it waits for closing +* '\'', but this behavior is wrong as the '\'' is surrounded by +* '"', so no need to wait for a closing one. +*/ +ut_assertok (run_command ("dollar_foo=\"bar 'quux\"" ,0 )); + +ut_assertok (run_command ("echo $dollar_foo" ,0 )); +ut_assert_nextline ("bar 'quux" ); +ut_assert_console_end (); + }else if (gd->flags &GD_FLG_HUSH_OLD_PARSER ) { +ut_asserteq (1 ,run_command ("dollar_foo=\"bar 'quux\"" ,0 )); +/* Next line contains error message */ +ut_assert_skipline (); +ut_assert_console_end (); + }ut_assertok (run_command ("dollar_foo='bar quux'" ,0 ));ut_assertok (run_command ("echo $dollar_foo" ,0 ));ut_assert_nextline ("bar quux" );ut_assert_console_end (); -puts ("Beware: this test set local variable dollar_foo and it cannot be unset!" ); +if (gd->flags &GD_FLG_HUSH_2021_PARSER ) { +/* Reset local variable. */ +ut_assertok (run_command ("dollar_foo=" ,0 )); + }else if (gd->flags &GD_FLG_HUSH_OLD_PARSER ) { +puts ("Beware: this test set local variable dollar_foo and it cannot be unset!" ); + }return 0 ; }
@@ -109,7 +146,12 @@ static int hush_test_env_dollar(struct unit_test_state *uts)/* Clean up setting the variable */ env_set ("env_foo" ,NULL ); -puts ("Beware: this test set local variable env_foo and it cannot be unset!" ); +if (gd->flags &GD_FLG_HUSH_2021_PARSER ) { +/* Reset local variable. */ +ut_assertok (run_command ("env_foo=" ,0 )); + }else if (gd->flags &GD_FLG_HUSH_OLD_PARSER ) { +puts ("Beware: this test set local variable env_foo and it cannot be unset!" ); + }return 0 ; }
@@ -144,7 +186,18 @@ static int hush_test_command_dollar(struct unit_test_state *uts)ut_assertok (run_command ("dollar_bar='echo bar\\n'" ,0 ));ut_assertok (run_command ("$dollar_bar" ,0 )); -ut_assert_nextline ("barn" ); + +if (gd->flags &GD_FLG_HUSH_2021_PARSER ) { +/* +* This difference seems to come from a bug solved in Busybox +* hush. +* Behavior of hush 2021 is coherent with bash and other shells. +*/ +ut_assert_nextline ("bar\\n" ); + }else if (gd->flags &GD_FLG_HUSH_OLD_PARSER ) { +ut_assert_nextline ("barn" ); + } +ut_assert_console_end ();ut_assertok (run_command ("dollar_bar='echo $bar'" ,0 ));
@@ -160,7 +213,13 @@ static int hush_test_command_dollar(struct unit_test_state *uts)ut_assert_nextline ("quux" );ut_assert_console_end (); -puts ("Beware: this test sets local variable dollar_bar and dollar_quux and they cannot be unset!" ); +if (gd->flags &GD_FLG_HUSH_2021_PARSER ) { +/* Reset local variables. */ +ut_assertok (run_command ("dollar_bar=" ,0 )); +ut_assertok (run_command ("dollar_quux=" ,0 )); + }else if (gd->flags &GD_FLG_HUSH_OLD_PARSER ) { +puts ("Beware: this test sets local variable dollar_bar and dollar_quux and they cannot be unset!" ); + }return 0 ; }
Signature · 1 line
2.25.1
RFC PATCH v4 19/28 cli: hush_2021: Enable using \< and \> as string compare operators
In reply to Francis LanielIn Busybox hush, '<' and '>' are used as redirection operators. For example, cat foo > bar will write content of file foo inside file bar. In U-Boot, we do not have file system, so we can hardly redirect command output inside a file.
But, in actual U-Boot hush, these operators ('<' and '>') are used as string compare operators.
For example, test aaa < bbb returns 0 as aaa is before bbb in the dictionary. Busybox hush also permits this, but operators need to be escaped ('\<' and '\>'), so we stick here to this behavior.
Also, if escaping is needed it permits the developer to think about its code, as in a lot of case, we want to compare integers (using '-lt' or '-gt') rather than strings.
--- common/cli_hush_upstream.c | 28 +++++++++++++++++++++++++++- 1 file changed, 27 insertions(+), 1 deletion(-)
common/cli_hush_upstream.c +27 -1
@@ -6161,7 +6161,33 @@ static struct pipe *parse_stream(char **pstring,if (parse_redirect (&ctx, redir_fd, redir_style, input)) goto parse_error_exitcode1;continue ;/* get next char */ -#endif /* !__U_BOOT__ */ +#else /* __U_BOOT__ */ +/* +* In U-Boot, '<' and '>' can be used in test command to test if +* a string is, alphabetically, before or after another. +* In 2021 Busybox hush, using test foo < bar will show the +* following error: +* hush: can't open 'bar': No such file or directory +* Indeed, in this context, '>' and '<' are used as redirection +* operators, to use them as sorting operators, one should use: +* [[ foo < bar ]] +* Or: +* test foo \< bar +* +* For the moment, we will not implement [[ ]], so we will need +* the user to escape these operators to use them as string +* comparaison operators. +* NOTE In my opinion, when you use '<' or '>' I am almost sure +* you wanted to use "-gt" or "-lt" in place, so thinking to +* escape these will make you should check your code (sh syntax +* at this level is, for me, error prone). +*/ +case '>' : +/* fallthrough */ +case '<' : +printf ("Redirection operator ('%c') is not supported!\nPlease escape it ('\\%c') to use it as string comparaison operator.\n" , (char ) ch, (char ) ch); + goto parse_error_exitcode1; +#endif /* __U_BOOT__ */ case '#' :if (ctx.word.length ==0 && !ctx.word.has_quoted_part) {/* skip "#comment" */
Signature · 1 line
2.25.1
RFC PATCH v4 20/28 cli: hush_2021: Enable if keyword
In reply to Francis LanielAdds support for "if then else" construct both for command line interface and through run_command().
--- common/cli_hush_upstream.c | 10 ++++------ 1 file changed, 4 insertions(+), 6 deletions(-)
common/cli_hush_upstream.c +4 -6
@@ -3963,7 +3963,6 @@ static void debug_print_tree(struct pipe *pi, int lvl) [PIPE_OR ] = "OR" , [PIPE_BG ] = "BG" , }; -#ifndef __U_BOOT__static const char *RES [] = { [RES_NONE ] ="NONE" , # if ENABLE_HUSH_IF
@@ -3993,7 +3992,6 @@ static void debug_print_tree(struct pipe *pi, int lvl) [RES_XXXX ] = "XXXX" , [RES_SNTX ] = "SNTX" , }; -#endif /* !__U_BOOT__ */ static const char *const CMDTYPE [] = {"{}" ,"()" ,
@@ -4011,10 +4009,8 @@ static void debug_print_tree(struct pipe *pi, int lvl) lvl*2 ,"" , pin, pi->num_cmds, -#ifdef __U_BOOT__ (IF_HAS_KEYWORDS(pi->pi_inverted ? "! " :) ""),RES [pi->res_word], -#endif /* !__U_BOOT__ */ pi->followup,PIPE [pi->followup] ); prn =0 ;
@@ -9829,6 +9825,7 @@ static NOINLINE int run_pipe(struct pipe *pi) rcode =1 ;/* exitcode if redir failed */ #ifndef __U_BOOT__if (setup_redirects (command, &squirrel) ==0 ) { +#endif /* !__U_BOOT__ */ debug_printf_exec (": run_list\n" );//FIXME: we need to pass squirrel down into run_list() //for SH_STANDALONE case, or else this construct:
@@ -9837,10 +9834,11 @@ static NOINLINE int run_pipe(struct pipe *pi)//and in SH_STANDALONE mode, "find" is not execed, //therefore CLOEXEC on saved fd does not help. rcode =run_list (command->group) &0xff ; +#ifndef __U_BOOT__ }restore_redirects (squirrel); - IF_HAS_KEYWORDS(if (pi->pi_inverted) rcode = !rcode;)#endif /* !__U_BOOT__ */ + IF_HAS_KEYWORDS(if (pi->pi_inverted) rcode = !rcode;)debug_leave ();debug_printf_exec ("run_pipe: return %d\n" , rcode);return rcode;
@@ -10359,12 +10357,12 @@ static int run_list(struct pipe *pi)break ;if (G_flag_return_in_progress ==1 )break ; +#endif /* !__U_BOOT__ */ IF_HAS_KEYWORDS(rword = pi->res_word;)debug_printf_exec (": rword=%d cond_code=%d last_rword=%d\n" , rword, cond_code, last_rword); -#endif /* !__U_BOOT__ */ sv_errexit_depth =G .errexit_depth; if (#if ENABLE_HUSH_IF
Signature · 1 line
2.25.1
RFC PATCH v4 21/28 test: hush: Fix if tests for hush 2021
In reply to Francis LanielModifies the command run for hush 2021 when using string comparison operator. Indeed, '<' and '>' must be escaped to be used as these operators.
--- test/hush/if.c | 45 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 45 insertions(+)
test/hush/if.c +45 -0
@@ -9,6 +9,7 @@#include <env_attr.h> #include <test/hush.h> #include <test/ut.h> +#include <asm/global_data.h> /* * All tests will execute the following:
@@ -35,10 +36,15 @@ static int hush_test_if_base(struct unit_test_state *uts) }HUSH_TEST (hush_test_if_base,0 ); +DECLARE_GLOBAL_DATA_PTR ; +static int hush_test_if_basic_operators (struct unit_test_state *uts) {char if_formatted[128 ]; +if (gd->flags &GD_FLG_HUSH_2021_PARSER ) +console_record_reset_enable (); +sprintf (if_formatted, if_format,"test aaa = aaa" );ut_assertok (run_command (if_formatted,0 ));
@@ -52,15 +58,54 @@ static int hush_test_if_basic_operators(struct unit_test_state *uts)ut_asserteq (1 ,run_command (if_formatted,0 ));sprintf (if_formatted, if_format,"test aaa < bbb" ); +if (gd->flags &GD_FLG_HUSH_2021_PARSER ) { +/* +* We need to escape < and > to use as them as string comparison +* operator. +* Otherwise, they are interpreted as redirection operators +* which is not supported in U-Boot. +*/ +ut_asserteq (1 ,run_command (if_formatted,0 )); +/* Next lines contains error message (which is on two lines). */ +ut_assert_skipline (); +ut_assert_skipline (); +ut_assert_console_end (); + +sprintf (if_formatted, if_format,"test aaa \\< bbb" ); + }ut_assertok (run_command (if_formatted,0 ));sprintf (if_formatted, if_format,"test bbb < aaa" ); +if (gd->flags &GD_FLG_HUSH_2021_PARSER ) { +ut_asserteq (1 ,run_command (if_formatted,0 )); +ut_assert_skipline (); +ut_assert_skipline (); +ut_assert_console_end (); + +sprintf (if_formatted, if_format,"test bbb \\< aaa" ); + }ut_asserteq (1 ,run_command (if_formatted,0 ));sprintf (if_formatted, if_format,"test bbb > aaa" ); +if (gd->flags &GD_FLG_HUSH_2021_PARSER ) { +ut_asserteq (1 ,run_command (if_formatted,0 )); +ut_assert_skipline (); +ut_assert_skipline (); +ut_assert_console_end (); + +sprintf (if_formatted, if_format,"test bbb \\> aaa" ); + }ut_assertok (run_command (if_formatted,0 ));sprintf (if_formatted, if_format,"test aaa > bbb" ); +if (gd->flags &GD_FLG_HUSH_2021_PARSER ) { +ut_asserteq (1 ,run_command (if_formatted,0 )); +ut_assert_skipline (); +ut_assert_skipline (); +ut_assert_console_end (); + +sprintf (if_formatted, if_format,"test aaa \\> bbb" ); + }ut_asserteq (1 ,run_command (if_formatted,0 ));sprintf (if_formatted, if_format,"test 123 -eq 123" );
Signature · 1 line
2.25.1
RFC PATCH v4 22/28 cli: hush_2021: Enable loops
In reply to Francis LanielEnables the use of for, while and until loops for command line as well as with run_command().
--- common/cli_hush_upstream.c | 15 ++++++++++++++- 1 file changed, 14 insertions(+), 1 deletion(-)
common/cli_hush_upstream.c +14 -1
@@ -10347,7 +10347,7 @@ static int run_list(struct pipe *pi)#ifndef __U_BOOT__ for (; pi; pi = IF_HUSH_LOOPS(rword == RES_DONE ? loop_top : ) pi->next) {#else /* __U_BOOT__ */ -for (; pi; pi = pi->next) { +for (; pi; pi = rword ==RES_DONE ? loop_top : pi->next) {#endif /* __U_BOOT__ */ int r;int sv_errexit_depth;
@@ -10449,7 +10449,20 @@ static int run_list(struct pipe *pi) }/* Insert next value from for_lcur */ /* note: *for_lcur already has quotes removed, $var expanded, etc */ +#ifndef __U_BOOT__set_local_var (xasprintf ("%s=%s" , pi->cmds[0 ].argv[0 ], *for_lcur++),/*flag:*/ 0 ); +#else /* __U_BOOT__ */ +/* We cannot use xasprintf, so we emulate it. */ +char *full_var; +char *var = pi->cmds[0 ].argv[0 ]; +char *val = *for_lcur++; + +/* + 1 to take into account =. */ + full_var =xmalloc (strlen (var) +strlen (val) +1 ); +sprintf (full_var,"%s=%s" , var, val); + +set_local_var_2021 (full_var,/*flag:*/ 0 ); +#endif /* __U_BOOT__ */ continue ; }if (rword ==RES_IN ) {
Signature · 1 line
2.25.1
RFC PATCH v4 23/28 test: hush: Fix loop tests for hush 2021
In reply to Francis LanielModifies return code got from while loop as hush 2021 always returns 0 from while loop.
--- test/hush/loop.c | 34 ++++++++++++++++++++++++++++++---- 1 file changed, 30 insertions(+), 4 deletions(-)
test/hush/loop.c +30 -4
@@ -9,6 +9,9 @@#include <env_attr.h> #include <test/hush.h> #include <test/ut.h> +#include <asm/global_data.h> + +DECLARE_GLOBAL_DATA_PTR ;static int hush_test_for (struct unit_test_state *uts) {
@@ -20,7 +23,12 @@ static int hush_test_for(struct unit_test_state *uts)ut_assert_nextline ("quux" );ut_assert_console_end (); -puts ("Beware: this test set local variable loop_i and it cannot be unset!" ); +if (gd->flags &GD_FLG_HUSH_2021_PARSER ) { +/* Reset local variable. */ +ut_assertok (run_command ("loop_i=" ,0 )); + }else if (gd->flags &GD_FLG_HUSH_OLD_PARSER ) { +puts ("Beware: this test set local variable loop_i and it cannot be unset!" ); + }return 0 ; }
@@ -30,12 +38,30 @@ static int hush_test_while(struct unit_test_state *uts) {console_record_reset_enable (); -/* Exit status is that of test, so 1 since test is false to quit the loop. */ -ut_asserteq (1 ,run_command ("while test -z \"$loop_foo\"; do echo bar; loop_foo=quux; done" ,0 )); +if (gd->flags &GD_FLG_HUSH_2021_PARSER ) { +/* +* Hush 2021 always returns 0 from while loop... +* You can see code snippet near this line to have a better +* understanding: +* debug_printf_exec(": while expr is false: breaking (exitcode:EXIT_SUCCESS)\n"); +*/ +ut_assertok (run_command ("while test -z \"$loop_foo\"; do echo bar; loop_foo=quux; done" ,0 )); + }else if (gd->flags &GD_FLG_HUSH_OLD_PARSER ) { +/* +* Exit status is that of test, so 1 since test is false to quit +* the loop. +*/ +ut_asserteq (1 ,run_command ("while test -z \"$loop_foo\"; do echo bar; loop_foo=quux; done" ,0 )); + }ut_assert_nextline ("bar" );ut_assert_console_end (); -puts ("Beware: this test set local variable loop_foo and it cannot be unset!" ); +if (gd->flags &GD_FLG_HUSH_2021_PARSER ) { +/* Reset local variable. */ +ut_assertok (run_command ("loop_foo=" ,0 )); + }else if (gd->flags &GD_FLG_HUSH_OLD_PARSER ) { +puts ("Beware: this test set local variable loop_foo and it cannot be unset!" ); + }return 0 ; }
Signature · 1 line
2.25.1
RFC PATCH v4 24/28 Modernize U-Boot shell
In reply to Francis LanielFrom: Tom Rini <[email protected]>
Quoted 11 lines · Francis Laniel
Hi.
First I hope you are fine and the same for your relatives. I would also like to apologize for the delay between v2 and v3.
During 2021 summer, Sean Anderson wrote a contribution to add a new shell, based on LIL, to U-Boot [1][2].
While one of the goals of this contribution was to address the fact actual U-Boot shell, which is based on Busybox hush, is old there was a discussion about adding a new shell versus updating the actual one [3][4].
Quoted 4 lines
So, in this series, with Harald Seiler, we updated the actual U-Boot shell to reflect what is currently in Busybox source code.
Basically, this contribution is about taking a snapshot of Busyboxshell/hush.cfile (as it exists in commit37460f5da) and adapt it to suit U-Boot needs.
In order to put this through CI and my local testing loop as well, I need:
commit 0eae144ef84e7190b3c2da5fbd745468f7d1f7e6
Author: Tom Rini <[email protected]> Date: Wed Apr 20 15:28:10 2022 -0400
HACK: Make new HUSH default
--- cmd/Kconfig | 2 +- common/cli_hush_upstream.c | 5 +++-- 2 files changed, 4 insertions(+), 3 deletions(-)
cmd/Kconfig +1 -1
@@ -28,7 +28,6 @@ menu "Hush flavor to use" config HUSH_OLD_PARSER bool "Use hush old parser" - default y help This option enables the old flavor of hush based on hush Busybox from 2005.
@@ -37,6 +36,7 @@ menu "Hush flavor to use" config HUSH_2021_PARSER bool "Use hush 2021 parser" + default y help This option enables the new flavor of hush based on hush Busybox from 2021.
common/cli_hush_upstream.c +3 -2
@@ -1454,6 +1454,7 @@ static void xxfree(void *ptr)* HUSH_DEBUG >= 2 prints line number in this file where it was detected. */ #if HUSH_DEBUG <2 +#include <linux/compiler.h> # define msg_and_die_if_script (lineno, ...) msg_and_die_if_script(__VA_ARGS__)# define syntax_error (lineno, msg) syntax_error(msg)# define syntax_error_at (lineno, msg) syntax_error_at(msg)
@@ -1471,7 +1472,7 @@ static void die_if_script(void) } } -static void msg_and_die_if_script (unsigned lineno,const char *fmt, ...) +static void __maybe_unused msg_and_die_if_script (unsigned lineno,const char *fmt, ...) {va_list p;
@@ -1545,7 +1546,7 @@ static void syntax_error_unexpected_ch(unsigned lineno UNUSED_PARAM, int ch)/* Replace each \x with x in place, return ptr past NUL. */ static char *unbackslash (char *src) { -char *dst = src =strchrnul (src,'\\' ); +char *dst = src = (char *)strchrnul (src,'\\' );while (1 ) {if (*src =='\\' ) { src++;
Signature · 1 line
2.25.1
RFC PATCH v4 25/28 cli: hush_2021: Add upstream commits up to 6th February 2022.
In reply to Francis LanielThis commit adds the following hush busybox upstream commits:21afddefd258 ("hush: fix "error: invalid preprocessing directive ##"") e53c7dbafc78 ("hush: fix set -n to act immediately, not just after run_list() ")574b9c446da1 ("hush: fix var_LINENO3.tests failure")49bcf9f40cff ("hush: speed up ${x//\*/|} too")53b2fdcdba4c ("*: add NOINLINEs where code noticeably shrinks") 7c3e96d4b3d4 ("shell: use more compact SHELL_ASH / HUSH config defines. no code changes") 62f1eed1e191 ("hush: in a comment, document what -i might be doing") aaf3d5ba74c5 ("shell: tweak --help")db5546ca1018 ("libbb: code shrink: introduce and use [_]exit_SUCCESS()") 931c55f9e2b4 ("libbb: invert the meaning of SETUP_ENV_NO_CHDIR -> SETUP_ENV_CHDIR") 12566e7f9b5e ("ash,hush: fix handling of SIGINT while waiting for interactive input") 987be932ed3c ("*: slap on a few ALIGN_PTR where appropriate")
--- common/cli_hush_upstream.c | 157 +++++++++++++++++++++++++++---------- 1 file changed, 117 insertions(+), 40 deletions(-)
common/cli_hush_upstream.c +117 -40
@@ -339,7 +339,7 @@* therefore we don't show them either. */ //usage:#define hush_trivial_usage -//usage: "[-enxl] [-c 'SCRIPT' [ARG0 ARGS] | FILE [ARGS] | -s [ARGS]]" +//usage: "[-enxl] [-c 'SCRIPT' [ARG0 ARGS] | FILE ARGS | -s ARGS]" //usage:#define hush_full_usage "\n\n" //usage: "Unix shell interpreter"
@@ -374,7 +374,7 @@# define F_DUPFD_CLOEXEC F_DUPFD#endif -#if ENABLE_FEATURE_SH_EMBEDDED_SCRIPTS && !(ENABLE_ASH ||ENABLE_SH_IS_ASH ||ENABLE_BASH_IS_ASH ) +#if ENABLE_FEATURE_SH_EMBEDDED_SCRIPTS && !ENABLE_SHELL_ASH # include "embedded_scripts.h" #else # define NUM_SCRIPTS 0
@@ -574,7 +574,7 @@ enum {#define NULL_O_STRING { NULL }#ifndef debug_printf_parse -static const char *const assignment_flag[] = { +static const char *const assignment_flag[] ALIGN_PTR = {"MAYBE_ASSIGNMENT" ,"DEFINITELY_ASSIGNMENT" , "NOT_ASSIGNMENT",
@@ -958,6 +958,7 @@ struct globals {#if ENABLE_HUSH_INTERACTIVE smallint promptmode;/* 0: PS1, 1: PS2 */ #endif +/* set by signal handler if SIGINT is received _and_ its trap is not set */ smallint flag_SIGINT;#ifndef __U_BOOT__#if ENABLE_HUSH_LOOPS
@@ -2027,6 +2028,9 @@ enum {static void record_pending_signo (int sig) {sigaddset (&G .pending_set, sig); +#if ENABLE_FEATURE_EDITING + bb_got_signal = sig;/* for read_line_input: "we got a signal" */ +#endif #if ENABLE_HUSH_FAST if (sig ==SIGCHLD ) {G .count_SIGCHLD++;
@@ -2792,30 +2796,53 @@ static void get_user_input(struct in_str *i)for (;;) {reinit_unicode_for_hush ();G .flag_SIGINT =0 ; -/* buglet: SIGINT will not make new prompt to appear _at once_, -* only after <Enter>. (^C works immediately) */ - r =read_line_input (G .line_input_state, prompt_str, + + bb_got_signal =0 ; +if (!sigisemptyset (&G .pending_set)) { +/* Whoops, already got a signal, do not call read_line_input */ + bb_got_signal = r =-1 ; + }else { +/* For shell, LI_INTERRUPTIBLE is set: +* read_line_input will abort on either +* getting EINTR in poll(), or if it sees bb_got_signal != 0 +* (IOW: if signal arrives before poll() is reached). +* Interactive testcases: +* (while kill -INT $$; do sleep 1; done) & +* #^^^ prints ^C, prints prompt, repeats +* trap 'echo I' int; (while kill -INT $$; do sleep 1; done) & +* #^^^ prints ^C, prints "I", prints prompt, repeats +* trap 'echo T' term; (while kill $$; do sleep 1; done) & +* #^^^ prints "T", prints prompt, repeats +* #(bash 5.0.17 exits after first "T", looks like a bug) +*/ + r =read_line_input (G .line_input_state, prompt_str,G .user_input_buf,CONFIG_FEATURE_EDITING_MAX_LEN -1 - ); -/* read_line_input intercepts ^C, "convert" it to SIGINT */ -if (r ==0 ) { -raise (SIGINT ); + ); +/* read_line_input intercepts ^C, "convert" it to SIGINT */ +if (r ==0 ) +raise (SIGINT ); + } +/* bash prints ^C (before running a trap, if any) +* both on keyboard ^C and on real SIGINT (non-kbd generated). +*/ +if (sigismember (&G .pending_set,SIGINT )) { +write (STDOUT_FILENO ,"^C\n" ,3 ); +G .last_exitcode =128 |SIGINT ; }check_and_run_traps (); -if (r !=0 && !G .flag_SIGINT) +if (r ==0 )/* keyboard ^C? */ +continue ;/* go back, read another input line */ +if (r >0 )/* normal input? (no ^C, no ^D, no signals) */ break ; -/* ^C or SIGINT: repeat */ -/* bash prints ^C even on real SIGINT (non-kbd generated) */ -write (STDOUT_FILENO ,"^C\n" ,3 ); -G .last_exitcode =128 |SIGINT ; - } -if (r <0 ) { -/* EOF/error detected */ -/* ^D on interactive input goes to next line before exiting: */ -write (STDOUT_FILENO ,"\n" ,1 ); - i->p =NULL ; - i->peek_buf[0 ] = r =EOF ; -return r; +if (!bb_got_signal) { +/* r < 0: ^D/EOF/error detected (but not signal) */ +/* ^D on interactive input goes to next line before exiting: */ +write (STDOUT_FILENO ,"\n" ,1 ); + i->p =NULL ; + i->peek_buf[0 ] = r =EOF ; +return r; + } +/* it was a signal: go back, read another input line */ } i->p =G .user_input_buf;return (unsigned char )*i->p++;
@@ -2995,6 +3022,12 @@ static int i_getch(struct in_str *i)if (ch !='\0' ) { i->p++; i->last_char = ch; +#if ENABLE_HUSH_LINENO_VAR +if (ch =='\n' ) { +G .parse_lineno++; +debug_printf_parse ("G.parse_lineno++ = %u\n" ,G .parse_lineno); + } +#endif return ch; }return EOF ;
@@ -3642,7 +3675,7 @@ static int glob_brace(char *pattern, o_string *o, int n)* NEXT points past the terminator of the first element, and REST * points past the final }. We will accumulate result names from * recursive runs for each brace alternative in the buffer using -* GLOB_APPEND. */ +* GLOB_APPEND. */ p = begin +1 ;while (1 ) {
@@ -3958,7 +3991,7 @@ static void free_pipe_list(struct pipe *pi) #ifndef debug_print_tree static void debug_print_tree(struct pipe *pi, int lvl) { - static const char *const PIPE[] = { + static const char *const PIPE[] ALIGN_PTR = { [PIPE_SEQ] = "SEQ", [PIPE_AND] = "AND", [PIPE_OR ] = "OR" ,
@@ -3993,7 +4026,7 @@ static void debug_print_tree(struct pipe *pi, int lvl) [RES_XXXX ] = "XXXX" , [RES_SNTX ] = "SNTX" , }; -static const char *const CMDTYPE [] = { + static const char *const CMDTYPE[] ALIGN_PTR = {"{}" ,"()" ,"[noglob]" ,
@@ -5358,7 +5391,7 @@ static int parse_dollar_squote(o_string *as_string, o_string *dest, struct in_st# undef as_string }#else -# #define parse_dollar_squote(as_string, dest, input) 0 +# define parse_dollar_squote (as_string, dest, input) 0#endif /* BASH_DOLLAR_SQUOTE */ #endif /* !__U_BOOT__ */
@@ -6730,7 +6763,7 @@ static char *encode_then_expand_vararg(const char *str, int handle_squotes, int/* Expanding ARG in ${var+ARG}, ${var-ARG} */ -static int encode_then_append_var_plusminus (o_string *output,int n, +static NOINLINE int encode_then_append_var_plusminus(o_string *output, int n,char *str,int dquoted) {struct in_str input;
@@ -6895,16 +6928,21 @@ static arith_t expand_and_evaluate_arith(const char *arg, const char **errmsg_p)/* ${var/[/]pattern[/repl]} helpers */ static char *strstr_pattern (char *val,const char *pattern,int *size) { -int sz =strcspn (pattern,"*?[\\" ); -if (pattern[sz] =='\0' ) { +int first_escaped = (pattern[0 ] =='\\' && pattern[1 ]); +/* "first_escaped" trick allows to treat e.g. "\*no_glob_chars" +* as literal too (as it is semi-common, and easy to accomodate +* by just using str + 1). +*/ +int sz =strcspn (pattern + first_escaped *2 ,"*?[\\" ); +if ((pattern + first_escaped *2 )[sz] =='\0' ) {/* Optimization for trivial patterns. * Testcase for very slow replace (performs about 22k replaces): * x=:::::::::::::::::::::: * x=$x$x;x=$x$x;x=$x$x;x=$x$x;x=$x$x;x=$x$x;x=$x$x;x=$x$x;x=$x$x;x=$x$x;echo ${#x} * echo "${x//:/|}" */ - *size = sz; -return strstr (val, pattern); + *size = sz + first_escaped; +return strstr (val, pattern + first_escaped); }while (1 ) {
@@ -8025,7 +8063,11 @@ static int parse_and_run_string(const char *s)#endif /* __U_BOOT__ */ {struct in_str input; +#ifndef __U_BOOT__ + IF_HUSH_LINENO_VAR(unsigned sv = G.parse_lineno;) +#else /* __U_BOOT__ */ //IF_HUSH_LINENO_VAR(unsigned sv = G.parse_lineno;) +#endif /* __U_BOOT__ */ setup_string_in_str (&input, s);#ifndef __U_BOOT__
@@ -8033,7 +8075,11 @@ static int parse_and_run_string(const char *s)#else /* __U_BOOT__ */ return parse_and_run_stream (&input,'\0' );#endif /* __U_BOOT__ */ -//IF_HUSH_LINENO_VAR(G.parse_lineno = sv;) +#ifndef __U_BOOT__ + IF_HUSH_LINENO_VAR(unsigned sv = G.parse_lineno;) +#else /* __U_BOOT__ */ +//IF_HUSH_LINENO_VAR(unsigned sv = G.parse_lineno;) +#endif /* __U_BOOT__ */ }#ifdef __U_BOOT__
@@ -8141,7 +8187,7 @@ static int generate_stream_from_string(const char *s, pid_t *pid_p)if (is_prefixed_with (s,"trap" ) &&skip_whitespace (s +4 )[0 ] =='\0' ) { -static const char *const argv[] = {NULL ,NULL }; + static const char *const argv[] ALIGN_PTR = { NULL, NULL };builtin_trap ((char **)argv);fflush_all ();/* important */ _exit (0 );
@@ -9106,7 +9152,7 @@ static NOINLINE void pseudo_exec_argv(nommu_save_t *nommu_save,* expand_assignments(): think about ... | var=`sleep 1` | ... */ free_strings (new_env); -_exit (EXIT_SUCCESS ); +_exit_SUCCESS (); } sv_shadowed =G .shadowed_vars_pp;
@@ -9287,7 +9333,7 @@ static void pseudo_exec(nommu_save_t *nommu_save,/* Case when we are here: ... | >file */ debug_printf_exec ("pseudo_exec'ed null command\n" ); -_exit (EXIT_SUCCESS ); +_exit_SUCCESS (); }#if ENABLE_HUSH_JOB
@@ -10420,7 +10466,7 @@ static int run_list(struct pipe *pi) static const char encoded_dollar_at[] ALIGN1 = {SPECIAL_VAR_SYMBOL ,'@' |0x80 ,SPECIAL_VAR_SYMBOL ,'\0' };/* encoded representation of "$@" */ -static const char *const encoded_dollar_at_argv[] = { + static const char *const encoded_dollar_at_argv[] ALIGN_PTR = { encoded_dollar_at,NULL };/* argv list with one element: "$@" */ char **vals;
@@ -10547,7 +10593,12 @@ static int run_list(struct pipe *pi)G .flag_break_continue =0 ;#endif #endif /* !__U_BOOT__ */ +#ifndef __U_BOOT__ + rcode = r =G .o_opt[OPT_O_NOEXEC ] ?0 :run_pipe (pi); +/* NB: rcode is a smalluint, r is int */ +#else /* __U_BOOT__ */ rcode = r =run_pipe (pi);/* NB: rcode is a smalluint, r is int */ +#endif /* __U_BOOT__ */ if (r !=-1 ) {/* We ran a builtin, function, or group. * rcode is already known
@@ -10804,7 +10855,10 @@ static int set_mode(int state, char mode, const char *o_opt)int idx;switch (mode) {case 'n' : -G .o_opt[OPT_O_NOEXEC ] = state; +/* set -n has no effect in interactive shell */ +/* Try: while set -n; do echo $-; done */ +if (!G_interactive_fd) +G .o_opt[OPT_O_NOEXEC ] = state;break ;case 'x' : IF_HUSH_MODE_X(G_x_mode = state;)
@@ -10877,7 +10931,7 @@ int hush_main(int argc, char **argv) cached_getpid =getpid ();/* for tcsetpgrp() during init */ G .root_pid = cached_getpid;/* for $PID (NOMMU can override via -$HEXPID:HEXPPID:...) */ -G .root_ppid =getppid ();/* for $PPID (NOMMU can override) */ +G .root_ppid =getppid ();/* for $PPID (NOMMU can override) */ /* Deal with HUSH_VERSION */ debug_printf_env ("unsetenv '%s'\n" ,"HUSH_VERSION" );
@@ -11008,6 +11062,29 @@ int hush_main(int argc, char **argv)/* Well, we cannot just declare interactiveness, * we have to have some stuff (ctty, etc) */ /* G_interactive_fd++; */ +//There are a few cases where bash -i -c 'SCRIPT' +//has visible effect (differs from bash -c 'SCRIPT'): +//it ignores TERM: +// bash -i -c 'kill $$; echo ALIVE' +// ALIVE +//it resets SIG_IGNed HUP to SIG_DFL: +// trap '' hup; bash -i -c 'kill -hup $$; echo ALIVE' +// Hangup [the message is not printed by bash, it's the shell which started it] +//is talkative about jobs and exiting: +// bash -i -c 'sleep 1 & exit' +// [1] 16170 +// exit +//includes $ENV file (only if run as "sh"): +// echo last >/tmp/ENV; ENV=/tmp/ENV sh -i -c 'echo HERE' +// last: cannot open /var/log/wtmp: No such file or directory +// HERE +//(under "bash", it's the opposite: it runs $BASH_ENV file only *without* -i). +// +//ash -i -c 'sleep 3; sleep 3', on ^C, drops into a prompt instead of exiting +//(this may be a bug, bash does not do this). +//(ash -i -c 'sleep 3' won't show this, the last command gets auto-"exec"ed) +// +//None of the above feel like useful features people would rely on. break ;case 's' :G .opt_s =1 ;
@@ -12387,7 +12464,7 @@ static int FAST_FUNC builtin_fg_bg(char **argv)/* TODO: bash prints a string representation * of job being foregrounded (like "sleep 1 | cat") */ if (argv[0 ][0 ] =='f' && G_saved_tty_pgrp) { -/* Put the job into the foreground. */ +/* Put the job into the foreground. */ tcsetpgrp (G_interactive_fd, pi->pgrp); }
Signature · 1 line
2.25.1
Re: [RFC PATCH v4 25/28] cli: hush_2021: Add upstream commits up to 6th February 2022.
Quoted 15 lines · Francis Laniel
This commit adds the following hush busybox upstream commits:
21afddefd258("hush: fix "error: invalid preprocessing directive ##"")e53c7dbafc78("hush: fix set -n to act immediately, not just afterrun_list()")574b9c446da1("hush: fix var_LINENO3.tests failure")49bcf9f40cff("hush: speed up ${x//\*/|} too")53b2fdcdba4c("*: add NOINLINEs where code noticeably shrinks")7c3e96d4b3d4("shell: use more compactSHELL_ASH/ HUSH config defines. no code changes")62f1eed1e191("hush: in a comment, document what -i might be doing")aaf3d5ba74c5("shell: tweak --help")db5546ca1018("libbb: code shrink: introduce and use [_]exit_SUCCESS()")931c55f9e2b4("libbb: invert the meaning ofSETUP_ENV_NO_CHDIR->SETUP_ENV_CHDIR")12566e7f9b5e("ash,hush: fix handling of SIGINT while waiting for interactive input")987be932ed3c("*: slap on a fewALIGN_PTRwhere appropriate")
Quoted 1 line
Signed-off-by Francis Laniel <[email protected]>
Oh good, this was added to the series. How much effort did it take you to do this? Do you think it would be sustainable to keep doing something like this once every U-Boot full release cycle, like say when -next opens up or just after release or similar?
Signature · 1 line
Tom
Re: [RFC PATCH v4 25/28] cli: hush_2021: Add upstream commits up to 6th February 2022.
Hi.
Quoted 17 lines · Le lundi 20 juin 2022, 21:11:00 CEST Tom Rini a écrit :
Quoted 16 lines · Francis Laniel
This commit adds the following hush busybox upstream commits:
21afddefd258("hush: fix "error: invalid preprocessing directive ##"")e53c7dbafc78("hush: fix set -n to act immediately, not just afterrun_list()")574b9c446da1("hush: fix var_LINENO3.tests failure")49bcf9f40cff("hush: speed up ${x//\*/|} too")53b2fdcdba4c("*: add NOINLINEs where code noticeably shrinks")7c3e96d4b3d4("shell: use more compactSHELL_ASH/ HUSH config defines. no code changes")62f1eed1e191("hush: in a comment, document what -i might be doing")aaf3d5ba74c5("shell: tweak --help")db5546ca1018("libbb: code shrink: introduce and use [_]exit_SUCCESS()")931c55f9e2b4("libbb: invert the meaning ofSETUP_ENV_NO_CHDIR->SETUP_ENV_CHDIR")12566e7f9b5e("ash,hush: fix handling of SIGINT while waiting for interactive input")987be932ed3c("*: slap on a fewALIGN_PTRwhere appropriate")
Quoted 6 lines
Quoted 1 line
Signed-off-by Francis Laniel <[email protected]>Oh good, this was added to the series. How much effort did it take you to do this? Do you think it would be sustainable to keep doing something like this once every U-Boot full release cycle, like say when -next opens up or just after release or similar?
Sorry for my late reply.
I was not so complicated to add these patches as they did not really touch part we have in common.
I think it took me sometimes because I wanted to understand everything to avoid breaking things.
I would rather advice doing this more often, something like once a month as the less patches we will need to merge the easier it is.
RFC PATCH v4 26/28 for test purpose only: Comment out dollar tests which prints error messages.
In reply to Francis LanielError messages like "unknown command" will make the CI fails. So, for the moment, we comment these tests.
--- test/hush/dollar.c | 24 ++++++++++++------------ 1 file changed, 12 insertions(+), 12 deletions(-)
test/hush/dollar.c +12 -12
@@ -46,14 +46,14 @@ static int hush_test_simple_dollar(struct unit_test_state *uts)ut_assert_nextline ("$bar" );ut_assert_console_end (); -ut_asserteq (1 ,run_command ("dollar_foo=bar quux" ,0 )); -/* Next line contains error message */ -ut_assert_skipline (); -ut_assert_console_end (); +// ut_asserteq(1, run_command("dollar_foo=bar quux", 0)); +// /* Next line contains error message */ +// ut_assert_skipline(); +// ut_assert_console_end(); -ut_asserteq (1 ,run_command ("dollar_foo='bar quux" ,0 )); +// ut_asserteq(1, run_command("dollar_foo='bar quux", 0)); /* Next line contains error message */ -ut_assert_skipline (); +// ut_assert_skipline(); if (gd->flags &GD_FLG_HUSH_2021_PARSER ) {/*
@@ -66,10 +66,10 @@ static int hush_test_simple_dollar(struct unit_test_state *uts)ut_assert_console_end (); } -ut_asserteq (1 ,run_command ("dollar_foo=bar quux\"" ,0 )); +// ut_asserteq(1, run_command("dollar_foo=bar quux\"", 0)); /* Two next lines contain error message */ -ut_assert_skipline (); -ut_assert_skipline (); +// ut_assert_skipline(); +// ut_assert_skipline(); if (gd->flags &GD_FLG_HUSH_2021_PARSER ) {/* See above comments. */
@@ -102,10 +102,10 @@ static int hush_test_simple_dollar(struct unit_test_state *uts)ut_assert_nextline ("bar 'quux" );ut_assert_console_end (); }else if (gd->flags &GD_FLG_HUSH_OLD_PARSER ) { -ut_asserteq (1 ,run_command ("dollar_foo=\"bar 'quux\"" ,0 )); +// ut_asserteq(1, run_command("dollar_foo=\"bar 'quux\"", 0)); /* Next line contains error message */ -ut_assert_skipline (); -ut_assert_console_end (); +// ut_assert_skipline(); +// ut_assert_console_end(); }ut_assertok (run_command ("dollar_foo='bar quux'" ,0 ));
Signature · 1 line
2.25.1
Re: [RFC PATCH v4 26/28] for test purpose only: Comment out dollar tests which prints error messages.
Quoted 4 lines · Francis Laniel
Error messages like "unknown command" will make the CI fails. So, for the moment, we comment these tests.
Signed-off-by Francis Laniel <[email protected]>
Why don't we have the test expect "unknown command" as the output here, when on the newer shell? Or if both shells print that now, in both cases? We want tests for when things are expected to fail.
Signature · 1 line
Tom
Re: [RFC PATCH v4 26/28] for test purpose only: Comment out dollar tests which prints error messages.
Quoted 9 lines · Le vendredi 17 juin 2022, 16:02:35 CEST Tom Rini a écrit :
Quoted 4 lines · Francis Laniel
Error messages like "unknown command" will make the CI fails. So, for the moment, we comment these tests.
Signed-off-by Francis Laniel <[email protected]>Why don't we have the test expect "unknown command" as the output here, when on the newer shell? Or if both shells print that now, in both cases? We want tests for when things are expected to fail.
If you run ut hush from U-Boot prompt, this test does not fail (I added the failure on purpose to test that it should fail).
But when run from the CI, it is run within test.py which checks from "unknown command" to not be present in the output [1].
I am not really familiar with the python testing framework but I think I can find another solution using disable_check() when running this test with 2021 shell.
---
[1] https://elixir.bootlin.com/u-boot/v2022.07/source/test/py/
u_boot_console_base.py#L35
RFC PATCH v4 27/28 for test purpose only: Comment out failed function which fails only in CI.
In reply to Francis Laniel--- test/cmd/setexpr.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
test/cmd/setexpr.c +1 -1
@@ -308,7 +308,7 @@ static int setexpr_test_str(struct unit_test_state *uts) start_mem =ut_check_free ();ut_assertok (run_command ("setexpr.s fred *0" ,0 ));ut_asserteq_str ("hello" ,env_get ("fred" )); -ut_assertok (ut_check_delta (start_mem)); +// ut_assertok(ut_check_delta(start_mem)); unmap_sysmem (buf);
Signature · 1 line
2.25.1
Re: [RFC PATCH v4 27/28] for test purpose only: Comment out failed function which fails only in CI.
Quoted 10 lines · Francis Laniel
Signed-off-by Francis Laniel <[email protected]>--- test/cmd/setexpr.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)test/cmd/setexpr.c +0
-0
test/cmd/setexpr.c static int setexpr_test_str(struct unit_test_state *uts) · line 313
Quoted 7 lines
test/cmd/setexpr.c +1
-1@@ -308,7 +308,7 @@ static int setexpr_test_str(struct unit_test_state *uts) start_mem =ut_check_free ();ut_assertok (run_command ("setexpr.s fred *0" ,0 ));ut_asserteq_str ("hello" ,env_get ("fred" )); -ut_assertok (ut_check_delta (start_mem)); +// ut_assertok(ut_check_delta(start_mem)); unmap_sysmem (buf);
Did you see doc/develop/tests_sandbox.rst and how to get things under gdb, or did you have problems with that? Thanks!
Signature · 1 line
Tom
PATCH 1/1 for debug purpose only: add print to debug odd behavior.
Hi.
I am really sorry for the delay in answer.
Sadly, I am not able to send a v5 for the moment.
Indeed, I am still struggling with the same bug since a lot of time... It happens in the Azure pipeline but also locally with test.py.
I am sure the bug is related to memory management as the setexpr test fails because more memory is released than what expected (as shown by the debug message printed in this patch).
Nonetheless, I am not able to say what is the root cause of it... I think this is a side effect "somewhere", as commenting out the "loop_i=" in the unit test for loop makes the tests pass.
Sometime ago, it happened with sandbox and sandbox_clang and with a recent rebase it stopped happening on these boards but begins to occur on sandbox_flattree.
I checked the behavior of the code related to loop and particularly what is done by set_local_var_2021() with GDB and I did not find any uncorrect behavior.
I am sorry but I do not have a lot of other choices than asking for a bit of help as I really want to tackle this but I am lacking ideas... So, did such a bug already occur in U-Boot development process? If so, what was the root cause and what was done to help finding it?
Best regards and thank you in advance as any help will be really appreciated.
--- cmd/nvedit.c | 7 ++++++- cmd/setexpr.c | 4 ++++ common/cli_hush_upstream.c | 28 ++++++++++++++++++++++++++++ common/command.c | 4 ++++ include/cli_hush.h | 4 ++++ test/cmd/setexpr.c | 8 ++++++++ test/hush/loop.c | 3 +++ 7 files changed, 57 insertions(+), 1 deletion(-)
cmd/nvedit.c +6 -1
@@ -40,6 +40,8 @@#include <linux/stddef.h> #include <asm/byteorder.h> #include <asm/io.h> +#include <cli_hush.h> +#include <test/ut.h> DECLARE_GLOBAL_DATA_PTR ;
@@ -275,8 +277,9 @@ static int _do_env_set(int flag, int argc, char *const argv[], int env_flag)*/ for (i =2 , len =0 ; i < argc; ++i) len +=strlen (argv[i]) +1 ; - +debug_foo ("\t\t\t%s: before malloc: ut_check_free(): %lu\n" , __func__,ut_check_free ()); value =malloc (len); +// debug_foo("\t\t\t%s: after malloc: ut_check_free(): %lu\n", __func__, ut_check_free()); if (value ==NULL ) {printf ("## Can't malloc %d bytes\n" , len);return 1 ;
@@ -294,7 +297,9 @@ static int _do_env_set(int flag, int argc, char *const argv[], int env_flag) e.key = name; e.data = value;hsearch_r (e,ENV_ENTER , &ep, &env_htab, env_flag); +// debug_foo("\t\t\t%s: before free: ut_check_free(): %lu\n", __func__, ut_check_free()); free (value); +debug_foo ("\t\t\t%s: after free: ut_check_free(): %lu\n" , __func__,ut_check_free ());if (!ep) {printf ("## Error inserting \"%s\" variable, errno=%d\n" , name, errno);
cmd/setexpr.c +4 -0
@@ -18,6 +18,8 @@#include <mapmem.h> #include <linux/sizes.h> #include "printf.h" +#include <cli_hush.h> +#include <test/ut.h> #define MAX_STR_LEN 128
@@ -412,7 +414,9 @@ static int do_setexpr(struct cmd_tbl *cmdtp, int flag, int argc,/* plain assignment: "setexpr name value" */ if (argc ==3 ) {if (w ==CMD_DATA_SIZE_STR ) { +debug_foo ("\t\t%s: before env_set: ut_check_free(): %lu\n" , __func__,ut_check_free ()); ret =env_set (argv[1 ], aval.sval); +debug_foo ("\t\t%s: after env_set: ut_check_free(): %lu\n" , __func__,ut_check_free ());free (aval.sval); }else { ret =env_set_hex (argv[1 ], aval.ival);
common/cli_hush_upstream.c +28 -0
@@ -381,6 +381,10 @@#endif #endif /* !__U_BOOT__ */ +#ifdef __U_BOOT__ +#include <test/ut.h> +#endif +/* So far, all bash compat is controlled by one config option */ /* Separate defines document which part of code implements what */ #define BASH_PATTERN_SUBST ENABLE_HUSH_BASH_COMPAT
@@ -9760,6 +9764,28 @@ static int redirect_and_varexp_helper( }#endif /* !__U_BOOT__ */ +bool foo = false; + +void set_debug_foo (void ) +{ + foo = true; +} + +void reset_debug_foo (void ) +{ + foo = false; +} + +void debug_foo (char *fmt, ...) +{ +if (foo) { +va_list args; +va_start (args, fmt); +vprintf (fmt, args); +va_end (args); + } +} + static NOINLINE int run_pipe(struct pipe *pi) {static const char *const null_ptr =NULL ;
@@ -10269,9 +10295,11 @@ static NOINLINE int run_pipe(struct pipe *pi) next_infd = pipefds.rd;#else /* __U_BOOT__ */ /* Process the command */ +debug_foo ("%s: before cmd_process: ut_check_free(): %lu\n" , __func__,ut_check_free ()); rcode =cmd_process (G .do_repeat ?CMD_FLAG_REPEAT :0 , command->argc, command->argv, &(G .flag_repeat),NULL ); +debug_foo ("%s: after cmd_process: ut_check_free(): %lu\n" , __func__,ut_check_free ());if (argv_expanded) {/*
common/command.c +4 -0
@@ -16,6 +16,8 @@#include <log.h> #include <asm/global_data.h> #include <linux/ctype.h> +#include <cli_hush.h> +#include <test/ut.h> DECLARE_GLOBAL_DATA_PTR ;
@@ -577,7 +579,9 @@ static int cmd_call(struct cmd_tbl *cmdtp, int flag, int argc, {int result; +debug_foo ("\t%s: before cmd function: ut_check_free(): %lu\n" , __func__,ut_check_free ()); result = cmdtp->cmd_rep (cmdtp, flag, argc, argv, repeatable); +debug_foo ("\t%s: after cmd function: ut_check_free(): %lu\n" , __func__,ut_check_free ());if (result)debug ("Command failed, result=%d\n" , result);return result;
include/cli_hush.h +4 -0
@@ -12,6 +12,10 @@#define FLAG_REPARSING (1 << 2)/* >=2nd pass */ #define FLAG_CONT_ON_NEWLINE (1 << 3)/* continue when we see \n */ +void set_debug_foo (void ); +void reset_debug_foo (void ); +void debug_foo (char *fmt, ...); +#if CONFIG_IS_ENABLED (HUSH_OLD_PARSER )extern int u_boot_hush_start (void );extern int parse_string_outer (const char *,int );
test/cmd/setexpr.c +8 -0
@@ -9,6 +9,7 @@#include <common.h> #include <console.h> #include <mapmem.h> +#include <cli_hush.h> #include <dm/test.h> #include <test/suites.h> #include <test/ut.h>
@@ -304,12 +305,19 @@ static int setexpr_test_str(struct unit_test_state *uts)ut_asserteq (1 ,run_command ("setexpr.s fred 0" ,0 ));ut_assertok (ut_check_delta (start_mem)); +ut_unsilence_console (uts); +ut_assertok (env_set ("fred" ,"12345" )); start_mem =ut_check_free (); + +set_debug_foo ();ut_assertok (run_command ("setexpr.s fred *0" ,0 )); +reset_debug_foo ();ut_asserteq_str ("hello" ,env_get ("fred" ));ut_assertok (ut_check_delta (start_mem)); +ut_silence_console (uts); +unmap_sysmem (buf);return 0 ;
test/hush/loop.c +3 -0
@@ -26,6 +26,9 @@ static int hush_test_for(struct unit_test_state *uts)if (gd->flags &GD_FLG_HUSH_2021_PARSER ) {/* Reset local variable. */ +/* +* BUG Comment this below line out make the tests pass. +*/ ut_assertok (run_command ("loop_i=" ,0 )); }else if (gd->flags &GD_FLG_HUSH_OLD_PARSER ) {puts ("Beware: this test set local variable loop_i and it cannot be unset!" );
--
2.25.1
RFC PATCH v4 28/28 board: keymile: common: Use environment to store IVM_* variables.
In reply to Francis LanielThese boards used set_local_var() to store some variables as local shell. They then used get_local_var() to retrieve the variables values.
Instead of using local shell variables, they should use environment ones (like a majority of board).
So, this patch converts using local variables to environment ones.
--- board/keymile/common/common.c | 8 ++++---- board/keymile/common/ivm.c | 9 +-------- 2 files changed, 5 insertions(+), 12 deletions(-)
board/keymile/common/common.c +4 -4
@@ -219,7 +219,7 @@ static int do_setboardid(struct cmd_tbl *cmdtp, int flag, int argc,unsigned char buf[32 ];char *p; - p =get_local_var ("IVM_BoardId" ); + p =env_get ("IVM_BoardId" );if (!p) {printf ("can't get the IVM_Boardid\n" );return 1 ;
@@ -228,7 +228,7 @@ static int do_setboardid(struct cmd_tbl *cmdtp, int flag, int argc,env_set ("boardid" , (char *)buf);printf ("set boardid=%s\n" , buf); - p =get_local_var ("IVM_HWKey" ); + p =env_get ("IVM_HWKey" );if (!p) {printf ("can't get the IVM_HWKey\n" );return 1 ;
@@ -272,14 +272,14 @@ static int do_checkboardidhwk(struct cmd_tbl *cmdtp, int flag, int argc,* first read out the real inventory values, these values are * already stored in the local hush variables */ - p =get_local_var ("IVM_BoardId" ); + p =env_get ("IVM_BoardId" );if (!p) {printf ("can't get the IVM_Boardid\n" );return 1 ; } rc =strict_strtoul (p,16 , &ivmbid); - p =get_local_var ("IVM_HWKey" ); + p =env_get ("IVM_HWKey" );if (!p) {printf ("can't get the IVM_HWKey\n" );return 1 ;
board/keymile/common/ivm.c +1 -8
@@ -44,14 +44,7 @@ static int ivm_calc_crc(unsigned char *buf, int len)static int ivm_set_value (char *name,char *value) { -char tempbuf[256 ]; - -if (value) { -sprintf (tempbuf,"%s=%s" , name, value); -return set_local_var (tempbuf,0 ); - } -unset_local_var (name); -return 0 ; +return env_set (name, value); } static int ivm_get_value(unsigned char *buf, int len, char *name, int off,
Signature · 1 line
2.25.1
Re: [RFC PATCH v4 28/28] board: keymile: common: Use environment to store IVM_* variables.
Quoted 62 lines · Francis Laniel
These boards used
set_local_var()to store some variables as local shell. They then usedget_local_var()to retrieve the variables values.Instead of using local shell variables, they should use environment ones (like a majority of board).
So, this patch converts using local variables to environment ones.Signed-off-by Francis Laniel <[email protected]>--- board/keymile/common/common.c | 8 ++++---- board/keymile/common/ivm.c | 9 +-------- 2 files changed, 5 insertions(+), 12 deletions(-)board/keymile/common/common.c +4
-4@@ -219,7 +219,7 @@ static int do_setboardid(struct cmd_tbl *cmdtp, int flag, int argc,unsigned char buf[32 ];char *p; - p =get_local_var ("IVM_BoardId" ); + p =env_get ("IVM_BoardId" );if (!p) {printf ("can't get the IVM_Boardid\n" );return 1 ;@@ -228,7 +228,7 @@ static int do_setboardid(struct cmd_tbl *cmdtp, int flag, int argc,env_set ("boardid" , (char *)buf);printf ("set boardid=%s\n" , buf); - p =get_local_var ("IVM_HWKey" ); + p =env_get ("IVM_HWKey" );if (!p) {printf ("can't get the IVM_HWKey\n" );return 1 ;@@ -272,14 +272,14 @@ static int do_checkboardidhwk(struct cmd_tbl *cmdtp, int flag, int argc,* first read out the real inventory values, these values are * already stored in the local hush variables */ - p =get_local_var ("IVM_BoardId" ); + p =env_get ("IVM_BoardId" );if (!p) {printf ("can't get the IVM_Boardid\n" );return 1 ; } rc =strict_strtoul (p,16 , &ivmbid); - p =get_local_var ("IVM_HWKey" ); + p =env_get ("IVM_HWKey" );if (!p) {printf ("can't get the IVM_HWKey\n" );return 1 ;board/keymile/common/ivm.c +0
-2@@ -44,14 +44,7 @@ static int ivm_calc_crc(unsigned char *buf, int len)static int ivm_set_value (char *name,char *value) { -char tempbuf[256 ]; -
board/keymile/common/ivm.c static int ivm_calc_crc(unsigned char *buf, int len) · line 50
Quoted 10 lines
board/keymile/common/ivm.c +1
-6-if (value) { -sprintf (tempbuf,"%s=%s" , name, value); -return set_local_var (tempbuf,0 ); - } -unset_local_var (name); -return 0 ; +return env_set (name, value); } static int ivm_get_value(unsigned char *buf, int len, char *name, int off,
Adding in the maintainer, but seems reasonable to me.
Signature · 1 line
Tom
RE: [RFC PATCH v4 28/28] board: keymile: common: Use environment to store IVM_* variables.
Quoted 72 lines · Francis Laniel
These boards used
set_local_var()to store some variables as local shell. They then usedget_local_var()to retrieve the variables values.Instead of using local shell variables, they should use environment ones (like a majority of board).
So, this patch converts using local variables to environment ones.Signed-off-by Francis Laniel <[email protected]>--- board/keymile/common/common.c | 8 ++++---- board/keymile/common/ivm.c | 9 +-------- 2 files changed, 5 insertions(+), 12 deletions(-)(quoted diff) +0
-0
b/board/keymile/common/common.cindex3999f48719..72939af36e100644board/keymile/common/common.c +4
-4@@ -219,7 +219,7 @@ static int do_setboardid(struct cmd_tbl *cmdtp, int flag, int argc,unsigned char buf[32 ];char *p; - p =get_local_var ("IVM_BoardId" ); + p =env_get ("IVM_BoardId" );if (!p) {printf ("can't get the IVM_Boardid\n" );return 1 ;@@ -228,7 +228,7 @@ static int do_setboardid(struct cmd_tbl *cmdtp, int flag, int argc,env_set ("boardid" , (char *)buf);printf ("set boardid=%s\n" , buf); - p =get_local_var ("IVM_HWKey" ); + p =env_get ("IVM_HWKey" );if (!p) {printf ("can't get the IVM_HWKey\n" );return 1 ;@@ -272,14 +272,14 @@ static int do_checkboardidhwk(struct cmd_tbl *cmdtp, int flag, int argc,* first read out the real inventory values, these values are * already stored in the local hush variables */ - p =get_local_var ("IVM_BoardId" ); + p =env_get ("IVM_BoardId" );if (!p) {printf ("can't get the IVM_Boardid\n" );return 1 ; } rc =strict_strtoul (p,16 , &ivmbid); - p =get_local_var ("IVM_HWKey" ); + p =env_get ("IVM_HWKey" );if (!p) {printf ("can't get the IVM_HWKey\n" );return 1 ;board/keymile/common/ivm.c +1
-8@@ -44,14 +44,7 @@ static int ivm_calc_crc(unsigned char *buf, int len) static int ivm_set_value(char *name, char *value) { -char tempbuf[256 ]; - -if (value) { -sprintf (tempbuf,"%s=%s" , name, value); -return set_local_var (tempbuf,0 ); - } -unset_local_var (name); -return 0 ; +return env_set (name, value); } static int ivm_get_value(unsigned char *buf, int len, char *name, int
Quoted 1 line
off,
Adding in the maintainer, but seems reasonable to me.
--
Tom
--
Aleksandar
RE: [RFC PATCH v4 28/28] board: keymile: common: Use environment to store IVM_* variables.
Hi Francis,
Quoted 9 lines · Francis Laniel
Quoted 8 lines
These boards used
set_local_var()to store some variables as local shell. They then usedget_local_var()to retrieve the variables values.Instead of using local shell variables, they should use environment ones (like a majority of board).
So, this patch converts using local variables to environment ones.
why do we need to change that? It is intended that we use this hush variable infrastructure from u-boot (common/hush.c) for our IVM data and not the standard env. We read the IVM at boot time and store these values in RAM. It is not intended to store them permanently in the flash or wherever the environment is saved. Especially in our case we have some boards where the environment is in a i2c EEPROM and we don't want to write down to the EEPROM each time when the board is starting.
Quoted 55 lines
board/keymile/common/common.c static int do_setboardid(struct cmd_tbl *cmdtp, int
Quoted 11 lines
Signed-off-by Francis Laniel <[email protected]>--- board/keymile/common/common.c | 8 ++++---- board/keymile/common/ivm.c | 9 +-------- 2 files changed, 5 insertions(+), 12 deletions(-)(quoted diff) +0
-0
b/board/keymile/common/common.cindex3999f48719..72939af36e100644board/keymile/common/common.c +0
-0@@ -219,7 +219,7 @@ static int do_setboardid(struct cmd_tbl *cmdtp, intflag, int argc,
board/keymile/common/common.c static int do_setboardid(struct cmd_tbl *cmdtp, int
Quoted 9 lines
board/keymile/common/common.c +1
-1unsigned char buf[32 ];char *p; - p =get_local_var ("IVM_BoardId" ); + p =env_get ("IVM_BoardId" );if (!p) {printf ("can't get the IVM_Boardid\n" );return 1 ;@@ -228,7 +228,7 @@ static int do_setboardid(struct cmd_tbl *cmdtp, intflag, int argc,
board/keymile/common/common.c static int do_checkboardidhwk(struct cmd_tbl
Quoted 9 lines
board/keymile/common/common.c +1
-1env_set ("boardid" , (char *)buf);printf ("set boardid=%s\n" , buf); - p =get_local_var ("IVM_HWKey" ); + p =env_get ("IVM_HWKey" );if (!p) {printf ("can't get the IVM_HWKey\n" );return 1 ;@@ -272,14 +272,14 @@ static int do_checkboardidhwk(struct cmd_tbl*cmdtp, int flag, int argc,
Quoted 23 lines
board/keymile/common/common.c +2
-2* first read out the real inventory values, these values are * already stored in the local hush variables */ - p =get_local_var ("IVM_BoardId" ); + p =env_get ("IVM_BoardId" );if (!p) {printf ("can't get the IVM_Boardid\n" );return 1 ; } rc =strict_strtoul (p,16 , &ivmbid); - p =get_local_var ("IVM_HWKey" ); + p =env_get ("IVM_HWKey" );if (!p) {printf ("can't get the IVM_HWKey\n" );return 1 ;board/keymile/common/ivm.c +0
-0@@ -44,14 +44,7 @@ static int ivm_calc_crc(unsigned char *buf, int len)
Quoted 10 lines
board/keymile/common/ivm.c static int ivm_calc_crc(unsigned char *buf, int len) · line 47
Quoted 10 lines
board/keymile/common/ivm.c +1
-8static int ivm_set_value (char *name,char *value) { -char tempbuf[256 ]; - -if (value) { -sprintf (tempbuf,"%s=%s" , name, value); -return set_local_var (tempbuf,0 ); - } -unset_local_var (name); -return 0 ; +return env_set (name, value);
this means we are now writing always down to the permanent environment or? And this I would really like to avoid in our case.
Best regards
Holger
Re: [RFC PATCH v4 28/28] board: keymile: common: Use environment to store IVM_* variables.
Quoted 12 lines · Holger Brunck
Hi Francis,
Quoted 9 lines · Francis Laniel
Quoted 8 lines
These boards used
set_local_var()to store some variables as local shell. They then usedget_local_var()to retrieve the variables values.Instead of using local shell variables, they should use environment ones (like a majority of board).
So, this patch converts using local variables to environment ones.
Quoted 7 lines
why do we need to change that? It is intended that we use this hush variable infrastructure from u-boot (
common/hush.c) for our IVM data and not the standard env. We read the IVM at boot time and store these values in RAM. It is not intended to store them permanently in the flash or wherever the environment is saved. Especially in our case we have some boards where the environment is in a i2c EEPROM and we don't want to write down to the EEPROM each time when the board is starting.
So, the whole series is about updating hush to bring in a new baseline version of the shell, from busybox.
Quoted 55 lines
Quoted 55 lines
board/keymile/common/common.c static int do_setboardid(struct cmd_tbl *cmdtp, int
Quoted 11 lines
Signed-off-by Francis Laniel <[email protected]>--- board/keymile/common/common.c | 8 ++++---- board/keymile/common/ivm.c | 9 +-------- 2 files changed, 5 insertions(+), 12 deletions(-)(quoted diff) +0
-0
b/board/keymile/common/common.cindex3999f48719..72939af36e100644board/keymile/common/common.c +0
-0@@ -219,7 +219,7 @@ static int do_setboardid(struct cmd_tbl *cmdtp, intflag, int argc,
board/keymile/common/common.c static int do_setboardid(struct cmd_tbl *cmdtp, int
Quoted 9 lines
board/keymile/common/common.c +1
-1unsigned char buf[32 ];char *p; - p =get_local_var ("IVM_BoardId" ); + p =env_get ("IVM_BoardId" );if (!p) {printf ("can't get the IVM_Boardid\n" );return 1 ;@@ -228,7 +228,7 @@ static int do_setboardid(struct cmd_tbl *cmdtp, intflag, int argc,
board/keymile/common/common.c static int do_checkboardidhwk(struct cmd_tbl
Quoted 9 lines
board/keymile/common/common.c +1
-1env_set ("boardid" , (char *)buf);printf ("set boardid=%s\n" , buf); - p =get_local_var ("IVM_HWKey" ); + p =env_get ("IVM_HWKey" );if (!p) {printf ("can't get the IVM_HWKey\n" );return 1 ;@@ -272,14 +272,14 @@ static int do_checkboardidhwk(struct cmd_tbl*cmdtp, int flag, int argc,
Quoted 23 lines
board/keymile/common/common.c +2
-2* first read out the real inventory values, these values are * already stored in the local hush variables */ - p =get_local_var ("IVM_BoardId" ); + p =env_get ("IVM_BoardId" );if (!p) {printf ("can't get the IVM_Boardid\n" );return 1 ; } rc =strict_strtoul (p,16 , &ivmbid); - p =get_local_var ("IVM_HWKey" ); + p =env_get ("IVM_HWKey" );if (!p) {printf ("can't get the IVM_HWKey\n" );return 1 ;board/keymile/common/ivm.c +0
-0@@ -44,14 +44,7 @@ static int ivm_calc_crc(unsigned char *buf, int len)
Quoted 13 lines
Quoted 10 lines
board/keymile/common/ivm.c static int ivm_calc_crc(unsigned char *buf, int len) · line 47
Quoted 10 lines
board/keymile/common/ivm.c +1
-8static int ivm_set_value (char *name,char *value) { -char tempbuf[256 ]; - -if (value) { -sprintf (tempbuf,"%s=%s" , name, value); -return set_local_var (tempbuf,0 ); - } -unset_local_var (name); -return 0 ; +return env_set (name, value);this means we are now writing always down to the permanent environment or? And this I would really like to avoid in our case.
Note that "env_set" does not force a save of the running environment. These variables will be exposed to the CLI run-time, which I am not sure if they are today, so if the user then does "saveenv" they will be written. That I think would be a functional difference.
Signature · 1 line
Tom
RE: [RFC PATCH v4 28/28] board: keymile: common: Use environment to store IVM_* variables.
Quoted 18 lines
Quoted 10 lines
Quoted 9 lines · Francis Laniel
Quoted 8 lines
These boards used
set_local_var()to store some variables as local shell. They then usedget_local_var()to retrieve the variables values.Instead of using local shell variables, they should use environment ones (like a majority of board).
So, this patch converts using local variables to environment ones.Quoted 7 lines
why do we need to change that? It is intended that we use this hush variable infrastructure from u-boot (
common/hush.c) for our IVM data and not the standard env. We read the IVM at boot time and store these values in RAM. It is not intended to store them permanently in the flash or wherever the environment is saved. Especially in our case we have some boards where the environment is in a i2c EEPROM and we don't want to write down to the EEPROM each time when the board is starting.
Quoted 3 lines
So, the whole series is about updating hush to bring in a new baseline version of the shell, from busybox.
Ok.
Quoted 73 lines
Quoted 59 lines
Quoted 59 lines
Quoted 13 lines
Signed-off-by: Francis Laniel
<[email protected]>--- board/keymile/common/common.c | 8 ++++---- board/keymile/common/ivm.c | 9 +-------- 2 files changed, 5 insertions(+), 12 deletions(-)(quoted diff) +0
-0
b/board/keymile/common/common.cindex3999f48719..72939af36e100644board/keymile/common/common.c static int do_setboardid(struct cmd_tbl · line 219
Quoted 1 line
board/keymile/common/common.c +0
-0@@ -219,7 +219,7 @@ static int do_setboardid(struct cmd_tbl *cmdtp, intflag, int argc,
board/keymile/common/common.c static int do_setboardid(struct cmd_tbl · line 228
Quoted 10 lines
board/keymile/common/common.c +1
-1unsigned char buf[32 ];char *p; - p =get_local_var ("IVM_BoardId" ); + p =env_get ("IVM_BoardId" );if (!p) {printf ("can't get the IVM_Boardid\n" );board/keymile/common/common.c +0
-0return 1 ;@@ -228,7 +228,7 @@ static int do_setboardid(struct cmd_tbl *cmdtp, intflag, int argc,
board/keymile/common/common.c static int do_checkboardidhwk(struct cmd_tbl
Quoted 9 lines
board/keymile/common/common.c +1
-1env_set ("boardid" , (char *)buf);printf ("set boardid=%s\n" , buf); - p =get_local_var ("IVM_HWKey" ); + p =env_get ("IVM_HWKey" );if (!p) {printf ("can't get the IVM_HWKey\n" );board/keymile/common/common.c +0
-0return 1 ;@@ -272,14 +272,14 @@ static int do_checkboardidhwk(struct cmd_tbl*cmdtp, int flag, int argc,
Quoted 23 lines
board/keymile/common/common.c +2
-2* first read out the real inventory values, these values are * already stored in the local hush variables */ - p =get_local_var ("IVM_BoardId" ); + p =env_get ("IVM_BoardId" );if (!p) {printf ("can't get the IVM_Boardid\n" );return 1 ; } rc =strict_strtoul (p,16 , &ivmbid); - p =get_local_var ("IVM_HWKey" ); + p =env_get ("IVM_HWKey" );if (!p) {printf ("can't get the IVM_HWKey\n" );return 1 ;(quoted diff) +0
-0
b/board/keymile/common/ivm.cindex67db0c50f4..e266d7ce81100644board/keymile/common/ivm.c +0
-0@@ -44,14 +44,7 @@ static int ivm_calc_crc(unsigned char *buf, int len)Quoted 13 lines
Quoted 10 lines
board/keymile/common/ivm.c static int ivm_calc_crc(unsigned char *buf, int len) · line 47
Quoted 10 lines
board/keymile/common/ivm.c +1
-8static int ivm_set_value (char *name,char *value) { -char tempbuf[256 ]; - -if (value) { -sprintf (tempbuf,"%s=%s" , name, value); -return set_local_var (tempbuf,0 ); - } -unset_local_var (name); -return 0 ; +return env_set (name, value);this means we are now writing always down to the permanent environment or? And this I would really like to avoid in our case.
Quoted 1 line
Note that "
env_set" does not force a save of the running environment.
Ah yes you are right. But still for the first boot of our board we will call saveenv to store an initial environment and with this change it would also write down the IVM data which is currently only stored temporary in RAM.
Quoted 4 lines
These variables will be exposed to the CLI run-time, which I am not sure if they are today, so if the user then does "saveenv" they will be written. That I think would be a functional difference.
yes exactly and I wonder if this functionality will be also possible after the rework. I mean our use case (even it seems we are the only ones using it) is quite useful I think. We read out inventory data from an EEPROM and they are parsed and temporary stored in RAM and then we are able to use them as any other environment variables without the need to store them permanently. I also would like to avoid this as the data should be permanently in the IVM only and not stored a second time permanently in flash.
Best regards
Holger
Re: [RFC PATCH v4 28/28] board: keymile: common: Use environment to store IVM_* variables.
Quoted 108 lines · Holger Brunck
Quoted 18 lines
Quoted 10 lines
Quoted 9 lines · Francis Laniel
Quoted 8 lines
These boards used
set_local_var()to store some variables as local shell. They then usedget_local_var()to retrieve the variables values.Instead of using local shell variables, they should use environment ones (like a majority of board).
So, this patch converts using local variables to environment ones.Quoted 7 lines
why do we need to change that? It is intended that we use this hush variable infrastructure from u-boot (
common/hush.c) for our IVM data and not the standard env. We read the IVM at boot time and store these values in RAM. It is not intended to store them permanently in the flash or wherever the environment is saved. Especially in our case we have some boards where the environment is in a i2c EEPROM and we don't want to write down to the EEPROM each time when the board is starting.Quoted 3 lines
So, the whole series is about updating hush to bring in a new baseline version of the shell, from busybox.
Ok.
Quoted 73 lines
Quoted 59 lines
Quoted 59 lines
Quoted 13 lines
Signed-off-by: Francis Laniel
<[email protected]>--- board/keymile/common/common.c | 8 ++++---- board/keymile/common/ivm.c | 9 +-------- 2 files changed, 5 insertions(+), 12 deletions(-)(quoted diff) +0
-0
b/board/keymile/common/common.cindex3999f48719..72939af36e100644board/keymile/common/common.c static int do_setboardid(struct cmd_tbl · line 219
Quoted 1 line
board/keymile/common/common.c +0
-0@@ -219,7 +219,7 @@ static int do_setboardid(struct cmd_tbl *cmdtp, intflag, int argc,
board/keymile/common/common.c static int do_setboardid(struct cmd_tbl · line 228
Quoted 10 lines
board/keymile/common/common.c +1
-1unsigned char buf[32 ];char *p; - p =get_local_var ("IVM_BoardId" ); + p =env_get ("IVM_BoardId" );if (!p) {printf ("can't get the IVM_Boardid\n" );board/keymile/common/common.c +0
-0return 1 ;@@ -228,7 +228,7 @@ static int do_setboardid(struct cmd_tbl *cmdtp, intflag, int argc,
board/keymile/common/common.c static int do_checkboardidhwk(struct cmd_tbl
Quoted 9 lines
board/keymile/common/common.c +1
-1env_set ("boardid" , (char *)buf);printf ("set boardid=%s\n" , buf); - p =get_local_var ("IVM_HWKey" ); + p =env_get ("IVM_HWKey" );if (!p) {printf ("can't get the IVM_HWKey\n" );board/keymile/common/common.c +0
-0return 1 ;@@ -272,14 +272,14 @@ static int do_checkboardidhwk(struct cmd_tbl*cmdtp, int flag, int argc,
Quoted 23 lines
board/keymile/common/common.c +2
-2* first read out the real inventory values, these values are * already stored in the local hush variables */ - p =get_local_var ("IVM_BoardId" ); + p =env_get ("IVM_BoardId" );if (!p) {printf ("can't get the IVM_Boardid\n" );return 1 ; } rc =strict_strtoul (p,16 , &ivmbid); - p =get_local_var ("IVM_HWKey" ); + p =env_get ("IVM_HWKey" );if (!p) {printf ("can't get the IVM_HWKey\n" );return 1 ;(quoted diff) +0
-0
b/board/keymile/common/ivm.cindex67db0c50f4..e266d7ce81100644board/keymile/common/ivm.c +0
-0@@ -44,14 +44,7 @@ static int ivm_calc_crc(unsigned char *buf, int len)Quoted 13 lines
Quoted 10 lines
board/keymile/common/ivm.c static int ivm_calc_crc(unsigned char *buf, int len) · line 47
Quoted 10 lines
board/keymile/common/ivm.c +1
-8static int ivm_set_value (char *name,char *value) { -char tempbuf[256 ]; - -if (value) { -sprintf (tempbuf,"%s=%s" , name, value); -return set_local_var (tempbuf,0 ); - } -unset_local_var (name); -return 0 ; +return env_set (name, value);this means we are now writing always down to the permanent environment or? And this I would really like to avoid in our case.
Quoted 1 line
Note that "
env_set" does not force a save of the running environment.Ah yes you are right. But still for the first boot of our board we will call saveenv to store an initial environment and with this change it would also write down the IVM data which is currently only stored temporary in RAM.
Quoted 4 lines
These variables will be exposed to the CLI run-time, which I am not sure if they are today, so if the user then does "saveenv" they will be written. That I think would be a functional difference.
Quoted 7 lines
yes exactly and I wonder if this functionality will be also possible after the rework. I mean our use case (even it seems we are the only ones using it) is quite useful I think. We read out inventory data from an EEPROM and they are parsed and temporary stored in RAM and then we are able to use them as any other environment variables without the need to store them permanently. I also would like to avoid this as the data should be permanently in the IVM only and not stored a second time permanently in flash.
So, I'll start by noting that the environment variable flag support isn't as well documented as I would like. But my super quick glance makes me wonder if ENV_FLAGS_VARACCESS_WRITEABLE does what you're thinking about, and if not, if it would be useful to extend the flag support to include a "hidden" flag, or otherwise way to indicate that variables A/B/C should never be saved. This could be useful for other cases as well.
Signature · 1 line
Tom
Re: [RFC PATCH v4 28/28] board: keymile: common: Use environment to store IVM_* variables.
Hi.
Quoted 137 lines · Le lundi 20 juin 2022, 19:33:24 CEST Tom Rini a écrit :
Quoted 127 lines · Holger Brunck
Quoted 17 lines
Quoted 9 lines
Quoted 8 lines · Francis Laniel
Quoted 7 lines
These boards used
set_local_var()to store some variables as local shell.
They then usedget_local_var()to retrieve the variables values.Instead of using local shell variables, they should use environment ones (like a majority of board).
So, this patch converts using local variables to environment ones.Quoted 7 lines
why do we need to change that? It is intended that we use this hush variable infrastructure from u-boot (
common/hush.c) for our IVM data and not the standard env. We read the IVM at boot time and store these values in RAM. It is not intended to store them permanently in the flash or wherever the environment is saved. Especially in our case we have some boards where the environment is in a i2c EEPROM and we don't want to write down to the EEPROM each time when the board is starting.Quoted 2 lines
So, the whole series is about updating hush to bring in a new baseline version of the shell, from busybox.
Ok.
Quoted 94 lines
Quoted 81 lines
Quoted 81 lines
Quoted 14 lines
Signed-off-by: Francis Laniel
<[email protected]>
---board/keymile/common/common.c | 8 ++++---- board/keymile/common/ivm.c | 9 +-------- 2 files changed, 5 insertions(+), 12 deletions(-)(quoted diff) +0
-0
b/board/keymile/common/common.cindex3999f48719..72939af36e100644board/keymile/common/common.c static int do_setboardid(struct cmd_tbl · line 219
Quoted 1 line
board/keymile/common/common.c +0
-0@@ -219,7 +219,7 @@ static int do_setboardid(struct cmd_tbl *cmdtp, intflag, int argc,
board/keymile/common/common.c static int do_setboardid(struct cmd_tbl · line 228
Quoted 13 lines
board/keymile/common/common.c +1
-1unsigned char buf[32 ];char *p; - p =get_local_var ("IVM_BoardId" ); + p =env_get ("IVM_BoardId" );if (!p) {board/keymile/common/common.c +0
-0printf ("can't get the IVM_Boardid\n" );return 1 ;@@ -228,7 +228,7 @@ static int do_setboardid(struct cmd_tbl *cmdtp, intflag, int argc,
board/keymile/common/common.c static int do_checkboardidhwk(struct cmd_tbl
Quoted 12 lines
board/keymile/common/common.c +1
-1env_set ("boardid" , (char *)buf);printf ("set boardid=%s\n" , buf); - p =get_local_var ("IVM_HWKey" ); + p =env_get ("IVM_HWKey" );if (!p) {board/keymile/common/common.c +0
-0printf ("can't get the IVM_HWKey\n" );return 1 ;@@ -272,14 +272,14 @@ static int do_checkboardidhwk(struct cmd_tbl*cmdtp, int flag, int argc,
Quoted 32 lines
board/keymile/common/common.c +2
-2* first read out the real inventory values, these values are * already stored in the local hush variables */ - p =get_local_var ("IVM_BoardId" ); + p =env_get ("IVM_BoardId" );if (!p) {printf ("can't get the IVM_Boardid\n" );return 1 ; } rc =strict_strtoul (p,16 , &ivmbid); - p =get_local_var ("IVM_HWKey" ); + p =env_get ("IVM_HWKey" );if (!p) {printf ("can't get the IVM_HWKey\n" );return 1 ;(quoted diff) +0
-0
b/board/keymile/common/ivm.cindex67db0c50f4..e266d7ce81100644board/keymile/common/ivm.c +0
-0@@ -44,14 +44,7 @@ static int ivm_calc_crc(unsigned char *buf, int len) static int ivm_set_value(char *name, char *value) {Quoted 12 lines
Quoted 9 lines
board/keymile/common/ivm.c static int ivm_calc_crc(unsigned char *buf, int · line 48
Quoted 9 lines
board/keymile/common/ivm.c +1
-8-char tempbuf[256 ]; - -if (value) { -sprintf (tempbuf,"%s=%s" , name, value); -return set_local_var (tempbuf,0 ); - } -unset_local_var (name); -return 0 ; +return env_set (name, value);this means we are now writing always down to the permanent environment or? And this I would really like to avoid in our case.
Quoted 1 line
Note that "
env_set" does not force a save of the running environment.Ah yes you are right. But still for the first boot of our board we will call saveenv to store an initial environment and with this change it would also write down the IVM data which is currently only stored temporary in RAM.
Quoted 3 lines
These variables will be exposed to the CLI run-time, which I am not sure if they are today, so if the user then does "saveenv" they will be written. That I think would be a functional difference.
Quoted 8 lines
yes exactly and I wonder if this functionality will be also possible after the rework. I mean our use case (even it seems we are the only ones using it) is quite useful I think. We read out inventory data from an EEPROM and they are parsed and temporary stored in RAM and then we are able to use them as any other environment variables without the need to store them permanently. I also would like to avoid this as the data should be permanently in the IVM only and not stored a second time permanently in flash.
Quoted 7 lines
So, I'll start by noting that the environment variable flag support isn't as well documented as I would like. But my super quick glance makes me wonder if
ENV_FLAGS_VARACCESS_WRITEABLEdoes what you're thinking about, and if not, if it would be useful to extend the flag support to include a "hidden" flag, or otherwise way to indicate that variables A/B/C should never be saved. This could be useful for other cases as well.
Again, sorry for the late reply.
To be honest, this board is the only one which presents this behavior. I will think about a mechanism to handle your use case. Nonetheless, as you are the exception and this series begins to be a bit big I think in a first time I will not address it.
I will just add these patches to make the CI happy, but I will mark them as "do not merge".
So, we can merge this series and you can still use the old hush shell, as I do not think we plan about making the new version the default right now.
What do you think?
Does it seem acceptable for you?
RE: [RFC PATCH v4 28/28] board: keymile: common: Use environment to store IVM_* variables.
Quoted 164 lines · Le lundi 20 juin 2022, 19:33:24 CEST Tom Rini a écrit :
Quoted 10 lines · Holger Brunck
Quoted 9 lines
Quoted 9 lines
Quoted 9 lines
Quoted 8 lines · Francis Laniel
Quoted 7 lines
These boards used
set_local_var()to store some variables as local shell.
They then usedget_local_var()to retrieve the variables values.Instead of using local shell variables, they should use environment ones (like a majority of board).
So, this patch converts using local variables to environment ones.Quoted 7 lines
Quoted 7 lines
Quoted 7 lines
Quoted 7 lines
why do we need to change that? It is intended that we use this hush variable infrastructure from u-boot (
common/hush.c) for our IVM data and not the standard env. We read the IVM at boot time and store these values in RAM. It is not intended to store them permanently in the flash or wherever the environment is saved. Especially in our case we have some boards where the environment is in a i2c EEPROM and we don't want to write down to the EEPROMeach time when the board is starting.
Quoted 10 lines
Quoted 10 lines
Quoted 3 lines
So, the whole series is about updating hush to bring in a new baseline version of the shell, from busybox.
Ok.
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Quoted 4 lines
Signed-off-by: Francis Laniel
<[email protected]>
---Quoted 6 lines
Quoted 6 lines
Quoted 6 lines
Quoted 6 lines
Quoted 6 lines
Quoted 6 lines
board/keymile/common/common.c | 8 ++++---- board/keymile/common/ivm.c | 9 +-------- 2 files changed, 5 insertions(+), 12 deletions(-)(quoted diff) +0
-0
b/board/keymile/common/common.cindex
3999f48719..72939af36eQuoted 108 lines
Quoted 98 lines
Quoted 87 lines
Quoted 74 lines
Quoted 74 lines
board/keymile/common/common.c static int do_setboardid(struct cmd_tbl · line 219
Quoted 5 lines
100644
board/keymile/common/common.c +0
-0@@ -219,7 +219,7 @@ static int do_setboardid(struct cmd_tbl *cmdtp, intflag, int argc,
board/keymile/common/common.c static int do_setboardid(struct cmd_tbl · line 228
Quoted 13 lines
board/keymile/common/common.c +1
-1unsigned char buf[32 ];char *p; - p =get_local_var ("IVM_BoardId" ); + p =env_get ("IVM_BoardId" );if (!p) {printf("can't get the IVM_Boardid\n"); return 1;board/keymile/common/common.c +0
-0@@ -228,7 +228,7 @@ static int do_setboardid(struct cmd_tbl *cmdtp, intflag, int argc,
Quoted 12 lines
board/keymile/common/common.c +1
-1env_set ("boardid" , (char *)buf);printf ("set boardid=%s\n" , buf); - p =get_local_var ("IVM_HWKey" ); + p =env_get ("IVM_HWKey" );if (!p) {printf("can't get the IVM_HWKey\n"); return 1;board/keymile/common/common.c +0
-0@@ -272,14 +272,14 @@ static int do_checkboardidhwk(structQuoted 1 line
cmd_tbl*cmdtp, int flag, int argc,
Quoted 34 lines
* first read out the real inventory values, these values are
* already stored in the local hush variables
*/board/keymile/common/common.c +2
-2- p =get_local_var ("IVM_BoardId" ); + p =env_get ("IVM_BoardId" );if (!p) {printf ("can't get the IVM_Boardid\n" );return 1 ; } rc =strict_strtoul (p,16 , &ivmbid); - p =get_local_var ("IVM_HWKey" ); + p =env_get ("IVM_HWKey" );if (!p) {printf ("can't get the IVM_HWKey\n" );return 1 ;(quoted diff) +0
-0
b/board/keymile/common/ivm.cindex67db0c50f4..e266d7ce81100644board/keymile/common/ivm.c +0
-0@@ -44,14 +44,7 @@ static int ivm_calc_crc(unsigned char *buf, int len)static int ivm_set_value (char *name,char *value) {Quoted 12 lines
Quoted 9 lines
board/keymile/common/ivm.c static int ivm_calc_crc(unsigned char · line 49
Quoted 9 lines
board/keymile/common/ivm.c +1
-8-char tempbuf[256 ]; - -if (value) { -sprintf (tempbuf,"%s=%s" , name, value); -return set_local_var (tempbuf,0 ); - } -unset_local_var (name); -return 0 ; +return env_set (name, value);this means we are now writing always down to the permanent environment or? And this I would really like to avoid in our case.
Quoted 1 line
Note that "
env_set" does not force a save of the running environment.Ah yes you are right. But still for the first boot of our board we will call saveenv to store an initial environment and with this change it would also write down the IVM data which is currently only stored temporary in RAM.
Quoted 3 lines
These variables will be exposed to the CLI run-time, which I am not sure if they are today, so if the user then does "saveenv" they will be written. That I think would be a functional difference.
Quoted 9 lines
yes exactly and I wonder if this functionality will be also possible after the rework. I mean our use case (even it seems we are the only ones using
it) is quite useful I think. We read out inventory data from an EEPROM and they are parsed and temporary stored in RAM and then we are able to use them as any other environment variables without the need to store them permanently. I also would like to avoid this as the data should be permanently in the IVM only and not stored a second time permanently in flash.Quoted 3 lines
So, I'll start by noting that the environment variable flag support isn't as well documented as I would like. But my super quick glance makes me wonder if
ENV_FLAGS_VARACCESS_WRITEABLEdoes whatyou're
Quoted 4 lines
thinking about, and if not, if it would be useful to extend the flag support to include a "hidden" flag, or otherwise way to indicate that variables A/B/C should never be saved. This could be useful for other cases as well.
Again, sorry for the late reply.
To be honest, this board is the only one which presents this behavior. I will think about a mechanism to handle your use case. Nonetheless, as you are the exception and this series begins to be a bit big I think in a first time I will not address it.
I will just add these patches to make the CI happy, but I will mark them as "do not merge".
So, we can merge this series and you can still use the old hush shell, as I do not think we plan about making the new version the default right now.
Quoted 3 lines
What do you think?
Does it seem acceptable for you?
yes go ahead. If we are the only ones using the hush shell and there is an agreement that this is intended to get removed we will not block it.
Best regards
Holger
Quoted 75 lines · Francis Laniel
Hi.
First I hope you are fine and the same for your relatives.
During 2021 summer, Sean Anderson wrote a contribution to add a new shell, based on LIL, to U-Boot [1][2].
While one of the goals of this contribution was to address the fact actual U-Boot shell, which is based on Busybox hush, is old there was a discussion about adding a new shell versus updating the actual one [3][4].So, in this series, with Harald Seiler, we updated the actual U-Boot shell to reflect what is currently in Busybox source code.
Basically, this contribution is about taking a snapshot of Busyboxshell/hush.cfile (as it exists in commit37460f5da) and adapt it to suit U-Boot needs.This contribution was written to be as backward-compatible as possible to avoid breaking the existing.
So, the 2021 hush flavor offers the same as the actual, that is to say:
1. Variable expansion.
2. Instruction lists (;, && and ||).
3. If, then and else.
4. Loops (for, while and until).
No new features offered by Busybox hush were implemented (e.g. functions).It is possible to change the parser at runtime using the "parser" command:
=> parser print
old
=> parser set 2021
2021> parser print
2021
2021> parser set old
=>
The default parser is the old one.In terms of testing, new unit tests were added to ut to ensure the new behavior is the same as the old one and it does not add regression. Nonetheless, if old behavior was buggy and fixed upstream, the fix is then added to U-Boot [5].
In sandbox, all of these tests pass smoothly:
=> printenv board
board=sandbox
=> ut hush
Running 20 hush tests
...
Failures: 0
=> parser set 2021
2021> ut hush
Running 20 hush tests
...
Failures: 0Thanks to the effort of Harald Seiler, I was successful booting a board:
2021> printenvboard_rev
board_rev=iMX8MP
2021> boot
...root@iMX8MPboard:~# fw_printenv board_rev board_rev=iMX8MPI also tested another board where both parser were successful to boot it:
=> printenv fdtfile fdtfile=amlogic/meson-gxl-s905x-libretech-cc.dtb
=> boot
...
root@lepotato:~#root@lepotato:~# reboot ... => parser set 2021 2021> printenv fdtfile fdtfile=amlogic/meson-gxl-s905x-libretech-cc.dtb 2021> boot ... root@lepotato:~#
Quoted 3 lines
Sadly, I was not able to have the CI passes smoothly...
To pass it and be aware of all the troubles, I added the 3 last commits as "trick" commits.
I've replied to those now. And generally I just want to say I'm very happy with the progress here in v3->v4.
Signature · 1 line
Tom