/*- * Copyright (c) 1996 - 2001 Brian Somers * based on work by Toshiharu OHNO * Internet Initiative Japan, Inc (IIJ) * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * * $FreeBSD$ */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifndef NONAT #ifdef LOCALNAT #include "alias.h" #else #include #endif #endif #include "layer.h" #include "defs.h" #include "command.h" #include "mbuf.h" #include "log.h" #include "timer.h" #include "fsm.h" #include "iplist.h" #include "throughput.h" #include "slcompress.h" #include "lqr.h" #include "hdlc.h" #include "lcp.h" #include "ncpaddr.h" #include "ipcp.h" #ifndef NONAT #include "nat_cmd.h" #endif #include "systems.h" #include "filter.h" #include "descriptor.h" #include "main.h" #include "route.h" #include "ccp.h" #include "auth.h" #include "async.h" #include "link.h" #include "physical.h" #include "mp.h" #ifndef NORADIUS #include "radius.h" #endif #include "ipv6cp.h" #include "ncp.h" #include "bundle.h" #include "server.h" #include "prompt.h" #include "chat.h" #include "chap.h" #include "cbcp.h" #include "datalink.h" #include "iface.h" #include "id.h" #include "probe.h" /* ``set'' values */ #define VAR_AUTHKEY 0 #define VAR_DIAL 1 #define VAR_LOGIN 2 #define VAR_AUTHNAME 3 #define VAR_AUTOLOAD 4 #define VAR_WINSIZE 5 #define VAR_DEVICE 6 #define VAR_ACCMAP 7 #define VAR_MRRU 8 #define VAR_MRU 9 #define VAR_MTU 10 #define VAR_OPENMODE 11 #define VAR_PHONE 12 #define VAR_HANGUP 13 #define VAR_IDLETIMEOUT 14 #define VAR_LQRPERIOD 15 #define VAR_LCPRETRY 16 #define VAR_CHAPRETRY 17 #define VAR_PAPRETRY 18 #define VAR_CCPRETRY 19 #define VAR_IPCPRETRY 20 #define VAR_DNS 21 #define VAR_NBNS 22 #define VAR_MODE 23 #define VAR_CALLBACK 24 #define VAR_CBCP 25 #define VAR_CHOKED 26 #define VAR_SENDPIPE 27 #define VAR_RECVPIPE 28 #define VAR_RADIUS 29 #define VAR_CD 30 #define VAR_PARITY 31 #define VAR_CRTSCTS 32 #define VAR_URGENTPORTS 33 #define VAR_LOGOUT 34 #define VAR_IFQUEUE 35 #define VAR_MPPE 36 #define VAR_IPV6CPRETRY 37 #define VAR_RAD_ALIVE 38 #define VAR_PPPOE 39 #define VAR_PORT_ID 40 /* ``accept|deny|disable|enable'' masks */ #define NEG_HISMASK (1) #define NEG_MYMASK (2) /* ``accept|deny|disable|enable'' values */ #define NEG_ACFCOMP 40 #define NEG_CHAP05 41 #define NEG_CHAP80 42 #define NEG_CHAP80LM 43 #define NEG_DEFLATE 44 #define NEG_DNS 45 #define NEG_ECHO 46 #define NEG_ENDDISC 47 #define NEG_LQR 48 #define NEG_PAP 49 #define NEG_PPPDDEFLATE 50 #define NEG_PRED1 51 #define NEG_PROTOCOMP 52 #define NEG_SHORTSEQ 53 #define NEG_VJCOMP 54 #define NEG_MPPE 55 #define NEG_CHAP81 56 const char Version[] = "3.4.2"; static int ShowCommand(struct cmdargs const *); static int TerminalCommand(struct cmdargs const *); static int QuitCommand(struct cmdargs const *); static int OpenCommand(struct cmdargs const *); static int CloseCommand(struct cmdargs const *); static int DownCommand(struct cmdargs const *); static int SetCommand(struct cmdargs const *); static int LinkCommand(struct cmdargs const *); static int AddCommand(struct cmdargs const *); static int DeleteCommand(struct cmdargs const *); static int NegotiateCommand(struct cmdargs const *); static int ClearCommand(struct cmdargs const *); static int RunListCommand(struct cmdargs const *); static int IfaceAddCommand(struct cmdargs const *); static int IfaceDeleteCommand(struct cmdargs const *); static int IfaceClearCommand(struct cmdargs const *); static int SetProcTitle(struct cmdargs const *); #ifndef NONAT static int NatEnable(struct cmdargs const *); static int NatOption(struct cmdargs const *); #endif extern struct libalias *la; static const char * showcx(struct cmdtab const *cmd) { if (cmd->lauth & LOCAL_CX) return "(c)"; else if (cmd->lauth & LOCAL_CX_OPT) return "(o)"; return ""; } static int HelpCommand(struct cmdargs const *arg) { struct cmdtab const *cmd; int n, cmax, dmax, cols, cxlen; const char *cx; if (!arg->prompt) { log_Printf(LogWARN, "help: Cannot help without a prompt\n"); return 0; } if (arg->argc > arg->argn) { for (cmd = arg->cmdtab; cmd->name || cmd->alias; cmd++) if ((cmd->lauth & arg->prompt->auth) && ((cmd->name && !strcasecmp(cmd->name, arg->argv[arg->argn])) || (cmd->alias && !strcasecmp(cmd->alias, arg->argv[arg->argn])))) { prompt_Printf(arg->prompt, "%s %s\n", cmd->syntax, showcx(cmd)); return 0; } return -1; } cmax = dmax = 0; for (cmd = arg->cmdtab; cmd->func; cmd++) if (cmd->name && (cmd->lauth & arg->prompt->auth)) { if ((n = strlen(cmd->name) + strlen(showcx(cmd))) > cmax) cmax = n; if ((n = strlen(cmd->helpmes)) > dmax) dmax = n; } cols = 80 / (dmax + cmax + 3); n = 0; prompt_Printf(arg->prompt, "(o) = Optional context," " (c) = Context required\n"); for (cmd = arg->cmdtab; cmd->func; cmd++) if (cmd->name && (cmd->lauth & arg->prompt->auth)) { cx = showcx(cmd); cxlen = cmax - strlen(cmd->name); if (n % cols != 0) prompt_Printf(arg->prompt, " "); prompt_Printf(arg->prompt, "%s%-*.*s: %-*.*s", cmd->name, cxlen, cxlen, cx, dmax, dmax, cmd->helpmes); if (++n % cols == 0) prompt_Printf(arg->prompt, "\n"); } if (n % cols != 0) prompt_Printf(arg->prompt, "\n"); return 0; } static int IdentCommand(struct cmdargs const *arg) { Concatinate(arg->cx->physical->link.lcp.cfg.ident, sizeof arg->cx->physical->link.lcp.cfg.ident, arg->argc - arg->argn, arg->argv + arg->argn); return 0; } static int SendIdentification(struct cmdargs const *arg) { if (arg->cx->state < DATALINK_LCP) { log_Printf(LogWARN, "sendident: link has not reached LCP\n"); return 2; } return lcp_SendIdentification(&arg->cx->physical->link.lcp) ? 0 : 1; } static int CloneCommand(struct cmdargs const *arg) { char namelist[LINE_LEN]; char *name; int f; if (arg->argc == arg->argn) return -1; namelist[sizeof namelist - 1] = '\0'; for (f = arg->argn; f < arg->argc; f++) { strncpy(namelist, arg->argv[f], sizeof namelist - 1); for(name = strtok(namelist, ", "); name; name = strtok(NULL,", ")) bundle_DatalinkClone(arg->bundle, arg->cx, name); } return 0; } static int RemoveCommand(struct cmdargs const *arg) { if (arg->argc != arg->argn) return -1; if (arg->cx->state != DATALINK_CLOSED) { log_Printf(LogWARN, "remove: Cannot delete links that aren't closed\n"); return 2; } bundle_DatalinkRemove(arg->bundle, arg->cx); return 0; } static int RenameCommand(struct cmdargs const *arg) { if (arg->argc != arg->argn + 1) return -1; if (bundle_RenameDatalink(arg->bundle, arg->cx, arg->argv[arg->argn])) return 0; log_Printf(LogWARN, "%s -> %s: target name already exists\n", arg->cx->name, arg->argv[arg->argn]); return 1; } static int LoadCommand(struct cmdargs const *arg) { const char *err; int n, mode; mode = arg->bundle->phys_type.all; if (arg->argn < arg->argc) { for (n = arg->argn; n < arg->argc; n++) if ((err = system_IsValid(arg->argv[n], arg->prompt, mode)) != NULL) { log_Printf(LogWARN, "%s: %s\n", arg->argv[n], err); return 1; } for (n = arg->argn; n < arg->argc; n++) { bundle_SetLabel(arg->bundle, arg->argv[arg->argc - 1]); system_Select(arg->bundle, arg->argv[n], CONFFILE, arg->prompt, arg->cx); } bundle_SetLabel(arg->bundle, arg->argv[arg->argc - 1]); } else if ((err = system_IsValid("default", arg->prompt, mode)) != NULL) { log_Printf(LogWARN, "default: %s\n", err); return 1; } else { bundle_SetLabel(arg->bundle, "default"); system_Select(arg->bundle, "default", CONFFILE, arg->prompt, arg->cx); bundle_SetLabel(arg->bundle, "default"); } return 0; } static int LogCommand(struct cmdargs const *arg) { char buf[LINE_LEN]; if (arg->argn < arg->argc) { char *argv[MAXARGS]; int argc = arg->argc - arg->argn; if (argc >= (int)(sizeof argv / sizeof argv[0])) { argc = sizeof argv / sizeof argv[0] - 1; log_Printf(LogWARN, "Truncating log command to %d args\n", argc); } command_Expand(argv, argc, arg->argv + arg->argn, arg->bundle, 1, getpid()); Concatinate(buf, sizeof buf, argc, (const char *const *)argv); log_Printf(LogLOG, "%s\n", buf); command_Free(argc, argv); return 0; } return -1; } static int SaveCommand(struct cmdargs const *arg __unused) { log_Printf(LogWARN, "save command is not yet implemented.\n"); return 1; } static int DialCommand(struct cmdargs const *arg) { int res; if ((arg->cx && !(arg->cx->physical->type & (PHYS_INTERACTIVE|PHYS_AUTO))) || (!arg->cx && (arg->bundle->phys_type.all & ~(PHYS_INTERACTIVE|PHYS_AUTO)))) { log_Printf(LogWARN, "Manual dial is only available for auto and" " interactive links\n"); return 1; } if (arg->argc > arg->argn && (res = LoadCommand(arg)) != 0) return res; bundle_Open(arg->bundle, arg->cx ? arg->cx->name : NULL, PHYS_ALL, 1); return 0; } #define isinword(ch) (isalnum(ch) || (ch) == '_') static char * strstrword(char *big, const char *little) { /* Get the first occurance of the word ``little'' in ``big'' */ char *pos; int len; pos = big; len = strlen(little); while ((pos = strstr(pos, little)) != NULL) if ((pos != big && isinword(pos[-1])) || isinword(pos[len])) pos++; else if (pos != big && pos[-1] == '\\') memmove(pos - 1, pos, strlen(pos) + 1); else break; return pos; } static char * subst(char *tgt, const char *oldstr, const char *newstr) { /* tgt is a malloc()d area... realloc() as necessary */ char *word, *ntgt; int ltgt, loldstr, lnewstr, pos; if ((word = strstrword(tgt, oldstr)) == NULL) return tgt; ltgt = strlen(tgt) + 1; loldstr = strlen(oldstr); lnewstr = strlen(newstr); do { pos = word - tgt; if (loldstr > lnewstr) bcopy(word + loldstr, word + lnewstr, ltgt - pos - loldstr); if (loldstr != lnewstr) { ntgt = realloc(tgt, ltgt += lnewstr - loldstr); if (ntgt == NULL) break; /* Oh wonderful ! */ word = ntgt + pos; tgt = ntgt; } if (lnewstr > loldstr) bcopy(word + loldstr, word + lnewstr, ltgt - pos - lnewstr); bcopy(newstr, word, lnewstr); } while ((word = strstrword(word, oldstr))); return tgt; } static char * substip(char *tgt, const char *oldstr, struct in_addr ip) { return subst(tgt, oldstr, inet_ntoa(ip)); } static char * substlong(char *tgt, const char *oldstr, long l) { char buf[23]; snprintf(buf, sizeof buf, "%ld", l); return subst(tgt, oldstr, buf); } static char * substull(char *tgt, const char *oldstr, unsigned long long ull) { char buf[21]; snprintf(buf, sizeof buf, "%llu", ull); return subst(tgt, oldstr, buf); } #ifndef NOINET6 static char * substipv6(char *tgt, const char *oldstr, const struct ncpaddr *ip) { return subst(tgt, oldstr, ncpaddr_ntoa(ip)); } #ifndef NORADIUS static char * substipv6prefix(char *tgt, const char *oldstr, const uint8_t *ipv6prefix) { uint8_t ipv6addr[INET6_ADDRSTRLEN]; uint8_t prefix[INET6_ADDRSTRLEN + sizeof("/128") - 1]; if (ipv6prefix) { inet_ntop(AF_INET6, &ipv6prefix[2], ipv6addr, sizeof(ipv6addr)); snprintf(prefix, sizeof(prefix), "%s/%d", ipv6addr, ipv6prefix[1]); } else prefix[0] = '\0'; return subst(tgt, oldstr, prefix); } #endif #endif void command_Expand(char **nargv, int argc, char const *const *oargv, struct bundle *bundle, int inc0, pid_t pid) { int arg, secs; char uptime[20]; unsigned long long oin, oout, pin, pout; if (inc0) arg = 0; /* Start at arg 0 */ else { nargv[0] = strdup(oargv[0]); arg = 1; } secs = bundle_Uptime(bundle); snprintf(uptime, sizeof uptime, "%d:%02d:%02d", secs / 3600, (secs / 60) % 60, secs % 60); oin = bundle->ncp.ipcp.throughput.OctetsIn; oout = bundle->ncp.ipcp.throughput.OctetsOut; pin = bundle->ncp.ipcp.throughput.PacketsIn; pout = bundle->ncp.ipcp.throughput.PacketsOut; #ifndef NOINET6 oin += bundle->ncp.ipv6cp.throughput.OctetsIn; oout += bundle->ncp.ipv6cp.throughput.OctetsOut; pin += bundle->ncp.ipv6cp.throughput.PacketsIn; pout += bundle->ncp.ipv6cp.throughput.PacketsOut; #endif for (; arg < argc; arg++) { nargv[arg] = strdup(oargv[arg]); nargv[arg] = subst(nargv[arg], "AUTHNAME", bundle->cfg.auth.name); nargv[arg] = substip(nargv[arg], "DNS0", bundle->ncp.ipcp.ns.dns[0]); nargv[arg] = substip(nargv[arg], "DNS1", bundle->ncp.ipcp.ns.dns[1]); nargv[arg] = subst(nargv[arg], "ENDDISC", mp_Enddisc(bundle->ncp.mp.cfg.enddisc.class, bundle->ncp.mp.cfg.enddisc.address, bundle->ncp.mp.cfg.enddisc.len)); nargv[arg] = substip(nargv[arg], "HISADDR", bundle->ncp.ipcp.peer_ip); #ifndef NOINET6 nargv[arg] = substipv6(nargv[arg], "HISADDR6", &bundle->ncp.ipv6cp.hisaddr); #endif nargv[arg] = subst(nargv[arg], "INTERFACE", bundle->iface->name); nargv[arg] = substull(nargv[arg], "IPOCTETSIN", bundle->ncp.ipcp.throughput.OctetsIn); nargv[arg] = substull(nargv[arg], "IPOCTETSOUT", bundle->ncp.ipcp.throughput.OctetsOut); nargv[arg] = substull(nargv[arg], "IPPACKETSIN", bundle->ncp.ipcp.throughput.PacketsIn); nargv[arg] = substull(nargv[arg], "IPPACKETSOUT", bundle->ncp.ipcp.throughput.PacketsOut); #ifndef NOINET6 nargv[arg] = substull(nargv[arg], "IPV6OCTETSIN", bundle->ncp.ipv6cp.throughput.OctetsIn); nargv[arg] = substull(nargv[arg], "IPV6OCTETSOUT", bundle->ncp.ipv6cp.throughput.OctetsOut); nargv[arg] = substull(nargv[arg], "IPV6PACKETSIN", bundle->ncp.ipv6cp.throughput.PacketsIn); nargv[arg] = substull(nargv[arg], "IPV6PACKETSOUT", bundle->ncp.ipv6cp.throughput.PacketsOut); #endif nargv[arg] = subst(nargv[arg], "LABEL", bundle_GetLabel(bundle)); nargv[arg] = substip(nargv[arg], "MYADDR", bundle->ncp.ipcp.my_ip); #ifndef NOINET6 nargv[arg] = substipv6(nargv[arg], "MYADDR6", &bundle->ncp.ipv6cp.myaddr); #ifndef NORADIUS nargv[arg] = substipv6prefix(nargv[arg], "IPV6PREFIX", bundle->radius.ipv6prefix); #endif #endif nargv[arg] = substull(nargv[arg], "OCTETSIN", oin); nargv[arg] = substull(nargv[arg], "OCTETSOUT", oout); nargv[arg] = substull(nargv[arg], "PACKETSIN", pin); nargv[arg] = substull(nargv[arg], "PACKETSOUT", pout); nargv[arg] = subst(nargv[arg], "PEER_ENDDISC", mp_Enddisc(bundle->ncp.mp.peer.enddisc.class, bundle->ncp.mp.peer.enddisc.address, bundle->ncp.mp.peer.enddisc.len)); nargv[arg] = substlong(nargv[arg], "PROCESSID", pid); if (server.cfg.port) nargv[arg] = substlong(nargv[arg], "SOCKNAME", server.cfg.port); else nargv[arg] = subst(nargv[arg], "SOCKNAME", server.cfg.sockname); nargv[arg] = subst(nargv[arg], "UPTIME", uptime); nargv[arg] = subst(nargv[arg], "USER", bundle->ncp.mp.peer.authname); nargv[arg] = subst(nargv[arg], "VERSION", Version); } nargv[arg] = NULL; } void command_Free(int argc, char **argv) { while (argc) { free(*argv); argc--; argv++; } } static int ShellCommand(struct cmdargs const *arg, int bg) { const char *shell; pid_t shpid, pid; #ifdef SHELL_ONLY_INTERACTIVELY /* we're only allowed to shell when we run ppp interactively */ if (arg->prompt && arg->prompt->owner) { log_Printf(LogWARN, "Can't start a shell from a network connection\n"); return 1; } #endif if (arg->argc == arg->argn) { if (!arg->prompt) { log_Printf(LogWARN, "Can't start an interactive shell from" " a config file\n"); return 1; } else if (arg->prompt->owner) { log_Printf(LogWARN, "Can't start an interactive shell from" " a socket connection\n"); return 1; } else if (bg) { log_Printf(LogWARN, "Can only start an interactive shell in" " the foreground mode\n"); return 1; } } pid = getpid(); if ((shpid = fork()) == 0) { int i, fd; if ((shell = getenv("SHELL")) == 0) shell = _PATH_BSHELL; timer_TermService(); if (arg->prompt) fd = arg->prompt->fd_out; else if ((fd = open(_PATH_DEVNULL, O_RDWR)) == -1) { log_Printf(LogALERT, "Failed to open %s: %s\n", _PATH_DEVNULL, strerror(errno)); exit(1); } dup2(fd, STDIN_FILENO); dup2(fd, STDOUT_FILENO); dup2(fd, STDERR_FILENO); for (i = getdtablesize(); i > STDERR_FILENO; i--) fcntl(i, F_SETFD, 1); #ifndef NOSUID setuid(ID0realuid()); #endif if (arg->argc > arg->argn) { /* substitute pseudo args */ char *argv[MAXARGS]; int argc = arg->argc - arg->argn; if (argc >= (int)(sizeof argv / sizeof argv[0])) { argc = sizeof argv / sizeof argv[0] - 1; log_Printf(LogWARN, "Truncating shell command to %d args\n", argc); } command_Expand(argv, argc, arg->argv + arg->argn, arg->bundle, 0, pid); if (bg) { pid_t p; p = getpid(); if (daemon(1, 1) == -1) { log_Printf(LogERROR, "%ld: daemon: %s\n", (long)p, strerror(errno)); exit(1); } } else if (arg->prompt) printf("ppp: Pausing until %s finishes\n", arg->argv[arg->argn]); execvp(argv[0], argv); } else { if (arg->prompt) printf("ppp: Pausing until %s finishes\n", shell); prompt_TtyOldMode(arg->prompt); execl(shell, shell, (char *)NULL); } log_Printf(LogWARN, "exec() of %s failed: %s\n", arg->argc > arg->argn ? arg->argv[arg->argn] : shell, strerror(errno)); _exit(255); } if (shpid == (pid_t)-1) log_Printf(LogERROR, "Fork failed: %s\n", strerror(errno)); else { int status; waitpid(shpid, &status, 0); } if (arg->prompt && !arg->prompt->owner) prompt_TtyCommandMode(arg->prompt); return 0; } static int BgShellCommand(struct cmdargs const *arg) { if (arg->argc == arg->argn) return -1; return ShellCommand(arg, 1); } static int FgShellCommand(struct cmdargs const *arg) { return ShellCommand(arg, 0); } static int ResolvCommand(struct cmdargs const *arg) { if (arg->argc == arg->argn + 1) { if (!strcasecmp(arg->argv[arg->argn], "reload")) ipcp_LoadDNS(&arg->bundle->ncp.ipcp); else if (!strcasecmp(arg->argv[arg->argn], "restore")) ipcp_RestoreDNS(&arg->bundle->ncp.ipcp); else if (!strcasecmp(arg->argv[arg->argn], "rewrite")) ipcp_WriteDNS(&arg->bundle->ncp.ipcp); else if (!strcasecmp(arg->argv[arg->argn], "readonly")) arg->bundle->ncp.ipcp.ns.writable = 0; else if (!strcasecmp(arg->argv[arg->argn], "writable")) arg->bundle->ncp.ipcp.ns.writable = 1; else return -1; return 0; } return -1; } #ifndef NONAT static struct cmdtab const NatCommands[] = { {"addr", NULL, nat_RedirectAddr, LOCAL_AUTH, "static address translation", "nat addr [addr_local addr_alias]", NULL}, {"deny_incoming", NULL, NatOption, LOCAL_AUTH, "stop incoming connections", "nat deny_incoming yes|no", (const void *) PKT_ALIAS_DENY_INCOMING}, {"enable", NULL, NatEnable, LOCAL_AUTH, "enable NAT", "nat enable yes|no", NULL}, {"log", NULL, NatOption, LOCAL_AUTH, "log NAT link creation", "nat log yes|no", (const void *) PKT_ALIAS_LOG}, {"port", NULL, nat_RedirectPort, LOCAL_AUTH, "port redirection", "nat port proto localaddr:port[-port] aliasport[-aliasport]", NULL}, {"proto", NULL, nat_RedirectProto, LOCAL_AUTH, "protocol redirection", "nat proto proto localIP [publicIP [remoteIP]]", NULL}, {"proxy", NULL, nat_ProxyRule, LOCAL_AUTH, "proxy control", "nat proxy server host[:port] ...", NULL}, #ifndef NO_FW_PUNCH {"punch_fw", NULL, nat_PunchFW, LOCAL_AUTH, "firewall control", "nat punch_fw [base count]", NULL}, #endif {"skinny_port", NULL, nat_SkinnyPort, LOCAL_AUTH, "TCP port used by Skinny Station protocol", "nat skinny_port [port]", NULL}, {"same_ports", NULL, NatOption, LOCAL_AUTH, "try to leave port numbers unchanged", "nat same_ports yes|no", (const void *) PKT_ALIAS_SAME_PORTS}, {"target", NULL, nat_SetTarget, LOCAL_AUTH, "Default address for incoming connections", "nat target addr", NULL}, {"unregistered_only", NULL, NatOption, LOCAL_AUTH, "translate unregistered (private) IP address space only", "nat unregistered_only yes|no", (const void *) PKT_ALIAS_UNREGISTERED_ONLY}, {"use_sockets", NULL, NatOption, LOCAL_AUTH, "allocate host sockets", "nat use_sockets yes|no", (const void *) PKT_ALIAS_USE_SOCKETS}, {"help", "?", HelpCommand, LOCAL_AUTH | LOCAL_NO_AUTH, "Display this message", "nat help|? [command]", NatCommands}, {NULL, NULL, NULL, 0, NULL, NULL, NULL}, }; #endif static struct cmdtab const AllowCommands[] = { {"modes", "mode", AllowModes, LOCAL_AUTH, "Only allow certain ppp modes", "allow modes mode...", NULL}, {"users", "user", AllowUsers, LOCAL_AUTH, "Only allow ppp access to certain users", "allow users logname...", NULL}, {"help", "?", HelpCommand, LOCAL_AUTH | LOCAL_NO_AUTH, "Display this message", "allow help|? [command]", AllowCommands}, {NULL, NULL, NULL, 0, NULL, NULL, NULL}, }; static struct cmdtab const IfaceCommands[] = { {"add", NULL, IfaceAddCommand, LOCAL_AUTH, "Add iface address", "iface add addr[/bits| mask] peer", NULL}, {NULL, "add!", IfaceAddCommand, LOCAL_AUTH, "Add or change an iface address", "iface add! addr[/bits| mask] peer", (void *)1}, {"clear", NULL, IfaceClearCommand, LOCAL_AUTH, "Clear iface address(es)", "iface clear [INET | INET6]", NULL}, {"delete", "rm", IfaceDeleteCommand, LOCAL_AUTH, "Delete iface address", "iface delete addr", NULL}, {NULL, "rm!", IfaceDeleteCommand, LOCAL_AUTH, "Delete iface address", "iface delete addr", (void *)1}, {NULL, "delete!", IfaceDeleteCommand, LOCAL_AUTH, "Delete iface address", "iface delete addr", (void *)1}, {"show", NULL, iface_Show, LOCAL_AUTH, "Show iface address(es)", "iface show", NULL}, {"help", "?", HelpCommand, LOCAL_AUTH | LOCAL_NO_AUTH, "Display this message", "nat help|? [command]", IfaceCommands}, {NULL, NULL, NULL, 0, NULL, NULL, NULL}, }; static struct cmdtab const Commands[] = { {"accept", NULL, NegotiateCommand, LOCAL_AUTH | LOCAL_CX_OPT, "accept option request", "accept option ..", NULL}, {"add", NULL, AddCommand, LOCAL_AUTH, "add route", "add dest mask gateway", NULL}, {NULL, "add!", AddCommand, LOCAL_AUTH, "add or change route", "add! dest mask gateway", (void *)1}, {"allow", "auth", RunListCommand, LOCAL_AUTH, "Allow ppp access", "allow users|modes ....", AllowCommands}, {"bg", "!bg", BgShellCommand, LOCAL_AUTH, "Run a background command", "[!]bg command", NULL}, {"clear", NULL, ClearCommand, LOCAL_AUTH | LOCAL_CX_OPT, "Clear throughput statistics", "clear ipcp|ipv6cp|physical [current|overall|peak]...", NULL}, {"clone", NULL, CloneCommand, LOCAL_AUTH | LOCAL_CX, "Clone a link", "clone newname...", NULL}, {"close", NULL, CloseCommand, LOCAL_AUTH | LOCAL_CX_OPT, "Close an FSM", "close [lcp|ccp]", NULL}, {"delete", NULL, DeleteCommand, LOCAL_AUTH, "delete route", "delete dest", NULL}, {NULL, "delete!", DeleteCommand, LOCAL_AUTH, "delete a route if it exists", "delete! dest", (void *)1}, {"deny", NULL, NegotiateCommand, LOCAL_AUTH | LOCAL_CX_OPT, "Deny option request", "deny option ..", NULL}, {"dial", "call", DialCommand, LOCAL_AUTH | LOCAL_CX_OPT, "Dial and login", "dial|call [system ...]", NULL}, {"disable", NULL, NegotiateCommand, LOCAL_AUTH | LOCAL_CX_OPT, "Disable option", "disable option ..", NULL}, {"down", NULL, DownCommand, LOCAL_AUTH | LOCAL_CX_OPT, "Generate a down event", "down [ccp|lcp]", NULL}, {"enable", NULL, NegotiateCommand, LOCAL_AUTH | LOCAL_CX_OPT, "Enable option", "enable option ..", NULL}, {"ident", NULL, IdentCommand, LOCAL_AUTH | LOCAL_CX, "Set the link identity", "ident text...", NULL}, {"iface", "interface", RunListCommand, LOCAL_AUTH, "interface control", "iface option ...", IfaceCommands}, {"link", "datalink", LinkCommand, LOCAL_AUTH, "Link specific commands", "link name command ...", NULL}, {"load", NULL, LoadCommand, LOCAL_AUTH | LOCAL_CX_OPT, "Load settings", "load [system ...]", NULL}, {"log", NULL, LogCommand, LOCAL_AUTH | LOCAL_CX_OPT, "log information", "log word ...", NULL}, #ifndef NONAT {"nat", "alias", RunListCommand, LOCAL_AUTH, "NAT control", "nat option yes|no", NatCommands}, #endif {"open", NULL, OpenCommand, LOCAL_AUTH | LOCAL_CX_OPT, "Open an FSM", "open! [lcp|ccp|ipcp]", (void *)1}, {"passwd", NULL, PasswdCommand, LOCAL_NO_AUTH, "Password for manipulation", "passwd LocalPassword", NULL}, {"quit", "bye", QuitCommand, LOCAL_AUTH | LOCAL_NO_AUTH, "Quit PPP program", "quit|bye [all]", NULL}, {"remove", "rm", RemoveCommand, LOCAL_AUTH | LOCAL_CX, "Remove a link", "remove", NULL}, {"rename", "mv", RenameCommand, LOCAL_AUTH | LOCAL_CX, "Rename a link", "rename name", NULL}, {"resolv", NULL, ResolvCommand, LOCAL_AUTH, "Manipulate resolv.conf", "resolv readonly|reload|restore|rewrite|writable", NULL}, {"save", NULL, SaveCommand, LOCAL_AUTH, "Save settings", "save", NULL}, {"sendident", NULL, SendIdentification, LOCAL_AUTH | LOCAL_CX, "Transmit the link identity", "sendident", NULL}, {"set", "setup", SetCommand, LOCAL_AUTH | LOCAL_CX_OPT, "Set parameters", "set[up] var value", NULL}, {"shell", "!", FgShellCommand, LOCAL_AUTH, "Run a subshell", "shell|! [sh command]", NULL}, {"show", NULL, ShowCommand, LOCAL_AUTH | LOCAL_CX_OPT, "Show status and stats", "show var", NULL}, {"term", NULL, TerminalCommand, LOCAL_AUTH | LOCAL_CX, "Enter terminal mode", "term", NULL}, {"help", "?", HelpCommand, LOCAL_AUTH | LOCAL_NO_AUTH, "Display this message", "help|? [command]", Commands}, {NULL, NULL, NULL, 0, NULL, NULL, NULL}, }; static int ShowEscape(struct cmdargs const *arg) { if (arg->cx->physical->async.cfg.EscMap[32]) { int code, bit; const char *sep = ""; for (code = 0; code < 32; code++) if (arg->cx->physical->async.cfg.EscMap[code]) for (bit = 0; bit < 8; bit++) if (arg->cx->physical->async.cfg.EscMap[code] & (1 << bit)) { prompt_Printf(arg->prompt, "%s0x%02x", sep, (code << 3) + bit); sep = ", "; } prompt_Printf(arg->prompt, "\n"); } return 0; } static int ShowTimerList(struct cmdargs const *arg) { timer_Show(0, arg->prompt); return 0; } static int ShowStopped(struct cmdargs const *arg) { prompt_Printf(arg->prompt, " Stopped Timer: LCP: "); if (!arg->cx->physical->link.lcp.fsm.StoppedTimer.load) prompt_Printf(arg->prompt, "Disabled"); else prompt_Printf(arg->prompt, "%ld secs", arg->cx->physical->link.lcp.fsm.StoppedTimer.load / SECTICKS); prompt_Printf(arg->prompt, ", CCP: "); if (!arg->cx->physical->link.ccp.fsm.StoppedTimer.load) prompt_Printf(arg->prompt, "Disabled"); else prompt_Printf(arg->prompt, "%ld secs", arg->cx->physical->link.ccp.fsm.StoppedTimer.load / SECTICKS); prompt_Printf(arg->prompt, "\n"); return 0; } static int ShowVersion(struct cmdargs const *arg) { prompt_Printf(arg->prompt, "PPP Version %s\n", Version); return 0; } static int ShowProtocolStats(struct cmdargs const *arg) { struct link *l = command_ChooseLink(arg); prompt_Printf(arg->prompt, "%s:\n", l->name); link_ReportProtocolStatus(l, arg->prompt); return 0; } static struct cmdtab const ShowCommands[] = { {"bundle", NULL, bundle_ShowStatus, LOCAL_AUTH, "bundle details", "show bundle", NULL}, {"ccp", NULL, ccp_ReportStatus, LOCAL_AUTH | LOCAL_CX_OPT, "CCP status", "show cpp", NULL}, {"compress", NULL, sl_Show, LOCAL_AUTH, "VJ compression stats", "show compress", NULL}, {"escape", NULL, ShowEscape, LOCAL_AUTH | LOCAL_CX, "escape characters", "show escape", NULL}, {"filter", NULL, filter_Show, LOCAL_AUTH, "packet filters", "show filter [in|out|dial|alive]", NULL}, {"hdlc", NULL, hdlc_ReportStatus, LOCAL_AUTH | LOCAL_CX, "HDLC errors", "show hdlc", NULL}, {"iface", "interface", iface_Show, LOCAL_AUTH, "Interface status", "show iface", NULL}, {"ipcp", NULL, ipcp_Show, LOCAL_AUTH, "IPCP status", "show ipcp", NULL}, #ifndef NOINET6 {"ipv6cp", NULL, ipv6cp_Show, LOCAL_AUTH, "IPV6CP status", "show ipv6cp", NULL}, #endif {"layers", NULL, link_ShowLayers, LOCAL_AUTH | LOCAL_CX_OPT, "Protocol layers", "show layers", NULL}, {"lcp", NULL, lcp_ReportStatus, LOCAL_AUTH | LOCAL_CX, "LCP status", "show lcp", NULL}, {"link", "datalink", datalink_Show, LOCAL_AUTH | LOCAL_CX, "(high-level) link info", "show link", NULL}, {"links", NULL, bundle_ShowLinks, LOCAL_AUTH, "available link names", "show links", NULL}, {"log", NULL, log_ShowLevel, LOCAL_AUTH, "log levels", "show log", NULL}, {"mem", NULL, mbuf_Show, LOCAL_AUTH, "mbuf allocations", "show mem", NULL}, {"ncp", NULL, ncp_Show, LOCAL_AUTH, "NCP status", "show ncp", NULL}, {"physical", NULL, physical_ShowStatus, LOCAL_AUTH | LOCAL_CX, "(low-level) link info", "show physical", NULL}, {"mp", "multilink", mp_ShowStatus, LOCAL_AUTH, "multilink setup", "show mp", NULL}, {"proto", NULL, ShowProtocolStats, LOCAL_AUTH | LOCAL_CX_OPT, "protocol summary", "show proto", NULL}, {"route", NULL, route_Show, LOCAL_AUTH, "routing table", "show route", NULL}, {"stopped", NULL, ShowStopped, LOCAL_AUTH | LOCAL_CX, "STOPPED timeout", "show stopped", NULL}, {"timers", NULL, ShowTimerList, LOCAL_AUTH, "alarm timers", "show timers", NULL}, {"version", NULL, ShowVersion, LOCAL_NO_AUTH | LOCAL_AUTH, "version string", "show version", NULL}, {"who", NULL, log_ShowWho, LOCAL_AUTH, "client list", "show who", NULL}, {"help", "?", HelpCommand, LOCAL_NO_AUTH | LOCAL_AUTH, "Display this message", "show help|? [command]", ShowCommands}, {NULL, NULL, NULL, 0, NULL, NULL, NULL}, }; static struct cmdtab const * FindCommand(struct cmdtab const *cmds, const char *str, int *pmatch) { int nmatch; int len; struct cmdtab const *found; found = NULL; len = strlen(str); nmatch = 0; while (cmds->func) { if (cmds->name && strncasecmp(str, cmds->name, len) == 0) { if (cmds->name[len] == '\0') { *pmatch = 1; return cmds; } nmatch++; found = cmds; } else if (cmds->alias && strncasecmp(str, cmds->alias, len) == 0) { if (cmds->alias[len] == '\0') { *pmatch = 1; return cmds; } nmatch++; found = cmds; } cmds++; } *pmatch = nmatch; return found; } static const char * mkPrefix(int argc, char const *const *argv, char *tgt, int sz) { int f, tlen, len; tlen = 0; for (f = 0; f < argc && tlen < sz - 2; f++) { if (f) tgt[tlen++] = ' '; len = strlen(argv[f]); if (len > sz - tlen - 1) len = sz - tlen - 1; strncpy(tgt+tlen, argv[f], len); tlen += len; } tgt[tlen] = '\0'; return tgt; } static int FindExec(struct bundle *bundle, struct cmdtab const *cmds, int argc, int argn, char const *const *argv, struct prompt *prompt, struct datalink *cx) { struct cmdtab const *cmd; int val = 1; int nmatch; struct cmdargs arg; char prefix[100]; cmd = FindCommand(cmds, argv[argn], &nmatch); if (nmatch > 1) log_Printf(LogWARN, "%s: Ambiguous command\n", mkPrefix(argn+1, argv, prefix, sizeof prefix)); else if (cmd && (!prompt || (cmd->lauth & prompt->auth))) { if ((cmd->lauth & LOCAL_CX) && !cx) /* We've got no context, but we require it */ cx = bundle2datalink(bundle, NULL); if ((cmd->lauth & LOCAL_CX) && !cx) log_Printf(LogWARN, "%s: No context (use the `link' command)\n", mkPrefix(argn+1, argv, prefix, sizeof prefix)); else { if (cx && !(cmd->lauth & (LOCAL_CX|LOCAL_CX_OPT))) { log_Printf(LogWARN, "%s: Redundant context (%s) ignored\n", mkPrefix(argn+1, argv, prefix, sizeof prefix), cx->name); cx = NULL; } arg.cmdtab = cmds; arg.cmd = cmd; arg.argc = argc; arg.argn = argn+1; arg.argv = argv; arg.bundle = bundle; arg.cx = cx; arg.prompt = prompt; val = (*cmd->func) (&arg); } } else log_Printf(LogWARN, "%s: Invalid command\n", mkPrefix(argn+1, argv, prefix, sizeof prefix)); if (val == -1) log_Printf(LogWARN, "usage: %s\n", cmd->syntax); else if (val) log_Printf(LogWARN, "%s: Failed %d\n", mkPrefix(argn+1, argv, prefix, sizeof prefix), val); return val; } int command_Expand_Interpret(char *buff, int nb, char *argv[MAXARGS], int offset) { char buff2[LINE_LEN-offset]; InterpretArg(buff, buff2); strncpy(buff, buff2, LINE_LEN - offset - 1); buff[LINE_LEN - offset - 1] = '\0'; return command_Interpret(buff, nb, argv); } int command_Interpret(char *buff, int nb, char *argv[MAXARGS]) { char *cp; if (nb > 0) { cp = buff + strcspn(buff, "\r\n"); if (cp) *cp = '\0'; return MakeArgs(buff, argv, MAXARGS, PARSE_REDUCE); } return 0; } static int arghidden(char const *const *argv, int n) { /* Is arg n of the given command to be hidden from the log ? */ /* set authkey xxxxx */ /* set key xxxxx */ if (n == 2 && !strncasecmp(argv[0], "se", 2) && (!strncasecmp(argv[1], "authk", 5) || !strncasecmp(argv[1], "ke", 2))) return 1; /* passwd xxxxx */ if (n == 1 && !strncasecmp(argv[0], "p", 1)) return 1; /* set server port xxxxx .... */ if (n == 3 && !strncasecmp(argv[0], "se", 2) && !strncasecmp(argv[1], "se", 2)) return 1; return 0; } void command_Run(struct bundle *bundle, int argc, char const *const *argv, struct prompt *prompt, const char *label, struct datalink *cx) { if (argc > 0) { if (log_IsKept(LogCOMMAND)) { char buf[LINE_LEN]; int f; size_t n; if (label) { strncpy(buf, label, sizeof buf - 3); buf[sizeof buf - 3] = '\0'; strcat(buf, ": "); n = strlen(buf); } else { *buf = '\0'; n = 0; } buf[sizeof buf - 1] = '\0'; /* In case we run out of room in buf */ for (f = 0; f < argc; f++) { if (n < sizeof buf - 1 && f) buf[n++] = ' '; if (arghidden(argv, f)) strncpy(buf+n, "********", sizeof buf - n - 1); else strncpy(buf+n, argv[f], sizeof buf - n - 1); n += strlen(buf+n); } log_Printf(LogCOMMAND, "%s\n", buf); } FindExec(bundle, Commands, argc, 0, argv, prompt, cx); } } int command_Decode(struct bundle *bundle, char *buff, int nb, struct prompt *prompt, const char *label) { int argc; char *argv[MAXARGS]; if ((argc = command_Expand_Interpret(buff, nb, argv, 0)) < 0) return 0; command_Run(bundle, argc, (char const *const *)argv, prompt, label, NULL); return 1; } static int ShowCommand(struct cmdargs const *arg) { if (!arg->prompt) log_Printf(LogWARN, "show: Cannot show without a prompt\n"); else if (arg->argc > arg->argn) FindExec(arg->bundle, ShowCommands, arg->argc, arg->argn, arg->argv, arg->prompt, arg->cx); else prompt_Printf(arg->prompt, "Use ``show ?'' to get a list.\n"); return 0; } static int TerminalCommand(struct cmdargs const *arg) { if (!arg->prompt) { log_Printf(LogWARN, "term: Need a prompt\n"); return 1; } if (arg->cx->physical->link.lcp.fsm.state > ST_CLOSED) { prompt_Printf(arg->prompt, "LCP state is [%s]\n", State2Nam(arg->cx->physical->link.lcp.fsm.state)); return 1; } datalink_Up(arg->cx, 0, 0); prompt_TtyTermMode(arg->prompt, arg->cx); return 0; } static int QuitCommand(struct cmdargs const *arg) { if (!arg->prompt || prompt_IsController(arg->prompt) || (arg->argc > arg->argn && !strcasecmp(arg->argv[arg->argn], "all") && (arg->prompt->auth & LOCAL_AUTH))) Cleanup(); if (arg->prompt) prompt_Destroy(arg->prompt, 1); return 0; } static int OpenCommand(struct cmdargs const *arg) { if (arg->argc == arg->argn) bundle_Open(arg->bundle, arg->cx ? arg->cx->name : NULL, PHYS_ALL, 1); else if (arg->argc == arg->argn + 1) { if (!strcasecmp(arg->argv[arg->argn], "lcp")) { struct datalink *cx = arg->cx ? arg->cx : bundle2datalink(arg->bundle, NULL); if (cx) { if (cx->physical->link.lcp.fsm.state == ST_OPENED) fsm_Reopen(&cx->physical->link.lcp.fsm); else bundle_Open(arg->bundle, cx->name, PHYS_ALL, 1); } else log_Printf(LogWARN, "open lcp: You must specify a link\n"); } else if (!strcasecmp(arg->argv[arg->argn], "ccp")) { struct fsm *fp; fp = &command_ChooseLink(arg)->ccp.fsm; if (fp->link->lcp.fsm.state != ST_OPENED) log_Printf(LogWARN, "open: LCP must be open before opening CCP\n"); else if (fp->state == ST_OPENED) fsm_Reopen(fp); else { fp->open_mode = 0; /* Not passive any more */ if (fp->state == ST_STOPPED) { fsm_Down(fp); fsm_Up(fp); } else { fsm_Up(fp); fsm_Open(fp); } } } else if (!strcasecmp(arg->argv[arg->argn], "ipcp")) { if (arg->cx) log_Printf(LogWARN, "open ipcp: You need not specify a link\n"); if (arg->bundle->ncp.ipcp.fsm.state == ST_OPENED) fsm_Reopen(&arg->bundle->ncp.ipcp.fsm); else bundle_Open(arg->bundle, NULL, PHYS_ALL, 1); } else return -1; } else return -1; return 0; } static int CloseCommand(struct cmdargs const *arg) { if (arg->argc == arg->argn) bundle_Close(arg->bundle, arg->cx ? arg->cx->name : NULL, CLOSE_STAYDOWN); else if (arg->argc == arg->argn + 1) { if (!strcasecmp(arg->argv[arg->argn], "lcp")) bundle_Close(arg->bundle, arg->cx ? arg->cx->name : NULL, CLOSE_LCP); else if (!strcasecmp(arg->argv[arg->argn], "ccp") || !strcasecmp(arg->argv[arg->argn], "ccp!")) { struct fsm *fp; fp = &command_ChooseLink(arg)->ccp.fsm; if (fp->state == ST_OPENED) { fsm_Close(fp); if (arg->argv[arg->argn][3] == '!') fp->open_mode = 0; /* Stay ST_CLOSED */ else fp->open_mode = OPEN_PASSIVE; /* Wait for the peer to start */ } } else return -1; } else return -1; return 0; } static int DownCommand(struct cmdargs const *arg) { if (arg->argc == arg->argn) { if (arg->cx) datalink_Down(arg->cx, CLOSE_STAYDOWN); else bundle_Down(arg->bundle, CLOSE_STAYDOWN); } else if (arg->argc == arg->argn + 1) { if (!strcasecmp(arg->argv[arg->argn], "lcp")) { if (arg->cx) datalink_Down(arg->cx, CLOSE_LCP); else bundle_Down(arg->bundle, CLOSE_LCP); } else if (!strcasecmp(arg->argv[arg->argn], "ccp")) { struct fsm *fp = arg->cx ? &arg->cx->physical->link.ccp.fsm : &arg->bundle->ncp.mp.link.ccp.fsm; fsm2initial(fp); } else return -1; } else return -1; return 0; } static int SetModemSpeed(struct cmdargs const *arg) { long speed; char *end; if (arg->argc > arg->argn && *arg->argv[arg->argn]) { if (arg->argc > arg->argn+1) { log_Printf(LogWARN, "SetModemSpeed: Too many arguments\n"); return -1; } if (strcasecmp(arg->argv[arg->argn], "sync") == 0) { physical_SetSync(arg->cx->physical); return 0; } end = NULL; speed = strtol(arg->argv[arg->argn], &end, 10); if (*end || speed < 0) { log_Printf(LogWARN, "SetModemSpeed: Bad argument \"%s\"", arg->argv[arg->argn]); return -1; } if (physical_SetSpeed(arg->cx->physical, speed)) return 0; log_Printf(LogWARN, "%s: Invalid speed\n", arg->argv[arg->argn]); } else log_Printf(LogWARN, "SetModemSpeed: No speed specified\n"); return -1; } static int SetStoppedTimeout(struct cmdargs const *arg) { struct link *l = &arg->cx->physical->link; l->lcp.fsm.StoppedTimer.load = 0; l->ccp.fsm.StoppedTimer.load = 0; if (arg->argc <= arg->argn+2) { if (arg->argc > arg->argn) { l->lcp.fsm.StoppedTimer.load = atoi(arg->argv[arg->argn]) * SECTICKS; if (arg->argc > arg->argn+1) l->ccp.fsm.StoppedTimer.load = atoi(arg->argv[arg->argn+1]) * SECTICKS; } return 0; } return -1; } static int SetServer(struct cmdargs const *arg) { int res = -1; if (arg->argc > arg->argn && arg->argc < arg->argn+4) { const char *port, *passwd, *mask; size_t mlen; /* What's what ? */ port = arg->argv[arg->argn]; if (arg->argc == arg->argn + 2) { passwd = arg->argv[arg->argn+1]; mask = NULL; } else if (arg->argc == arg->argn + 3) { passwd = arg->argv[arg->argn+1]; mask = arg->argv[arg->argn+2]; mlen = strlen(mask); if (mlen == 0 || mlen > 4 || strspn(mask, "01234567") != mlen || (mlen == 4 && *mask != '0')) { log_Printf(LogWARN, "%s %s: %s: Invalid mask\n", arg->argv[arg->argn - 2], arg->argv[arg->argn - 1], mask); return -1; } } else if (arg->argc != arg->argn + 1) return -1; else if (strcasecmp(port, "none") == 0) { if (server_Clear(arg->bundle)) log_Printf(LogPHASE, "Disabled server socket\n"); return 0; } else if (strcasecmp(port, "open") == 0) { switch (server_Reopen(arg->bundle)) { case SERVER_OK: return 0; case SERVER_FAILED: log_Printf(LogWARN, "Failed to reopen server port\n"); return 1; case SERVER_UNSET: log_Printf(LogWARN, "Cannot reopen unset server socket\n"); return 1; default: break; } return -1; } else if (strcasecmp(port, "closed") == 0) { if (server_Close(arg->bundle)) log_Printf(LogPHASE, "Closed server socket\n"); else log_Printf(LogWARN, "Server socket not open\n"); return 0; } else return -1; strncpy(server.cfg.passwd, passwd, sizeof server.cfg.passwd - 1); server.cfg.passwd[sizeof server.cfg.passwd - 1] = '\0'; if (*port == '/') { mode_t imask; char *ptr, name[LINE_LEN + 12]; if (mask == NULL) imask = (mode_t)-1; else for (imask = mlen = 0; mask[mlen]; mlen++) imask = (imask * 8) + mask[mlen] - '0'; ptr = strstr(port, "%d"); if (ptr) { snprintf(name, sizeof name, "%.*s%d%s", (int)(ptr - port), port, arg->bundle->unit, ptr + 2); port = name; } res = server_LocalOpen(arg->bundle, port, imask); } else { int iport, add = 0; if (mask != NULL) return -1; if (*port == '+') { port++; add = 1; } if (strspn(port, "0123456789") != strlen(port)) { struct servent *s; if ((s = getservbyname(port, "tcp")) == NULL) { iport = 0; log_Printf(LogWARN, "%s: Invalid port or service\n", port); } else iport = ntohs(s->s_port); } else iport = atoi(port); if (iport) { if (add) iport += arg->bundle->unit; res = server_TcpOpen(arg->bundle, iport); } else res = -1; } } return res; } static int SetEscape(struct cmdargs const *arg) { int code; int argc = arg->argc - arg->argn; char const *const *argv = arg->argv + arg->argn; for (code = 0; code < 33; code++) arg->cx->physical->async.cfg.EscMap[code] = 0; while (argc-- > 0) { sscanf(*argv++, "%x", &code); code &= 0xff; arg->cx->physical->async.cfg.EscMap[code >> 3] |= (1 << (code & 7)); arg->cx->physical->async.cfg.EscMap[32] = 1; } return 0; } static int SetInterfaceAddr(struct cmdargs const *arg) { struct ncp *ncp = &arg->bundle->ncp; struct ncpaddr ncpaddr; const char *hisaddr; if (arg->argc > arg->argn + 4) return -1; hisaddr = NULL; memset(&ncp->ipcp.cfg.my_range, '\0', sizeof ncp->ipcp.cfg.my_range); memset(&ncp->ipcp.cfg.peer_range, '\0', sizeof ncp->ipcp.cfg.peer_range); ncp->ipcp.cfg.HaveTriggerAddress = 0; ncp->ipcp.cfg.netmask.s_addr = INADDR_ANY; iplist_reset(&ncp->ipcp.cfg.peer_list); if (arg->argc > arg->argn) { if (!ncprange_aton(&ncp->ipcp.cfg.my_range, ncp, arg->argv[arg->argn])) return 1; if (arg->argc > arg->argn+1) { hisaddr = arg->argv[arg->argn+1]; if (arg->argc > arg->argn+2) { ncp->ipcp.ifmask = ncp->ipcp.cfg.netmask = GetIpAddr(arg->argv[arg->argn+2]); if (arg->argc > arg->argn+3) { ncp->ipcp.cfg.TriggerAddress = GetIpAddr(arg->argv[arg->argn+3]); ncp->ipcp.cfg.HaveTriggerAddress = 1; } } } } /* 0.0.0.0 means any address (0 bits) */ ncprange_getaddr(&ncp->ipcp.cfg.my_range, &ncpaddr); ncpaddr_getip4(&ncpaddr, &ncp->ipcp.my_ip); if (ncp->ipcp.my_ip.s_addr == INADDR_ANY) ncprange_setwidth(&ncp->ipcp.cfg.my_range, 0); bundle_AdjustFilters(arg->bundle, &ncpaddr, NULL); if (hisaddr && !ipcp_UseHisaddr(arg->bundle, hisaddr, arg->bundle->phys_type.all & PHYS_AUTO)) return 4; return 0; } static int SetRetry(int argc, char const *const *argv, u_int *timeout, u_int *maxreq, u_int *maxtrm, int def) { if (argc == 0) { *timeout = DEF_FSMRETRY; *maxreq = def; if (maxtrm != NULL) *maxtrm = def; } else { long l = atol(argv[0]); if (l < MIN_FSMRETRY) { log_Printf(LogWARN, "%ld: Invalid FSM retry period - min %d\n", l, MIN_FSMRETRY); return 1; } else *timeout = l; if (argc > 1) { l = atol(argv[1]); if (l < 1) { log_Printf(LogWARN, "%ld: Invalid FSM REQ tries - changed to 1\n", l); l = 1; } *maxreq = l; if (argc > 2 && maxtrm != NULL) { l = atol(argv[2]); if (l < 1) { log_Printf(LogWARN, "%ld: Invalid FSM TRM tries - changed to 1\n", l); l = 1; } *maxtrm = l; } } } return 0; } static int SetVariable(struct cmdargs const *arg) { long long_val, param = (long)arg->cmd->args; int mode, dummyint, f, first, res; u_short *change; const char *argp; struct datalink *cx = arg->cx; /* LOCAL_CX uses this */ struct link *l = command_ChooseLink(arg); /* LOCAL_CX_OPT uses this */ struct in_addr *ipaddr; struct ncpaddr ncpaddr[2]; if (arg->argc > arg->argn) argp = arg->argv[arg->argn]; else argp = ""; res = 0; if ((arg->cmd->lauth & LOCAL_CX) && !cx) { log_Printf(LogWARN, "set %s: No context (use the `link' command)\n", arg->cmd->name); return 1; } else if (cx && !(arg->cmd->lauth & (LOCAL_CX|LOCAL_CX_OPT))) { log_Printf(LogWARN, "set %s: Redundant context (%s) ignored\n", arg->cmd->name, cx->name); cx = NULL; } switch (param) { case VAR_AUTHKEY: strncpy(arg->bundle->cfg.auth.key, argp, sizeof arg->bundle->cfg.auth.key - 1); arg->bundle->cfg.auth.key[sizeof arg->bundle->cfg.auth.key - 1] = '\0'; break; case VAR_AUTHNAME: switch (bundle_Phase(arg->bundle)) { default: log_Printf(LogWARN, "Altering authname while at phase %s\n", bundle_PhaseName(arg->bundle)); /* drop through */ case PHASE_DEAD: case PHASE_ESTABLISH: strncpy(arg->bundle->cfg.auth.name, argp, sizeof arg->bundle->cfg.auth.name - 1); arg->bundle->cfg.auth.name[sizeof arg->bundle->cfg.auth.name-1] = '\0'; break; } break; case VAR_AUTOLOAD: if (arg->argc == arg->argn + 3) { int v1, v2, v3; char *end; v1 = strtol(arg->argv[arg->argn], &end, 0); if (v1 < 0 || *end) { log_Printf(LogWARN, "autoload: %s: Invalid min percentage\n", arg->argv[arg->argn]); res = 1; break; } v2 = strtol(arg->argv[arg->argn + 1], &end, 0); if (v2 < 0 || *end) { log_Printf(LogWARN, "autoload: %s: Invalid max percentage\n", arg->argv[arg->argn + 1]); res = 1; break; } if (v2 < v1) { v3 = v1; v1 = v2; v2 = v3; } v3 = strtol(arg->argv[arg->argn + 2], &end, 0); if (v3 <= 0 || *end) { log_Printf(LogWARN, "autoload: %s: Invalid throughput period\n", arg->argv[arg->argn + 2]); res = 1; break; } arg->bundle->ncp.mp.cfg.autoload.min = v1; arg->bundle->ncp.mp.cfg.autoload.max = v2; arg->bundle->ncp.mp.cfg.autoload.period = v3; mp_RestartAutoloadTimer(&arg->bundle->ncp.mp); } else { log_Printf(LogWARN, "Set autoload requires three arguments\n"); res = 1; } break; case VAR_DIAL: strncpy(cx->cfg.script.dial, argp, sizeof cx->cfg.script.dial - 1); cx->cfg.script.dial[sizeof cx->cfg.script.dial - 1] = '\0'; break; case VAR_LOGIN: strncpy(cx->cfg.script.login, argp, sizeof cx->cfg.script.login - 1); cx->cfg.script.login[sizeof cx->cfg.script.login - 1] = '\0'; break; case VAR_WINSIZE: if (arg->argc > arg->argn) { l->ccp.cfg.deflate.out.winsize = atoi(arg->argv[arg->argn]); if (l->ccp.cfg.deflate.out.winsize < 8 || l->ccp.cfg.deflate.out.winsize > 15) { log_Printf(LogWARN, "%d: Invalid outgoing window size\n", l->ccp.cfg.deflate.out.winsize); l->ccp.cfg.deflate.out.winsize = 15; } if (arg->argc > arg->argn+1) { l->ccp.cfg.deflate.in.winsize = atoi(arg->argv[arg->argn+1]); if (l->ccp.cfg.deflate.in.winsize < 8 || l->ccp.cfg.deflate.in.winsize > 15) { log_Printf(LogWARN, "%d: Invalid incoming window size\n", l->ccp.cfg.deflate.in.winsize); l->ccp.cfg.deflate.in.winsize = 15; } } else l->ccp.cfg.deflate.in.winsize = 0; } else { log_Printf(LogWARN, "No window size specified\n"); res = 1; } break; #ifndef NODES case VAR_MPPE: if (arg->argc > arg->argn + 2) { res = -1; break; } if (arg->argc == arg->argn) { l->ccp.cfg.mppe.keybits = 0; l->ccp.cfg.mppe.state = MPPE_ANYSTATE; l->ccp.cfg.mppe.required = 0; break; } if (!strcmp(argp, "*")) long_val = 0; else { long_val = atol(argp); if (long_val != 40 && long_val != 56 && long_val != 128) { log_Printf(LogWARN, "%s: Invalid bits value\n", argp); res = -1; break; } } if (arg->argc == arg->argn + 2) { if (!strcmp(arg->argv[arg->argn + 1], "*")) l->ccp.cfg.mppe.state = MPPE_ANYSTATE; else if (!strcasecmp(arg->argv[arg->argn + 1], "stateless")) l->ccp.cfg.mppe.state = MPPE_STATELESS; else if (!strcasecmp(arg->argv[arg->argn + 1], "stateful")) l->ccp.cfg.mppe.state = MPPE_STATEFUL; else { log_Printf(LogWARN, "%s: Invalid state value\n", arg->argv[arg->argn + 1]); res = -1; break; } } else l->ccp.cfg.mppe.state = MPPE_ANYSTATE; l->ccp.cfg.mppe.keybits = long_val; l->ccp.cfg.mppe.required = 1; break; #endif case VAR_DEVICE: physical_SetDeviceList(cx->physical, arg->argc - arg->argn, arg->argv + arg->argn); break; case VAR_ACCMAP: if (arg->argc > arg->argn) { u_long ulong_val; sscanf(argp, "%lx", &ulong_val); cx->physical->link.lcp.cfg.accmap = (u_int32_t)ulong_val; } else { log_Printf(LogWARN, "No accmap specified\n"); res = 1; } break; case VAR_MODE: mode = Nam2mode(argp); if (mode == PHYS_NONE || mode == PHYS_ALL) { log_Printf(LogWARN, "%s: Invalid mode\n", argp); res = -1; break; } bundle_SetMode(arg->bundle, cx, mode); break; case VAR_MRRU: switch (bundle_Phase(arg->bundle)) { case PHASE_DEAD: break; case PHASE_ESTABLISH: /* Make sure none of our links are DATALINK_LCP or greater */ if (bundle_HighestState(arg->bundle) >= DATALINK_LCP) { log_Printf(LogWARN, "mrru: Only changable before LCP negotiations\n"); res = 1; break; } break; default: log_Printf(LogWARN, "mrru: Only changable at phase DEAD/ESTABLISH\n"); res = 1; break; } if (res != 0) break; long_val = atol(argp); if (long_val && long_val < MIN_MRU) { log_Printf(LogWARN, "MRRU %ld: too small - min %d\n", long_val, MIN_MRU); res = 1; break; } else if (long_val > MAX_MRU) { log_Printf(LogWARN, "MRRU %ld: too big - max %d\n", long_val, MAX_MRU); res = 1; break; } else arg->bundle->ncp.mp.cfg.mrru = long_val; break; case VAR_MRU: long_val = 0; /* silence gcc */ change = NULL; /* silence gcc */ switch(arg->argc - arg->argn) { case 1: if (argp[strspn(argp, "0123456789")] != '\0') { res = -1; break; } /*FALLTHRU*/ case 0: long_val = atol(argp); change = &l->lcp.cfg.mru; if (long_val > l->lcp.cfg.max_mru) { log_Printf(LogWARN, "MRU %ld: too large - max set to %d\n", long_val, l->lcp.cfg.max_mru); res = 1; break; } break; case 2: if (strcasecmp(argp, "max") && strcasecmp(argp, "maximum")) { res = -1; break; } long_val = atol(arg->argv[arg->argn + 1]); change = &l->lcp.cfg.max_mru; if (long_val > MAX_MRU) { log_Printf(LogWARN, "MRU %ld: too large - maximum is %d\n", long_val, MAX_MRU); res = 1; break; } break; default: res = -1; break; } if (res != 0) break; if (long_val == 0) *change = 0; else if (long_val < MIN_MRU) { log_Printf(LogWARN, "MRU %ld: too small - min %d\n", long_val, MIN_MRU); res = 1; break; } else if (long_val > MAX_MRU) { log_Printf(LogWARN, "MRU %ld: too big - max %d\n", long_val, MAX_MRU); res = 1; break; } else *change = long_val; if (l->lcp.cfg.mru > *change) l->lcp.cfg.mru = *change; break; case VAR_MTU: long_val = 0; /* silence gcc */ change = NULL; /* silence gcc */ switch(arg->argc - arg->argn) { case 1: if (argp[strspn(argp, "0123456789")] != '\0') { res = -1; break; } /*FALLTHRU*/ case 0: long_val = atol(argp); change = &l->lcp.cfg.mtu; if (long_val > l->lcp.cfg.max_mtu) { log_Printf(LogWARN, "MTU %ld: too large - max set to %d\n", long_val, l->lcp.cfg.max_mtu); res = 1; break; } break; case 2: if (strcasecmp(argp, "max") && strcasecmp(argp, "maximum")) { res = -1; break; } long_val = atol(arg->argv[arg->argn + 1]); change = &l->lcp.cfg.max_mtu; if (long_val > MAX_MTU) { log_Printf(LogWARN, "MTU %ld: too large - maximum is %d\n", long_val, MAX_MTU); res = 1; break; } break; default: res = -1; break; } if (res != 0) break; if (long_val && long_val < MIN_MTU) { log_Printf(LogWARN, "MTU %ld: too small - min %d\n", long_val, MIN_MTU); res = 1; break; } else if (long_val > MAX_MTU) { log_Printf(LogWARN, "MTU %ld: too big - max %d\n", long_val, MAX_MTU); res = 1; break; } else *change = long_val; if (l->lcp.cfg.mtu > *change) l->lcp.cfg.mtu = *change; break; case VAR_OPENMODE: if (strcasecmp(argp, "active") == 0) cx->physical->link.lcp.cfg.openmode = arg->argc > arg->argn+1 ? atoi(arg->argv[arg->argn+1]) : 1; else if (strcasecmp(argp, "passive") == 0) cx->physical->link.lcp.cfg.openmode = OPEN_PASSIVE; else { log_Printf(LogWARN, "%s: Invalid openmode\n", argp); res = 1; } break; case VAR_PHONE: strncpy(cx->cfg.phone.list, argp, sizeof cx->cfg.phone.list - 1); cx->cfg.phone.list[sizeof cx->cfg.phone.list - 1] = '\0'; cx->phone.alt = cx->phone.next = NULL; break; case VAR_HANGUP: strncpy(cx->cfg.script.hangup, argp, sizeof cx->cfg.script.hangup - 1); cx->cfg.script.hangup[sizeof cx->cfg.script.hangup - 1] = '\0'; break; case VAR_IFQUEUE: long_val = atol(argp); arg->bundle->cfg.ifqueue = long_val < 0 ? 0 : long_val; break; case VAR_LOGOUT: strncpy(cx->cfg.script.logout, argp, sizeof cx->cfg.script.logout - 1); cx->cfg.script.logout[sizeof cx->cfg.script.logout - 1] = '\0'; break; case VAR_IDLETIMEOUT: if (arg->argc > arg->argn+2) { log_Printf(LogWARN, "Too many idle timeout values\n"); res = 1; } else if (arg->argc == arg->argn) { log_Printf(LogWARN, "Too few idle timeout values\n"); res = 1; } else { unsigned long timeout, min; timeout = strtoul(argp, NULL, 10); min = arg->bundle->cfg.idle.min_timeout; if (arg->argc == arg->argn + 2) min = strtoul(arg->argv[arg->argn + 1], NULL, 10); bundle_SetIdleTimer(arg->bundle, timeout, min); } break; #ifndef NORADIUS case VAR_RAD_ALIVE: if (arg->argc > arg->argn + 2) { log_Printf(LogWARN, "Too many RADIUS alive interval values\n"); res = 1; } else if (arg->argc == arg->argn) { log_Printf(LogWARN, "Too few RADIUS alive interval values\n"); res = 1; } else { arg->bundle->radius.alive.interval = atoi(argp); if (arg->bundle->radius.alive.interval && !arg->bundle->radius.cfg.file) { log_Printf(LogWARN, "rad_alive requires radius to be configured\n"); res = 1; } else if (arg->bundle->ncp.ipcp.fsm.state == ST_OPENED) { if (arg->bundle->radius.alive.interval) radius_StartTimer(arg->bundle); else radius_StopTimer(&arg->bundle->radius); } } break; #endif case VAR_LQRPERIOD: long_val = atol(argp); if (long_val < MIN_LQRPERIOD) { log_Printf(LogWARN, "%ld: Invalid lqr period - min %d\n", long_val, MIN_LQRPERIOD); res = 1; } else l->lcp.cfg.lqrperiod = long_val; break; case VAR_LCPRETRY: res = SetRetry(arg->argc - arg->argn, arg->argv + arg->argn, &cx->physical->link.lcp.cfg.fsm.timeout, &cx->physical->link.lcp.cfg.fsm.maxreq, &cx->physical->link.lcp.cfg.fsm.maxtrm, DEF_FSMTRIES); break; case VAR_CHAPRETRY: res = SetRetry(arg->argc - arg->argn, arg->argv + arg->argn, &cx->chap.auth.cfg.fsm.timeout, &cx->chap.auth.cfg.fsm.maxreq, NULL, DEF_FSMAUTHTRIES); break; case VAR_PAPRETRY: res = SetRetry(arg->argc - arg->argn, arg->argv + arg->argn, &cx->pap.cfg.fsm.timeout, &cx->pap.cfg.fsm.maxreq, NULL, DEF_FSMAUTHTRIES); break; case VAR_CCPRETRY: res = SetRetry(arg->argc - arg->argn, arg->argv + arg->argn, &l->ccp.cfg.fsm.timeout, &l->ccp.cfg.fsm.maxreq, &l->ccp.cfg.fsm.maxtrm, DEF_FSMTRIES); break; case VAR_IPCPRETRY: res = SetRetry(arg->argc - arg->argn, arg->argv + arg->argn, &arg->bundle->ncp.ipcp.cfg.fsm.timeout, &arg->bundle->ncp.ipcp.cfg.fsm.maxreq, &arg->bundle->ncp.ipcp.cfg.fsm.maxtrm, DEF_FSMTRIES); break; #ifndef NOINET6 case VAR_IPV6CPRETRY: res = SetRetry(arg->argc - arg->argn, arg->argv + arg->argn, &arg->bundle->ncp.ipv6cp.cfg.fsm.timeout, &arg->bundle->ncp.ipv6cp.cfg.fsm.maxreq, &arg->bundle->ncp.ipv6cp.cfg.fsm.maxtrm, DEF_FSMTRIES); break; #endif case VAR_NBNS: case VAR_DNS: if (param == VAR_DNS) { ipaddr = arg->bundle->ncp.ipcp.cfg.ns.dns; ipaddr[0].s_addr = ipaddr[1].s_addr = INADDR_NONE; } else { ipaddr = arg->bundle->ncp.ipcp.cfg.ns.nbns; ipaddr[0].s_addr = ipaddr[1].s_addr = INADDR_ANY; } if (arg->argc > arg->argn) { ncpaddr_aton(ncpaddr, &arg->bundle->ncp, arg->argv[arg->argn]); if (!ncpaddr_getip4(ncpaddr, ipaddr)) return -1; if (arg->argc > arg->argn+1) { ncpaddr_aton(ncpaddr + 1, &arg->bundle->ncp, arg->argv[arg->argn + 1]); if (!ncpaddr_getip4(ncpaddr + 1, ipaddr + 1)) return -1; } if (ipaddr[0].s_addr == INADDR_ANY) { ipaddr[0] = ipaddr[1]; ipaddr[1].s_addr = INADDR_ANY; } if (ipaddr[0].s_addr == INADDR_NONE) { ipaddr[0] = ipaddr[1]; ipaddr[1].s_addr = INADDR_NONE; } } break; case VAR_CALLBACK: cx->cfg.callback.opmask = 0; for (dummyint = arg->argn; dummyint < arg->argc; dummyint++) { if (!strcasecmp(arg->argv[dummyint], "auth")) cx->cfg.callback.opmask |= CALLBACK_BIT(CALLBACK_AUTH); else if (!strcasecmp(arg->argv[dummyint], "cbcp")) cx->cfg.callback.opmask |= CALLBACK_BIT(CALLBACK_CBCP); else if (!strcasecmp(arg->argv[dummyint], "e.164")) { if (dummyint == arg->argc - 1) log_Printf(LogWARN, "No E.164 arg (E.164 ignored) !\n"); else { cx->cfg.callback.opmask |= CALLBACK_BIT(CALLBACK_E164); strncpy(cx->cfg.callback.msg, arg->argv[++dummyint], sizeof cx->cfg.callback.msg - 1); cx->cfg.callback.msg[sizeof cx->cfg.callback.msg - 1] = '\0'; } } else if (!strcasecmp(arg->argv[dummyint], "none")) cx->cfg.callback.opmask |= CALLBACK_BIT(CALLBACK_NONE); else { res = -1; break; } } if (cx->cfg.callback.opmask == CALLBACK_BIT(CALLBACK_NONE)) cx->cfg.callback.opmask = 0; break; case VAR_CBCP: cx->cfg.cbcp.delay = 0; *cx->cfg.cbcp.phone = '\0'; cx->cfg.cbcp.fsmretry = DEF_FSMRETRY; if (arg->argc > arg->argn) { strncpy(cx->cfg.cbcp.phone, arg->argv[arg->argn], sizeof cx->cfg.cbcp.phone - 1); cx->cfg.cbcp.phone[sizeof cx->cfg.cbcp.phone - 1] = '\0'; if (arg->argc > arg->argn + 1) { cx->cfg.cbcp.delay = atoi(arg->argv[arg->argn + 1]); if (arg->argc > arg->argn + 2) { long_val = atol(arg->argv[arg->argn + 2]); if (long_val < MIN_FSMRETRY) log_Printf(LogWARN, "%ld: Invalid CBCP FSM retry period - min %d\n", long_val, MIN_FSMRETRY); else cx->cfg.cbcp.fsmretry = long_val; } } } break; case VAR_CHOKED: arg->bundle->cfg.choked.timeout = atoi(argp); if (arg->bundle->cfg.choked.timeout <= 0) arg->bundle->cfg.choked.timeout = CHOKED_TIMEOUT; break; case VAR_SENDPIPE: long_val = atol(argp); arg->bundle->ncp.cfg.sendpipe = long_val; break; case VAR_RECVPIPE: long_val = atol(argp); arg->bundle->ncp.cfg.recvpipe = long_val; break; #ifndef NORADIUS case VAR_RADIUS: if (!*argp) *arg->bundle->radius.cfg.file = '\0'; else if (access(argp, R_OK)) { log_Printf(LogWARN, "%s: %s\n", argp, strerror(errno)); res = 1; break; } else { strncpy(arg->bundle->radius.cfg.file, argp, sizeof arg->bundle->radius.cfg.file - 1); arg->bundle->radius.cfg.file [sizeof arg->bundle->radius.cfg.file - 1] = '\0'; } break; #endif case VAR_CD: if (*argp) { if (strcasecmp(argp, "off")) { long_val = atol(argp); if (long_val < 0) long_val = 0; cx->physical->cfg.cd.delay = long_val; cx->physical->cfg.cd.necessity = argp[strlen(argp)-1] == '!' ? CD_REQUIRED : CD_VARIABLE; } else cx->physical->cfg.cd.necessity = CD_NOTREQUIRED; } else { cx->physical->cfg.cd.delay = 0; cx->physical->cfg.cd.necessity = CD_DEFAULT; } break; case VAR_PARITY: if (arg->argc == arg->argn + 1) res = physical_SetParity(arg->cx->physical, argp); else { log_Printf(LogWARN, "Parity value must be odd, even or none\n"); res = 1; } break; case VAR_CRTSCTS: if (strcasecmp(argp, "on") == 0) physical_SetRtsCts(arg->cx->physical, 1); else if (strcasecmp(argp, "off") == 0) physical_SetRtsCts(arg->cx->physical, 0); else { log_Printf(LogWARN, "RTS/CTS value must be on or off\n"); res = 1; } break; case VAR_URGENTPORTS: if (arg->argn == arg->argc) { ncp_SetUrgentTOS(&arg->bundle->ncp); ncp_ClearUrgentTcpPorts(&arg->bundle->ncp); ncp_ClearUrgentUdpPorts(&arg->bundle->ncp); } else if (!strcasecmp(arg->argv[arg->argn], "udp")) { ncp_SetUrgentTOS(&arg->bundle->ncp); if (arg->argn == arg->argc - 1) ncp_ClearUrgentUdpPorts(&arg->bundle->ncp); else for (f = arg->argn + 1; f < arg->argc; f++) if (*arg->argv[f] == '+') ncp_AddUrgentUdpPort(&arg->bundle->ncp, atoi(arg->argv[f] + 1)); else if (*arg->argv[f] == '-') ncp_RemoveUrgentUdpPort(&arg->bundle->ncp, atoi(arg->argv[f] + 1)); else { if (f == arg->argn) ncp_ClearUrgentUdpPorts(&arg->bundle->ncp); ncp_AddUrgentUdpPort(&arg->bundle->ncp, atoi(arg->argv[f])); } } else if (arg->argn == arg->argc - 1 && !strcasecmp(arg->argv[arg->argn], "none")) { ncp_ClearUrgentTcpPorts(&arg->bundle->ncp); ncp_ClearUrgentUdpPorts(&arg->bundle->ncp); ncp_ClearUrgentTOS(&arg->bundle->ncp); } else { ncp_SetUrgentTOS(&arg->bundle->ncp); first = arg->argn; if (!strcasecmp(arg->argv[first], "tcp") && ++first == arg->argc) ncp_ClearUrgentTcpPorts(&arg->bundle->ncp); for (f = first; f < arg->argc; f++) if (*arg->argv[f] == '+') ncp_AddUrgentTcpPort(&arg->bundle->ncp, atoi(arg->argv[f] + 1)); else if (*arg->argv[f] == '-') ncp_RemoveUrgentTcpPort(&arg->bundle->ncp, atoi(arg->argv[f] + 1)); else { if (f == first) ncp_ClearUrgentTcpPorts(&arg->bundle->ncp); ncp_AddUrgentTcpPort(&arg->bundle->ncp, atoi(arg->argv[f])); } } break; case VAR_PPPOE: if (strcasecmp(argp, "3Com") == 0) physical_SetPPPoEnonstandard(arg->cx->physical, 1); else if (strcasecmp(argp, "standard") == 0) physical_SetPPPoEnonstandard(arg->cx->physical, 0); else { log_Printf(LogWARN, "PPPoE standard value must be \"standard\" or \"3Com\"\n"); res = 1; } break; #ifndef NORADIUS case VAR_PORT_ID: if (strcasecmp(argp, "default") == 0) arg->bundle->radius.port_id_type = RPI_DEFAULT; else if (strcasecmp(argp, "pid") == 0) arg->bundle->radius.port_id_type = RPI_PID; else if (strcasecmp(argp, "ifnum") == 0) arg->bundle->radius.port_id_type = RPI_IFNUM; else if (strcasecmp(argp, "tunnum") == 0) arg->bundle->radius.port_id_type = RPI_TUNNUM; else { log_Printf(LogWARN, "RADIUS port id must be one of \"default\", \"pid\", \"ifnum\" or \"tunnum\"\n"); res = 1; } if (arg->bundle->radius.port_id_type && !arg->bundle->radius.cfg.file) { log_Printf(LogWARN, "rad_port_id requires radius to be configured\n"); res = 1; } break; #endif } return res; } static struct cmdtab const SetCommands[] = { {"accmap", NULL, SetVariable, LOCAL_AUTH | LOCAL_CX, "accmap value", "set accmap hex-value", (const void *)VAR_ACCMAP}, {"authkey", "key", SetVariable, LOCAL_AUTH, "authentication key", "set authkey|key key", (const void *)VAR_AUTHKEY}, {"authname", NULL, SetVariable, LOCAL_AUTH, "authentication name", "set authname name", (const void *)VAR_AUTHNAME}, {"autoload", NULL, SetVariable, LOCAL_AUTH, "auto link [de]activation", "set autoload maxtime maxload mintime minload", (const void *)VAR_AUTOLOAD}, {"bandwidth", NULL, mp_SetDatalinkBandwidth, LOCAL_AUTH | LOCAL_CX, "datalink bandwidth", "set bandwidth value", NULL}, {"callback", NULL, SetVariable, LOCAL_AUTH | LOCAL_CX, "callback control", "set callback [none|auth|cbcp|" "E.164 *|number[,number]...]...", (const void *)VAR_CALLBACK}, {"cbcp", NULL, SetVariable, LOCAL_AUTH | LOCAL_CX, "CBCP control", "set cbcp [*|phone[,phone...] [delay [timeout]]]", (const void *)VAR_CBCP}, {"ccpretry", "ccpretries", SetVariable, LOCAL_AUTH | LOCAL_CX_OPT, "CCP retries", "set ccpretry value [attempts]", (const void *)VAR_CCPRETRY}, {"cd", NULL, SetVariable, LOCAL_AUTH | LOCAL_CX, "Carrier delay requirement", "set cd value[!]", (const void *)VAR_CD}, {"chapretry", "chapretries", SetVariable, LOCAL_AUTH | LOCAL_CX, "CHAP retries", "set chapretry value [attempts]", (const void *)VAR_CHAPRETRY}, {"choked", NULL, SetVariable, LOCAL_AUTH, "choked timeout", "set choked [secs]", (const void *)VAR_CHOKED}, {"ctsrts", "crtscts", SetVariable, LOCAL_AUTH | LOCAL_CX, "Use hardware flow control", "set ctsrts [on|off]", (const char *)VAR_CRTSCTS}, {"deflate", NULL, SetVariable, LOCAL_AUTH | LOCAL_CX_OPT, "deflate window sizes", "set deflate out-winsize in-winsize", (const void *) VAR_WINSIZE}, #ifndef NODES {"mppe", NULL, SetVariable, LOCAL_AUTH | LOCAL_CX_OPT, "MPPE key size and state", "set mppe [40|56|128|* [stateful|stateless|*]]", (const void *) VAR_MPPE}, #endif {"device", "line", SetVariable, LOCAL_AUTH | LOCAL_CX, "physical device name", "set device|line device-name[,device-name]", (const void *) VAR_DEVICE}, {"dial", NULL, SetVariable, LOCAL_AUTH | LOCAL_CX, "dialing script", "set dial chat-script", (const void *) VAR_DIAL}, {"dns", NULL, SetVariable, LOCAL_AUTH, "Domain Name Server", "set dns pri-addr [sec-addr]", (const void *)VAR_DNS}, {"enddisc", NULL, mp_SetEnddisc, LOCAL_AUTH, "Endpoint Discriminator", "set enddisc [IP|magic|label|psn value]", NULL}, {"escape", NULL, SetEscape, LOCAL_AUTH | LOCAL_CX, "escape characters", "set escape hex-digit ...", NULL}, {"filter", NULL, filter_Set, LOCAL_AUTH, "packet filters", "set filter alive|dial|in|out rule-no permit|deny " "[src_addr[/width]] [dst_addr[/width]] [proto " "[src [lt|eq|gt port]] [dst [lt|eq|gt port]] [estab] [syn] [finrst]]", NULL}, {"hangup", NULL, SetVariable, LOCAL_AUTH | LOCAL_CX, "hangup script", "set hangup chat-script", (const void *) VAR_HANGUP}, {"ifaddr", NULL, SetInterfaceAddr, LOCAL_AUTH, "destination address", "set ifaddr [src-addr [dst-addr [netmask [trg-addr]]]]", NULL}, {"ifqueue", NULL, SetVariable, LOCAL_AUTH, "interface queue", "set ifqueue packets", (const void *)VAR_IFQUEUE}, {"ipcpretry", "ipcpretries", SetVariable, LOCAL_AUTH, "IPCP retries", "set ipcpretry value [attempts]", (const void *)VAR_IPCPRETRY}, {"ipv6cpretry", "ipv6cpretries", SetVariable, LOCAL_AUTH, "IPV6CP retries", "set ipv6cpretry value [attempts]", (const void *)VAR_IPV6CPRETRY}, {"lcpretry", "lcpretries", SetVariable, LOCAL_AUTH | LOCAL_CX, "LCP retries", "set lcpretry value [attempts]", (const void *)VAR_LCPRETRY}, {"log", NULL, log_SetLevel, LOCAL_AUTH, "log level", "set log [local] [+|-]all|async|cbcp|ccp|chat|command|connect|debug|dns|hdlc|" "id0|ipcp|lcp|lqm|phase|physical|radius|sync|tcp/ip|timer|tun...", NULL}, {"login", NULL, SetVariable, LOCAL_AUTH | LOCAL_CX, "login script", "set login chat-script", (const void *) VAR_LOGIN}, {"logout", NULL, SetVariable, LOCAL_AUTH | LOCAL_CX, "logout script", "set logout chat-script", (const void *) VAR_LOGOUT}, {"lqrperiod", "echoperiod", SetVariable, LOCAL_AUTH | LOCAL_CX_OPT, "LQR period", "set lqr/echo period value", (const void *)VAR_LQRPERIOD}, {"mode", NULL, SetVariable, LOCAL_AUTH | LOCAL_CX, "mode value", "set mode interactive|auto|ddial|background", (const void *)VAR_MODE}, {"mrru", NULL, SetVariable, LOCAL_AUTH, "MRRU value", "set mrru value", (const void *)VAR_MRRU}, {"mru", NULL, SetVariable, LOCAL_AUTH | LOCAL_CX, "MRU value", "set mru [max[imum]] [value]", (const void *)VAR_MRU}, {"mtu", NULL, SetVariable, LOCAL_AUTH | LOCAL_CX, "interface MTU value", "set mtu [max[imum]] [value]", (const void *)VAR_MTU}, {"nbns", NULL, SetVariable, LOCAL_AUTH, "NetBIOS Name Server", "set nbns pri-addr [sec-addr]", (const void *)VAR_NBNS}, {"openmode", NULL, SetVariable, LOCAL_AUTH | LOCAL_CX, "open mode", "set openmode active|passive [secs]", (const void *)VAR_OPENMODE}, {"papretry", "papretries", SetVariable, LOCAL_AUTH | LOCAL_CX, "PAP retries", "set papretry value [attempts]", (const void *)VAR_PAPRETRY}, {"parity", NULL, SetVariable, LOCAL_AUTH | LOCAL_CX, "serial parity", "set parity [odd|even|none]", (const void *)VAR_PARITY}, {"phone", NULL, SetVariable, LOCAL_AUTH | LOCAL_CX, "telephone number(s)", "set phone phone1[:phone2[...]]", (const void *)VAR_PHONE}, {"proctitle", "title", SetProcTitle, LOCAL_AUTH, "Process title", "set proctitle [value]", NULL}, #ifndef NORADIUS {"radius", NULL, SetVariable, LOCAL_AUTH, "RADIUS Config", "set radius cfgfile", (const void *)VAR_RADIUS}, {"rad_alive", NULL, SetVariable, LOCAL_AUTH, "Raduis alive interval", "set rad_alive value", (const void *)VAR_RAD_ALIVE}, {"rad_port_id", NULL, SetVariable, LOCAL_AUTH, "NAS-Port-Id", "set rad_port_id [default|pid|ifnum|tunnum]", (const void *)VAR_PORT_ID}, #endif {"reconnect", NULL, datalink_SetReconnect, LOCAL_AUTH | LOCAL_CX, "Reconnect timeout", "set reconnect value ntries", NULL}, {"recvpipe", NULL, SetVariable, LOCAL_AUTH, "RECVPIPE value", "set recvpipe value", (const void *)VAR_RECVPIPE}, {"redial", NULL, datalink_SetRedial, LOCAL_AUTH | LOCAL_CX, "Redial timeout", "set redial secs[+inc[-incmax]][.next] [attempts]", NULL}, {"sendpipe", NULL, SetVariable, LOCAL_AUTH, "SENDPIPE value", "set sendpipe value", (const void *)VAR_SENDPIPE}, {"server", "socket", SetServer, LOCAL_AUTH, "diagnostic port", "set server|socket TcpPort|LocalName|none|open|closed [password [mask]]", NULL}, {"speed", NULL, SetModemSpeed, LOCAL_AUTH | LOCAL_CX, "physical speed", "set speed value|sync", NULL}, {"stopped", NULL, SetStoppedTimeout, LOCAL_AUTH | LOCAL_CX, "STOPPED timeouts", "set stopped [LCPseconds [CCPseconds]]", NULL}, {"timeout", NULL, SetVariable, LOCAL_AUTH, "Idle timeout", "set timeout idletime", (const void *)VAR_IDLETIMEOUT}, {"urgent", NULL, SetVariable, LOCAL_AUTH, "urgent ports", "set urgent [tcp|udp] [+|-]port...", (const void *)VAR_URGENTPORTS}, {"vj", NULL, ipcp_vjset, LOCAL_AUTH, "vj values", "set vj slots|slotcomp [value]", NULL}, {"help", "?", HelpCommand, LOCAL_AUTH | LOCAL_NO_AUTH, "Display this message", "set help|? [command]", SetCommands}, {"pppoe", NULL, SetVariable, LOCAL_AUTH | LOCAL_CX, "Connect using standard/3Com mode", "set pppoe [standard|3Com]", (const char *)VAR_PPPOE}, {NULL, NULL, NULL, 0, NULL, NULL, NULL}, }; static int SetCommand(struct cmdargs const *arg) { if (arg->argc > arg->argn) FindExec(arg->bundle, SetCommands, arg->argc, arg->argn, arg->argv, arg->prompt, arg->cx); else if (arg->prompt) prompt_Printf(arg->prompt, "Use `set ?' to get a list or `set ? ' for" " syntax help.\n"); else log_Printf(LogWARN, "set command must have arguments\n"); return 0; } static int AddCommand(struct cmdargs const *arg) { struct ncpaddr gw; struct ncprange dest; struct in_addr host; #ifndef NOINET6 struct in6_addr host6; #endif int dest_default, gw_arg, addrs; if (arg->argc != arg->argn+3 && arg->argc != arg->argn+2) return -1; addrs = 0; dest_default = 0; if (arg->argc == arg->argn + 2) { if (!strcasecmp(arg->argv[arg->argn], "default")) dest_default = 1; else { if (!ncprange_aton(&dest, &arg->bundle->ncp, arg->argv[arg->argn])) return -1; if (!strncasecmp(arg->argv[arg->argn], "MYADDR", 6)) addrs = ROUTE_DSTMYADDR; else if (!strncasecmp(arg->argv[arg->argn], "MYADDR6", 7)) addrs = ROUTE_DSTMYADDR6; else if (!strncasecmp(arg->argv[arg->argn], "HISADDR", 7)) addrs = ROUTE_DSTHISADDR; else if (!strncasecmp(arg->argv[arg->argn], "HISADDR6", 8)) addrs = ROUTE_DSTHISADDR6; else if (!strncasecmp(arg->argv[arg->argn], "DNS0", 4)) addrs = ROUTE_DSTDNS0; else if (!strncasecmp(arg->argv[arg->argn], "DNS1", 4)) addrs = ROUTE_DSTDNS1; } gw_arg = 1; } else { if (strcasecmp(arg->argv[arg->argn], "MYADDR") == 0) { addrs = ROUTE_DSTMYADDR; host = arg->bundle->ncp.ipcp.my_ip; } else if (strcasecmp(arg->argv[arg->argn], "HISADDR") == 0) { addrs = ROUTE_DSTHISADDR; host = arg->bundle->ncp.ipcp.peer_ip; } else if (strcasecmp(arg->argv[arg->argn], "DNS0") == 0) { addrs = ROUTE_DSTDNS0; host = arg->bundle->ncp.ipcp.ns.dns[0]; } else if (strcasecmp(arg->argv[arg->argn], "DNS1") == 0) { addrs = ROUTE_DSTDNS1; host = arg->bundle->ncp.ipcp.ns.dns[1]; } else { host = GetIpAddr(arg->argv[arg->argn]); if (host.s_addr == INADDR_NONE) { log_Printf(LogWARN, "%s: Invalid destination address\n", arg->argv[arg->argn]); return -1; } } ncprange_setip4(&dest, host, GetIpAddr(arg->argv[arg->argn + 1])); gw_arg = 2; } if (strcasecmp(arg->argv[arg->argn + gw_arg], "HISADDR") == 0) { ncpaddr_setip4(&gw, arg->bundle->ncp.ipcp.peer_ip); addrs |= ROUTE_GWHISADDR; #ifndef NOINET6 } else if (strcasecmp(arg->argv[arg->argn + gw_arg], "HISADDR6") == 0) { if (!ncpaddr_getip6(&arg->bundle->ncp.ipv6cp.hisaddr, &host6)) memset(&host6, '\0', sizeof host6); ncpaddr_setip6(&gw, &host6); addrs |= ROUTE_GWHISADDR6; #endif } else { if (!ncpaddr_aton(&gw, &arg->bundle->ncp, arg->argv[arg->argn + gw_arg])) { log_Printf(LogWARN, "%s: Invalid gateway address\n", arg->argv[arg->argn + gw_arg]); return -1; } } if (dest_default) ncprange_setdefault(&dest, ncpaddr_family(&gw)); if (rt_Set(arg->bundle, RTM_ADD, &dest, &gw, arg->cmd->args ? 1 : 0, ((addrs & ROUTE_GWHISADDR) || (addrs & ROUTE_GWHISADDR6)) ? 1 : 0) && addrs != ROUTE_STATIC) route_Add(&arg->bundle->ncp.route, addrs, &dest, &gw); return 0; } static int DeleteCommand(struct cmdargs const *arg) { struct ncprange dest; int addrs; if (arg->argc == arg->argn+1) { if(strcasecmp(arg->argv[arg->argn], "all") == 0) { route_IfDelete(arg->bundle, 0); route_DeleteAll(&arg->bundle->ncp.route); } else { addrs = 0; if (strcasecmp(arg->argv[arg->argn], "MYADDR") == 0) { ncprange_setip4host(&dest, arg->bundle->ncp.ipcp.my_ip); addrs = ROUTE_DSTMYADDR; #ifndef NOINET6 } else if (strcasecmp(arg->argv[arg->argn], "MYADDR6") == 0) { ncprange_sethost(&dest, &arg->bundle->ncp.ipv6cp.myaddr); addrs = ROUTE_DSTMYADDR6; #endif } else if (strcasecmp(arg->argv[arg->argn], "HISADDR") == 0) { ncprange_setip4host(&dest, arg->bundle->ncp.ipcp.peer_ip); addrs = ROUTE_DSTHISADDR; #ifndef NOINET6 } else if (strcasecmp(arg->argv[arg->argn], "HISADDR6") == 0) { ncprange_sethost(&dest, &arg->bundle->ncp.ipv6cp.hisaddr); addrs = ROUTE_DSTHISADDR6; #endif } else if (strcasecmp(arg->argv[arg->argn], "DNS0") == 0) { ncprange_setip4host(&dest, arg->bundle->ncp.ipcp.ns.dns[0]); addrs = ROUTE_DSTDNS0; } else if (strcasecmp(arg->argv[arg->argn], "DNS1") == 0) { ncprange_setip4host(&dest, arg->bundle->ncp.ipcp.ns.dns[1]); addrs = ROUTE_DSTDNS1; } else { ncprange_aton(&dest, &arg->bundle->ncp, arg->argv[arg->argn]); addrs = ROUTE_STATIC; } rt_Set(arg->bundle, RTM_DELETE, &dest, NULL, arg->cmd->args ? 1 : 0, 0); route_Delete(&arg->bundle->ncp.route, addrs, &dest); } } else return -1; return 0; } #ifndef NONAT static int NatEnable(struct cmdargs const *arg) { if (arg->argc == arg->argn+1) { if (strcasecmp(arg->argv[arg->argn], "yes") == 0) { if (!arg->bundle->NatEnabled) { if (arg->bundle->ncp.ipcp.fsm.state == ST_OPENED) LibAliasSetAddress(la, arg->bundle->ncp.ipcp.my_ip); arg->bundle->NatEnabled = 1; } return 0; } else if (strcasecmp(arg->argv[arg->argn], "no") == 0) { arg->bundle->NatEnabled = 0; opt_disable(arg->bundle, OPT_IFACEALIAS); /* Don't iface_Clear() - there may be manually configured addresses */ return 0; } } return -1; } static int NatOption(struct cmdargs const *arg) { long param = (long)arg->cmd->args; if (arg->argc == arg->argn+1) { if (strcasecmp(arg->argv[arg->argn], "yes") == 0) { if (arg->bundle->NatEnabled) { LibAliasSetMode(la, param, param); return 0; } log_Printf(LogWARN, "nat not enabled\n"); } else if (strcmp(arg->argv[arg->argn], "no") == 0) { if (arg->bundle->NatEnabled) { LibAliasSetMode(la, 0, param); return 0; } log_Printf(LogWARN, "nat not enabled\n"); } } return -1; } #endif /* #ifndef NONAT */ static int LinkCommand(struct cmdargs const *arg) { if (arg->argc > arg->argn+1) { char namelist[LINE_LEN]; struct datalink *cx; char *name; int result = 0; if (!strcmp(arg->argv[arg->argn], "*")) { struct datalink *dl; cx = arg->bundle->links; while (cx) { /* Watch it, the command could be a ``remove'' */ dl = cx->next; FindExec(arg->bundle, Commands, arg->argc, arg->argn+1, arg->argv, arg->prompt, cx); for (cx = arg->bundle->links; cx; cx = cx->next) if (cx == dl) break; /* Pointer's still valid ! */ } } else { strncpy(namelist, arg->argv[arg->argn], sizeof namelist - 1); namelist[sizeof namelist - 1] = '\0'; for(name = strtok(namelist, ", "); name; name = strtok(NULL,", ")) if (!bundle2datalink(arg->bundle, name)) { log_Printf(LogWARN, "link: %s: Invalid link name\n", name); return 1; } strncpy(namelist, arg->argv[arg->argn], sizeof namelist - 1); namelist[sizeof namelist - 1] = '\0'; for(name = strtok(namelist, ", "); name; name = strtok(NULL,", ")) { cx = bundle2datalink(arg->bundle, name); if (cx) FindExec(arg->bundle, Commands, arg->argc, arg->argn+1, arg->argv, arg->prompt, cx); else { log_Printf(LogWARN, "link: %s: Invalidated link name !\n", name); result++; } } } return result; } log_Printf(LogWARN, "usage: %s\n", arg->cmd->syntax); return 2; } struct link * command_ChooseLink(struct cmdargs const *arg) { if (arg->cx) return &arg->cx->physical->link; else if (!arg->bundle->ncp.mp.cfg.mrru) { struct datalink *dl = bundle2datalink(arg->bundle, NULL); if (dl) return &dl->physical->link; } return &arg->bundle->ncp.mp.link; } static const char * ident_cmd(const char *cmd, unsigned *keep, unsigned *add) { const char *result; switch (*cmd) { case 'A': case 'a': result = "accept"; *keep = NEG_MYMASK; *add = NEG_ACCEPTED; break; case 'D': case 'd': switch (cmd[1]) { case 'E': case 'e': result = "deny"; *keep = NEG_MYMASK; *add = 0; break; case 'I': case 'i': result = "disable"; *keep = NEG_HISMASK; *add = 0; break; default: return NULL; } break; case 'E': case 'e': result = "enable"; *keep = NEG_HISMASK; *add = NEG_ENABLED; break; default: return NULL; } return result; } static int OptSet(struct cmdargs const *arg) { int opt = (int)(long)arg->cmd->args; unsigned keep; /* Keep this opt */ unsigned add; /* Add this opt */ if (ident_cmd(arg->argv[arg->argn - 2], &keep, &add) == NULL) return 1; #ifndef NOINET6 if (add == NEG_ENABLED && opt == OPT_IPV6CP && !probe.ipv6_available) { log_Printf(LogWARN, "IPv6 is not available on this machine\n"); return 1; } #endif if (!add && ((opt == OPT_NAS_IP_ADDRESS && !Enabled(arg->bundle, OPT_NAS_IDENTIFIER)) || (opt == OPT_NAS_IDENTIFIER && !Enabled(arg->bundle, OPT_NAS_IP_ADDRESS)))) { log_Printf(LogWARN, "Cannot disable both NAS-IP-Address and NAS-Identifier\n"); return 1; } if (add) opt_enable(arg->bundle, opt); else opt_disable(arg->bundle, opt); return 0; } static int IfaceAliasOptSet(struct cmdargs const *arg) { unsigned long long save = arg->bundle->cfg.optmask; int result = OptSet(arg); if (result == 0) if (Enabled(arg->bundle, OPT_IFACEALIAS) && !arg->bundle->NatEnabled) { arg->bundle->cfg.optmask = save; log_Printf(LogWARN, "Cannot enable iface-alias without NAT\n"); result = 2; } return result; } static int NegotiateSet(struct cmdargs const *arg) { long param = (long)arg->cmd->args; struct link *l = command_ChooseLink(arg); /* LOCAL_CX_OPT uses this */ struct datalink *cx = arg->cx; /* LOCAL_CX uses this */ const char *cmd; unsigned keep; /* Keep these bits */ unsigned add; /* Add these bits */ if ((cmd = ident_cmd(arg->argv[arg->argn-2], &keep, &add)) == NULL) return 1; if ((arg->cmd->lauth & LOCAL_CX) && !cx) { log_Printf(LogWARN, "%s %s: No context (use the `link' command)\n", cmd, arg->cmd->name); return 2; } else if (cx && !(arg->cmd->lauth & (LOCAL_CX|LOCAL_CX_OPT))) { log_Printf(LogWARN, "%s %s: Redundant context (%s) ignored\n", cmd, arg->cmd->name, cx->name); cx = NULL; } switch (param) { case NEG_ACFCOMP: cx->physical->link.lcp.cfg.acfcomp &= keep; cx->physical->link.lcp.cfg.acfcomp |= add; break; case NEG_CHAP05: cx->physical->link.lcp.cfg.chap05 &= keep; cx->physical->link.lcp.cfg.chap05 |= add; break; #ifndef NODES case NEG_CHAP80: cx->physical->link.lcp.cfg.chap80nt &= keep; cx->physical->link.lcp.cfg.chap80nt |= add; break; case NEG_CHAP80LM: cx->physical->link.lcp.cfg.chap80lm &= keep; cx->physical->link.lcp.cfg.chap80lm |= add; break; case NEG_CHAP81: cx->physical->link.lcp.cfg.chap81 &= keep; cx->physical->link.lcp.cfg.chap81 |= add; break; case NEG_MPPE: l->ccp.cfg.neg[CCP_NEG_MPPE] &= keep; l->ccp.cfg.neg[CCP_NEG_MPPE] |= add; break; #endif case NEG_DEFLATE: l->ccp.cfg.neg[CCP_NEG_DEFLATE] &= keep; l->ccp.cfg.neg[CCP_NEG_DEFLATE] |= add; break; case NEG_DNS: arg->bundle->ncp.ipcp.cfg.ns.dns_neg &= keep; arg->bundle->ncp.ipcp.cfg.ns.dns_neg |= add; break; case NEG_ECHO: /* probably misplaced in this function ! */ if (cx->physical->link.lcp.cfg.echo && !add) { cx->physical->link.lcp.cfg.echo = 0; cx->physical->hdlc.lqm.method &= ~LQM_ECHO; if (cx->physical->hdlc.lqm.method & LQM_ECHO && !cx->physical->link.lcp.want_lqrperiod && cx->physical->hdlc.lqm.timer.load) { cx->physical->hdlc.lqm.timer.load = 0; lqr_StopTimer(cx->physical); } } else if (!cx->physical->link.lcp.cfg.echo && add) { cx->physical->link.lcp.cfg.echo = 1; cx->physical->hdlc.lqm.method |= LQM_ECHO; cx->physical->hdlc.lqm.timer.load = cx->physical->link.lcp.cfg.lqrperiod * SECTICKS; if (cx->physical->link.lcp.fsm.state == ST_OPENED) (*cx->physical->hdlc.lqm.timer.func)(&cx->physical->link.lcp); } break; case NEG_ENDDISC: arg->bundle->ncp.mp.cfg.negenddisc &= keep; arg->bundle->ncp.mp.cfg.negenddisc |= add; break; case NEG_LQR: cx->physical->link.lcp.cfg.lqr &= keep; cx->physical->link.lcp.cfg.lqr |= add; break; case NEG_PAP: cx->physical->link.lcp.cfg.pap &= keep; cx->physical->link.lcp.cfg.pap |= add; break; case NEG_PPPDDEFLATE: l->ccp.cfg.neg[CCP_NEG_DEFLATE24] &= keep; l->ccp.cfg.neg[CCP_NEG_DEFLATE24] |= add; break; case NEG_PRED1: l->ccp.cfg.neg[CCP_NEG_PRED1] &= keep; l->ccp.cfg.neg[CCP_NEG_PRED1] |= add; break; case NEG_PROTOCOMP: cx->physical->link.lcp.cfg.protocomp &= keep; cx->physical->link.lcp.cfg.protocomp |= add; break; case NEG_SHORTSEQ: switch (bundle_Phase(arg->bundle)) { case PHASE_DEAD: break; case PHASE_ESTABLISH: /* Make sure none of our links are DATALINK_LCP or greater */ if (bundle_HighestState(arg->bundle) >= DATALINK_LCP) { log_Printf(LogWARN, "shortseq: Only changable before" " LCP negotiations\n"); return 1; } break; default: log_Printf(LogWARN, "shortseq: Only changable at phase" " DEAD/ESTABLISH\n"); return 1; } arg->bundle->ncp.mp.cfg.shortseq &= keep; arg->bundle->ncp.mp.cfg.shortseq |= add; break; case NEG_VJCOMP: arg->bundle->ncp.ipcp.cfg.vj.neg &= keep; arg->bundle->ncp.ipcp.cfg.vj.neg |= add; break; } return 0; } static struct cmdtab const NegotiateCommands[] = { {"echo", NULL, NegotiateSet, LOCAL_AUTH | LOCAL_CX, "Send echo requests", "disable|enable", (const void *)NEG_ECHO}, {"filter-decapsulation", NULL, OptSet, LOCAL_AUTH, "filter on PPPoUDP payloads", "disable|enable", (const void *)OPT_FILTERDECAP}, {"force-scripts", NULL, OptSet, LOCAL_AUTH, "Force execution of the configured chat scripts", "disable|enable", (const void *)OPT_FORCE_SCRIPTS}, {"idcheck", NULL, OptSet, LOCAL_AUTH, "Check FSM reply ids", "disable|enable", (const void *)OPT_IDCHECK}, {"iface-alias", NULL, IfaceAliasOptSet, LOCAL_AUTH, "retain interface addresses", "disable|enable", (const void *)OPT_IFACEALIAS}, #ifndef NOINET6 {"ipcp", NULL, OptSet, LOCAL_AUTH, "IP Network Control Protocol", "disable|enable", (const void *)OPT_IPCP}, {"ipv6cp", NULL, OptSet, LOCAL_AUTH, "IPv6 Network Control Protocol", "disable|enable", (const void *)OPT_IPV6CP}, #endif {"keep-session", NULL, OptSet, LOCAL_AUTH, "Retain device session leader", "disable|enable", (const void *)OPT_KEEPSESSION}, {"loopback", NULL, OptSet, LOCAL_AUTH, "Loop packets for local iface", "disable|enable", (const void *)OPT_LOOPBACK}, {"nas-ip-address", NULL, OptSet, LOCAL_AUTH, "Send NAS-IP-Address to RADIUS", "disable|enable", (const void *)OPT_NAS_IP_ADDRESS}, {"nas-identifier", NULL, OptSet, LOCAL_AUTH, "Send NAS-Identifier to RADIUS", "disable|enable", (const void *)OPT_NAS_IDENTIFIER}, {"passwdauth", NULL, OptSet, LOCAL_AUTH, "Use passwd file", "disable|enable", (const void *)OPT_PASSWDAUTH}, {"proxy", NULL, OptSet, LOCAL_AUTH, "Create a proxy ARP entry", "disable|enable", (const void *)OPT_PROXY}, {"proxyall", NULL, OptSet, LOCAL_AUTH, "Proxy ARP for all remote hosts", "disable|enable", (const void *)OPT_PROXYALL}, {"sroutes", NULL, OptSet, LOCAL_AUTH, "Use sticky routes", "disable|enable", (const void *)OPT_SROUTES}, {"tcpmssfixup", "mssfixup", OptSet, LOCAL_AUTH, "Modify MSS options", "disable|enable", (const void *)OPT_TCPMSSFIXUP}, {"throughput", NULL, OptSet, LOCAL_AUTH, "Rolling throughput", "disable|enable", (const void *)OPT_THROUGHPUT}, {"utmp", NULL, OptSet, LOCAL_AUTH, "Log connections in utmp", "disable|enable", (const void *)OPT_UTMP}, #ifndef NOINET6 #define NEG_OPT_MAX 17 /* accept/deny allowed below and not above */ #else #define NEG_OPT_MAX 15 #endif {"acfcomp", NULL, NegotiateSet, LOCAL_AUTH | LOCAL_CX, "Address & Control field compression", "accept|deny|disable|enable", (const void *)NEG_ACFCOMP}, {"chap", "chap05", NegotiateSet, LOCAL_AUTH | LOCAL_CX, "Challenge Handshake Authentication Protocol", "accept|deny|disable|enable", (const void *)NEG_CHAP05}, #ifndef NODES {"mschap", "chap80nt", NegotiateSet, LOCAL_AUTH | LOCAL_CX, "Microsoft (NT) CHAP", "accept|deny|disable|enable", (const void *)NEG_CHAP80}, {"LANMan", "chap80lm", NegotiateSet, LOCAL_AUTH | LOCAL_CX, "Microsoft (NT) CHAP", "accept|deny|disable|enable", (const void *)NEG_CHAP80LM}, {"mschapv2", "chap81", NegotiateSet, LOCAL_AUTH | LOCAL_CX, "Microsoft CHAP v2", "accept|deny|disable|enable", (const void *)NEG_CHAP81}, {"mppe", NULL, NegotiateSet, LOCAL_AUTH | LOCAL_CX_OPT, "MPPE encryption", "accept|deny|disable|enable", (const void *)NEG_MPPE}, #endif {"deflate", NULL, NegotiateSet, LOCAL_AUTH | LOCAL_CX_OPT, "Deflate compression", "accept|deny|disable|enable", (const void *)NEG_DEFLATE}, {"deflate24", NULL, NegotiateSet, LOCAL_AUTH | LOCAL_CX_OPT, "Deflate (type 24) compression", "accept|deny|disable|enable", (const void *)NEG_PPPDDEFLATE}, {"dns", NULL, NegotiateSet, LOCAL_AUTH, "DNS specification", "accept|deny|disable|enable", (const void *)NEG_DNS}, {"enddisc", NULL, NegotiateSet, LOCAL_AUTH, "ENDDISC negotiation", "accept|deny|disable|enable", (const void *)NEG_ENDDISC}, {"lqr", NULL, NegotiateSet, LOCAL_AUTH | LOCAL_CX, "Link Quality Reports", "accept|deny|disable|enable", (const void *)NEG_LQR}, {"pap", NULL, NegotiateSet, LOCAL_AUTH | LOCAL_CX, "Password Authentication protocol", "accept|deny|disable|enable", (const void *)NEG_PAP}, {"pred1", "predictor1", NegotiateSet, LOCAL_AUTH | LOCAL_CX_OPT, "Predictor 1 compression", "accept|deny|disable|enable", (const void *)NEG_PRED1}, {"protocomp", NULL, NegotiateSet, LOCAL_AUTH | LOCAL_CX, "Protocol field compression", "accept|deny|disable|enable", (const void *)NEG_PROTOCOMP}, {"shortseq", NULL, NegotiateSet, LOCAL_AUTH, "MP Short Sequence Numbers", "accept|deny|disable|enable", (const void *)NEG_SHORTSEQ}, {"vjcomp", NULL, NegotiateSet, LOCAL_AUTH, "Van Jacobson header compression", "accept|deny|disable|enable", (const void *)NEG_VJCOMP}, {"help", "?", HelpCommand, LOCAL_AUTH | LOCAL_NO_AUTH, "Display this message", "accept|deny|disable|enable help|? [value]", NegotiateCommands}, {NULL, NULL, NULL, 0, NULL, NULL, NULL}, }; static int NegotiateCommand(struct cmdargs const *arg) { if (arg->argc > arg->argn) { char const *argv[3]; unsigned keep, add; int n; if ((argv[0] = ident_cmd(arg->argv[arg->argn-1], &keep, &add)) == NULL) return -1; argv[2] = NULL; for (n = arg->argn; n < arg->argc; n++) { argv[1] = arg->argv[n]; FindExec(arg->bundle, NegotiateCommands + (keep == NEG_HISMASK ? 0 : NEG_OPT_MAX), 2, 1, argv, arg->prompt, arg->cx); } } else if (arg->prompt) prompt_Printf(arg->prompt, "Use `%s ?' to get a list.\n", arg->argv[arg->argn-1]); else log_Printf(LogWARN, "%s command must have arguments\n", arg->argv[arg->argn] ); return 0; } const char * command_ShowNegval(unsigned val) { switch (val&3) { case 1: return "disabled & accepted"; case 2: return "enabled & denied"; case 3: return "enabled & accepted"; } return "disabled & denied"; } static int ClearCommand(struct cmdargs const *arg) { struct pppThroughput *t; struct datalink *cx; int i, clear_type; if (arg->argc < arg->argn + 1) return -1; if (strcasecmp(arg->argv[arg->argn], "physical") == 0) { cx = arg->cx; if (!cx) cx = bundle2datalink(arg->bundle, NULL); if (!cx) { log_Printf(LogWARN, "A link must be specified for ``clear physical''\n"); return 1; } t = &cx->physical->link.stats.total; } else if (strcasecmp(arg->argv[arg->argn], "ipcp") == 0) t = &arg->bundle->ncp.ipcp.throughput; #ifndef NOINET6 else if (strcasecmp(arg->argv[arg->argn], "ipv6cp") == 0) t = &arg->bundle->ncp.ipv6cp.throughput; #endif else return -1; if (arg->argc > arg->argn + 1) { clear_type = 0; for (i = arg->argn + 1; i < arg->argc; i++) if (strcasecmp(arg->argv[i], "overall") == 0) clear_type |= THROUGHPUT_OVERALL; else if (strcasecmp(arg->argv[i], "current") == 0) clear_type |= THROUGHPUT_CURRENT; else if (strcasecmp(arg->argv[i], "peak") == 0) clear_type |= THROUGHPUT_PEAK; else return -1; } else clear_type = THROUGHPUT_ALL; throughput_clear(t, clear_type, arg->prompt); return 0; } static int RunListCommand(struct cmdargs const *arg) { const char *cmd = arg->argc ? arg->argv[arg->argc - 1] : "???"; #ifndef NONAT if (arg->cmd->args == NatCommands && tolower(*arg->argv[arg->argn - 1]) == 'a') { if (arg->prompt) prompt_Printf(arg->prompt, "The alias command is deprecated\n"); else log_Printf(LogWARN, "The alias command is deprecated\n"); } #endif if (arg->argc > arg->argn) FindExec(arg->bundle, arg->cmd->args, arg->argc, arg->argn, arg->argv, arg->prompt, arg->cx); else if (arg->prompt) prompt_Printf(arg->prompt, "Use `%s help' to get a list or `%s help" "