summaryrefslogtreecommitdiff
path: root/main.c
diff options
context:
space:
mode:
Diffstat (limited to 'main.c')
-rw-r--r--main.c792
1 files changed, 792 insertions, 0 deletions
diff --git a/main.c b/main.c
new file mode 100644
index 0000000..41d4d80
--- /dev/null
+++ b/main.c
@@ -0,0 +1,792 @@
+/* $NetBSD: main.c,v 1.23 2018/05/08 16:37:59 kamil Exp $ */
+
+/*
+ * startup, main loop, environments and error handling
+ */
+#include <sys/cdefs.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+#include <locale.h>
+#include <time.h>
+
+#ifndef lint
+__RCSID("$NetBSD: main.c,v 1.23 2018/05/08 16:37:59 kamil Exp $");
+#endif
+
+
+#define EXTERN /* define EXTERNs in sh.h */
+
+#include "sh.h"
+
+extern char **environ;
+
+/*
+ * global data
+ */
+
+static void reclaim ARGS((void));
+static void remove_temps ARGS((struct temp *tp));
+static int is_restricted ARGS((char *name));
+
+/*
+ * shell initialization
+ */
+
+static const char initifs[] = "IFS= \t\n";
+
+static const char initsubs[] = "${PS2=> } ${PS3=#? } ${PS4=+ }";
+
+static const char version_param[] =
+#ifdef KSH
+ "KSH_VERSION"
+#else /* KSH */
+ "SH_VERSION"
+#endif /* KSH */
+ ;
+
+static const char *const initcoms [] = {
+ "typeset", "-x", "SHELL", "PATH", "HOME", NULL,
+ "typeset", "-r", version_param, NULL,
+ "typeset", "-i", "PPID", NULL,
+ "typeset", "-i", "OPTIND=1", NULL,
+#ifdef KSH
+ "eval", "typeset -i RANDOM MAILCHECK=\"${MAILCHECK-600}\" SECONDS=\"${SECONDS-0}\" TMOUT=\"${TMOUT-0}\"", NULL,
+#endif /* KSH */
+ "alias",
+ /* Standard ksh aliases */
+ "hash=alias -t", /* not "alias -t --": hash -r needs to work */
+ "type=whence -v",
+#ifdef JOBS
+ "stop=kill -STOP",
+ "suspend=kill -STOP $$",
+#endif
+#ifdef KSH
+ "autoload=typeset -fu",
+ "functions=typeset -f",
+# ifdef HISTORY
+ "history=fc -l",
+# endif /* HISTORY */
+ "integer=typeset -i",
+ "nohup=nohup ",
+ "local=typeset",
+ "r=fc -e -",
+#endif /* KSH */
+#ifdef KSH
+ /* Aliases that are builtin commands in at&t */
+ "login=exec login",
+#ifndef __NetBSD__
+ "newgrp=exec newgrp",
+#endif /* __NetBSD__ */
+#endif /* KSH */
+ NULL,
+ /* this is what at&t ksh seems to track, with the addition of emacs */
+ "alias", "-tU",
+ "cat", "cc", "chmod", "cp", "date", "ed", "emacs", "grep", "ls",
+ "mail", "make", "mv", "pr", "rm", "sed", "sh", "vi", "who",
+ NULL,
+#ifdef EXTRA_INITCOMS
+ EXTRA_INITCOMS, NULL,
+#endif /* EXTRA_INITCOMS */
+ NULL
+};
+
+int
+main(int argc, char *argv[])
+{
+ int i;
+ int argi;
+ Source *s;
+ struct block *l;
+ int restricted, errexit;
+ char **wp;
+ struct env env;
+ pid_t ppid;
+
+ /* make sure argv[] is sane */
+ if (!*argv) {
+ static const char *empty_argv[] = {
+ "pdksh", (char *) 0
+ };
+
+ argv = (char **)__UNCONST(empty_argv);
+ argc = 1;
+ }
+ kshname = *argv;
+
+ ainit(&aperm); /* initialize permanent Area */
+
+ /* set up base environment */
+ memset(&env, 0, sizeof(env));
+ env.type = E_NONE;
+ ainit(&env.area);
+ e = &env;
+ newblock(); /* set up global l->vars and l->funs */
+
+ /* Do this first so output routines (eg, errorf, shellf) can work */
+ initio();
+
+ initvar();
+
+ initctypes();
+
+ inittraps();
+
+#ifdef KSH
+ coproc_init();
+#endif /* KSH */
+
+ /* set up variable and command dictionaries */
+ tinit(&taliases, APERM, 0);
+ tinit(&aliases, APERM, 0);
+ tinit(&homedirs, APERM, 0);
+
+ /* define shell keywords */
+ initkeywords();
+
+ /* define built-in commands */
+ tinit(&builtins, APERM, 64); /* must be 2^n (currently 40 builtins) */
+ for (i = 0; shbuiltins[i].name != NULL; i++)
+ builtin(shbuiltins[i].name, shbuiltins[i].func);
+ for (i = 0; kshbuiltins[i].name != NULL; i++)
+ builtin(kshbuiltins[i].name, kshbuiltins[i].func);
+
+ init_histvec();
+
+ def_path = DEFAULT__PATH;
+#if defined(HAVE_CONFSTR) && defined(_CS_PATH)
+ {
+ size_t len = confstr(_CS_PATH, (char *) 0, 0);
+ char *new;
+
+ if (len > 0) {
+ confstr(_CS_PATH, new = alloc(len + 1, APERM), len + 1);
+ def_path = new;
+ }
+ }
+#endif /* HAVE_CONFSTR && _CS_PATH */
+
+ /* Set PATH to def_path (will set the path global variable).
+ * (import of environment below will probably change this setting).
+ */
+ {
+ struct tbl *vp = global("PATH");
+ /* setstr can't fail here */
+ setstr(vp, def_path, KSH_RETURN_ERROR);
+ }
+
+
+ /* Turn on nohup by default for now - will change to off
+ * by default once people are aware of its existence
+ * (at&t ksh does not have a nohup option - it always sends
+ * the hup).
+ */
+ Flag(FNOHUP) = 1;
+
+ /* Turn on brace expansion by default. At&t ksh's that have
+ * alternation always have it on. BUT, posix doesn't have
+ * brace expansion, so set this before setting up FPOSIX
+ * (change_flag() clears FBRACEEXPAND when FPOSIX is set).
+ */
+#ifdef BRACE_EXPAND
+ Flag(FBRACEEXPAND) = 1;
+#endif /* BRACE_EXPAND */
+
+ /* set posix flag just before environment so that it will have
+ * exactly the same effect as the POSIXLY_CORRECT environment
+ * variable. If this needs to be done sooner to ensure correct posix
+ * operation, an initial scan of the environment will also have
+ * done sooner.
+ */
+#ifdef POSIXLY_CORRECT
+ change_flag(FPOSIX, OF_SPECIAL, 1);
+#endif /* POSIXLY_CORRECT */
+
+ /* Set edit mode to emacs by default, may be overridden
+ * by the environment or the user. Also, we want tab completion
+ * on in vi by default. */
+#if defined(EDIT) && defined(EMACS)
+ change_flag(FEMACS, OF_SPECIAL, 1);
+#endif /* EDIT && EMACS */
+#if defined(EDIT) && defined(VI)
+ Flag(FVITABCOMPLETE) = 1;
+#endif /* EDIT && VI */
+
+ /* import environment */
+ if (environ != NULL)
+ for (wp = environ; *wp != NULL; wp++)
+ typeset(*wp, IMPORT|EXPORT, 0, 0, 0);
+
+ kshpid = procpid = getpid();
+ typeset(initifs, 0, 0, 0, 0); /* for security */
+
+ /* assign default shell variable values */
+ substitute(initsubs, 0);
+
+ /* Figure out the current working directory and set $PWD */
+ {
+ struct stat s_pwd, s_dot;
+ struct tbl *pwd_v = global("PWD");
+ char *pwd = str_val(pwd_v);
+ char *pwdx = pwd;
+
+ /* Try to use existing $PWD if it is valid */
+ if (!ISABSPATH(pwd)
+ || stat(pwd, &s_pwd) < 0 || stat(".", &s_dot) < 0
+ || s_pwd.st_dev != s_dot.st_dev
+ || s_pwd.st_ino != s_dot.st_ino)
+ pwdx = (char *) 0;
+ set_current_wd(pwdx);
+ if (current_wd[0])
+ simplify_path(current_wd);
+ /* Only set pwd if we know where we are or if it had a
+ * bogus value
+ */
+ if (current_wd[0] || pwd != null)
+ /* setstr can't fail here */
+ setstr(pwd_v, current_wd, KSH_RETURN_ERROR);
+ }
+ ppid = getppid();
+ setint(global("PPID"), (long) ppid);
+#ifdef KSH
+ setint(global("RANDOM"), (long) (time((time_t *)0) * kshpid * ppid));
+#endif /* KSH */
+ /* setstr can't fail here */
+ setstr(global(version_param), ksh_version, KSH_RETURN_ERROR);
+
+ /* execute initialization statements */
+ for (wp = (char**)__UNCONST(initcoms); *wp != NULL; wp++) {
+ shcomexec(wp);
+ for (; *wp != NULL; wp++)
+ ;
+ }
+
+
+ ksheuid = geteuid();
+ safe_prompt = ksheuid ? "$ " : "# ";
+ {
+ struct tbl *vp = global("PS1");
+
+ /* Set PS1 if it isn't set, or we are root and prompt doesn't
+ * contain a #.
+ */
+ if (!(vp->flag & ISSET)
+ || (!ksheuid && !strchr(str_val(vp), '#')))
+ /* setstr can't fail here */
+ setstr(vp, safe_prompt, KSH_RETURN_ERROR);
+ }
+
+ /* Set this before parsing arguments */
+ Flag(FPRIVILEGED) = getuid() != ksheuid || getgid() != getegid();
+
+ /* this to note if monitor is set on command line (see below) */
+ Flag(FMONITOR) = 127;
+ argi = parse_args(argv, OF_CMDLINE, (int *) 0);
+ if (argi < 0) {
+ exit(1);
+ /* NOTREACHED */
+ }
+
+ if (Flag(FCOMMAND)) {
+ s = pushs(SSTRING, ATEMP);
+ if (!(s->start = s->str = argv[argi++]))
+ errorf("-c requires an argument");
+ if (argv[argi])
+ kshname = argv[argi++];
+ } else if (argi < argc && !Flag(FSTDIN)) {
+ s = pushs(SFILE, ATEMP);
+ s->file = argv[argi++];
+ s->u.shf = shf_open(s->file, O_RDONLY, 0, SHF_MAPHI|SHF_CLEXEC);
+ if (s->u.shf == NULL) {
+ exstat = 127; /* POSIX */
+ errorf("%s: %s", s->file, strerror(errno));
+ }
+ kshname = s->file;
+ } else {
+ Flag(FSTDIN) = 1;
+ s = pushs(SSTDIN, ATEMP);
+ s->file = "<stdin>";
+ s->u.shf = shf_fdopen(0, SHF_RD | can_seek(0),
+ (struct shf *) 0);
+ if (isatty(0) && isatty(2)) {
+ Flag(FTALKING) = Flag(FTALKING_I) = 1;
+ /* The following only if isatty(0) */
+ s->flags |= SF_TTY;
+ s->u.shf->flags |= SHF_INTERRUPT;
+ s->file = (char *) 0;
+ }
+ }
+
+ /* This bizarreness is mandated by POSIX */
+ {
+ struct stat s_stdin;
+
+ if (fstat(0, &s_stdin) >= 0 && S_ISCHR(s_stdin.st_mode) &&
+ Flag(FTALKING))
+ reset_nonblock(0);
+ }
+
+ /* initialize job control */
+ i = Flag(FMONITOR) != 127;
+ Flag(FMONITOR) = 0;
+ j_init(i);
+#ifdef EDIT
+ /* Do this after j_init(), as tty_fd is not initialized 'til then */
+ if (Flag(FTALKING))
+ x_init();
+#endif
+
+ l = e->loc;
+ l->argv = &argv[argi - 1];
+ l->argc = argc - argi;
+ l->argv[0] = (char *)__UNCONST(kshname);
+ getopts_reset(1);
+
+ /* Disable during .profile/ENV reading */
+ restricted = Flag(FRESTRICTED);
+ Flag(FRESTRICTED) = 0;
+ errexit = Flag(FERREXIT);
+ Flag(FERREXIT) = 0;
+
+ /* Do this before profile/$ENV so that if it causes problems in them,
+ * user will know why things broke.
+ */
+ if (!current_wd[0] && Flag(FTALKING))
+ warningf(false, "Cannot determine current working directory");
+
+ if (Flag(FLOGIN)) {
+ include(KSH_SYSTEM_PROFILE, 0, (char **) 0, 1);
+ if (!Flag(FPRIVILEGED))
+ include(substitute("$HOME/.profile", 0), 0,
+ (char **) 0, 1);
+ }
+
+ if (Flag(FPRIVILEGED))
+ include("/etc/suid_profile", 0, (char **) 0, 1);
+ else {
+ char *env_file;
+
+#ifndef KSH
+ if (!Flag(FPOSIX))
+ env_file = null;
+ else
+#endif /* !KSH */
+ /* include $ENV */
+ env_file = str_val(global("ENV"));
+
+#ifdef DEFAULT_ENV
+ /* If env isn't set, include default environment */
+ if (env_file == null)
+ env_file = __UNCONST(DEFAULT_ENV);
+#endif /* DEFAULT_ENV */
+ env_file = substitute(env_file, DOTILDE);
+ if (*env_file != '\0')
+ include(env_file, 0, (char **) 0, 1);
+ else if (Flag(FTALKING))
+ include(substitute("$HOME/kshrc.ksh", 0), 0,
+ (char **) 0, 1);
+ }
+
+ if (is_restricted(argv[0]) || is_restricted(str_val(global("SHELL"))))
+ restricted = 1;
+ if (restricted) {
+ static const char *const restr_com[] = {
+ "typeset", "-r", "PATH",
+ "ENV", "SHELL",
+ (char *) 0
+ };
+ shcomexec((char **)__UNCONST(restr_com));
+ /* After typeset command... */
+ Flag(FRESTRICTED) = 1;
+ }
+ if (errexit)
+ Flag(FERREXIT) = 1;
+
+ if (Flag(FTALKING)) {
+ hist_init(s);
+#ifdef KSH
+ alarm_init();
+#endif /* KSH */
+ } else
+ Flag(FTRACKALL) = 1; /* set after ENV */
+
+ setlocale(LC_CTYPE, "");
+ shell(s, true); /* doesn't return */
+ return 0;
+}
+
+int
+include(name, argc, argv, intr_ok)
+ const char *name;
+ int argc;
+ char **argv;
+ int intr_ok;
+{
+ Source *volatile s = NULL;
+ struct shf *shf;
+ char **volatile old_argv;
+ volatile int old_argc;
+ int i;
+
+ shf = shf_open(name, O_RDONLY, 0, SHF_MAPHI|SHF_CLEXEC);
+ if (shf == NULL)
+ return -1;
+
+ if (argv) {
+ old_argv = e->loc->argv;
+ old_argc = e->loc->argc;
+ } else {
+ old_argv = (char **) 0;
+ old_argc = 0;
+ }
+ newenv(E_INCL);
+ i = ksh_sigsetjmp(e->jbuf, 0);
+ if (i) {
+ if (s) /* Do this before quitenv(), which frees the memory */
+ shf_close(s->u.shf);
+ quitenv();
+ if (old_argv) {
+ e->loc->argv = old_argv;
+ e->loc->argc = old_argc;
+ }
+ switch (i) {
+ case LRETURN:
+ case LERROR:
+ return exstat & 0xff; /* see below */
+ case LINTR:
+ /* intr_ok is set if we are including .profile or $ENV.
+ * If user ^C's out, we don't want to kill the shell...
+ */
+ if (intr_ok && (exstat - 128) != SIGTERM)
+ return 1;
+ /* fall through... */
+ case LEXIT:
+ case LLEAVE:
+ case LSHELL:
+ unwind(i);
+ /*NOREACHED*/
+ default:
+ internal_errorf(1, "include: %d", i);
+ /*NOREACHED*/
+ }
+ }
+ if (argv) {
+ e->loc->argv = argv;
+ e->loc->argc = argc;
+ }
+ s = pushs(SFILE, ATEMP);
+ s->u.shf = shf;
+ s->file = str_save(name, ATEMP);
+ i = shell(s, false);
+ shf_close(s->u.shf);
+ quitenv();
+ if (old_argv) {
+ e->loc->argv = old_argv;
+ e->loc->argc = old_argc;
+ }
+ return i & 0xff; /* & 0xff to ensure value not -1 */
+}
+
+int
+command(comm)
+ const char *comm;
+{
+ Source *s;
+ int r;
+
+ s = pushs(SSTRING, ATEMP);
+ s->start = s->str = comm;
+ r = shell(s, false);
+ afree(s, ATEMP);
+ return r;
+}
+
+/*
+ * run the commands from the input source, returning status.
+ */
+int
+shell(s, toplevel)
+ Source *volatile s; /* input source */
+ int volatile toplevel;
+{
+ struct op *t;
+ volatile int wastty = s->flags & SF_TTY;
+ volatile int attempts = 13;
+ volatile int interactive = Flag(FTALKING) && toplevel;
+ Source *volatile old_source = source;
+ int i;
+
+ newenv(E_PARSE);
+ if (interactive)
+ really_exit = 0;
+ i = ksh_sigsetjmp(e->jbuf, 0);
+ if (i) {
+ switch (i) {
+ case LINTR: /* we get here if SIGINT not caught or ignored */
+ case LERROR:
+ case LSHELL:
+ if (interactive) {
+ if (i == LINTR)
+ shellf("%s", newline);
+ /* Reset any eof that was read as part of a
+ * multiline command.
+ */
+ if (Flag(FIGNOREEOF) && s->type == SEOF
+ && wastty)
+ s->type = SSTDIN;
+ /* Used by exit command to get back to
+ * top level shell. Kind of strange since
+ * interactive is set if we are reading from
+ * a tty, but to have stopped jobs, one only
+ * needs FMONITOR set (not FTALKING/SF_TTY)...
+ */
+ /* toss any input we have so far */
+ s->start = s->str = null;
+ break;
+ }
+ /* fall through... */
+ case LEXIT:
+ case LLEAVE:
+ case LRETURN:
+ source = old_source;
+ quitenv();
+ unwind(i); /* keep on going */
+ /*NOREACHED*/
+ default:
+ source = old_source;
+ quitenv();
+ internal_errorf(1, "shell: %d", i);
+ /*NOREACHED*/
+ }
+ }
+
+ while (1) {
+ if (trap)
+ runtraps(0);
+
+ if (s->next == NULL) {
+ if (Flag(FVERBOSE))
+ s->flags |= SF_ECHO;
+ else
+ s->flags &= ~SF_ECHO;
+ }
+
+ if (interactive) {
+ j_notify();
+#ifdef KSH
+ mcheck();
+#endif /* KSH */
+ set_prompt(PS1, s);
+ }
+
+ t = compile(s);
+ if (t != NULL && t->type == TEOF) {
+ if (wastty && Flag(FIGNOREEOF) && --attempts > 0) {
+ shellf("Use `exit' to leave ksh\n");
+ s->type = SSTDIN;
+ } else if (wastty && !really_exit
+ && j_stopped_running())
+ {
+ really_exit = 1;
+ s->type = SSTDIN;
+ } else {
+ /* this for POSIX, which says EXIT traps
+ * shall be taken in the environment
+ * immediately after the last command
+ * executed.
+ */
+ if (toplevel)
+ unwind(LEXIT);
+ break;
+ }
+ }
+
+ if (t && (!Flag(FNOEXEC) || (s->flags & SF_TTY)))
+ exstat = execute(t, 0);
+
+ if (t != NULL && t->type != TEOF && interactive && really_exit)
+ really_exit = 0;
+
+ reclaim();
+ }
+ quitenv();
+ source = old_source;
+ return exstat;
+}
+
+/* return to closest error handler or shell(), exit if none found */
+void
+unwind(i)
+ int i;
+{
+ /* ordering for EXIT vs ERR is a bit odd (this is what at&t ksh does) */
+ if (i == LEXIT || (Flag(FERREXIT) && (i == LERROR || i == LINTR)
+ && sigtraps[SIGEXIT_].trap))
+ {
+ runtrap(&sigtraps[SIGEXIT_]);
+ i = LLEAVE;
+ } else if (Flag(FERREXIT) && (i == LERROR || i == LINTR)) {
+ runtrap(&sigtraps[SIGERR_]);
+ i = LLEAVE;
+ }
+ while (1) {
+ switch (e->type) {
+ case E_PARSE:
+ case E_FUNC:
+ case E_INCL:
+ case E_LOOP:
+ case E_ERRH:
+ ksh_siglongjmp(e->jbuf, i);
+ /*NOTREACHED*/
+
+ case E_NONE:
+ if (i == LINTR)
+ e->flags |= EF_FAKE_SIGDIE;
+ /* Fall through... */
+
+ default:
+ quitenv();
+ }
+ }
+}
+
+void
+newenv(type)
+ int type;
+{
+ struct env *ep;
+
+ ep = (struct env *) alloc(sizeof(*ep), ATEMP);
+ ep->type = type;
+ ep->flags = 0;
+ ainit(&ep->area);
+ ep->loc = e->loc;
+ ep->savefd = NULL;
+ ep->oenv = e;
+ ep->temps = NULL;
+ e = ep;
+}
+
+void
+quitenv()
+{
+ struct env *ep = e;
+ int fd;
+
+ if (ep->oenv && ep->oenv->loc != ep->loc)
+ popblock();
+ if (ep->savefd != NULL) {
+ for (fd = 0; fd < NUFILE; fd++)
+ /* if ep->savefd[fd] < 0, means fd was closed */
+ if (ep->savefd[fd])
+ restfd(fd, ep->savefd[fd]);
+ if (ep->savefd[2]) /* Clear any write errors */
+ shf_reopen(2, SHF_WR, shl_out);
+ }
+ reclaim();
+
+ /* Bottom of the stack.
+ * Either main shell is exiting or cleanup_parents_env() was called.
+ */
+ if (ep->oenv == NULL) {
+ if (ep->type == E_NONE) { /* Main shell exiting? */
+ if (Flag(FTALKING))
+ hist_finish();
+ j_exit();
+ if (ep->flags & EF_FAKE_SIGDIE) {
+ int sig = exstat - 128;
+
+ /* ham up our death a bit (at&t ksh
+ * only seems to do this for SIGTERM)
+ * Don't do it for SIGQUIT, since we'd
+ * dump a core..
+ */
+ if (sig == SIGINT || sig == SIGTERM) {
+ setsig(&sigtraps[sig], SIG_DFL,
+ SS_RESTORE_CURR|SS_FORCE);
+ kill(0, sig);
+ }
+ }
+ }
+ exit(exstat);
+ }
+
+ e = e->oenv;
+ afree(ep, ATEMP);
+}
+
+/* Called after a fork to cleanup stuff left over from parents environment */
+void
+cleanup_parents_env()
+{
+ struct env *ep;
+ int fd;
+
+ /* Don't clean up temporary files - parent will probably need them.
+ * Also, can't easily reclaim memory since variables, etc. could be
+ * anywhere.
+ */
+
+ /* close all file descriptors hiding in savefd */
+ for (ep = e; ep; ep = ep->oenv) {
+ if (ep->savefd) {
+ for (fd = 0; fd < NUFILE; fd++)
+ if (ep->savefd[fd] > 0)
+ close(ep->savefd[fd]);
+ afree(ep->savefd, &ep->area);
+ ep->savefd = (short *) 0;
+ }
+ }
+ e->oenv = (struct env *) 0;
+}
+
+/* Called just before an execve cleanup stuff temporary files */
+void
+cleanup_proc_env()
+{
+ struct env *ep;
+
+ for (ep = e; ep; ep = ep->oenv)
+ remove_temps(ep->temps);
+}
+
+/* remove temp files and free ATEMP Area */
+static void
+reclaim()
+{
+ remove_temps(e->temps);
+ e->temps = NULL;
+ afreeall(&e->area);
+}
+
+static void
+remove_temps(tp)
+ struct temp *tp;
+{
+ for (; tp != NULL; tp = tp->next)
+ if (tp->pid == procpid) {
+ unlink(tp->name);
+ }
+}
+
+/* Returns true if name refers to a restricted shell */
+static int
+is_restricted(name)
+ char *name;
+{
+ char *p;
+
+ if ((p = ksh_strrchr_dirsep(name)))
+ name = p;
+ /* accepts rsh, rksh, rpdksh, pdrksh, etc. */
+ return (p = strchr(name, 'r')) && strstr(p, "sh");
+}
+
+void
+aerror(ap, msg)
+ Area *ap;
+ const char *msg;
+{
+ internal_errorf(1, "alloc: %s", msg);
+ errorf("%s", null); /* this is never executed - keeps gcc quiet */
+ /*NOTREACHED*/
+}