command.c revision 31080
16059Samurai/* 26059Samurai * PPP User command processing module 36059Samurai * 46059Samurai * Written by Toshiharu OHNO (tony-o@iij.ad.jp) 56059Samurai * 66059Samurai * Copyright (C) 1993, Internet Initiative Japan, Inc. All rights reserverd. 76059Samurai * 86059Samurai * Redistribution and use in source and binary forms are permitted 96059Samurai * provided that the above copyright notice and this paragraph are 106059Samurai * duplicated in all such forms and that any documentation, 116059Samurai * advertising materials, and other materials related to such 126059Samurai * distribution and use acknowledge that the software was developed 136059Samurai * by the Internet Initiative Japan, Inc. The name of the 146059Samurai * IIJ may not be used to endorse or promote products derived 156059Samurai * from this software without specific prior written permission. 166059Samurai * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR 176059Samurai * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED 186059Samurai * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. 198857Srgrimes * 2031080Sbrian * $Id: command.c,v 1.93 1997/11/09 17:51:24 brian Exp $ 218857Srgrimes * 226059Samurai */ 2330715Sbrian#include <sys/param.h> 2430715Sbrian#include <netinet/in_systm.h> 2526031Sbrian#include <netinet/in.h> 2630715Sbrian#include <netinet/ip.h> 2726031Sbrian#include <arpa/inet.h> 2830715Sbrian#include <sys/socket.h> 2926031Sbrian#include <net/route.h> 3030715Sbrian#include <netdb.h> 3130715Sbrian 3226031Sbrian#include <alias.h> 3330715Sbrian#include <ctype.h> 3430715Sbrian#include <errno.h> 3526516Sbrian#include <fcntl.h> 3630715Sbrian#include <paths.h> 3730715Sbrian#include <stdio.h> 3830715Sbrian#include <stdlib.h> 3930715Sbrian#include <string.h> 4030715Sbrian#include <sys/stat.h> 4130715Sbrian#include <sys/wait.h> 4230715Sbrian#include <termios.h> 4330715Sbrian#include <time.h> 4430715Sbrian#include <unistd.h> 4530715Sbrian 4630715Sbrian#include "mbuf.h" 4730715Sbrian#include "log.h" 4830715Sbrian#include "defs.h" 4930715Sbrian#include "timer.h" 506059Samurai#include "fsm.h" 516059Samurai#include "phase.h" 526059Samurai#include "lcp.h" 536059Samurai#include "ipcp.h" 546059Samurai#include "modem.h" 5530715Sbrian#include "command.h" 5613389Sphk#include "filter.h" 5726031Sbrian#include "alias_cmd.h" 586059Samurai#include "hdlc.h" 5926142Sbrian#include "loadalias.h" 606059Samurai#include "vars.h" 6125630Sbrian#include "systems.h" 6225630Sbrian#include "chat.h" 636059Samurai#include "os.h" 6426940Sbrian#include "server.h" 6530715Sbrian#include "main.h" 6630715Sbrian#include "route.h" 6730715Sbrian#include "ccp.h" 6830733Sbrian#include "ip.h" 6930715Sbrian#include "slcompress.h" 7031080Sbrian#include "auth.h" 716059Samurai 726059Samuraistruct in_addr ifnetmask; 736059Samurai 7428679Sbrianstatic int ShowCommand(struct cmdtab const *, int, char **); 7528679Sbrianstatic int TerminalCommand(struct cmdtab const *, int, char **); 7628679Sbrianstatic int QuitCommand(struct cmdtab const *, int, char **); 7728679Sbrianstatic int CloseCommand(struct cmdtab const *, int, char **); 7828679Sbrianstatic int DialCommand(struct cmdtab const *, int, char **); 7928679Sbrianstatic int DownCommand(struct cmdtab const *, int, char **); 8028679Sbrianstatic int SetCommand(struct cmdtab const *, int, char **); 8128679Sbrianstatic int AddCommand(struct cmdtab const *, int, char **); 8228679Sbrianstatic int DeleteCommand(struct cmdtab const *, int, char **); 8328679Sbrianstatic int BgShellCommand(struct cmdtab const *, int, char **); 8428679Sbrianstatic int FgShellCommand(struct cmdtab const *, int, char **); 8528679Sbrianstatic int ShellCommand(struct cmdtab const *, int, char **, int); 8630715Sbrianstatic int AliasCommand(struct cmdtab const *, int, char **); 8730715Sbrianstatic int AliasEnable(struct cmdtab const *, int, char **); 8830715Sbrianstatic int AliasOption(struct cmdtab const *, int, char **, void *); 896059Samurai 906059Samuraistatic int 9128679SbrianHelpCommand(struct cmdtab const * list, 9228679Sbrian int argc, 9328679Sbrian char **argv, 9428679Sbrian struct cmdtab const * plist) 956059Samurai{ 9628679Sbrian struct cmdtab const *cmd; 976059Samurai int n; 986059Samurai 9926516Sbrian if (!VarTerm) 10026516Sbrian return 0; 10126516Sbrian 1026059Samurai if (argc > 0) { 10326516Sbrian for (cmd = plist; cmd->name; cmd++) 10425566Sbrian if (strcasecmp(cmd->name, *argv) == 0 && (cmd->lauth & VarLocalAuth)) { 10528679Sbrian fprintf(VarTerm, "%s\n", cmd->syntax); 10628679Sbrian return 0; 1076059Samurai } 10826516Sbrian return -1; 1096059Samurai } 1106059Samurai n = 0; 11126516Sbrian for (cmd = plist; cmd->func; cmd++) 1126764Samurai if (cmd->name && (cmd->lauth & VarLocalAuth)) { 11326587Sbrian fprintf(VarTerm, " %-9s: %-20s\n", cmd->name, cmd->helpmes); 1146059Samurai n++; 1156059Samurai } 1166059Samurai if (n & 1) 11726516Sbrian fprintf(VarTerm, "\n"); 11826516Sbrian 11926516Sbrian return 0; 1206059Samurai} 1216059Samurai 1226059Samuraiint 12330913SbrianIsInteractive(int Display) 1246059Samurai{ 1256059Samurai char *mes = NULL; 1266059Samurai 12720120Snate if (mode & MODE_DDIAL) 12820120Snate mes = "Working in dedicated dial mode."; 12925908Sbrian else if (mode & MODE_BACKGROUND) 13025908Sbrian mes = "Working in background mode."; 13120120Snate else if (mode & MODE_AUTO) 13210528Samurai mes = "Working in auto mode."; 1336059Samurai else if (mode & MODE_DIRECT) 13410528Samurai mes = "Working in direct mode."; 1356059Samurai else if (mode & MODE_DEDICATED) 13610528Samurai mes = "Working in dedicated mode."; 1376059Samurai if (mes) { 13830913Sbrian if (Display && VarTerm) 13926516Sbrian fprintf(VarTerm, "%s\n", mes); 14026516Sbrian return 0; 1416059Samurai } 14226516Sbrian return 1; 1436059Samurai} 1446059Samurai 1456059Samuraistatic int 14628679SbrianDialCommand(struct cmdtab const * cmdlist, int argc, char **argv) 1476059Samurai{ 14811336Samurai int tries; 14926858Sbrian int res; 15011336Samurai 1516059Samurai if (LcpFsm.state > ST_CLOSED) { 15226516Sbrian if (VarTerm) 15326516Sbrian fprintf(VarTerm, "LCP state is [%s]\n", StateNames[LcpFsm.state]); 15426516Sbrian return 0; 1556059Samurai } 15626516Sbrian 1576735Samurai if (argc > 0) { 1586735Samurai if (SelectSystem(*argv, CONFFILE) < 0) { 15926516Sbrian if (VarTerm) 16028679Sbrian fprintf(VarTerm, "%s: not found.\n", *argv); 16126516Sbrian return -1; 1626735Samurai } 1636735Samurai } 16411336Samurai tries = 0; 16511336Samurai do { 16626516Sbrian if (VarTerm) 16726516Sbrian fprintf(VarTerm, "Dial attempt %u of %d\n", ++tries, VarDialTries); 16831034Sbrian if (OpenModem() < 0) { 16926516Sbrian if (VarTerm) 17028679Sbrian fprintf(VarTerm, "Failed to open modem.\n"); 17111336Samurai break; 17211336Samurai } 17326858Sbrian if ((res = DialModem()) == EX_DONE) { 17430697Sbrian nointr_sleep(1); 17511336Samurai ModemTimeout(); 17611336Samurai PacketMode(); 17711336Samurai break; 17826858Sbrian } else if (res == EX_SIG) 17926858Sbrian return 1; 18011336Samurai } while (VarDialTries == 0 || tries < VarDialTries); 18126516Sbrian 18226516Sbrian return 0; 1836059Samurai} 1846059Samurai 18510528Samuraistatic int 18628679SbrianSetLoopback(struct cmdtab const * cmdlist, int argc, char **argv) 18728536Sbrian{ 18828536Sbrian if (argc == 1) 18928536Sbrian if (!strcasecmp(*argv, "on")) 19028536Sbrian VarLoopback = 1; 19128536Sbrian else if (!strcasecmp(*argv, "off")) 19228536Sbrian VarLoopback = 0; 19328536Sbrian return -1; 19428536Sbrian} 19528536Sbrian 19628536Sbrianstatic int 19728679SbrianBgShellCommand(struct cmdtab const * cmdlist, int argc, char **argv) 19810528Samurai{ 19928381Sbrian if (argc == 0) 20028381Sbrian return -1; 20128381Sbrian return ShellCommand(cmdlist, argc, argv, 1); 20228381Sbrian} 20328381Sbrian 20428381Sbrianstatic int 20528679SbrianFgShellCommand(struct cmdtab const * cmdlist, int argc, char **argv) 20628381Sbrian{ 20728381Sbrian return ShellCommand(cmdlist, argc, argv, 0); 20828381Sbrian} 20928381Sbrian 21028381Sbrianstatic int 21128679SbrianShellCommand(struct cmdtab const * cmdlist, int argc, char **argv, int bg) 21228381Sbrian{ 21310528Samurai const char *shell; 21410528Samurai pid_t shpid; 21526516Sbrian FILE *oVarTerm; 21620813Sjkh 21718856Ssos#ifdef SHELL_ONLY_INTERACTIVELY 21826911Sbrian /* we're only allowed to shell when we run ppp interactively */ 21926516Sbrian if (mode != MODE_INTER) { 22026516Sbrian LogPrintf(LogWARN, "Can only start a shell in interactive mode\n"); 22126516Sbrian return 1; 22210528Samurai } 22326911Sbrian#endif 22426911Sbrian#ifdef NO_SHELL_IN_AUTO_INTERACTIVE 22528679Sbrian 22626911Sbrian /* 22728679Sbrian * we want to stop shell commands when we've got a telnet connection to an 22828679Sbrian * auto mode ppp 22926911Sbrian */ 23028679Sbrian if ((mode & (MODE_AUTO | MODE_INTER)) == (MODE_AUTO | MODE_INTER)) { 23128679Sbrian LogPrintf(LogWARN, "Shell is not allowed interactively in auto mode\n"); 23226516Sbrian return 1; 23326516Sbrian } 23426516Sbrian#endif 23526516Sbrian 23628679Sbrian if (argc == 0) 23728381Sbrian if (!(mode & MODE_INTER)) { 23828381Sbrian LogPrintf(LogWARN, "Can only start an interactive shell in" 23928679Sbrian " interactive mode\n"); 24028381Sbrian return 1; 24128381Sbrian } else if (bg) { 24228381Sbrian LogPrintf(LogWARN, "Can only start an interactive shell in" 24328679Sbrian " the foreground mode\n"); 24428381Sbrian return 1; 24529255Sbrian } else if (mode&(MODE_AUTO|MODE_DEDICATED|MODE_DIRECT)) { 24629255Sbrian LogPrintf(LogWARN, "Can't start an interactive shell from" 24729255Sbrian " a telnet session\n"); 24829255Sbrian return 1; 24928381Sbrian } 25028679Sbrian if ((shell = getenv("SHELL")) == 0) 25126516Sbrian shell = _PATH_BSHELL; 25226516Sbrian 25328679Sbrian if ((shpid = fork()) == 0) { 25428679Sbrian int dtablesize, i, fd; 25518531Sbde 25628679Sbrian if (VarTerm) 25728679Sbrian fd = fileno(VarTerm); 25828679Sbrian else if ((fd = open("/dev/null", O_RDWR)) == -1) { 25928679Sbrian LogPrintf(LogALERT, "Failed to open /dev/null: %s\n", strerror(errno)); 26028679Sbrian exit(1); 26128679Sbrian } 26228679Sbrian for (i = 0; i < 3; i++) 26328679Sbrian dup2(fd, i); 26426516Sbrian 26528679Sbrian if (fd > 2) 26628679Sbrian if (VarTerm) { 26728679Sbrian oVarTerm = VarTerm; 26828679Sbrian VarTerm = 0; 26928679Sbrian if (oVarTerm && oVarTerm != stdout) 27028679Sbrian fclose(oVarTerm); 27128679Sbrian } else 27228679Sbrian close(fd); 27326516Sbrian 27428679Sbrian for (dtablesize = getdtablesize(), i = 3; i < dtablesize; i++) 27528679Sbrian (void) close(i); 27626516Sbrian 27728679Sbrian TtyOldMode(); 27831061Sbrian setuid(geteuid()); 27928679Sbrian if (argc > 0) { 28028679Sbrian /* substitute pseudo args */ 28128679Sbrian for (i = 1; i < argc; i++) 28228679Sbrian if (strcasecmp(argv[i], "HISADDR") == 0) 28328679Sbrian argv[i] = strdup(inet_ntoa(IpcpInfo.his_ipaddr)); 28428679Sbrian else if (strcasecmp(argv[i], "INTERFACE") == 0) 28528679Sbrian argv[i] = strdup(IfDevName); 28628679Sbrian else if (strcasecmp(argv[i], "MYADDR") == 0) 28728679Sbrian argv[i] = strdup(inet_ntoa(IpcpInfo.want_ipaddr)); 28828679Sbrian if (bg) { 28928679Sbrian pid_t p; 29010528Samurai 29128679Sbrian p = getpid(); 29228679Sbrian if (daemon(1, 1) == -1) { 29328974Sbrian LogPrintf(LogERROR, "%d: daemon: %s\n", p, strerror(errno)); 29428679Sbrian exit(1); 29528679Sbrian } 29628679Sbrian } 29730316Sbrian if (VarTerm) 29830316Sbrian fprintf(VarTerm, "ppp: Pausing until %s finishes\n", argv[0]); 29928679Sbrian (void) execvp(argv[0], argv); 30030316Sbrian } else { 30130316Sbrian if (VarTerm) 30230316Sbrian fprintf(VarTerm, "ppp: Pausing until %s finishes\n", shell); 30328679Sbrian (void) execl(shell, shell, NULL); 30430316Sbrian } 30520813Sjkh 30628679Sbrian LogPrintf(LogWARN, "exec() of %s failed\n", argc > 0 ? argv[0] : shell); 30728679Sbrian exit(255); 30810528Samurai } 30928679Sbrian if (shpid == (pid_t) - 1) { 31026516Sbrian LogPrintf(LogERROR, "Fork failed: %s\n", strerror(errno)); 31110528Samurai } else { 31210528Samurai int status; 31328679Sbrian 31428679Sbrian (void) waitpid(shpid, &status, 0); 31510528Samurai } 31620813Sjkh 31710528Samurai TtyCommandMode(1); 31820813Sjkh 31928679Sbrian return (0); 32010528Samurai} 32110528Samurai 32230715Sbrianstatic struct cmdtab const Commands[] = { 32328679Sbrian {"accept", NULL, AcceptCommand, LOCAL_AUTH, 32428679Sbrian "accept option request", "accept option .."}, 32528679Sbrian {"add", NULL, AddCommand, LOCAL_AUTH, 32628679Sbrian "add route", "add dest mask gateway"}, 32728679Sbrian {"bg", "!bg", BgShellCommand, LOCAL_AUTH, 32828679Sbrian "Run a command in the background", "[!]bg command"}, 32928679Sbrian {"close", NULL, CloseCommand, LOCAL_AUTH, 33028679Sbrian "Close connection", "close"}, 33128679Sbrian {"delete", NULL, DeleteCommand, LOCAL_AUTH, 33228679Sbrian "delete route", "delete ALL | dest [gateway [mask]]"}, 33328679Sbrian {"deny", NULL, DenyCommand, LOCAL_AUTH, 33428679Sbrian "Deny option request", "deny option .."}, 33528679Sbrian {"dial", "call", DialCommand, LOCAL_AUTH, 33628679Sbrian "Dial and login", "dial|call [remote]"}, 33728679Sbrian {"disable", NULL, DisableCommand, LOCAL_AUTH, 33828679Sbrian "Disable option", "disable option .."}, 33928679Sbrian {"display", NULL, DisplayCommand, LOCAL_AUTH, 34028679Sbrian "Display option configs", "display"}, 34128679Sbrian {"enable", NULL, EnableCommand, LOCAL_AUTH, 34228679Sbrian "Enable option", "enable option .."}, 34328679Sbrian {"passwd", NULL, LocalAuthCommand, LOCAL_NO_AUTH, 34429083Sbrian "Password for manipulation", "passwd LocalPassword"}, 34528679Sbrian {"load", NULL, LoadCommand, LOCAL_AUTH, 34628679Sbrian "Load settings", "load [remote]"}, 34728679Sbrian {"save", NULL, SaveCommand, LOCAL_AUTH, 34828679Sbrian "Save settings", "save"}, 34928679Sbrian {"set", "setup", SetCommand, LOCAL_AUTH, 35028679Sbrian "Set parameters", "set[up] var value"}, 35128679Sbrian {"shell", "!", FgShellCommand, LOCAL_AUTH, 35228679Sbrian "Run a subshell", "shell|! [sh command]"}, 35328679Sbrian {"show", NULL, ShowCommand, LOCAL_AUTH, 35429660Sbrian "Show status and statistics", "show var"}, 35528679Sbrian {"term", NULL, TerminalCommand, LOCAL_AUTH, 35628679Sbrian "Enter to terminal mode", "term"}, 35728679Sbrian {"alias", NULL, AliasCommand, LOCAL_AUTH, 35828679Sbrian "alias control", "alias option [yes|no]"}, 35928679Sbrian {"quit", "bye", QuitCommand, LOCAL_AUTH | LOCAL_NO_AUTH, 36028679Sbrian "Quit PPP program", "quit|bye [all]"}, 36128679Sbrian {"help", "?", HelpCommand, LOCAL_AUTH | LOCAL_NO_AUTH, 36228679Sbrian "Display this message", "help|? [command]", (void *) Commands}, 36328679Sbrian {NULL, "down", DownCommand, LOCAL_AUTH, 36428679Sbrian "Generate down event", "down"}, 36528679Sbrian {NULL, NULL, NULL}, 3666059Samurai}; 3676059Samurai 36828536Sbrianstatic int 36928536SbrianShowLoopback() 37028536Sbrian{ 37128536Sbrian if (VarTerm) 37228536Sbrian fprintf(VarTerm, "Local loopback is %s\n", VarLoopback ? "on" : "off"); 37328536Sbrian 37428536Sbrian return 0; 37528536Sbrian} 37628536Sbrian 37728679Sbrianstatic int 37828679SbrianShowLogLevel() 3796059Samurai{ 3806059Samurai int i; 3816059Samurai 38226516Sbrian if (!VarTerm) 38326516Sbrian return 0; 38430913Sbrian 38530913Sbrian fprintf(VarTerm, "Log: "); 38630913Sbrian for (i = LogMIN; i <= LogMAX; i++) 38730913Sbrian if (LogIsKept(i) & LOG_KEPT_SYSLOG) 38826516Sbrian fprintf(VarTerm, " %s", LogName(i)); 38930913Sbrian 39030913Sbrian fprintf(VarTerm, "\nLocal:"); 39130913Sbrian for (i = LogMIN; i <= LogMAX; i++) 39230913Sbrian if (LogIsKept(i) & LOG_KEPT_LOCAL) 39330913Sbrian fprintf(VarTerm, " %s", LogName(i)); 39430913Sbrian 39526516Sbrian fprintf(VarTerm, "\n"); 39626516Sbrian 39726516Sbrian return 0; 3986059Samurai} 3996059Samurai 40028679Sbrianstatic int 40128679SbrianShowEscape() 4026059Samurai{ 4036059Samurai int code, bit; 4046059Samurai 40526516Sbrian if (!VarTerm) 40626516Sbrian return 0; 4076059Samurai if (EscMap[32]) { 40826516Sbrian for (code = 0; code < 32; code++) 40926516Sbrian if (EscMap[code]) 41028679Sbrian for (bit = 0; bit < 8; bit++) 41128679Sbrian if (EscMap[code] & (1 << bit)) 41228679Sbrian fprintf(VarTerm, " 0x%02x", (code << 3) + bit); 41326516Sbrian fprintf(VarTerm, "\n"); 4146059Samurai } 41531077Sbrian return 0; 4166059Samurai} 4176059Samurai 41828679Sbrianstatic int 41928679SbrianShowTimeout() 4206059Samurai{ 42131077Sbrian if (VarTerm) 42231077Sbrian fprintf(VarTerm, " Idle Timer: %d secs LQR Timer: %d secs" 42331077Sbrian " Retry Timer: %d secs\n", VarIdleTimeout, VarLqrTimeout, 42431077Sbrian VarRetryTimeout); 42531077Sbrian return 0; 4266059Samurai} 4276059Samurai 42828679Sbrianstatic int 42928679SbrianShowStopped() 43028327Sbrian{ 43128327Sbrian if (!VarTerm) 43228327Sbrian return 0; 43328461Sbrian 43428461Sbrian fprintf(VarTerm, " Stopped Timer: LCP: "); 43528461Sbrian if (!LcpFsm.StoppedTimer.load) 43628461Sbrian fprintf(VarTerm, "Disabled"); 43728327Sbrian else 43828461Sbrian fprintf(VarTerm, "%ld secs", LcpFsm.StoppedTimer.load / SECTICKS); 43928461Sbrian 44028461Sbrian fprintf(VarTerm, ", IPCP: "); 44128461Sbrian if (!IpcpFsm.StoppedTimer.load) 44228461Sbrian fprintf(VarTerm, "Disabled"); 44328461Sbrian else 44428461Sbrian fprintf(VarTerm, "%ld secs", IpcpFsm.StoppedTimer.load / SECTICKS); 44528461Sbrian 44628461Sbrian fprintf(VarTerm, ", CCP: "); 44728461Sbrian if (!CcpFsm.StoppedTimer.load) 44828461Sbrian fprintf(VarTerm, "Disabled"); 44928461Sbrian else 45028461Sbrian fprintf(VarTerm, "%ld secs", CcpFsm.StoppedTimer.load / SECTICKS); 45128461Sbrian 45228461Sbrian fprintf(VarTerm, "\n"); 45328461Sbrian 45431077Sbrian return 0; 45528327Sbrian} 45628327Sbrian 45728679Sbrianstatic int 45828679SbrianShowAuthKey() 4596059Samurai{ 46026516Sbrian if (!VarTerm) 46126516Sbrian return 0; 46226516Sbrian fprintf(VarTerm, "AuthName = %s\n", VarAuthName); 46326516Sbrian fprintf(VarTerm, "AuthKey = %s\n", VarAuthKey); 46429840Sbrian#ifdef HAVE_DES 46529840Sbrian fprintf(VarTerm, "Encrypt = %s\n", VarMSChap ? "MSChap" : "MD5" ); 46629840Sbrian#endif 46731077Sbrian return 0; 4686059Samurai} 4696059Samurai 47028679Sbrianstatic int 47128679SbrianShowVersion() 4726059Samurai{ 47331077Sbrian if (VarTerm) 47431077Sbrian fprintf(VarTerm, "%s - %s \n", VarVersion, VarLocalVersion); 47531077Sbrian return 0; 4766059Samurai} 4776059Samurai 47828679Sbrianstatic int 47928679SbrianShowInitialMRU() 48026326Sbrian{ 48131077Sbrian if (VarTerm) 48231077Sbrian fprintf(VarTerm, " Initial MRU: %ld\n", VarMRU); 48331077Sbrian return 0; 48426326Sbrian} 48526326Sbrian 48628679Sbrianstatic int 48728679SbrianShowPreferredMTU() 48826326Sbrian{ 48931077Sbrian if (VarTerm) 49031077Sbrian if (VarPrefMTU) 49131077Sbrian fprintf(VarTerm, " Preferred MTU: %ld\n", VarPrefMTU); 49231077Sbrian else 49331077Sbrian fprintf(VarTerm, " Preferred MTU: unspecified\n"); 49431077Sbrian return 0; 49526326Sbrian} 49626326Sbrian 49728679Sbrianstatic int 49828679SbrianShowReconnect() 49925067Sbrian{ 50031077Sbrian if (VarTerm) 50131077Sbrian fprintf(VarTerm, " Reconnect Timer: %d, %d tries\n", 50231077Sbrian VarReconnectTimer, VarReconnectTries); 50331077Sbrian return 0; 50425067Sbrian} 50525067Sbrian 50628679Sbrianstatic int 50728679SbrianShowRedial() 50811336Samurai{ 50926516Sbrian if (!VarTerm) 51026516Sbrian return 0; 51126516Sbrian fprintf(VarTerm, " Redial Timer: "); 51211336Samurai 51311336Samurai if (VarRedialTimeout >= 0) { 51426516Sbrian fprintf(VarTerm, " %d seconds, ", VarRedialTimeout); 51528679Sbrian } else { 51626516Sbrian fprintf(VarTerm, " Random 0 - %d seconds, ", REDIAL_PERIOD); 51711336Samurai } 51811336Samurai 51926516Sbrian fprintf(VarTerm, " Redial Next Timer: "); 52024939Sbrian 52124939Sbrian if (VarRedialNextTimeout >= 0) { 52226516Sbrian fprintf(VarTerm, " %d seconds, ", VarRedialNextTimeout); 52328679Sbrian } else { 52426516Sbrian fprintf(VarTerm, " Random 0 - %d seconds, ", REDIAL_PERIOD); 52524939Sbrian } 52624939Sbrian 52711336Samurai if (VarDialTries) 52828679Sbrian fprintf(VarTerm, "%d dial tries", VarDialTries); 52911336Samurai 53026516Sbrian fprintf(VarTerm, "\n"); 53111336Samurai 53231077Sbrian return 0; 53311336Samurai} 53411336Samurai 53526516Sbrian#ifndef NOMSEXT 53628679Sbrianstatic int 53728679SbrianShowMSExt() 53818752Sjkh{ 53931077Sbrian if (VarTerm) { 54031077Sbrian fprintf(VarTerm, " MS PPP extention values \n"); 54131077Sbrian fprintf(VarTerm, " Primary NS : %s\n", inet_ntoa(ns_entries[0])); 54231077Sbrian fprintf(VarTerm, " Secondary NS : %s\n", inet_ntoa(ns_entries[1])); 54331077Sbrian fprintf(VarTerm, " Primary NBNS : %s\n", inet_ntoa(nbns_entries[0])); 54431077Sbrian fprintf(VarTerm, " Secondary NBNS : %s\n", inet_ntoa(nbns_entries[1])); 54531077Sbrian } 54631077Sbrian return 0; 54718752Sjkh} 54828679Sbrian 54926516Sbrian#endif 55018752Sjkh 55130715Sbrianstatic struct cmdtab const ShowCommands[] = { 55228679Sbrian {"afilter", NULL, ShowAfilter, LOCAL_AUTH, 55328679Sbrian "Show keep Alive filters", "show afilter option .."}, 55428679Sbrian {"auth", NULL, ShowAuthKey, LOCAL_AUTH, 55529549Sbrian "Show auth name, key and algorithm", "show auth"}, 55628679Sbrian {"ccp", NULL, ReportCcpStatus, LOCAL_AUTH, 55728679Sbrian "Show CCP status", "show cpp"}, 55828679Sbrian {"compress", NULL, ReportCompress, LOCAL_AUTH, 55929660Sbrian "Show compression statistics", "show compress"}, 56028679Sbrian {"dfilter", NULL, ShowDfilter, LOCAL_AUTH, 56128679Sbrian "Show Demand filters", "show dfilteroption .."}, 56228679Sbrian {"escape", NULL, ShowEscape, LOCAL_AUTH, 56328679Sbrian "Show escape characters", "show escape"}, 56428679Sbrian {"hdlc", NULL, ReportHdlcStatus, LOCAL_AUTH, 56528679Sbrian "Show HDLC error summary", "show hdlc"}, 56628679Sbrian {"ifilter", NULL, ShowIfilter, LOCAL_AUTH, 56728679Sbrian "Show Input filters", "show ifilter option .."}, 56828679Sbrian {"ipcp", NULL, ReportIpcpStatus, LOCAL_AUTH, 56928679Sbrian "Show IPCP status", "show ipcp"}, 57028679Sbrian {"lcp", NULL, ReportLcpStatus, LOCAL_AUTH, 57128679Sbrian "Show LCP status", "show lcp"}, 57228679Sbrian {"loopback", NULL, ShowLoopback, LOCAL_AUTH, 57328679Sbrian "Show current loopback setting", "show loopback"}, 57428679Sbrian {"log", NULL, ShowLogLevel, LOCAL_AUTH, 57528679Sbrian "Show current log level", "show log"}, 57628679Sbrian {"mem", NULL, ShowMemMap, LOCAL_AUTH, 57728679Sbrian "Show memory map", "show mem"}, 57828679Sbrian {"modem", NULL, ShowModemStatus, LOCAL_AUTH, 57928679Sbrian "Show modem setups", "show modem"}, 58028679Sbrian {"mru", NULL, ShowInitialMRU, LOCAL_AUTH, 58128679Sbrian "Show Initial MRU", "show mru"}, 58228679Sbrian {"mtu", NULL, ShowPreferredMTU, LOCAL_AUTH, 58328679Sbrian "Show Preferred MTU", "show mtu"}, 58428679Sbrian {"ofilter", NULL, ShowOfilter, LOCAL_AUTH, 58528679Sbrian "Show Output filters", "show ofilter option .."}, 58628679Sbrian {"proto", NULL, ReportProtStatus, LOCAL_AUTH, 58728679Sbrian "Show protocol summary", "show proto"}, 58828679Sbrian {"reconnect", NULL, ShowReconnect, LOCAL_AUTH, 58928679Sbrian "Show Reconnect timer,tries", "show reconnect"}, 59028679Sbrian {"redial", NULL, ShowRedial, LOCAL_AUTH, 59128679Sbrian "Show Redial timeout value", "show redial"}, 59228679Sbrian {"route", NULL, ShowRoute, LOCAL_AUTH, 59328679Sbrian "Show routing table", "show route"}, 59428679Sbrian {"timeout", NULL, ShowTimeout, LOCAL_AUTH, 59528679Sbrian "Show Idle timeout value", "show timeout"}, 59628679Sbrian {"stopped", NULL, ShowStopped, LOCAL_AUTH, 59728679Sbrian "Show STOPPED timeout value", "show stopped"}, 59826516Sbrian#ifndef NOMSEXT 59928679Sbrian {"msext", NULL, ShowMSExt, LOCAL_AUTH, 60028679Sbrian "Show MS PPP extentions", "show msext"}, 60126516Sbrian#endif 60228679Sbrian {"version", NULL, ShowVersion, LOCAL_NO_AUTH | LOCAL_AUTH, 60328679Sbrian "Show version string", "show version"}, 60428679Sbrian {"help", "?", HelpCommand, LOCAL_NO_AUTH | LOCAL_AUTH, 60528679Sbrian "Display this message", "show help|? [command]", (void *) ShowCommands}, 60628679Sbrian {NULL, NULL, NULL}, 6076059Samurai}; 6086059Samurai 60930715Sbrianstatic struct cmdtab const * 61028679SbrianFindCommand(struct cmdtab const * cmds, char *str, int *pmatch) 6116059Samurai{ 61226516Sbrian int nmatch; 61326516Sbrian int len; 61428679Sbrian struct cmdtab const *found; 6156059Samurai 61626516Sbrian found = NULL; 61726516Sbrian len = strlen(str); 61826516Sbrian nmatch = 0; 6196059Samurai while (cmds->func) { 62025566Sbrian if (cmds->name && strncasecmp(str, cmds->name, len) == 0) { 62126516Sbrian if (cmds->name[len] == '\0') { 62228679Sbrian *pmatch = 1; 62328679Sbrian return cmds; 62426516Sbrian } 6256059Samurai nmatch++; 6266059Samurai found = cmds; 62728679Sbrian } else if (cmds->alias && strncasecmp(str, cmds->alias, len) == 0) { 62826516Sbrian if (cmds->alias[len] == '\0') { 62928679Sbrian *pmatch = 1; 63028679Sbrian return cmds; 63126516Sbrian } 6326059Samurai nmatch++; 6336059Samurai found = cmds; 6346059Samurai } 6356059Samurai cmds++; 6366059Samurai } 6376059Samurai *pmatch = nmatch; 63826516Sbrian return found; 6396059Samurai} 6406059Samurai 64130715Sbrianstatic int 64228679SbrianFindExec(struct cmdtab const * cmdlist, int argc, char **argv) 6436059Samurai{ 64428679Sbrian struct cmdtab const *cmd; 6456059Samurai int val = 1; 6466059Samurai int nmatch; 6476059Samurai 6486059Samurai cmd = FindCommand(cmdlist, *argv, &nmatch); 6496059Samurai if (nmatch > 1) 65026516Sbrian LogPrintf(LogWARN, "%s: Ambiguous command\n", *argv); 65128679Sbrian else if (cmd && (cmd->lauth & VarLocalAuth)) 65229257Sbrian val = (cmd->func) (cmd, argc-1, argv+1, cmd->args); 6536059Samurai else 65426516Sbrian LogPrintf(LogWARN, "%s: Invalid command\n", *argv); 65526516Sbrian 65626516Sbrian if (val == -1) 65726516Sbrian LogPrintf(LogWARN, "Usage: %s\n", cmd->syntax); 65828679Sbrian else if (val) 65926516Sbrian LogPrintf(LogCOMMAND, "%s: Failed %d\n", *argv, val); 66026516Sbrian 66126516Sbrian return val; 6626059Samurai} 6636059Samurai 66418885Sjkhint aft_cmd = 1; 66518885Sjkh 6666059Samuraivoid 66718885SjkhPrompt() 6686059Samurai{ 6696735Samurai char *pconnect, *pauth; 6706735Samurai 67126516Sbrian if (!(mode & MODE_INTER) || !VarTerm || TermMode) 6726059Samurai return; 6736735Samurai 67418885Sjkh if (!aft_cmd) 67526516Sbrian fprintf(VarTerm, "\n"); 67618885Sjkh else 67718885Sjkh aft_cmd = 0; 6786735Samurai 67928679Sbrian if (VarLocalAuth == LOCAL_AUTH) 6806735Samurai pauth = " ON "; 6816735Samurai else 6826735Samurai pauth = " on "; 6836059Samurai if (IpcpFsm.state == ST_OPENED && phase == PHASE_NETWORK) 6846735Samurai pconnect = "PPP"; 6856059Samurai else 6866735Samurai pconnect = "ppp"; 68726516Sbrian fprintf(VarTerm, "%s%s%s> ", pconnect, pauth, VarShortHost); 68826516Sbrian fflush(VarTerm); 6896059Samurai} 6906059Samurai 6916059Samuraivoid 69228679SbrianDecodeCommand(char *buff, int nb, int prompt) 6936059Samurai{ 6946059Samurai char *vector[20]; 6956059Samurai char **argv; 69626516Sbrian int argc; 6976059Samurai char *cp; 6986059Samurai 6996059Samurai if (nb > 0) { 7006059Samurai cp = buff + strcspn(buff, "\r\n"); 7016059Samurai if (cp) 7026059Samurai *cp = '\0'; 70326516Sbrian argc = MakeArgs(buff, vector, VECSIZE(vector)); 70426516Sbrian argv = vector; 7056059Samurai 70626516Sbrian if (argc > 0) 70726516Sbrian FindExec(Commands, argc, argv); 7086059Samurai } 70926516Sbrian if (prompt) 71025630Sbrian Prompt(); 7116059Samurai} 7126059Samurai 7136059Samuraistatic int 71428679SbrianShowCommand(struct cmdtab const * list, int argc, char **argv) 7156059Samurai{ 7166059Samurai if (argc > 0) 71726516Sbrian FindExec(ShowCommands, argc, argv); 71826516Sbrian else if (VarTerm) 71926516Sbrian fprintf(VarTerm, "Use ``show ?'' to get a list.\n"); 7206059Samurai else 72126516Sbrian LogPrintf(LogWARN, "show command must have arguments\n"); 72226516Sbrian 72326516Sbrian return 0; 7246059Samurai} 7256059Samurai 7266059Samuraistatic int 72728679SbrianTerminalCommand(struct cmdtab const * list, int argc, char **argv) 7286059Samurai{ 7296059Samurai if (LcpFsm.state > ST_CLOSED) { 73026516Sbrian if (VarTerm) 73126516Sbrian fprintf(VarTerm, "LCP state is [%s]\n", StateNames[LcpFsm.state]); 73226516Sbrian return 1; 7336059Samurai } 73430913Sbrian if (!IsInteractive(1)) 73528679Sbrian return (1); 73631034Sbrian if (OpenModem() < 0) { 73726516Sbrian if (VarTerm) 73826516Sbrian fprintf(VarTerm, "Failed to open modem.\n"); 73928679Sbrian return (1); 7406059Samurai } 74126516Sbrian if (VarTerm) { 74226516Sbrian fprintf(VarTerm, "Enter to terminal mode.\n"); 74326516Sbrian fprintf(VarTerm, "Type `~?' for help.\n"); 74426516Sbrian } 7456059Samurai TtyTermMode(); 74628679Sbrian return (0); 7476059Samurai} 7486059Samurai 7496059Samuraistatic int 75028679SbrianQuitCommand(struct cmdtab const * list, int argc, char **argv) 7516059Samurai{ 75226516Sbrian FILE *oVarTerm; 75326516Sbrian 75428679Sbrian if (mode & (MODE_DIRECT | MODE_DEDICATED | MODE_AUTO)) { 75529083Sbrian if (argc > 0 && !strcasecmp(*argv, "all") && (VarLocalAuth & LOCAL_AUTH)) { 75618911Ssos mode &= ~MODE_INTER; 75726516Sbrian oVarTerm = VarTerm; 75826516Sbrian VarTerm = 0; 75926516Sbrian if (oVarTerm && oVarTerm != stdout) 76028679Sbrian fclose(oVarTerm); 76129083Sbrian Cleanup(EX_NORMAL); 76229083Sbrian } else if (VarTerm) { 76326516Sbrian LogPrintf(LogPHASE, "Client connection closed.\n"); 76431080Sbrian LocalAuthInit(); 76526516Sbrian mode &= ~MODE_INTER; 76626516Sbrian oVarTerm = VarTerm; 76726516Sbrian VarTerm = 0; 76826516Sbrian if (oVarTerm && oVarTerm != stdout) 76928679Sbrian fclose(oVarTerm); 7706059Samurai close(netfd); 7716059Samurai netfd = -1; 7726059Samurai } 7736059Samurai } else 7746059Samurai Cleanup(EX_NORMAL); 77526516Sbrian 77626516Sbrian return 0; 7776059Samurai} 7786059Samurai 7796059Samuraistatic int 78028679SbrianCloseCommand(struct cmdtab const * list, int argc, char **argv) 7816059Samurai{ 78226098Sbrian reconnect(RECON_FALSE); 7836059Samurai LcpClose(); 78425908Sbrian if (mode & MODE_BACKGROUND) 78528679Sbrian Cleanup(EX_NORMAL); 78626516Sbrian return 0; 7876059Samurai} 7886059Samurai 7896059Samuraistatic int 79028679SbrianDownCommand(struct cmdtab const * list, int argc, char **argv) 7916059Samurai{ 7926059Samurai LcpDown(); 79326516Sbrian return 0; 7946059Samurai} 7956059Samurai 79625067Sbrianstatic int 79728679SbrianSetModemSpeed(struct cmdtab const * list, int argc, char **argv) 7986059Samurai{ 7996059Samurai int speed; 8006059Samurai 8016059Samurai if (argc > 0) { 80229521Sbrian if (strcasecmp(*argv, "sync") == 0) { 8036735Samurai VarSpeed = 0; 80426516Sbrian return 0; 8056735Samurai } 8066059Samurai speed = atoi(*argv); 8076735Samurai if (IntToSpeed(speed) != B0) { 8086735Samurai VarSpeed = speed; 80926516Sbrian return 0; 8106059Samurai } 81126516Sbrian LogPrintf(LogWARN, "%s: Invalid speed\n", *argv); 8126059Samurai } 81326516Sbrian return -1; 8146059Samurai} 8156059Samurai 81625067Sbrianstatic int 81728679SbrianSetReconnect(struct cmdtab const * list, int argc, char **argv) 81811336Samurai{ 81925067Sbrian if (argc == 2) { 82025067Sbrian VarReconnectTimer = atoi(argv[0]); 82125067Sbrian VarReconnectTries = atoi(argv[1]); 82226516Sbrian return 0; 82326516Sbrian } 82426516Sbrian return -1; 82525067Sbrian} 82625067Sbrian 82725067Sbrianstatic int 82828679SbrianSetRedialTimeout(struct cmdtab const * list, int argc, char **argv) 82925067Sbrian{ 83011336Samurai int timeout; 83111336Samurai int tries; 83224939Sbrian char *dot; 83311336Samurai 83428679Sbrian if (argc == 1 || argc == 2) { 83524939Sbrian if (strncasecmp(argv[0], "random", 6) == 0 && 83624939Sbrian (argv[0][6] == '\0' || argv[0][6] == '.')) { 83711336Samurai VarRedialTimeout = -1; 83830715Sbrian randinit(); 83926516Sbrian } else { 84011336Samurai timeout = atoi(argv[0]); 84111336Samurai 84226516Sbrian if (timeout >= 0) 84311336Samurai VarRedialTimeout = timeout; 84411336Samurai else { 84526516Sbrian LogPrintf(LogWARN, "Invalid redial timeout\n"); 84628679Sbrian return -1; 84711336Samurai } 84811336Samurai } 84924939Sbrian 85030715Sbrian dot = strchr(argv[0], '.'); 85124939Sbrian if (dot) { 85224939Sbrian if (strcasecmp(++dot, "random") == 0) { 85328679Sbrian VarRedialNextTimeout = -1; 85430715Sbrian randinit(); 85528679Sbrian } else { 85628679Sbrian timeout = atoi(dot); 85728679Sbrian if (timeout >= 0) 85828679Sbrian VarRedialNextTimeout = timeout; 85928679Sbrian else { 86028679Sbrian LogPrintf(LogWARN, "Invalid next redial timeout\n"); 86126516Sbrian return -1; 86228679Sbrian } 86324939Sbrian } 86428679Sbrian } else 86528679Sbrian VarRedialNextTimeout = NEXT_REDIAL_PERIOD; /* Default next timeout */ 86624939Sbrian 86711336Samurai if (argc == 2) { 86811336Samurai tries = atoi(argv[1]); 86911336Samurai 87011336Samurai if (tries >= 0) { 87126516Sbrian VarDialTries = tries; 87226516Sbrian } else { 87326516Sbrian LogPrintf(LogWARN, "Invalid retry value\n"); 87426516Sbrian return 1; 87511336Samurai } 87611336Samurai } 87726516Sbrian return 0; 87811336Samurai } 87926516Sbrian return -1; 88011336Samurai} 88111336Samurai 88225067Sbrianstatic int 88328679SbrianSetStoppedTimeout(struct cmdtab const * list, int argc, char **argv) 88428327Sbrian{ 88528461Sbrian LcpFsm.StoppedTimer.load = 0; 88628461Sbrian IpcpFsm.StoppedTimer.load = 0; 88728461Sbrian CcpFsm.StoppedTimer.load = 0; 88828461Sbrian if (argc <= 3) { 88928461Sbrian if (argc > 0) { 89028461Sbrian LcpFsm.StoppedTimer.load = atoi(argv[0]) * SECTICKS; 89128461Sbrian if (argc > 1) { 89228679Sbrian IpcpFsm.StoppedTimer.load = atoi(argv[1]) * SECTICKS; 89328679Sbrian if (argc > 2) 89428679Sbrian CcpFsm.StoppedTimer.load = atoi(argv[2]) * SECTICKS; 89528461Sbrian } 89628461Sbrian } 89728327Sbrian return 0; 89828327Sbrian } 89928327Sbrian return -1; 90028327Sbrian} 90128327Sbrian 90228327Sbrianstatic int 90328679SbrianSetServer(struct cmdtab const * list, int argc, char **argv) 90426940Sbrian{ 90526940Sbrian int res = -1; 90626940Sbrian 90727089Sbrian if (argc > 0 && argc < 3) 90826940Sbrian if (strcasecmp(argv[0], "none") == 0) { 90926940Sbrian ServerClose(); 91026940Sbrian LogPrintf(LogPHASE, "Disabling server port.\n"); 91126940Sbrian res = 0; 91227089Sbrian } else if (*argv[0] == '/') { 91327089Sbrian mode_t mask; 91428679Sbrian 91527089Sbrian umask(mask = umask(0)); 91627089Sbrian if (argc == 2) { 91728679Sbrian unsigned m; 91828679Sbrian 91928679Sbrian if (sscanf(argv[1], "%o", &m) == 1) 92028679Sbrian mask = m; 92127089Sbrian } 92227089Sbrian res = ServerLocalOpen(argv[0], mask); 92327346Sbrian } else { 92427346Sbrian int port; 92528679Sbrian 92627346Sbrian if (strspn(argv[0], "0123456789") != strlen(argv[0])) { 92728679Sbrian struct servent *s; 92828679Sbrian 92928679Sbrian if ((s = getservbyname(argv[0], "tcp")) == NULL) { 93028679Sbrian port = 0; 93128679Sbrian LogPrintf(LogWARN, "%s: Invalid port or service\n", argv[0]); 93228679Sbrian } else 93328679Sbrian port = ntohs(s->s_port); 93427346Sbrian } else 93528679Sbrian port = atoi(argv[0]); 93627346Sbrian if (port) 93728679Sbrian res = ServerTcpOpen(port); 93827346Sbrian } 93926940Sbrian 94026940Sbrian return res; 94126940Sbrian} 94226940Sbrian 94326940Sbrianstatic int 94428679SbrianSetModemParity(struct cmdtab const * list, int argc, char **argv) 9456059Samurai{ 94626845Sbrian return argc > 0 ? ChangeParity(*argv) : -1; 9476059Samurai} 9486059Samurai 9496059Samuraistatic int 95028679SbrianSetLogLevel(struct cmdtab const * list, int argc, char **argv) 9516059Samurai{ 95226516Sbrian int i; 95326516Sbrian int res; 95426516Sbrian char *arg; 95530913Sbrian void (*Discard)(int), (*Keep)(int); 95630913Sbrian void (*DiscardAll)(void); 9576059Samurai 95826516Sbrian res = 0; 95930913Sbrian if (strcasecmp(argv[0], "local")) { 96030913Sbrian Discard = LogDiscard; 96130913Sbrian Keep = LogKeep; 96230913Sbrian DiscardAll = LogDiscardAll; 96330913Sbrian } else { 96430913Sbrian argc--; 96530913Sbrian argv++; 96630913Sbrian Discard = LogDiscardLocal; 96730913Sbrian Keep = LogKeepLocal; 96830913Sbrian DiscardAll = LogDiscardAllLocal; 96930913Sbrian } 97030913Sbrian 97126516Sbrian if (argc == 0 || (argv[0][0] != '+' && argv[0][0] != '-')) 97230913Sbrian (*DiscardAll)(); 97326516Sbrian while (argc--) { 97426516Sbrian arg = **argv == '+' || **argv == '-' ? *argv + 1 : *argv; 97526516Sbrian for (i = LogMIN; i <= LogMAX; i++) 97626516Sbrian if (strcasecmp(arg, LogName(i)) == 0) { 97728679Sbrian if (**argv == '-') 97830913Sbrian (*Discard)(i); 97928679Sbrian else 98030913Sbrian (*Keep)(i); 9816059Samurai break; 9826059Samurai } 98326516Sbrian if (i > LogMAX) { 98426516Sbrian LogPrintf(LogWARN, "%s: Invalid log value\n", arg); 98526516Sbrian res = -1; 9866059Samurai } 98726516Sbrian argv++; 9886059Samurai } 98926516Sbrian return res; 9906059Samurai} 9916059Samurai 9926059Samuraistatic int 99328679SbrianSetEscape(struct cmdtab const * list, int argc, char **argv) 9946059Samurai{ 9956059Samurai int code; 9966059Samurai 9976059Samurai for (code = 0; code < 33; code++) 9986059Samurai EscMap[code] = 0; 9996059Samurai while (argc-- > 0) { 10006059Samurai sscanf(*argv++, "%x", &code); 10016059Samurai code &= 0xff; 100228679Sbrian EscMap[code >> 3] |= (1 << (code & 7)); 10036059Samurai EscMap[32] = 1; 10046059Samurai } 100526516Sbrian return 0; 10066059Samurai} 10076059Samurai 10086059Samuraistatic int 100928679SbrianSetInitialMRU(struct cmdtab const * list, int argc, char **argv) 10106059Samurai{ 101126326Sbrian long mru; 101226516Sbrian char *err; 10136059Samurai 10146059Samurai if (argc > 0) { 101526326Sbrian mru = atol(*argv); 101626326Sbrian if (mru < MIN_MRU) 101726516Sbrian err = "Given MRU value (%ld) is too small.\n"; 10186059Samurai else if (mru > MAX_MRU) 101926516Sbrian err = "Given MRU value (%ld) is too big.\n"; 102026516Sbrian else { 10216059Samurai VarMRU = mru; 102226516Sbrian return 0; 102326516Sbrian } 102426516Sbrian LogPrintf(LogWARN, err, mru); 102526516Sbrian } 102626516Sbrian return -1; 10276059Samurai} 10286059Samurai 10296059Samuraistatic int 103028679SbrianSetPreferredMTU(struct cmdtab const * list, int argc, char **argv) 103126326Sbrian{ 103226326Sbrian long mtu; 103326516Sbrian char *err; 103426326Sbrian 103526326Sbrian if (argc > 0) { 103626326Sbrian mtu = atol(*argv); 103726516Sbrian if (mtu == 0) { 103826326Sbrian VarPrefMTU = 0; 103926516Sbrian return 0; 104026516Sbrian } else if (mtu < MIN_MTU) 104126516Sbrian err = "Given MTU value (%ld) is too small.\n"; 104226326Sbrian else if (mtu > MAX_MTU) 104326516Sbrian err = "Given MTU value (%ld) is too big.\n"; 104426516Sbrian else { 104526326Sbrian VarPrefMTU = mtu; 104626516Sbrian return 0; 104726516Sbrian } 104826516Sbrian LogPrintf(LogWARN, err, mtu); 104926516Sbrian } 105026516Sbrian return -1; 105126326Sbrian} 105226326Sbrian 105326326Sbrianstatic int 105428679SbrianSetIdleTimeout(struct cmdtab const * list, int argc, char **argv) 10556059Samurai{ 10566059Samurai if (argc-- > 0) { 10576059Samurai VarIdleTimeout = atoi(*argv++); 105828679Sbrian UpdateIdleTimer(); /* If we're connected, restart the idle timer */ 10596735Samurai if (argc-- > 0) { 10606735Samurai VarLqrTimeout = atoi(*argv++); 10616735Samurai if (VarLqrTimeout < 1) 10626735Samurai VarLqrTimeout = 30; 10636735Samurai if (argc > 0) { 10646735Samurai VarRetryTimeout = atoi(*argv); 10656735Samurai if (VarRetryTimeout < 1 || VarRetryTimeout > 10) 10666735Samurai VarRetryTimeout = 3; 10676735Samurai } 10686735Samurai } 106926516Sbrian return 0; 10706059Samurai } 107126516Sbrian return -1; 10726059Samurai} 10736059Samurai 107430715Sbrianstatic struct in_addr 107528679SbrianGetIpAddr(char *cp) 10766059Samurai{ 10776059Samurai struct hostent *hp; 10786059Samurai struct in_addr ipaddr; 10796059Samurai 10806059Samurai hp = gethostbyname(cp); 10816059Samurai if (hp && hp->h_addrtype == AF_INET) 108230715Sbrian memcpy(&ipaddr, hp->h_addr, hp->h_length); 10836059Samurai else if (inet_aton(cp, &ipaddr) == 0) 10846059Samurai ipaddr.s_addr = 0; 108528679Sbrian return (ipaddr); 10866059Samurai} 10876059Samurai 10886059Samuraistatic int 108928679SbrianSetInterfaceAddr(struct cmdtab const * list, int argc, char **argv) 10906059Samurai{ 109128394Sbrian DefMyAddress.ipaddr.s_addr = DefHisAddress.ipaddr.s_addr = 0L; 10926059Samurai 109326516Sbrian if (argc > 4) 109428679Sbrian return -1; 109526516Sbrian 109628394Sbrian HaveTriggerAddress = 0; 109728394Sbrian ifnetmask.s_addr = 0; 109828394Sbrian 10996059Samurai if (argc > 0) { 110025630Sbrian if (ParseAddr(argc, argv++, 110128679Sbrian &DefMyAddress.ipaddr, 110228679Sbrian &DefMyAddress.mask, 110328679Sbrian &DefMyAddress.width) == 0) 110428679Sbrian return 1; 11056059Samurai if (--argc > 0) { 110625630Sbrian if (ParseAddr(argc, argv++, 110725630Sbrian &DefHisAddress.ipaddr, 110825630Sbrian &DefHisAddress.mask, 110925630Sbrian &DefHisAddress.width) == 0) 111028679Sbrian return 2; 11116059Samurai if (--argc > 0) { 111228679Sbrian ifnetmask = GetIpAddr(*argv); 111328679Sbrian if (--argc > 0) { 111428679Sbrian TriggerAddress = GetIpAddr(*argv); 111528679Sbrian HaveTriggerAddress = 1; 11169440Samurai } 11176059Samurai } 11186059Samurai } 11196059Samurai } 112028394Sbrian 11216059Samurai /* 11226059Samurai * For backwards compatibility, 0.0.0.0 means any address. 11236059Samurai */ 11246059Samurai if (DefMyAddress.ipaddr.s_addr == 0) { 11256059Samurai DefMyAddress.mask.s_addr = 0; 11266059Samurai DefMyAddress.width = 0; 11276059Samurai } 11286059Samurai if (DefHisAddress.ipaddr.s_addr == 0) { 11296059Samurai DefHisAddress.mask.s_addr = 0; 11306059Samurai DefHisAddress.width = 0; 11316059Samurai } 113228537Sbrian IpcpInfo.want_ipaddr.s_addr = DefMyAddress.ipaddr.s_addr; 113328537Sbrian IpcpInfo.his_ipaddr.s_addr = DefHisAddress.ipaddr.s_addr; 113428537Sbrian 11356735Samurai if ((mode & MODE_AUTO) || 113628679Sbrian ((mode & MODE_DEDICATED) && dstsystem)) { 113725630Sbrian if (OsSetIpaddress(DefMyAddress.ipaddr, DefHisAddress.ipaddr, ifnetmask) < 0) 113828679Sbrian return 4; 11396059Samurai } 114026516Sbrian return 0; 11416059Samurai} 11426059Samurai 114326516Sbrian#ifndef NOMSEXT 11446059Samurai 114530715Sbrianstatic void 114628679SbrianSetMSEXT(struct in_addr * pri_addr, 114728679Sbrian struct in_addr * sec_addr, 114828679Sbrian int argc, 114928679Sbrian char **argv) 115018752Sjkh{ 115118752Sjkh int dummyint; 115218752Sjkh struct in_addr dummyaddr; 115318752Sjkh 115418752Sjkh pri_addr->s_addr = sec_addr->s_addr = 0L; 115518752Sjkh 115628679Sbrian if (argc > 0) { 115718752Sjkh ParseAddr(argc, argv++, pri_addr, &dummyaddr, &dummyint); 115828679Sbrian if (--argc > 0) 115918752Sjkh ParseAddr(argc, argv++, sec_addr, &dummyaddr, &dummyint); 116018752Sjkh else 116118752Sjkh sec_addr->s_addr = pri_addr->s_addr; 116218752Sjkh } 116318752Sjkh 116428679Sbrian /* 116528679Sbrian * if the primary/secondary ns entries are 0.0.0.0 we should set them to 116628679Sbrian * either the localhost's ip, or the values in /etc/resolv.conf ?? 116728679Sbrian * 116828679Sbrian * up to you if you want to implement this... 116928679Sbrian */ 117018752Sjkh 117118752Sjkh} 117218752Sjkh 117318752Sjkhstatic int 117428679SbrianSetNS(struct cmdtab const * list, int argc, char **argv) 117518752Sjkh{ 117618752Sjkh SetMSEXT(&ns_entries[0], &ns_entries[1], argc, argv); 117726516Sbrian return 0; 117818752Sjkh} 117918752Sjkh 118018752Sjkhstatic int 118128679SbrianSetNBNS(struct cmdtab const * list, int argc, char **argv) 118218752Sjkh{ 118318752Sjkh SetMSEXT(&nbns_entries[0], &nbns_entries[1], argc, argv); 118426516Sbrian return 0; 118518752Sjkh} 118618752Sjkh 118728679Sbrian#endif /* MS_EXT */ 118818752Sjkh 118929696Sbrianint 119028679SbrianSetVariable(struct cmdtab const * list, int argc, char **argv, int param) 11916059Samurai{ 11926059Samurai u_long map; 119326551Sbrian char *arg; 11946059Samurai 119526551Sbrian if (argc > 0) 119626551Sbrian arg = *argv; 119726551Sbrian else 119826551Sbrian arg = ""; 119926551Sbrian 120026551Sbrian switch (param) { 120128679Sbrian case VAR_AUTHKEY: 120228679Sbrian strncpy(VarAuthKey, arg, sizeof(VarAuthKey) - 1); 120328679Sbrian VarAuthKey[sizeof(VarAuthKey) - 1] = '\0'; 120428679Sbrian break; 120528679Sbrian case VAR_AUTHNAME: 120628679Sbrian strncpy(VarAuthName, arg, sizeof(VarAuthName) - 1); 120728679Sbrian VarAuthName[sizeof(VarAuthName) - 1] = '\0'; 120828679Sbrian break; 120928679Sbrian case VAR_DIAL: 121028679Sbrian strncpy(VarDialScript, arg, sizeof(VarDialScript) - 1); 121128679Sbrian VarDialScript[sizeof(VarDialScript) - 1] = '\0'; 121228679Sbrian break; 121328679Sbrian case VAR_LOGIN: 121428679Sbrian strncpy(VarLoginScript, arg, sizeof(VarLoginScript) - 1); 121528679Sbrian VarLoginScript[sizeof(VarLoginScript) - 1] = '\0'; 121628679Sbrian break; 121728679Sbrian case VAR_DEVICE: 121829696Sbrian if (modem != -1) 121929696Sbrian LogPrintf(LogWARN, "Cannot change device to \"%s\" when \"%s\" is open\n", 122029696Sbrian arg, VarDevice); 122129696Sbrian else { 122229696Sbrian strncpy(VarDevice, arg, sizeof(VarDevice) - 1); 122329696Sbrian VarDevice[sizeof(VarDevice) - 1] = '\0'; 122430715Sbrian VarBaseDevice = strrchr(VarDevice, '/'); 122529696Sbrian VarBaseDevice = VarBaseDevice ? VarBaseDevice + 1 : ""; 122629696Sbrian } 122728679Sbrian break; 122828679Sbrian case VAR_ACCMAP: 122928679Sbrian sscanf(arg, "%lx", &map); 123028679Sbrian VarAccmap = map; 123128679Sbrian break; 123228679Sbrian case VAR_PHONE: 123328679Sbrian strncpy(VarPhoneList, arg, sizeof(VarPhoneList) - 1); 123428679Sbrian VarPhoneList[sizeof(VarPhoneList) - 1] = '\0'; 123528679Sbrian strcpy(VarPhoneCopy, VarPhoneList); 123628679Sbrian VarNextPhone = VarPhoneCopy; 123728679Sbrian break; 123828679Sbrian case VAR_HANGUP: 123928679Sbrian strncpy(VarHangupScript, arg, sizeof(VarHangupScript) - 1); 124028679Sbrian VarHangupScript[sizeof(VarHangupScript) - 1] = '\0'; 124128679Sbrian break; 124229840Sbrian#ifdef HAVE_DES 124329549Sbrian case VAR_ENC: 124429840Sbrian VarMSChap = !strcasecmp(arg, "mschap"); 124529549Sbrian break; 124629840Sbrian#endif 12476059Samurai } 124826516Sbrian return 0; 12496059Samurai} 12506059Samurai 125128679Sbrianstatic int 125228679SbrianSetCtsRts(struct cmdtab const * list, int argc, char **argv) 125320812Sjkh{ 125420812Sjkh if (argc > 0) { 125520812Sjkh if (strcmp(*argv, "on") == 0) 125630715Sbrian VarCtsRts = 1; 125720812Sjkh else if (strcmp(*argv, "off") == 0) 125830715Sbrian VarCtsRts = 0; 125920812Sjkh else 126026516Sbrian return -1; 126126516Sbrian return 0; 126220812Sjkh } 126326516Sbrian return -1; 126420812Sjkh} 126520812Sjkh 126620812Sjkh 126728679Sbrianstatic int 126828679SbrianSetOpenMode(struct cmdtab const * list, int argc, char **argv) 12696059Samurai{ 12706059Samurai if (argc > 0) { 12716059Samurai if (strcmp(*argv, "active") == 0) 12726059Samurai VarOpenMode = OPEN_ACTIVE; 12736059Samurai else if (strcmp(*argv, "passive") == 0) 12746059Samurai VarOpenMode = OPEN_PASSIVE; 12756059Samurai else 127626516Sbrian return -1; 127726516Sbrian return 0; 12786059Samurai } 127926516Sbrian return -1; 12806059Samurai} 12816059Samurai 128230715Sbrianstatic struct cmdtab const SetCommands[] = { 128328679Sbrian {"accmap", NULL, SetVariable, LOCAL_AUTH, 128428679Sbrian "Set accmap value", "set accmap hex-value", (void *) VAR_ACCMAP}, 128528679Sbrian {"afilter", NULL, SetAfilter, LOCAL_AUTH, 128628679Sbrian "Set keep Alive filter", "set afilter ..."}, 128728679Sbrian {"authkey", "key", SetVariable, LOCAL_AUTH, 128828679Sbrian "Set authentication key", "set authkey|key key", (void *) VAR_AUTHKEY}, 128928679Sbrian {"authname", NULL, SetVariable, LOCAL_AUTH, 129028679Sbrian "Set authentication name", "set authname name", (void *) VAR_AUTHNAME}, 129128679Sbrian {"ctsrts", NULL, SetCtsRts, LOCAL_AUTH, 129228679Sbrian "Use CTS/RTS modem signalling", "set ctsrts [on|off]"}, 129328679Sbrian {"device", "line", SetVariable, LOCAL_AUTH, 129428679Sbrian "Set modem device name", "set device|line device-name", (void *) VAR_DEVICE}, 129528679Sbrian {"dfilter", NULL, SetDfilter, LOCAL_AUTH, 129628679Sbrian "Set demand filter", "set dfilter ..."}, 129728679Sbrian {"dial", NULL, SetVariable, LOCAL_AUTH, 129828679Sbrian "Set dialing script", "set dial chat-script", (void *) VAR_DIAL}, 129929840Sbrian#ifdef HAVE_DES 130029549Sbrian {"encrypt", NULL, SetVariable, LOCAL_AUTH, 130129840Sbrian "Set CHAP encryption algorithm", "set encrypt MSChap|MD5", (void *) VAR_ENC}, 130229840Sbrian#endif 130328679Sbrian {"escape", NULL, SetEscape, LOCAL_AUTH, 130428679Sbrian "Set escape characters", "set escape hex-digit ..."}, 130528679Sbrian {"hangup", NULL, SetVariable, LOCAL_AUTH, 130628679Sbrian "Set hangup script", "set hangup chat-script", (void *) VAR_HANGUP}, 130728679Sbrian {"ifaddr", NULL, SetInterfaceAddr, LOCAL_AUTH, 130828679Sbrian "Set destination address", "set ifaddr [src-addr [dst-addr [netmask [trg-addr]]]]"}, 130928679Sbrian {"ifilter", NULL, SetIfilter, LOCAL_AUTH, 131028679Sbrian "Set input filter", "set ifilter ..."}, 131128679Sbrian {"loopback", NULL, SetLoopback, LOCAL_AUTH, 131228679Sbrian "Set loopback facility", "set loopback on|off"}, 131328679Sbrian {"log", NULL, SetLogLevel, LOCAL_AUTH, 131430913Sbrian "Set log level", "set log [local] [+|-]value..."}, 131528679Sbrian {"login", NULL, SetVariable, LOCAL_AUTH, 131628679Sbrian "Set login script", "set login chat-script", (void *) VAR_LOGIN}, 131728679Sbrian {"mru", NULL, SetInitialMRU, LOCAL_AUTH, 131828679Sbrian "Set Initial MRU value", "set mru value"}, 131928679Sbrian {"mtu", NULL, SetPreferredMTU, LOCAL_AUTH, 132028679Sbrian "Set Preferred MTU value", "set mtu value"}, 132128679Sbrian {"ofilter", NULL, SetOfilter, LOCAL_AUTH, 132228679Sbrian "Set output filter", "set ofilter ..."}, 132328679Sbrian {"openmode", NULL, SetOpenMode, LOCAL_AUTH, 132428679Sbrian "Set open mode", "set openmode [active|passive]"}, 132528679Sbrian {"parity", NULL, SetModemParity, LOCAL_AUTH, 132628679Sbrian "Set modem parity", "set parity [odd|even|none]"}, 132728679Sbrian {"phone", NULL, SetVariable, LOCAL_AUTH, 132828679Sbrian "Set telephone number(s)", "set phone phone1[:phone2[...]]", (void *) VAR_PHONE}, 132928679Sbrian {"reconnect", NULL, SetReconnect, LOCAL_AUTH, 133028679Sbrian "Set Reconnect timeout", "set reconnect value ntries"}, 133128679Sbrian {"redial", NULL, SetRedialTimeout, LOCAL_AUTH, 133228679Sbrian "Set Redial timeout", "set redial value|random[.value|random] [dial_attempts]"}, 133328679Sbrian {"stopped", NULL, SetStoppedTimeout, LOCAL_AUTH, 133428679Sbrian "Set STOPPED timeouts", "set stopped [LCPseconds [IPCPseconds [CCPseconds]]]"}, 133528679Sbrian {"server", "socket", SetServer, LOCAL_AUTH, 133628679Sbrian "Set server port", "set server|socket TcpPort|LocalName|none [mask]"}, 133728679Sbrian {"speed", NULL, SetModemSpeed, LOCAL_AUTH, 133828679Sbrian "Set modem speed", "set speed value"}, 133928679Sbrian {"timeout", NULL, SetIdleTimeout, LOCAL_AUTH, 134028679Sbrian "Set Idle timeout", "set timeout value"}, 134126516Sbrian#ifndef NOMSEXT 134228679Sbrian {"ns", NULL, SetNS, LOCAL_AUTH, 134328679Sbrian "Set NameServer", "set ns pri-addr [sec-addr]"}, 134428679Sbrian {"nbns", NULL, SetNBNS, LOCAL_AUTH, 134528679Sbrian "Set NetBIOS NameServer", "set nbns pri-addr [sec-addr]"}, 134626516Sbrian#endif 134728679Sbrian {"help", "?", HelpCommand, LOCAL_AUTH | LOCAL_NO_AUTH, 134828679Sbrian "Display this message", "set help|? [command]", (void *) SetCommands}, 134928679Sbrian {NULL, NULL, NULL}, 13506059Samurai}; 13516059Samurai 13526059Samuraistatic int 135328679SbrianSetCommand(struct cmdtab const * list, int argc, char **argv) 13546059Samurai{ 13556059Samurai if (argc > 0) 135626516Sbrian FindExec(SetCommands, argc, argv); 135726516Sbrian else if (VarTerm) 135826516Sbrian fprintf(VarTerm, "Use `set ?' to get a list or `set ? <var>' for" 135926516Sbrian " syntax help.\n"); 13606059Samurai else 136126516Sbrian LogPrintf(LogWARN, "set command must have arguments\n"); 136226516Sbrian 136326516Sbrian return 0; 13646059Samurai} 13656059Samurai 13666059Samurai 13676059Samuraistatic int 136828679SbrianAddCommand(struct cmdtab const * list, int argc, char **argv) 13696059Samurai{ 13706059Samurai struct in_addr dest, gateway, netmask; 13716059Samurai 13726059Samurai if (argc == 3) { 137327011Sbrian if (strcasecmp(argv[0], "MYADDR") == 0) 137427011Sbrian dest = IpcpInfo.want_ipaddr; 137527011Sbrian else 137627011Sbrian dest = GetIpAddr(argv[0]); 13776059Samurai netmask = GetIpAddr(argv[1]); 137825566Sbrian if (strcasecmp(argv[2], "HISADDR") == 0) 13796059Samurai gateway = IpcpInfo.his_ipaddr; 13806059Samurai else 13816059Samurai gateway = GetIpAddr(argv[2]); 13826059Samurai OsSetRoute(RTM_ADD, dest, gateway, netmask); 138326516Sbrian return 0; 13846059Samurai } 138526516Sbrian return -1; 13866059Samurai} 13876059Samurai 13886059Samuraistatic int 138928679SbrianDeleteCommand(struct cmdtab const * list, int argc, char **argv) 13906059Samurai{ 13916059Samurai struct in_addr dest, gateway, netmask; 13926059Samurai 139326591Sbrian if (argc == 1 && strcasecmp(argv[0], "all") == 0) 139426591Sbrian DeleteIfRoutes(0); 139526591Sbrian else if (argc > 0 && argc < 4) { 139627011Sbrian if (strcasecmp(argv[0], "MYADDR") == 0) 139727011Sbrian dest = IpcpInfo.want_ipaddr; 139827011Sbrian else 139927011Sbrian dest = GetIpAddr(argv[0]); 140026591Sbrian netmask.s_addr = INADDR_ANY; 140126591Sbrian if (argc > 1) { 140226591Sbrian if (strcasecmp(argv[1], "HISADDR") == 0) 140328679Sbrian gateway = IpcpInfo.his_ipaddr; 140426591Sbrian else 140528679Sbrian gateway = GetIpAddr(argv[1]); 140626591Sbrian if (argc == 3) { 140728679Sbrian if (inet_aton(argv[2], &netmask) == 0) { 140826591Sbrian LogPrintf(LogWARN, "Bad netmask value.\n"); 140926591Sbrian return -1; 141028679Sbrian } 14116059Samurai } 141226591Sbrian } else 141326591Sbrian gateway.s_addr = INADDR_ANY; 14146059Samurai OsSetRoute(RTM_DELETE, dest, gateway, netmask); 141526516Sbrian } else 141626516Sbrian return -1; 141726516Sbrian 141826516Sbrian return 0; 14196059Samurai} 14206059Samurai 142126031Sbrianstatic struct cmdtab const AliasCommands[] = 142226031Sbrian{ 142328679Sbrian {"enable", NULL, AliasEnable, LOCAL_AUTH, 142428679Sbrian "enable IP aliasing", "alias enable [yes|no]"}, 142528679Sbrian {"port", NULL, AliasRedirectPort, LOCAL_AUTH, 142628679Sbrian "port redirection", "alias port [proto addr_local:port_local port_alias]"}, 142728679Sbrian {"addr", NULL, AliasRedirectAddr, LOCAL_AUTH, 142828679Sbrian "static address translation", "alias addr [addr_local addr_alias]"}, 142928679Sbrian {"deny_incoming", NULL, AliasOption, LOCAL_AUTH, 143028679Sbrian "stop incoming connections", "alias deny_incoming [yes|no]", 143128679Sbrian (void *) PKT_ALIAS_DENY_INCOMING}, 143228679Sbrian {"log", NULL, AliasOption, LOCAL_AUTH, 143328679Sbrian "log aliasing link creation", "alias log [yes|no]", 143428679Sbrian (void *) PKT_ALIAS_LOG}, 143528679Sbrian {"same_ports", NULL, AliasOption, LOCAL_AUTH, 143628679Sbrian "try to leave port numbers unchanged", "alias same_ports [yes|no]", 143728679Sbrian (void *) PKT_ALIAS_SAME_PORTS}, 143828679Sbrian {"use_sockets", NULL, AliasOption, LOCAL_AUTH, 143928679Sbrian "allocate host sockets", "alias use_sockets [yes|no]", 144028679Sbrian (void *) PKT_ALIAS_USE_SOCKETS}, 144128679Sbrian {"unregistered_only", NULL, AliasOption, LOCAL_AUTH, 144228679Sbrian "alias unregistered (private) IP address space only", 144328679Sbrian "alias unregistered_only [yes|no]", 144428679Sbrian (void *) PKT_ALIAS_UNREGISTERED_ONLY}, 144528679Sbrian {"help", "?", HelpCommand, LOCAL_AUTH | LOCAL_NO_AUTH, 144628679Sbrian "Display this message", "alias help|? [command]", 144728679Sbrian (void *) AliasCommands}, 144828679Sbrian {NULL, NULL, NULL}, 144926031Sbrian}; 145026031Sbrian 145126031Sbrian 145226031Sbrianstatic int 145328679SbrianAliasCommand(struct cmdtab const * list, int argc, char **argv) 145426031Sbrian{ 145526031Sbrian if (argc > 0) 145626516Sbrian FindExec(AliasCommands, argc, argv); 145726516Sbrian else if (VarTerm) 145826516Sbrian fprintf(VarTerm, "Use `alias help' to get a list or `alias help <option>'" 145926516Sbrian " for syntax help.\n"); 146026031Sbrian else 146126516Sbrian LogPrintf(LogWARN, "alias command must have arguments\n"); 146226516Sbrian 146326516Sbrian return 0; 146426031Sbrian} 146526031Sbrian 146626031Sbrianstatic int 146728679SbrianAliasEnable(struct cmdtab const * list, int argc, char **argv) 146826031Sbrian{ 146926516Sbrian if (argc == 1) 147026516Sbrian if (strcasecmp(argv[0], "yes") == 0) { 147126516Sbrian if (!(mode & MODE_ALIAS)) { 147228679Sbrian if (loadAliasHandlers(&VarAliasHandlers) == 0) { 147328679Sbrian mode |= MODE_ALIAS; 147428679Sbrian return 0; 147528679Sbrian } 147628679Sbrian LogPrintf(LogWARN, "Cannot load alias library\n"); 147728679Sbrian return 1; 147826516Sbrian } 147926516Sbrian return 0; 148026516Sbrian } else if (strcasecmp(argv[0], "no") == 0) { 148126516Sbrian if (mode & MODE_ALIAS) { 148228679Sbrian unloadAliasHandlers(); 148328679Sbrian mode &= ~MODE_ALIAS; 148426516Sbrian } 148526516Sbrian return 0; 148626142Sbrian } 148726516Sbrian return -1; 148826031Sbrian} 148926031Sbrian 149026031Sbrian 149126031Sbrianstatic int 149228679SbrianAliasOption(struct cmdtab const * list, int argc, char **argv, void *param) 149326031Sbrian{ 149428679Sbrian if (argc == 1) 149528679Sbrian if (strcasecmp(argv[0], "yes") == 0) { 149628679Sbrian if (mode & MODE_ALIAS) { 149728679Sbrian VarPacketAliasSetMode((unsigned) param, (unsigned) param); 149828679Sbrian return 0; 149928679Sbrian } 150028679Sbrian LogPrintf(LogWARN, "alias not enabled\n"); 150128679Sbrian } else if (strcmp(argv[0], "no") == 0) { 150228679Sbrian if (mode & MODE_ALIAS) { 150328679Sbrian VarPacketAliasSetMode(0, (unsigned) param); 150428679Sbrian return 0; 150528679Sbrian } 150628679Sbrian LogPrintf(LogWARN, "alias not enabled\n"); 150728679Sbrian } 150828679Sbrian return -1; 150926031Sbrian} 1510