* AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
* OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*
- * Copyright (c) 1999-2004 Paul Mackerras. All rights reserved.
+ * Copyright (c) 1999-2020 Paul Mackerras. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
-#define RCSID "$Id: main.c,v 1.152 2005/08/25 23:59:34 paulus Exp $"
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
#include <stdio.h>
#include <ctype.h>
#include <netdb.h>
#include <utmp.h>
#include <pwd.h>
-#include <setjmp.h>
#include <sys/param.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
+#include <limits.h>
+#include <inttypes.h>
#include "pppd.h"
#include "magic.h"
#include "fsm.h"
#include "lcp.h"
#include "ipcp.h"
-#ifdef INET6
+#ifdef PPP_WITH_IPV6CP
#include "ipv6cp.h"
#endif
#include "upap.h"
#include "cbcp.h"
#endif
-#ifdef IPX_CHANGE
-#include "ipxcp.h"
-#endif /* IPX_CHANGE */
#ifdef AT_CHANGE
#include "atcp.h"
#endif
-static const char rcsid[] = RCSID;
/* interface vars */
-char ifname[32]; /* Interface name */
+char ifname[IFNAMSIZ]; /* Interface name */
int ifunit; /* Interface unit number */
struct channel *the_channel;
char db_key[32];
-int (*holdoff_hook) __P((void)) = NULL;
-int (*new_phase_hook) __P((int)) = NULL;
-void (*snoop_recv_hook) __P((unsigned char *p, int len)) = NULL;
-void (*snoop_send_hook) __P((unsigned char *p, int len)) = NULL;
+int (*holdoff_hook)(void) = NULL;
+int (*new_phase_hook)(int) = NULL;
+void (*snoop_recv_hook)(unsigned char *p, int len) = NULL;
+void (*snoop_send_hook)(unsigned char *p, int len) = NULL;
static int conn_running; /* we have a [dis]connector running */
static int fd_loop; /* fd for getting demand-dial packets */
static sigset_t signals_handled;
static int waiting;
-static sigjmp_buf sigjmp;
+static int sigpipe[2];
char **script_env; /* Env. variable values for scripts */
int s_env_nalloc; /* # words avail at script_env */
struct subprocess {
pid_t pid;
char *prog;
- void (*done) __P((void *));
+ void (*done)(void *);
void *arg;
+ int killable;
struct subprocess *next;
};
/* Prototypes for procedures local to this file. */
-static void setup_signals __P((void));
-static void create_pidfile __P((int pid));
-static void create_linkpidfile __P((int pid));
-static void cleanup __P((void));
-static void get_input __P((void));
-static void calltimeout __P((void));
-static struct timeval *timeleft __P((struct timeval *));
-static void kill_my_pg __P((int));
-static void hup __P((int));
-static void term __P((int));
-static void chld __P((int));
-static void toggle_debug __P((int));
-static void open_ccp __P((int));
-static void bad_signal __P((int));
-static void holdoff_end __P((void *));
-static int reap_kids __P((void));
-static void childwait_end __P((void *));
+static void setup_signals(void);
+static void create_pidfile(int pid);
+static void create_linkpidfile(int pid);
+static void cleanup(void);
+static void get_input(void);
+static void calltimeout(void);
+static struct timeval *timeleft(struct timeval *);
+static void kill_my_pg(int);
+static void hup(int);
+static void term(int);
+static void chld(int);
+static void toggle_debug(int);
+static void open_ccp(int);
+static void bad_signal(int);
+static void holdoff_end(void *);
+static void forget_child(int pid, int status);
+static int reap_kids(void);
+static void childwait_end(void *);
#ifdef USE_TDB
-static void update_db_entry __P((void));
-static void add_db_key __P((const char *));
-static void delete_db_key __P((const char *));
-static void cleanup_db __P((void));
+static void update_db_entry(void);
+static void add_db_key(const char *);
+static void delete_db_key(const char *);
+static void cleanup_db(void);
#endif
-static void handle_events __P((void));
-void print_link_stats __P((void));
-
-extern char *ttyname __P((int));
-extern char *getlogin __P((void));
-int main __P((int, char *[]));
+static void handle_events(void);
+void print_link_stats(void);
-#ifdef ultrix
-#undef O_NONBLOCK
-#define O_NONBLOCK O_NDELAY
-#endif
-
-#ifdef ULTRIX
-#define setlogmask(x)
-#endif
+extern char *getlogin(void);
+int main(int, char *[]);
/*
* PPP Data Link Layer "protocol" table.
&cbcp_protent,
#endif
&ipcp_protent,
-#ifdef INET6
+#ifdef PPP_WITH_IPV6CP
&ipv6cp_protent,
#endif
&ccp_protent,
&ecp_protent,
-#ifdef IPX_CHANGE
- &ipxcp_protent,
-#endif
#ifdef AT_CHANGE
&atcp_protent,
#endif
NULL
};
-/*
- * If PPP_DRV_NAME is not defined, use the default "ppp" as the device name.
- */
-#if !defined(PPP_DRV_NAME)
-#define PPP_DRV_NAME "ppp"
-#endif /* !defined(PPP_DRV_NAME) */
-
int
-main(argc, argv)
- int argc;
- char *argv[];
+main(int argc, char *argv[])
{
int i, t;
char *p;
struct protent *protp;
char numbuf[16];
+ strlcpy(path_ipup, _PATH_IPUP, sizeof(path_ipup));
+ strlcpy(path_ipdown, _PATH_IPDOWN, sizeof(path_ipdown));
+
+#ifdef PPP_WITH_IPV6CP
+ strlcpy(path_ipv6up, _PATH_IPV6UP, MAXPATHLEN);
+ strlcpy(path_ipv6down, _PATH_IPV6DOWN, MAXPATHLEN);
+#endif
link_stats_valid = 0;
new_phase(PHASE_INITIALIZE);
info("Starting link");
}
- gettimeofday(&start_time, NULL);
+ get_time(&start_time);
script_unsetenv("CONNECT_TIME");
script_unsetenv("BYTES_SENT");
script_unsetenv("BYTES_RCVD");
* handle_events - wait for something to happen and respond to it.
*/
static void
-handle_events()
+handle_events(void)
{
struct timeval timo;
+ unsigned char buf[16];
kill_link = open_ccp_flag = 0;
- if (sigsetjmp(sigjmp, 1) == 0) {
- sigprocmask(SIG_BLOCK, &signals_handled, NULL);
- if (got_sighup || got_sigterm || got_sigusr2 || got_sigchld) {
- sigprocmask(SIG_UNBLOCK, &signals_handled, NULL);
- } else {
- waiting = 1;
- sigprocmask(SIG_UNBLOCK, &signals_handled, NULL);
- wait_input(timeleft(&timo));
- }
- }
+
+ /* alert via signal pipe */
+ waiting = 1;
+ /* flush signal pipe */
+ for (; read(sigpipe[0], buf, sizeof(buf)) > 0; );
+ add_fd(sigpipe[0]);
+ /* wait if necessary */
+ if (!(got_sighup || got_sigterm || got_sigusr2 || got_sigchld))
+ wait_input(timeleft(&timo));
waiting = 0;
+ remove_fd(sigpipe[0]);
+
calltimeout();
if (got_sighup) {
info("Hangup (SIGHUP)");
* setup_signals - initialize signal handling.
*/
static void
-setup_signals()
+setup_signals(void)
{
struct sigaction sa;
+ /* create pipe to wake up event handler from signal handler */
+ if (pipe(sigpipe) < 0)
+ fatal("Couldn't create signal pipe: %m");
+ fcntl(sigpipe[0], F_SETFD, fcntl(sigpipe[0], F_GETFD) | FD_CLOEXEC);
+ fcntl(sigpipe[1], F_SETFD, fcntl(sigpipe[1], F_GETFD) | FD_CLOEXEC);
+ fcntl(sigpipe[0], F_SETFL, fcntl(sigpipe[0], F_GETFL) | O_NONBLOCK);
+ fcntl(sigpipe[1], F_SETFL, fcntl(sigpipe[1], F_GETFL) | O_NONBLOCK);
+
/*
* Compute mask of all interesting signals and install signal handlers
* for each. Only one signal handler may be active at a time. Therefore,
* unit we are using.
*/
void
-set_ifunit(iskey)
- int iskey;
+set_ifunit(int iskey)
{
- info("Using interface %s%d", PPP_DRV_NAME, ifunit);
- slprintf(ifname, sizeof(ifname), "%s%d", PPP_DRV_NAME, ifunit);
+ char ifkey[32];
+
+ if (req_ifname[0] != '\0')
+ slprintf(ifname, sizeof(ifname), "%s", req_ifname);
+ else
+ slprintf(ifname, sizeof(ifname), "%s%d", PPP_DRV_NAME, ifunit);
+ info("Using interface %s", ifname);
script_setenv("IFNAME", ifname, iskey);
+ slprintf(ifkey, sizeof(ifkey), "%d", ifunit);
+ script_setenv("UNIT", ifkey, iskey);
if (iskey) {
create_pidfile(getpid()); /* write pid to file */
create_linkpidfile(getpid());
* detach - detach us from the controlling terminal.
*/
void
-detach()
+detach(void)
{
int pid;
+ int ret;
char numbuf[16];
int pipefd[2];
/* update pid files if they have been written already */
if (pidfilename[0])
create_pidfile(pid);
- if (linkpidfile[0])
- create_linkpidfile(pid);
+ create_linkpidfile(pid);
exit(0); /* parent dies */
}
setsid();
- chdir("/");
+ ret = chdir("/");
+ if (ret != 0) {
+ fatal("Could not change directory to '/', %m");
+ }
dup2(fd_devnull, 0);
dup2(fd_devnull, 1);
dup2(fd_devnull, 2);
* reopen_log - (re)open our connection to syslog.
*/
void
-reopen_log()
+reopen_log(void)
{
openlog("pppd", LOG_PID | LOG_NDELAY, LOG_PPP);
setlogmask(LOG_UPTO(LOG_INFO));
* Create a file containing our process ID.
*/
static void
-create_pidfile(pid)
- int pid;
+create_pidfile(int pid)
{
FILE *pidfile;
}
void
-create_linkpidfile(pid)
- int pid;
+create_linkpidfile(int pid)
{
FILE *pidfile;
/*
* remove_pidfile - remove our pid files
*/
-void remove_pidfiles()
+void remove_pidfiles(void)
{
if (pidfilename[0] != 0 && unlink(pidfilename) < 0 && errno != ENOENT)
warn("unable to delete pid file %s: %m", pidfilename);
* holdoff_end - called via a timeout when the holdoff period ends.
*/
static void
-holdoff_end(arg)
- void *arg;
+holdoff_end(void *arg)
{
new_phase(PHASE_DORMANT);
}
{ 0x8051, "KNX Bridging Control Protocol" },
{ 0x8053, "Encryption Control Protocol" },
{ 0x8055, "Individual Link Encryption Control Protocol" },
- { 0x8057, "IPv6 Control Protovol" },
+ { 0x8057, "IPv6 Control Protocol" },
{ 0x8059, "PPP Muxing Control Protocol" },
{ 0x805b, "Vendor-Specific Network Control Protocol (VSNCP)" },
{ 0x806f, "Stampede Bridging Control Protocol" },
* protocol_name - find a name for a PPP protocol.
*/
const char *
-protocol_name(proto)
- int proto;
+protocol_name(int proto)
{
struct protocol_list *lp;
* get_input - called when incoming data is available.
*/
static void
-get_input()
+get_input(void)
{
int len, i;
u_char *p;
* itself), otherwise 0.
*/
int
-ppp_send_config(unit, mtu, accm, pcomp, accomp)
- int unit, mtu;
- u_int32_t accm;
- int pcomp, accomp;
+ppp_send_config(int unit, int mtu, u_int32_t accm, int pcomp, int accomp)
{
int errs;
* itself), otherwise 0.
*/
int
-ppp_recv_config(unit, mru, accm, pcomp, accomp)
- int unit, mru;
- u_int32_t accm;
- int pcomp, accomp;
+ppp_recv_config(int unit, int mru, u_int32_t accm, int pcomp, int accomp)
{
int errs;
* new_phase - signal the start of a new phase of pppd's operation.
*/
void
-new_phase(p)
- int p;
+new_phase(int p)
{
phase = p;
if (new_phase_hook)
* die - clean up state and exit with the specified status.
*/
void
-die(status)
- int status;
+die(int status)
{
if (!doing_multilink || multilink_master)
print_link_stats();
*/
/* ARGSUSED */
static void
-cleanup()
+cleanup(void)
{
sys_cleanup();
}
void
-print_link_stats()
+print_link_stats(void)
{
/*
* Print connect time and statistics.
* reset_link_stats - "reset" stats when link goes up.
*/
void
-reset_link_stats(u)
- int u;
+reset_link_stats(int u)
{
if (!get_ppp_stats(u, &old_link_stats))
return;
- gettimeofday(&start_time, NULL);
+ get_time(&start_time);
}
/*
* update_link_stats - get stats at link termination.
*/
void
-update_link_stats(u)
- int u;
+update_link_stats(int u)
{
struct timeval now;
char numbuf[32];
if (!get_ppp_stats(u, &link_stats)
- || gettimeofday(&now, NULL) < 0)
+ || get_time(&now) < 0)
return;
link_connect_time = now.tv_sec - start_time.tv_sec;
link_stats_valid = 1;
slprintf(numbuf, sizeof(numbuf), "%u", link_connect_time);
script_setenv("CONNECT_TIME", numbuf, 0);
- slprintf(numbuf, sizeof(numbuf), "%u", link_stats.bytes_out);
+ snprintf(numbuf, sizeof(numbuf), "%" PRIu64, link_stats.bytes_out);
script_setenv("BYTES_SENT", numbuf, 0);
- slprintf(numbuf, sizeof(numbuf), "%u", link_stats.bytes_in);
+ snprintf(numbuf, sizeof(numbuf), "%" PRIu64, link_stats.bytes_in);
script_setenv("BYTES_RCVD", numbuf, 0);
}
struct callout {
struct timeval c_time; /* time at which to call routine */
void *c_arg; /* argument to routine */
- void (*c_func) __P((void *)); /* routine */
+ void (*c_func)(void *); /* routine */
struct callout *c_next;
};
* timeout - Schedule a timeout.
*/
void
-timeout(func, arg, secs, usecs)
- void (*func) __P((void *));
- void *arg;
- int secs, usecs;
+timeout(void (*func)(void *), void *arg, int secs, int usecs)
{
struct callout *newp, *p, **pp;
fatal("Out of memory in timeout()!");
newp->c_arg = arg;
newp->c_func = func;
- gettimeofday(&timenow, NULL);
+ get_time(&timenow);
newp->c_time.tv_sec = timenow.tv_sec + secs;
newp->c_time.tv_usec = timenow.tv_usec + usecs;
if (newp->c_time.tv_usec >= 1000000) {
* untimeout - Unschedule a timeout.
*/
void
-untimeout(func, arg)
- void (*func) __P((void *));
- void *arg;
+untimeout(void (*func)(void *), void *arg)
{
struct callout **copp, *freep;
* calltimeout - Call any timeout routines which are now due.
*/
static void
-calltimeout()
+calltimeout(void)
{
struct callout *p;
while (callout != NULL) {
p = callout;
- if (gettimeofday(&timenow, NULL) < 0)
+ if (get_time(&timenow) < 0)
fatal("Failed to get time of day: %m");
if (!(p->c_time.tv_sec < timenow.tv_sec
|| (p->c_time.tv_sec == timenow.tv_sec
* timeleft - return the length of time until the next timeout is due.
*/
static struct timeval *
-timeleft(tvp)
- struct timeval *tvp;
+timeleft(struct timeval *tvp)
{
if (callout == NULL)
return NULL;
- gettimeofday(&timenow, NULL);
+ get_time(&timenow);
tvp->tv_sec = callout->c_time.tv_sec - timenow.tv_sec;
tvp->tv_usec = callout->c_time.tv_usec - timenow.tv_usec;
if (tvp->tv_usec < 0) {
* We assume that sig is currently blocked.
*/
static void
-kill_my_pg(sig)
- int sig;
+kill_my_pg(int sig)
{
struct sigaction act, oldact;
+ struct subprocess *chp;
+ if (!detached) {
+ /*
+ * There might be other things in our process group that we
+ * didn't start that would get hit if we did a kill(0), so
+ * just send the signal individually to our children.
+ */
+ for (chp = children; chp != NULL; chp = chp->next)
+ if (chp->killable)
+ kill(chp->pid, sig);
+ return;
+ }
+
+ /* We've done a setsid(), so we can just use a kill(0) */
sigemptyset(&act.sa_mask); /* unnecessary in fact */
act.sa_handler = SIG_IGN;
act.sa_flags = 0;
* signal, we just take the link down.
*/
static void
-hup(sig)
- int sig;
+hup(int sig)
{
/* can't log a message here, it can deadlock */
got_sighup = 1;
/* Send the signal to the [dis]connector process(es) also */
kill_my_pg(sig);
notify(sigreceived, sig);
- if (waiting)
- siglongjmp(sigjmp, 1);
+ if (waiting) {
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunused-result"
+ write(sigpipe[1], &sig, sizeof(sig));
+#pragma GCC diagnostic pop
+ }
}
*/
/*ARGSUSED*/
static void
-term(sig)
- int sig;
+term(int sig)
{
/* can't log a message here, it can deadlock */
got_sigterm = sig;
/* Send the signal to the [dis]connector process(es) also */
kill_my_pg(sig);
notify(sigreceived, sig);
- if (waiting)
- siglongjmp(sigjmp, 1);
+ if (waiting) {
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunused-result"
+ write(sigpipe[1], &sig, sizeof(sig));
+#pragma GCC diagnostic pop
+ }
}
* Sets a flag so we will call reap_kids in the mainline.
*/
static void
-chld(sig)
- int sig;
+chld(int sig)
{
got_sigchld = 1;
- if (waiting)
- siglongjmp(sigjmp, 1);
+ if (waiting) {
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunused-result"
+ write(sigpipe[1], &sig, sizeof(sig));
+#pragma GCC diagnostic pop
+ }
}
*/
/*ARGSUSED*/
static void
-toggle_debug(sig)
- int sig;
+toggle_debug(int sig)
{
debug = !debug;
if (debug) {
*/
/*ARGSUSED*/
static void
-open_ccp(sig)
- int sig;
+open_ccp(int sig)
{
got_sigusr2 = 1;
- if (waiting)
- siglongjmp(sigjmp, 1);
+ if (waiting) {
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunused-result"
+ write(sigpipe[1], &sig, sizeof(sig));
+#pragma GCC diagnostic pop
+ }
}
* bad_signal - We've caught a fatal signal. Clean up state and exit.
*/
static void
-bad_signal(sig)
- int sig;
+bad_signal(int sig)
{
static int crashed = 0;
/* Executing in the child */
sys_close();
#ifdef USE_TDB
- tdb_close(pppdb);
+ if (pppdb != NULL)
+ tdb_close(pppdb);
#endif
/* make sure infd, outfd and errfd won't get tromped on below */
if (errfd == 0 || errfd == 1)
errfd = dup(errfd);
+ closelog();
+
/* dup the in, out, err fds to 0, 1, 2 */
if (infd != 0)
dup2(infd, 0);
if (errfd != 2)
dup2(errfd, 2);
- closelog();
if (log_to_fd > 2)
close(log_to_fd);
if (the_channel->close)
return 0;
}
+static bool
+add_script_env(int pos, char *newstring)
+{
+ if (pos + 1 >= s_env_nalloc) {
+ int new_n = pos + 17;
+ char **newenv = realloc(script_env, new_n * sizeof(char *));
+ if (newenv == NULL) {
+ free(newstring - 1);
+ return 0;
+ }
+ script_env = newenv;
+ s_env_nalloc = new_n;
+ }
+ script_env[pos] = newstring;
+ script_env[pos + 1] = NULL;
+ return 1;
+}
+
+static void
+remove_script_env(int pos)
+{
+ free(script_env[pos] - 1);
+ while ((script_env[pos] = script_env[pos + 1]) != NULL)
+ pos++;
+}
+
+/*
+ * update_system_environment - process the list of set/unset options
+ * and update the system environment.
+ */
+static void
+update_system_environment(void)
+{
+ struct userenv *uep;
+
+ for (uep = userenv_list; uep != NULL; uep = uep->ue_next) {
+ if (uep->ue_isset)
+ setenv(uep->ue_name, uep->ue_value, 1);
+ else
+ unsetenv(uep->ue_name);
+ }
+}
+
/*
* device_script - run a program to talk to the specified fds
* (e.g. to run the connector or disconnector script).
* stderr gets connected to the log fd or to the _PATH_CONNERRS file.
*/
int
-device_script(program, in, out, dont_wait)
- char *program;
- int in, out;
- int dont_wait;
+device_script(char *program, int in, int out, int dont_wait)
{
int pid;
int status = -1;
int errfd;
+ int ret;
if (log_to_fd >= 0)
errfd = log_to_fd;
else
- errfd = open(_PATH_CONNERRS, O_WRONLY | O_APPEND | O_CREAT, 0600);
+ errfd = open(_PATH_CONNERRS, O_WRONLY | O_APPEND | O_CREAT, 0644);
++conn_running;
pid = safe_fork(in, out, errfd);
}
if (pid != 0) {
- if (dont_wait) {
- record_child(pid, program, NULL, NULL);
- status = 0;
- } else {
+ record_child(pid, program, NULL, NULL, 1);
+ status = 0;
+ if (!dont_wait) {
while (waitpid(pid, &status, 0) < 0) {
if (errno == EINTR)
continue;
fatal("error waiting for (dis)connection process: %m");
}
+ forget_child(pid, status);
--conn_running;
}
return (status == 0 ? 0 : -1);
}
/* here we are executing in the child */
-
- setgid(getgid());
- setuid(uid);
- if (getuid() != uid) {
- fprintf(stderr, "pppd: setuid failed\n");
- exit(1);
+ ret = setgid(getgid());
+ if (ret != 0) {
+ perror("pppd: setgid failed\n");
+ exit(1);
}
+ ret = setuid(uid);
+ if (ret != 0 || getuid() != uid) {
+ perror("pppd: setuid failed\n");
+ exit(1);
+ }
+ update_system_environment();
execl("/bin/sh", "sh", "-c", program, (char *)0);
perror("pppd: could not exec /bin/sh");
- exit(99);
+ _exit(99);
/* NOTREACHED */
}
/*
- * run-program - execute a program with given arguments,
+ * update_script_environment - process the list of set/unset options
+ * and update the script environment. Note that we intentionally do
+ * not update the TDB. These changes are layered on top right before
+ * exec. It is not possible to use script_setenv() or
+ * script_unsetenv() safely after this routine is run.
+ */
+static void
+update_script_environment(void)
+{
+ struct userenv *uep;
+
+ for (uep = userenv_list; uep != NULL; uep = uep->ue_next) {
+ int i;
+ char *p, *newstring;
+ int nlen = strlen(uep->ue_name);
+
+ for (i = 0; (p = script_env[i]) != NULL; i++) {
+ if (strncmp(p, uep->ue_name, nlen) == 0 && p[nlen] == '=')
+ break;
+ }
+ if (uep->ue_isset) {
+ nlen += strlen(uep->ue_value) + 2;
+ newstring = malloc(nlen + 1);
+ if (newstring == NULL)
+ continue;
+ *newstring++ = 0;
+ slprintf(newstring, nlen, "%s=%s", uep->ue_name, uep->ue_value);
+ if (p != NULL)
+ script_env[i] = newstring;
+ else
+ add_script_env(i, newstring);
+ } else if (p != NULL) {
+ remove_script_env(i);
+ }
+ }
+}
+
+/*
+ * run_program - execute a program with given arguments,
* but don't wait for it unless wait is non-zero.
* If the program can't be executed, logs an error unless
* must_exist is 0 and the program file doesn't exist.
* reap_kids) iff the return value is > 0.
*/
pid_t
-run_program(prog, args, must_exist, done, arg, wait)
- char *prog;
- char **args;
- int must_exist;
- void (*done) __P((void *));
- void *arg;
- int wait;
+run_program(char *prog, char **args, int must_exist, void (*done)(void *), void *arg, int wait)
{
- int pid, status;
+ int pid, status, ret;
struct stat sbuf;
/*
if (pid != 0) {
if (debug)
dbglog("Script %s started (pid %d)", prog, pid);
- record_child(pid, prog, done, arg);
+ record_child(pid, prog, done, arg, 0);
if (wait) {
while (waitpid(pid, &status, 0) < 0) {
if (errno == EINTR)
continue;
fatal("error waiting for script %s: %m", prog);
}
- reap_kids();
+ forget_child(pid, status);
}
return pid;
}
/* Leave the current location */
(void) setsid(); /* No controlling tty. */
(void) umask (S_IRWXG|S_IRWXO);
- (void) chdir ("/"); /* no current directory. */
- setuid(0); /* set real UID = root */
- setgid(getegid());
+ ret = chdir ("/"); /* no current directory. */
+ if (ret != 0) {
+ fatal("Failed to change directory to '/', %m");
+ }
+ ret = setuid(0); /* set real UID = root */
+ if (ret != 0) {
+ fatal("Failed to set uid, %m");
+ }
+ ret = setgid(getegid());
+ if (ret != 0) {
+ fatal("failed to set gid, %m");
+ }
#ifdef BSD
/* Force the priority back to zero if pppd is running higher. */
#endif
/* run the program */
+ update_script_environment();
execve(prog, args, script_env);
if (must_exist || errno != ENOENT) {
/* have to reopen the log, there's nowhere else
syslog(LOG_ERR, "Can't execute %s: %m", prog);
closelog();
}
- _exit(-1);
+ _exit(99);
}
* to use.
*/
void
-record_child(pid, prog, done, arg)
- int pid;
- char *prog;
- void (*done) __P((void *));
- void *arg;
+record_child(int pid, char *prog, void (*done)(void *), void *arg, int killable)
{
struct subprocess *chp;
chp->done = done;
chp->arg = arg;
chp->next = children;
+ chp->killable = killable;
children = chp;
}
}
* exit, send them all a SIGTERM.
*/
static void
-childwait_end(arg)
- void *arg;
+childwait_end(void *arg)
{
struct subprocess *chp;
childwait_done = 1;
}
+/*
+ * forget_child - clean up after a dead child
+ */
+static void
+forget_child(int pid, int status)
+{
+ struct subprocess *chp, **prevp;
+
+ for (prevp = &children; (chp = *prevp) != NULL; prevp = &chp->next) {
+ if (chp->pid == pid) {
+ --n_children;
+ *prevp = chp->next;
+ break;
+ }
+ }
+ if (WIFSIGNALED(status)) {
+ warn("Child process %s (pid %d) terminated with signal %d",
+ (chp? chp->prog: "??"), pid, WTERMSIG(status));
+ } else if (debug)
+ dbglog("Script %s finished (pid %d), status = 0x%x",
+ (chp? chp->prog: "??"), pid,
+ WIFEXITED(status) ? WEXITSTATUS(status) : status);
+ if (chp && chp->done)
+ (*chp->done)(chp->arg);
+ if (chp)
+ free(chp);
+}
+
/*
* reap_kids - get status from any dead child processes,
* and log a message for abnormal terminations.
*/
static int
-reap_kids()
+reap_kids(void)
{
int pid, status;
- struct subprocess *chp, **prevp;
if (n_children == 0)
return 0;
while ((pid = waitpid(-1, &status, WNOHANG)) != -1 && pid != 0) {
- for (prevp = &children; (chp = *prevp) != NULL; prevp = &chp->next) {
- if (chp->pid == pid) {
- --n_children;
- *prevp = chp->next;
- break;
- }
- }
- if (WIFSIGNALED(status)) {
- warn("Child process %s (pid %d) terminated with signal %d",
- (chp? chp->prog: "??"), pid, WTERMSIG(status));
- } else if (debug)
- dbglog("Script %s finished (pid %d), status = 0x%x",
- (chp? chp->prog: "??"), pid,
- WIFEXITED(status) ? WEXITSTATUS(status) : status);
- if (chp && chp->done)
- (*chp->done)(chp->arg);
- if (chp)
- free(chp);
+ forget_child(pid, status);
}
if (pid == -1) {
if (errno == ECHILD)
* add_notifier - add a new function to be called when something happens.
*/
void
-add_notifier(notif, func, arg)
- struct notifier **notif;
- notify_func func;
- void *arg;
+add_notifier(struct notifier **notif, notify_func func, void *arg)
{
struct notifier *np;
* be called when something happens.
*/
void
-remove_notifier(notif, func, arg)
- struct notifier **notif;
- notify_func func;
- void *arg;
+remove_notifier(struct notifier **notif, notify_func func, void *arg)
{
struct notifier *np;
* notify - call a set of functions registered with add_notifier.
*/
void
-notify(notif, val)
- struct notifier *notif;
- int val;
+notify(struct notifier *notif, int val)
{
struct notifier *np;
* novm - log an error message saying we ran out of memory, and die.
*/
void
-novm(msg)
- char *msg;
+novm(char *msg)
{
fatal("Virtual memory exhausted allocating %s\n", msg);
}
* for scripts that we run (e.g. ip-up, auth-up, etc.)
*/
void
-script_setenv(var, value, iskey)
- char *var, *value;
- int iskey;
+script_setenv(char *var, char *value, int iskey)
{
size_t varl = strlen(var);
size_t vl = varl + strlen(value) + 2;
free(p-1);
script_env[i] = newstring;
#ifdef USE_TDB
- if (iskey && pppdb != NULL)
- add_db_key(newstring);
- update_db_entry();
+ if (pppdb != NULL) {
+ if (iskey)
+ add_db_key(newstring);
+ update_db_entry();
+ }
#endif
return;
}
} else {
/* no space allocated for script env. ptrs. yet */
i = 0;
- script_env = (char **) malloc(16 * sizeof(char *));
- if (script_env == 0)
+ script_env = malloc(16 * sizeof(char *));
+ if (script_env == 0) {
+ free(newstring - 1);
return;
+ }
s_env_nalloc = 16;
}
- /* reallocate script_env with more space if needed */
- if (i + 1 >= s_env_nalloc) {
- int new_n = i + 17;
- char **newenv = (char **) realloc((void *)script_env,
- new_n * sizeof(char *));
- if (newenv == 0)
- return;
- script_env = newenv;
- s_env_nalloc = new_n;
- }
-
- script_env[i] = newstring;
- script_env[i+1] = 0;
+ if (!add_script_env(i, newstring))
+ return;
#ifdef USE_TDB
if (pppdb != NULL) {
* for scripts.
*/
void
-script_unsetenv(var)
- char *var;
+script_unsetenv(char *var)
{
int vl = strlen(var);
int i;
if (p[-1] && pppdb != NULL)
delete_db_key(p);
#endif
- free(p-1);
- while ((script_env[i] = script_env[i+1]) != 0)
- ++i;
+ remove_script_env(i);
break;
}
}
* lock_db - get an exclusive lock on the TDB database.
* Used to ensure atomicity of various lookup/modify operations.
*/
-void lock_db()
+void lock_db(void)
{
#ifdef USE_TDB
TDB_DATA key;
/*
* unlock_db - remove the exclusive lock obtained by lock_db.
*/
-void unlock_db()
+void unlock_db(void)
{
#ifdef USE_TDB
TDB_DATA key;
* update_db_entry - update our entry in the database.
*/
static void
-update_db_entry()
+update_db_entry(void)
{
TDB_DATA key, dbuf;
int vlen, i;
dbuf.dptr = vbuf;
dbuf.dsize = vlen;
if (tdb_store(pppdb, key, dbuf, TDB_REPLACE))
- error("tdb_store failed: %s", tdb_error(pppdb));
+ error("tdb_store failed: %s", tdb_errorstr(pppdb));
if (vbuf)
free(vbuf);
* add_db_key - add a key that we can use to look up our database entry.
*/
static void
-add_db_key(str)
- const char *str;
+add_db_key(const char *str)
{
TDB_DATA key, dbuf;
dbuf.dptr = db_key;
dbuf.dsize = strlen(db_key);
if (tdb_store(pppdb, key, dbuf, TDB_REPLACE))
- error("tdb_store key failed: %s", tdb_error(pppdb));
+ error("tdb_store key failed: %s", tdb_errorstr(pppdb));
}
/*
* delete_db_key - delete a key for looking up our database entry.
*/
static void
-delete_db_key(str)
- const char *str;
+delete_db_key(const char *str)
{
TDB_DATA key;
* cleanup_db - delete all the entries we put in the database.
*/
static void
-cleanup_db()
+cleanup_db(void)
{
TDB_DATA key;
int i;
projects / ppp.git / blobdiff