*
*/
-
/*
* The follow should be set to reflect the type of system you have:
* JOBS -> 1 if you have Berkeley job control, 0 otherwise.
* a quit signal will generate a core dump.
*/
#define DEBUG 0
-
-
#define IFS_BROKEN
-
#define PROFILE 0
-
-#include "busybox.h"
+#if ENABLE_ASH_JOB_CONTROL
+#define JOBS 1
+#else
+#define JOBS 0
+#endif
#if DEBUG
#define _GNU_SOURCE
#endif
-
-#include <sys/types.h>
-#include <sys/ioctl.h>
-#include <sys/param.h>
-#include <sys/resource.h>
-#include <sys/stat.h>
-#include <sys/wait.h>
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <unistd.h>
-
-#include <stdarg.h>
-#include <stddef.h>
-#include <assert.h>
-#include <ctype.h>
-#include <dirent.h>
-#include <errno.h>
-#include <fcntl.h>
-#include <limits.h>
+#include "busybox.h"
#include <paths.h>
#include <setjmp.h>
-#include <signal.h>
-/*#include <stdint.h>*/
-#include <time.h>
#include <fnmatch.h>
-
-#if ENABLE_ASH_JOB_CONTROL
-#define JOBS 1
-#else
-#define JOBS 0
-#endif
-
#if JOBS || ENABLE_ASH_READ_NCHARS
#include <termios.h>
#endif
+#if defined(__uClinux__)
+#error "Do not even bother, ash will not run on uClinux"
+#endif
+
#ifdef __GLIBC__
/* glibc sucks */
#define errno (*dash_errno)
#endif
-#if defined(__uClinux__)
-#error "Do not even bother, ash will not run on uClinux"
-#endif
-
-#if DEBUG
-#define _DIAGASSERT(assert_expr) assert(assert_expr)
-#else
-#define _DIAGASSERT(assert_expr)
-#endif
-
#if ENABLE_ASH_ALIAS
-/* alias.h */
-
-#define ALIASINUSE 1
-#define ALIASDEAD 2
-
+#define ALIASINUSE 1
+#define ALIASDEAD 2
struct alias {
struct alias *next;
char *name;
char *val;
int flag;
};
-
-static struct alias *lookupalias(const char *, int);
static int aliascmd(int, char **);
static int unaliascmd(int, char **);
-static void rmaliases(void);
-static int unalias(const char *);
static void printalias(const struct alias *);
#endif
-/* cd.h */
+/* ============ Shell options */
-static void setpwd(const char *, int);
+static const char *const optletters_optnames[] = {
+ "e" "errexit",
+ "f" "noglob",
+ "I" "ignoreeof",
+ "i" "interactive",
+ "m" "monitor",
+ "n" "noexec",
+ "s" "stdin",
+ "x" "xtrace",
+ "v" "verbose",
+ "C" "noclobber",
+ "a" "allexport",
+ "b" "notify",
+ "u" "nounset",
+ "\0" "vi",
+#if DEBUG
+ "\0" "nolog",
+ "\0" "debug",
+#endif
+};
-/* error.h */
+#define optletters(n) optletters_optnames[(n)][0]
+#define optnames(n) (&optletters_optnames[(n)][1])
+#define NOPTS (sizeof(optletters_optnames)/sizeof(optletters_optnames[0]))
-/*
- * Types of operations (passed to the errmsg routine).
- */
+static char optlist[NOPTS];
+#define eflag optlist[0]
+#define fflag optlist[1]
+#define Iflag optlist[2]
+#define iflag optlist[3]
+#define mflag optlist[4]
+#define nflag optlist[5]
+#define sflag optlist[6]
+#define xflag optlist[7]
+#define vflag optlist[8]
+#define Cflag optlist[9]
+#define aflag optlist[10]
+#define bflag optlist[11]
+#define uflag optlist[12]
+#define viflag optlist[13]
+#if DEBUG
+#define nolog optlist[14]
+#define debug optlist[15]
+#endif
-static const char not_found_msg[] = "%s: not found";
+/* ============ Misc data */
-#define E_OPEN "No such file" /* opening a file */
-#define E_CREAT "Directory nonexistent" /* creating a file */
-#define E_EXEC not_found_msg+4 /* executing a program */
+/* pid of main shell */
+static int rootpid;
+/* shell level: 0 for the main shell, 1 for its children, and so on */
+static int shlvl;
+#define rootshell (!shlvl)
+/* trap handler commands */
+static char *trap[NSIG];
+/* current value of signal */
+static char sigmode[NSIG - 1];
+/* indicates specified signal received */
+static char gotsig[NSIG - 1];
+static char *arg0; /* value of $0 */
-/*
+
+/* ============ Interrupts / exceptions
+ *
* We enclose jmp_buf in a structure so that we can declare pointers to
* jump locations. The global variable handler contains the location to
* jump to when an exception occurs, and the global variable exception
* to an inner scope, set handler to point to a jmploc structure for the
* inner scope, and restore handler on exit from the scope.
*/
-
struct jmploc {
jmp_buf loc;
};
-
static struct jmploc *handler;
static int exception;
-static volatile int suppressint;
-static volatile sig_atomic_t intpending;
-
/* exceptions */
#define EXINT 0 /* SIGINT received */
#define EXERROR 1 /* a generic error */
#define EXEXEC 3 /* command execution failed */
#define EXEXIT 4 /* exit the shell */
#define EXSIG 5 /* trapped signal in wait(1) */
-
-
+static volatile int suppressint;
+static volatile sig_atomic_t intpending;
/* do we generate EXSIG events */
static int exsig;
/* last pending signal */
* much more efficient and portable. (But hacking the kernel is so much
* more fun than worrying about efficiency and portability. :-))
*/
-
#define xbarrier() ({ __asm__ __volatile__ ("": : :"memory"); })
-#define INTOFF \
+#define INT_OFF \
({ \
suppressint++; \
xbarrier(); \
0; \
})
-#define SAVEINT(v) ((v) = suppressint)
-#define RESTOREINT(v) \
- ({ \
- xbarrier(); \
- suppressint = (v); \
- if (suppressint == 0 && intpending) onint(); \
- 0; \
- })
-#define EXSIGON() \
- ({ \
- exsig++; \
- xbarrier(); \
- if (pendingsigs) \
- exraise(EXSIG); \
- 0; \
- })
-/* EXSIG is turned off by evalbltin(). */
-
-static void exraise(int) ATTRIBUTE_NORETURN;
-static void onint(void) ATTRIBUTE_NORETURN;
+/*
+ * Called to raise an exception. Since C doesn't include exceptions, we
+ * just do a longjmp to the exception handler. The type of exception is
+ * stored in the global variable "exception".
+ */
+static void raise_exception(int) ATTRIBUTE_NORETURN;
+static void
+raise_exception(int e)
+{
+#if DEBUG
+ if (handler == NULL)
+ abort();
+#endif
+ INT_OFF;
+ exception = e;
+ longjmp(handler->loc, 1);
+}
-static void sh_error(const char *, ...) ATTRIBUTE_NORETURN;
-static void exerror(int, const char *, ...) ATTRIBUTE_NORETURN;
+/*
+ * Called from trap.c when a SIGINT is received. (If the user specifies
+ * that SIGINT is to be trapped or ignored using the trap builtin, then
+ * this routine is not called.) Suppressint is nonzero when interrupts
+ * are held using the INT_OFF macro. (The test for iflag is just
+ * defensive programming.)
+ */
+static void raise_interrupt(void) ATTRIBUTE_NORETURN;
+static void
+raise_interrupt(void)
+{
+ int i;
-static void sh_warnx(const char *, ...);
+ intpending = 0;
+ i = EXSIG;
+ if (gotsig[SIGINT - 1] && !trap[SIGINT]) {
+ if (!(rootshell && iflag)) {
+ signal(SIGINT, SIG_DFL);
+ raise(SIGINT);
+ }
+ i = EXINT;
+ }
+ raise_exception(i);
+ /* NOTREACHED */
+}
#if ENABLE_ASH_OPTIMIZE_FOR_SIZE
-static void
-inton(void)
+static void int_on(void)
{
if (--suppressint == 0 && intpending) {
- onint();
+ raise_interrupt();
}
}
-#define INTON inton()
-static void forceinton(void)
+#define INT_ON int_on()
+static void force_int_on(void)
{
suppressint = 0;
if (intpending)
- onint();
+ raise_interrupt();
}
-#define FORCEINTON forceinton()
+#define FORCE_INT_ON force_int_on()
#else
-#define INTON \
+#define INT_ON \
({ \
xbarrier(); \
- if (--suppressint == 0 && intpending) onint(); \
+ if (--suppressint == 0 && intpending) raise_interrupt(); \
0; \
})
-#define FORCEINTON \
+#define FORCE_INT_ON \
({ \
xbarrier(); \
suppressint = 0; \
- if (intpending) onint(); \
+ if (intpending) raise_interrupt(); \
0; \
})
#endif /* ASH_OPTIMIZE_FOR_SIZE */
+#define SAVE_INT(v) ((v) = suppressint)
+
+#define RESTORE_INT(v) \
+ ({ \
+ xbarrier(); \
+ suppressint = (v); \
+ if (suppressint == 0 && intpending) raise_interrupt(); \
+ 0; \
+ })
+
+#define EXSIGON \
+ ({ \
+ exsig++; \
+ xbarrier(); \
+ if (pendingsigs) \
+ raise_exception(EXSIG); \
+ 0; \
+ })
+/* EXSIG is turned off by evalbltin(). */
+
+
+/* ============ stdout/stderr output */
+
+static void
+outstr(const char *p, FILE *file)
+{
+ INT_OFF;
+ fputs(p, file);
+ INT_ON;
+}
+
+static void
+flush_stdout_stderr(void)
+{
+ INT_OFF;
+ fflush(stdout);
+ fflush(stderr);
+ INT_ON;
+}
+
+static void
+flush_stderr(void)
+{
+ INT_OFF;
+ fflush(stderr);
+ INT_ON;
+}
+
+static void
+outcslow(int c, FILE *dest)
+{
+ INT_OFF;
+ putc(c, dest);
+ fflush(dest);
+ INT_ON;
+}
+
+static int out1fmt(const char *, ...) __attribute__((__format__(__printf__,1,2)));
+static int
+out1fmt(const char *fmt, ...)
+{
+ va_list ap;
+ int r;
+
+ INT_OFF;
+ va_start(ap, fmt);
+ r = vprintf(fmt, ap);
+ va_end(ap);
+ INT_ON;
+ return r;
+}
+
+static int fmtstr(char *, size_t, const char *, ...) __attribute__((__format__(__printf__,3,4)));
+static int
+fmtstr(char *outbuf, size_t length, const char *fmt, ...)
+{
+ va_list ap;
+ int ret;
+
+ va_start(ap, fmt);
+ INT_OFF;
+ ret = vsnprintf(outbuf, length, fmt, ap);
+ va_end(ap);
+ INT_ON;
+ return ret;
+}
+
+static void
+out1str(const char *p)
+{
+ outstr(p, stdout);
+}
+
+static void
+out2str(const char *p)
+{
+ outstr(p, stderr);
+ flush_stderr();
+}
+
+
+/* ============ Parser data
+ *
+ * ash_vmsg() needs parsefile->fd, hence parsefile definition is moved up.
+ */
+
+struct strpush {
+ struct strpush *prev; /* preceding string on stack */
+ char *prevstring;
+ int prevnleft;
+#if ENABLE_ASH_ALIAS
+ struct alias *ap; /* if push was associated with an alias */
+#endif
+ char *string; /* remember the string since it may change */
+};
+
+struct parsefile {
+ struct parsefile *prev; /* preceding file on stack */
+ int linno; /* current line */
+ int fd; /* file descriptor (or -1 if string) */
+ int nleft; /* number of chars left in this line */
+ int lleft; /* number of chars left in this buffer */
+ char *nextc; /* next char in buffer */
+ char *buf; /* input buffer */
+ struct strpush *strpush; /* for pushing strings at this level */
+ struct strpush basestrpush; /* so pushing one is fast */
+};
+
+static struct parsefile basepf; /* top level input file */
+static struct parsefile *parsefile = &basepf; /* current input file */
+static int startlinno; /* line # where last token started */
+static char *commandname; /* currently executing command */
+static struct strlist *cmdenviron; /* environment for builtin command */
+static int exitstatus; /* exit status of last command */
+static int back_exitstatus; /* exit status of backquoted command */
+
+
+/* ============ Message printing */
+
+static void
+ash_vmsg(const char *msg, va_list ap)
+{
+ fprintf(stderr, "%s: ", arg0);
+ if (commandname) {
+ const char *fmt = (!iflag || parsefile->fd) ?
+ "%s: %d: " : "%s: ";
+ fprintf(stderr, fmt, commandname, startlinno);
+ }
+ vfprintf(stderr, msg, ap);
+ outcslow('\n', stderr);
+}
+
+/*
+ * Exverror is called to raise the error exception. If the second argument
+ * is not NULL then error prints an error message using printf style
+ * formatting. It then raises the error exception.
+ */
+static void ash_vmsg_and_raise(int, const char *, va_list) ATTRIBUTE_NORETURN;
+static void
+ash_vmsg_and_raise(int cond, const char *msg, va_list ap)
+{
+#if DEBUG
+ if (msg) {
+ TRACE(("ash_vmsg_and_raise(%d, \"", cond));
+ TRACEV((msg, ap));
+ TRACE(("\") pid=%d\n", getpid()));
+ } else
+ TRACE(("ash_vmsg_and_raise(%d, NULL) pid=%d\n", cond, getpid()));
+ if (msg)
+#endif
+ ash_vmsg(msg, ap);
+
+ flush_stdout_stderr();
+ raise_exception(cond);
+ /* NOTREACHED */
+}
+
+static void ash_msg_and_raise_error(const char *, ...) ATTRIBUTE_NORETURN;
+static void
+ash_msg_and_raise_error(const char *msg, ...)
+{
+ va_list ap;
+
+ va_start(ap, msg);
+ ash_vmsg_and_raise(EXERROR, msg, ap);
+ /* NOTREACHED */
+ va_end(ap);
+}
+
+static void ash_msg_and_raise(int, const char *, ...) ATTRIBUTE_NORETURN;
+static void
+ash_msg_and_raise(int cond, const char *msg, ...)
+{
+ va_list ap;
+
+ va_start(ap, msg);
+ ash_vmsg_and_raise(cond, msg, ap);
+ /* NOTREACHED */
+ va_end(ap);
+}
+
+/*
+ * error/warning routines for external builtins
+ */
+static void
+ash_msg(const char *fmt, ...)
+{
+ va_list ap;
+
+ va_start(ap, fmt);
+ ash_vmsg(fmt, ap);
+ va_end(ap);
+}
+
+/*
+ * Return a string describing an error. The returned string may be a
+ * pointer to a static buffer that will be overwritten on the next call.
+ * Action describes the operation that got the error.
+ */
+static const char *
+errmsg(int e, const char *em)
+{
+ if (e == ENOENT || e == ENOTDIR) {
+ return em;
+ }
+ return strerror(e);
+}
+
+
+/* ============ Unsorted yet */
+
+
+static void setpwd(const char *, int);
+
/* expand.h */
struct strlist {
/* eval.h */
-static char *commandname; /* currently executing command */
-static struct strlist *cmdenviron; /* environment for builtin command */
-static int exitstatus; /* exit status of last command */
-static int back_exitstatus; /* exit status of backquoted command */
struct backcmd { /* result of evalbackcmd */
static int plinno = 1; /* input line number */
/* number of characters left in input buffer */
-static int parsenleft; /* copy of parsefile->nleft */
-static int parselleft; /* copy of parsefile->lleft */
-
-/* next character in input buffer */
-static char *parsenextc; /* copy of parsefile->nextc */
-
-struct strpush {
- struct strpush *prev; /* preceding string on stack */
- char *prevstring;
- int prevnleft;
-#if ENABLE_ASH_ALIAS
- struct alias *ap; /* if push was associated with an alias */
-#endif
- char *string; /* remember the string since it may change */
-};
-
-struct parsefile {
- struct parsefile *prev; /* preceding file on stack */
- int linno; /* current line */
- int fd; /* file descriptor (or -1 if string) */
- int nleft; /* number of chars left in this line */
- int lleft; /* number of chars left in this buffer */
- char *nextc; /* next char in buffer */
- char *buf; /* input buffer */
- struct strpush *strpush; /* for pushing strings at this level */
- struct strpush basestrpush; /* so pushing one is fast */
-};
+static int parsenleft; /* copy of parsefile->nleft */
+static int parselleft; /* copy of parsefile->lleft */
+
+/* next character in input buffer */
+static char *parsenextc; /* copy of parsefile->nextc */
-static struct parsefile basepf; /* top level input file */
#define basebuf bb_common_bufsiz1 /* buffer for top level input file */
-static struct parsefile *parsefile = &basepf; /* current input file */
static int tokpushback; /* last token pushed back */
static union node *redirnode;
static struct heredoc *heredoc;
static int quoteflag; /* set if (part of) last token was quoted */
-static int startlinno; /* line # where last token started */
static union node *parsecmd(int);
static void fixredir(union node *, const char *, int);
extern char **environ;
-/* output.h */
-
-
-static void outstr(const char *, FILE *);
-static void outcslow(int, FILE *);
-static void flushall(void);
-static void flusherr(void);
-static int out1fmt(const char *, ...)
- __attribute__((__format__(__printf__,1,2)));
-static int fmtstr(char *, size_t, const char *, ...)
- __attribute__((__format__(__printf__,3,4)));
static int preverrout_fd; /* save fd2 before print debug if xflag is set. */
-static void out1str(const char *p)
-{
- outstr(p, stdout);
-}
-
-static void out2str(const char *p)
-{
- outstr(p, stderr);
- flusherr();
-}
-
/*
* Initialization code.
*/
/* main.h */
-/* pid of main shell */
-static int rootpid;
-/* shell level: 0 for the main shell, 1 for its children, and so on */
-static int shlvl;
-#define rootshell (!shlvl)
-
static void readcmdfile(char *);
static int cmdloop(int);
#define ungrabstackstr(s, p) stunalloc((s))
#define stackstrend() ((void *)sstrend)
-#define ckfree(p) free((pointer)(p))
-
/* mystring.h */
};
-#define eflag optlist[0]
-#define fflag optlist[1]
-#define Iflag optlist[2]
-#define iflag optlist[3]
-#define mflag optlist[4]
-#define nflag optlist[5]
-#define sflag optlist[6]
-#define xflag optlist[7]
-#define vflag optlist[8]
-#define Cflag optlist[9]
-#define aflag optlist[10]
-#define bflag optlist[11]
-#define uflag optlist[12]
-#define viflag optlist[13]
-
-#if DEBUG
-#define nolog optlist[14]
-#define debug optlist[15]
-#endif
-
-/* options.c */
-
-
-static const char *const optletters_optnames[] = {
- "e" "errexit",
- "f" "noglob",
- "I" "ignoreeof",
- "i" "interactive",
- "m" "monitor",
- "n" "noexec",
- "s" "stdin",
- "x" "xtrace",
- "v" "verbose",
- "C" "noclobber",
- "a" "allexport",
- "b" "notify",
- "u" "nounset",
- "\0" "vi",
-#if DEBUG
- "\0" "nolog",
- "\0" "debug",
-#endif
-};
-
-#define optletters(n) optletters_optnames[(n)][0]
-#define optnames(n) (&optletters_optnames[(n)][1])
-
-#define NOPTS (sizeof(optletters_optnames)/sizeof(optletters_optnames[0]))
-
-static char optlist[NOPTS];
-
-
-static char *arg0; /* value of $0 */
static struct shparam shellparam; /* $@ current positional parameters */
static char **argptr; /* argument list for builtin commands */
static char *optionarg; /* set by nextopt (like getopt) */
/* trap.h */
-/* trap handler commands */
-static char *trap[NSIG];
-/* current value of signal */
-static char sigmode[NSIG - 1];
-/* indicates specified signal received */
-static char gotsig[NSIG - 1];
-
static void clear_traps(void);
static void setsignal(int);
static void ignoresig(int);
app = __lookupalias(name);
ap = *app;
- INTOFF;
+ INT_OFF;
if (ap) {
if (!(ap->flag & ALIASINUSE)) {
- ckfree(ap->val);
+ free(ap->val);
}
ap->val = savestr(val);
ap->flag &= ~ALIASDEAD;
ap->next = 0;
*app = ap;
}
- INTON;
+ INT_ON;
}
static int
app = __lookupalias(name);
if (*app) {
- INTOFF;
+ INT_OFF;
*app = freealias(*app);
- INTON;
+ INT_ON;
return 0;
}
struct alias *ap, **app;
int i;
- INTOFF;
+ INT_OFF;
for (i = 0; i < ATABSIZE; i++) {
app = &atab[i];
for (ap = *app; ap; ap = *app) {
}
}
}
- INTON;
+ INT_ON;
}
static struct alias *
}
next = ap->next;
- ckfree(ap->name);
- ckfree(ap->val);
- ckfree(ap);
+ free(ap->name);
+ free(ap->val);
+ free(ap);
return next;
}
break;
}
} while (path);
- sh_error("can't cd to %s", dest);
+ ash_msg_and_raise_error("can't cd to %s", dest);
/* NOTREACHED */
out:
if (flags & CD_PRINT)
TRACE(("docd(\"%s\", %d) called\n", dest, flags));
- INTOFF;
+ INT_OFF;
if (!(flags & CD_PHYSICAL)) {
dir = updatepwd(dest);
if (dir)
setpwd(dir, 1);
hashcd();
out:
- INTON;
+ INT_ON;
return err;
}
if (setold) {
setvar("OLDPWD", oldcur, VEXPORT);
}
- INTOFF;
+ INT_OFF;
if (physdir != nullstr) {
if (physdir != oldcur)
free(physdir);
free(oldcur);
}
curdir = dir;
- INTON;
+ INT_ON;
setvar("PWD", dir, VEXPORT);
}
-/* error.c */
-
-/*
- * Errors and exceptions.
- */
-
-/*
- * Code to handle exceptions in C.
- */
-
-
-static void exverror(int, const char *, va_list) ATTRIBUTE_NORETURN;
-
-/*
- * Called to raise an exception. Since C doesn't include exceptions, we
- * just do a longjmp to the exception handler. The type of exception is
- * stored in the global variable "exception".
- */
-static void
-exraise(int e)
-{
-#if DEBUG
- if (handler == NULL)
- abort();
-#endif
- INTOFF;
-
- exception = e;
- longjmp(handler->loc, 1);
-}
-
-
-/*
- * Called from trap.c when a SIGINT is received. (If the user specifies
- * that SIGINT is to be trapped or ignored using the trap builtin, then
- * this routine is not called.) Suppressint is nonzero when interrupts
- * are held using the INTOFF macro. (The test for iflag is just
- * defensive programming.)
- */
-static void
-onint(void)
-{
- int i;
-
- intpending = 0;
- i = EXSIG;
- if (gotsig[SIGINT - 1] && !trap[SIGINT]) {
- if (!(rootshell && iflag)) {
- signal(SIGINT, SIG_DFL);
- raise(SIGINT);
- }
- i = EXINT;
- }
- exraise(i);
- /* NOTREACHED */
-}
-
-static void
-exvwarning(const char *msg, va_list ap)
-{
- FILE *errs;
-
- errs = stderr;
- fprintf(errs, "%s: ", arg0);
- if (commandname) {
- const char *fmt = (!iflag || parsefile->fd) ?
- "%s: %d: " : "%s: ";
- fprintf(errs, fmt, commandname, startlinno);
- }
- vfprintf(errs, msg, ap);
- outcslow('\n', errs);
-}
-
-/*
- * Exverror is called to raise the error exception. If the second argument
- * is not NULL then error prints an error message using printf style
- * formatting. It then raises the error exception.
- */
-static void
-exverror(int cond, const char *msg, va_list ap)
-{
-#if DEBUG
- if (msg) {
- TRACE(("exverror(%d, \"", cond));
- TRACEV((msg, ap));
- TRACE(("\") pid=%d\n", getpid()));
- } else
- TRACE(("exverror(%d, NULL) pid=%d\n", cond, getpid()));
- if (msg)
-#endif
- exvwarning(msg, ap);
-
- flushall();
- exraise(cond);
- /* NOTREACHED */
-}
-
-
-static void
-sh_error(const char *msg, ...)
-{
- va_list ap;
-
- va_start(ap, msg);
- exverror(EXERROR, msg, ap);
- /* NOTREACHED */
- va_end(ap);
-}
-
-
-static void
-exerror(int cond, const char *msg, ...)
-{
- va_list ap;
-
- va_start(ap, msg);
- exverror(cond, msg, ap);
- /* NOTREACHED */
- va_end(ap);
-}
-
-
-/*
- * error/warning routines for external builtins
- */
-static void
-sh_warnx(const char *fmt, ...)
-{
- va_list ap;
-
- va_start(ap, fmt);
- exvwarning(fmt, ap);
- va_end(ap);
-}
-
-
-/*
- * Return a string describing an error. The returned string may be a
- * pointer to a static buffer that will be overwritten on the next call.
- * Action describes the operation that got the error.
- */
-static const char *
-errmsg(int e, const char *em)
-{
- if (e == ENOENT || e == ENOTDIR) {
- return em;
- }
- return strerror(e);
-}
-
-
/* eval.c */
/*
if (flags & EV_EXIT) {
exexit:
- exraise(EXEXIT);
+ raise_exception(EXEXIT);
}
}
expredir(n->nredir.redirect);
if (!backgnd && flags & EV_EXIT && !trap[0])
goto nofork;
- INTOFF;
+ INT_OFF;
jp = makejob(n, 1);
if (forkshell(jp, n, backgnd) == 0) {
- INTON;
+ INT_ON;
flags |= EV_EXIT;
if (backgnd)
flags &=~ EV_TESTED;
if (! backgnd)
status = waitforjob(jp);
exitstatus = status;
- INTON;
+ INT_ON;
}
if (fn.list != NULL)
fixredir(redir, fn.list->text, 1);
else
- sh_error("redir error");
+ ash_msg_and_raise_error("redir error");
}
break;
}
for (lp = n->npipe.cmdlist ; lp ; lp = lp->next)
pipelen++;
flags |= EV_EXIT;
- INTOFF;
+ INT_OFF;
jp = makejob(n, pipelen);
prevfd = -1;
for (lp = n->npipe.cmdlist ; lp ; lp = lp->next) {
if (lp->next) {
if (pipe(pip) < 0) {
close(prevfd);
- sh_error("Pipe call failed");
+ ash_msg_and_raise_error("Pipe call failed");
}
}
if (forkshell(jp, lp->n, n->npipe.backgnd) == 0) {
- INTON;
+ INT_ON;
if (pip[1] >= 0) {
close(pip[0]);
}
exitstatus = waitforjob(jp);
TRACE(("evalpipe: job done exit status %d\n", exitstatus));
}
- INTON;
+ INT_ON;
}
struct job *jp;
if (pipe(pip) < 0)
- sh_error("Pipe call failed");
+ ash_msg_and_raise_error("Pipe call failed");
jp = makejob(n, 1);
if (forkshell(jp, n, FORK_NOJOB) == 0) {
- FORCEINTON;
+ FORCE_INT_ON;
close(pip[0]);
if (pip[1] != 1) {
close(1);
*arglist.lastp = NULL;
argc = 0;
- if (cmd->ncmd.args)
- {
+ if (cmd->ncmd.args) {
bcmd = find_builtin(cmd->ncmd.args->narg.text);
pseudovarflag = bcmd && IS_BUILTIN_ASSIGN(bcmd);
}
find_command(argv[0], &cmdentry, cmd_flag, path);
if (cmdentry.cmdtype == CMDUNKNOWN) {
status = 127;
- flusherr();
+ flush_stderr();
goto bail;
}
if (status) {
/* We have a redirection error. */
if (spclbltin > 0)
- exraise(EXERROR);
+ raise_exception(EXERROR);
bail:
exitstatus = status;
goto out;
default:
/* Fork off a child process if necessary. */
if (!(flags & EV_EXIT) || trap[0]) {
- INTOFF;
+ INT_OFF;
jp = makejob(cmd, 1);
if (forkshell(jp, cmd, FORK_FG) != 0) {
exitstatus = waitforjob(jp);
- INTON;
+ INT_ON;
break;
}
- FORCEINTON;
+ FORCE_INT_ON;
}
listsetvar(varlist.list, VEXPORT|VSTACK);
shellexec(argv, path, cmdentry.u.index);
raise:
longjmp(handler->loc, 1);
}
- FORCEINTON;
+ FORCE_INT_ON;
}
break;
argptr = argv + 1;
optptr = NULL; /* initialize nextopt */
exitstatus = (*cmd->builtin)(argc, argv);
- flushall();
+ flush_stdout_stderr();
cmddone:
exitstatus |= ferror(stdout);
clearerr(stdout);
if (e) {
goto funcdone;
}
- INTOFF;
+ INT_OFF;
savehandler = handler;
handler = &jmploc;
localvars = NULL;
shellparam.malloc = 0;
func->count++;
funcnest++;
- INTON;
+ INT_ON;
shellparam.nparam = argc - 1;
shellparam.p = argv + 1;
#if ENABLE_ASH_GETOPTS
#endif
evaltree(&func->n, flags & EV_TESTED);
funcdone:
- INTOFF;
+ INT_OFF;
funcnest--;
freefunc(func);
poplocalvars();
freeparam(&shellparam);
shellparam = saveparam;
handler = savehandler;
- INTON;
+ INT_ON;
evalskip &= ~SKIPFUNC;
return e;
}
int n = argc > 1 ? number(argv[1]) : 1;
if (n <= 0)
- sh_error(illnum, argv[1]);
+ ash_msg_and_raise_error(illnum, argv[1]);
if (n > loopnest)
n = loopnest;
if (n > 0) {
exitstatus = exerrno;
TRACE(("shellexec failed for %s, errno %d, suppressint %d\n",
argv[0], e, suppressint ));
- exerror(EXEXEC, "%s: %s", argv[0], errmsg(e, E_EXEC));
+ ash_msg_and_raise(EXEXEC, "%s: %s", argv[0], errmsg(e, "not found"));
/* NOTREACHED */
}
execve(cmd, argv, envp);
#endif
if (repeated++) {
- ckfree(argv);
+ free(argv);
} else if (errno == ENOEXEC) {
char **ap;
char **new;
readcmdfile(fullname);
cmdp = cmdlookup(name, 0);
if (cmdp == NULL || cmdp->cmdtype != CMDFUNCTION)
- sh_error("%s not defined in %s", name, fullname);
+ ash_msg_and_raise_error("%s not defined in %s", name, fullname);
stunalloc(fullname);
goto success;
}
entry->u.index = idx;
return;
}
- INTOFF;
+ INT_OFF;
cmdp = cmdlookup(name, 1);
cmdp->cmdtype = CMDNORMAL;
cmdp->param.index = idx;
- INTON;
+ INT_ON;
goto success;
}
if (cmdp && updatetbl)
delete_cmd_entry();
if (act & DO_ERR)
- sh_warnx("%s: %s", name, errmsg(e, E_EXEC));
+ ash_msg("%s: %s", name, errmsg(e, "not found"));
entry->cmdtype = CMDUNKNOWN;
return;
entry->u.cmd = bcmd;
return;
}
- INTOFF;
+ INT_OFF;
cmdp = cmdlookup(name, 1);
cmdp->cmdtype = CMDBUILTIN;
cmdp->param.cmd = bcmd;
- INTON;
+ INT_ON;
success:
cmdp->rehash = 0;
entry->cmdtype = cmdp->cmdtype;
struct tblentry **pp;
struct tblentry *cmdp;
- INTOFF;
+ INT_OFF;
for (tblp = cmdtable ; tblp < &cmdtable[CMDTABLESIZE] ; tblp++) {
pp = tblp;
while ((cmdp = *pp) != NULL) {
builtinloc >= firstchange)
) {
*pp = cmdp->next;
- ckfree(cmdp);
+ free(cmdp);
} else {
pp = &cmdp->next;
}
}
}
- INTON;
+ INT_ON;
}
{
struct tblentry *cmdp;
- INTOFF;
+ INT_OFF;
cmdp = *lastcmdentry;
*lastcmdentry = cmdp->next;
if (cmdp->cmdtype == CMDFUNCTION)
freefunc(cmdp->param.func);
- ckfree(cmdp);
- INTON;
+ free(cmdp);
+ INT_ON;
}
{
struct cmdentry entry;
- INTOFF;
+ INT_OFF;
entry.cmdtype = CMDFUNCTION;
entry.u.func = copyfunc(func);
addcmdentry(name, &entry);
- INTON;
+ INT_ON;
}
if (ifsfirst.endoff > endoff) {
while (ifsfirst.next != NULL) {
struct ifsregion *ifsp;
- INTOFF;
+ INT_OFF;
ifsp = ifsfirst.next->next;
- ckfree(ifsfirst.next);
+ free(ifsfirst.next);
ifsfirst.next = ifsp;
- INTON;
+ INT_ON;
}
if (ifsfirst.begoff > endoff)
ifslastp = NULL;
ifslastp=ifslastp->next;
while (ifslastp->next != NULL) {
struct ifsregion *ifsp;
- INTOFF;
+ INT_OFF;
ifsp = ifslastp->next->next;
- ckfree(ifslastp->next);
+ free(ifslastp->next);
ifslastp->next = ifsp;
- INTON;
+ INT_ON;
}
if (ifslastp->endoff > endoff)
ifslastp->endoff = endoff;
p--;
#if DEBUG
if (p < start) {
- sh_error("missing CTLARI (shouldn't happen)");
+ ash_msg_and_raise_error("missing CTLARI (shouldn't happen)");
}
#endif
}
int syntax = quoted? DQSYNTAX : BASESYNTAX;
struct stackmark smark;
- INTOFF;
+ INT_OFF;
setstackmark(&smark);
dest = expdest;
startloc = dest - (char *)stackblock();
}
if (in.buf)
- ckfree(in.buf);
+ free(in.buf);
if (in.fd >= 0) {
close(in.fd);
back_exitstatus = waitforjob(in.jp);
}
- INTON;
+ INT_ON;
/* Eat all trailing newlines */
dest = expdest;
if (ifslastp == NULL) {
ifsp = &ifsfirst;
} else {
- INTOFF;
+ INT_OFF;
ifsp = (struct ifsregion *)ckmalloc(sizeof(struct ifsregion));
ifsp->next = NULL;
ifslastp->next = ifsp;
- INTON;
+ INT_ON;
}
ifslastp = ifsp;
ifslastp->begoff = start;
{
struct ifsregion *p;
- INTOFF;
+ INT_OFF;
p = ifsfirst.next;
do {
struct ifsregion *ifsp;
ifsp = p->next;
- ckfree(p);
+ free(p);
p = ifsp;
} while (p);
ifslastp = NULL;
ifsfirst.next = NULL;
- INTON;
+ INT_ON;
}
static void expmeta(char *, char *);
goto nometa;
savelastp = exparg.lastp;
- INTOFF;
+ INT_OFF;
p = preglob(str->text, 0, RMESCAPE_ALLOC | RMESCAPE_HEAP);
{
int i = strlen(str->text);
}
expmeta(expdir, p);
- ckfree(expdir);
+ free(expdir);
if (p != str->text)
- ckfree(p);
- INTON;
+ free(p);
+ INT_ON;
if (exparg.lastp == savelastp) {
/*
* no matches
} else
msg = umsg;
}
- sh_error("%.*s: %s%s", end - var - 1, var, msg, tail);
+ ash_msg_and_raise_error("%.*s: %s%s", end - var - 1, var, msg, tail);
}
}
if (parsenleft == EOF_NLEFT || parsefile->buf == NULL)
return PEOF;
- flushall();
+ flush_stdout_stderr();
more = parselleft;
if (more <= 0) {
size_t len;
len = strlen(s);
- INTOFF;
+ INT_OFF;
/*dprintf("*** calling pushstring: %s, %d\n", s, len);*/
if (parsefile->strpush) {
sp = ckmalloc(sizeof(struct strpush));
#endif
parsenextc = s;
parsenleft = len;
- INTON;
+ INT_ON;
}
static void
{
struct strpush *sp = parsefile->strpush;
- INTOFF;
+ INT_OFF;
#if ENABLE_ASH_ALIAS
if (sp->ap) {
if (parsenextc[-1] == ' ' || parsenextc[-1] == '\t') {
checkkwd |= CHKALIAS;
}
if (sp->string != sp->ap->val) {
- ckfree(sp->string);
+ free(sp->string);
}
sp->ap->flag &= ~ALIASINUSE;
if (sp->ap->flag & ALIASDEAD) {
/*dprintf("*** calling popstring: restoring to '%s'\n", parsenextc);*/
parsefile->strpush = sp->prev;
if (sp != &(parsefile->basestrpush))
- ckfree(sp);
- INTON;
+ free(sp);
+ INT_ON;
}
int fd;
int fd2;
- INTOFF;
+ INT_OFF;
fd = open(fname, O_RDONLY);
if (fd < 0) {
if (flags & INPUT_NOFILE_OK)
goto out;
- sh_error("Can't open %s", fname);
+ ash_msg_and_raise_error("Can't open %s", fname);
}
if (fd < 10) {
fd2 = copyfd(fd, 10);
close(fd);
if (fd2 < 0)
- sh_error("Out of file descriptors");
+ ash_msg_and_raise_error("Out of file descriptors");
fd = fd2;
}
setinputfd(fd, flags & INPUT_PUSH_FILE);
out:
- INTON;
+ INT_ON;
return fd;
}
static void
setinputstring(char *string)
{
- INTOFF;
+ INT_OFF;
pushfile();
parsenextc = string;
parsenleft = strlen(string);
parsefile->buf = NULL;
plinno = 1;
- INTON;
+ INT_ON;
}
{
struct parsefile *pf = parsefile;
- INTOFF;
+ INT_OFF;
if (pf->fd >= 0)
close(pf->fd);
if (pf->buf)
- ckfree(pf->buf);
+ free(pf->buf);
while (pf->strpush)
popstring();
parsefile = pf->prev;
- ckfree(pf);
+ free(pf);
parsenleft = parsefile->nleft;
parselleft = parsefile->lleft;
parsenextc = parsefile->nextc;
plinno = parsefile->linno;
- INTON;
+ INT_ON;
}
pgrp = tcgetpgrp(fd);
if (pgrp < 0) {
out:
- sh_warnx("can't access tty; job control turned off");
+ ash_msg("can't access tty; job control turned off");
mflag = on = 0;
goto close;
}
if (argc <= 1) {
usage:
- sh_error(
+ ash_msg_and_raise_error(
"Usage: kill [-s sigspec | -signum | -sigspec] [pid | job]... or\n"
"kill -l [exitstatus]"
);
case 's':
signo = get_signum(optionarg);
if (signo < 0) {
- sh_error(
+ ash_msg_and_raise_error(
"invalid signal number or name: %s",
optionarg
);
if (isdigit(*name))
out1fmt(snlfmt, name);
else
- sh_error("invalid signal number or exit status: %s", *argptr);
+ ash_msg_and_raise_error("invalid signal number or exit status: %s", *argptr);
return 0;
}
-number(*argv + 1) : number(*argv);
}
if (kill(pid, signo) != 0) {
- sh_warnx("(%d) - %m", pid);
+ ash_msg("(%d) - %m", pid);
i = 1;
}
} while (*++argv);
int status;
pid_t pgid;
- INTOFF;
+ INT_OFF;
if (jp->state == JOBDONE)
goto out;
jp->state = JOBRUNNING;
} while (ps++, --i);
out:
status = (mode == FORK_FG) ? waitforjob(jp) : 0;
- INTON;
+ INT_ON;
return status;
}
#endif
struct procstat *ps;
int i;
- INTOFF;
+ INT_OFF;
for (i = jp->nprocs, ps = jp->ps ; --i >= 0 ; ps++) {
if (ps->cmd != nullstr)
- ckfree(ps->cmd);
+ free(ps->cmd);
}
if (jp->ps != &jp->ps0)
- ckfree(jp->ps);
+ free(jp->ps);
jp->used = 0;
set_curjob(jp, CUR_DELETE);
- INTON;
+ INT_ON;
}
int retval;
struct job *jp;
- EXSIGON();
+ EXSIGON;
nextopt(nullstr);
retval = 0;
#endif
return jp;
err:
- sh_error(err_msg, name);
+ ash_msg_and_raise_error(err_msg, name);
}
if (jp->nprocs == 0) {
close(0);
if (open(bb_dev_null, O_RDONLY) != 0)
- sh_error("Can't open %s", bb_dev_null);
+ ash_msg_and_raise_error("Can't open %s", bb_dev_null);
}
}
if (!oldlvl && iflag) {
TRACE(("Fork failed, errno=%d", errno));
if (jp)
freejob(jp);
- sh_error("Cannot fork");
+ ash_msg_and_raise_error("Cannot fork");
}
if (pid == 0)
forkchild(jp, n, mode);
TRACE(("wait returns pid %d, status=%d\n", pid, status));
if (pid <= 0)
return pid;
- INTOFF;
+ INT_OFF;
thisjob = NULL;
for (jp = curjob; jp; jp = jp->prev_job) {
struct procstat *sp;
}
out:
- INTON;
+ INT_ON;
if (thisjob && thisjob == job) {
char s[48 + 1];
for (sp = jp->ps + 1; sp < spend; sp++)
fprintf(out, " | %s", sp->cmd);
outcslow('\n', out);
- flushall();
+ flush_stdout_stderr();
}
static void
xtcsetpgrp(int fd, pid_t pgrp)
{
if (tcsetpgrp(fd, pgrp))
- sh_error("Cannot set tty process group (%m)");
+ ash_msg_and_raise_error("Cannot set tty process group (%m)");
}
#endif /* JOBS */
outcslow('\n', stderr);
}
popstackmark(&smark);
- FORCEINTON; /* enable interrupts */
+ FORCE_INT_ON; /* enable interrupts */
if (s == 1)
goto state1;
else if (s == 2)
}
/* not found in the PATH */
- sh_error(not_found_msg, name);
+ ash_msg_and_raise_error("%s: not found", name);
/* NOTREACHED */
}
return 0;
if (argc > 1)
exitstatus = number(argv[1]);
- exraise(EXEXIT);
+ raise_exception(EXEXIT);
/* NOTREACHED */
}
{
p = realloc(p, nbytes);
if (p == NULL)
- sh_error(bb_msg_memory_exhausted);
+ ash_msg_and_raise_error(bb_msg_memory_exhausted);
return p;
}
{
char *p = strdup(s);
if (!p)
- sh_error(bb_msg_memory_exhausted);
+ ash_msg_and_raise_error(bb_msg_memory_exhausted);
return p;
}
blocksize = MINSIZE;
len = sizeof(struct stack_block) - MINSIZE + blocksize;
if (len < blocksize)
- sh_error(bb_msg_memory_exhausted);
- INTOFF;
+ ash_msg_and_raise_error(bb_msg_memory_exhausted);
+ INT_OFF;
sp = ckmalloc(len);
sp->prev = stackp;
stacknxt = sp->space;
stacknleft = blocksize;
sstrend = stacknxt + blocksize;
stackp = sp;
- INTON;
+ INT_ON;
}
p = stacknxt;
stacknxt += aligned;
{
struct stack_block *sp;
- INTOFF;
+ INT_OFF;
markp = mark->marknext;
while (stackp != mark->stackp) {
sp = stackp;
stackp = sp->prev;
- ckfree(sp);
+ free(sp);
}
stacknxt = mark->stacknxt;
stacknleft = mark->stacknleft;
sstrend = mark->stacknxt + mark->stacknleft;
- INTON;
+ INT_ON;
}
newlen = stacknleft * 2;
if (newlen < stacknleft)
- sh_error(bb_msg_memory_exhausted);
+ ash_msg_and_raise_error(bb_msg_memory_exhausted);
if (newlen < 128)
newlen += 128;
struct stack_block *prevstackp;
size_t grosslen;
- INTOFF;
+ INT_OFF;
oldstackp = stackp;
sp = stackp;
prevstackp = sp->prev;
xmark->stacknleft = stacknleft;
xmark = xmark->marknext;
}
- INTON;
+ INT_ON;
} else {
char *oldspace = stacknxt;
int oldlen = stacknleft;
number(const char *s)
{
if (! is_number(s))
- sh_error(illnum, s);
+ ash_msg_and_raise_error(illnum, s);
return atoi(s);
}
freefunc(struct funcnode *f)
{
if (f && --f->count < 0)
- ckfree(f);
+ free(f);
}
xminusc = minusc;
if (*xargv == NULL) {
if (xminusc)
- sh_error(bb_msg_requires_arg, "-c");
+ ash_msg_and_raise_error(bb_msg_requires_arg, "-c");
sflag = 1;
}
if (iflag == 2 && sflag == 1 && isatty(0) && isatty(1))
optlist[i] = val;
return;
}
- sh_error("Illegal option -o %s", name);
+ ash_msg_and_raise_error("Illegal option -o %s", name);
}
}
optlist[i] = val;
return;
}
- sh_error("Illegal option -%c", flag);
+ ash_msg_and_raise_error("Illegal option -%c", flag);
/* NOTREACHED */
}
if (param->malloc) {
for (ap = param->p ; *ap ; ap++)
- ckfree(*ap);
- ckfree(param->p);
+ free(*ap);
+ free(param->p);
}
}
if (argc > 1)
n = number(argv[1]);
if (n > shellparam.nparam)
- sh_error("can't shift that many");
- INTOFF;
+ ash_msg_and_raise_error("can't shift that many");
+ INT_OFF;
shellparam.nparam -= n;
for (ap1 = shellparam.p ; --n >= 0 ; ap1++) {
if (shellparam.malloc)
- ckfree(*ap1);
+ free(*ap1);
}
ap2 = shellparam.p;
while ((*ap2++ = *ap1++) != NULL);
shellparam.optind = 1;
shellparam.optoff = -1;
#endif
- INTON;
+ INT_ON;
return 0;
}
{
if (argc == 1)
return showvars(nullstr, 0, VUNSET);
- INTOFF;
+ INT_OFF;
options(0);
optschanged();
if (*argptr != NULL) {
setparam(argptr);
}
- INTON;
+ INT_ON;
return 0;
}
if (err) {
*param_optind = 1;
*optoff = -1;
- flushall();
- exraise(EXERROR);
+ flush_stdout_stderr();
+ raise_exception(EXERROR);
}
return done;
}
char **optbase;
if (argc < 3)
- sh_error("Usage: getopts optstring var [arg]");
+ ash_msg_and_raise_error("Usage: getopts optstring var [arg]");
else if (argc == 3) {
optbase = shellparam.p;
if (shellparam.optind > shellparam.nparam + 1) {
c = *p++;
for (q = optstring ; *q != c ; ) {
if (*q == '\0')
- sh_error("Illegal option -%c", c);
+ ash_msg_and_raise_error("Illegal option -%c", c);
if (*++q == ':')
q++;
}
if (*++q == ':') {
if (*p == '\0' && (p = *argptr++) == NULL)
- sh_error("No arg for -%c option", c);
+ ash_msg_and_raise_error("No arg for -%c option", c);
optionarg = p;
p = NULL;
}
}
-/* output.c */
-
-static void
-outstr(const char *p, FILE *file)
-{
- INTOFF;
- fputs(p, file);
- INTON;
-}
-
-static void
-flushall(void)
-{
- INTOFF;
- fflush(stdout);
- fflush(stderr);
- INTON;
-}
-
-static void
-flusherr(void)
-{
- INTOFF;
- fflush(stderr);
- INTON;
-}
-
-static void
-outcslow(int c, FILE *dest)
-{
- INTOFF;
- putc(c, dest);
- fflush(dest);
- INTON;
-}
-
-
-static int
-out1fmt(const char *fmt, ...)
-{
- va_list ap;
- int r;
-
- INTOFF;
- va_start(ap, fmt);
- r = vprintf(fmt, ap);
- va_end(ap);
- INTON;
- return r;
-}
-
-
-static int
-fmtstr(char *outbuf, size_t length, const char *fmt, ...)
-{
- va_list ap;
- int ret;
-
- va_start(ap, fmt);
- INTOFF;
- ret = vsnprintf(outbuf, length, fmt, ap);
- va_end(ap);
- INTON;
- return ret;
-}
-
-
/* parser.c */
savepbq = parsebackquote;
if (setjmp(jmploc.loc)) {
if (str)
- ckfree(str);
+ free(str);
parsebackquote = 0;
handler = savehandler;
longjmp(handler->loc, 1);
}
- INTOFF;
+ INT_OFF;
str = NULL;
savelen = out - (char *)stackblock();
if (savelen > 0) {
}
savehandler = handler;
handler = &jmploc;
- INTON;
+ INT_ON;
if (oldstyle) {
/* We must read until the closing backquote, giving special
treatment to some slashes, and then push the string and
if (str) {
memcpy(out, str, savelen);
STADJUST(savelen, out);
- INTOFF;
- ckfree(str);
+ INT_OFF;
+ free(str);
str = NULL;
- INTON;
+ INT_ON;
}
parsebackquote = savepbq;
handler = savehandler;
static void
synerror(const char *msg)
{
- sh_error("Syntax error: %s", msg);
+ ash_msg_and_raise_error("Syntax error: %s", msg);
/* NOTREACHED */
}
size_t len = 0;
if (pipe(pip) < 0)
- sh_error("Pipe call failed");
+ ash_msg_and_raise_error("Pipe call failed");
if (redir->type == NHERE) {
len = strlen(redir->nhere.doc->narg.text);
if (len <= PIPESIZE) {
return f;
ecreate:
- sh_error("cannot create %s: %s", fname, errmsg(errno, E_CREAT));
+ ash_msg_and_raise_error("cannot create %s: %s", fname, errmsg(errno, "Directory nonexistent"));
eopen:
- sh_error("cannot open %s: %s", fname, errmsg(errno, E_OPEN));
+ ash_msg_and_raise_error("cannot open %s: %s", fname, errmsg(errno, "No such file"));
}
static void dupredirect(union node *redir, int f)
return;
}
sv = NULL;
- INTOFF;
+ INT_OFF;
if (flags & REDIR_PUSH) {
struct redirtab *q;
q = ckmalloc(sizeof(struct redirtab));
if (i != EBADF) {
close(newfd);
errno = i;
- sh_error("%d: %m", fd);
+ ash_msg_and_raise_error("%d: %m", fd);
/* NOTREACHED */
}
} else {
}
dupredirect(n, newfd);
} while ((n = n->nfile.next));
- INTON;
+ INT_ON;
if (flags & REDIR_SAVEFD2 && sv && sv->renamed[2] >= 0)
preverrout_fd = sv->renamed[2];
}
if (--nullredirs >= 0)
return;
- INTOFF;
+ INT_OFF;
rp = redirlist;
for (i = 0 ; i < 10 ; i++) {
if (rp->renamed[i] != EMPTY) {
}
redirlist = rp->next;
nullredirs = rp->nullredirs;
- ckfree(rp);
- INTON;
+ free(rp);
+ INT_ON;
}
/*
if (errno == EMFILE)
return EMPTY;
else
- sh_error("%d: %m", from);
+ ash_msg_and_raise_error("%d: %m", from);
}
return newfd;
}
struct jmploc *volatile savehandler = handler;
struct jmploc jmploc;
- SAVEINT(saveint);
+ SAVE_INT(saveint);
err = setjmp(jmploc.loc) * 2;
if (!err) {
handler = &jmploc;
handler = savehandler;
if (err && exception != EXERROR)
longjmp(handler->loc, 1);
- RESTOREINT(saveint);
+ RESTORE_INT(saveint);
return err;
}
while (*ap) {
signo = get_signum(*ap);
if (signo < 0)
- sh_error("%s: bad trap", *ap);
- INTOFF;
+ ash_msg_and_raise_error("%s: bad trap", *ap);
+ INT_OFF;
if (action) {
if (LONE_DASH(action))
action = NULL;
action = savestr(action);
}
if (trap[signo])
- ckfree(trap[signo]);
+ free(trap[signo]);
trap[signo] = action;
if (signo != 0)
setsignal(signo);
- INTON;
+ INT_ON;
ap++;
}
return 0;
for (tp = trap ; tp < &trap[NSIG] ; tp++) {
if (*tp && **tp) { /* trap not NULL or SIG_IGN */
- INTOFF;
- ckfree(*tp);
+ INT_OFF;
+ free(*tp);
*tp = NULL;
if (tp != &trap[0])
setsignal(tp - trap);
- INTON;
+ INT_ON;
}
}
}
if (exsig || (signo == SIGINT && !trap[SIGINT])) {
if (!suppressint)
- onint();
+ raise_interrupt();
intpending = 1;
}
}
trap[0] = NULL;
evalstring(p, 0);
}
- flushall();
+ flush_stdout_stderr();
out:
setjobctl(0);
_exit(status);
struct jmploc *volatile savehandler = handler;
struct jmploc jmploc;
- SAVEINT(saveint);
+ SAVE_INT(saveint);
if (setjmp(jmploc.loc))
err = 1;
else {
err = 0;
}
handler = savehandler;
- RESTOREINT(saveint);
+ RESTORE_INT(saveint);
return err;
}
#endif
p = strchrnul(q, '=');
namelen = p - name;
if (!namelen || p != q)
- sh_error("%.*s: bad variable name", namelen, name);
+ ash_msg_and_raise_error("%.*s: bad variable name", namelen, name);
vallen = 0;
if (val == NULL) {
flags |= VUNSET;
} else {
vallen = strlen(val);
}
- INTOFF;
+ INT_OFF;
nameeq = ckmalloc(namelen + vallen + 2);
p = memcpy(nameeq, name, namelen) + namelen;
if (val) {
}
*p = '\0';
setvareq(nameeq, flags | VNOSAVE);
- INTON;
+ INT_ON;
}
if (flags & VNOSAVE)
free(s);
n = vp->text;
- sh_error("%.*s: is read only", strchrnul(n, '=') - n, n);
+ ash_msg_and_raise_error("%.*s: is read only", strchrnul(n, '=') - n, n);
}
if (flags & VNOSET)
(*vp->func)(strchrnul(s, '=') + 1);
if ((vp->flags & (VTEXTFIXED|VSTACK)) == 0)
- ckfree(vp->text);
+ free((char*)vp->text);
flags |= vp->flags & ~(VTEXTFIXED|VSTACK|VNOSAVE|VUNSET);
} else {
if (!lp)
return;
- INTOFF;
+ INT_OFF;
do {
setvareq(lp->text, flags);
} while ((lp = lp->next));
- INTON;
+ INT_ON;
}
struct var **vpp;
struct var *vp;
- INTOFF;
+ INT_OFF;
lvp = ckmalloc(sizeof(struct localvar));
if (LONE_DASH(name)) {
char *p;
lvp->vp = vp;
lvp->next = localvars;
localvars = lvp;
- INTON;
+ INT_ON;
}
TRACE(("poplocalvar %s", vp ? vp->text : "-"));
if (vp == NULL) { /* $- saved */
memcpy(optlist, lvp->text, sizeof(optlist));
- ckfree(lvp->text);
+ free((char*)lvp->text);
optschanged();
} else if ((lvp->flags & (VUNSET|VSTRFIXED)) == VUNSET) {
unsetvar(vp->text);
if (vp->func)
(*vp->func)(strchrnul(lvp->text, '=') + 1);
if ((vp->flags & (VTEXTFIXED|VSTACK)) == 0)
- ckfree(vp->text);
+ free((char*)vp->text);
vp->flags = lvp->flags;
vp->text = lvp->text;
}
- ckfree(lvp);
+ free(lvp);
}
}
if (flags & VUNSET)
goto ok;
if ((flags & VSTRFIXED) == 0) {
- INTOFF;
+ INT_OFF;
if ((flags & (VTEXTFIXED|VSTACK)) == 0)
- ckfree(vp->text);
+ free((char*)vp->text);
*vpp = vp->next;
- ckfree(vp);
- INTON;
+ free(vp);
+ INT_ON;
} else {
setvar(s, 0, 0);
vp->flags &= ~VEXPORT;
}
-ok:
+ ok:
retval = 0;
}
out:
arith_t result;
int errcode = 0;
- INTOFF;
+ INT_OFF;
result = arith(s, &errcode);
if (errcode < 0) {
if (errcode == -3)
- sh_error("exponent less than 0");
+ ash_msg_and_raise_error("exponent less than 0");
else if (errcode == -2)
- sh_error("divide by zero");
+ ash_msg_and_raise_error("divide by zero");
else if (errcode == -5)
- sh_error("expression recursion loop detected");
+ ash_msg_and_raise_error("expression recursion loop detected");
else
synerror(s);
}
- INTON;
+ INT_ON;
return result;
}
ap = argv + 1;
if (!*ap)
- sh_error("expression expected");
+ ash_msg_and_raise_error("expression expected");
for (ap = argv + 1; *ap; ap++) {
i = dash_arith(*ap);
}
case 'n':
nchars = strtol(optionarg, &p, 10);
if (*p)
- sh_error("invalid count");
+ ash_msg_and_raise_error("invalid count");
nch_flag = (nchars > 0);
break;
case 's':
int scale;
ts.tv_usec = strtol(p, &p2, 10);
if (*p2)
- sh_error("invalid timeout");
+ ash_msg_and_raise_error("invalid timeout");
scale = p2 - p;
/* normalize to usec */
if (scale > 6)
- sh_error("invalid timeout");
+ ash_msg_and_raise_error("invalid timeout");
while (scale++ < 6)
ts.tv_usec *= 10;
}
} else if (*p) {
- sh_error("invalid timeout");
+ ash_msg_and_raise_error("invalid timeout");
}
if ( ! ts.tv_sec && ! ts.tv_usec)
- sh_error("invalid timeout");
+ ash_msg_and_raise_error("invalid timeout");
break;
#endif
case 'r':
}
ap = argptr;
if (*ap == NULL)
- sh_error("arg count");
+ ash_msg_and_raise_error("arg count");
ifs = bltinlookup("IFS");
if (ifs == NULL)
ifs = defifs;
symbolic_mode = 1;
}
- INTOFF;
+ INT_OFF;
mask = umask(0);
umask(mask);
- INTON;
+ INT_ON;
ap = *argptr;
if (ap == NULL) {
mask = 0;
do {
if (*ap >= '8' || *ap < '0')
- sh_error(illnum, argv[1]);
+ ash_msg_and_raise_error(illnum, argv[1]);
mask = (mask << 3) + (*ap - '0');
} while (*++ap != '\0');
umask(mask);
} else {
mask = ~mask & 0777;
if (!bb_parse_mode(ap, &mask)) {
- sh_error("Illegal mode: %s", ap);
+ ash_msg_and_raise_error("Illegal mode: %s", ap);
}
umask(~mask & 0777);
}
char *p = *argptr;
if (all || argptr[1])
- sh_error("too many arguments");
+ ash_msg_and_raise_error("too many arguments");
if (strncmp(p, "unlimited\n", 9) == 0)
val = RLIM_INFINITY;
else {
break;
}
if (c)
- sh_error("bad number");
+ ash_msg_and_raise_error("bad number");
val *= l->factor;
}
}
if (how & SOFT)
limit.rlim_cur = val;
if (setrlimit(l->cmd, &limit) < 0)
- sh_error("error setting limit (%m)");
+ ash_msg_and_raise_error("error setting limit (%m)");
} else {
printlim(how, &limit, l);
}
projects / oweals / busybox.git / commitdiff