Compare commits
4
Commits
master
...
1_12_stable
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
9b8f810d38 | ||
|
|
9343da45d3 | ||
|
|
84641942e5 | ||
|
|
bacaff6e54 |
No files matched your search
@@ -1,6 +1,6 @@
|
||||
VERSION = 1
|
||||
PATCHLEVEL = 12
|
||||
SUBLEVEL = 0
|
||||
SUBLEVEL = 4
|
||||
EXTRAVERSION =
|
||||
NAME = Unnamed
|
||||
|
||||
|
||||
@@ -50,7 +50,7 @@ static void signal_handler(int signo)
|
||||
{
|
||||
// restore keyboard and console settings
|
||||
xset1(STDIN_FILENO, &tio0, "stdin");
|
||||
xioctl(STDIN_FILENO, KDSKBMODE, (void *)kbmode);
|
||||
xioctl(STDIN_FILENO, KDSKBMODE, (void *)(ptrdiff_t)kbmode);
|
||||
// alarmed? -> exit 0
|
||||
exit(SIGALRM == signo);
|
||||
}
|
||||
@@ -95,7 +95,7 @@ int showkey_main(int argc UNUSED_PARAM, char **argv)
|
||||
// we should exit on any signal
|
||||
bb_signals(BB_FATAL_SIGS, signal_handler);
|
||||
// set raw keyboard mode
|
||||
xioctl(STDIN_FILENO, KDSKBMODE, (void *)((option_mask32 & OPT_k) ? K_MEDIUMRAW : K_RAW));
|
||||
xioctl(STDIN_FILENO, KDSKBMODE, (void *)(ptrdiff_t)((option_mask32 & OPT_k) ? K_MEDIUMRAW : K_RAW));
|
||||
|
||||
// read and show scancodes
|
||||
while (1) {
|
||||
|
||||
@@ -48,5 +48,5 @@ int basename_main(int argc, char **argv)
|
||||
|
||||
/* puts(s) will do, but we can do without stdio this way: */
|
||||
s[m++] = '\n';
|
||||
return full_write(STDOUT_FILENO, s, m) == (ssize_t)m;
|
||||
return full_write(STDOUT_FILENO, s, m) != (ssize_t)m;
|
||||
}
|
||||
+2
-2
@@ -29,6 +29,8 @@
|
||||
* - use xfunc_error_retval
|
||||
*/
|
||||
|
||||
/* This is a NOEXEC applet. Be very careful! */
|
||||
|
||||
#include "libbb.h"
|
||||
|
||||
#if ENABLE_FEATURE_ENV_LONG_OPTIONS
|
||||
@@ -119,5 +121,3 @@ int env_main(int argc UNUSED_PARAM, char **argv)
|
||||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
||||
* SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
|
||||
+8
-1
@@ -359,8 +359,15 @@ int printf_main(int argc UNUSED_PARAM, char **argv)
|
||||
* We will mimic coreutils. */
|
||||
if (argv[1] && argv[1][0] == '-' && argv[1][1] == '-' && !argv[1][2])
|
||||
argv++;
|
||||
if (!argv[1])
|
||||
if (!argv[1]) {
|
||||
if (ENABLE_ASH_BUILTIN_PRINTF
|
||||
&& applet_name[0] != 'p'
|
||||
) {
|
||||
bb_error_msg("usage: printf FORMAT [ARGUMENT...]");
|
||||
return 2; /* bash compat */
|
||||
}
|
||||
bb_show_usage();
|
||||
}
|
||||
|
||||
format = argv[1];
|
||||
argv2 = argv + 2;
|
||||
|
||||
+14
-7
@@ -973,7 +973,12 @@ static uint32_t next_token(uint32_t expected)
|
||||
|
||||
} else if (*p == '.' || isdigit(*p)) {
|
||||
/* it's a number */
|
||||
t_double = strtod(p, &p);
|
||||
#if ENABLE_DESKTOP
|
||||
if (p[0] == '0' && (p[1] | 0x20) == 'x')
|
||||
t_double = strtoll(p, &p, 0);
|
||||
else
|
||||
#endif
|
||||
t_double = strtod(p, &p);
|
||||
if (*p == '.')
|
||||
syntax_error(EMSG_UNEXP_TOKEN);
|
||||
tc = TC_NUMBER;
|
||||
@@ -2034,28 +2039,30 @@ static var *exec_builtin(node *op, var *res)
|
||||
setvar_p(res, s);
|
||||
break;
|
||||
|
||||
/* Bitwise ops must assume that operands are unsigned. GNU Awk 3.1.5:
|
||||
* awk '{ print or(-1,1) }' gives "4.29497e+09", not "-2.xxxe+09" */
|
||||
case B_an:
|
||||
setvar_i(res, (long)getvar_i(av[0]) & (long)getvar_i(av[1]));
|
||||
setvar_i(res, (unsigned long)getvar_i(av[0]) & (unsigned long)getvar_i(av[1]));
|
||||
break;
|
||||
|
||||
case B_co:
|
||||
setvar_i(res, ~(long)getvar_i(av[0]));
|
||||
setvar_i(res, ~(unsigned long)getvar_i(av[0]));
|
||||
break;
|
||||
|
||||
case B_ls:
|
||||
setvar_i(res, (long)getvar_i(av[0]) << (long)getvar_i(av[1]));
|
||||
setvar_i(res, (unsigned long)getvar_i(av[0]) << (unsigned long)getvar_i(av[1]));
|
||||
break;
|
||||
|
||||
case B_or:
|
||||
setvar_i(res, (long)getvar_i(av[0]) | (long)getvar_i(av[1]));
|
||||
setvar_i(res, (unsigned long)getvar_i(av[0]) | (unsigned long)getvar_i(av[1]));
|
||||
break;
|
||||
|
||||
case B_rs:
|
||||
setvar_i(res, (long)((unsigned long)getvar_i(av[0]) >> (unsigned long)getvar_i(av[1])));
|
||||
setvar_i(res, (unsigned long)getvar_i(av[0]) >> (unsigned long)getvar_i(av[1]));
|
||||
break;
|
||||
|
||||
case B_xo:
|
||||
setvar_i(res, (long)getvar_i(av[0]) ^ (long)getvar_i(av[1]));
|
||||
setvar_i(res, (unsigned long)getvar_i(av[0]) ^ (unsigned long)getvar_i(av[1]));
|
||||
break;
|
||||
|
||||
case B_lo:
|
||||
|
||||
+30
-32
@@ -147,10 +147,10 @@ struct globals {
|
||||
#endif
|
||||
|
||||
smallint editing; // >0 while we are editing a file
|
||||
// [code audit says "can be 0 or 1 only"]
|
||||
// [code audit says "can be 0, 1 or 2 only"]
|
||||
smallint cmd_mode; // 0=command 1=insert 2=replace
|
||||
int file_modified; // buffer contents changed (counter, not flag!)
|
||||
int last_file_modified; // = -1;
|
||||
int last_file_modified; // = -1;
|
||||
int fn_start; // index of first cmd line file name
|
||||
int save_argc; // how many file names on cmd line
|
||||
int cmdcnt; // repetition count
|
||||
@@ -291,6 +291,8 @@ struct globals {
|
||||
#define INIT_G() do { \
|
||||
SET_PTR_TO_GLOBALS(xzalloc(sizeof(G))); \
|
||||
last_file_modified = -1; \
|
||||
/* "" but has space for 2 chars */ \
|
||||
USE_FEATURE_VI_SEARCH(last_search_pattern = xzalloc(2);) \
|
||||
} while (0)
|
||||
|
||||
|
||||
@@ -623,7 +625,7 @@ static void edit_file(char *fn)
|
||||
// These are commands that change text[].
|
||||
// Remember the input for the "." command
|
||||
if (!adding2q && ioq_start == NULL
|
||||
&& strchr(modifying_cmds, c)
|
||||
&& c != '\0' && strchr(modifying_cmds, c)
|
||||
) {
|
||||
start_new_cmd_q(c);
|
||||
}
|
||||
@@ -645,8 +647,8 @@ static void edit_file(char *fn)
|
||||
}
|
||||
//-------------------------------------------------------------------
|
||||
|
||||
place_cursor(rows, 0, FALSE); // go to bottom of screen
|
||||
clear_to_eol(); // Erase to end of line
|
||||
place_cursor(rows - 1, 0, FALSE); // go to bottom of screen
|
||||
clear_to_eol(); // erase to end of line
|
||||
cookmode();
|
||||
#undef cur_line
|
||||
}
|
||||
@@ -2009,9 +2011,9 @@ static void start_new_cmd_q(char c)
|
||||
{
|
||||
// get buffer for new cmd
|
||||
// if there is a current cmd count put it in the buffer first
|
||||
if (cmdcnt > 0)
|
||||
if (cmdcnt > 0) {
|
||||
lmc_len = sprintf(last_modifying_cmd, "%d%c", cmdcnt, c);
|
||||
else { // just save char c onto queue
|
||||
} else { // just save char c onto queue
|
||||
last_modifying_cmd[0] = c;
|
||||
lmc_len = 1;
|
||||
}
|
||||
@@ -2157,21 +2159,21 @@ static void winch_sig(int sig UNUSED_PARAM)
|
||||
//----- Come here when we get a continue signal -------------------
|
||||
static void cont_sig(int sig UNUSED_PARAM)
|
||||
{
|
||||
rawmode(); // terminal to "raw"
|
||||
last_status_cksum = 0; // force status update
|
||||
redraw(TRUE); // re-draw the screen
|
||||
rawmode(); // terminal to "raw"
|
||||
last_status_cksum = 0; // force status update
|
||||
redraw(TRUE); // re-draw the screen
|
||||
|
||||
signal(SIGTSTP, suspend_sig);
|
||||
signal(SIGCONT, SIG_DFL);
|
||||
kill(my_pid, SIGCONT);
|
||||
kill(my_pid, SIGCONT); // huh? why? we are already "continued"...
|
||||
}
|
||||
|
||||
//----- Come here when we get a Suspend signal -------------------
|
||||
static void suspend_sig(int sig UNUSED_PARAM)
|
||||
{
|
||||
place_cursor(rows - 1, 0, FALSE); // go to bottom of screen
|
||||
clear_to_eol(); // Erase to end of line
|
||||
cookmode(); // terminal to "cooked"
|
||||
place_cursor(rows - 1, 0, FALSE); // go to bottom of screen
|
||||
clear_to_eol(); // erase to end of line
|
||||
cookmode(); // terminal to "cooked"
|
||||
|
||||
signal(SIGCONT, cont_sig);
|
||||
signal(SIGTSTP, SIG_DFL);
|
||||
@@ -2247,18 +2249,20 @@ static char readit(void) // read (maybe cursor) key from stdin
|
||||
|
||||
fflush(stdout);
|
||||
n = chars_to_parse;
|
||||
// get input from User- are there already input chars in Q?
|
||||
// get input from User - are there already input chars in Q?
|
||||
if (n <= 0) {
|
||||
// the Q is empty, wait for a typed char
|
||||
again:
|
||||
n = safe_read(STDIN_FILENO, readbuffer, sizeof(readbuffer));
|
||||
if (n < 0) {
|
||||
if (errno == EBADF || errno == EFAULT || errno == EINVAL
|
||||
|| errno == EIO)
|
||||
editing = 0; // want to exit
|
||||
errno = 0;
|
||||
if (n <= 0) {
|
||||
place_cursor(rows - 1, 0, FALSE); // go to bottom of screen
|
||||
clear_to_eol(); // erase to end of line
|
||||
cookmode(); // terminal to "cooked"
|
||||
bb_error_msg_and_die("can't read user input");
|
||||
}
|
||||
if (n <= 0)
|
||||
return 0; // error
|
||||
/* elsewhere we can get very confused by NULs */
|
||||
if (readbuffer[0] == '\0')
|
||||
goto again;
|
||||
if (readbuffer[0] == 27) {
|
||||
// This is an ESC char. Is this Esc sequence?
|
||||
// Could be bare Esc key. See if there are any
|
||||
@@ -2972,7 +2976,7 @@ static void do_cmd(char c)
|
||||
const char *msg = msg; // for compiler
|
||||
char c1, *p, *q, *save_dot;
|
||||
char buf[12];
|
||||
int dir = dir; // for compiler
|
||||
int dir;
|
||||
int cnt, i, j;
|
||||
|
||||
// c1 = c; // quiet the compiler
|
||||
@@ -3314,7 +3318,7 @@ static void do_cmd(char c)
|
||||
q = get_input_line(buf); // get input line- use "status line"
|
||||
if (q[0] && !q[1]) {
|
||||
if (last_search_pattern[0])
|
||||
last_search_pattern[0] = c;
|
||||
last_search_pattern[0] = c;
|
||||
goto dc3; // if no pat re-use old pat
|
||||
}
|
||||
if (q[0]) { // strlen(q) > 1: new pat- save it and find
|
||||
@@ -3344,14 +3348,8 @@ static void do_cmd(char c)
|
||||
do_cmd(c);
|
||||
} // repeat cnt
|
||||
dc3:
|
||||
if (last_search_pattern == 0) {
|
||||
msg = "No previous regular expression";
|
||||
goto dc2;
|
||||
}
|
||||
if (last_search_pattern[0] == '/') {
|
||||
dir = FORWARD; // assume FORWARD search
|
||||
p = dot + 1;
|
||||
}
|
||||
dir = FORWARD; // assume FORWARD search
|
||||
p = dot + 1;
|
||||
if (last_search_pattern[0] == '?') {
|
||||
dir = BACK;
|
||||
p = dot - 1;
|
||||
|
||||
+47
-3
@@ -87,7 +87,11 @@ enum {
|
||||
|
||||
struct globals {
|
||||
int max_matches;
|
||||
#if !ENABLE_EXTRA_COMPAT
|
||||
int reflags;
|
||||
#else
|
||||
RE_TRANSLATE_TYPE case_fold; /* RE_TRANSLATE_TYPE is [[un]signed] char* */
|
||||
#endif
|
||||
smalluint invert_search;
|
||||
smalluint print_filename;
|
||||
smalluint open_errors;
|
||||
@@ -110,7 +114,19 @@ struct globals {
|
||||
}; \
|
||||
} while (0)
|
||||
#define max_matches (G.max_matches )
|
||||
#if !ENABLE_EXTRA_COMPAT
|
||||
#define reflags (G.reflags )
|
||||
#else
|
||||
#define case_fold (G.case_fold )
|
||||
/* http://www.delorie.com/gnu/docs/regex/regex_46.html */
|
||||
#define reflags re_syntax_options
|
||||
#undef REG_NOSUB
|
||||
#undef REG_EXTENDED
|
||||
#undef REG_ICASE
|
||||
#define REG_NOSUB bug:is:here /* should not be used */
|
||||
#define REG_EXTENDED RE_SYNTAX_EGREP
|
||||
#define REG_ICASE bug:is:here /* should not be used */
|
||||
#endif
|
||||
#define invert_search (G.invert_search )
|
||||
#define print_filename (G.print_filename )
|
||||
#define open_errors (G.open_errors )
|
||||
@@ -240,6 +256,7 @@ static int grep_file(FILE *file)
|
||||
xregcomp(&gl->compiled_regex, gl->pattern, reflags);
|
||||
#else
|
||||
memset(&gl->compiled_regex, 0, sizeof(gl->compiled_regex));
|
||||
gl->compiled_regex.translate = case_fold; /* for -i */
|
||||
if (re_compile_pattern(gl->pattern, strlen(gl->pattern), &gl->compiled_regex))
|
||||
bb_error_msg_and_die("bad regex '%s'", gl->pattern);
|
||||
#endif
|
||||
@@ -346,12 +363,22 @@ static int grep_file(FILE *file)
|
||||
* (unless -v: -Fov doesnt print anything at all) */
|
||||
if (found)
|
||||
print_line(gl->pattern, strlen(gl->pattern), linenum, ':');
|
||||
} else {
|
||||
} else while (1) {
|
||||
char old = line[gl->matched_range.rm_eo];
|
||||
line[gl->matched_range.rm_eo] = '\0';
|
||||
print_line(line + gl->matched_range.rm_so,
|
||||
gl->matched_range.rm_eo - gl->matched_range.rm_so,
|
||||
linenum, ':');
|
||||
}
|
||||
line[gl->matched_range.rm_eo] = old;
|
||||
#if !ENABLE_EXTRA_COMPAT
|
||||
break;
|
||||
#else
|
||||
if (re_search(&gl->compiled_regex, line, line_len,
|
||||
gl->matched_range.rm_eo, line_len - gl->matched_range.rm_eo,
|
||||
&gl->matched_range) < 0)
|
||||
break;
|
||||
#endif
|
||||
}
|
||||
} else {
|
||||
print_line(line, line_len, linenum, ':');
|
||||
}
|
||||
@@ -532,17 +559,34 @@ int grep_main(int argc, char **argv)
|
||||
if (ENABLE_FEATURE_GREP_FGREP_ALIAS && applet_name[0] == 'f')
|
||||
option_mask32 |= OPT_F;
|
||||
|
||||
#if !ENABLE_EXTRA_COMPAT
|
||||
if (!(option_mask32 & (OPT_o | OPT_w)))
|
||||
reflags = REG_NOSUB;
|
||||
#endif
|
||||
|
||||
if (ENABLE_FEATURE_GREP_EGREP_ALIAS
|
||||
&& (applet_name[0] == 'e' || (option_mask32 & OPT_E))
|
||||
) {
|
||||
reflags |= REG_EXTENDED;
|
||||
}
|
||||
#if ENABLE_EXTRA_COMPAT
|
||||
else {
|
||||
reflags = RE_SYNTAX_GREP;
|
||||
}
|
||||
#endif
|
||||
|
||||
if (option_mask32 & OPT_i)
|
||||
if (option_mask32 & OPT_i) {
|
||||
#if !ENABLE_EXTRA_COMPAT
|
||||
reflags |= REG_ICASE;
|
||||
#else
|
||||
int i;
|
||||
case_fold = xmalloc(256);
|
||||
for (i = 0; i < 256; i++)
|
||||
case_fold[i] = (unsigned char)i;
|
||||
for (i = 'a'; i <= 'z'; i++)
|
||||
case_fold[i] = (unsigned char)(i - ('a' - 'A'));
|
||||
#endif
|
||||
}
|
||||
|
||||
argv += optind;
|
||||
argc -= optind;
|
||||
|
||||
+2
-2
@@ -136,7 +136,7 @@ USE_ECHO(APPLET_NOFORK(echo, echo, _BB_DIR_BIN, _BB_SUID_NEVER, echo))
|
||||
USE_ED(APPLET(ed, _BB_DIR_BIN, _BB_SUID_NEVER))
|
||||
USE_FEATURE_GREP_EGREP_ALIAS(APPLET_ODDNAME(egrep, grep, _BB_DIR_BIN, _BB_SUID_NEVER, egrep))
|
||||
USE_EJECT(APPLET(eject, _BB_DIR_USR_BIN, _BB_SUID_NEVER))
|
||||
USE_ENV(APPLET(env, _BB_DIR_USR_BIN, _BB_SUID_NEVER))
|
||||
USE_ENV(APPLET_NOEXEC(env, env, _BB_DIR_USR_BIN, _BB_SUID_NEVER, env))
|
||||
USE_ENVDIR(APPLET_ODDNAME(envdir, chpst, _BB_DIR_USR_BIN, _BB_SUID_NEVER, envdir))
|
||||
USE_ENVUIDGID(APPLET_ODDNAME(envuidgid, chpst, _BB_DIR_USR_BIN, _BB_SUID_NEVER, envuidgid))
|
||||
USE_ETHER_WAKE(APPLET_ODDNAME(ether-wake, ether_wake, _BB_DIR_USR_BIN, _BB_SUID_NEVER, ether_wake))
|
||||
@@ -171,7 +171,7 @@ USE_GREP(APPLET(grep, _BB_DIR_BIN, _BB_SUID_NEVER))
|
||||
USE_GUNZIP(APPLET(gunzip, _BB_DIR_BIN, _BB_SUID_NEVER))
|
||||
USE_GZIP(APPLET(gzip, _BB_DIR_BIN, _BB_SUID_NEVER))
|
||||
USE_HALT(APPLET(halt, _BB_DIR_SBIN, _BB_SUID_NEVER))
|
||||
USE_HD(APPLET_ODDNAME(hd, hexdump, _BB_DIR_USR_BIN, _BB_SUID_NEVER, hd))
|
||||
USE_HD(APPLET_NOEXEC(hd, hexdump, _BB_DIR_USR_BIN, _BB_SUID_NEVER, hd))
|
||||
USE_HDPARM(APPLET(hdparm, _BB_DIR_SBIN, _BB_SUID_NEVER))
|
||||
USE_HEAD(APPLET(head, _BB_DIR_USR_BIN, _BB_SUID_NEVER))
|
||||
USE_HEXDUMP(APPLET_NOEXEC(hexdump, hexdump, _BB_DIR_USR_BIN, _BB_SUID_NEVER, hexdump))
|
||||
|
||||
+3
-12
@@ -517,18 +517,8 @@ getopt32(char **argv, const char *applet_opts, ...)
|
||||
|
||||
/* In case getopt32 was already called:
|
||||
* reset the libc getopt() function, which keeps internal state.
|
||||
*
|
||||
* BSD-derived getopt() functions require that optind be set to 1 in
|
||||
* order to reset getopt() state. This used to be generally accepted
|
||||
* way of resetting getopt(). However, glibc's getopt()
|
||||
* has additional getopt() state beyond optind, and requires that
|
||||
* optind be set to zero to reset its state. So the unfortunate state of
|
||||
* affairs is that BSD-derived versions of getopt() misbehave if
|
||||
* optind is set to 0 in order to reset getopt(), and glibc's getopt()
|
||||
* will core dump if optind is set 1 in order to reset getopt().
|
||||
*
|
||||
* More modern versions of BSD require that optreset be set to 1 in
|
||||
* order to reset getopt(). Sigh. Standards, anyone?
|
||||
* run_nofork_applet_prime() does this, but we might end up here
|
||||
* also via gunzip_main() -> gzip_main(). Play safe.
|
||||
*/
|
||||
#ifdef __GLIBC__
|
||||
optind = 0;
|
||||
@@ -537,6 +527,7 @@ getopt32(char **argv, const char *applet_opts, ...)
|
||||
/* optreset = 1; */
|
||||
#endif
|
||||
/* optarg = NULL; opterr = 0; optopt = 0; - do we need this?? */
|
||||
|
||||
pargv = NULL;
|
||||
|
||||
/* Note: just "getopt() <= 0" will not work well for
|
||||
|
||||
+51
-27
@@ -956,24 +956,33 @@ static void input_tab(smallint *lastWasTab)
|
||||
|
||||
#if MAX_HISTORY > 0
|
||||
|
||||
/* state->flags is already checked to be nonzero */
|
||||
static void get_previous_history(void)
|
||||
static void save_command_ps_at_cur_history(void)
|
||||
{
|
||||
if (command_ps[0] != '\0' || state->history[state->cur_history] == NULL) {
|
||||
free(state->history[state->cur_history]);
|
||||
state->history[state->cur_history] = xstrdup(command_ps);
|
||||
if (command_ps[0] != '\0') {
|
||||
int cur = state->cur_history;
|
||||
free(state->history[cur]);
|
||||
state->history[cur] = xstrdup(command_ps);
|
||||
}
|
||||
state->cur_history--;
|
||||
}
|
||||
|
||||
/* state->flags is already checked to be nonzero */
|
||||
static int get_previous_history(void)
|
||||
{
|
||||
if ((state->flags & DO_HISTORY) && state->cur_history) {
|
||||
save_command_ps_at_cur_history();
|
||||
state->cur_history--;
|
||||
return 1;
|
||||
}
|
||||
beep();
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int get_next_history(void)
|
||||
{
|
||||
if (state->flags & DO_HISTORY) {
|
||||
int ch = state->cur_history;
|
||||
if (ch < state->cnt_history) {
|
||||
get_previous_history(); /* save the current history line */
|
||||
state->cur_history = ch + 1;
|
||||
return state->cur_history;
|
||||
if (state->cur_history < state->cnt_history) {
|
||||
save_command_ps_at_cur_history(); /* save the current history line */
|
||||
return ++state->cur_history;
|
||||
}
|
||||
}
|
||||
beep();
|
||||
@@ -995,6 +1004,7 @@ static void load_history(const char *fromfile)
|
||||
for (hi = state->cnt_history; hi > 0;) {
|
||||
hi--;
|
||||
free(state->history[hi]);
|
||||
state->history[hi] = NULL;
|
||||
}
|
||||
|
||||
for (hi = 0; hi < MAX_HISTORY;) {
|
||||
@@ -1006,14 +1016,14 @@ static void load_history(const char *fromfile)
|
||||
l = strlen(hl);
|
||||
if (l >= MAX_LINELEN)
|
||||
hl[MAX_LINELEN-1] = '\0';
|
||||
if (l == 0 || hl[0] == ' ') {
|
||||
if (l == 0) {
|
||||
free(hl);
|
||||
continue;
|
||||
}
|
||||
state->history[hi++] = hl;
|
||||
}
|
||||
fclose(fp);
|
||||
state->cur_history = state->cnt_history = hi;
|
||||
state->cnt_history = hi;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1043,19 +1053,27 @@ static void remember_in_history(const char *str)
|
||||
|
||||
if (!(state->flags & DO_HISTORY))
|
||||
return;
|
||||
|
||||
if (str[0] == '\0')
|
||||
return;
|
||||
i = state->cnt_history;
|
||||
free(state->history[MAX_HISTORY]);
|
||||
state->history[MAX_HISTORY] = NULL;
|
||||
/* After max history, remove the oldest command */
|
||||
/* Don't save dupes */
|
||||
if (i && strcmp(state->history[i-1], str) == 0)
|
||||
return;
|
||||
|
||||
free(state->history[MAX_HISTORY]); /* redundant, paranoia */
|
||||
state->history[MAX_HISTORY] = NULL; /* redundant, paranoia */
|
||||
|
||||
/* If history[] is full, remove the oldest command */
|
||||
/* we need to keep history[MAX_HISTORY] empty, hence >=, not > */
|
||||
if (i >= MAX_HISTORY) {
|
||||
free(state->history[0]);
|
||||
for (i = 0; i < MAX_HISTORY-1; i++)
|
||||
state->history[i] = state->history[i+1];
|
||||
/* i == MAX_HISTORY-1 */
|
||||
}
|
||||
// Maybe "if (!i || strcmp(history[i-1], command) != 0) ..."
|
||||
// (i.e. do not save dups?)
|
||||
/* i <= MAX_HISTORY-1 */
|
||||
state->history[i++] = xstrdup(str);
|
||||
/* i <= MAX_HISTORY */
|
||||
state->cur_history = i;
|
||||
state->cnt_history = i;
|
||||
#if ENABLE_FEATURE_EDITING_SAVEHISTORY
|
||||
@@ -1397,6 +1415,10 @@ int FAST_FUNC read_line_input(const char *prompt, char *command, int maxsize, li
|
||||
if ((state->flags & SAVE_HISTORY) && state->hist_file)
|
||||
load_history(state->hist_file);
|
||||
#endif
|
||||
#if MAX_HISTORY > 0
|
||||
if (state->flags & DO_HISTORY)
|
||||
state->cur_history = state->cnt_history;
|
||||
#endif
|
||||
|
||||
/* prepare before init handlers */
|
||||
cmdedit_y = 0; /* quasireal y, not true if line > xt*yt */
|
||||
@@ -1432,6 +1454,13 @@ int FAST_FUNC read_line_input(const char *prompt, char *command, int maxsize, li
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
#if 0
|
||||
for (ic = 0; ic <= MAX_HISTORY; ic++)
|
||||
bb_error_msg("history[%d]:'%s'", ic, state->history[ic]);
|
||||
bb_error_msg("cur_history:%d cnt_history:%d", state->cur_history, state->cnt_history);
|
||||
#endif
|
||||
|
||||
/* Print out the command prompt */
|
||||
parse_and_put_prompt(prompt);
|
||||
|
||||
@@ -1540,11 +1569,8 @@ int FAST_FUNC read_line_input(const char *prompt, char *command, int maxsize, li
|
||||
vi_case(CTRL('P')|vbit:)
|
||||
vi_case('k'|vbit:)
|
||||
/* Control-p -- Get previous command from history */
|
||||
if ((state->flags & DO_HISTORY) && state->cur_history > 0) {
|
||||
get_previous_history();
|
||||
if (get_previous_history())
|
||||
goto rewrite_line;
|
||||
}
|
||||
beep();
|
||||
break;
|
||||
#endif
|
||||
|
||||
@@ -1733,10 +1759,8 @@ int FAST_FUNC read_line_input(const char *prompt, char *command, int maxsize, li
|
||||
#if MAX_HISTORY > 0
|
||||
case 'A':
|
||||
/* Up Arrow -- Get previous command from history */
|
||||
if ((state->flags & DO_HISTORY) && state->cur_history > 0) {
|
||||
get_previous_history();
|
||||
if (get_previous_history())
|
||||
goto rewrite_line;
|
||||
}
|
||||
beep();
|
||||
break;
|
||||
case 'B':
|
||||
@@ -1746,7 +1770,7 @@ int FAST_FUNC read_line_input(const char *prompt, char *command, int maxsize, li
|
||||
rewrite_line:
|
||||
/* Rewrite the line with the selected history item */
|
||||
/* change command */
|
||||
command_len = strlen(strcpy(command, state->history[state->cur_history]));
|
||||
command_len = strlen(strcpy(command, state->history[state->cur_history] ? : ""));
|
||||
/* redraw and go to eol (bol, in vi */
|
||||
redraw(cmdedit_y, (state->flags & VI_MODE) ? 9999 : 0);
|
||||
break;
|
||||
|
||||
@@ -32,16 +32,16 @@
|
||||
|
||||
void FAST_FUNC setup_environment(const char *shell, int clear_env, int change_env, const struct passwd *pw)
|
||||
{
|
||||
/* Change the current working directory to be the home directory
|
||||
* of the user */
|
||||
if (chdir(pw->pw_dir)) {
|
||||
xchdir("/");
|
||||
bb_error_msg("can't chdir to home directory '%s'", pw->pw_dir);
|
||||
}
|
||||
|
||||
if (clear_env) {
|
||||
const char *term;
|
||||
|
||||
/* Change the current working directory to be the home directory
|
||||
* of the user */
|
||||
if (chdir(pw->pw_dir)) {
|
||||
xchdir("/");
|
||||
bb_error_msg("can't chdir to home directory '%s'", pw->pw_dir);
|
||||
}
|
||||
|
||||
/* Leave TERM unchanged. Set HOME, SHELL, USER, LOGNAME, PATH.
|
||||
Unset all other environment variables. */
|
||||
term = getenv("TERM");
|
||||
|
||||
@@ -125,6 +125,7 @@ int FAST_FUNC run_nofork_applet_prime(struct nofork_save_area *old, int applet_n
|
||||
int rc, argc;
|
||||
|
||||
applet_name = APPLET_NAME(applet_no);
|
||||
|
||||
xfunc_error_retval = EXIT_FAILURE;
|
||||
|
||||
/* Special flag for xfunc_die(). If xfunc will "die"
|
||||
@@ -132,7 +133,30 @@ int FAST_FUNC run_nofork_applet_prime(struct nofork_save_area *old, int applet_n
|
||||
* die_sleep and longjmp here instead. */
|
||||
die_sleep = -1;
|
||||
|
||||
/* option_mask32 = 0; - not needed */
|
||||
/* In case getopt() or getopt32() was already called:
|
||||
* reset the libc getopt() function, which keeps internal state.
|
||||
*
|
||||
* BSD-derived getopt() functions require that optind be set to 1 in
|
||||
* order to reset getopt() state. This used to be generally accepted
|
||||
* way of resetting getopt(). However, glibc's getopt()
|
||||
* has additional getopt() state beyond optind, and requires that
|
||||
* optind be set to zero to reset its state. So the unfortunate state of
|
||||
* affairs is that BSD-derived versions of getopt() misbehave if
|
||||
* optind is set to 0 in order to reset getopt(), and glibc's getopt()
|
||||
* will core dump if optind is set 1 in order to reset getopt().
|
||||
*
|
||||
* More modern versions of BSD require that optreset be set to 1 in
|
||||
* order to reset getopt(). Sigh. Standards, anyone?
|
||||
*/
|
||||
#ifdef __GLIBC__
|
||||
optind = 0;
|
||||
#else /* BSD style */
|
||||
optind = 1;
|
||||
/* optreset = 1; */
|
||||
#endif
|
||||
/* optarg = NULL; opterr = 1; optopt = 63; - do we need this too? */
|
||||
/* (values above are what they initialized to in glibc and uclibc) */
|
||||
/* option_mask32 = 0; - not needed, no applet depends on it being 0 */
|
||||
|
||||
argc = 1;
|
||||
while (argv[argc])
|
||||
@@ -161,8 +185,16 @@ int FAST_FUNC run_nofork_applet_prime(struct nofork_save_area *old, int applet_n
|
||||
rc = 0;
|
||||
}
|
||||
|
||||
/* Restoring globals */
|
||||
/* Restoring some globals */
|
||||
restore_nofork_data(old);
|
||||
|
||||
/* Other globals can be simply reset to defaults */
|
||||
#ifdef __GLIBC__
|
||||
optind = 0;
|
||||
#else /* BSD style */
|
||||
optind = 1;
|
||||
#endif
|
||||
|
||||
return rc & 0xff; /* don't confuse people with "exitcodes" >255 */
|
||||
}
|
||||
|
||||
|
||||
+10
-9
@@ -93,6 +93,7 @@ int crontab_main(int argc UNUSED_PARAM, char **argv)
|
||||
char *new_fname;
|
||||
char *user_name; /* -u USER */
|
||||
int fd;
|
||||
int src_fd;
|
||||
int opt_ler;
|
||||
|
||||
/* file [opts] Replace crontab from file
|
||||
@@ -144,15 +145,15 @@ int crontab_main(int argc UNUSED_PARAM, char **argv)
|
||||
bb_show_usage();
|
||||
|
||||
/* Read replacement file under user's UID/GID/group vector */
|
||||
src_fd = STDIN_FILENO;
|
||||
if (!opt_ler) { /* Replace? */
|
||||
if (!argv[0])
|
||||
bb_show_usage();
|
||||
if (NOT_LONE_DASH(argv[0])) {
|
||||
fd = open_as_user(pas, argv[0]);
|
||||
if (fd < 0)
|
||||
src_fd = open_as_user(pas, argv[0]);
|
||||
if (src_fd < 0)
|
||||
bb_error_msg_and_die("user %s cannot read %s",
|
||||
pas->pw_name, argv[0]);
|
||||
xmove_fd(fd, STDIN_FILENO);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -180,23 +181,23 @@ int crontab_main(int argc UNUSED_PARAM, char **argv)
|
||||
tmp_fname = xasprintf("%s.%u", crontab_dir, (unsigned)getpid());
|
||||
/* No O_EXCL: we don't want to be stuck if earlier crontabs
|
||||
* were killed, leaving stale temp file behind */
|
||||
fd = xopen3(tmp_fname, O_RDWR|O_CREAT|O_TRUNC, 0600);
|
||||
xmove_fd(fd, STDIN_FILENO);
|
||||
fchown(STDIN_FILENO, pas->pw_uid, pas->pw_gid);
|
||||
src_fd = xopen3(tmp_fname, O_RDWR|O_CREAT|O_TRUNC, 0600);
|
||||
fchown(src_fd, pas->pw_uid, pas->pw_gid);
|
||||
fd = open(pas->pw_name, O_RDONLY);
|
||||
if (fd >= 0) {
|
||||
bb_copyfd_eof(fd, STDIN_FILENO);
|
||||
bb_copyfd_eof(fd, src_fd);
|
||||
close(fd);
|
||||
xlseek(src_fd, 0, SEEK_SET);
|
||||
}
|
||||
close_on_exec_on(src_fd); /* don't want editor to see this fd */
|
||||
edit_file(pas, tmp_fname);
|
||||
xlseek(STDIN_FILENO, 0, SEEK_SET);
|
||||
/* fall through */
|
||||
|
||||
case 0: /* Replace (no -l, -e, or -r were given) */
|
||||
new_fname = xasprintf("%s.new", pas->pw_name);
|
||||
fd = open(new_fname, O_WRONLY|O_CREAT|O_TRUNC|O_APPEND, 0600);
|
||||
if (fd >= 0) {
|
||||
bb_copyfd_eof(STDIN_FILENO, fd);
|
||||
bb_copyfd_eof(src_fd, fd);
|
||||
close(fd);
|
||||
xrename(new_fname, pas->pw_name);
|
||||
} else {
|
||||
|
||||
+65
-55
@@ -1059,8 +1059,9 @@ arch_apply_relocation(struct obj_file *f,
|
||||
|
||||
case R_68K_PC8:
|
||||
v -= dot;
|
||||
if ((ElfW(Sword))v > 0x7f ||
|
||||
(ElfW(Sword))v < -(ElfW(Sword))0x80) {
|
||||
if ((ElfW(Sword))v > 0x7f
|
||||
|| (ElfW(Sword))v < -(ElfW(Sword))0x80
|
||||
) {
|
||||
ret = obj_reloc_overflow;
|
||||
}
|
||||
*(char *)loc = v;
|
||||
@@ -1068,8 +1069,9 @@ arch_apply_relocation(struct obj_file *f,
|
||||
|
||||
case R_68K_PC16:
|
||||
v -= dot;
|
||||
if ((ElfW(Sword))v > 0x7fff ||
|
||||
(ElfW(Sword))v < -(ElfW(Sword))0x8000) {
|
||||
if ((ElfW(Sword))v > 0x7fff
|
||||
|| (ElfW(Sword))v < -(ElfW(Sword))0x8000
|
||||
) {
|
||||
ret = obj_reloc_overflow;
|
||||
}
|
||||
*(short *)loc = v;
|
||||
@@ -1208,8 +1210,9 @@ arch_apply_relocation(struct obj_file *f,
|
||||
{
|
||||
Elf32_Addr word;
|
||||
|
||||
if ((Elf32_Sword)v > 0x7fff ||
|
||||
(Elf32_Sword)v < -(Elf32_Sword)0x8000) {
|
||||
if ((Elf32_Sword)v > 0x7fff
|
||||
|| (Elf32_Sword)v < -(Elf32_Sword)0x8000
|
||||
) {
|
||||
ret = obj_reloc_overflow;
|
||||
}
|
||||
|
||||
@@ -1238,8 +1241,9 @@ arch_apply_relocation(struct obj_file *f,
|
||||
Elf32_Addr word;
|
||||
|
||||
v -= dot + 4;
|
||||
if ((Elf32_Sword)v > 0x7fff ||
|
||||
(Elf32_Sword)v < -(Elf32_Sword)0x8000) {
|
||||
if ((Elf32_Sword)v > 0x7fff
|
||||
|| (Elf32_Sword)v < -(Elf32_Sword)0x8000
|
||||
) {
|
||||
ret = obj_reloc_overflow;
|
||||
}
|
||||
|
||||
@@ -1253,9 +1257,10 @@ arch_apply_relocation(struct obj_file *f,
|
||||
Elf32_Addr word, gp;
|
||||
/* get _gp */
|
||||
gp = obj_symbol_final_value(f, obj_find_symbol(f, SPFX "_gp"));
|
||||
v-=gp;
|
||||
if ((Elf32_Sword)v > 0x7fff ||
|
||||
(Elf32_Sword)v < -(Elf32_Sword)0x8000) {
|
||||
v -= gp;
|
||||
if ((Elf32_Sword)v > 0x7fff
|
||||
|| (Elf32_Sword)v < -(Elf32_Sword)0x8000
|
||||
) {
|
||||
ret = obj_reloc_overflow;
|
||||
}
|
||||
|
||||
@@ -2132,7 +2137,6 @@ obj_find_symbol(struct obj_file *f, const char *name)
|
||||
for (sym = f->symtab[hash]; sym; sym = sym->next)
|
||||
if (f->symbol_cmp(sym->name, name) == 0)
|
||||
return sym;
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
@@ -2141,12 +2145,10 @@ static ElfW(Addr) obj_symbol_final_value(struct obj_file * f, struct obj_symbol
|
||||
if (sym) {
|
||||
if (sym->secidx >= SHN_LORESERVE)
|
||||
return sym->value;
|
||||
|
||||
return sym->value + f->sections[sym->secidx]->header.sh_addr;
|
||||
} else {
|
||||
/* As a special case, a NULL sym has value zero. */
|
||||
return 0;
|
||||
}
|
||||
/* As a special case, a NULL sym has value zero. */
|
||||
return 0;
|
||||
}
|
||||
|
||||
static struct obj_section *obj_find_section(struct obj_file *f, const char *name)
|
||||
@@ -2156,7 +2158,6 @@ static struct obj_section *obj_find_section(struct obj_file *f, const char *name
|
||||
for (i = 0; i < n; ++i)
|
||||
if (strcmp(f->sections[i]->name, name) == 0)
|
||||
return f->sections[i];
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
@@ -2167,9 +2168,11 @@ static int obj_load_order_prio(struct obj_section *a)
|
||||
af = a->header.sh_flags;
|
||||
|
||||
ac = 0;
|
||||
if (a->name[0] != '.' || strlen(a->name) != 10 ||
|
||||
strcmp(a->name + 5, ".init"))
|
||||
if (a->name[0] != '.' || strlen(a->name) != 10
|
||||
|| strcmp(a->name + 5, ".init") != 0
|
||||
) {
|
||||
ac |= 32;
|
||||
}
|
||||
if (af & SHF_ALLOC)
|
||||
ac |= 16;
|
||||
if (!(af & SHF_WRITE))
|
||||
@@ -2212,7 +2215,7 @@ static struct obj_section *obj_create_alloced_section(struct obj_file *f,
|
||||
sec->name = name;
|
||||
sec->idx = newidx;
|
||||
if (size)
|
||||
sec->contents = xmalloc(size);
|
||||
sec->contents = xzalloc(size);
|
||||
|
||||
obj_insert_section_load_order(f, sec);
|
||||
|
||||
@@ -2227,7 +2230,7 @@ static struct obj_section *obj_create_alloced_section_first(struct obj_file *f,
|
||||
int newidx = f->header.e_shnum++;
|
||||
struct obj_section *sec;
|
||||
|
||||
f->sections = xrealloc(f->sections, (newidx + 1) * sizeof(sec));
|
||||
f->sections = xrealloc_vector(f->sections, 2, newidx);
|
||||
f->sections[newidx] = sec = arch_new_section();
|
||||
|
||||
sec->header.sh_type = SHT_PROGBITS;
|
||||
@@ -2237,7 +2240,7 @@ static struct obj_section *obj_create_alloced_section_first(struct obj_file *f,
|
||||
sec->name = name;
|
||||
sec->idx = newidx;
|
||||
if (size)
|
||||
sec->contents = xmalloc(size);
|
||||
sec->contents = xzalloc(size);
|
||||
|
||||
sec->load_next = f->load_order;
|
||||
f->load_order = sec;
|
||||
@@ -2689,8 +2692,7 @@ static void new_get_kernel_symbols(void)
|
||||
/* Collect the modules' symbols. */
|
||||
|
||||
if (nmod) {
|
||||
ext_modules = modules = xmalloc(nmod * sizeof(*modules));
|
||||
memset(modules, 0, nmod * sizeof(*modules));
|
||||
ext_modules = modules = xzalloc(nmod * sizeof(*modules));
|
||||
for (i = 0, mn = module_names, m = modules;
|
||||
i < nmod; ++i, ++m, mn += strlen(mn) + 1) {
|
||||
struct new_module_info info;
|
||||
@@ -2770,13 +2772,14 @@ static int new_is_kernel_checksummed(void)
|
||||
}
|
||||
|
||||
|
||||
static void new_create_this_module(struct obj_file *f, const char *m_name)
|
||||
static void new_create_this_module(struct obj_file *f, const char *m_name)
|
||||
{
|
||||
struct obj_section *sec;
|
||||
|
||||
sec = obj_create_alloced_section_first(f, ".this", tgt_sizeof_long,
|
||||
sizeof(struct new_module));
|
||||
memset(sec->contents, 0, sizeof(struct new_module));
|
||||
/* done by obj_create_alloced_section_first: */
|
||||
/*memset(sec->contents, 0, sizeof(struct new_module));*/
|
||||
|
||||
obj_add_symbol(f, SPFX "__this_module", -1,
|
||||
ELF_ST_INFO(STB_LOCAL, STT_OBJECT), sec->idx, 0,
|
||||
@@ -2856,18 +2859,19 @@ static int new_create_module_ksymtab(struct obj_file *f)
|
||||
/* We don't want to export symbols residing in sections that
|
||||
aren't loaded. There are a number of these created so that
|
||||
we make sure certain module options don't appear twice. */
|
||||
|
||||
loaded = alloca(sizeof(int) * (i = f->header.e_shnum));
|
||||
i = f->header.e_shnum;
|
||||
loaded = alloca(sizeof(int) * i);
|
||||
while (--i >= 0)
|
||||
loaded[i] = (f->sections[i]->header.sh_flags & SHF_ALLOC) != 0;
|
||||
|
||||
for (nsyms = i = 0; i < HASH_BUCKETS; ++i) {
|
||||
struct obj_symbol *sym;
|
||||
for (sym = f->symtab[i]; sym; sym = sym->next)
|
||||
for (sym = f->symtab[i]; sym; sym = sym->next) {
|
||||
if (ELF_ST_BIND(sym->info) != STB_LOCAL
|
||||
&& sym->secidx <= SHN_HIRESERVE
|
||||
&& (sym->secidx >= SHN_LORESERVE
|
||||
|| loaded[sym->secidx])) {
|
||||
|| loaded[sym->secidx])
|
||||
) {
|
||||
ElfW(Addr) ofs = nsyms * 2 * tgt_sizeof_void_p;
|
||||
|
||||
obj_symbol_patch(f, sec->idx, ofs, sym);
|
||||
@@ -2876,6 +2880,7 @@ static int new_create_module_ksymtab(struct obj_file *f)
|
||||
|
||||
nsyms++;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
obj_extend_section(sec, nsyms * 2 * tgt_sizeof_char_p);
|
||||
@@ -2934,9 +2939,11 @@ new_init_module(const char *m_name, struct obj_file *f, unsigned long m_size)
|
||||
}
|
||||
sec = obj_find_section(f, ".data.init");
|
||||
if (sec) {
|
||||
if (!module->runsize ||
|
||||
module->runsize > sec->header.sh_addr - m_addr)
|
||||
if (!module->runsize
|
||||
|| module->runsize > sec->header.sh_addr - m_addr
|
||||
) {
|
||||
module->runsize = sec->header.sh_addr - m_addr;
|
||||
}
|
||||
}
|
||||
sec = obj_find_section(f, ARCHDATA_SEC_NAME);
|
||||
if (sec && sec->header.sh_size) {
|
||||
@@ -3083,9 +3090,9 @@ static void obj_allocate_commons(struct obj_file *f)
|
||||
if (i == f->header.e_shnum) {
|
||||
struct obj_section *sec;
|
||||
|
||||
f->header.e_shnum++;
|
||||
f->sections = xrealloc_vector(f->sections, 2, i);
|
||||
f->sections[i] = sec = arch_new_section();
|
||||
f->header.e_shnum = i + 1;
|
||||
|
||||
sec->header.sh_type = SHT_PROGBITS;
|
||||
sec->header.sh_flags = SHF_WRITE | SHF_ALLOC;
|
||||
@@ -3124,12 +3131,9 @@ static void obj_allocate_commons(struct obj_file *f)
|
||||
for (i = 0; i < f->header.e_shnum; ++i) {
|
||||
struct obj_section *s = f->sections[i];
|
||||
if (s->header.sh_type == SHT_NOBITS) {
|
||||
s->contents = NULL;
|
||||
if (s->header.sh_size != 0)
|
||||
s->contents = memset(xmalloc(s->header.sh_size),
|
||||
0, s->header.sh_size);
|
||||
else
|
||||
s->contents = NULL;
|
||||
|
||||
s->contents = xzalloc(s->header.sh_size),
|
||||
s->header.sh_type = SHT_PROGBITS;
|
||||
}
|
||||
}
|
||||
@@ -3222,8 +3226,8 @@ static int obj_relocate(struct obj_file *f, ElfW(Addr) base)
|
||||
#if SHT_RELM == SHT_RELA
|
||||
#if defined(__alpha__) && defined(AXP_BROKEN_GAS)
|
||||
/* Work around a nasty GAS bug, that is fixed as of 2.7.0.9. */
|
||||
if (!extsym || !extsym->st_name ||
|
||||
ELF_ST_BIND(extsym->st_info) != STB_LOCAL)
|
||||
if (!extsym || !extsym->st_name
|
||||
|| ELF_ST_BIND(extsym->st_info) != STB_LOCAL)
|
||||
#endif
|
||||
value += rel->r_addend;
|
||||
#endif
|
||||
@@ -3329,16 +3333,17 @@ static struct obj_file *obj_load(FILE *fp, int loadprogbits UNUSED_PARAM)
|
||||
}
|
||||
|
||||
if (f->header.e_ident[EI_MAG0] != ELFMAG0
|
||||
|| f->header.e_ident[EI_MAG1] != ELFMAG1
|
||||
|| f->header.e_ident[EI_MAG2] != ELFMAG2
|
||||
|| f->header.e_ident[EI_MAG3] != ELFMAG3) {
|
||||
|| f->header.e_ident[EI_MAG1] != ELFMAG1
|
||||
|| f->header.e_ident[EI_MAG2] != ELFMAG2
|
||||
|| f->header.e_ident[EI_MAG3] != ELFMAG3
|
||||
) {
|
||||
bb_error_msg_and_die("not an ELF file");
|
||||
}
|
||||
if (f->header.e_ident[EI_CLASS] != ELFCLASSM
|
||||
|| f->header.e_ident[EI_DATA] != (BB_BIG_ENDIAN
|
||||
? ELFDATA2MSB : ELFDATA2LSB)
|
||||
|| f->header.e_ident[EI_VERSION] != EV_CURRENT
|
||||
|| !MATCH_MACHINE(f->header.e_machine)) {
|
||||
|| f->header.e_ident[EI_DATA] != (BB_BIG_ENDIAN ? ELFDATA2MSB : ELFDATA2LSB)
|
||||
|| f->header.e_ident[EI_VERSION] != EV_CURRENT
|
||||
|| !MATCH_MACHINE(f->header.e_machine)
|
||||
) {
|
||||
bb_error_msg_and_die("ELF file not for this architecture");
|
||||
}
|
||||
if (f->header.e_type != ET_REL) {
|
||||
@@ -3354,8 +3359,10 @@ static struct obj_file *obj_load(FILE *fp, int loadprogbits UNUSED_PARAM)
|
||||
}
|
||||
|
||||
shnum = f->header.e_shnum;
|
||||
f->sections = xmalloc(sizeof(struct obj_section *) * shnum);
|
||||
memset(f->sections, 0, sizeof(struct obj_section *) * shnum);
|
||||
/* Growth of ->sections vector will be done by
|
||||
* xrealloc_vector(..., 2, ...), therefore we must allocate
|
||||
* at least 2^2 = 4 extra elements here. */
|
||||
f->sections = xzalloc(sizeof(f->sections[0]) * (shnum + 4));
|
||||
|
||||
section_headers = alloca(sizeof(ElfW(Shdr)) * shnum);
|
||||
fseek(fp, f->header.e_shoff, SEEK_SET);
|
||||
@@ -3391,14 +3398,13 @@ static struct obj_file *obj_load(FILE *fp, int loadprogbits UNUSED_PARAM)
|
||||
case SHT_SYMTAB:
|
||||
case SHT_STRTAB:
|
||||
case SHT_RELM:
|
||||
sec->contents = NULL;
|
||||
if (sec->header.sh_size > 0) {
|
||||
sec->contents = xmalloc(sec->header.sh_size);
|
||||
sec->contents = xzalloc(sec->header.sh_size);
|
||||
fseek(fp, sec->header.sh_offset, SEEK_SET);
|
||||
if (fread(sec->contents, sec->header.sh_size, 1, fp) != 1) {
|
||||
bb_perror_msg_and_die("error reading ELF section data");
|
||||
}
|
||||
} else {
|
||||
sec->contents = NULL;
|
||||
}
|
||||
break;
|
||||
|
||||
@@ -3860,16 +3866,20 @@ static void print_load_map(struct obj_file *f)
|
||||
for (nsyms = i = 0; i < HASH_BUCKETS; ++i)
|
||||
for (sym = f->symtab[i]; sym; sym = sym->next)
|
||||
if (sym->secidx <= SHN_HIRESERVE
|
||||
&& (sym->secidx >= SHN_LORESERVE || loaded[sym->secidx]))
|
||||
&& (sym->secidx >= SHN_LORESERVE || loaded[sym->secidx])
|
||||
) {
|
||||
++nsyms;
|
||||
}
|
||||
|
||||
all = alloca(nsyms * sizeof(struct obj_symbol *));
|
||||
|
||||
for (i = 0, p = all; i < HASH_BUCKETS; ++i)
|
||||
for (sym = f->symtab[i]; sym; sym = sym->next)
|
||||
if (sym->secidx <= SHN_HIRESERVE
|
||||
&& (sym->secidx >= SHN_LORESERVE || loaded[sym->secidx]))
|
||||
&& (sym->secidx >= SHN_LORESERVE || loaded[sym->secidx])
|
||||
) {
|
||||
*p++ = sym;
|
||||
}
|
||||
|
||||
/* And list them. */
|
||||
printf("\nSymbols:\n");
|
||||
@@ -4265,7 +4275,7 @@ static int insmod_ng_main(int argc UNUSED_PARAM, char **argv)
|
||||
}
|
||||
#else
|
||||
len = MAXINT(ssize_t);
|
||||
map = xmalloc_open_read_close(filename, &len);
|
||||
map = xmalloc_xopen_read_close(filename, &len);
|
||||
#endif
|
||||
|
||||
if (init_module(map, len, options) != 0)
|
||||
|
||||
+4
-4
@@ -263,9 +263,9 @@ static int FAST_FUNC include_conf_dir_act(const char *filename UNUSED_PARAM,
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
static int include_conf_recursive(struct include_conf_t *conf, const char *filename)
|
||||
static int include_conf_recursive(struct include_conf_t *conf, const char *filename, int flags)
|
||||
{
|
||||
return recursive_action(filename, ACTION_RECURSE,
|
||||
return recursive_action(filename, ACTION_RECURSE | flags,
|
||||
include_conf_file_act,
|
||||
include_conf_dir_act,
|
||||
conf, 1);
|
||||
@@ -362,7 +362,7 @@ static int FAST_FUNC include_conf_file_act(const char *filename,
|
||||
char *includefile;
|
||||
|
||||
includefile = skip_whitespace(line_buffer + 8);
|
||||
include_conf_recursive(conf, includefile);
|
||||
include_conf_recursive(conf, includefile, 0);
|
||||
} else if (ENABLE_FEATURE_MODPROBE_BLACKLIST &&
|
||||
(is_conf_command(line_buffer, "blacklist"))) {
|
||||
char *mod;
|
||||
@@ -559,7 +559,7 @@ static struct dep_t *build_dep(void)
|
||||
if (ENABLE_FEATURE_2_6_MODULES) {
|
||||
if (include_conf_file(&conf, "/etc/modprobe.conf"))
|
||||
r = TRUE;
|
||||
if (include_conf_recursive(&conf, "/etc/modprobe.d"))
|
||||
if (include_conf_recursive(&conf, "/etc/modprobe.d", ACTION_QUIET))
|
||||
r = TRUE;
|
||||
}
|
||||
if (ENABLE_FEATURE_2_4_MODULES && !r)
|
||||
|
||||
+1
-1
@@ -31,7 +31,7 @@ static int NORETURN ip_print_help(char **argv UNUSED_PARAM)
|
||||
|
||||
static int ip_do(int (*ip_func)(char **argv), char **argv)
|
||||
{
|
||||
argv = ip_parse_common_args(argv);
|
||||
argv = ip_parse_common_args(argv + 1);
|
||||
return ip_func(argv);
|
||||
}
|
||||
|
||||
|
||||
@@ -6,7 +6,6 @@
|
||||
*
|
||||
* Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
|
||||
*
|
||||
*
|
||||
* Changes:
|
||||
*
|
||||
* Rani Assaf <rani@magic.metawire.com> 980929: resolve addresses
|
||||
@@ -18,10 +17,52 @@
|
||||
#include <net/if.h>
|
||||
#include <net/if_arp.h>
|
||||
#include <asm/types.h>
|
||||
|
||||
#ifndef __constant_htons
|
||||
#define __constant_htons htons
|
||||
#endif
|
||||
#include <linux/if_tunnel.h>
|
||||
|
||||
// FYI: #define SIOCDEVPRIVATE 0x89F0
|
||||
|
||||
/* From linux/if_tunnel.h. #including it proved troublesome
|
||||
* (redefiniton errors due to name collisions in linux/ and net[inet]/) */
|
||||
#define SIOCGETTUNNEL (SIOCDEVPRIVATE + 0)
|
||||
#define SIOCADDTUNNEL (SIOCDEVPRIVATE + 1)
|
||||
#define SIOCDELTUNNEL (SIOCDEVPRIVATE + 2)
|
||||
#define SIOCCHGTUNNEL (SIOCDEVPRIVATE + 3)
|
||||
//#define SIOCGETPRL (SIOCDEVPRIVATE + 4)
|
||||
//#define SIOCADDPRL (SIOCDEVPRIVATE + 5)
|
||||
//#define SIOCDELPRL (SIOCDEVPRIVATE + 6)
|
||||
//#define SIOCCHGPRL (SIOCDEVPRIVATE + 7)
|
||||
#define GRE_CSUM __constant_htons(0x8000)
|
||||
//#define GRE_ROUTING __constant_htons(0x4000)
|
||||
#define GRE_KEY __constant_htons(0x2000)
|
||||
#define GRE_SEQ __constant_htons(0x1000)
|
||||
//#define GRE_STRICT __constant_htons(0x0800)
|
||||
//#define GRE_REC __constant_htons(0x0700)
|
||||
//#define GRE_FLAGS __constant_htons(0x00F8)
|
||||
//#define GRE_VERSION __constant_htons(0x0007)
|
||||
struct ip_tunnel_parm {
|
||||
char name[IFNAMSIZ];
|
||||
int link;
|
||||
uint16_t i_flags;
|
||||
uint16_t o_flags;
|
||||
uint32_t i_key;
|
||||
uint32_t o_key;
|
||||
struct iphdr iph;
|
||||
};
|
||||
/* SIT-mode i_flags */
|
||||
//#define SIT_ISATAP 0x0001
|
||||
//struct ip_tunnel_prl {
|
||||
// uint32_t addr;
|
||||
// uint16_t flags;
|
||||
// uint16_t __reserved;
|
||||
// uint32_t datalen;
|
||||
// uint32_t __reserved2;
|
||||
// /* data follows */
|
||||
//};
|
||||
///* PRL flags */
|
||||
//#define PRL_DEFAULT 0x0001
|
||||
|
||||
#include "ip_common.h" /* #include "libbb.h" is inside */
|
||||
#include "rt_names.h"
|
||||
|
||||
@@ -259,9 +259,10 @@ int udhcpc_main(int argc UNUSED_PARAM, char **argv)
|
||||
if (opt & OPT_o)
|
||||
client_config.no_default_options = 1;
|
||||
while (list_O) {
|
||||
int n = index_in_strings(dhcp_option_strings, llist_pop(&list_O));
|
||||
char *optstr = llist_pop(&list_O);
|
||||
int n = index_in_strings(dhcp_option_strings, optstr);
|
||||
if (n < 0)
|
||||
bb_error_msg_and_die("unknown option '%s'", list_O->data);
|
||||
bb_error_msg_and_die("unknown option '%s'", optstr);
|
||||
n = dhcp_options[n].code;
|
||||
client_config.opt_mask[n >> 3] |= 1 << (n & 7);
|
||||
}
|
||||
|
||||
+13
-4
@@ -745,7 +745,7 @@ int top_main(int argc UNUSED_PARAM, char **argv)
|
||||
int iterations;
|
||||
unsigned lines, col;
|
||||
unsigned interval;
|
||||
char *sinterval;
|
||||
char *str_interval, *str_iterations;
|
||||
SKIP_FEATURE_TOPMEM(const) unsigned scan_mask = TOP_MASK;
|
||||
#if ENABLE_FEATURE_USE_TERMIOS
|
||||
struct termios new_settings;
|
||||
@@ -762,10 +762,19 @@ int top_main(int argc UNUSED_PARAM, char **argv)
|
||||
iterations = 0; /* infinite */
|
||||
|
||||
/* all args are options; -n NUM */
|
||||
opt_complementary = "-:n+";
|
||||
if (getopt32(argv, "d:n:b", &sinterval, &iterations) & OPT_d) {
|
||||
opt_complementary = "-";
|
||||
col = getopt32(argv, "d:n:b", &str_interval, &str_iterations);
|
||||
if (col & OPT_d) {
|
||||
/* work around for "-d 1" -> "-d -1" done by getopt32 */
|
||||
if (str_interval[0] == '-')
|
||||
str_interval++;
|
||||
/* Need to limit it to not overflow poll timeout */
|
||||
interval = xatou16(sinterval); // -d
|
||||
interval = xatou16(str_interval);
|
||||
}
|
||||
if (col & OPT_n) {
|
||||
if (str_iterations[0] == '-')
|
||||
str_iterations++;
|
||||
iterations = xatou(str_iterations);
|
||||
}
|
||||
|
||||
/* change to /proc */
|
||||
|
||||
+5
-2
@@ -6964,8 +6964,11 @@ tryexec(USE_FEATURE_SH_STANDALONE(int applet_no,) char *cmd, char **argv, char *
|
||||
|
||||
#if ENABLE_FEATURE_SH_STANDALONE
|
||||
if (applet_no >= 0) {
|
||||
if (APPLET_IS_NOEXEC(applet_no))
|
||||
if (APPLET_IS_NOEXEC(applet_no)) {
|
||||
while (*envp)
|
||||
putenv(*envp++);
|
||||
run_applet_no_and_exit(applet_no, argv);
|
||||
}
|
||||
/* re-exec ourselves with the new arguments */
|
||||
execve(bb_busybox_exec_path, argv, envp);
|
||||
/* If they called chroot or otherwise made the binary no longer
|
||||
@@ -12014,7 +12017,7 @@ exportcmd(int argc UNUSED_PARAM, char **argv)
|
||||
char *name;
|
||||
const char *p;
|
||||
char **aptr;
|
||||
int flag = argv[0][0] == 'r'? VREADONLY : VEXPORT;
|
||||
int flag = argv[0][0] == 'r' ? VREADONLY : VEXPORT;
|
||||
|
||||
if (nextopt("p") != 'p') {
|
||||
aptr = argptr;
|
||||
|
||||
+2
-9
@@ -142,7 +142,8 @@ static const char *normalize(const char *arg)
|
||||
* Other settings are found in global variables.
|
||||
*/
|
||||
#if !ENABLE_GETOPT_LONG
|
||||
#define generate_output(argv,argc,optstr,longopts) generate_output(argv,argc,optstr)
|
||||
#define generate_output(argv,argc,optstr,longopts) \
|
||||
generate_output(argv,argc,optstr)
|
||||
#endif
|
||||
static int generate_output(char **argv, int argc, const char *optstr, const struct option *longopts)
|
||||
{
|
||||
@@ -156,14 +157,6 @@ static int generate_output(char **argv, int argc, const char *optstr, const stru
|
||||
if (quiet_errors) /* No error reporting from getopt(3) */
|
||||
opterr = 0;
|
||||
|
||||
/* Reset getopt(3) (see libbb/getopt32.c for long rant) */
|
||||
#ifdef __GLIBC__
|
||||
optind = 0;
|
||||
#else /* BSD style */
|
||||
optind = 1;
|
||||
/* optreset = 1; */
|
||||
#endif
|
||||
|
||||
while (1) {
|
||||
opt =
|
||||
#if ENABLE_GETOPT_LONG
|
||||
|
||||
Reference in new issue
Block a user