#endif
#endif /* PPP_WITH_FILTER */
-#include "pppd.h"
+#include "pppd-private.h"
+#include "options.h"
+#include "upap.h"
#include "pathnames.h"
#if defined(ultrix) || defined(NeXT)
int debug = 0; /* Debug flag */
int kdebugflag = 0; /* Tell kernel to print debug messages */
int default_device = 1; /* Using /dev/tty or equivalent */
-char devnam[MAXPATHLEN]; /* Device name */
bool nodetach = 0; /* Don't detach from controlling tty */
bool updetach = 0; /* Detach once link is up */
bool master_detach; /* Detach when we're (only) multilink master */
bool persist = 0; /* Reopen link after it goes down */
char our_name[MAXNAMELEN]; /* Our name for authentication purposes */
bool demand = 0; /* do dial-on-demand */
-char *ipparam = NULL; /* Extra parameter for ip up/down scripts */
int idle_time_limit = 0; /* Disconnect if idle for this many seconds */
int holdoff = 30; /* # seconds to pause before reconnecting */
bool holdoff_specified; /* true if a holdoff value has been given */
#endif
unsigned int maxoctets = 0; /* default - no limit */
-int maxoctets_dir = 0; /* default - sum of traffic */
+session_limit_dir_t maxoctets_dir = PPP_OCTETS_DIRECTION_SUM; /* default - sum of traffic */
int maxoctets_timeout = 1; /* default 1 second */
-extern option_t auth_options[];
+extern struct option auth_options[];
extern struct stat devstat;
#ifdef PPP_WITH_FILTER
struct bpf_program active_filter; /* Filter program for link-active pkts */
#endif
-static option_t *curopt; /* pointer to option being processed */
+static struct option *curopt; /* pointer to option being processed */
char *current_option; /* the name of the option being parsed */
int privileged_option; /* set iff the current option came from root */
char *option_source; /* string saying where the option came from */
static int setmodir(char **);
static int user_setenv(char **);
-static void user_setprint(option_t *, printer_func, void *);
+static void user_setprint(struct option *, printer_func, void *);
static int user_unsetenv(char **);
-static void user_unsetprint(option_t *, printer_func, void *);
+static void user_unsetprint(struct option *, printer_func, void *);
-static option_t *find_option(char *name);
-static int process_option(option_t *, char *, char **);
-static int n_arguments(option_t *);
+static struct option *find_option(char *name);
+static int process_option(struct option *, char *, char **);
+static int n_arguments(struct option *);
static int number_option(char *, u_int32_t *, int);
/*
* Structure to store extra lists of options.
*/
struct option_list {
- option_t *options;
+ struct option *options;
struct option_list *next;
};
/*
* Valid arguments.
*/
-option_t general_options[] = {
+struct option general_options[] = {
{ "debug", o_int, &debug,
"Increase debugging level", OPT_INC | OPT_NOARG | 1 },
{ "-d", o_int, &debug,
#define IMPLEMENTATION ""
#endif
+int
+ppp_get_max_idle_time()
+{
+ return idle_time_limit;
+}
+
+void
+ppp_set_max_idle_time(unsigned int max)
+{
+ idle_time_limit = max;
+}
+
+int
+ppp_get_max_connect_time()
+{
+ return maxconnect;
+}
+
+void
+ppp_set_max_connect_time(unsigned int max)
+{
+ maxconnect = max;
+}
+
+void
+ppp_set_session_limit(unsigned int octets)
+{
+ maxoctets = octets;
+}
+
+void
+ppp_set_session_limit_dir(unsigned int dir)
+{
+ if (dir > 4)
+ dir = PPP_OCTETS_DIRECTION_SUM;
+ maxoctets_dir = (session_limit_dir_t) dir;
+}
+
+bool
+debug_on()
+{
+ return !!debug;
+}
+
+int
+ppp_get_path(ppp_path_t type, char *buf, size_t bufsz)
+{
+ const char *path;
+
+ if (buf && bufsz > 0) {
+ switch (type) {
+ case PPP_DIR_LOG:
+ path = PPP_PATH_VARLOG;
+ break;
+ case PPP_DIR_RUNTIME:
+ path = PPP_PATH_VARRUN;
+ break;
+ case PPP_DIR_PLUGIN:
+ path = PPP_PATH_PLUGIN;
+ break;
+ case PPP_DIR_CONF:
+ path = PPP_PATH_CONFDIR;
+ break;
+ }
+ return strlcpy(buf, path, bufsz);
+ }
+ return -1;
+}
+
+int
+ppp_get_filepath(ppp_path_t type, const char *name, char *buf, size_t bufsz)
+{
+ const char *path;
+
+ if (buf && bufsz > 0) {
+ switch (type) {
+ case PPP_DIR_LOG:
+ path = PPP_PATH_VARLOG;
+ break;
+ case PPP_DIR_RUNTIME:
+ path = PPP_PATH_VARRUN;
+ break;
+ case PPP_DIR_PLUGIN:
+ path = PPP_PATH_PLUGIN;
+ break;
+ case PPP_DIR_CONF:
+ path = PPP_PATH_CONFDIR;
+ break;
+ }
+ return slprintf(buf, bufsz, "%s/%s", path, name);
+ }
+ return -1;
+}
+
+bool ppp_persist()
+{
+ return !!persist;
+}
/*
* parse_args - parse a string of arguments from the command line.
parse_args(int argc, char **argv)
{
char *arg;
- option_t *opt;
+ struct option *opt;
int n;
privileged_option = privileged;
--argc;
opt = find_option(arg);
if (opt == NULL) {
- option_error("unrecognized option '%s'", arg);
+ ppp_option_error("unrecognized option '%s'", arg);
usage();
return 0;
}
n = n_arguments(opt);
if (argc < n) {
- option_error("too few parameters for option %s", arg);
+ ppp_option_error("too few parameters for option %s", arg);
return 0;
}
if (!process_option(opt, arg, argv))
* and interpret them.
*/
int
-options_from_file(char *filename, int must_exist, int check_prot, int priv)
+ppp_options_from_file(char *filename, int must_exist, int check_prot, int priv)
{
FILE *f;
int i, newline, ret, err;
- option_t *opt;
+ struct option *opt;
int oldpriv, n;
char *oldsource;
uid_t euid;
euid = geteuid();
if (check_prot && seteuid(getuid()) == -1) {
- option_error("unable to drop privileges to open %s: %m", filename);
+ ppp_option_error("unable to drop privileges to open %s: %m", filename);
return 0;
}
f = fopen(filename, "r");
warn("Warning: can't open options file %s: %m", filename);
return 1;
}
- option_error("Can't open options file %s: %m", filename);
+ ppp_option_error("Can't open options file %s: %m", filename);
return 0;
}
while (getword(f, cmd, &newline, filename)) {
opt = find_option(cmd);
if (opt == NULL) {
- option_error("In file %s: unrecognized option '%s'",
+ ppp_option_error("In file %s: unrecognized option '%s'",
filename, cmd);
goto err;
}
n = n_arguments(opt);
for (i = 0; i < n; ++i) {
if (!getword(f, args[i], &newline, filename)) {
- option_error(
+ ppp_option_error(
"In file %s: too few parameters for option '%s'",
filename, cmd);
goto err;
novm("init file name");
slprintf(path, pl, "%s/%s", user, file);
option_priority = OPRIO_CFGFILE;
- ret = options_from_file(path, 0, 1, privileged);
+ ret = ppp_options_from_file(path, 0, 1, privileged);
free(path);
return ret;
}
if (*p == '/')
*p = '.';
option_priority = OPRIO_CFGFILE;
- ret = options_from_file(path, 0, 0, 1);
+ ret = ppp_options_from_file(path, 0, 0, 1);
free(path);
return ret;
}
options_from_list(struct wordlist *w, int priv)
{
char *argv[MAXARGS];
- option_t *opt;
+ struct option *opt;
int i, n, ret = 0;
struct wordlist *w0;
while (w != NULL) {
opt = find_option(w->word);
if (opt == NULL) {
- option_error("In secrets file: unrecognized option '%s'",
+ ppp_option_error("In secrets file: unrecognized option '%s'",
w->word);
goto err;
}
for (i = 0; i < n; ++i) {
w = w->next;
if (w == NULL) {
- option_error(
+ ppp_option_error(
"In secrets file: too few parameters for option '%s'",
w0->word);
goto err;
}
/*
- * match_option - see if this option matches an option_t structure.
+ * match_option - see if this option matches an option structure.
*/
static int
-match_option(char *name, option_t *opt, int dowild)
+match_option(char *name, struct option *opt, int dowild)
{
int (*match)(char *, char **, int);
* looking for an entry with the given name.
* This could be optimized by using a hash table.
*/
-static option_t *
+static struct option *
find_option(char *name)
{
- option_t *opt;
+ struct option *opt;
struct option_list *list;
int i, dowild;
* process_option - process one new-style option.
*/
static int
-process_option(option_t *opt, char *cmd, char **argv)
+process_option(struct option *opt, char *cmd, char **argv)
{
u_int32_t v;
int iv, a;
int (*wildp)(char *, char **, int);
char *optopt = (opt->type == o_wild)? "": " option";
int prio = option_priority;
- option_t *mainopt = opt;
+ struct option *mainopt = opt;
current_option = opt->name;
if ((opt->flags & OPT_PRIVFIX) && privileged_option)
if (prio < mainopt->priority) {
/* new value doesn't override old */
if (prio == OPRIO_CMDLINE && mainopt->priority > OPRIO_ROOT) {
- option_error("%s%s set in %s cannot be overridden\n",
+ ppp_option_error("%s%s set in %s cannot be overridden\n",
opt->name, optopt, mainopt->source);
return 0;
}
opt->name, optopt, option_source);
}
- if ((opt->flags & OPT_INITONLY) && phase != PHASE_INITIALIZE) {
- option_error("%s%s cannot be changed after initialization",
+ if ((opt->flags & OPT_INITONLY) && !in_phase(PHASE_INITIALIZE)) {
+ ppp_option_error("%s%s cannot be changed after initialization",
opt->name, optopt);
return 0;
}
if ((opt->flags & OPT_PRIV) && !privileged_option) {
- option_error("using the %s%s requires root privilege",
+ ppp_option_error("using the %s%s requires root privilege",
opt->name, optopt);
return 0;
}
if ((opt->flags & OPT_ENABLE) && *(bool *)(opt->addr2) == 0) {
- option_error("%s%s is disabled", opt->name, optopt);
+ ppp_option_error("%s%s is disabled", opt->name, optopt);
return 0;
}
if ((opt->flags & OPT_DEVEQUIV) && devnam_fixed) {
- option_error("the %s%s may not be changed in %s",
+ ppp_option_error("the %s%s may not be changed in %s",
opt->name, optopt, option_source);
return 0;
}
case o_int:
iv = 0;
if ((opt->flags & OPT_NOARG) == 0) {
- if (!int_option(*argv, &iv))
+ if (!ppp_int_option(*argv, &iv))
return 0;
if ((((opt->flags & OPT_LLIMIT) && iv < opt->lower_limit)
|| ((opt->flags & OPT_ULIMIT) && iv > opt->upper_limit))
char *zok = (opt->flags & OPT_ZEROOK)? " zero or": "";
switch (opt->flags & OPT_LIMITS) {
case OPT_LLIMIT:
- option_error("%s value must be%s >= %d",
+ ppp_option_error("%s value must be%s >= %d",
opt->name, zok, opt->lower_limit);
break;
case OPT_ULIMIT:
- option_error("%s value must be%s <= %d",
+ ppp_option_error("%s value must be%s <= %d",
opt->name, zok, opt->upper_limit);
break;
case OPT_LIMITS:
- option_error("%s value must be%s between %d and %d",
+ ppp_option_error("%s value must be%s between %d and %d",
opt->name, zok, opt->lower_limit, opt->upper_limit);
break;
}
int oldv = *(int *)(opt->addr);
if ((opt->flags & OPT_ZEROINF) ?
(oldv != 0 && (iv == 0 || iv > oldv)) : (iv > oldv)) {
- option_error("%s value cannot be increased", opt->name);
+ ppp_option_error("%s value cannot be increased", opt->name);
return 0;
}
}
int
override_value(char *option, int priority, const char *source)
{
- option_t *opt;
+ struct option *opt;
opt = find_option(option);
if (opt == NULL)
* n_arguments - tell how many arguments an option takes
*/
static int
-n_arguments(option_t *opt)
+n_arguments(struct option *opt)
{
return (opt->type == o_bool || opt->type == o_special_noarg
|| (opt->flags & OPT_NOARG))? 0: 1;
* add_options - add a list of options to the set we grok.
*/
void
-add_options(option_t *opt)
+ppp_add_options(struct option *opt)
{
struct option_list *list;
* print_option - print out an option and its value
*/
static void
-print_option(option_t *opt, option_t *mainopt, printer_func printer, void *arg)
+print_option(struct option *opt, struct option *mainopt, printer_func printer, void *arg)
{
int i, v;
char *p;
printer(arg, " ");
}
if (opt->flags & OPT_A2PRINTER) {
- void (*oprt)(option_t *, printer_func, void *);
- oprt = (void (*)(option_t *, printer_func, void *))
+ void (*oprt)(struct option *, printer_func, void *);
+ oprt = (void (*)(struct option *, printer_func, void *))
opt->addr2;
(*oprt)(opt, printer, arg);
} else if (opt->flags & OPT_A2STRVAL) {
* array of options.
*/
static void
-print_option_list(option_t *opt, printer_func printer, void *arg)
+print_option_list(struct option *opt, printer_func printer, void *arg)
{
while (opt->name != NULL) {
if (opt->priority != OPRIO_DEFAULT
usage(void)
{
FILE *fp = stderr;
- if (phase == PHASE_INITIALIZE) {
+ if (in_phase(PHASE_INITIALIZE)) {
fprintf(fp, "%s v%s\n", PACKAGE_NAME, PACKAGE_VERSION);
fprintf(fp, "Copyright (C) 1999-2022 Paul Mackerras, and others. All rights reserved.\n\n");
static int
showhelp(char **argv)
{
- if (phase == PHASE_INITIALIZE) {
+ if (in_phase(PHASE_INITIALIZE)) {
usage();
exit(0);
}
static int
showversion(char **argv)
{
- if (phase == PHASE_INITIALIZE) {
+ if (in_phase(PHASE_INITIALIZE)) {
fprintf(stdout, "pppd version %s\n", VERSION);
exit(0);
}
* Print a set of options including the name of the group of options
*/
static void
-showopts_list(FILE *fp, const char *title, option_t *list, ...)
+showopts_list(FILE *fp, const char *title, struct option *list, ...)
{
- option_t *opt = list;
+ struct option *opt = list;
va_list varg;
if (opt && opt->name) {
}
/*
- * option_error - print a message about an error in an option.
+ * ppp_option_error - print a message about an error in an option.
* The message is logged, and also sent to
- * stderr if phase == PHASE_INITIALIZE.
+ * stderr if in_phase(PHASE_INITIALIZE).
*/
void
-option_error(char *fmt, ...)
+ppp_option_error(char *fmt, ...)
{
va_list args;
char buf[1024];
va_start(args, fmt);
vslprintf(buf, sizeof(buf), fmt, args);
va_end(args);
- if (phase == PHASE_INITIALIZE)
+ if (in_phase(PHASE_INITIALIZE))
fprintf(stderr, "%s: %s\n", progname, buf);
syslog(LOG_ERR, "%s", buf);
}
if (ferror(f)) {
if (errno == 0)
errno = EIO;
- option_error("Error reading %s: %m", filename);
+ ppp_option_error("Error reading %s: %m", filename);
die(1);
}
/*
if (len == 0)
return 0;
if (quoted)
- option_error("warning: quoted word runs to end of file (%.20s...)",
+ ppp_option_error("warning: quoted word runs to end of file (%.20s...)",
filename, word);
}
* Warn if the word was too long, and append a terminating null.
*/
if (len >= MAXWORDLEN) {
- option_error("warning: word in file %s too long (%.20s...)",
+ ppp_option_error("warning: word in file %s too long (%.20s...)",
filename, word);
len = MAXWORDLEN - 1;
}
*valp = strtoul(str, &ptr, base);
if (ptr == str) {
- option_error("invalid numeric parameter '%s' for %s option",
+ ppp_option_error("invalid numeric parameter '%s' for %s option",
str, current_option);
return 0;
}
* if there is an error.
*/
int
-int_option(char *str, int *valp)
+ppp_int_option(char *str, int *valp)
{
u_int32_t v;
static int
readfile(char **argv)
{
- return options_from_file(*argv, 1, 1, privileged_option);
+ return ppp_options_from_file(*argv, 1, 1, privileged_option);
}
/*
}
}
if (!ok) {
- option_error("call option value may not contain .. or start with /");
+ ppp_option_error("call option value may not contain .. or start with /");
return 0;
}
if ((fname = (char *) malloc(l)) == NULL)
novm("call file name");
slprintf(fname, l, "%s%s", PPP_PATH_PEERFILES, arg);
- script_setenv("CALL_FILE", arg, 0);
+ ppp_script_setenv("CALL_FILE", arg, 0);
- ok = options_from_file(fname, 1, 1, 1);
+ ok = ppp_options_from_file(fname, 1, 1, 1);
free(fname);
return ok;
pc = pcap_open_dead(DLT_PPP_PPPD, 65535);
if (pcap_compile(pc, &pass_filter, *argv, 1, netmask) == -1) {
- option_error("error in pass-filter expression: %s\n",
+ ppp_option_error("error in pass-filter expression: %s\n",
pcap_geterr(pc));
ret = 0;
}
pc = pcap_open_dead(DLT_PPP_PPPD, 65535);
if (pcap_compile(pc, &active_filter, *argv, 1, netmask) == -1) {
- option_error("error in active-filter expression: %s\n",
+ ppp_option_error("error in active-filter expression: %s\n",
pcap_geterr(pc));
ret = 0;
}
euid = geteuid();
if (!privileged_option && seteuid(getuid()) == -1) {
- option_error("unable to drop permissions to open %s: %m", *argv);
+ ppp_option_error("unable to drop permissions to open %s: %m", *argv);
return 0;
}
fd = open(*argv, O_WRONLY | O_APPEND | O_CREAT | O_EXCL, 0644);
fatal("unable to regain privileges: %m");
if (fd < 0) {
errno = err;
- option_error("Can't open log file %s: %m", *argv);
+ ppp_option_error("Can't open log file %s: %m", *argv);
return 0;
}
strlcpy(logfile_name, *argv, sizeof(logfile_name));
if (handle == 0) {
err = dlerror();
if (err != 0)
- option_error("%s", err);
- option_error("Couldn't load plugin %s", arg);
+ ppp_option_error("%s", err);
+ ppp_option_error("Couldn't load plugin %s", arg);
goto err;
}
init = (void (*)(void))dlsym(handle, "plugin_init");
if (init == 0) {
- option_error("%s has no initialization entry point", arg);
+ ppp_option_error("%s has no initialization entry point", arg);
goto errclose;
}
vers = (const char *) dlsym(handle, "pppd_version");
if (vers == 0) {
warn("Warning: plugin %s has no version information", arg);
} else if (strcmp(vers, VERSION) != 0) {
- option_error("Plugin %s is for pppd version %s, this is %s",
+ ppp_option_error("Plugin %s is for pppd version %s, this is %s",
arg, vers, VERSION);
goto errclose;
}
struct userenv *uep, **insp;
if ((eqp = strchr(arg, '=')) == NULL) {
- option_error("missing = in name=value: %s", arg);
+ ppp_option_error("missing = in name=value: %s", arg);
return 0;
}
if (eqp == arg) {
- option_error("missing variable name: %s", arg);
+ ppp_option_error("missing variable name: %s", arg);
return 0;
}
for (uep = userenv_list; uep != NULL; uep = uep->ue_next) {
}
static void
-user_setprint(option_t *opt, printer_func printer, void *arg)
+user_setprint(struct option *opt, printer_func printer, void *arg)
{
struct userenv *uep, *uepnext;
char *arg = argv[0];
if (strchr(arg, '=') != NULL) {
- option_error("unexpected = in name: %s", arg);
+ ppp_option_error("unexpected = in name: %s", arg);
return 0;
}
if (*arg == '\0') {
- option_error("missing variable name for unset");
+ ppp_option_error("missing variable name for unset");
return 0;
}
for (uep = userenv_list; uep != NULL; uep = uep->ue_next) {
}
static void
-user_unsetprint(option_t *opt, printer_func printer, void *arg)
+user_unsetprint(struct option *opt, printer_func printer, void *arg)
{
struct userenv *uep, *uepnext;
projects / ppp.git / blobdiff