Compare commits
11
Commits
master
...
1_13_stable
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
8f0c89e05a | ||
|
|
bc7177187f | ||
|
|
8bc376bc12 | ||
|
|
dadf7907b2 | ||
|
|
22f180fd6c | ||
|
|
f62f761936 | ||
|
|
a76f10b544 | ||
|
|
15c0b72584 | ||
|
|
ccdc13d306 | ||
|
|
ab310e1b1c | ||
|
|
1cd1012a90 |
No files matched your search
@@ -1,7 +1,7 @@
|
||||
VERSION = 1
|
||||
PATCHLEVEL = 13
|
||||
SUBLEVEL = 0
|
||||
EXTRAVERSION = .svn
|
||||
SUBLEVEL = 4
|
||||
EXTRAVERSION =
|
||||
NAME = Unnamed
|
||||
|
||||
# *DOCUMENTATION*
|
||||
|
||||
@@ -91,7 +91,7 @@ char FAST_FUNC get_header_tar(archive_handle_t *archive_handle)
|
||||
|
||||
again_after_align:
|
||||
|
||||
#if ENABLE_DESKTOP
|
||||
#if ENABLE_DESKTOP || ENABLE_FEATURE_TAR_AUTODETECT
|
||||
/* to prevent misdetection of bz2 sig */
|
||||
*(uint32_t*)(&tar) = 0;
|
||||
i = full_read(archive_handle->src_fd, &tar, 512);
|
||||
@@ -142,7 +142,7 @@ char FAST_FUNC get_header_tar(archive_handle_t *archive_handle)
|
||||
#if ENABLE_FEATURE_TAR_AUTODETECT
|
||||
char FAST_FUNC (*get_header_ptr)(archive_handle_t *);
|
||||
|
||||
USE_DESKTOP(autodetect:)
|
||||
autodetect:
|
||||
/* tar gz/bz autodetect: check for gz/bz2 magic.
|
||||
* If we see the magic, and it is the very first block,
|
||||
* we can switch to get_header_tar_gz/bz2/lzma().
|
||||
|
||||
+4
-4
@@ -591,8 +591,6 @@ static NOINLINE int writeTarFile(int tar_fd, int verboseFlag,
|
||||
struct TarBallInfo tbInfo;
|
||||
|
||||
tbInfo.hlInfoHead = NULL;
|
||||
|
||||
fchmod(tar_fd, 0644);
|
||||
tbInfo.tarFd = tar_fd;
|
||||
tbInfo.verboseFlag = verboseFlag;
|
||||
|
||||
@@ -936,8 +934,10 @@ int tar_main(int argc UNUSED_PARAM, char **argv)
|
||||
tar_handle->src_fd = fileno(tar_stream);
|
||||
tar_handle->seek = seek_by_read;
|
||||
} else {
|
||||
if (ENABLE_FEATURE_TAR_AUTODETECT && flags == O_RDONLY) {
|
||||
get_header_ptr = get_header_tar;
|
||||
if (ENABLE_FEATURE_TAR_AUTODETECT
|
||||
&& get_header_ptr == get_header_tar
|
||||
&& flags == O_RDONLY
|
||||
) {
|
||||
tar_handle->src_fd = open_zipped(tar_filename);
|
||||
if (tar_handle->src_fd < 0)
|
||||
bb_perror_msg_and_die("can't open '%s'", tar_filename);
|
||||
|
||||
+1
-1
@@ -140,7 +140,7 @@ struct BUG_cde_header_must_be_16_bytes {
|
||||
};
|
||||
|
||||
#define FIX_ENDIANNESS_CDE(cde_header) do { \
|
||||
(cde_header).formatted.cds_offset = SWAP_LE16((cde_header).formatted.cds_offset); \
|
||||
(cde_header).formatted.cds_offset = SWAP_LE32((cde_header).formatted.cds_offset); \
|
||||
} while (0)
|
||||
|
||||
enum { zip_fd = 3 };
|
||||
|
||||
@@ -17,6 +17,14 @@
|
||||
|
||||
#include "libbb.h"
|
||||
|
||||
#if !ENABLE_USE_BB_PWD_GRP
|
||||
#if defined(__UCLIBC_MAJOR__) && (__UCLIBC_MAJOR__ == 0)
|
||||
#if (__UCLIBC_MINOR__ < 9) || (__UCLIBC_MINOR__ == 9 && __UCLIBC_SUBLEVEL__ < 30)
|
||||
#error "Sorry, you need at least uClibc version 0.9.30 for id applet to build"
|
||||
#endif
|
||||
#endif
|
||||
#endif
|
||||
|
||||
enum {
|
||||
PRINT_REAL = (1 << 0),
|
||||
NAME_NOT_NUMBER = (1 << 1),
|
||||
|
||||
+11
-4
@@ -139,14 +139,14 @@ static void print_direc(char *format, unsigned fmt_length,
|
||||
char saved;
|
||||
char *have_prec, *have_width;
|
||||
|
||||
saved = format[fmt_length];
|
||||
format[fmt_length] = '\0';
|
||||
|
||||
have_prec = strstr(format, ".*");
|
||||
have_width = strchr(format, '*');
|
||||
if (have_width - 1 == have_prec)
|
||||
have_width = NULL;
|
||||
|
||||
saved = format[fmt_length];
|
||||
format[fmt_length] = '\0';
|
||||
|
||||
switch (format[fmt_length - 1]) {
|
||||
case 'c':
|
||||
printf(format, *argument);
|
||||
@@ -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;
|
||||
|
||||
+1
-1
@@ -104,7 +104,7 @@ int tail_main(int argc, char **argv)
|
||||
if (argv[1] && (argv[1][0] == '+' || argv[1][0] == '-')
|
||||
&& isdigit(argv[1][1])
|
||||
) {
|
||||
count = eat_num(&argv[1][1]);
|
||||
count = eat_num(argv[1]);
|
||||
argv++;
|
||||
argc--;
|
||||
}
|
||||
|
||||
+9
-6
@@ -392,8 +392,12 @@ static const uint16_t PRIMES[] ALIGN2 = { 251, 1021, 4093, 16381, 65521 };
|
||||
|
||||
|
||||
/* Globals. Split in two parts so that first one is addressed
|
||||
* with (mostly short) negative offsets */
|
||||
* with (mostly short) negative offsets.
|
||||
* NB: it's unsafe to put members of type "double"
|
||||
* into globals2 (gcc may fail to align them).
|
||||
*/
|
||||
struct globals {
|
||||
double t_double;
|
||||
chain beginseq, mainseq, endseq;
|
||||
chain *seq;
|
||||
node *break_ptr, *continue_ptr;
|
||||
@@ -442,16 +446,16 @@ struct globals2 {
|
||||
tsplitter exec_builtin__tspl;
|
||||
|
||||
/* biggest and least used members go last */
|
||||
double t_double;
|
||||
tsplitter fsplitter, rsplitter;
|
||||
};
|
||||
#define G1 (ptr_to_globals[-1])
|
||||
#define G (*(struct globals2 *)ptr_to_globals)
|
||||
/* For debug. nm --size-sort awk.o | grep -vi ' [tr] ' */
|
||||
/* char G1size[sizeof(G1)]; - 0x6c */
|
||||
/* char Gsize[sizeof(G)]; - 0x1cc */
|
||||
/*char G1size[sizeof(G1)]; - 0x74 */
|
||||
/*char Gsize[sizeof(G)]; - 0x1c4 */
|
||||
/* Trying to keep most of members accessible with short offsets: */
|
||||
/* char Gofs_seed[offsetof(struct globals2, evaluate__seed)]; - 0x90 */
|
||||
/*char Gofs_seed[offsetof(struct globals2, evaluate__seed)]; - 0x90 */
|
||||
#define t_double (G1.t_double )
|
||||
#define beginseq (G1.beginseq )
|
||||
#define mainseq (G1.mainseq )
|
||||
#define endseq (G1.endseq )
|
||||
@@ -479,7 +483,6 @@ struct globals2 {
|
||||
#define t_info (G.t_info )
|
||||
#define t_tclass (G.t_tclass )
|
||||
#define t_string (G.t_string )
|
||||
#define t_double (G.t_double )
|
||||
#define t_lineno (G.t_lineno )
|
||||
#define t_rollback (G.t_rollback )
|
||||
#define intvar (G.intvar )
|
||||
|
||||
+8
-1
@@ -437,6 +437,7 @@ ssize_t xsendto(int s, const void *buf, size_t len, const struct sockaddr *to,
|
||||
* Turn it on before you call bind(). */
|
||||
void setsockopt_reuseaddr(int fd) FAST_FUNC; /* On Linux this never fails. */
|
||||
int setsockopt_broadcast(int fd) FAST_FUNC;
|
||||
int setsockopt_bindtodevice(int fd, const char *iface) FAST_FUNC;
|
||||
/* NB: returns port in host byte order */
|
||||
unsigned bb_lookup_port(const char *port, const char *protocol, unsigned default_port) FAST_FUNC;
|
||||
typedef struct len_and_sockaddr {
|
||||
@@ -1274,7 +1275,13 @@ enum {
|
||||
PSSCAN_UTIME = 1 << 13,
|
||||
PSSCAN_TTY = 1 << 14,
|
||||
PSSCAN_SMAPS = (1 << 15) * ENABLE_FEATURE_TOPMEM,
|
||||
PSSCAN_ARGVN = (1 << 16) * (ENABLE_PGREP || ENABLE_PKILL || ENABLE_PIDOF),
|
||||
/* NB: used by find_pid_by_name(). Any applet using it
|
||||
* needs to be mentioned here. */
|
||||
PSSCAN_ARGVN = (1 << 16) * (ENABLE_KILLALL
|
||||
|| ENABLE_PGREP || ENABLE_PKILL
|
||||
|| ENABLE_PIDOF
|
||||
|| ENABLE_SESTATUS
|
||||
),
|
||||
USE_SELINUX(PSSCAN_CONTEXT = 1 << 17,)
|
||||
PSSCAN_START_TIME = 1 << 18,
|
||||
PSSCAN_CPU = 1 << 19,
|
||||
|
||||
+23
-16
@@ -118,18 +118,18 @@ static void message(int where, const char *fmt, ...)
|
||||
|
||||
msg[0] = '\r';
|
||||
va_start(arguments, fmt);
|
||||
l = vsnprintf(msg + 1, sizeof(msg) - 2, fmt, arguments);
|
||||
if (l > sizeof(msg) - 2)
|
||||
l = sizeof(msg) - 2;
|
||||
l = 1 + vsnprintf(msg + 1, sizeof(msg) - 2, fmt, arguments);
|
||||
if (l > sizeof(msg) - 1)
|
||||
l = sizeof(msg) - 1;
|
||||
msg[l] = '\0';
|
||||
va_end(arguments);
|
||||
|
||||
if (ENABLE_FEATURE_INIT_SYSLOG) {
|
||||
/* Log the message to syslogd */
|
||||
if (where & L_LOG) {
|
||||
/* don't print out "\r" */
|
||||
openlog(applet_name, 0, LOG_DAEMON);
|
||||
syslog(LOG_INFO, "init: %s", msg + 1);
|
||||
/* Log the message to syslogd */
|
||||
openlog("init", 0, LOG_DAEMON);
|
||||
/* don't print "\r" */
|
||||
syslog(LOG_INFO, "%s", msg + 1);
|
||||
closelog();
|
||||
}
|
||||
msg[l++] = '\n';
|
||||
@@ -209,8 +209,9 @@ static void console_init(void)
|
||||
/* Make sure fd 0,1,2 are not closed
|
||||
* (so that they won't be used by future opens) */
|
||||
bb_sanitize_stdio();
|
||||
/* Make sure init can't be blocked by writing to stderr */
|
||||
fcntl(STDERR_FILENO, F_SETFL, fcntl(STDERR_FILENO, F_GETFL) | O_NONBLOCK);
|
||||
// Users report problems
|
||||
// /* Make sure init can't be blocked by writing to stderr */
|
||||
// fcntl(STDERR_FILENO, F_SETFL, fcntl(STDERR_FILENO, F_GETFL) | O_NONBLOCK);
|
||||
}
|
||||
|
||||
s = getenv("TERM");
|
||||
@@ -670,15 +671,14 @@ static void new_init_action(uint8_t action_type, const char *command, const char
|
||||
*/
|
||||
static void parse_inittab(void)
|
||||
{
|
||||
#if ENABLE_FEATURE_USE_INITTAB
|
||||
char *token[4];
|
||||
/* order must correspond to SYSINIT..RESTART constants */
|
||||
static const char actions[] ALIGN1 =
|
||||
"sysinit\0""respawn\0""askfirst\0""wait\0""once\0"
|
||||
"ctrlaltdel\0""shutdown\0""restart\0";
|
||||
parser_t *parser = config_open2("/etc/inittab", fopen_for_read);
|
||||
|
||||
parser_t *parser = config_open2(INITTAB, fopen_for_read);
|
||||
/* No inittab file -- set up some default behavior */
|
||||
if (parser == NULL) {
|
||||
if (parser == NULL)
|
||||
#endif
|
||||
{
|
||||
/* No inittab file -- set up some default behavior */
|
||||
/* Reboot on Ctrl-Alt-Del */
|
||||
new_init_action(CTRLALTDEL, "reboot", "");
|
||||
/* Umount all filesystems on halt/reboot */
|
||||
@@ -698,11 +698,17 @@ static void parse_inittab(void)
|
||||
new_init_action(SYSINIT, INIT_SCRIPT, "");
|
||||
return;
|
||||
}
|
||||
|
||||
#if ENABLE_FEATURE_USE_INITTAB
|
||||
/* optional_tty:ignored_runlevel:action:command
|
||||
* Delims are not to be collapsed and need exactly 4 tokens
|
||||
*/
|
||||
while (config_read(parser, token, 4, 0, "#:",
|
||||
PARSE_NORMAL & ~(PARSE_TRIM | PARSE_COLLAPSE))) {
|
||||
/* order must correspond to SYSINIT..RESTART constants */
|
||||
static const char actions[] ALIGN1 =
|
||||
"sysinit\0""respawn\0""askfirst\0""wait\0""once\0"
|
||||
"ctrlaltdel\0""shutdown\0""restart\0";
|
||||
int action;
|
||||
char *tty = token[0];
|
||||
|
||||
@@ -726,6 +732,7 @@ static void parse_inittab(void)
|
||||
parser->lineno);
|
||||
}
|
||||
config_close(parser);
|
||||
#endif
|
||||
}
|
||||
|
||||
#if ENABLE_FEATURE_USE_INITTAB
|
||||
|
||||
@@ -515,6 +515,19 @@ getopt32(char **argv, const char *applet_opts, ...)
|
||||
}
|
||||
}
|
||||
|
||||
/* In case getopt32 was already called:
|
||||
* reset the libc getopt() function, which keeps internal state.
|
||||
* run_nofork_applet_prime() does this, but we might end up here
|
||||
* also via gunzip_main() -> gzip_main(). Play safe.
|
||||
*/
|
||||
#ifdef __GLIBC__
|
||||
optind = 0;
|
||||
#else /* BSD style */
|
||||
optind = 1;
|
||||
/* optreset = 1; */
|
||||
#endif
|
||||
/* optarg = NULL; opterr = 0; optopt = 0; - do we need this?? */
|
||||
|
||||
pargv = NULL;
|
||||
|
||||
/* Note: just "getopt() <= 0" will not work well for
|
||||
|
||||
@@ -1415,8 +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 */
|
||||
|
||||
@@ -7,6 +7,7 @@
|
||||
*/
|
||||
|
||||
#include <netinet/in.h>
|
||||
#include <net/if.h>
|
||||
#include "libbb.h"
|
||||
|
||||
void FAST_FUNC setsockopt_reuseaddr(int fd)
|
||||
@@ -17,6 +18,20 @@ int FAST_FUNC setsockopt_broadcast(int fd)
|
||||
{
|
||||
return setsockopt(fd, SOL_SOCKET, SO_BROADCAST, &const_int_1, sizeof(const_int_1));
|
||||
}
|
||||
int FAST_FUNC setsockopt_bindtodevice(int fd, const char *iface)
|
||||
{
|
||||
int r;
|
||||
struct ifreq ifr;
|
||||
strncpy(ifr.ifr_name, iface, IFNAMSIZ);
|
||||
/* Actually, ifr_name is at offset 0, and in practice
|
||||
* just giving char[IFNAMSIZ] instead of struct ifreq works too.
|
||||
* But just in case it's not true on some obscure arch... */
|
||||
r = setsockopt(fd, SOL_SOCKET, SO_BINDTODEVICE, &ifr, sizeof(ifr));
|
||||
if (r)
|
||||
bb_perror_msg("can't bind to interface %s", iface);
|
||||
return r;
|
||||
}
|
||||
|
||||
|
||||
void FAST_FUNC xconnect(int s, const struct sockaddr *s_addr, socklen_t addrlen)
|
||||
{
|
||||
|
||||
@@ -779,6 +779,8 @@ ForkJob(const char *user, CronLine *line, int mailFd,
|
||||
xmove_fd(mailFd, mail_filename ? 1 : 0);
|
||||
dup2(1, 2);
|
||||
}
|
||||
/* crond 3.0pl1-100 puts tasks in separate process groups */
|
||||
bb_setpgrp();
|
||||
execlp(prog, prog, cmd, arg, NULL);
|
||||
crondlog(ERR20 "can't exec, user %s cmd %s %s %s", user, prog, cmd, arg);
|
||||
if (mail_filename) {
|
||||
@@ -914,6 +916,8 @@ static void RunJob(const char *user, CronLine *line)
|
||||
if (DebugOpt) {
|
||||
crondlog(LVL5 "child running %s", DEFAULT_SHELL);
|
||||
}
|
||||
/* crond 3.0pl1-100 puts tasks in separate process groups */
|
||||
bb_setpgrp();
|
||||
execl(DEFAULT_SHELL, DEFAULT_SHELL, "-c", line->cl_Shell, NULL);
|
||||
crondlog(ERR20 "can't exec, user %s cmd %s %s %s", user,
|
||||
DEFAULT_SHELL, "-c", line->cl_Shell);
|
||||
|
||||
+3
-1
@@ -19,7 +19,9 @@ enum { STACK_SIZE = (COMMON_BUFSIZE - offsetof(struct globals, stack)) / sizeof(
|
||||
#define pointer (G.pointer )
|
||||
#define base (G.base )
|
||||
#define stack (G.stack )
|
||||
#define INIT_G() do { } while (0)
|
||||
#define INIT_G() do { \
|
||||
base = 10; \
|
||||
} while (0)
|
||||
|
||||
|
||||
static void push(double a)
|
||||
|
||||
+29
-22
@@ -51,6 +51,7 @@ extern int inotify_add_watch(int fd, const char *path, uint32_t mask);
|
||||
int inotifyd_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
|
||||
int inotifyd_main(int argc UNUSED_PARAM, char **argv)
|
||||
{
|
||||
int n;
|
||||
unsigned mask = IN_ALL_EVENTS; // assume we want all events
|
||||
struct pollfd pfd;
|
||||
char **watched = ++argv; // watched name list
|
||||
@@ -69,7 +70,6 @@ int inotifyd_main(int argc UNUSED_PARAM, char **argv)
|
||||
while (*++argv) {
|
||||
char *path = *argv;
|
||||
char *masks = strchr(path, ':');
|
||||
int wd; // watch descriptor
|
||||
// if mask is specified ->
|
||||
if (masks) {
|
||||
*masks = '\0'; // split path and mask
|
||||
@@ -83,32 +83,39 @@ int inotifyd_main(int argc UNUSED_PARAM, char **argv)
|
||||
}
|
||||
}
|
||||
// add watch
|
||||
wd = inotify_add_watch(pfd.fd, path, mask);
|
||||
if (wd < 0) {
|
||||
n = inotify_add_watch(pfd.fd, path, mask);
|
||||
if (n < 0)
|
||||
bb_perror_msg_and_die("add watch (%s) failed", path);
|
||||
// } else {
|
||||
// bb_error_msg("added %d [%s]:%4X", wd, path, mask);
|
||||
}
|
||||
//bb_error_msg("added %d [%s]:%4X", n, path, mask);
|
||||
}
|
||||
|
||||
// setup signals
|
||||
bb_signals(0
|
||||
+ (1 << SIGHUP)
|
||||
+ (1 << SIGINT)
|
||||
+ (1 << SIGTERM)
|
||||
+ (1 << SIGPIPE)
|
||||
, record_signo);
|
||||
bb_signals(BB_FATAL_SIGS, record_signo);
|
||||
|
||||
// do watch
|
||||
|
||||
// pfd.fd = fd;
|
||||
pfd.events = POLLIN;
|
||||
|
||||
while (!bb_got_signal && poll(&pfd, 1, -1) > 0) {
|
||||
while (1) {
|
||||
ssize_t len;
|
||||
void *buf;
|
||||
struct inotify_event *ie;
|
||||
|
||||
again:
|
||||
if (bb_got_signal)
|
||||
break;
|
||||
n = poll(&pfd, 1, -1);
|
||||
/* Signal interrupted us? */
|
||||
if (n < 0 && errno == EINTR)
|
||||
goto again;
|
||||
// Under Linux, above if() is not necessary.
|
||||
// Non-fatal signals, e.g. SIGCHLD, when set to SIG_DFL,
|
||||
// are not interrupting poll().
|
||||
// Thus we can just break if n <= 0 (see below),
|
||||
// because EINTR will happen only on SIGTERM et al.
|
||||
// But this might be not true under other Unixes,
|
||||
// and is generally way too subtle to depend on.
|
||||
if (n <= 0) // strange error?
|
||||
break;
|
||||
|
||||
// read out all pending events
|
||||
xioctl(pfd.fd, FIONREAD, &len);
|
||||
#define eventbuf bb_common_bufsiz1
|
||||
@@ -117,21 +124,21 @@ int inotifyd_main(int argc UNUSED_PARAM, char **argv)
|
||||
// process events. N.B. events may vary in length
|
||||
while (len > 0) {
|
||||
int i;
|
||||
char events[12];
|
||||
char events[sizeof(mask_names)];
|
||||
char *s = events;
|
||||
unsigned m = ie->mask;
|
||||
|
||||
for (i = 0; i < 12; ++i, m >>= 1) {
|
||||
if (m & 1) {
|
||||
for (i = 0; i < sizeof(mask_names)-1; ++i, m >>= 1) {
|
||||
if (m & 1)
|
||||
*s++ = mask_names[i];
|
||||
}
|
||||
}
|
||||
*s = '\0';
|
||||
// bb_error_msg("exec %s %08X\t%s\t%s\t%s", agent, ie->mask, events, watched[ie->wd], ie->len ? ie->name : "");
|
||||
//bb_error_msg("exec %s %08X\t%s\t%s\t%s", agent,
|
||||
// ie->mask, events, watched[ie->wd], ie->len ? ie->name : "");
|
||||
args[1] = events;
|
||||
args[2] = watched[ie->wd];
|
||||
args[3] = ie->len ? ie->name : NULL;
|
||||
xspawn((char **)args);
|
||||
wait4pid(xspawn((char **)args));
|
||||
// next event
|
||||
i = sizeof(struct inotify_event) + ie->len;
|
||||
len -= i;
|
||||
|
||||
+37
-20
@@ -33,7 +33,7 @@ typedef struct module_info {
|
||||
enum {
|
||||
ARG_a = (1<<0), /* All modules, ignore mods in argv */
|
||||
ARG_A = (1<<1), /* Only emit .ko that are newer than modules.dep file */
|
||||
ARG_b = (1<<2), /* not /lib/modules/$(uname -r)/ but this base-dir */
|
||||
ARG_b = (1<<2), /* base directory when modules are in staging area */
|
||||
ARG_e = (1<<3), /* with -F, print unresolved symbols */
|
||||
ARG_F = (1<<4), /* System.map that contains the symbols */
|
||||
ARG_n = (1<<5) /* dry-run, print to stdout only */
|
||||
@@ -57,7 +57,7 @@ static int FAST_FUNC parse_module(const char *fname, struct stat *sb,
|
||||
*first = info;
|
||||
|
||||
info->dnext = info->dprev = info;
|
||||
info->name = xstrdup(fname);
|
||||
info->name = xasprintf("/%s", fname);
|
||||
info->modname = filename2modname(fname, NULL);
|
||||
for (ptr = image; ptr < image + len - 10; ptr++) {
|
||||
if (strncmp(ptr, "depends=", 8) == 0) {
|
||||
@@ -123,44 +123,61 @@ static void order_dep_list(module_info *modules, module_info *start,
|
||||
}
|
||||
}
|
||||
|
||||
static void xfreopen_write(const char *file, FILE *f)
|
||||
{
|
||||
if (freopen(file, "w", f) == NULL)
|
||||
bb_perror_msg_and_die("can't open '%s'", file);
|
||||
}
|
||||
|
||||
int depmod_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
|
||||
int depmod_main(int argc UNUSED_PARAM, char **argv)
|
||||
{
|
||||
module_info *modules = NULL, *m, *dep;
|
||||
char *moddir_base = (char *)CONFIG_DEFAULT_MODULES_DIR;
|
||||
const char *moddir_base = "/";
|
||||
char *moddir, *version;
|
||||
struct utsname uts;
|
||||
int tmp;
|
||||
|
||||
getopt32(argv, "aAb:eF:n", &moddir_base, NULL);
|
||||
argv += optind;
|
||||
|
||||
/* goto modules location */
|
||||
xchdir(moddir_base);
|
||||
|
||||
/* If a version is provided, then that kernel version's module directory
|
||||
* is used, rather than the current kernel version (as returned by
|
||||
* "uname -r"). */
|
||||
xchdir(moddir_base);
|
||||
if (*argv && (sscanf(*argv, "%d.%d.%d", &tmp, &tmp, &tmp) == 3)) {
|
||||
xchdir(*argv++);
|
||||
if (*argv && sscanf(*argv, "%d.%d.%d", &tmp, &tmp, &tmp) == 3) {
|
||||
version = *argv++;
|
||||
} else {
|
||||
struct utsname uts;
|
||||
uname(&uts);
|
||||
xchdir(uts.release);
|
||||
version = uts.release;
|
||||
}
|
||||
/* If no modules are given on the command-line, -a is on per default. */
|
||||
option_mask32 |= *argv == NULL;
|
||||
moddir = concat_path_file(&CONFIG_DEFAULT_MODULES_DIR[1], version);
|
||||
|
||||
/* Scan modules */
|
||||
moddir_base = xrealloc_getcwd_or_warn(NULL);
|
||||
do {
|
||||
recursive_action((option_mask32 & ARG_a) ? moddir_base : *argv,
|
||||
ACTION_RECURSE, parse_module, NULL, &modules, 0);
|
||||
} while (!(option_mask32 & ARG_a) && *(++argv));
|
||||
if (*argv) {
|
||||
char *modfile;
|
||||
struct stat sb;
|
||||
do {
|
||||
modfile = concat_path_file(moddir, *argv);
|
||||
xstat(modfile, &sb);
|
||||
parse_module(modfile, &sb, &modules, 0);
|
||||
free(modfile);
|
||||
} while (*(++argv));
|
||||
} else {
|
||||
recursive_action(moddir, ACTION_RECURSE,
|
||||
parse_module, NULL, &modules, 0);
|
||||
}
|
||||
|
||||
/* Prepare for writing out the dep files */
|
||||
xchdir(moddir);
|
||||
if (ENABLE_FEATURE_CLEAN_UP)
|
||||
free(moddir_base);
|
||||
free(moddir);
|
||||
|
||||
/* Generate dependency and alias files */
|
||||
if (!(option_mask32 & ARG_n))
|
||||
freopen(CONFIG_DEFAULT_DEPMOD_FILE, "w", stdout);
|
||||
xfreopen_write(CONFIG_DEFAULT_DEPMOD_FILE, stdout);
|
||||
for (m = modules; m != NULL; m = m->next) {
|
||||
printf("%s:", m->name);
|
||||
|
||||
@@ -174,12 +191,12 @@ int depmod_main(int argc UNUSED_PARAM, char **argv)
|
||||
dep->dprev->dnext = dep->dnext;
|
||||
dep->dnext = dep->dprev = dep;
|
||||
}
|
||||
puts("");
|
||||
bb_putchar('\n');
|
||||
}
|
||||
|
||||
#if ENABLE_FEATURE_MODUTILS_ALIAS
|
||||
if (!(option_mask32 & ARG_n))
|
||||
freopen("modules.alias", "w", stdout);
|
||||
xfreopen_write("modules.alias", stdout);
|
||||
for (m = modules; m != NULL; m = m->next) {
|
||||
while (m->aliases) {
|
||||
printf("alias %s %s\n",
|
||||
@@ -190,7 +207,7 @@ int depmod_main(int argc UNUSED_PARAM, char **argv)
|
||||
#endif
|
||||
#if ENABLE_FEATURE_MODUTILS_SYMBOLS
|
||||
if (!(option_mask32 & ARG_n))
|
||||
freopen("modules.symbols", "w", stdout);
|
||||
xfreopen_write("modules.symbols", stdout);
|
||||
for (m = modules; m != NULL; m = m->next) {
|
||||
while (m->symbols) {
|
||||
printf("alias symbol:%s %s\n",
|
||||
|
||||
@@ -600,18 +600,22 @@ static void process_module(char *name, const char *cmdline_options)
|
||||
free(deps);
|
||||
|
||||
/* modprobe -> load it */
|
||||
if (!is_rmmod && (options && !strstr(options, "blacklist"))) {
|
||||
errno = 0;
|
||||
if (load_module(info->pathname, options) != 0) {
|
||||
if (EEXIST != errno) {
|
||||
bb_error_msg("'%s': %s",
|
||||
if (!is_rmmod) {
|
||||
if (!options || strstr(options, "blacklist") == NULL) {
|
||||
errno = 0;
|
||||
if (load_module(info->pathname, options) != 0) {
|
||||
if (EEXIST != errno) {
|
||||
bb_error_msg("'%s': %s",
|
||||
info->pathname,
|
||||
moderror(errno));
|
||||
} else {
|
||||
dbg1_error_msg("'%s': %s",
|
||||
} else {
|
||||
dbg1_error_msg("'%s': %s",
|
||||
info->pathname,
|
||||
moderror(errno));
|
||||
}
|
||||
}
|
||||
} else {
|
||||
dbg1_error_msg("'%s': blacklisted", info->pathname);
|
||||
}
|
||||
}
|
||||
ret:
|
||||
|
||||
+16
-18
@@ -2150,7 +2150,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);
|
||||
|
||||
@@ -2165,7 +2165,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;
|
||||
@@ -2175,7 +2175,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;
|
||||
@@ -2571,8 +2571,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;
|
||||
@@ -2652,13 +2651,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,
|
||||
@@ -2965,9 +2965,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;
|
||||
@@ -3006,12 +3006,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;
|
||||
}
|
||||
}
|
||||
@@ -3236,8 +3233,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);
|
||||
@@ -3273,14 +3272,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;
|
||||
|
||||
|
||||
+1
-1
@@ -71,7 +71,7 @@ char * FAST_FUNC filename2modname(const char *filename, char *modname)
|
||||
if (modname == NULL)
|
||||
modname = xmalloc(MODULE_NAME_LEN);
|
||||
from = bb_get_last_path_component_nostrip(filename);
|
||||
for (i = 0; i < MODULE_NAME_LEN && from[i] != '\0' && from[i] != '.'; i++)
|
||||
for (i = 0; i < (MODULE_NAME_LEN-1) && from[i] != '\0' && from[i] != '.'; i++)
|
||||
modname[i] = (from[i] == '-') ? '_' : from[i];
|
||||
modname[i] = 0;
|
||||
|
||||
|
||||
+3
-2
@@ -16,8 +16,9 @@
|
||||
# pragma GCC visibility push(hidden)
|
||||
#endif
|
||||
|
||||
/* As defined in linux/include/linux/module.h */
|
||||
#define MODULE_NAME_LEN 64
|
||||
/* linux/include/linux/module.h has 64, but this is also used
|
||||
* internally for the maximum alias name length, which can be quite long */
|
||||
#define MODULE_NAME_LEN 256
|
||||
|
||||
const char *moderror(int err) FAST_FUNC;
|
||||
llist_t *llist_find(llist_t *first, const char *str) FAST_FUNC;
|
||||
|
||||
+1
-2
@@ -322,8 +322,7 @@ int arping_main(int argc UNUSED_PARAM, char **argv)
|
||||
struct sockaddr_in saddr;
|
||||
int probe_fd = xsocket(AF_INET, SOCK_DGRAM, 0);
|
||||
|
||||
if (setsockopt(probe_fd, SOL_SOCKET, SO_BINDTODEVICE, device, strlen(device) + 1) == -1)
|
||||
bb_perror_msg("cannot bind to device %s", device);
|
||||
setsockopt_bindtodevice(probe_fd, device);
|
||||
memset(&saddr, 0, sizeof(saddr));
|
||||
saddr.sin_family = AF_INET;
|
||||
if (src.s_addr) {
|
||||
|
||||
+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"
|
||||
|
||||
+2
-2
@@ -572,7 +572,7 @@ static void ping4(len_and_sockaddr *lsa)
|
||||
xbind(pingsock, &source_lsa->u.sa, source_lsa->len);
|
||||
}
|
||||
if (str_I)
|
||||
setsockopt(pingsock, SOL_SOCKET, SO_BINDTODEVICE, str_I, strlen(str_I) + 1);
|
||||
setsockopt_bindtodevice(pingsock, str_I);
|
||||
|
||||
/* enable broadcast pings */
|
||||
setsockopt_broadcast(pingsock);
|
||||
@@ -622,7 +622,7 @@ static void ping6(len_and_sockaddr *lsa)
|
||||
if (source_lsa)
|
||||
xbind(pingsock, &source_lsa->u.sa, source_lsa->len);
|
||||
if (str_I)
|
||||
setsockopt(pingsock, SOL_SOCKET, SO_BINDTODEVICE, str_I, strlen(str_I) + 1);
|
||||
setsockopt_bindtodevice(pingsock, str_I);
|
||||
|
||||
#ifdef ICMP6_FILTER
|
||||
{
|
||||
|
||||
@@ -98,8 +98,8 @@ int FAST_FUNC udhcp_listen_socket(/*uint32_t ip,*/ int port, const char *inf)
|
||||
bb_perror_msg_and_die("SO_BROADCAST");
|
||||
|
||||
/* NB: bug 1032 says this doesn't work on ethernet aliases (ethN:M) */
|
||||
if (setsockopt(fd, SOL_SOCKET, SO_BINDTODEVICE, &inf, strlen(inf) + 1) == -1)
|
||||
bb_perror_msg_and_die("SO_BINDTODEVICE");
|
||||
if (setsockopt_bindtodevice(fd, inf))
|
||||
xfunc_die(); /* warning is already printed */
|
||||
|
||||
memset(&addr, 0, sizeof(addr));
|
||||
addr.sin_family = AF_INET;
|
||||
|
||||
+15
-9
@@ -417,15 +417,17 @@ int wget_main(int argc UNUSED_PARAM, char **argv)
|
||||
KEY_content_length = 1, KEY_transfer_encoding, KEY_chunked, KEY_location
|
||||
};
|
||||
enum {
|
||||
WGET_OPT_CONTINUE = 0x1,
|
||||
WGET_OPT_SPIDER = 0x2,
|
||||
WGET_OPT_QUIET = 0x4,
|
||||
WGET_OPT_OUTNAME = 0x8,
|
||||
WGET_OPT_PREFIX = 0x10,
|
||||
WGET_OPT_PROXY = 0x20,
|
||||
WGET_OPT_USER_AGENT = 0x40,
|
||||
WGET_OPT_PASSIVE = 0x80,
|
||||
WGET_OPT_HEADER = 0x100,
|
||||
WGET_OPT_CONTINUE = (1 << 0),
|
||||
WGET_OPT_SPIDER = (1 << 1),
|
||||
WGET_OPT_QUIET = (1 << 2),
|
||||
WGET_OPT_OUTNAME = (1 << 3),
|
||||
WGET_OPT_PREFIX = (1 << 4),
|
||||
WGET_OPT_PROXY = (1 << 5),
|
||||
WGET_OPT_USER_AGENT = (1 << 6),
|
||||
WGET_OPT_RETRIES = (1 << 7),
|
||||
WGET_OPT_NETWORK_READ_TIMEOUT = (1 << 8),
|
||||
WGET_OPT_PASSIVE = (1 << 9),
|
||||
WGET_OPT_HEADER = (1 << 10),
|
||||
};
|
||||
#if ENABLE_FEATURE_WGET_LONG_OPTIONS
|
||||
static const char wget_longopts[] ALIGN1 =
|
||||
@@ -437,6 +439,10 @@ int wget_main(int argc UNUSED_PARAM, char **argv)
|
||||
"directory-prefix\0" Required_argument "P"
|
||||
"proxy\0" Required_argument "Y"
|
||||
"user-agent\0" Required_argument "U"
|
||||
/* Ignored: */
|
||||
// "tries\0" Required_argument "t"
|
||||
// "timeout\0" Required_argument "T"
|
||||
/* Ignored (we always use PASV): */
|
||||
"passive-ftp\0" No_argument "\xff"
|
||||
"header\0" Required_argument "\xfe"
|
||||
;
|
||||
|
||||
+1
-1
@@ -200,7 +200,7 @@ static NOINLINE int read_cpu_jiffy(FILE *fp, jiffy_counts_t *p_jif)
|
||||
&p_jif->usr, &p_jif->nic, &p_jif->sys, &p_jif->idle,
|
||||
&p_jif->iowait, &p_jif->irq, &p_jif->softirq,
|
||||
&p_jif->steal);
|
||||
if (ret > 4) {
|
||||
if (ret >= 4) {
|
||||
p_jif->total = p_jif->usr + p_jif->nic + p_jif->sys + p_jif->idle
|
||||
+ p_jif->iowait + p_jif->irq + p_jif->softirq + p_jif->steal;
|
||||
/* procps 2.x does not count iowait as busy time */
|
||||
|
||||
+216
-120
@@ -30,7 +30,7 @@
|
||||
*/
|
||||
|
||||
/*
|
||||
* The follow should be set to reflect the type of system you have:
|
||||
* The following should be set to reflect the type of system you have:
|
||||
* JOBS -> 1 if you have Berkeley job control, 0 otherwise.
|
||||
* define SYSV if you are running under System V.
|
||||
* define DEBUG=1 to compile in debugging ('set -o debug' to turn on)
|
||||
@@ -40,6 +40,11 @@
|
||||
* a quit signal will generate a core dump.
|
||||
*/
|
||||
#define DEBUG 0
|
||||
/* Tweak debug output verbosity here */
|
||||
#define DEBUG_TIME 0
|
||||
#define DEBUG_PID 1
|
||||
#define DEBUG_SIG 1
|
||||
|
||||
#define PROFILE 0
|
||||
|
||||
#define IFS_BROKEN
|
||||
@@ -47,9 +52,9 @@
|
||||
#define JOBS ENABLE_ASH_JOB_CONTROL
|
||||
|
||||
#if DEBUG
|
||||
#ifndef _GNU_SOURCE
|
||||
#define _GNU_SOURCE
|
||||
#endif
|
||||
# ifndef _GNU_SOURCE
|
||||
# define _GNU_SOURCE
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#include "busybox.h" /* for applet_names */
|
||||
@@ -57,15 +62,15 @@
|
||||
#include <setjmp.h>
|
||||
#include <fnmatch.h>
|
||||
#if JOBS || ENABLE_ASH_READ_NCHARS
|
||||
#include <termios.h>
|
||||
# include <termios.h>
|
||||
#endif
|
||||
|
||||
#ifndef PIPE_BUF
|
||||
#define PIPE_BUF 4096 /* amount of buffering in a pipe */
|
||||
# define PIPE_BUF 4096 /* amount of buffering in a pipe */
|
||||
#endif
|
||||
|
||||
#if defined(__uClinux__)
|
||||
#error "Do not even bother, ash will not run on uClinux"
|
||||
# error "Do not even bother, ash will not run on uClinux"
|
||||
#endif
|
||||
|
||||
|
||||
@@ -76,14 +81,6 @@
|
||||
#define CMDTABLESIZE 31 /* should be prime */
|
||||
|
||||
|
||||
/* ============ Misc helpers */
|
||||
|
||||
#define xbarrier() do { __asm__ __volatile__ ("": : :"memory"); } while (0)
|
||||
|
||||
/* C99 say: "char" declaration may be signed or unsigned default */
|
||||
#define signed_char2int(sc) ((int)((signed char)sc))
|
||||
|
||||
|
||||
/* ============ Shell options */
|
||||
|
||||
static const char *const optletters_optnames[] = {
|
||||
@@ -245,7 +242,30 @@ extern struct globals_misc *const ash_ptr_to_globals_misc;
|
||||
} while (0)
|
||||
|
||||
|
||||
/* ============ DEBUG */
|
||||
#if DEBUG
|
||||
static void trace_printf(const char *fmt, ...);
|
||||
static void trace_vprintf(const char *fmt, va_list va);
|
||||
# define TRACE(param) trace_printf param
|
||||
# define TRACEV(param) trace_vprintf param
|
||||
# define close(f) do { \
|
||||
int dfd = (f); \
|
||||
if (close(dfd) < 0) \
|
||||
bb_error_msg("bug on %d: closing %d(%x)", \
|
||||
__LINE__, dfd, dfd); \
|
||||
} while (0)
|
||||
#else
|
||||
# define TRACE(param)
|
||||
# define TRACEV(param)
|
||||
#endif
|
||||
|
||||
|
||||
/* ============ Utility functions */
|
||||
#define xbarrier() do { __asm__ __volatile__ ("": : :"memory"); } while (0)
|
||||
|
||||
/* C99 say: "char" declaration may be signed or unsigned by default */
|
||||
#define signed_char2int(sc) ((int)(signed char)(sc))
|
||||
|
||||
static int isdigit_str9(const char *str)
|
||||
{
|
||||
int maxlen = 9 + 1; /* max 9 digits: 999999999 */
|
||||
@@ -284,6 +304,12 @@ raise_exception(int e)
|
||||
exception = e;
|
||||
longjmp(exception_handler->loc, 1);
|
||||
}
|
||||
#if DEBUG
|
||||
#define raise_exception(e) do { \
|
||||
TRACE(("raising exception %d on line %d\n", (e), __LINE__)); \
|
||||
raise_exception(e); \
|
||||
} while (0)
|
||||
#endif
|
||||
|
||||
/*
|
||||
* Called from trap.c when a SIGINT is received. (If the user specifies
|
||||
@@ -316,6 +342,12 @@ raise_interrupt(void)
|
||||
raise_exception(i);
|
||||
/* NOTREACHED */
|
||||
}
|
||||
#if DEBUG
|
||||
#define raise_interrupt() do { \
|
||||
TRACE(("raising interrupt on line %d\n", __LINE__)); \
|
||||
raise_interrupt(); \
|
||||
} while (0)
|
||||
#endif
|
||||
|
||||
#if ENABLE_ASH_OPTIMIZE_FOR_SIZE
|
||||
static void
|
||||
@@ -334,7 +366,9 @@ force_int_on(void)
|
||||
raise_interrupt();
|
||||
}
|
||||
#define FORCE_INT_ON force_int_on()
|
||||
#else
|
||||
|
||||
#else /* !ASH_OPTIMIZE_FOR_SIZE */
|
||||
|
||||
#define INT_ON do { \
|
||||
xbarrier(); \
|
||||
if (--suppressint == 0 && intpending) \
|
||||
@@ -346,7 +380,7 @@ force_int_on(void)
|
||||
if (intpending) \
|
||||
raise_interrupt(); \
|
||||
} while (0)
|
||||
#endif /* ASH_OPTIMIZE_FOR_SIZE */
|
||||
#endif /* !ASH_OPTIMIZE_FOR_SIZE */
|
||||
|
||||
#define SAVE_INT(v) ((v) = suppressint)
|
||||
|
||||
@@ -376,7 +410,6 @@ static void
|
||||
onsig(int signo)
|
||||
{
|
||||
gotsig[signo - 1] = 1;
|
||||
pendingsig = signo;
|
||||
|
||||
if (/* exsig || */ (signo == SIGINT && !trap[SIGINT])) {
|
||||
if (!suppressint) {
|
||||
@@ -384,6 +417,8 @@ onsig(int signo)
|
||||
raise_interrupt(); /* does not return */
|
||||
}
|
||||
intpending = 1;
|
||||
} else {
|
||||
pendingsig = signo;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -536,6 +571,7 @@ static const char dolatstr[] ALIGN1 = {
|
||||
#define NHERE 24
|
||||
#define NXHERE 25
|
||||
#define NNOT 26
|
||||
#define N_NUMBER 27
|
||||
|
||||
union node;
|
||||
|
||||
@@ -683,6 +719,12 @@ trace_printf(const char *fmt, ...)
|
||||
|
||||
if (debug != 1)
|
||||
return;
|
||||
if (DEBUG_TIME)
|
||||
fprintf(tracefile, "%u ", (int) time(NULL));
|
||||
if (DEBUG_PID)
|
||||
fprintf(tracefile, "[%u] ", (int) getpid());
|
||||
if (DEBUG_SIG)
|
||||
fprintf(tracefile, "pending s:%d i:%d(supp:%d) ", pendingsig, intpending, suppressint);
|
||||
va_start(va, fmt);
|
||||
vfprintf(tracefile, fmt, va);
|
||||
va_end(va);
|
||||
@@ -693,6 +735,12 @@ trace_vprintf(const char *fmt, va_list va)
|
||||
{
|
||||
if (debug != 1)
|
||||
return;
|
||||
if (DEBUG_TIME)
|
||||
fprintf(tracefile, "%u ", (int) time(NULL));
|
||||
if (DEBUG_PID)
|
||||
fprintf(tracefile, "[%u] ", (int) getpid());
|
||||
if (DEBUG_SIG)
|
||||
fprintf(tracefile, "pending s:%d i:%d(supp:%d) ", pendingsig, intpending, suppressint);
|
||||
vfprintf(tracefile, fmt, va);
|
||||
}
|
||||
|
||||
@@ -997,14 +1045,6 @@ showtree(union node *n)
|
||||
shtree(n, 1, NULL, stdout);
|
||||
}
|
||||
|
||||
#define TRACE(param) trace_printf param
|
||||
#define TRACEV(param) trace_vprintf param
|
||||
|
||||
#else
|
||||
|
||||
#define TRACE(param)
|
||||
#define TRACEV(param)
|
||||
|
||||
#endif /* DEBUG */
|
||||
|
||||
|
||||
@@ -3778,7 +3818,7 @@ dowait(int wait_flags, struct job *job)
|
||||
* NB: _not_ safe_waitpid, we need to detect EINTR */
|
||||
pid = waitpid(-1, &status,
|
||||
(doing_jobctl ? (wait_flags | WUNTRACED) : wait_flags));
|
||||
TRACE(("wait returns pid=%d, status=0x%x\n", pid, status));
|
||||
TRACE(("wait returns pid=%d, status=0x%x, errno=%d(%s)\n", pid, status, errno, strerror(errno)));
|
||||
|
||||
if (pid <= 0) {
|
||||
/* If we were doing blocking wait and (probably) got EINTR,
|
||||
@@ -5030,7 +5070,9 @@ redirect(union node *redir, int flags)
|
||||
if (newfd < 0) {
|
||||
/* NTOFD/NFROMFD: copy redir->ndup.dupfd to fd */
|
||||
if (redir->ndup.dupfd < 0) { /* "fd>&-" */
|
||||
close(fd);
|
||||
/* Don't want to trigger debugging */
|
||||
if (fd != -1)
|
||||
close(fd);
|
||||
} else {
|
||||
copyfd(redir->ndup.dupfd, fd | COPYFD_EXACT);
|
||||
}
|
||||
@@ -5083,7 +5125,7 @@ popredir(int drop, int restore)
|
||||
/*close(fd);*/
|
||||
copyfd(copy, fd | COPYFD_EXACT);
|
||||
}
|
||||
close(copy);
|
||||
close(copy & ~COPYFD_RESTORE);
|
||||
}
|
||||
}
|
||||
redirlist = rp->next;
|
||||
@@ -7546,43 +7588,46 @@ commandcmd(int argc UNUSED_PARAM, char **argv UNUSED_PARAM)
|
||||
|
||||
/* ============ eval.c */
|
||||
|
||||
static int funcblocksize; /* size of structures in function */
|
||||
static int funcstringsize; /* size of strings in node */
|
||||
static void *funcblock; /* block to allocate function from */
|
||||
static char *funcstring; /* block to allocate strings from */
|
||||
static int funcblocksize; /* size of structures in function */
|
||||
static int funcstringsize; /* size of strings in node */
|
||||
static void *funcblock; /* block to allocate function from */
|
||||
static char *funcstring; /* block to allocate strings from */
|
||||
|
||||
/* flags in argument to evaltree */
|
||||
#define EV_EXIT 01 /* exit after evaluating tree */
|
||||
#define EV_TESTED 02 /* exit status is checked; ignore -e flag */
|
||||
#define EV_EXIT 01 /* exit after evaluating tree */
|
||||
#define EV_TESTED 02 /* exit status is checked; ignore -e flag */
|
||||
#define EV_BACKCMD 04 /* command executing within back quotes */
|
||||
|
||||
static const short nodesize[26] = {
|
||||
SHELL_ALIGN(sizeof(struct ncmd)),
|
||||
SHELL_ALIGN(sizeof(struct npipe)),
|
||||
SHELL_ALIGN(sizeof(struct nredir)),
|
||||
SHELL_ALIGN(sizeof(struct nredir)),
|
||||
SHELL_ALIGN(sizeof(struct nredir)),
|
||||
SHELL_ALIGN(sizeof(struct nbinary)),
|
||||
SHELL_ALIGN(sizeof(struct nbinary)),
|
||||
SHELL_ALIGN(sizeof(struct nbinary)),
|
||||
SHELL_ALIGN(sizeof(struct nif)),
|
||||
SHELL_ALIGN(sizeof(struct nbinary)),
|
||||
SHELL_ALIGN(sizeof(struct nbinary)),
|
||||
SHELL_ALIGN(sizeof(struct nfor)),
|
||||
SHELL_ALIGN(sizeof(struct ncase)),
|
||||
SHELL_ALIGN(sizeof(struct nclist)),
|
||||
SHELL_ALIGN(sizeof(struct narg)),
|
||||
SHELL_ALIGN(sizeof(struct narg)),
|
||||
SHELL_ALIGN(sizeof(struct nfile)),
|
||||
SHELL_ALIGN(sizeof(struct nfile)),
|
||||
SHELL_ALIGN(sizeof(struct nfile)),
|
||||
SHELL_ALIGN(sizeof(struct nfile)),
|
||||
SHELL_ALIGN(sizeof(struct nfile)),
|
||||
SHELL_ALIGN(sizeof(struct ndup)),
|
||||
SHELL_ALIGN(sizeof(struct ndup)),
|
||||
SHELL_ALIGN(sizeof(struct nhere)),
|
||||
SHELL_ALIGN(sizeof(struct nhere)),
|
||||
SHELL_ALIGN(sizeof(struct nnot)),
|
||||
static const short nodesize[N_NUMBER] = {
|
||||
[NCMD ] = SHELL_ALIGN(sizeof(struct ncmd)),
|
||||
[NPIPE ] = SHELL_ALIGN(sizeof(struct npipe)),
|
||||
[NREDIR ] = SHELL_ALIGN(sizeof(struct nredir)),
|
||||
[NBACKGND ] = SHELL_ALIGN(sizeof(struct nredir)),
|
||||
[NSUBSHELL] = SHELL_ALIGN(sizeof(struct nredir)),
|
||||
[NAND ] = SHELL_ALIGN(sizeof(struct nbinary)),
|
||||
[NOR ] = SHELL_ALIGN(sizeof(struct nbinary)),
|
||||
[NSEMI ] = SHELL_ALIGN(sizeof(struct nbinary)),
|
||||
[NIF ] = SHELL_ALIGN(sizeof(struct nif)),
|
||||
[NWHILE ] = SHELL_ALIGN(sizeof(struct nbinary)),
|
||||
[NUNTIL ] = SHELL_ALIGN(sizeof(struct nbinary)),
|
||||
[NFOR ] = SHELL_ALIGN(sizeof(struct nfor)),
|
||||
[NCASE ] = SHELL_ALIGN(sizeof(struct ncase)),
|
||||
[NCLIST ] = SHELL_ALIGN(sizeof(struct nclist)),
|
||||
[NDEFUN ] = SHELL_ALIGN(sizeof(struct narg)),
|
||||
[NARG ] = SHELL_ALIGN(sizeof(struct narg)),
|
||||
[NTO ] = SHELL_ALIGN(sizeof(struct nfile)),
|
||||
#if ENABLE_ASH_BASH_COMPAT
|
||||
[NTO2 ] = SHELL_ALIGN(sizeof(struct nfile)),
|
||||
#endif
|
||||
[NCLOBBER ] = SHELL_ALIGN(sizeof(struct nfile)),
|
||||
[NFROM ] = SHELL_ALIGN(sizeof(struct nfile)),
|
||||
[NFROMTO ] = SHELL_ALIGN(sizeof(struct nfile)),
|
||||
[NAPPEND ] = SHELL_ALIGN(sizeof(struct nfile)),
|
||||
[NTOFD ] = SHELL_ALIGN(sizeof(struct ndup)),
|
||||
[NFROMFD ] = SHELL_ALIGN(sizeof(struct ndup)),
|
||||
[NHERE ] = SHELL_ALIGN(sizeof(struct nhere)),
|
||||
[NXHERE ] = SHELL_ALIGN(sizeof(struct nhere)),
|
||||
[NNOT ] = SHELL_ALIGN(sizeof(struct nnot)),
|
||||
};
|
||||
|
||||
static void calcsize(union node *n);
|
||||
@@ -7867,20 +7912,30 @@ dotrap(void)
|
||||
pendingsig = 0;
|
||||
xbarrier();
|
||||
|
||||
TRACE(("dotrap entered\n"));
|
||||
for (i = 1, q = gotsig; i < NSIG; i++, q++) {
|
||||
if (!*q)
|
||||
continue;
|
||||
*q = '\0';
|
||||
|
||||
p = trap[i];
|
||||
/* non-trapped SIGINT is handled separately by raise_interrupt,
|
||||
* don't upset it by resetting gotsig[SIGINT-1] */
|
||||
if (i == SIGINT && !p)
|
||||
continue;
|
||||
|
||||
TRACE(("sig %d is active, will run handler '%s'\n", i, p));
|
||||
*q = '\0';
|
||||
if (!p)
|
||||
continue;
|
||||
skip = evalstring(p, SKIPEVAL);
|
||||
exitstatus = savestatus;
|
||||
if (skip)
|
||||
if (skip) {
|
||||
TRACE(("dotrap returns %d\n", skip));
|
||||
return skip;
|
||||
}
|
||||
}
|
||||
|
||||
TRACE(("dotrap returns 0\n"));
|
||||
return 0;
|
||||
}
|
||||
|
||||
@@ -7902,28 +7957,32 @@ static void prehash(union node *);
|
||||
static void
|
||||
evaltree(union node *n, int flags)
|
||||
{
|
||||
|
||||
struct jmploc *volatile savehandler = exception_handler;
|
||||
struct jmploc jmploc;
|
||||
int checkexit = 0;
|
||||
void (*evalfn)(union node *, int);
|
||||
int status;
|
||||
int int_level;
|
||||
|
||||
SAVE_INT(int_level);
|
||||
|
||||
if (n == NULL) {
|
||||
TRACE(("evaltree(NULL) called\n"));
|
||||
goto out1;
|
||||
}
|
||||
TRACE(("pid %d, evaltree(%p: %d, %d) called\n",
|
||||
getpid(), n, n->type, flags));
|
||||
TRACE(("evaltree(%p: %d, %d) called\n", n, n->type, flags));
|
||||
|
||||
exception_handler = &jmploc;
|
||||
{
|
||||
int err = setjmp(jmploc.loc);
|
||||
if (err) {
|
||||
/* if it was a signal, check for trap handlers */
|
||||
if (exception == EXSIG)
|
||||
if (exception == EXSIG) {
|
||||
TRACE(("exception %d (EXSIG) in evaltree, err=%d\n", exception, err));
|
||||
goto out;
|
||||
}
|
||||
/* continue on the way out */
|
||||
TRACE(("exception %d in evaltree, propagating err=%d\n", exception, err));
|
||||
exception_handler = savehandler;
|
||||
longjmp(exception_handler->loc, err);
|
||||
}
|
||||
@@ -8006,7 +8065,8 @@ evaltree(union node *n, int flags)
|
||||
if (exitstatus == 0) {
|
||||
n = n->nif.ifpart;
|
||||
goto evaln;
|
||||
} else if (n->nif.elsepart) {
|
||||
}
|
||||
if (n->nif.elsepart) {
|
||||
n = n->nif.elsepart;
|
||||
goto evaln;
|
||||
}
|
||||
@@ -8032,6 +8092,9 @@ evaltree(union node *n, int flags)
|
||||
exexit:
|
||||
raise_exception(EXEXIT);
|
||||
}
|
||||
|
||||
RESTORE_INT(int_level);
|
||||
TRACE(("leaving evaltree (no interrupts)\n"));
|
||||
}
|
||||
|
||||
#if !defined(__alpha__) || (defined(__GNUC__) && __GNUC__ >= 3)
|
||||
@@ -8277,7 +8340,9 @@ evalpipe(union node *n, int flags)
|
||||
if (prevfd >= 0)
|
||||
close(prevfd);
|
||||
prevfd = pip[0];
|
||||
close(pip[1]);
|
||||
/* Don't want to trigger debugging */
|
||||
if (pip[1] != -1)
|
||||
close(pip[1]);
|
||||
}
|
||||
if (n->npipe.pipe_backgnd == 0) {
|
||||
exitstatus = waitforjob(jp);
|
||||
@@ -8909,6 +8974,7 @@ evalcommand(union node *cmd, int flags)
|
||||
if (forkshell(jp, cmd, FORK_FG) != 0) {
|
||||
exitstatus = waitforjob(jp);
|
||||
INT_ON;
|
||||
TRACE(("forked child exited with %d\n", exitstatus));
|
||||
break;
|
||||
}
|
||||
FORCE_INT_ON;
|
||||
@@ -9065,8 +9131,6 @@ breakcmd(int argc UNUSED_PARAM, char **argv)
|
||||
* This implements the input routines used by the parser.
|
||||
*/
|
||||
|
||||
#define EOF_NLEFT -99 /* value of parsenleft when EOF pushed back */
|
||||
|
||||
enum {
|
||||
INPUT_PUSH_FILE = 1,
|
||||
INPUT_NOFILE_OK = 2,
|
||||
@@ -9107,7 +9171,6 @@ popstring(void)
|
||||
#endif
|
||||
parsenextc = sp->prevstring;
|
||||
parsenleft = sp->prevnleft;
|
||||
/*dprintf("*** calling popstring: restoring to '%s'\n", parsenextc);*/
|
||||
g_parsefile->strpush = sp->prev;
|
||||
if (sp != &(g_parsefile->basestrpush))
|
||||
free(sp);
|
||||
@@ -9123,7 +9186,7 @@ preadfd(void)
|
||||
|
||||
#if ENABLE_FEATURE_EDITING
|
||||
retry:
|
||||
if (!iflag || g_parsefile->fd)
|
||||
if (!iflag || g_parsefile->fd != STDIN_FILENO)
|
||||
nr = nonblock_safe_read(g_parsefile->fd, buf, BUFSIZ - 1);
|
||||
else {
|
||||
#if ENABLE_FEATURE_TAB_COMPLETION
|
||||
@@ -9171,55 +9234,76 @@ preadfd(void)
|
||||
* Refill the input buffer and return the next input character:
|
||||
*
|
||||
* 1) If a string was pushed back on the input, pop it;
|
||||
* 2) If an EOF was pushed back (parsenleft == EOF_NLEFT) or we are reading
|
||||
* 2) If an EOF was pushed back (parsenleft < -BIGNUM) or we are reading
|
||||
* from a string so we can't refill the buffer, return EOF.
|
||||
* 3) If the is more stuff in this buffer, use it else call read to fill it.
|
||||
* 4) Process input up to the next newline, deleting nul characters.
|
||||
*/
|
||||
//#define pgetc_debug(...) bb_error_msg(__VA_ARGS__)
|
||||
#define pgetc_debug(...) ((void)0)
|
||||
static int
|
||||
preadbuffer(void)
|
||||
{
|
||||
char *q;
|
||||
int more;
|
||||
char savec;
|
||||
|
||||
while (g_parsefile->strpush) {
|
||||
#if ENABLE_ASH_ALIAS
|
||||
if (parsenleft == -1 && g_parsefile->strpush->ap &&
|
||||
parsenextc[-1] != ' ' && parsenextc[-1] != '\t') {
|
||||
if (parsenleft == -1 && g_parsefile->strpush->ap
|
||||
&& parsenextc[-1] != ' ' && parsenextc[-1] != '\t'
|
||||
) {
|
||||
pgetc_debug("preadbuffer PEOA");
|
||||
return PEOA;
|
||||
}
|
||||
#endif
|
||||
popstring();
|
||||
/* try "pgetc" now: */
|
||||
pgetc_debug("internal pgetc at %d:%p'%s'", parsenleft, parsenextc, parsenextc);
|
||||
if (--parsenleft >= 0)
|
||||
return signed_char2int(*parsenextc++);
|
||||
}
|
||||
if (parsenleft == EOF_NLEFT || g_parsefile->buf == NULL)
|
||||
/* on both branches above parsenleft < 0.
|
||||
* "pgetc" needs refilling.
|
||||
*/
|
||||
|
||||
/* -90 is -BIGNUM. Below we use -99 to mark "EOF on read",
|
||||
* pungetc() may decrement it a few times. -90 is enough.
|
||||
*/
|
||||
if (parsenleft < -90 || g_parsefile->buf == NULL) {
|
||||
pgetc_debug("preadbuffer PEOF1");
|
||||
/* even in failure keep them in lock step,
|
||||
* for correct pungetc. */
|
||||
parsenextc++;
|
||||
return PEOF;
|
||||
flush_stdout_stderr();
|
||||
}
|
||||
|
||||
more = parselleft;
|
||||
if (more <= 0) {
|
||||
flush_stdout_stderr();
|
||||
again:
|
||||
more = preadfd();
|
||||
if (more <= 0) {
|
||||
parselleft = parsenleft = EOF_NLEFT;
|
||||
parselleft = parsenleft = -99;
|
||||
pgetc_debug("preadbuffer PEOF2");
|
||||
parsenextc++;
|
||||
return PEOF;
|
||||
}
|
||||
}
|
||||
|
||||
/* Find out where's the end of line.
|
||||
* Set parsenleft/parselleft acordingly.
|
||||
* NUL chars are deleted.
|
||||
*/
|
||||
q = parsenextc;
|
||||
|
||||
/* delete nul characters */
|
||||
for (;;) {
|
||||
int c;
|
||||
char c;
|
||||
|
||||
more--;
|
||||
c = *q;
|
||||
|
||||
if (!c)
|
||||
c = *q;
|
||||
if (c == '\0') {
|
||||
memmove(q, q + 1, more);
|
||||
else {
|
||||
} else {
|
||||
q++;
|
||||
if (c == '\n') {
|
||||
parsenleft = q - parsenextc - 1;
|
||||
@@ -9236,22 +9320,23 @@ preadbuffer(void)
|
||||
}
|
||||
parselleft = more;
|
||||
|
||||
savec = *q;
|
||||
*q = '\0';
|
||||
|
||||
if (vflag) {
|
||||
char save = *q;
|
||||
*q = '\0';
|
||||
out2str(parsenextc);
|
||||
*q = save;
|
||||
}
|
||||
|
||||
*q = savec;
|
||||
|
||||
pgetc_debug("preadbuffer at %d:%p'%s'", parsenleft, parsenextc, parsenextc);
|
||||
return signed_char2int(*parsenextc++);
|
||||
}
|
||||
|
||||
#define pgetc_as_macro() (--parsenleft >= 0 ? signed_char2int(*parsenextc++) : preadbuffer())
|
||||
|
||||
static int
|
||||
pgetc(void)
|
||||
{
|
||||
pgetc_debug("pgetc at %d:%p'%s'", parsenleft, parsenextc, parsenextc);
|
||||
return pgetc_as_macro();
|
||||
}
|
||||
|
||||
@@ -9312,6 +9397,7 @@ pungetc(void)
|
||||
{
|
||||
parsenleft++;
|
||||
parsenextc--;
|
||||
pgetc_debug("pushed back to %d:%p'%s'", parsenleft, parsenextc, parsenextc);
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -9325,16 +9411,17 @@ static void
|
||||
pushstring(char *s, struct alias *ap)
|
||||
{
|
||||
struct strpush *sp;
|
||||
size_t len;
|
||||
int len;
|
||||
|
||||
len = strlen(s);
|
||||
INT_OFF;
|
||||
if (g_parsefile->strpush) {
|
||||
sp = ckzalloc(sizeof(struct strpush));
|
||||
sp = ckzalloc(sizeof(*sp));
|
||||
sp->prev = g_parsefile->strpush;
|
||||
g_parsefile->strpush = sp;
|
||||
} else
|
||||
sp = g_parsefile->strpush = &(g_parsefile->basestrpush);
|
||||
} else {
|
||||
sp = &(g_parsefile->basestrpush);
|
||||
}
|
||||
g_parsefile->strpush = sp;
|
||||
sp->prevstring = parsenextc;
|
||||
sp->prevnleft = parsenleft;
|
||||
#if ENABLE_ASH_ALIAS
|
||||
@@ -9424,7 +9511,7 @@ setinputfd(int fd, int push)
|
||||
close_on_exec_on(fd);
|
||||
if (push) {
|
||||
pushfile();
|
||||
g_parsefile->buf = 0;
|
||||
g_parsefile->buf = NULL;
|
||||
}
|
||||
g_parsefile->fd = fd;
|
||||
if (g_parsefile->buf == NULL)
|
||||
@@ -12366,7 +12453,7 @@ readcmd(int argc UNUSED_PARAM, char **argv UNUSED_PARAM)
|
||||
#endif
|
||||
|
||||
status = 0;
|
||||
startword = 1;
|
||||
startword = 2;
|
||||
backslash = 0;
|
||||
#if ENABLE_ASH_READ_TIMEOUT
|
||||
if (timeout) /* NB: ensuring end_ms is nonzero */
|
||||
@@ -12374,6 +12461,8 @@ readcmd(int argc UNUSED_PARAM, char **argv UNUSED_PARAM)
|
||||
#endif
|
||||
STARTSTACKSTR(p);
|
||||
do {
|
||||
const char *is_ifs;
|
||||
|
||||
#if ENABLE_ASH_READ_TIMEOUT
|
||||
if (end_ms) {
|
||||
struct pollfd pfd[1];
|
||||
@@ -12403,25 +12492,34 @@ readcmd(int argc UNUSED_PARAM, char **argv UNUSED_PARAM)
|
||||
continue;
|
||||
}
|
||||
if (!rflag && c == '\\') {
|
||||
backslash++;
|
||||
backslash = 1;
|
||||
continue;
|
||||
}
|
||||
if (c == '\n')
|
||||
break;
|
||||
if (startword && *ifs == ' ' && strchr(ifs, c)) {
|
||||
continue;
|
||||
is_ifs = strchr(ifs, c);
|
||||
if (startword && is_ifs) {
|
||||
if (isspace(c))
|
||||
continue;
|
||||
/* non-space ifs char */
|
||||
startword--;
|
||||
if (startword == 1) /* first one? */
|
||||
continue;
|
||||
}
|
||||
startword = 0;
|
||||
if (ap[1] != NULL && strchr(ifs, c) != NULL) {
|
||||
if (ap[1] != NULL && is_ifs) {
|
||||
const char *beg;
|
||||
STACKSTRNUL(p);
|
||||
setvar(*ap, stackblock(), 0);
|
||||
beg = stackblock();
|
||||
setvar(*ap, beg, 0);
|
||||
ap++;
|
||||
startword = 1;
|
||||
/* can we skip one non-space ifs? (2: yes) */
|
||||
startword = isspace(c) ? 2 : 1;
|
||||
STARTSTACKSTR(p);
|
||||
} else {
|
||||
put:
|
||||
STPUTC(c, p);
|
||||
continue;
|
||||
}
|
||||
put:
|
||||
STPUTC(c, p);
|
||||
}
|
||||
/* end of do {} while: */
|
||||
#if ENABLE_ASH_READ_NCHARS
|
||||
@@ -12435,8 +12533,8 @@ readcmd(int argc UNUSED_PARAM, char **argv UNUSED_PARAM)
|
||||
#endif
|
||||
|
||||
STACKSTRNUL(p);
|
||||
/* Remove trailing blanks */
|
||||
while ((char *)stackblock() <= --p && strchr(ifs, *p) != NULL)
|
||||
/* Remove trailing space ifs chars */
|
||||
while ((char *)stackblock() <= --p && isspace(*p) && strchr(ifs, *p) != NULL)
|
||||
*p = '\0';
|
||||
setvar(*ap, stackblock(), 0);
|
||||
while (*++ap != NULL)
|
||||
@@ -13615,7 +13713,7 @@ int ash_main(int argc UNUSED_PARAM, char **argv)
|
||||
exception_handler = &jmploc;
|
||||
#if DEBUG
|
||||
opentrace();
|
||||
trace_puts("Shell args: ");
|
||||
TRACE(("Shell args: "));
|
||||
trace_puts_args(argv);
|
||||
#endif
|
||||
rootpid = getpid();
|
||||
@@ -13667,8 +13765,14 @@ int ash_main(int argc UNUSED_PARAM, char **argv)
|
||||
}
|
||||
state3:
|
||||
state = 4;
|
||||
if (minusc)
|
||||
if (minusc) {
|
||||
/* evalstring pushes parsefile stack.
|
||||
* Ensure we don't falsely claim that 0 (stdin)
|
||||
* is one of stacked source fds */
|
||||
if (!sflag)
|
||||
g_parsefile->fd = -1;
|
||||
evalstring(minusc, 0);
|
||||
}
|
||||
|
||||
if (sflag || minusc == NULL) {
|
||||
#if ENABLE_FEATURE_EDITING_SAVEHISTORY
|
||||
@@ -13695,14 +13799,6 @@ int ash_main(int argc UNUSED_PARAM, char **argv)
|
||||
/* NOTREACHED */
|
||||
}
|
||||
|
||||
#if DEBUG
|
||||
const char *applet_name = "debug stuff usage";
|
||||
int main(int argc, char **argv)
|
||||
{
|
||||
return ash_main(argc, argv);
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
/*-
|
||||
* Copyright (c) 1989, 1991, 1993, 1994
|
||||
|
||||
@@ -0,0 +1,7 @@
|
||||
.a. .b. .c.
|
||||
.a. .b. .c.
|
||||
.a. .. .b,c.
|
||||
.a. .. .b,c.
|
||||
.a. .. .c.
|
||||
.a. .. .c. .d.
|
||||
.a. .. .b,c,d , ,.
|
||||
Executable
+7
@@ -0,0 +1,7 @@
|
||||
printf 'a\t\tb\tc\n' | ( IFS=$(printf "\t") read a b c; echo ".$a. .$b. .$c." )
|
||||
printf 'a\t\tb\tc\n' | ( IFS=$(printf " \t") read a b c; echo ".$a. .$b. .$c." )
|
||||
printf 'a,,b,c\n' | ( IFS="," read a b c; echo ".$a. .$b. .$c." )
|
||||
printf 'a,,b,c\n' | ( IFS=" ," read a b c; echo ".$a. .$b. .$c." )
|
||||
printf 'a ,, c\n' | ( IFS=" ," read a b c; echo ".$a. .$b. .$c." )
|
||||
printf 'a ,, c d\n' | ( IFS=" ," read a b c d; echo ".$a. .$b. .$c. .$d." )
|
||||
printf ' a,,b,c,d , ,\n' | ( IFS=" ," read a b c; echo ".$a. .$b. .$c." )
|
||||
+82
-13
@@ -458,8 +458,11 @@ struct globals {
|
||||
smallint fake_mode;
|
||||
/* these three support $?, $#, and $1 */
|
||||
smalluint last_return_code;
|
||||
char **global_argv;
|
||||
/* is global_argv and global_argv[1..n] malloced? (note: not [0]) */
|
||||
smalluint global_args_malloced;
|
||||
/* how many non-NULL argv's we have. NB: $# + 1 */
|
||||
int global_argc;
|
||||
char **global_argv;
|
||||
#if ENABLE_HUSH_LOOPS
|
||||
unsigned depth_break_continue;
|
||||
unsigned depth_of_loop;
|
||||
@@ -633,7 +636,7 @@ static char *unbackslash(char *src)
|
||||
return dst;
|
||||
}
|
||||
|
||||
static char **add_strings_to_strings(char **strings, char **add)
|
||||
static char **add_strings_to_strings(char **strings, char **add, int need_to_dup)
|
||||
{
|
||||
int i;
|
||||
unsigned count1;
|
||||
@@ -658,7 +661,7 @@ static char **add_strings_to_strings(char **strings, char **add)
|
||||
v[count1 + count2] = NULL;
|
||||
i = count2;
|
||||
while (--i >= 0)
|
||||
v[count1 + i] = add[i];
|
||||
v[count1 + i] = (need_to_dup ? xstrdup(add[i]) : add[i]);
|
||||
return v;
|
||||
}
|
||||
|
||||
@@ -667,7 +670,7 @@ 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);
|
||||
return add_strings_to_strings(strings, v, /*dup:*/ 0);
|
||||
}
|
||||
|
||||
static void putenv_all(char **strings)
|
||||
@@ -1213,8 +1216,13 @@ static int o_glob(o_string *o, int n)
|
||||
* Otherwise, just finish current list[] and start new */
|
||||
static int o_save_ptr(o_string *o, int n)
|
||||
{
|
||||
if (o->o_glob)
|
||||
return o_glob(o, n); /* o_save_ptr_helper is inside */
|
||||
if (o->o_glob) { /* if globbing is requested */
|
||||
/* If o->has_empty_slot, list[n] was already globbed
|
||||
* (if it was requested back then when it was filled)
|
||||
* so don't do that again! */
|
||||
if (!o->has_empty_slot)
|
||||
return o_glob(o, n); /* o_save_ptr_helper is inside */
|
||||
}
|
||||
return o_save_ptr_helper(o, n);
|
||||
}
|
||||
|
||||
@@ -4279,6 +4287,11 @@ int hush_main(int argc, char **argv)
|
||||
switch (opt) {
|
||||
case 'c':
|
||||
G.global_argv = argv + optind;
|
||||
if (!argv[optind]) {
|
||||
/* -c 'script' (no params): prevent empty $0 */
|
||||
*--G.global_argv = argv[0];
|
||||
optind--;
|
||||
} /* else -c 'script' PAR0 PAR1: $0 is PAR0 */
|
||||
G.global_argc = argc - optind;
|
||||
opt = parse_and_run_string(optarg, 0 /* parse_flag */);
|
||||
goto final_return;
|
||||
@@ -4639,17 +4652,68 @@ static int builtin_read(char **argv)
|
||||
return set_local_var(string, 0);
|
||||
}
|
||||
|
||||
/* built-in 'set [VAR=value]' handler */
|
||||
/* built-in 'set' handler
|
||||
* SUSv3 says:
|
||||
* set [-abCefmnuvx] [-h] [-o option] [argument...]
|
||||
* set [+abCefmnuvx] [+h] [+o option] [argument...]
|
||||
* set -- [argument...]
|
||||
* set -o
|
||||
* set +o
|
||||
* Implementations shall support the options in both their hyphen and
|
||||
* plus-sign forms. These options can also be specified as options to sh.
|
||||
* Examples:
|
||||
* Write out all variables and their values: set
|
||||
* Set $1, $2, and $3 and set "$#" to 3: set c a b
|
||||
* Turn on the -x and -v options: set -xv
|
||||
* Unset all positional parameters: set --
|
||||
* Set $1 to the value of x, even if it begins with '-' or '+': set -- "$x"
|
||||
* Set the positional parameters to the expansion of x, even if x expands
|
||||
* with a leading '-' or '+': set -- $x
|
||||
*
|
||||
* So far, we only support "set -- [argument...]" by ignoring all options
|
||||
* (also, "-o option" will be mishandled by taking "option" as parameter #1).
|
||||
*/
|
||||
static int builtin_set(char **argv)
|
||||
{
|
||||
char *temp = argv[1];
|
||||
struct variable *e;
|
||||
char **pp;
|
||||
char *arg = *++argv;
|
||||
|
||||
if (temp == NULL)
|
||||
if (arg == NULL) {
|
||||
for (e = G.top_var; e; e = e->next)
|
||||
puts(e->varstr);
|
||||
else
|
||||
set_local_var(xstrdup(temp), 0);
|
||||
} else {
|
||||
/* NB: G.global_argv[0] ($0) is never freed/changed */
|
||||
|
||||
if (G.global_args_malloced) {
|
||||
pp = G.global_argv;
|
||||
while (*++pp)
|
||||
free(*pp);
|
||||
G.global_argv[1] = NULL;
|
||||
} else {
|
||||
G.global_args_malloced = 1;
|
||||
pp = xzalloc(sizeof(pp[0]) * 2);
|
||||
pp[0] = G.global_argv[0]; /* retain $0 */
|
||||
G.global_argv = pp;
|
||||
}
|
||||
do {
|
||||
if (arg[0] == '+')
|
||||
continue;
|
||||
if (arg[0] != '-')
|
||||
break;
|
||||
if (arg[1] == '-' && arg[2] == '\0') {
|
||||
argv++;
|
||||
break;
|
||||
}
|
||||
} while ((arg = *++argv) != NULL);
|
||||
/* Now argv[0] is 1st argument */
|
||||
|
||||
/* This realloc's G.global_argv */
|
||||
G.global_argv = pp = add_strings_to_strings(G.global_argv, argv, /*dup:*/ 1);
|
||||
G.global_argc = 1;
|
||||
while (*++pp)
|
||||
G.global_argc++;
|
||||
}
|
||||
|
||||
return EXIT_SUCCESS;
|
||||
}
|
||||
@@ -4661,9 +4725,14 @@ static int builtin_shift(char **argv)
|
||||
n = atoi(argv[1]);
|
||||
}
|
||||
if (n >= 0 && n < G.global_argc) {
|
||||
G.global_argv[n] = G.global_argv[0];
|
||||
if (G.global_args_malloced) {
|
||||
int m = 1;
|
||||
while (m <= n)
|
||||
free(G.global_argv[m++]);
|
||||
}
|
||||
G.global_argc -= n;
|
||||
G.global_argv += n;
|
||||
memmove(&G.global_argv[1], &G.global_argv[n+1],
|
||||
G.global_argc * sizeof(G.global_argv[0]));
|
||||
return EXIT_SUCCESS;
|
||||
}
|
||||
return EXIT_FAILURE;
|
||||
|
||||
@@ -1,2 +1,3 @@
|
||||
Should be printed
|
||||
Should be printed
|
||||
Empty:
|
||||
@@ -12,3 +12,6 @@ for a in "$@"""; do echo Should not be printed; done
|
||||
for a in """$@"; do echo Should not be printed; done
|
||||
for a in """$@"''"$@"''; do echo Should not be printed; done
|
||||
for a in ""; do echo Should be printed; done
|
||||
|
||||
# Bug 207: "$@" expands to nothing, and we erroneously glob "%s\\n" twice:
|
||||
printf "Empty:%s\\n" "$@"
|
||||
+2
-4
@@ -73,9 +73,6 @@ int klogd_main(int argc UNUSED_PARAM, char **argv)
|
||||
|
||||
syslog(LOG_NOTICE, "klogd started: %s", bb_banner);
|
||||
|
||||
/* Initially null terminate the buffer in case of a very long line */
|
||||
log_buffer[KLOGD_LOGBUF_SIZE - 1] = '\0';
|
||||
|
||||
while (1) {
|
||||
int n;
|
||||
int priority;
|
||||
@@ -89,6 +86,7 @@ int klogd_main(int argc UNUSED_PARAM, char **argv)
|
||||
errno);
|
||||
break;
|
||||
}
|
||||
log_buffer[used + n] = '\0';
|
||||
|
||||
/* klogctl buffer parsing modelled after code in dmesg.c */
|
||||
start = &log_buffer[0];
|
||||
@@ -101,7 +99,7 @@ int klogd_main(int argc UNUSED_PARAM, char **argv)
|
||||
/* This line is incomplete... */
|
||||
if (start != log_buffer) {
|
||||
/* move it to the front of the buffer */
|
||||
strcpy(log_buffer, start);
|
||||
overlapping_strcpy(log_buffer, start);
|
||||
/* don't log it yet */
|
||||
used = strlen(log_buffer);
|
||||
break;
|
||||
|
||||
+9
-3
@@ -301,17 +301,23 @@ static void log_locally(time_t now, char *msg)
|
||||
}
|
||||
#endif
|
||||
if (G.logFD >= 0) {
|
||||
/* Reopen log file every second. This allows admin
|
||||
* to delete the file and not worry about restarting us.
|
||||
* This costs almost nothing since it happens
|
||||
* _at most_ once a second.
|
||||
*/
|
||||
if (!now)
|
||||
now = time(NULL);
|
||||
if (G.last_log_time != now) {
|
||||
G.last_log_time = now; /* reopen log file every second */
|
||||
G.last_log_time = now;
|
||||
close(G.logFD);
|
||||
goto reopen;
|
||||
}
|
||||
} else {
|
||||
reopen:
|
||||
G.logFD = device_open(G.logFilePath, O_WRONLY | O_CREAT
|
||||
| O_NOCTTY | O_APPEND | O_NONBLOCK);
|
||||
G.logFD = open(G.logFilePath, O_WRONLY | O_CREAT
|
||||
| O_NOCTTY | O_APPEND | O_NONBLOCK,
|
||||
0666);
|
||||
if (G.logFD < 0) {
|
||||
/* cannot open logfile? - print to /dev/console then */
|
||||
int fd = device_open(DEV_CONSOLE, O_WRONLY | O_NOCTTY | O_NONBLOCK);
|
||||
|
||||
@@ -109,6 +109,22 @@ brw-r--r-- 1 0 0 8,0 sda
|
||||
" \
|
||||
"" ""
|
||||
|
||||
# continuing to use directory structure from prev test
|
||||
rm -rf mdev.testdir/dev/*
|
||||
echo "sda 0:0 644 =block/ @echo @echo TEST" >mdev.testdir/etc/mdev.conf
|
||||
testing "mdev move and command" \
|
||||
"env - PATH=$PATH ACTION=add DEVPATH=/block/sda chroot mdev.testdir /mdev 2>&1;
|
||||
ls -lnR mdev.testdir/dev | $FILTER_LS2" \
|
||||
"\
|
||||
@echo TEST
|
||||
mdev.testdir/dev:
|
||||
drwxr-xr-x 2 0 0 block
|
||||
|
||||
mdev.testdir/dev/block:
|
||||
brw-r--r-- 1 0 0 sda
|
||||
" \
|
||||
"" ""
|
||||
|
||||
# continuing to use directory structure from prev test
|
||||
rm -rf mdev.testdir/dev/*
|
||||
echo "@8,0 :1 644" >mdev.testdir/etc/mdev.conf
|
||||
|
||||
+3
-2
@@ -179,8 +179,9 @@ static void make_device(char *path, int delete)
|
||||
unsigned i, n;
|
||||
#endif
|
||||
char *a = val;
|
||||
s = strchr(val, ' ');
|
||||
val = (s && s[1]) ? s+1 : NULL;
|
||||
s = strchrnul(val, ' ');
|
||||
val = (s[0] && s[1]) ? s+1 : NULL;
|
||||
s[0] = '\0';
|
||||
#if ENABLE_FEATURE_MDEV_RENAME_REGEXP
|
||||
/* substitute %1..9 with off[1..9], if any */
|
||||
n = 0;
|
||||
|
||||
@@ -223,13 +223,11 @@ void display_uuid_cache(void)
|
||||
char *get_devname_from_label(const char *spec)
|
||||
{
|
||||
struct uuidCache_s *uc;
|
||||
int spec_len = strlen(spec);
|
||||
|
||||
uuidcache_init();
|
||||
uc = uuidCache;
|
||||
while (uc) {
|
||||
// FIXME: empty label ("LABEL=") matches anything??!
|
||||
if (uc->label[0] && strncmp(spec, uc->label, spec_len) == 0) {
|
||||
if (uc->label[0] && strcmp(spec, uc->label) == 0) {
|
||||
return xstrdup(uc->device);
|
||||
}
|
||||
uc = uc->next;
|
||||
|
||||
Reference in new issue
Block a user