command.c revision 31077
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 * 2031077Sbrian * $Id: command.c,v 1.92 1997/11/09 06:22:39 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" 706059Samurai 716059Samuraistruct in_addr ifnetmask; 726059Samurai 7328679Sbrianstatic int ShowCommand(struct cmdtab const *, int, char **); 7428679Sbrianstatic int TerminalCommand(struct cmdtab const *, int, char **); 7528679Sbrianstatic int QuitCommand(struct cmdtab const *, int, char **); 7628679Sbrianstatic int CloseCommand(struct cmdtab const *, int, char **); 7728679Sbrianstatic int DialCommand(struct cmdtab const *, int, char **); 7828679Sbrianstatic int DownCommand(struct cmdtab const *, int, char **); 7928679Sbrianstatic int SetCommand(struct cmdtab const *, int, char **); 8028679Sbrianstatic int AddCommand(struct cmdtab const *, int, char **); 8128679Sbrianstatic int DeleteCommand(struct cmdtab const *, int, char **); 8228679Sbrianstatic int BgShellCommand(struct cmdtab const *, int, char **); 8328679Sbrianstatic int FgShellCommand(struct cmdtab const *, int, char **); 8428679Sbrianstatic int ShellCommand(struct cmdtab const *, int, char **, int); 8530715Sbrianstatic int AliasCommand(struct cmdtab const *, int, char **); 8630715Sbrianstatic int AliasEnable(struct cmdtab const *, int, char **); 8730715Sbrianstatic int AliasOption(struct cmdtab const *, int, char **, void *); 886059Samurai 896059Samuraistatic int 9028679SbrianHelpCommand(struct cmdtab const * list, 9128679Sbrian int argc, 9228679Sbrian char **argv, 9328679Sbrian struct cmdtab const * plist) 946059Samurai{ 9528679Sbrian struct cmdtab const *cmd; 966059Samurai int n; 976059Samurai 9826516Sbrian if (!VarTerm) 9926516Sbrian return 0; 10026516Sbrian 1016059Samurai if (argc > 0) { 10226516Sbrian for (cmd = plist; cmd->name; cmd++) 10325566Sbrian if (strcasecmp(cmd->name, *argv) == 0 && (cmd->lauth & VarLocalAuth)) { 10428679Sbrian fprintf(VarTerm, "%s\n", cmd->syntax); 10528679Sbrian return 0; 1066059Samurai } 10726516Sbrian return -1; 1086059Samurai } 1096059Samurai n = 0; 11026516Sbrian for (cmd = plist; cmd->func; cmd++) 1116764Samurai if (cmd->name && (cmd->lauth & VarLocalAuth)) { 11226587Sbrian fprintf(VarTerm, " %-9s: %-20s\n", cmd->name, cmd->helpmes); 1136059Samurai n++; 1146059Samurai } 1156059Samurai if (n & 1) 11626516Sbrian fprintf(VarTerm, "\n"); 11726516Sbrian 11826516Sbrian return 0; 1196059Samurai} 1206059Samurai 1216059Samuraiint 12230913SbrianIsInteractive(int Display) 1236059Samurai{ 1246059Samurai char *mes = NULL; 1256059Samurai 12620120Snate if (mode & MODE_DDIAL) 12720120Snate mes = "Working in dedicated dial mode."; 12825908Sbrian else if (mode & MODE_BACKGROUND) 12925908Sbrian mes = "Working in background mode."; 13020120Snate else if (mode & MODE_AUTO) 13110528Samurai mes = "Working in auto mode."; 1326059Samurai else if (mode & MODE_DIRECT) 13310528Samurai mes = "Working in direct mode."; 1346059Samurai else if (mode & MODE_DEDICATED) 13510528Samurai mes = "Working in dedicated mode."; 1366059Samurai if (mes) { 13730913Sbrian if (Display && VarTerm) 13826516Sbrian fprintf(VarTerm, "%s\n", mes); 13926516Sbrian return 0; 1406059Samurai } 14126516Sbrian return 1; 1426059Samurai} 1436059Samurai 1446059Samuraistatic int 14528679SbrianDialCommand(struct cmdtab const * cmdlist, int argc, char **argv) 1466059Samurai{ 14711336Samurai int tries; 14826858Sbrian int res; 14911336Samurai 1506059Samurai if (LcpFsm.state > ST_CLOSED) { 15126516Sbrian if (VarTerm) 15226516Sbrian fprintf(VarTerm, "LCP state is [%s]\n", StateNames[LcpFsm.state]); 15326516Sbrian return 0; 1546059Samurai } 15526516Sbrian 1566735Samurai if (argc > 0) { 1576735Samurai if (SelectSystem(*argv, CONFFILE) < 0) { 15826516Sbrian if (VarTerm) 15928679Sbrian fprintf(VarTerm, "%s: not found.\n", *argv); 16026516Sbrian return -1; 1616735Samurai } 1626735Samurai } 16311336Samurai tries = 0; 16411336Samurai do { 16526516Sbrian if (VarTerm) 16626516Sbrian fprintf(VarTerm, "Dial attempt %u of %d\n", ++tries, VarDialTries); 16731034Sbrian if (OpenModem() < 0) { 16826516Sbrian if (VarTerm) 16928679Sbrian fprintf(VarTerm, "Failed to open modem.\n"); 17011336Samurai break; 17111336Samurai } 17226858Sbrian if ((res = DialModem()) == EX_DONE) { 17330697Sbrian nointr_sleep(1); 17411336Samurai ModemTimeout(); 17511336Samurai PacketMode(); 17611336Samurai break; 17726858Sbrian } else if (res == EX_SIG) 17826858Sbrian return 1; 17911336Samurai } while (VarDialTries == 0 || tries < VarDialTries); 18026516Sbrian 18126516Sbrian return 0; 1826059Samurai} 1836059Samurai 18410528Samuraistatic int 18528679SbrianSetLoopback(struct cmdtab const * cmdlist, int argc, char **argv) 18628536Sbrian{ 18728536Sbrian if (argc == 1) 18828536Sbrian if (!strcasecmp(*argv, "on")) 18928536Sbrian VarLoopback = 1; 19028536Sbrian else if (!strcasecmp(*argv, "off")) 19128536Sbrian VarLoopback = 0; 19228536Sbrian return -1; 19328536Sbrian} 19428536Sbrian 19528536Sbrianstatic int 19628679SbrianBgShellCommand(struct cmdtab const * cmdlist, int argc, char **argv) 19710528Samurai{ 19828381Sbrian if (argc == 0) 19928381Sbrian return -1; 20028381Sbrian return ShellCommand(cmdlist, argc, argv, 1); 20128381Sbrian} 20228381Sbrian 20328381Sbrianstatic int 20428679SbrianFgShellCommand(struct cmdtab const * cmdlist, int argc, char **argv) 20528381Sbrian{ 20628381Sbrian return ShellCommand(cmdlist, argc, argv, 0); 20728381Sbrian} 20828381Sbrian 20928381Sbrianstatic int 21028679SbrianShellCommand(struct cmdtab const * cmdlist, int argc, char **argv, int bg) 21128381Sbrian{ 21210528Samurai const char *shell; 21310528Samurai pid_t shpid; 21426516Sbrian FILE *oVarTerm; 21520813Sjkh 21618856Ssos#ifdef SHELL_ONLY_INTERACTIVELY 21726911Sbrian /* we're only allowed to shell when we run ppp interactively */ 21826516Sbrian if (mode != MODE_INTER) { 21926516Sbrian LogPrintf(LogWARN, "Can only start a shell in interactive mode\n"); 22026516Sbrian return 1; 22110528Samurai } 22226911Sbrian#endif 22326911Sbrian#ifdef NO_SHELL_IN_AUTO_INTERACTIVE 22428679Sbrian 22526911Sbrian /* 22628679Sbrian * we want to stop shell commands when we've got a telnet connection to an 22728679Sbrian * auto mode ppp 22826911Sbrian */ 22928679Sbrian if ((mode & (MODE_AUTO | MODE_INTER)) == (MODE_AUTO | MODE_INTER)) { 23028679Sbrian LogPrintf(LogWARN, "Shell is not allowed interactively in auto mode\n"); 23126516Sbrian return 1; 23226516Sbrian } 23326516Sbrian#endif 23426516Sbrian 23528679Sbrian if (argc == 0) 23628381Sbrian if (!(mode & MODE_INTER)) { 23728381Sbrian LogPrintf(LogWARN, "Can only start an interactive shell in" 23828679Sbrian " interactive mode\n"); 23928381Sbrian return 1; 24028381Sbrian } else if (bg) { 24128381Sbrian LogPrintf(LogWARN, "Can only start an interactive shell in" 24228679Sbrian " the foreground mode\n"); 24328381Sbrian return 1; 24429255Sbrian } else if (mode&(MODE_AUTO|MODE_DEDICATED|MODE_DIRECT)) { 24529255Sbrian LogPrintf(LogWARN, "Can't start an interactive shell from" 24629255Sbrian " a telnet session\n"); 24729255Sbrian return 1; 24828381Sbrian } 24928679Sbrian if ((shell = getenv("SHELL")) == 0) 25026516Sbrian shell = _PATH_BSHELL; 25126516Sbrian 25228679Sbrian if ((shpid = fork()) == 0) { 25328679Sbrian int dtablesize, i, fd; 25418531Sbde 25528679Sbrian if (VarTerm) 25628679Sbrian fd = fileno(VarTerm); 25728679Sbrian else if ((fd = open("/dev/null", O_RDWR)) == -1) { 25828679Sbrian LogPrintf(LogALERT, "Failed to open /dev/null: %s\n", strerror(errno)); 25928679Sbrian exit(1); 26028679Sbrian } 26128679Sbrian for (i = 0; i < 3; i++) 26228679Sbrian dup2(fd, i); 26326516Sbrian 26428679Sbrian if (fd > 2) 26528679Sbrian if (VarTerm) { 26628679Sbrian oVarTerm = VarTerm; 26728679Sbrian VarTerm = 0; 26828679Sbrian if (oVarTerm && oVarTerm != stdout) 26928679Sbrian fclose(oVarTerm); 27028679Sbrian } else 27128679Sbrian close(fd); 27226516Sbrian 27328679Sbrian for (dtablesize = getdtablesize(), i = 3; i < dtablesize; i++) 27428679Sbrian (void) close(i); 27526516Sbrian 27628679Sbrian TtyOldMode(); 27731061Sbrian setuid(geteuid()); 27828679Sbrian if (argc > 0) { 27928679Sbrian /* substitute pseudo args */ 28028679Sbrian for (i = 1; i < argc; i++) 28128679Sbrian if (strcasecmp(argv[i], "HISADDR") == 0) 28228679Sbrian argv[i] = strdup(inet_ntoa(IpcpInfo.his_ipaddr)); 28328679Sbrian else if (strcasecmp(argv[i], "INTERFACE") == 0) 28428679Sbrian argv[i] = strdup(IfDevName); 28528679Sbrian else if (strcasecmp(argv[i], "MYADDR") == 0) 28628679Sbrian argv[i] = strdup(inet_ntoa(IpcpInfo.want_ipaddr)); 28728679Sbrian if (bg) { 28828679Sbrian pid_t p; 28910528Samurai 29028679Sbrian p = getpid(); 29128679Sbrian if (daemon(1, 1) == -1) { 29228974Sbrian LogPrintf(LogERROR, "%d: daemon: %s\n", p, strerror(errno)); 29328679Sbrian exit(1); 29428679Sbrian } 29528679Sbrian } 29630316Sbrian if (VarTerm) 29730316Sbrian fprintf(VarTerm, "ppp: Pausing until %s finishes\n", argv[0]); 29828679Sbrian (void) execvp(argv[0], argv); 29930316Sbrian } else { 30030316Sbrian if (VarTerm) 30130316Sbrian fprintf(VarTerm, "ppp: Pausing until %s finishes\n", shell); 30228679Sbrian (void) execl(shell, shell, NULL); 30330316Sbrian } 30420813Sjkh 30528679Sbrian LogPrintf(LogWARN, "exec() of %s failed\n", argc > 0 ? argv[0] : shell); 30628679Sbrian exit(255); 30710528Samurai } 30828679Sbrian if (shpid == (pid_t) - 1) { 30926516Sbrian LogPrintf(LogERROR, "Fork failed: %s\n", strerror(errno)); 31010528Samurai } else { 31110528Samurai int status; 31228679Sbrian 31328679Sbrian (void) waitpid(shpid, &status, 0); 31410528Samurai } 31520813Sjkh 31610528Samurai TtyCommandMode(1); 31720813Sjkh 31828679Sbrian return (0); 31910528Samurai} 32010528Samurai 32130715Sbrianstatic struct cmdtab const Commands[] = { 32228679Sbrian {"accept", NULL, AcceptCommand, LOCAL_AUTH, 32328679Sbrian "accept option request", "accept option .."}, 32428679Sbrian {"add", NULL, AddCommand, LOCAL_AUTH, 32528679Sbrian "add route", "add dest mask gateway"}, 32628679Sbrian {"bg", "!bg", BgShellCommand, LOCAL_AUTH, 32728679Sbrian "Run a command in the background", "[!]bg command"}, 32828679Sbrian {"close", NULL, CloseCommand, LOCAL_AUTH, 32928679Sbrian "Close connection", "close"}, 33028679Sbrian {"delete", NULL, DeleteCommand, LOCAL_AUTH, 33128679Sbrian "delete route", "delete ALL | dest [gateway [mask]]"}, 33228679Sbrian {"deny", NULL, DenyCommand, LOCAL_AUTH, 33328679Sbrian "Deny option request", "deny option .."}, 33428679Sbrian {"dial", "call", DialCommand, LOCAL_AUTH, 33528679Sbrian "Dial and login", "dial|call [remote]"}, 33628679Sbrian {"disable", NULL, DisableCommand, LOCAL_AUTH, 33728679Sbrian "Disable option", "disable option .."}, 33828679Sbrian {"display", NULL, DisplayCommand, LOCAL_AUTH, 33928679Sbrian "Display option configs", "display"}, 34028679Sbrian {"enable", NULL, EnableCommand, LOCAL_AUTH, 34128679Sbrian "Enable option", "enable option .."}, 34228679Sbrian {"passwd", NULL, LocalAuthCommand, LOCAL_NO_AUTH, 34329083Sbrian "Password for manipulation", "passwd LocalPassword"}, 34428679Sbrian {"load", NULL, LoadCommand, LOCAL_AUTH, 34528679Sbrian "Load settings", "load [remote]"}, 34628679Sbrian {"save", NULL, SaveCommand, LOCAL_AUTH, 34728679Sbrian "Save settings", "save"}, 34828679Sbrian {"set", "setup", SetCommand, LOCAL_AUTH, 34928679Sbrian "Set parameters", "set[up] var value"}, 35028679Sbrian {"shell", "!", FgShellCommand, LOCAL_AUTH, 35128679Sbrian "Run a subshell", "shell|! [sh command]"}, 35228679Sbrian {"show", NULL, ShowCommand, LOCAL_AUTH, 35329660Sbrian "Show status and statistics", "show var"}, 35428679Sbrian {"term", NULL, TerminalCommand, LOCAL_AUTH, 35528679Sbrian "Enter to terminal mode", "term"}, 35628679Sbrian {"alias", NULL, AliasCommand, LOCAL_AUTH, 35728679Sbrian "alias control", "alias option [yes|no]"}, 35828679Sbrian {"quit", "bye", QuitCommand, LOCAL_AUTH | LOCAL_NO_AUTH, 35928679Sbrian "Quit PPP program", "quit|bye [all]"}, 36028679Sbrian {"help", "?", HelpCommand, LOCAL_AUTH | LOCAL_NO_AUTH, 36128679Sbrian "Display this message", "help|? [command]", (void *) Commands}, 36228679Sbrian {NULL, "down", DownCommand, LOCAL_AUTH, 36328679Sbrian "Generate down event", "down"}, 36428679Sbrian {NULL, NULL, NULL}, 3656059Samurai}; 3666059Samurai 36728536Sbrianstatic int 36828536SbrianShowLoopback() 36928536Sbrian{ 37028536Sbrian if (VarTerm) 37128536Sbrian fprintf(VarTerm, "Local loopback is %s\n", VarLoopback ? "on" : "off"); 37228536Sbrian 37328536Sbrian return 0; 37428536Sbrian} 37528536Sbrian 37628679Sbrianstatic int 37728679SbrianShowLogLevel() 3786059Samurai{ 3796059Samurai int i; 3806059Samurai 38126516Sbrian if (!VarTerm) 38226516Sbrian return 0; 38330913Sbrian 38430913Sbrian fprintf(VarTerm, "Log: "); 38530913Sbrian for (i = LogMIN; i <= LogMAX; i++) 38630913Sbrian if (LogIsKept(i) & LOG_KEPT_SYSLOG) 38726516Sbrian fprintf(VarTerm, " %s", LogName(i)); 38830913Sbrian 38930913Sbrian fprintf(VarTerm, "\nLocal:"); 39030913Sbrian for (i = LogMIN; i <= LogMAX; i++) 39130913Sbrian if (LogIsKept(i) & LOG_KEPT_LOCAL) 39230913Sbrian fprintf(VarTerm, " %s", LogName(i)); 39330913Sbrian 39426516Sbrian fprintf(VarTerm, "\n"); 39526516Sbrian 39626516Sbrian return 0; 3976059Samurai} 3986059Samurai 39928679Sbrianstatic int 40028679SbrianShowEscape() 4016059Samurai{ 4026059Samurai int code, bit; 4036059Samurai 40426516Sbrian if (!VarTerm) 40526516Sbrian return 0; 4066059Samurai if (EscMap[32]) { 40726516Sbrian for (code = 0; code < 32; code++) 40826516Sbrian if (EscMap[code]) 40928679Sbrian for (bit = 0; bit < 8; bit++) 41028679Sbrian if (EscMap[code] & (1 << bit)) 41128679Sbrian fprintf(VarTerm, " 0x%02x", (code << 3) + bit); 41226516Sbrian fprintf(VarTerm, "\n"); 4136059Samurai } 41431077Sbrian return 0; 4156059Samurai} 4166059Samurai 41728679Sbrianstatic int 41828679SbrianShowTimeout() 4196059Samurai{ 42031077Sbrian if (VarTerm) 42131077Sbrian fprintf(VarTerm, " Idle Timer: %d secs LQR Timer: %d secs" 42231077Sbrian " Retry Timer: %d secs\n", VarIdleTimeout, VarLqrTimeout, 42331077Sbrian VarRetryTimeout); 42431077Sbrian return 0; 4256059Samurai} 4266059Samurai 42728679Sbrianstatic int 42828679SbrianShowStopped() 42928327Sbrian{ 43028327Sbrian if (!VarTerm) 43128327Sbrian return 0; 43228461Sbrian 43328461Sbrian fprintf(VarTerm, " Stopped Timer: LCP: "); 43428461Sbrian if (!LcpFsm.StoppedTimer.load) 43528461Sbrian fprintf(VarTerm, "Disabled"); 43628327Sbrian else 43728461Sbrian fprintf(VarTerm, "%ld secs", LcpFsm.StoppedTimer.load / SECTICKS); 43828461Sbrian 43928461Sbrian fprintf(VarTerm, ", IPCP: "); 44028461Sbrian if (!IpcpFsm.StoppedTimer.load) 44128461Sbrian fprintf(VarTerm, "Disabled"); 44228461Sbrian else 44328461Sbrian fprintf(VarTerm, "%ld secs", IpcpFsm.StoppedTimer.load / SECTICKS); 44428461Sbrian 44528461Sbrian fprintf(VarTerm, ", CCP: "); 44628461Sbrian if (!CcpFsm.StoppedTimer.load) 44728461Sbrian fprintf(VarTerm, "Disabled"); 44828461Sbrian else 44928461Sbrian fprintf(VarTerm, "%ld secs", CcpFsm.StoppedTimer.load / SECTICKS); 45028461Sbrian 45128461Sbrian fprintf(VarTerm, "\n"); 45228461Sbrian 45331077Sbrian return 0; 45428327Sbrian} 45528327Sbrian 45628679Sbrianstatic int 45728679SbrianShowAuthKey() 4586059Samurai{ 45926516Sbrian if (!VarTerm) 46026516Sbrian return 0; 46126516Sbrian fprintf(VarTerm, "AuthName = %s\n", VarAuthName); 46226516Sbrian fprintf(VarTerm, "AuthKey = %s\n", VarAuthKey); 46329840Sbrian#ifdef HAVE_DES 46429840Sbrian fprintf(VarTerm, "Encrypt = %s\n", VarMSChap ? "MSChap" : "MD5" ); 46529840Sbrian#endif 46631077Sbrian return 0; 4676059Samurai} 4686059Samurai 46928679Sbrianstatic int 47028679SbrianShowVersion() 4716059Samurai{ 47231077Sbrian if (VarTerm) 47331077Sbrian fprintf(VarTerm, "%s - %s \n", VarVersion, VarLocalVersion); 47431077Sbrian return 0; 4756059Samurai} 4766059Samurai 47728679Sbrianstatic int 47828679SbrianShowInitialMRU() 47926326Sbrian{ 48031077Sbrian if (VarTerm) 48131077Sbrian fprintf(VarTerm, " Initial MRU: %ld\n", VarMRU); 48231077Sbrian return 0; 48326326Sbrian} 48426326Sbrian 48528679Sbrianstatic int 48628679SbrianShowPreferredMTU() 48726326Sbrian{ 48831077Sbrian if (VarTerm) 48931077Sbrian if (VarPrefMTU) 49031077Sbrian fprintf(VarTerm, " Preferred MTU: %ld\n", VarPrefMTU); 49131077Sbrian else 49231077Sbrian fprintf(VarTerm, " Preferred MTU: unspecified\n"); 49331077Sbrian return 0; 49426326Sbrian} 49526326Sbrian 49628679Sbrianstatic int 49728679SbrianShowReconnect() 49825067Sbrian{ 49931077Sbrian if (VarTerm) 50031077Sbrian fprintf(VarTerm, " Reconnect Timer: %d, %d tries\n", 50131077Sbrian VarReconnectTimer, VarReconnectTries); 50231077Sbrian return 0; 50325067Sbrian} 50425067Sbrian 50528679Sbrianstatic int 50628679SbrianShowRedial() 50711336Samurai{ 50826516Sbrian if (!VarTerm) 50926516Sbrian return 0; 51026516Sbrian fprintf(VarTerm, " Redial Timer: "); 51111336Samurai 51211336Samurai if (VarRedialTimeout >= 0) { 51326516Sbrian fprintf(VarTerm, " %d seconds, ", VarRedialTimeout); 51428679Sbrian } else { 51526516Sbrian fprintf(VarTerm, " Random 0 - %d seconds, ", REDIAL_PERIOD); 51611336Samurai } 51711336Samurai 51826516Sbrian fprintf(VarTerm, " Redial Next Timer: "); 51924939Sbrian 52024939Sbrian if (VarRedialNextTimeout >= 0) { 52126516Sbrian fprintf(VarTerm, " %d seconds, ", VarRedialNextTimeout); 52228679Sbrian } else { 52326516Sbrian fprintf(VarTerm, " Random 0 - %d seconds, ", REDIAL_PERIOD); 52424939Sbrian } 52524939Sbrian 52611336Samurai if (VarDialTries) 52728679Sbrian fprintf(VarTerm, "%d dial tries", VarDialTries); 52811336Samurai 52926516Sbrian fprintf(VarTerm, "\n"); 53011336Samurai 53131077Sbrian return 0; 53211336Samurai} 53311336Samurai 53426516Sbrian#ifndef NOMSEXT 53528679Sbrianstatic int 53628679SbrianShowMSExt() 53718752Sjkh{ 53831077Sbrian if (VarTerm) { 53931077Sbrian fprintf(VarTerm, " MS PPP extention values \n"); 54031077Sbrian fprintf(VarTerm, " Primary NS : %s\n", inet_ntoa(ns_entries[0])); 54131077Sbrian fprintf(VarTerm, " Secondary NS : %s\n", inet_ntoa(ns_entries[1])); 54231077Sbrian fprintf(VarTerm, " Primary NBNS : %s\n", inet_ntoa(nbns_entries[0])); 54331077Sbrian fprintf(VarTerm, " Secondary NBNS : %s\n", inet_ntoa(nbns_entries[1])); 54431077Sbrian } 54531077Sbrian return 0; 54618752Sjkh} 54728679Sbrian 54826516Sbrian#endif 54918752Sjkh 55030715Sbrianstatic struct cmdtab const ShowCommands[] = { 55128679Sbrian {"afilter", NULL, ShowAfilter, LOCAL_AUTH, 55228679Sbrian "Show keep Alive filters", "show afilter option .."}, 55328679Sbrian {"auth", NULL, ShowAuthKey, LOCAL_AUTH, 55429549Sbrian "Show auth name, key and algorithm", "show auth"}, 55528679Sbrian {"ccp", NULL, ReportCcpStatus, LOCAL_AUTH, 55628679Sbrian "Show CCP status", "show cpp"}, 55728679Sbrian {"compress", NULL, ReportCompress, LOCAL_AUTH, 55829660Sbrian "Show compression statistics", "show compress"}, 55928679Sbrian {"dfilter", NULL, ShowDfilter, LOCAL_AUTH, 56028679Sbrian "Show Demand filters", "show dfilteroption .."}, 56128679Sbrian {"escape", NULL, ShowEscape, LOCAL_AUTH, 56228679Sbrian "Show escape characters", "show escape"}, 56328679Sbrian {"hdlc", NULL, ReportHdlcStatus, LOCAL_AUTH, 56428679Sbrian "Show HDLC error summary", "show hdlc"}, 56528679Sbrian {"ifilter", NULL, ShowIfilter, LOCAL_AUTH, 56628679Sbrian "Show Input filters", "show ifilter option .."}, 56728679Sbrian {"ipcp", NULL, ReportIpcpStatus, LOCAL_AUTH, 56828679Sbrian "Show IPCP status", "show ipcp"}, 56928679Sbrian {"lcp", NULL, ReportLcpStatus, LOCAL_AUTH, 57028679Sbrian "Show LCP status", "show lcp"}, 57128679Sbrian {"loopback", NULL, ShowLoopback, LOCAL_AUTH, 57228679Sbrian "Show current loopback setting", "show loopback"}, 57328679Sbrian {"log", NULL, ShowLogLevel, LOCAL_AUTH, 57428679Sbrian "Show current log level", "show log"}, 57528679Sbrian {"mem", NULL, ShowMemMap, LOCAL_AUTH, 57628679Sbrian "Show memory map", "show mem"}, 57728679Sbrian {"modem", NULL, ShowModemStatus, LOCAL_AUTH, 57828679Sbrian "Show modem setups", "show modem"}, 57928679Sbrian {"mru", NULL, ShowInitialMRU, LOCAL_AUTH, 58028679Sbrian "Show Initial MRU", "show mru"}, 58128679Sbrian {"mtu", NULL, ShowPreferredMTU, LOCAL_AUTH, 58228679Sbrian "Show Preferred MTU", "show mtu"}, 58328679Sbrian {"ofilter", NULL, ShowOfilter, LOCAL_AUTH, 58428679Sbrian "Show Output filters", "show ofilter option .."}, 58528679Sbrian {"proto", NULL, ReportProtStatus, LOCAL_AUTH, 58628679Sbrian "Show protocol summary", "show proto"}, 58728679Sbrian {"reconnect", NULL, ShowReconnect, LOCAL_AUTH, 58828679Sbrian "Show Reconnect timer,tries", "show reconnect"}, 58928679Sbrian {"redial", NULL, ShowRedial, LOCAL_AUTH, 59028679Sbrian "Show Redial timeout value", "show redial"}, 59128679Sbrian {"route", NULL, ShowRoute, LOCAL_AUTH, 59228679Sbrian "Show routing table", "show route"}, 59328679Sbrian {"timeout", NULL, ShowTimeout, LOCAL_AUTH, 59428679Sbrian "Show Idle timeout value", "show timeout"}, 59528679Sbrian {"stopped", NULL, ShowStopped, LOCAL_AUTH, 59628679Sbrian "Show STOPPED timeout value", "show stopped"}, 59726516Sbrian#ifndef NOMSEXT 59828679Sbrian {"msext", NULL, ShowMSExt, LOCAL_AUTH, 59928679Sbrian "Show MS PPP extentions", "show msext"}, 60026516Sbrian#endif 60128679Sbrian {"version", NULL, ShowVersion, LOCAL_NO_AUTH | LOCAL_AUTH, 60228679Sbrian "Show version string", "show version"}, 60328679Sbrian {"help", "?", HelpCommand, LOCAL_NO_AUTH | LOCAL_AUTH, 60428679Sbrian "Display this message", "show help|? [command]", (void *) ShowCommands}, 60528679Sbrian {NULL, NULL, NULL}, 6066059Samurai}; 6076059Samurai 60830715Sbrianstatic struct cmdtab const * 60928679SbrianFindCommand(struct cmdtab const * cmds, char *str, int *pmatch) 6106059Samurai{ 61126516Sbrian int nmatch; 61226516Sbrian int len; 61328679Sbrian struct cmdtab const *found; 6146059Samurai 61526516Sbrian found = NULL; 61626516Sbrian len = strlen(str); 61726516Sbrian nmatch = 0; 6186059Samurai while (cmds->func) { 61925566Sbrian if (cmds->name && strncasecmp(str, cmds->name, len) == 0) { 62026516Sbrian if (cmds->name[len] == '\0') { 62128679Sbrian *pmatch = 1; 62228679Sbrian return cmds; 62326516Sbrian } 6246059Samurai nmatch++; 6256059Samurai found = cmds; 62628679Sbrian } else if (cmds->alias && strncasecmp(str, cmds->alias, len) == 0) { 62726516Sbrian if (cmds->alias[len] == '\0') { 62828679Sbrian *pmatch = 1; 62928679Sbrian return cmds; 63026516Sbrian } 6316059Samurai nmatch++; 6326059Samurai found = cmds; 6336059Samurai } 6346059Samurai cmds++; 6356059Samurai } 6366059Samurai *pmatch = nmatch; 63726516Sbrian return found; 6386059Samurai} 6396059Samurai 64030715Sbrianstatic int 64128679SbrianFindExec(struct cmdtab const * cmdlist, int argc, char **argv) 6426059Samurai{ 64328679Sbrian struct cmdtab const *cmd; 6446059Samurai int val = 1; 6456059Samurai int nmatch; 6466059Samurai 6476059Samurai cmd = FindCommand(cmdlist, *argv, &nmatch); 6486059Samurai if (nmatch > 1) 64926516Sbrian LogPrintf(LogWARN, "%s: Ambiguous command\n", *argv); 65028679Sbrian else if (cmd && (cmd->lauth & VarLocalAuth)) 65129257Sbrian val = (cmd->func) (cmd, argc-1, argv+1, cmd->args); 6526059Samurai else 65326516Sbrian LogPrintf(LogWARN, "%s: Invalid command\n", *argv); 65426516Sbrian 65526516Sbrian if (val == -1) 65626516Sbrian LogPrintf(LogWARN, "Usage: %s\n", cmd->syntax); 65728679Sbrian else if (val) 65826516Sbrian LogPrintf(LogCOMMAND, "%s: Failed %d\n", *argv, val); 65926516Sbrian 66026516Sbrian return val; 6616059Samurai} 6626059Samurai 66318885Sjkhint aft_cmd = 1; 66418885Sjkh 6656059Samuraivoid 66618885SjkhPrompt() 6676059Samurai{ 6686735Samurai char *pconnect, *pauth; 6696735Samurai 67026516Sbrian if (!(mode & MODE_INTER) || !VarTerm || TermMode) 6716059Samurai return; 6726735Samurai 67318885Sjkh if (!aft_cmd) 67426516Sbrian fprintf(VarTerm, "\n"); 67518885Sjkh else 67618885Sjkh aft_cmd = 0; 6776735Samurai 67828679Sbrian if (VarLocalAuth == LOCAL_AUTH) 6796735Samurai pauth = " ON "; 6806735Samurai else 6816735Samurai pauth = " on "; 6826059Samurai if (IpcpFsm.state == ST_OPENED && phase == PHASE_NETWORK) 6836735Samurai pconnect = "PPP"; 6846059Samurai else 6856735Samurai pconnect = "ppp"; 68626516Sbrian fprintf(VarTerm, "%s%s%s> ", pconnect, pauth, VarShortHost); 68726516Sbrian fflush(VarTerm); 6886059Samurai} 6896059Samurai 6906059Samuraivoid 69128679SbrianDecodeCommand(char *buff, int nb, int prompt) 6926059Samurai{ 6936059Samurai char *vector[20]; 6946059Samurai char **argv; 69526516Sbrian int argc; 6966059Samurai char *cp; 6976059Samurai 6986059Samurai if (nb > 0) { 6996059Samurai cp = buff + strcspn(buff, "\r\n"); 7006059Samurai if (cp) 7016059Samurai *cp = '\0'; 70226516Sbrian argc = MakeArgs(buff, vector, VECSIZE(vector)); 70326516Sbrian argv = vector; 7046059Samurai 70526516Sbrian if (argc > 0) 70626516Sbrian FindExec(Commands, argc, argv); 7076059Samurai } 70826516Sbrian if (prompt) 70925630Sbrian Prompt(); 7106059Samurai} 7116059Samurai 7126059Samuraistatic int 71328679SbrianShowCommand(struct cmdtab const * list, int argc, char **argv) 7146059Samurai{ 7156059Samurai if (argc > 0) 71626516Sbrian FindExec(ShowCommands, argc, argv); 71726516Sbrian else if (VarTerm) 71826516Sbrian fprintf(VarTerm, "Use ``show ?'' to get a list.\n"); 7196059Samurai else 72026516Sbrian LogPrintf(LogWARN, "show command must have arguments\n"); 72126516Sbrian 72226516Sbrian return 0; 7236059Samurai} 7246059Samurai 7256059Samuraistatic int 72628679SbrianTerminalCommand(struct cmdtab const * list, int argc, char **argv) 7276059Samurai{ 7286059Samurai if (LcpFsm.state > ST_CLOSED) { 72926516Sbrian if (VarTerm) 73026516Sbrian fprintf(VarTerm, "LCP state is [%s]\n", StateNames[LcpFsm.state]); 73126516Sbrian return 1; 7326059Samurai } 73330913Sbrian if (!IsInteractive(1)) 73428679Sbrian return (1); 73531034Sbrian if (OpenModem() < 0) { 73626516Sbrian if (VarTerm) 73726516Sbrian fprintf(VarTerm, "Failed to open modem.\n"); 73828679Sbrian return (1); 7396059Samurai } 74026516Sbrian if (VarTerm) { 74126516Sbrian fprintf(VarTerm, "Enter to terminal mode.\n"); 74226516Sbrian fprintf(VarTerm, "Type `~?' for help.\n"); 74326516Sbrian } 7446059Samurai TtyTermMode(); 74528679Sbrian return (0); 7466059Samurai} 7476059Samurai 7486059Samuraistatic int 74928679SbrianQuitCommand(struct cmdtab const * list, int argc, char **argv) 7506059Samurai{ 75126516Sbrian FILE *oVarTerm; 75226516Sbrian 75328679Sbrian if (mode & (MODE_DIRECT | MODE_DEDICATED | MODE_AUTO)) { 75429083Sbrian if (argc > 0 && !strcasecmp(*argv, "all") && (VarLocalAuth & LOCAL_AUTH)) { 75518911Ssos mode &= ~MODE_INTER; 75626516Sbrian oVarTerm = VarTerm; 75726516Sbrian VarTerm = 0; 75826516Sbrian if (oVarTerm && oVarTerm != stdout) 75928679Sbrian fclose(oVarTerm); 76029083Sbrian Cleanup(EX_NORMAL); 76129083Sbrian } else if (VarTerm) { 76226516Sbrian LogPrintf(LogPHASE, "Client connection closed.\n"); 7636735Samurai VarLocalAuth = LOCAL_NO_AUTH; 76426516Sbrian mode &= ~MODE_INTER; 76526516Sbrian oVarTerm = VarTerm; 76626516Sbrian VarTerm = 0; 76726516Sbrian if (oVarTerm && oVarTerm != stdout) 76828679Sbrian fclose(oVarTerm); 7696059Samurai close(netfd); 7706059Samurai netfd = -1; 7716059Samurai } 7726059Samurai } else 7736059Samurai Cleanup(EX_NORMAL); 77426516Sbrian 77526516Sbrian return 0; 7766059Samurai} 7776059Samurai 7786059Samuraistatic int 77928679SbrianCloseCommand(struct cmdtab const * list, int argc, char **argv) 7806059Samurai{ 78126098Sbrian reconnect(RECON_FALSE); 7826059Samurai LcpClose(); 78325908Sbrian if (mode & MODE_BACKGROUND) 78428679Sbrian Cleanup(EX_NORMAL); 78526516Sbrian return 0; 7866059Samurai} 7876059Samurai 7886059Samuraistatic int 78928679SbrianDownCommand(struct cmdtab const * list, int argc, char **argv) 7906059Samurai{ 7916059Samurai LcpDown(); 79226516Sbrian return 0; 7936059Samurai} 7946059Samurai 79525067Sbrianstatic int 79628679SbrianSetModemSpeed(struct cmdtab const * list, int argc, char **argv) 7976059Samurai{ 7986059Samurai int speed; 7996059Samurai 8006059Samurai if (argc > 0) { 80129521Sbrian if (strcasecmp(*argv, "sync") == 0) { 8026735Samurai VarSpeed = 0; 80326516Sbrian return 0; 8046735Samurai } 8056059Samurai speed = atoi(*argv); 8066735Samurai if (IntToSpeed(speed) != B0) { 8076735Samurai VarSpeed = speed; 80826516Sbrian return 0; 8096059Samurai } 81026516Sbrian LogPrintf(LogWARN, "%s: Invalid speed\n", *argv); 8116059Samurai } 81226516Sbrian return -1; 8136059Samurai} 8146059Samurai 81525067Sbrianstatic int 81628679SbrianSetReconnect(struct cmdtab const * list, int argc, char **argv) 81711336Samurai{ 81825067Sbrian if (argc == 2) { 81925067Sbrian VarReconnectTimer = atoi(argv[0]); 82025067Sbrian VarReconnectTries = atoi(argv[1]); 82126516Sbrian return 0; 82226516Sbrian } 82326516Sbrian return -1; 82425067Sbrian} 82525067Sbrian 82625067Sbrianstatic int 82728679SbrianSetRedialTimeout(struct cmdtab const * list, int argc, char **argv) 82825067Sbrian{ 82911336Samurai int timeout; 83011336Samurai int tries; 83124939Sbrian char *dot; 83211336Samurai 83328679Sbrian if (argc == 1 || argc == 2) { 83424939Sbrian if (strncasecmp(argv[0], "random", 6) == 0 && 83524939Sbrian (argv[0][6] == '\0' || argv[0][6] == '.')) { 83611336Samurai VarRedialTimeout = -1; 83730715Sbrian randinit(); 83826516Sbrian } else { 83911336Samurai timeout = atoi(argv[0]); 84011336Samurai 84126516Sbrian if (timeout >= 0) 84211336Samurai VarRedialTimeout = timeout; 84311336Samurai else { 84426516Sbrian LogPrintf(LogWARN, "Invalid redial timeout\n"); 84528679Sbrian return -1; 84611336Samurai } 84711336Samurai } 84824939Sbrian 84930715Sbrian dot = strchr(argv[0], '.'); 85024939Sbrian if (dot) { 85124939Sbrian if (strcasecmp(++dot, "random") == 0) { 85228679Sbrian VarRedialNextTimeout = -1; 85330715Sbrian randinit(); 85428679Sbrian } else { 85528679Sbrian timeout = atoi(dot); 85628679Sbrian if (timeout >= 0) 85728679Sbrian VarRedialNextTimeout = timeout; 85828679Sbrian else { 85928679Sbrian LogPrintf(LogWARN, "Invalid next redial timeout\n"); 86026516Sbrian return -1; 86128679Sbrian } 86224939Sbrian } 86328679Sbrian } else 86428679Sbrian VarRedialNextTimeout = NEXT_REDIAL_PERIOD; /* Default next timeout */ 86524939Sbrian 86611336Samurai if (argc == 2) { 86711336Samurai tries = atoi(argv[1]); 86811336Samurai 86911336Samurai if (tries >= 0) { 87026516Sbrian VarDialTries = tries; 87126516Sbrian } else { 87226516Sbrian LogPrintf(LogWARN, "Invalid retry value\n"); 87326516Sbrian return 1; 87411336Samurai } 87511336Samurai } 87626516Sbrian return 0; 87711336Samurai } 87826516Sbrian return -1; 87911336Samurai} 88011336Samurai 88125067Sbrianstatic int 88228679SbrianSetStoppedTimeout(struct cmdtab const * list, int argc, char **argv) 88328327Sbrian{ 88428461Sbrian LcpFsm.StoppedTimer.load = 0; 88528461Sbrian IpcpFsm.StoppedTimer.load = 0; 88628461Sbrian CcpFsm.StoppedTimer.load = 0; 88728461Sbrian if (argc <= 3) { 88828461Sbrian if (argc > 0) { 88928461Sbrian LcpFsm.StoppedTimer.load = atoi(argv[0]) * SECTICKS; 89028461Sbrian if (argc > 1) { 89128679Sbrian IpcpFsm.StoppedTimer.load = atoi(argv[1]) * SECTICKS; 89228679Sbrian if (argc > 2) 89328679Sbrian CcpFsm.StoppedTimer.load = atoi(argv[2]) * SECTICKS; 89428461Sbrian } 89528461Sbrian } 89628327Sbrian return 0; 89728327Sbrian } 89828327Sbrian return -1; 89928327Sbrian} 90028327Sbrian 90128327Sbrianstatic int 90228679SbrianSetServer(struct cmdtab const * list, int argc, char **argv) 90326940Sbrian{ 90426940Sbrian int res = -1; 90526940Sbrian 90627089Sbrian if (argc > 0 && argc < 3) 90726940Sbrian if (strcasecmp(argv[0], "none") == 0) { 90826940Sbrian ServerClose(); 90926940Sbrian LogPrintf(LogPHASE, "Disabling server port.\n"); 91026940Sbrian res = 0; 91127089Sbrian } else if (*argv[0] == '/') { 91227089Sbrian mode_t mask; 91328679Sbrian 91427089Sbrian umask(mask = umask(0)); 91527089Sbrian if (argc == 2) { 91628679Sbrian unsigned m; 91728679Sbrian 91828679Sbrian if (sscanf(argv[1], "%o", &m) == 1) 91928679Sbrian mask = m; 92027089Sbrian } 92127089Sbrian res = ServerLocalOpen(argv[0], mask); 92227346Sbrian } else { 92327346Sbrian int port; 92428679Sbrian 92527346Sbrian if (strspn(argv[0], "0123456789") != strlen(argv[0])) { 92628679Sbrian struct servent *s; 92728679Sbrian 92828679Sbrian if ((s = getservbyname(argv[0], "tcp")) == NULL) { 92928679Sbrian port = 0; 93028679Sbrian LogPrintf(LogWARN, "%s: Invalid port or service\n", argv[0]); 93128679Sbrian } else 93228679Sbrian port = ntohs(s->s_port); 93327346Sbrian } else 93428679Sbrian port = atoi(argv[0]); 93527346Sbrian if (port) 93628679Sbrian res = ServerTcpOpen(port); 93727346Sbrian } 93826940Sbrian 93926940Sbrian return res; 94026940Sbrian} 94126940Sbrian 94226940Sbrianstatic int 94328679SbrianSetModemParity(struct cmdtab const * list, int argc, char **argv) 9446059Samurai{ 94526845Sbrian return argc > 0 ? ChangeParity(*argv) : -1; 9466059Samurai} 9476059Samurai 9486059Samuraistatic int 94928679SbrianSetLogLevel(struct cmdtab const * list, int argc, char **argv) 9506059Samurai{ 95126516Sbrian int i; 95226516Sbrian int res; 95326516Sbrian char *arg; 95430913Sbrian void (*Discard)(int), (*Keep)(int); 95530913Sbrian void (*DiscardAll)(void); 9566059Samurai 95726516Sbrian res = 0; 95830913Sbrian if (strcasecmp(argv[0], "local")) { 95930913Sbrian Discard = LogDiscard; 96030913Sbrian Keep = LogKeep; 96130913Sbrian DiscardAll = LogDiscardAll; 96230913Sbrian } else { 96330913Sbrian argc--; 96430913Sbrian argv++; 96530913Sbrian Discard = LogDiscardLocal; 96630913Sbrian Keep = LogKeepLocal; 96730913Sbrian DiscardAll = LogDiscardAllLocal; 96830913Sbrian } 96930913Sbrian 97026516Sbrian if (argc == 0 || (argv[0][0] != '+' && argv[0][0] != '-')) 97130913Sbrian (*DiscardAll)(); 97226516Sbrian while (argc--) { 97326516Sbrian arg = **argv == '+' || **argv == '-' ? *argv + 1 : *argv; 97426516Sbrian for (i = LogMIN; i <= LogMAX; i++) 97526516Sbrian if (strcasecmp(arg, LogName(i)) == 0) { 97628679Sbrian if (**argv == '-') 97730913Sbrian (*Discard)(i); 97828679Sbrian else 97930913Sbrian (*Keep)(i); 9806059Samurai break; 9816059Samurai } 98226516Sbrian if (i > LogMAX) { 98326516Sbrian LogPrintf(LogWARN, "%s: Invalid log value\n", arg); 98426516Sbrian res = -1; 9856059Samurai } 98626516Sbrian argv++; 9876059Samurai } 98826516Sbrian return res; 9896059Samurai} 9906059Samurai 9916059Samuraistatic int 99228679SbrianSetEscape(struct cmdtab const * list, int argc, char **argv) 9936059Samurai{ 9946059Samurai int code; 9956059Samurai 9966059Samurai for (code = 0; code < 33; code++) 9976059Samurai EscMap[code] = 0; 9986059Samurai while (argc-- > 0) { 9996059Samurai sscanf(*argv++, "%x", &code); 10006059Samurai code &= 0xff; 100128679Sbrian EscMap[code >> 3] |= (1 << (code & 7)); 10026059Samurai EscMap[32] = 1; 10036059Samurai } 100426516Sbrian return 0; 10056059Samurai} 10066059Samurai 10076059Samuraistatic int 100828679SbrianSetInitialMRU(struct cmdtab const * list, int argc, char **argv) 10096059Samurai{ 101026326Sbrian long mru; 101126516Sbrian char *err; 10126059Samurai 10136059Samurai if (argc > 0) { 101426326Sbrian mru = atol(*argv); 101526326Sbrian if (mru < MIN_MRU) 101626516Sbrian err = "Given MRU value (%ld) is too small.\n"; 10176059Samurai else if (mru > MAX_MRU) 101826516Sbrian err = "Given MRU value (%ld) is too big.\n"; 101926516Sbrian else { 10206059Samurai VarMRU = mru; 102126516Sbrian return 0; 102226516Sbrian } 102326516Sbrian LogPrintf(LogWARN, err, mru); 102426516Sbrian } 102526516Sbrian return -1; 10266059Samurai} 10276059Samurai 10286059Samuraistatic int 102928679SbrianSetPreferredMTU(struct cmdtab const * list, int argc, char **argv) 103026326Sbrian{ 103126326Sbrian long mtu; 103226516Sbrian char *err; 103326326Sbrian 103426326Sbrian if (argc > 0) { 103526326Sbrian mtu = atol(*argv); 103626516Sbrian if (mtu == 0) { 103726326Sbrian VarPrefMTU = 0; 103826516Sbrian return 0; 103926516Sbrian } else if (mtu < MIN_MTU) 104026516Sbrian err = "Given MTU value (%ld) is too small.\n"; 104126326Sbrian else if (mtu > MAX_MTU) 104226516Sbrian err = "Given MTU value (%ld) is too big.\n"; 104326516Sbrian else { 104426326Sbrian VarPrefMTU = mtu; 104526516Sbrian return 0; 104626516Sbrian } 104726516Sbrian LogPrintf(LogWARN, err, mtu); 104826516Sbrian } 104926516Sbrian return -1; 105026326Sbrian} 105126326Sbrian 105226326Sbrianstatic int 105328679SbrianSetIdleTimeout(struct cmdtab const * list, int argc, char **argv) 10546059Samurai{ 10556059Samurai if (argc-- > 0) { 10566059Samurai VarIdleTimeout = atoi(*argv++); 105728679Sbrian UpdateIdleTimer(); /* If we're connected, restart the idle timer */ 10586735Samurai if (argc-- > 0) { 10596735Samurai VarLqrTimeout = atoi(*argv++); 10606735Samurai if (VarLqrTimeout < 1) 10616735Samurai VarLqrTimeout = 30; 10626735Samurai if (argc > 0) { 10636735Samurai VarRetryTimeout = atoi(*argv); 10646735Samurai if (VarRetryTimeout < 1 || VarRetryTimeout > 10) 10656735Samurai VarRetryTimeout = 3; 10666735Samurai } 10676735Samurai } 106826516Sbrian return 0; 10696059Samurai } 107026516Sbrian return -1; 10716059Samurai} 10726059Samurai 107330715Sbrianstatic struct in_addr 107428679SbrianGetIpAddr(char *cp) 10756059Samurai{ 10766059Samurai struct hostent *hp; 10776059Samurai struct in_addr ipaddr; 10786059Samurai 10796059Samurai hp = gethostbyname(cp); 10806059Samurai if (hp && hp->h_addrtype == AF_INET) 108130715Sbrian memcpy(&ipaddr, hp->h_addr, hp->h_length); 10826059Samurai else if (inet_aton(cp, &ipaddr) == 0) 10836059Samurai ipaddr.s_addr = 0; 108428679Sbrian return (ipaddr); 10856059Samurai} 10866059Samurai 10876059Samuraistatic int 108828679SbrianSetInterfaceAddr(struct cmdtab const * list, int argc, char **argv) 10896059Samurai{ 109028394Sbrian DefMyAddress.ipaddr.s_addr = DefHisAddress.ipaddr.s_addr = 0L; 10916059Samurai 109226516Sbrian if (argc > 4) 109328679Sbrian return -1; 109426516Sbrian 109528394Sbrian HaveTriggerAddress = 0; 109628394Sbrian ifnetmask.s_addr = 0; 109728394Sbrian 10986059Samurai if (argc > 0) { 109925630Sbrian if (ParseAddr(argc, argv++, 110028679Sbrian &DefMyAddress.ipaddr, 110128679Sbrian &DefMyAddress.mask, 110228679Sbrian &DefMyAddress.width) == 0) 110328679Sbrian return 1; 11046059Samurai if (--argc > 0) { 110525630Sbrian if (ParseAddr(argc, argv++, 110625630Sbrian &DefHisAddress.ipaddr, 110725630Sbrian &DefHisAddress.mask, 110825630Sbrian &DefHisAddress.width) == 0) 110928679Sbrian return 2; 11106059Samurai if (--argc > 0) { 111128679Sbrian ifnetmask = GetIpAddr(*argv); 111228679Sbrian if (--argc > 0) { 111328679Sbrian TriggerAddress = GetIpAddr(*argv); 111428679Sbrian HaveTriggerAddress = 1; 11159440Samurai } 11166059Samurai } 11176059Samurai } 11186059Samurai } 111928394Sbrian 11206059Samurai /* 11216059Samurai * For backwards compatibility, 0.0.0.0 means any address. 11226059Samurai */ 11236059Samurai if (DefMyAddress.ipaddr.s_addr == 0) { 11246059Samurai DefMyAddress.mask.s_addr = 0; 11256059Samurai DefMyAddress.width = 0; 11266059Samurai } 11276059Samurai if (DefHisAddress.ipaddr.s_addr == 0) { 11286059Samurai DefHisAddress.mask.s_addr = 0; 11296059Samurai DefHisAddress.width = 0; 11306059Samurai } 113128537Sbrian IpcpInfo.want_ipaddr.s_addr = DefMyAddress.ipaddr.s_addr; 113228537Sbrian IpcpInfo.his_ipaddr.s_addr = DefHisAddress.ipaddr.s_addr; 113328537Sbrian 11346735Samurai if ((mode & MODE_AUTO) || 113528679Sbrian ((mode & MODE_DEDICATED) && dstsystem)) { 113625630Sbrian if (OsSetIpaddress(DefMyAddress.ipaddr, DefHisAddress.ipaddr, ifnetmask) < 0) 113728679Sbrian return 4; 11386059Samurai } 113926516Sbrian return 0; 11406059Samurai} 11416059Samurai 114226516Sbrian#ifndef NOMSEXT 11436059Samurai 114430715Sbrianstatic void 114528679SbrianSetMSEXT(struct in_addr * pri_addr, 114628679Sbrian struct in_addr * sec_addr, 114728679Sbrian int argc, 114828679Sbrian char **argv) 114918752Sjkh{ 115018752Sjkh int dummyint; 115118752Sjkh struct in_addr dummyaddr; 115218752Sjkh 115318752Sjkh pri_addr->s_addr = sec_addr->s_addr = 0L; 115418752Sjkh 115528679Sbrian if (argc > 0) { 115618752Sjkh ParseAddr(argc, argv++, pri_addr, &dummyaddr, &dummyint); 115728679Sbrian if (--argc > 0) 115818752Sjkh ParseAddr(argc, argv++, sec_addr, &dummyaddr, &dummyint); 115918752Sjkh else 116018752Sjkh sec_addr->s_addr = pri_addr->s_addr; 116118752Sjkh } 116218752Sjkh 116328679Sbrian /* 116428679Sbrian * if the primary/secondary ns entries are 0.0.0.0 we should set them to 116528679Sbrian * either the localhost's ip, or the values in /etc/resolv.conf ?? 116628679Sbrian * 116728679Sbrian * up to you if you want to implement this... 116828679Sbrian */ 116918752Sjkh 117018752Sjkh} 117118752Sjkh 117218752Sjkhstatic int 117328679SbrianSetNS(struct cmdtab const * list, int argc, char **argv) 117418752Sjkh{ 117518752Sjkh SetMSEXT(&ns_entries[0], &ns_entries[1], argc, argv); 117626516Sbrian return 0; 117718752Sjkh} 117818752Sjkh 117918752Sjkhstatic int 118028679SbrianSetNBNS(struct cmdtab const * list, int argc, char **argv) 118118752Sjkh{ 118218752Sjkh SetMSEXT(&nbns_entries[0], &nbns_entries[1], argc, argv); 118326516Sbrian return 0; 118418752Sjkh} 118518752Sjkh 118628679Sbrian#endif /* MS_EXT */ 118718752Sjkh 118829696Sbrianint 118928679SbrianSetVariable(struct cmdtab const * list, int argc, char **argv, int param) 11906059Samurai{ 11916059Samurai u_long map; 119226551Sbrian char *arg; 11936059Samurai 119426551Sbrian if (argc > 0) 119526551Sbrian arg = *argv; 119626551Sbrian else 119726551Sbrian arg = ""; 119826551Sbrian 119926551Sbrian switch (param) { 120028679Sbrian case VAR_AUTHKEY: 120128679Sbrian strncpy(VarAuthKey, arg, sizeof(VarAuthKey) - 1); 120228679Sbrian VarAuthKey[sizeof(VarAuthKey) - 1] = '\0'; 120328679Sbrian break; 120428679Sbrian case VAR_AUTHNAME: 120528679Sbrian strncpy(VarAuthName, arg, sizeof(VarAuthName) - 1); 120628679Sbrian VarAuthName[sizeof(VarAuthName) - 1] = '\0'; 120728679Sbrian break; 120828679Sbrian case VAR_DIAL: 120928679Sbrian strncpy(VarDialScript, arg, sizeof(VarDialScript) - 1); 121028679Sbrian VarDialScript[sizeof(VarDialScript) - 1] = '\0'; 121128679Sbrian break; 121228679Sbrian case VAR_LOGIN: 121328679Sbrian strncpy(VarLoginScript, arg, sizeof(VarLoginScript) - 1); 121428679Sbrian VarLoginScript[sizeof(VarLoginScript) - 1] = '\0'; 121528679Sbrian break; 121628679Sbrian case VAR_DEVICE: 121729696Sbrian if (modem != -1) 121829696Sbrian LogPrintf(LogWARN, "Cannot change device to \"%s\" when \"%s\" is open\n", 121929696Sbrian arg, VarDevice); 122029696Sbrian else { 122129696Sbrian strncpy(VarDevice, arg, sizeof(VarDevice) - 1); 122229696Sbrian VarDevice[sizeof(VarDevice) - 1] = '\0'; 122330715Sbrian VarBaseDevice = strrchr(VarDevice, '/'); 122429696Sbrian VarBaseDevice = VarBaseDevice ? VarBaseDevice + 1 : ""; 122529696Sbrian } 122628679Sbrian break; 122728679Sbrian case VAR_ACCMAP: 122828679Sbrian sscanf(arg, "%lx", &map); 122928679Sbrian VarAccmap = map; 123028679Sbrian break; 123128679Sbrian case VAR_PHONE: 123228679Sbrian strncpy(VarPhoneList, arg, sizeof(VarPhoneList) - 1); 123328679Sbrian VarPhoneList[sizeof(VarPhoneList) - 1] = '\0'; 123428679Sbrian strcpy(VarPhoneCopy, VarPhoneList); 123528679Sbrian VarNextPhone = VarPhoneCopy; 123628679Sbrian break; 123728679Sbrian case VAR_HANGUP: 123828679Sbrian strncpy(VarHangupScript, arg, sizeof(VarHangupScript) - 1); 123928679Sbrian VarHangupScript[sizeof(VarHangupScript) - 1] = '\0'; 124028679Sbrian break; 124129840Sbrian#ifdef HAVE_DES 124229549Sbrian case VAR_ENC: 124329840Sbrian VarMSChap = !strcasecmp(arg, "mschap"); 124429549Sbrian break; 124529840Sbrian#endif 12466059Samurai } 124726516Sbrian return 0; 12486059Samurai} 12496059Samurai 125028679Sbrianstatic int 125128679SbrianSetCtsRts(struct cmdtab const * list, int argc, char **argv) 125220812Sjkh{ 125320812Sjkh if (argc > 0) { 125420812Sjkh if (strcmp(*argv, "on") == 0) 125530715Sbrian VarCtsRts = 1; 125620812Sjkh else if (strcmp(*argv, "off") == 0) 125730715Sbrian VarCtsRts = 0; 125820812Sjkh else 125926516Sbrian return -1; 126026516Sbrian return 0; 126120812Sjkh } 126226516Sbrian return -1; 126320812Sjkh} 126420812Sjkh 126520812Sjkh 126628679Sbrianstatic int 126728679SbrianSetOpenMode(struct cmdtab const * list, int argc, char **argv) 12686059Samurai{ 12696059Samurai if (argc > 0) { 12706059Samurai if (strcmp(*argv, "active") == 0) 12716059Samurai VarOpenMode = OPEN_ACTIVE; 12726059Samurai else if (strcmp(*argv, "passive") == 0) 12736059Samurai VarOpenMode = OPEN_PASSIVE; 12746059Samurai else 127526516Sbrian return -1; 127626516Sbrian return 0; 12776059Samurai } 127826516Sbrian return -1; 12796059Samurai} 12806059Samurai 128130715Sbrianstatic struct cmdtab const SetCommands[] = { 128228679Sbrian {"accmap", NULL, SetVariable, LOCAL_AUTH, 128328679Sbrian "Set accmap value", "set accmap hex-value", (void *) VAR_ACCMAP}, 128428679Sbrian {"afilter", NULL, SetAfilter, LOCAL_AUTH, 128528679Sbrian "Set keep Alive filter", "set afilter ..."}, 128628679Sbrian {"authkey", "key", SetVariable, LOCAL_AUTH, 128728679Sbrian "Set authentication key", "set authkey|key key", (void *) VAR_AUTHKEY}, 128828679Sbrian {"authname", NULL, SetVariable, LOCAL_AUTH, 128928679Sbrian "Set authentication name", "set authname name", (void *) VAR_AUTHNAME}, 129028679Sbrian {"ctsrts", NULL, SetCtsRts, LOCAL_AUTH, 129128679Sbrian "Use CTS/RTS modem signalling", "set ctsrts [on|off]"}, 129228679Sbrian {"device", "line", SetVariable, LOCAL_AUTH, 129328679Sbrian "Set modem device name", "set device|line device-name", (void *) VAR_DEVICE}, 129428679Sbrian {"dfilter", NULL, SetDfilter, LOCAL_AUTH, 129528679Sbrian "Set demand filter", "set dfilter ..."}, 129628679Sbrian {"dial", NULL, SetVariable, LOCAL_AUTH, 129728679Sbrian "Set dialing script", "set dial chat-script", (void *) VAR_DIAL}, 129829840Sbrian#ifdef HAVE_DES 129929549Sbrian {"encrypt", NULL, SetVariable, LOCAL_AUTH, 130029840Sbrian "Set CHAP encryption algorithm", "set encrypt MSChap|MD5", (void *) VAR_ENC}, 130129840Sbrian#endif 130228679Sbrian {"escape", NULL, SetEscape, LOCAL_AUTH, 130328679Sbrian "Set escape characters", "set escape hex-digit ..."}, 130428679Sbrian {"hangup", NULL, SetVariable, LOCAL_AUTH, 130528679Sbrian "Set hangup script", "set hangup chat-script", (void *) VAR_HANGUP}, 130628679Sbrian {"ifaddr", NULL, SetInterfaceAddr, LOCAL_AUTH, 130728679Sbrian "Set destination address", "set ifaddr [src-addr [dst-addr [netmask [trg-addr]]]]"}, 130828679Sbrian {"ifilter", NULL, SetIfilter, LOCAL_AUTH, 130928679Sbrian "Set input filter", "set ifilter ..."}, 131028679Sbrian {"loopback", NULL, SetLoopback, LOCAL_AUTH, 131128679Sbrian "Set loopback facility", "set loopback on|off"}, 131228679Sbrian {"log", NULL, SetLogLevel, LOCAL_AUTH, 131330913Sbrian "Set log level", "set log [local] [+|-]value..."}, 131428679Sbrian {"login", NULL, SetVariable, LOCAL_AUTH, 131528679Sbrian "Set login script", "set login chat-script", (void *) VAR_LOGIN}, 131628679Sbrian {"mru", NULL, SetInitialMRU, LOCAL_AUTH, 131728679Sbrian "Set Initial MRU value", "set mru value"}, 131828679Sbrian {"mtu", NULL, SetPreferredMTU, LOCAL_AUTH, 131928679Sbrian "Set Preferred MTU value", "set mtu value"}, 132028679Sbrian {"ofilter", NULL, SetOfilter, LOCAL_AUTH, 132128679Sbrian "Set output filter", "set ofilter ..."}, 132228679Sbrian {"openmode", NULL, SetOpenMode, LOCAL_AUTH, 132328679Sbrian "Set open mode", "set openmode [active|passive]"}, 132428679Sbrian {"parity", NULL, SetModemParity, LOCAL_AUTH, 132528679Sbrian "Set modem parity", "set parity [odd|even|none]"}, 132628679Sbrian {"phone", NULL, SetVariable, LOCAL_AUTH, 132728679Sbrian "Set telephone number(s)", "set phone phone1[:phone2[...]]", (void *) VAR_PHONE}, 132828679Sbrian {"reconnect", NULL, SetReconnect, LOCAL_AUTH, 132928679Sbrian "Set Reconnect timeout", "set reconnect value ntries"}, 133028679Sbrian {"redial", NULL, SetRedialTimeout, LOCAL_AUTH, 133128679Sbrian "Set Redial timeout", "set redial value|random[.value|random] [dial_attempts]"}, 133228679Sbrian {"stopped", NULL, SetStoppedTimeout, LOCAL_AUTH, 133328679Sbrian "Set STOPPED timeouts", "set stopped [LCPseconds [IPCPseconds [CCPseconds]]]"}, 133428679Sbrian {"server", "socket", SetServer, LOCAL_AUTH, 133528679Sbrian "Set server port", "set server|socket TcpPort|LocalName|none [mask]"}, 133628679Sbrian {"speed", NULL, SetModemSpeed, LOCAL_AUTH, 133728679Sbrian "Set modem speed", "set speed value"}, 133828679Sbrian {"timeout", NULL, SetIdleTimeout, LOCAL_AUTH, 133928679Sbrian "Set Idle timeout", "set timeout value"}, 134026516Sbrian#ifndef NOMSEXT 134128679Sbrian {"ns", NULL, SetNS, LOCAL_AUTH, 134228679Sbrian "Set NameServer", "set ns pri-addr [sec-addr]"}, 134328679Sbrian {"nbns", NULL, SetNBNS, LOCAL_AUTH, 134428679Sbrian "Set NetBIOS NameServer", "set nbns pri-addr [sec-addr]"}, 134526516Sbrian#endif 134628679Sbrian {"help", "?", HelpCommand, LOCAL_AUTH | LOCAL_NO_AUTH, 134728679Sbrian "Display this message", "set help|? [command]", (void *) SetCommands}, 134828679Sbrian {NULL, NULL, NULL}, 13496059Samurai}; 13506059Samurai 13516059Samuraistatic int 135228679SbrianSetCommand(struct cmdtab const * list, int argc, char **argv) 13536059Samurai{ 13546059Samurai if (argc > 0) 135526516Sbrian FindExec(SetCommands, argc, argv); 135626516Sbrian else if (VarTerm) 135726516Sbrian fprintf(VarTerm, "Use `set ?' to get a list or `set ? <var>' for" 135826516Sbrian " syntax help.\n"); 13596059Samurai else 136026516Sbrian LogPrintf(LogWARN, "set command must have arguments\n"); 136126516Sbrian 136226516Sbrian return 0; 13636059Samurai} 13646059Samurai 13656059Samurai 13666059Samuraistatic int 136728679SbrianAddCommand(struct cmdtab const * list, int argc, char **argv) 13686059Samurai{ 13696059Samurai struct in_addr dest, gateway, netmask; 13706059Samurai 13716059Samurai if (argc == 3) { 137227011Sbrian if (strcasecmp(argv[0], "MYADDR") == 0) 137327011Sbrian dest = IpcpInfo.want_ipaddr; 137427011Sbrian else 137527011Sbrian dest = GetIpAddr(argv[0]); 13766059Samurai netmask = GetIpAddr(argv[1]); 137725566Sbrian if (strcasecmp(argv[2], "HISADDR") == 0) 13786059Samurai gateway = IpcpInfo.his_ipaddr; 13796059Samurai else 13806059Samurai gateway = GetIpAddr(argv[2]); 13816059Samurai OsSetRoute(RTM_ADD, dest, gateway, netmask); 138226516Sbrian return 0; 13836059Samurai } 138426516Sbrian return -1; 13856059Samurai} 13866059Samurai 13876059Samuraistatic int 138828679SbrianDeleteCommand(struct cmdtab const * list, int argc, char **argv) 13896059Samurai{ 13906059Samurai struct in_addr dest, gateway, netmask; 13916059Samurai 139226591Sbrian if (argc == 1 && strcasecmp(argv[0], "all") == 0) 139326591Sbrian DeleteIfRoutes(0); 139426591Sbrian else if (argc > 0 && argc < 4) { 139527011Sbrian if (strcasecmp(argv[0], "MYADDR") == 0) 139627011Sbrian dest = IpcpInfo.want_ipaddr; 139727011Sbrian else 139827011Sbrian dest = GetIpAddr(argv[0]); 139926591Sbrian netmask.s_addr = INADDR_ANY; 140026591Sbrian if (argc > 1) { 140126591Sbrian if (strcasecmp(argv[1], "HISADDR") == 0) 140228679Sbrian gateway = IpcpInfo.his_ipaddr; 140326591Sbrian else 140428679Sbrian gateway = GetIpAddr(argv[1]); 140526591Sbrian if (argc == 3) { 140628679Sbrian if (inet_aton(argv[2], &netmask) == 0) { 140726591Sbrian LogPrintf(LogWARN, "Bad netmask value.\n"); 140826591Sbrian return -1; 140928679Sbrian } 14106059Samurai } 141126591Sbrian } else 141226591Sbrian gateway.s_addr = INADDR_ANY; 14136059Samurai OsSetRoute(RTM_DELETE, dest, gateway, netmask); 141426516Sbrian } else 141526516Sbrian return -1; 141626516Sbrian 141726516Sbrian return 0; 14186059Samurai} 14196059Samurai 142026031Sbrianstatic struct cmdtab const AliasCommands[] = 142126031Sbrian{ 142228679Sbrian {"enable", NULL, AliasEnable, LOCAL_AUTH, 142328679Sbrian "enable IP aliasing", "alias enable [yes|no]"}, 142428679Sbrian {"port", NULL, AliasRedirectPort, LOCAL_AUTH, 142528679Sbrian "port redirection", "alias port [proto addr_local:port_local port_alias]"}, 142628679Sbrian {"addr", NULL, AliasRedirectAddr, LOCAL_AUTH, 142728679Sbrian "static address translation", "alias addr [addr_local addr_alias]"}, 142828679Sbrian {"deny_incoming", NULL, AliasOption, LOCAL_AUTH, 142928679Sbrian "stop incoming connections", "alias deny_incoming [yes|no]", 143028679Sbrian (void *) PKT_ALIAS_DENY_INCOMING}, 143128679Sbrian {"log", NULL, AliasOption, LOCAL_AUTH, 143228679Sbrian "log aliasing link creation", "alias log [yes|no]", 143328679Sbrian (void *) PKT_ALIAS_LOG}, 143428679Sbrian {"same_ports", NULL, AliasOption, LOCAL_AUTH, 143528679Sbrian "try to leave port numbers unchanged", "alias same_ports [yes|no]", 143628679Sbrian (void *) PKT_ALIAS_SAME_PORTS}, 143728679Sbrian {"use_sockets", NULL, AliasOption, LOCAL_AUTH, 143828679Sbrian "allocate host sockets", "alias use_sockets [yes|no]", 143928679Sbrian (void *) PKT_ALIAS_USE_SOCKETS}, 144028679Sbrian {"unregistered_only", NULL, AliasOption, LOCAL_AUTH, 144128679Sbrian "alias unregistered (private) IP address space only", 144228679Sbrian "alias unregistered_only [yes|no]", 144328679Sbrian (void *) PKT_ALIAS_UNREGISTERED_ONLY}, 144428679Sbrian {"help", "?", HelpCommand, LOCAL_AUTH | LOCAL_NO_AUTH, 144528679Sbrian "Display this message", "alias help|? [command]", 144628679Sbrian (void *) AliasCommands}, 144728679Sbrian {NULL, NULL, NULL}, 144826031Sbrian}; 144926031Sbrian 145026031Sbrian 145126031Sbrianstatic int 145228679SbrianAliasCommand(struct cmdtab const * list, int argc, char **argv) 145326031Sbrian{ 145426031Sbrian if (argc > 0) 145526516Sbrian FindExec(AliasCommands, argc, argv); 145626516Sbrian else if (VarTerm) 145726516Sbrian fprintf(VarTerm, "Use `alias help' to get a list or `alias help <option>'" 145826516Sbrian " for syntax help.\n"); 145926031Sbrian else 146026516Sbrian LogPrintf(LogWARN, "alias command must have arguments\n"); 146126516Sbrian 146226516Sbrian return 0; 146326031Sbrian} 146426031Sbrian 146526031Sbrianstatic int 146628679SbrianAliasEnable(struct cmdtab const * list, int argc, char **argv) 146726031Sbrian{ 146826516Sbrian if (argc == 1) 146926516Sbrian if (strcasecmp(argv[0], "yes") == 0) { 147026516Sbrian if (!(mode & MODE_ALIAS)) { 147128679Sbrian if (loadAliasHandlers(&VarAliasHandlers) == 0) { 147228679Sbrian mode |= MODE_ALIAS; 147328679Sbrian return 0; 147428679Sbrian } 147528679Sbrian LogPrintf(LogWARN, "Cannot load alias library\n"); 147628679Sbrian return 1; 147726516Sbrian } 147826516Sbrian return 0; 147926516Sbrian } else if (strcasecmp(argv[0], "no") == 0) { 148026516Sbrian if (mode & MODE_ALIAS) { 148128679Sbrian unloadAliasHandlers(); 148228679Sbrian mode &= ~MODE_ALIAS; 148326516Sbrian } 148426516Sbrian return 0; 148526142Sbrian } 148626516Sbrian return -1; 148726031Sbrian} 148826031Sbrian 148926031Sbrian 149026031Sbrianstatic int 149128679SbrianAliasOption(struct cmdtab const * list, int argc, char **argv, void *param) 149226031Sbrian{ 149328679Sbrian if (argc == 1) 149428679Sbrian if (strcasecmp(argv[0], "yes") == 0) { 149528679Sbrian if (mode & MODE_ALIAS) { 149628679Sbrian VarPacketAliasSetMode((unsigned) param, (unsigned) param); 149728679Sbrian return 0; 149828679Sbrian } 149928679Sbrian LogPrintf(LogWARN, "alias not enabled\n"); 150028679Sbrian } else if (strcmp(argv[0], "no") == 0) { 150128679Sbrian if (mode & MODE_ALIAS) { 150228679Sbrian VarPacketAliasSetMode(0, (unsigned) param); 150328679Sbrian return 0; 150428679Sbrian } 150528679Sbrian LogPrintf(LogWARN, "alias not enabled\n"); 150628679Sbrian } 150728679Sbrian return -1; 150826031Sbrian} 1509