command.c revision 28327
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 * 2028327Sbrian * $Id: command.c,v 1.67 1997/07/14 01:41:26 brian Exp $ 218857Srgrimes * 226059Samurai */ 2313379Sphk#include <sys/types.h> 2427089Sbrian#include <sys/stat.h> 256059Samurai#include <ctype.h> 266735Samurai#include <termios.h> 2713385Speter#include <sys/wait.h> 2813379Sphk#include <time.h> 2926031Sbrian#include <netdb.h> 3026031Sbrian#include <sys/socket.h> 3126031Sbrian#include <netinet/in.h> 3226031Sbrian#include <arpa/inet.h> 3326031Sbrian#include <net/route.h> 3426031Sbrian#include <paths.h> 3526031Sbrian#include <alias.h> 3626516Sbrian#include <fcntl.h> 3726516Sbrian#include <errno.h> 386059Samurai#include "fsm.h" 396059Samurai#include "phase.h" 406059Samurai#include "lcp.h" 416059Samurai#include "ipcp.h" 426059Samurai#include "modem.h" 4313389Sphk#include "filter.h" 446059Samurai#include "command.h" 4526031Sbrian#include "alias_cmd.h" 466059Samurai#include "hdlc.h" 4726142Sbrian#include "loadalias.h" 486059Samurai#include "vars.h" 4925630Sbrian#include "systems.h" 5025630Sbrian#include "chat.h" 516059Samurai#include "os.h" 5226516Sbrian#include "timeout.h" 5326940Sbrian#include "server.h" 546059Samurai 556059Samuraiextern void Cleanup(), TtyTermMode(), PacketMode(); 566059Samuraiextern int EnableCommand(), DisableCommand(), DisplayCommand(); 576059Samuraiextern int AcceptCommand(), DenyCommand(); 5826031Sbrianstatic int AliasCommand(); 596735Samuraiextern int LocalAuthCommand(); 606059Samuraiextern int LoadCommand(), SaveCommand(); 616059Samuraiextern int ChangeParity(char *); 626059Samuraiextern int SelectSystem(); 636059Samuraiextern int ShowRoute(); 6410528Samuraiextern void TtyOldMode(), TtyCommandMode(); 656735Samuraiextern struct pppvars pppVars; 6614418Sacheextern struct cmdtab const SetCommands[]; 676059Samurai 6822973Sphkextern char *IfDevName; 6922973Sphk 706059Samuraistruct in_addr ifnetmask; 7123603Sacheint randinit; 726059Samurai 736059Samuraistatic int ShowCommand(), TerminalCommand(), QuitCommand(); 746059Samuraistatic int CloseCommand(), DialCommand(), DownCommand(); 756059Samuraistatic int SetCommand(), AddCommand(), DeleteCommand(); 7610528Samuraistatic int ShellCommand(); 776059Samurai 786059Samuraistatic int 796059SamuraiHelpCommand(list, argc, argv, plist) 806059Samuraistruct cmdtab *list; 816059Samuraiint argc; 826059Samuraichar **argv; 836059Samuraistruct cmdtab *plist; 846059Samurai{ 856059Samurai struct cmdtab *cmd; 866059Samurai int n; 876059Samurai 8826516Sbrian if (!VarTerm) 8926516Sbrian return 0; 9026516Sbrian 916059Samurai if (argc > 0) { 9226516Sbrian for (cmd = plist; cmd->name; cmd++) 9325566Sbrian if (strcasecmp(cmd->name, *argv) == 0 && (cmd->lauth & VarLocalAuth)) { 9426516Sbrian fprintf(VarTerm, "%s\n", cmd->syntax); 9526516Sbrian return 0; 966059Samurai } 9726516Sbrian 9826516Sbrian return -1; 996059Samurai } 10026516Sbrian 1016059Samurai n = 0; 10226516Sbrian for (cmd = plist; cmd->func; cmd++) 1036764Samurai if (cmd->name && (cmd->lauth & VarLocalAuth)) { 10426587Sbrian fprintf(VarTerm, " %-9s: %-20s\n", cmd->name, cmd->helpmes); 1056059Samurai n++; 1066059Samurai } 10726516Sbrian 1086059Samurai if (n & 1) 10926516Sbrian fprintf(VarTerm, "\n"); 11026516Sbrian 11126516Sbrian return 0; 1126059Samurai} 1136059Samurai 1146059Samuraiint 1156059SamuraiIsInteractive() 1166059Samurai{ 1176059Samurai char *mes = NULL; 1186059Samurai 11920120Snate if (mode & MODE_DDIAL) 12020120Snate mes = "Working in dedicated dial mode."; 12125908Sbrian else if (mode & MODE_BACKGROUND) 12225908Sbrian mes = "Working in background mode."; 12320120Snate else if (mode & MODE_AUTO) 12410528Samurai mes = "Working in auto mode."; 1256059Samurai else if (mode & MODE_DIRECT) 12610528Samurai mes = "Working in direct mode."; 1276059Samurai else if (mode & MODE_DEDICATED) 12810528Samurai mes = "Working in dedicated mode."; 1296059Samurai if (mes) { 13026516Sbrian if (VarTerm) 13126516Sbrian fprintf(VarTerm, "%s\n", mes); 13226516Sbrian return 0; 1336059Samurai } 13426516Sbrian return 1; 1356059Samurai} 1366059Samurai 1376059Samuraistatic int 1386059SamuraiDialCommand(cmdlist, argc, argv) 1396059Samuraistruct cmdtab *cmdlist; 1406059Samuraiint argc; 1416059Samuraichar **argv; 1426059Samurai{ 14311336Samurai int tries; 14426858Sbrian int res; 14511336Samurai 1466059Samurai if (LcpFsm.state > ST_CLOSED) { 14726516Sbrian if (VarTerm) 14826516Sbrian fprintf(VarTerm, "LCP state is [%s]\n", StateNames[LcpFsm.state]); 14926516Sbrian return 0; 1506059Samurai } 15126516Sbrian 1526059Samurai if (!IsInteractive()) 1536059Samurai return(1); 15426516Sbrian 1556735Samurai if (argc > 0) { 1566735Samurai if (SelectSystem(*argv, CONFFILE) < 0) { 15726516Sbrian if (VarTerm) 15826516Sbrian fprintf(VarTerm, "%s: not found.\n", *argv); 15926516Sbrian return -1; 1606735Samurai } 1616735Samurai } 16226516Sbrian 16311336Samurai tries = 0; 16411336Samurai do { 16526516Sbrian if (VarTerm) 16626516Sbrian fprintf(VarTerm, "Dial attempt %u of %d\n", ++tries, VarDialTries); 16711336Samurai modem = OpenModem(mode); 16811336Samurai if (modem < 0) { 16926516Sbrian if (VarTerm) 17026516Sbrian fprintf(VarTerm, "Failed to open modem.\n"); 17111336Samurai break; 17211336Samurai } 17326858Sbrian if ((res = DialModem()) == EX_DONE) { 17411336Samurai 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 18610528SamuraiShellCommand(cmdlist, argc, argv) 18710528Samuraistruct cmdtab *cmdlist; 18810528Samuraiint argc; 18910528Samuraichar **argv; 19010528Samurai{ 19110528Samurai const char *shell; 19210528Samurai pid_t shpid; 19326516Sbrian FILE *oVarTerm; 19420813Sjkh 19518856Ssos#ifdef SHELL_ONLY_INTERACTIVELY 19626911Sbrian /* we're only allowed to shell when we run ppp interactively */ 19726516Sbrian if (mode != MODE_INTER) { 19826516Sbrian LogPrintf(LogWARN, "Can only start a shell in interactive mode\n"); 19926516Sbrian return 1; 20010528Samurai } 20126911Sbrian#endif 20226911Sbrian#ifdef NO_SHELL_IN_AUTO_INTERACTIVE 20326911Sbrian /* 20426911Sbrian * we want to stop shell commands when we've got a telnet connection 20526911Sbrian * to an auto mode ppp 20626911Sbrian */ 20726516Sbrian if ((mode & (MODE_AUTO|MODE_INTER)) == (MODE_AUTO|MODE_INTER)) { 20826516Sbrian LogPrintf(LogWARN, "Shell is not allowed interactively in auto mode\n"); 20926516Sbrian return 1; 21026516Sbrian } 21126516Sbrian#endif 21226516Sbrian 21310528Samurai if(argc == 0 && !(mode & MODE_INTER)) { 21426516Sbrian LogPrintf(LogWARN, "Can only start an interactive shell in" 21526516Sbrian " interactive mode\n"); 21626516Sbrian return 1; 21710528Samurai } 21826516Sbrian 21926516Sbrian if((shell = getenv("SHELL")) == 0) 22026516Sbrian shell = _PATH_BSHELL; 22126516Sbrian 22210528Samurai if((shpid = fork()) == 0) { 22326516Sbrian int dtablesize, i, fd; 22418531Sbde 22526516Sbrian if (VarTerm) 22626516Sbrian fd = fileno(VarTerm); 22726516Sbrian else if ((fd = open("/dev/null", O_RDWR)) == -1) { 22826516Sbrian LogPrintf(LogALERT, "Failed to open /dev/null: %s\n", strerror(errno)); 22926516Sbrian exit(1); 23026516Sbrian } 23126516Sbrian 23226516Sbrian for (i = 0; i < 3; i++) 23326516Sbrian dup2(fd, i); 23426516Sbrian 23526516Sbrian if (fd > 2) 23626516Sbrian if (VarTerm) { 23726516Sbrian oVarTerm = VarTerm; 23826516Sbrian VarTerm = 0; 23926516Sbrian if (oVarTerm && oVarTerm != stdout) 24026516Sbrian fclose(oVarTerm); 24126516Sbrian } else 24226516Sbrian close(fd); 24326516Sbrian 24418531Sbde for (dtablesize = getdtablesize(), i = 3; i < dtablesize; i++) 24510528Samurai (void)close(i); 24610528Samurai 24710528Samurai /* 24810528Samurai * We are running setuid, we should change to 24910528Samurai * real user for avoiding security problems. 25010528Samurai */ 25116263Sache if (setgid(getgid()) < 0) { 25226516Sbrian LogPrintf(LogERROR, "setgid: %s\n", strerror(errno)); 25316263Sache exit(1); 25416263Sache } 25516263Sache if (setuid(getuid()) < 0) { 25626516Sbrian LogPrintf(LogERROR, "setuid: %s\n", strerror(errno)); 25716263Sache exit(1); 25816263Sache } 25910528Samurai TtyOldMode(); 26018790Ssos if(argc > 0) { 26118790Ssos /* substitute pseudo args */ 26227011Sbrian for (i=1; i<argc; i++) 26327011Sbrian if (strcasecmp(argv[i], "HISADDR") == 0) 26418790Ssos argv[i] = strdup(inet_ntoa(IpcpInfo.his_ipaddr)); 26527011Sbrian else if (strcasecmp(argv[i], "INTERFACE") == 0) 26622973Sphk argv[i] = strdup(IfDevName); 26727011Sbrian else if (strcasecmp(argv[i], "MYADDR") == 0) 26818790Ssos argv[i] = strdup(inet_ntoa(IpcpInfo.want_ipaddr)); 26925630Sbrian (void)execvp(argv[0], argv); 27018790Ssos } 27110528Samurai else 27225630Sbrian (void)execl(shell, shell, NULL); 27320813Sjkh 27426516Sbrian LogPrintf(LogWARN, "exec() of %s failed\n", argc > 0 ? argv[0] : shell); 27510528Samurai exit(255); 27610528Samurai } 27726516Sbrian 27810528Samurai if( shpid == (pid_t)-1 ) { 27926516Sbrian LogPrintf(LogERROR, "Fork failed: %s\n", strerror(errno)); 28010528Samurai } else { 28110528Samurai int status; 28210528Samurai (void)waitpid(shpid, &status, 0); 28310528Samurai } 28420813Sjkh 28510528Samurai TtyCommandMode(1); 28620813Sjkh 28710528Samurai return(0); 28810528Samurai} 28910528Samurai 29013760Sphkstruct cmdtab const Commands[] = { 2916735Samurai { "accept", NULL, AcceptCommand, LOCAL_AUTH, 29226516Sbrian "accept option request", "accept option .."}, 2936735Samurai { "add", NULL, AddCommand, LOCAL_AUTH, 29426516Sbrian "add route", "add dest mask gateway"}, 2956735Samurai { "close", NULL, CloseCommand, LOCAL_AUTH, 29626516Sbrian "Close connection", "close"}, 2976735Samurai { "delete", NULL, DeleteCommand, LOCAL_AUTH, 29826591Sbrian "delete route", "delete ALL | dest [gateway [mask]]"}, 2996735Samurai { "deny", NULL, DenyCommand, LOCAL_AUTH, 30026516Sbrian "Deny option request", "deny option .."}, 3016735Samurai { "dial", "call", DialCommand, LOCAL_AUTH, 30226516Sbrian "Dial and login", "dial|call [remote]"}, 3036735Samurai { "disable", NULL, DisableCommand, LOCAL_AUTH, 30426516Sbrian "Disable option", "disable option .."}, 3056735Samurai { "display", NULL, DisplayCommand, LOCAL_AUTH, 30626516Sbrian "Display option configs", "display"}, 3076735Samurai { "enable", NULL, EnableCommand, LOCAL_AUTH, 30826516Sbrian "Enable option", "enable option .."}, 3096764Samurai { "passwd", NULL, LocalAuthCommand,LOCAL_NO_AUTH, 31026516Sbrian "Password for manipulation", "passwd option .."}, 3116735Samurai { "load", NULL, LoadCommand, LOCAL_AUTH, 31226516Sbrian "Load settings", "load [remote]"}, 3136735Samurai { "save", NULL, SaveCommand, LOCAL_AUTH, 31426516Sbrian "Save settings", "save"}, 3156735Samurai { "set", "setup", SetCommand, LOCAL_AUTH, 31626516Sbrian "Set parameters", "set[up] var value"}, 31710528Samurai { "shell", "!", ShellCommand, LOCAL_AUTH, 31826516Sbrian "Run a subshell", "shell|! [sh command]"}, 3196735Samurai { "show", NULL, ShowCommand, LOCAL_AUTH, 32026516Sbrian "Show status and statictics", "show var"}, 3216735Samurai { "term", NULL, TerminalCommand,LOCAL_AUTH, 32226516Sbrian "Enter to terminal mode", "term"}, 32326031Sbrian { "alias", NULL, AliasCommand, LOCAL_AUTH, 32426516Sbrian "alias control", "alias option [yes|no]"}, 3256764Samurai { "quit", "bye", QuitCommand, LOCAL_AUTH | LOCAL_NO_AUTH, 32626516Sbrian "Quit PPP program", "quit|bye [all]"}, 3276735Samurai { "help", "?", HelpCommand, LOCAL_AUTH | LOCAL_NO_AUTH, 32826516Sbrian "Display this message", "help|? [command]", (void *)Commands }, 3296735Samurai { NULL, "down", DownCommand, LOCAL_AUTH, 33026516Sbrian "Generate down event", "down"}, 3316059Samurai { NULL, NULL, NULL }, 3326059Samurai}; 3336059Samurai 3346059Samuraiextern int ReportCcpStatus(); 3356059Samuraiextern int ReportLcpStatus(); 3366059Samuraiextern int ReportIpcpStatus(); 3376059Samuraiextern int ReportProtStatus(); 3386059Samuraiextern int ReportCompress(); 3396059Samuraiextern int ShowModemStatus(); 3406059Samuraiextern int ReportHdlcStatus(); 3416059Samuraiextern int ShowMemMap(); 3426059Samurai 34326516Sbrianstatic int ShowLogLevel() 3446059Samurai{ 3456059Samurai int i; 3466059Samurai 34726516Sbrian if (!VarTerm) 34826516Sbrian return 0; 34926516Sbrian fprintf(VarTerm, "Log:"); 35026516Sbrian for (i = LogMIN; i < LogMAXCONF; i++) { 35126516Sbrian if (LogIsKept(i)) 35226516Sbrian fprintf(VarTerm, " %s", LogName(i)); 3536059Samurai } 35426516Sbrian fprintf(VarTerm, "\n"); 35526516Sbrian 35626516Sbrian return 0; 3576059Samurai} 3586059Samurai 3596059Samuraistatic int ShowEscape() 3606059Samurai{ 3616059Samurai int code, bit; 3626059Samurai 36326516Sbrian if (!VarTerm) 36426516Sbrian return 0; 3656059Samurai if (EscMap[32]) { 36626516Sbrian for (code = 0; code < 32; code++) 36726516Sbrian if (EscMap[code]) 36826516Sbrian for (bit = 0; bit < 8; bit++) 36926516Sbrian if (EscMap[code] & (1<<bit)) 37026516Sbrian fprintf(VarTerm, " 0x%02x", (code << 3) + bit); 37126516Sbrian fprintf(VarTerm, "\n"); 3726059Samurai } 37326516Sbrian return 1; 3746059Samurai} 3756059Samurai 3766059Samuraistatic int ShowTimeout() 3776059Samurai{ 37826516Sbrian if (!VarTerm) 37926516Sbrian return 0; 38026516Sbrian fprintf(VarTerm, " Idle Timer: %d secs LQR Timer: %d secs" 38126516Sbrian " Retry Timer: %d secs\n", VarIdleTimeout, VarLqrTimeout, 38226516Sbrian VarRetryTimeout); 38326516Sbrian return 1; 3846059Samurai} 3856059Samurai 38628327Sbrianstatic int ShowStopped() 38728327Sbrian{ 38828327Sbrian if (!VarTerm) 38928327Sbrian return 0; 39028327Sbrian if (!VarStoppedTimeout) 39128327Sbrian fprintf(VarTerm, " Stopped Timer: Disabled\n"); 39228327Sbrian else 39328327Sbrian fprintf(VarTerm, " Stopped Timer: %d secs\n", VarStoppedTimeout); 39428327Sbrian return 1; 39528327Sbrian} 39628327Sbrian 3976059Samuraistatic int ShowAuthKey() 3986059Samurai{ 39926516Sbrian if (!VarTerm) 40026516Sbrian return 0; 40126516Sbrian fprintf(VarTerm, "AuthName = %s\n", VarAuthName); 40226516Sbrian fprintf(VarTerm, "AuthKey = %s\n", VarAuthKey); 40326516Sbrian return 1; 4046059Samurai} 4056059Samurai 4066059Samuraistatic int ShowVersion() 4076059Samurai{ 40813389Sphk extern char VarVersion[]; 40913389Sphk extern char VarLocalVersion[]; 4106059Samurai 41126516Sbrian if (!VarTerm) 41226516Sbrian return 0; 41326516Sbrian fprintf(VarTerm, "%s - %s \n", VarVersion, VarLocalVersion); 41426516Sbrian return 1; 4156059Samurai} 4166059Samurai 41726326Sbrianstatic int ShowInitialMRU() 41826326Sbrian{ 41926516Sbrian if (!VarTerm) 42026516Sbrian return 0; 42126516Sbrian fprintf(VarTerm, " Initial MRU: %ld\n", VarMRU); 42226516Sbrian return 1; 42326326Sbrian} 42426326Sbrian 42526326Sbrianstatic int ShowPreferredMTU() 42626326Sbrian{ 42726516Sbrian if (!VarTerm) 42826516Sbrian return 0; 42926326Sbrian if (VarPrefMTU) 43026516Sbrian fprintf(VarTerm, " Preferred MTU: %ld\n", VarPrefMTU); 43126326Sbrian else 43226516Sbrian fprintf(VarTerm, " Preferred MTU: unspecified\n"); 43326516Sbrian return 1; 43426326Sbrian} 43526326Sbrian 43625067Sbrianstatic int ShowReconnect() 43725067Sbrian{ 43826516Sbrian if (!VarTerm) 43926516Sbrian return 0; 44026516Sbrian fprintf(VarTerm, " Reconnect Timer: %d, %d tries\n", 44125067Sbrian VarReconnectTimer, VarReconnectTries); 44226516Sbrian return 1; 44325067Sbrian} 44425067Sbrian 44511336Samuraistatic int ShowRedial() 44611336Samurai{ 44726516Sbrian if (!VarTerm) 44826516Sbrian return 0; 44926516Sbrian fprintf(VarTerm, " Redial Timer: "); 45011336Samurai 45111336Samurai if (VarRedialTimeout >= 0) { 45226516Sbrian fprintf(VarTerm, " %d seconds, ", VarRedialTimeout); 45311336Samurai } 45411336Samurai else { 45526516Sbrian fprintf(VarTerm, " Random 0 - %d seconds, ", REDIAL_PERIOD); 45611336Samurai } 45711336Samurai 45826516Sbrian fprintf(VarTerm, " Redial Next Timer: "); 45924939Sbrian 46024939Sbrian if (VarRedialNextTimeout >= 0) { 46126516Sbrian fprintf(VarTerm, " %d seconds, ", VarRedialNextTimeout); 46224939Sbrian } 46324939Sbrian else { 46426516Sbrian fprintf(VarTerm, " Random 0 - %d seconds, ", REDIAL_PERIOD); 46524939Sbrian } 46624939Sbrian 46711336Samurai if (VarDialTries) 46826516Sbrian fprintf(VarTerm, "%d dial tries", VarDialTries); 46911336Samurai 47026516Sbrian fprintf(VarTerm, "\n"); 47111336Samurai 47226516Sbrian return 1; 47311336Samurai} 47411336Samurai 47526516Sbrian#ifndef NOMSEXT 47618752Sjkhstatic int ShowMSExt() 47718752Sjkh{ 47826516Sbrian if (!VarTerm) 47926516Sbrian return 0; 48026516Sbrian fprintf(VarTerm, " MS PPP extention values \n" ); 48126516Sbrian fprintf(VarTerm, " Primary NS : %s\n", inet_ntoa( ns_entries[0] )); 48226516Sbrian fprintf(VarTerm, " Secondary NS : %s\n", inet_ntoa( ns_entries[1] )); 48326516Sbrian fprintf(VarTerm, " Primary NBNS : %s\n", inet_ntoa( nbns_entries[0] )); 48426516Sbrian fprintf(VarTerm, " Secondary NBNS : %s\n", inet_ntoa( nbns_entries[1] )); 48526516Sbrian return 1; 48618752Sjkh} 48726516Sbrian#endif 48818752Sjkh 4896735Samuraiextern int ShowIfilter(), ShowOfilter(), ShowDfilter(), ShowAfilter(); 4906059Samurai 49113760Sphkstruct cmdtab const ShowCommands[] = { 4926735Samurai { "afilter", NULL, ShowAfilter, LOCAL_AUTH, 49326516Sbrian "Show keep Alive filters", "show afilter option .."}, 4946735Samurai { "auth", NULL, ShowAuthKey, LOCAL_AUTH, 49526516Sbrian "Show auth name/key", "show auth"}, 4966735Samurai { "ccp", NULL, ReportCcpStatus, LOCAL_AUTH, 49726516Sbrian "Show CCP status", "show cpp"}, 4986735Samurai { "compress", NULL, ReportCompress, LOCAL_AUTH, 49926516Sbrian "Show compression statictics", "show compress"}, 5006735Samurai { "dfilter", NULL, ShowDfilter, LOCAL_AUTH, 50126516Sbrian "Show Demand filters", "show dfilteroption .."}, 5026735Samurai { "escape", NULL, ShowEscape, LOCAL_AUTH, 50326516Sbrian "Show escape characters", "show escape"}, 5046735Samurai { "hdlc", NULL, ReportHdlcStatus, LOCAL_AUTH, 50526516Sbrian "Show HDLC error summary", "show hdlc"}, 5066735Samurai { "ifilter", NULL, ShowIfilter, LOCAL_AUTH, 50726516Sbrian "Show Input filters", "show ifilter option .."}, 5086735Samurai { "ipcp", NULL, ReportIpcpStatus, LOCAL_AUTH, 50926516Sbrian "Show IPCP status", "show ipcp"}, 5106735Samurai { "lcp", NULL, ReportLcpStatus, LOCAL_AUTH, 51126516Sbrian "Show LCP status", "show lcp"}, 51226516Sbrian { "log", NULL, ShowLogLevel, LOCAL_AUTH, 51326516Sbrian "Show current log level", "show log"}, 5146735Samurai { "mem", NULL, ShowMemMap, LOCAL_AUTH, 51526516Sbrian "Show memory map", "show mem"}, 5166735Samurai { "modem", NULL, ShowModemStatus, LOCAL_AUTH, 51726516Sbrian "Show modem setups", "show modem"}, 51826326Sbrian { "mru", NULL, ShowInitialMRU, LOCAL_AUTH, 51926516Sbrian "Show Initial MRU", "show mru"}, 52026326Sbrian { "mtu", NULL, ShowPreferredMTU, LOCAL_AUTH, 52126516Sbrian "Show Preferred MTU", "show mtu"}, 5226735Samurai { "ofilter", NULL, ShowOfilter, LOCAL_AUTH, 52326516Sbrian "Show Output filters", "show ofilter option .."}, 5246735Samurai { "proto", NULL, ReportProtStatus, LOCAL_AUTH, 52526516Sbrian "Show protocol summary", "show proto"}, 52625067Sbrian { "reconnect",NULL, ShowReconnect, LOCAL_AUTH, 52726516Sbrian "Show Reconnect timer,tries", "show reconnect"}, 52825067Sbrian { "redial", NULL, ShowRedial, LOCAL_AUTH, 52926516Sbrian "Show Redial timeout value", "show redial"}, 5306735Samurai { "route", NULL, ShowRoute, LOCAL_AUTH, 53126516Sbrian "Show routing table", "show route"}, 5326735Samurai { "timeout", NULL, ShowTimeout, LOCAL_AUTH, 53326516Sbrian "Show Idle timeout value", "show timeout"}, 53428327Sbrian { "stopped", NULL, ShowStopped, LOCAL_AUTH, 53528327Sbrian "Show STOPPED timeout value", "show stopped"}, 53626516Sbrian#ifndef NOMSEXT 53718752Sjkh { "msext", NULL, ShowMSExt, LOCAL_AUTH, 53826516Sbrian "Show MS PPP extentions", "show msext"}, 53926516Sbrian#endif 5406735Samurai { "version", NULL, ShowVersion, LOCAL_NO_AUTH | LOCAL_AUTH, 54126516Sbrian "Show version string", "show version"}, 5426735Samurai { "help", "?", HelpCommand, LOCAL_NO_AUTH | LOCAL_AUTH, 54326698Sbrian "Display this message", "show help|? [command]", (void *)ShowCommands}, 5446059Samurai { NULL, NULL, NULL }, 5456059Samurai}; 5466059Samurai 5476059Samuraistruct cmdtab * 5486059SamuraiFindCommand(cmds, str, pmatch) 5496059Samuraistruct cmdtab *cmds; 5506059Samuraichar *str; 5516059Samuraiint *pmatch; 5526059Samurai{ 55326516Sbrian int nmatch; 55426516Sbrian int len; 55526516Sbrian struct cmdtab *found; 5566059Samurai 55726516Sbrian found = NULL; 55826516Sbrian len = strlen(str); 55926516Sbrian nmatch = 0; 5606059Samurai while (cmds->func) { 56125566Sbrian if (cmds->name && strncasecmp(str, cmds->name, len) == 0) { 56226516Sbrian if (cmds->name[len] == '\0') { 56326516Sbrian *pmatch = 1; 56426516Sbrian return cmds; 56526516Sbrian } 5666059Samurai nmatch++; 5676059Samurai found = cmds; 56826516Sbrian } else if(cmds->alias && strncasecmp(str, cmds->alias, len) == 0) { 56926516Sbrian if (cmds->alias[len] == '\0') { 57026516Sbrian *pmatch = 1; 57126516Sbrian return cmds; 57226516Sbrian } 5736059Samurai nmatch++; 5746059Samurai found = cmds; 5756059Samurai } 5766059Samurai cmds++; 5776059Samurai } 5786059Samurai *pmatch = nmatch; 57926516Sbrian return found; 5806059Samurai} 5816059Samurai 5826059Samuraiint 5836059SamuraiFindExec(cmdlist, argc, argv) 5846059Samuraistruct cmdtab *cmdlist; 5856059Samuraiint argc; 5866059Samuraichar **argv; 5876059Samurai{ 5886059Samurai struct cmdtab *cmd; 5896059Samurai int val = 1; 5906059Samurai int nmatch; 5916059Samurai 5926059Samurai cmd = FindCommand(cmdlist, *argv, &nmatch); 5936059Samurai if (nmatch > 1) 59426516Sbrian LogPrintf(LogWARN, "%s: Ambiguous command\n", *argv); 5956735Samurai else if (cmd && ( cmd->lauth & VarLocalAuth ) ) 5966059Samurai val = (cmd->func)(cmd, --argc, ++argv, cmd->args); 5976059Samurai else 59826516Sbrian LogPrintf(LogWARN, "%s: Invalid command\n", *argv); 59926516Sbrian 60026516Sbrian if (val == -1) 60126516Sbrian LogPrintf(LogWARN, "Usage: %s\n", cmd->syntax); 60226516Sbrian else if(val) 60326516Sbrian LogPrintf(LogCOMMAND, "%s: Failed %d\n", *argv, val); 60426516Sbrian 60526516Sbrian return val; 6066059Samurai} 6076059Samurai 60818885Sjkhint aft_cmd = 1; 60926516Sbrianextern int TermMode; 61018885Sjkh 6116059Samuraivoid 61218885SjkhPrompt() 6136059Samurai{ 6146735Samurai char *pconnect, *pauth; 6156735Samurai 61626516Sbrian if (!(mode & MODE_INTER) || !VarTerm || TermMode) 6176059Samurai return; 6186735Samurai 61918885Sjkh if (!aft_cmd) 62026516Sbrian fprintf(VarTerm, "\n"); 62118885Sjkh else 62218885Sjkh aft_cmd = 0; 6236735Samurai 6246735Samurai if ( VarLocalAuth == LOCAL_AUTH ) 6256735Samurai pauth = " ON "; 6266735Samurai else 6276735Samurai pauth = " on "; 6286059Samurai if (IpcpFsm.state == ST_OPENED && phase == PHASE_NETWORK) 6296735Samurai pconnect = "PPP"; 6306059Samurai else 6316735Samurai pconnect = "ppp"; 63226516Sbrian fprintf(VarTerm, "%s%s%s> ", pconnect, pauth, VarShortHost); 63326516Sbrian fflush(VarTerm); 6346059Samurai} 6356059Samurai 6366059Samuraivoid 6376059SamuraiDecodeCommand(buff, nb, prompt) 6386059Samuraichar *buff; 6396059Samuraiint nb; 6406059Samuraiint prompt; 6416059Samurai{ 6426059Samurai char *vector[20]; 6436059Samurai char **argv; 64426516Sbrian int argc; 6456059Samurai char *cp; 6466059Samurai 6476059Samurai if (nb > 0) { 6486059Samurai cp = buff + strcspn(buff, "\r\n"); 6496059Samurai if (cp) 6506059Samurai *cp = '\0'; 65126516Sbrian argc = MakeArgs(buff, vector, VECSIZE(vector)); 65226516Sbrian argv = vector; 6536059Samurai 65426516Sbrian if (argc > 0) 65526516Sbrian FindExec(Commands, argc, argv); 6566059Samurai } 65726516Sbrian if (prompt) 65825630Sbrian Prompt(); 6596059Samurai} 6606059Samurai 6616059Samuraistatic int 6626059SamuraiShowCommand(list, argc, argv) 6636059Samuraistruct cmdtab *list; 6646059Samuraiint argc; 6656059Samuraichar **argv; 6666059Samurai{ 6676059Samurai if (argc > 0) 66826516Sbrian FindExec(ShowCommands, argc, argv); 66926516Sbrian else if (VarTerm) 67026516Sbrian fprintf(VarTerm, "Use ``show ?'' to get a list.\n"); 6716059Samurai else 67226516Sbrian LogPrintf(LogWARN, "show command must have arguments\n"); 67326516Sbrian 67426516Sbrian return 0; 6756059Samurai} 6766059Samurai 6776059Samuraistatic int 6786059SamuraiTerminalCommand() 6796059Samurai{ 6806059Samurai if (LcpFsm.state > ST_CLOSED) { 68126516Sbrian if (VarTerm) 68226516Sbrian fprintf(VarTerm, "LCP state is [%s]\n", StateNames[LcpFsm.state]); 68326516Sbrian return 1; 6846059Samurai } 6856059Samurai if (!IsInteractive()) 6866059Samurai return(1); 6876059Samurai modem = OpenModem(mode); 6886059Samurai if (modem < 0) { 68926516Sbrian if (VarTerm) 69026516Sbrian fprintf(VarTerm, "Failed to open modem.\n"); 6916059Samurai return(1); 6926059Samurai } 69326516Sbrian if (VarTerm) { 69426516Sbrian fprintf(VarTerm, "Enter to terminal mode.\n"); 69526516Sbrian fprintf(VarTerm, "Type `~?' for help.\n"); 69626516Sbrian } 6976059Samurai TtyTermMode(); 6986059Samurai return(0); 6996059Samurai} 7006059Samurai 7016059Samuraistatic int 7026059SamuraiQuitCommand(list, argc, argv) 7036059Samuraistruct cmdtab *list; 7046059Samuraiint argc; 7056059Samuraichar **argv; 7066059Samurai{ 70726516Sbrian FILE *oVarTerm; 70826516Sbrian 7096059Samurai if (mode & (MODE_DIRECT|MODE_DEDICATED|MODE_AUTO)) { 7106764Samurai if (argc > 0 && (VarLocalAuth & LOCAL_AUTH)) { 7116059Samurai Cleanup(EX_NORMAL); 71218911Ssos mode &= ~MODE_INTER; 71326516Sbrian oVarTerm = VarTerm; 71426516Sbrian VarTerm = 0; 71526516Sbrian if (oVarTerm && oVarTerm != stdout) 71626516Sbrian fclose(oVarTerm); 7176059Samurai } else { 71826516Sbrian LogPrintf(LogPHASE, "Client connection closed.\n"); 7196735Samurai VarLocalAuth = LOCAL_NO_AUTH; 72026516Sbrian mode &= ~MODE_INTER; 72126516Sbrian oVarTerm = VarTerm; 72226516Sbrian VarTerm = 0; 72326516Sbrian if (oVarTerm && oVarTerm != stdout) 72426516Sbrian fclose(oVarTerm); 7256059Samurai close(netfd); 7266059Samurai netfd = -1; 7276059Samurai } 7286059Samurai } else 7296059Samurai Cleanup(EX_NORMAL); 73026516Sbrian 73126516Sbrian return 0; 7326059Samurai} 7336059Samurai 7346059Samuraistatic int 7356059SamuraiCloseCommand() 7366059Samurai{ 73726098Sbrian reconnect(RECON_FALSE); 7386059Samurai LcpClose(); 73925908Sbrian if (mode & MODE_BACKGROUND) 74025908Sbrian Cleanup(EX_NORMAL); 74126516Sbrian return 0; 7426059Samurai} 7436059Samurai 7446059Samuraistatic int 7456059SamuraiDownCommand() 7466059Samurai{ 7476059Samurai LcpDown(); 74826516Sbrian return 0; 7496059Samurai} 7506059Samurai 75125067Sbrianstatic int 75225067SbrianSetModemSpeed(list, argc, argv) 7536059Samuraistruct cmdtab *list; 7546059Samuraiint argc; 7556059Samuraichar **argv; 7566059Samurai{ 7576059Samurai int speed; 7586059Samurai 7596059Samurai if (argc > 0) { 7606735Samurai if (strcmp(*argv, "sync") == 0) { 7616735Samurai VarSpeed = 0; 76226516Sbrian return 0; 7636735Samurai } 7646059Samurai speed = atoi(*argv); 7656735Samurai if (IntToSpeed(speed) != B0) { 7666735Samurai VarSpeed = speed; 76726516Sbrian return 0; 7686059Samurai } 76926516Sbrian LogPrintf(LogWARN, "%s: Invalid speed\n", *argv); 7706059Samurai } 77126516Sbrian return -1; 7726059Samurai} 7736059Samurai 77425067Sbrianstatic int 77525067SbrianSetReconnect(list, argc, argv) 77611336Samuraistruct cmdtab *list; 77711336Samuraiint argc; 77811336Samuraichar **argv; 77911336Samurai{ 78025067Sbrian if (argc == 2) { 78125067Sbrian VarReconnectTimer = atoi(argv[0]); 78225067Sbrian VarReconnectTries = atoi(argv[1]); 78326516Sbrian return 0; 78426516Sbrian } 78526516Sbrian 78626516Sbrian return -1; 78725067Sbrian} 78825067Sbrian 78925067Sbrianstatic int 79025067SbrianSetRedialTimeout(list, argc, argv) 79125067Sbrianstruct cmdtab *list; 79225067Sbrianint argc; 79325067Sbrianchar **argv; 79425067Sbrian{ 79511336Samurai int timeout; 79611336Samurai int tries; 79724939Sbrian char *dot; 79811336Samurai 79911336Samurai if (argc == 1 || argc == 2 ) { 80024939Sbrian if (strncasecmp(argv[0], "random", 6) == 0 && 80124939Sbrian (argv[0][6] == '\0' || argv[0][6] == '.')) { 80211336Samurai VarRedialTimeout = -1; 80323603Sache if (!randinit) { 80423603Sache randinit = 1; 80526626Sache srandomdev(); 80623603Sache } 80726516Sbrian } else { 80811336Samurai timeout = atoi(argv[0]); 80911336Samurai 81026516Sbrian if (timeout >= 0) 81111336Samurai VarRedialTimeout = timeout; 81211336Samurai else { 81326516Sbrian LogPrintf(LogWARN, "Invalid redial timeout\n"); 81426516Sbrian return -1; 81511336Samurai } 81611336Samurai } 81724939Sbrian 81824939Sbrian dot = index(argv[0],'.'); 81924939Sbrian if (dot) { 82024939Sbrian if (strcasecmp(++dot, "random") == 0) { 82124939Sbrian VarRedialNextTimeout = -1; 82224939Sbrian if (!randinit) { 82324939Sbrian randinit = 1; 82426626Sache srandomdev(); 82524939Sbrian } 82624939Sbrian } 82724939Sbrian else { 82824939Sbrian timeout = atoi(dot); 82926516Sbrian if (timeout >= 0) 83024939Sbrian VarRedialNextTimeout = timeout; 83124939Sbrian else { 83226516Sbrian LogPrintf(LogWARN, "Invalid next redial timeout\n"); 83326516Sbrian return -1; 83424939Sbrian } 83524939Sbrian } 83624939Sbrian } 83724939Sbrian else 83824939Sbrian VarRedialNextTimeout = NEXT_REDIAL_PERIOD; /* Default next timeout */ 83924939Sbrian 84011336Samurai if (argc == 2) { 84111336Samurai tries = atoi(argv[1]); 84211336Samurai 84311336Samurai if (tries >= 0) { 84426516Sbrian VarDialTries = tries; 84526516Sbrian } else { 84626516Sbrian LogPrintf(LogWARN, "Invalid retry value\n"); 84726516Sbrian return 1; 84811336Samurai } 84911336Samurai } 85026516Sbrian return 0; 85111336Samurai } 85226516Sbrian 85326516Sbrian return -1; 85411336Samurai} 85511336Samurai 85625067Sbrianstatic int 85728327SbrianSetStoppedTimeout(list, argc, argv) 85828327Sbrianstruct cmdtab *list; 85928327Sbrianint argc; 86028327Sbrianchar **argv; 86128327Sbrian{ 86228327Sbrian if (argc == 1) { 86328327Sbrian VarStoppedTimeout = atoi(argv[0]); 86428327Sbrian return 0; 86528327Sbrian } 86628327Sbrian return -1; 86728327Sbrian} 86828327Sbrian 86928327Sbrianstatic int 87026940SbrianSetServer(list, argc, argv) 87126940Sbrianstruct cmdtab *list; 87226940Sbrianint argc; 87326940Sbrianchar **argv; 87426940Sbrian{ 87526940Sbrian int res = -1; 87626940Sbrian 87727089Sbrian if (argc > 0 && argc < 3) 87826940Sbrian if (strcasecmp(argv[0], "none") == 0) { 87926940Sbrian ServerClose(); 88026940Sbrian LogPrintf(LogPHASE, "Disabling server port.\n"); 88126940Sbrian res = 0; 88227089Sbrian } else if (*argv[0] == '/') { 88327089Sbrian mode_t mask; 88427089Sbrian umask(mask = umask(0)); 88527089Sbrian if (argc == 2) { 88627089Sbrian unsigned m; 88727089Sbrian if (sscanf(argv[1], "%o", &m) == 1) 88827089Sbrian mask = m; 88927089Sbrian } 89027089Sbrian res = ServerLocalOpen(argv[0], mask); 89127346Sbrian } else { 89227346Sbrian int port; 89327346Sbrian if (strspn(argv[0], "0123456789") != strlen(argv[0])) { 89427346Sbrian struct servent *s; 89527346Sbrian if ((s = getservbyname(argv[0], "tcp")) == NULL) { 89627346Sbrian port = 0; 89727346Sbrian LogPrintf(LogWARN, "%s: Invalid port or service\n", argv[0]); 89827346Sbrian } else 89927346Sbrian port = ntohs(s->s_port); 90027346Sbrian } else 90127346Sbrian port = atoi(argv[0]); 90227346Sbrian if (port) 90327346Sbrian res = ServerTcpOpen(port); 90427346Sbrian } 90526940Sbrian 90626940Sbrian return res; 90726940Sbrian} 90826940Sbrian 90926940Sbrianstatic int 91025067SbrianSetModemParity(list, argc, argv) 9116059Samuraistruct cmdtab *list; 9126059Samuraiint argc; 9136059Samuraichar **argv; 9146059Samurai{ 91526845Sbrian return argc > 0 ? ChangeParity(*argv) : -1; 9166059Samurai} 9176059Samurai 9186059Samuraistatic int 91926516SbrianSetLogLevel(list, argc, argv) 9206059Samuraistruct cmdtab *list; 9216059Samuraiint argc; 9226059Samuraichar **argv; 9236059Samurai{ 92426516Sbrian int i; 92526516Sbrian int res; 92626516Sbrian char *arg; 9276059Samurai 92826516Sbrian res = 0; 92926516Sbrian if (argc == 0 || (argv[0][0] != '+' && argv[0][0] != '-')) 93026516Sbrian LogDiscardAll(); 93126516Sbrian while (argc--) { 93226516Sbrian arg = **argv == '+' || **argv == '-' ? *argv + 1 : *argv; 93326516Sbrian for (i = LogMIN; i <= LogMAX; i++) 93426516Sbrian if (strcasecmp(arg, LogName(i)) == 0) { 93526516Sbrian if (**argv == '-') 93626516Sbrian LogDiscard(i); 93726516Sbrian else 93826516Sbrian LogKeep(i); 9396059Samurai break; 9406059Samurai } 94126516Sbrian if (i > LogMAX) { 94226516Sbrian LogPrintf(LogWARN, "%s: Invalid log value\n", arg); 94326516Sbrian res = -1; 9446059Samurai } 94526516Sbrian argv++; 9466059Samurai } 94726516Sbrian return res; 9486059Samurai} 9496059Samurai 9506059Samuraistatic int 9516059SamuraiSetEscape(list, argc, argv) 9526059Samuraistruct cmdtab *list; 9536059Samuraiint argc; 9546059Samuraichar **argv; 9556059Samurai{ 9566059Samurai int code; 9576059Samurai 9586059Samurai for (code = 0; code < 33; code++) 9596059Samurai EscMap[code] = 0; 9606059Samurai while (argc-- > 0) { 9616059Samurai sscanf(*argv++, "%x", &code); 9626059Samurai code &= 0xff; 9636059Samurai EscMap[code >> 3] |= (1 << (code&7)); 9646059Samurai EscMap[32] = 1; 9656059Samurai } 96626516Sbrian return 0; 9676059Samurai} 9686059Samurai 9696059Samuraistatic int 9706059SamuraiSetInitialMRU(list, argc, argv) 9716059Samuraistruct cmdtab *list; 9726059Samuraiint argc; 9736059Samuraichar **argv; 9746059Samurai{ 97526326Sbrian long mru; 97626516Sbrian char *err; 9776059Samurai 9786059Samurai if (argc > 0) { 97926326Sbrian mru = atol(*argv); 98026326Sbrian if (mru < MIN_MRU) 98126516Sbrian err = "Given MRU value (%ld) is too small.\n"; 9826059Samurai else if (mru > MAX_MRU) 98326516Sbrian err = "Given MRU value (%ld) is too big.\n"; 98426516Sbrian else { 9856059Samurai VarMRU = mru; 98626516Sbrian return 0; 98726516Sbrian } 98826516Sbrian LogPrintf(LogWARN, err, mru); 98926516Sbrian } 99026326Sbrian 99126516Sbrian return -1; 9926059Samurai} 9936059Samurai 9946059Samuraistatic int 99526326SbrianSetPreferredMTU(list, argc, argv) 99626326Sbrianstruct cmdtab *list; 99726326Sbrianint argc; 99826326Sbrianchar **argv; 99926326Sbrian{ 100026326Sbrian long mtu; 100126516Sbrian char *err; 100226326Sbrian 100326326Sbrian if (argc > 0) { 100426326Sbrian mtu = atol(*argv); 100526516Sbrian if (mtu == 0) { 100626326Sbrian VarPrefMTU = 0; 100726516Sbrian return 0; 100826516Sbrian } else if (mtu < MIN_MTU) 100926516Sbrian err = "Given MTU value (%ld) is too small.\n"; 101026326Sbrian else if (mtu > MAX_MTU) 101126516Sbrian err = "Given MTU value (%ld) is too big.\n"; 101226516Sbrian else { 101326326Sbrian VarPrefMTU = mtu; 101426516Sbrian return 0; 101526516Sbrian } 101626516Sbrian LogPrintf(LogWARN, err, mtu); 101726516Sbrian } 101826326Sbrian 101926516Sbrian return -1; 102026326Sbrian} 102126326Sbrian 102226326Sbrianstatic int 10236059SamuraiSetIdleTimeout(list, argc, argv) 10246059Samuraistruct cmdtab *list; 10256059Samuraiint argc; 10266059Samuraichar **argv; 10276059Samurai{ 10286059Samurai if (argc-- > 0) { 10296059Samurai VarIdleTimeout = atoi(*argv++); 103026516Sbrian UpdateIdleTimer(); /* If we're connected, restart the idle timer */ 10316735Samurai if (argc-- > 0) { 10326735Samurai VarLqrTimeout = atoi(*argv++); 10336735Samurai if (VarLqrTimeout < 1) 10346735Samurai VarLqrTimeout = 30; 10356735Samurai if (argc > 0) { 10366735Samurai VarRetryTimeout = atoi(*argv); 10376735Samurai if (VarRetryTimeout < 1 || VarRetryTimeout > 10) 10386735Samurai VarRetryTimeout = 3; 10396735Samurai } 10406735Samurai } 104126516Sbrian return 0; 10426059Samurai } 104326516Sbrian 104426516Sbrian return -1; 10456059Samurai} 10466059Samurai 10476059Samuraistruct in_addr 10486059SamuraiGetIpAddr(cp) 10496059Samuraichar *cp; 10506059Samurai{ 10516059Samurai struct hostent *hp; 10526059Samurai struct in_addr ipaddr; 10536059Samurai 10546059Samurai hp = gethostbyname(cp); 10556059Samurai if (hp && hp->h_addrtype == AF_INET) 10566059Samurai bcopy(hp->h_addr, &ipaddr, hp->h_length); 10576059Samurai else if (inet_aton(cp, &ipaddr) == 0) 10586059Samurai ipaddr.s_addr = 0; 10596059Samurai return(ipaddr); 10606059Samurai} 10616059Samurai 10626059Samuraistatic int 10636059SamuraiSetInterfaceAddr(list, argc, argv) 10646059Samuraistruct cmdtab *list; 10656059Samuraiint argc; 10666059Samuraichar **argv; 10676059Samurai{ 10686059Samurai 10696059Samurai DefMyAddress.ipaddr.s_addr = DefHisAddress.ipaddr.s_addr = 0L; 107026516Sbrian if (argc > 4) 107126516Sbrian return -1; 107226516Sbrian 10736059Samurai if (argc > 0) { 107425630Sbrian if (ParseAddr(argc, argv++, 107525630Sbrian &DefMyAddress.ipaddr, 107625630Sbrian &DefMyAddress.mask, 107725630Sbrian &DefMyAddress.width) == 0) 107826516Sbrian return 1; 10796059Samurai if (--argc > 0) { 108025630Sbrian if (ParseAddr(argc, argv++, 108125630Sbrian &DefHisAddress.ipaddr, 108225630Sbrian &DefHisAddress.mask, 108325630Sbrian &DefHisAddress.width) == 0) 108426516Sbrian return 2; 10856059Samurai if (--argc > 0) { 10866059Samurai ifnetmask = GetIpAddr(*argv); 10879440Samurai if (--argc > 0) { 108825630Sbrian if (ParseAddr(argc, argv++, 108925630Sbrian &DefTriggerAddress.ipaddr, 109025630Sbrian &DefTriggerAddress.mask, 109125630Sbrian &DefTriggerAddress.width) == 0) 109226516Sbrian return 3; 10939440Samurai } 10946059Samurai } 10956059Samurai } 10966059Samurai } 10976059Samurai /* 10986059Samurai * For backwards compatibility, 0.0.0.0 means any address. 10996059Samurai */ 11006059Samurai if (DefMyAddress.ipaddr.s_addr == 0) { 11016059Samurai DefMyAddress.mask.s_addr = 0; 11026059Samurai DefMyAddress.width = 0; 11036059Samurai } 11046059Samurai if (DefHisAddress.ipaddr.s_addr == 0) { 11056059Samurai DefHisAddress.mask.s_addr = 0; 11066059Samurai DefHisAddress.width = 0; 11076059Samurai } 11086059Samurai 11096735Samurai if ((mode & MODE_AUTO) || 11106059Samurai ((mode & MODE_DEDICATED) && dstsystem)) { 111125630Sbrian if (OsSetIpaddress(DefMyAddress.ipaddr, DefHisAddress.ipaddr, ifnetmask) < 0) 111226516Sbrian return 4; 11136059Samurai } 111426516Sbrian return 0; 11156059Samurai} 11166059Samurai 111726516Sbrian#ifndef NOMSEXT 11186059Samurai 111918752Sjkhvoid 112018752SjkhSetMSEXT(pri_addr, sec_addr, argc, argv) 112118752Sjkhstruct in_addr *pri_addr; 112218752Sjkhstruct in_addr *sec_addr; 112318752Sjkhint argc; 112418752Sjkhchar **argv; 112518752Sjkh{ 112618752Sjkh int dummyint; 112718752Sjkh struct in_addr dummyaddr; 112818752Sjkh 112918752Sjkh pri_addr->s_addr = sec_addr->s_addr = 0L; 113018752Sjkh 113118752Sjkh if( argc > 0 ) { 113218752Sjkh ParseAddr(argc, argv++, pri_addr, &dummyaddr, &dummyint); 113318752Sjkh if( --argc > 0 ) 113418752Sjkh ParseAddr(argc, argv++, sec_addr, &dummyaddr, &dummyint); 113518752Sjkh else 113618752Sjkh sec_addr->s_addr = pri_addr->s_addr; 113718752Sjkh } 113818752Sjkh 113918752Sjkh /* 114018752Sjkh * if the primary/secondary ns entries are 0.0.0.0 we should 114118752Sjkh * set them to either the localhost's ip, or the values in 114218752Sjkh * /etc/resolv.conf ?? 114318752Sjkh * 114418752Sjkh * up to you if you want to implement this... 114518752Sjkh */ 114618752Sjkh 114718752Sjkh} 114818752Sjkh 114918752Sjkhstatic int 115018752SjkhSetNS(list, argc, argv) 115118752Sjkhstruct cmdtab *list; 115218752Sjkhint argc; 115318752Sjkhchar **argv; 115418752Sjkh{ 115518752Sjkh SetMSEXT(&ns_entries[0], &ns_entries[1], argc, argv); 115626516Sbrian return 0; 115718752Sjkh} 115818752Sjkh 115918752Sjkhstatic int 116018752SjkhSetNBNS(list, argc, argv) 116118752Sjkhstruct cmdtab *list; 116218752Sjkhint argc; 116318752Sjkhchar **argv; 116418752Sjkh{ 116518752Sjkh SetMSEXT(&nbns_entries[0], &nbns_entries[1], argc, argv); 116626516Sbrian return 0; 116718752Sjkh} 116818752Sjkh 116918752Sjkh#endif /* MS_EXT */ 117018752Sjkh 11716059Samurai#define VAR_AUTHKEY 0 11726059Samurai#define VAR_DIAL 1 11736059Samurai#define VAR_LOGIN 2 11746059Samurai#define VAR_AUTHNAME 3 11756059Samurai#define VAR_DEVICE 4 11766059Samurai#define VAR_ACCMAP 5 11776059Samurai#define VAR_PHONE 6 117827384Sbrian#define VAR_HANGUP 7 11796059Samurai 11806059Samuraistatic int 11816059SamuraiSetVariable(list, argc, argv, param) 11826059Samuraistruct cmdtab *list; 11836059Samuraiint argc; 11846059Samuraichar **argv; 11856059Samuraiint param; 11866059Samurai{ 11876059Samurai u_long map; 118826551Sbrian char *arg; 11896059Samurai 119026551Sbrian if (argc > 0) 119126551Sbrian arg = *argv; 119226551Sbrian else 119326551Sbrian arg = ""; 119426551Sbrian 119526551Sbrian switch (param) { 11966059Samurai case VAR_AUTHKEY: 119726551Sbrian strncpy(VarAuthKey, arg, sizeof(VarAuthKey)-1); 119821488Simp VarAuthKey[sizeof(VarAuthKey)-1] = '\0'; 11996059Samurai break; 12006059Samurai case VAR_AUTHNAME: 120126551Sbrian strncpy(VarAuthName, arg, sizeof(VarAuthName)-1); 120221488Simp VarAuthName[sizeof(VarAuthName)-1] = '\0'; 12036059Samurai break; 12046059Samurai case VAR_DIAL: 120526551Sbrian strncpy(VarDialScript, arg, sizeof(VarDialScript)-1); 120621488Simp VarDialScript[sizeof(VarDialScript)-1] = '\0'; 12076059Samurai break; 12086059Samurai case VAR_LOGIN: 120926551Sbrian strncpy(VarLoginScript, arg, sizeof(VarLoginScript)-1); 121021488Simp VarLoginScript[sizeof(VarLoginScript)-1] = '\0'; 12116059Samurai break; 12126059Samurai case VAR_DEVICE: 121326516Sbrian CloseModem(); 121426551Sbrian strncpy(VarDevice, arg, sizeof(VarDevice)-1); 121521488Simp VarDevice[sizeof(VarDevice)-1] = '\0'; 121625634Sbrian VarBaseDevice = rindex(VarDevice, '/'); 121725634Sbrian VarBaseDevice = VarBaseDevice ? VarBaseDevice + 1 : ""; 12186059Samurai break; 12196059Samurai case VAR_ACCMAP: 122026551Sbrian sscanf(arg, "%lx", &map); 12216059Samurai VarAccmap = map; 12226059Samurai break; 12236059Samurai case VAR_PHONE: 122426551Sbrian strncpy(VarPhoneList, arg, sizeof(VarPhoneList)-1); 122521488Simp VarPhoneList[sizeof(VarPhoneList)-1] = '\0'; 122614423Sache strcpy(VarPhoneCopy, VarPhoneList); 122714423Sache VarNextPhone = VarPhoneCopy; 12286059Samurai break; 122927384Sbrian case VAR_HANGUP: 123027384Sbrian strncpy(VarHangupScript, arg, sizeof(VarHangupScript)-1); 123127384Sbrian VarHangupScript[sizeof(VarHangupScript)-1] = '\0'; 123227384Sbrian break; 12336059Samurai } 123426516Sbrian return 0; 12356059Samurai} 12366059Samurai 123720812Sjkhstatic int SetCtsRts(list, argc, argv) 123820812Sjkhstruct cmdtab *list; 123920812Sjkhint argc; 124020812Sjkhchar **argv; 124120812Sjkh{ 124220812Sjkh if (argc > 0) { 124320812Sjkh if (strcmp(*argv, "on") == 0) 124420812Sjkh VarCtsRts = TRUE; 124520812Sjkh else if (strcmp(*argv, "off") == 0) 124620812Sjkh VarCtsRts = FALSE; 124720812Sjkh else 124826516Sbrian return -1; 124926516Sbrian return 0; 125020812Sjkh } 125126516Sbrian return -1; 125220812Sjkh} 125320812Sjkh 125420812Sjkh 12556059Samuraistatic int SetOpenMode(list, argc, argv) 12566059Samuraistruct cmdtab *list; 12576059Samuraiint argc; 12586059Samuraichar **argv; 12596059Samurai{ 12606059Samurai if (argc > 0) { 12616059Samurai if (strcmp(*argv, "active") == 0) 12626059Samurai VarOpenMode = OPEN_ACTIVE; 12636059Samurai else if (strcmp(*argv, "passive") == 0) 12646059Samurai VarOpenMode = OPEN_PASSIVE; 12656059Samurai else 126626516Sbrian return -1; 126726516Sbrian return 0; 12686059Samurai } 126926516Sbrian return -1; 12706059Samurai} 12716059Samurai 12726735Samuraiextern int SetIfilter(), SetOfilter(), SetDfilter(), SetAfilter(); 12736059Samurai 127413760Sphkstruct cmdtab const SetCommands[] = { 12756735Samurai { "accmap", NULL, SetVariable, LOCAL_AUTH, 127626516Sbrian "Set accmap value", "set accmap hex-value", (void *)VAR_ACCMAP}, 12776735Samurai { "afilter", NULL, SetAfilter, LOCAL_AUTH, 127826516Sbrian "Set keep Alive filter", "set afilter ..."}, 12796735Samurai { "authkey", "key", SetVariable, LOCAL_AUTH, 128026516Sbrian "Set authentication key", "set authkey|key key", (void *)VAR_AUTHKEY}, 12816735Samurai { "authname", NULL, SetVariable, LOCAL_AUTH, 128226516Sbrian "Set authentication name", "set authname name", (void *)VAR_AUTHNAME}, 128320812Sjkh { "ctsrts", NULL, SetCtsRts, LOCAL_AUTH, 128426516Sbrian "Use CTS/RTS modem signalling", "set ctsrts [on|off]"}, 12856735Samurai { "device", "line", SetVariable, LOCAL_AUTH, 128626516Sbrian "Set modem device name", "set device|line device-name", (void *)VAR_DEVICE}, 12876735Samurai { "dfilter", NULL, SetDfilter, LOCAL_AUTH, 128826516Sbrian "Set demand filter", "set dfilter ..."}, 12896735Samurai { "dial", NULL, SetVariable, LOCAL_AUTH, 129026516Sbrian "Set dialing script", "set dial chat-script", (void *)VAR_DIAL}, 12916735Samurai { "escape", NULL, SetEscape, LOCAL_AUTH, 129226516Sbrian "Set escape characters", "set escape hex-digit ..."}, 129327384Sbrian { "hangup", NULL, SetVariable, LOCAL_AUTH, 129427384Sbrian "Set hangup script", "set hangup chat-script", (void *)VAR_HANGUP}, 12956735Samurai { "ifaddr", NULL, SetInterfaceAddr, LOCAL_AUTH, 129626516Sbrian "Set destination address", "set ifaddr [src-addr [dst-addr [netmask [trg-addr]]]]"}, 12976735Samurai { "ifilter", NULL, SetIfilter, LOCAL_AUTH, 129826516Sbrian "Set input filter", "set ifilter ..."}, 129926516Sbrian { "log", NULL, SetLogLevel, LOCAL_AUTH, 130026516Sbrian "Set log level", "set log [+|-]value..."}, 13016735Samurai { "login", NULL, SetVariable, LOCAL_AUTH, 130226516Sbrian "Set login script", "set login chat-script", (void *)VAR_LOGIN }, 130326321Sbrian { "mru", NULL, SetInitialMRU, LOCAL_AUTH, 130426516Sbrian "Set Initial MRU value", "set mru value" }, 130526326Sbrian { "mtu", NULL, SetPreferredMTU, LOCAL_AUTH, 130626516Sbrian "Set Preferred MTU value", "set mtu value" }, 13076735Samurai { "ofilter", NULL, SetOfilter, LOCAL_AUTH, 130826516Sbrian "Set output filter", "set ofilter ..." }, 13096735Samurai { "openmode", NULL, SetOpenMode, LOCAL_AUTH, 131026516Sbrian "Set open mode", "set openmode [active|passive]"}, 13116735Samurai { "parity", NULL, SetModemParity, LOCAL_AUTH, 131226516Sbrian "Set modem parity", "set parity [odd|even|none]"}, 13136735Samurai { "phone", NULL, SetVariable, LOCAL_AUTH, 131426516Sbrian "Set telephone number(s)", "set phone phone1[:phone2[...]]", (void *)VAR_PHONE }, 131525067Sbrian { "reconnect",NULL, SetReconnect, LOCAL_AUTH, 131626516Sbrian "Set Reconnect timeout", "set reconnect value ntries"}, 131725067Sbrian { "redial", NULL, SetRedialTimeout, LOCAL_AUTH, 131826516Sbrian "Set Redial timeout", "set redial value|random[.value|random] [dial_attempts]"}, 131928327Sbrian { "stopped", NULL, SetStoppedTimeout, LOCAL_AUTH, 132028327Sbrian "Set STOPPED timeout", "set stopped value"}, 132126940Sbrian { "server", "socket", SetServer, LOCAL_AUTH, 132227089Sbrian "Set server port", "set server|socket TcpPort|LocalName|none [mask]"}, 13236735Samurai { "speed", NULL, SetModemSpeed, LOCAL_AUTH, 132426516Sbrian "Set modem speed", "set speed value"}, 13256735Samurai { "timeout", NULL, SetIdleTimeout, LOCAL_AUTH, 132626516Sbrian "Set Idle timeout", "set timeout value"}, 132726516Sbrian#ifndef NOMSEXT 132818752Sjkh { "ns", NULL, SetNS, LOCAL_AUTH, 132926516Sbrian "Set NameServer", "set ns pri-addr [sec-addr]"}, 133018752Sjkh { "nbns", NULL, SetNBNS, LOCAL_AUTH, 133126516Sbrian "Set NetBIOS NameServer", "set nbns pri-addr [sec-addr]"}, 133226516Sbrian#endif 13336735Samurai { "help", "?", HelpCommand, LOCAL_AUTH | LOCAL_NO_AUTH, 133426698Sbrian "Display this message", "set help|? [command]", (void *)SetCommands}, 13356059Samurai { NULL, NULL, NULL }, 13366059Samurai}; 13376059Samurai 13386059Samuraistatic int 13396059SamuraiSetCommand(list, argc, argv) 13406059Samuraistruct cmdtab *list; 13416059Samuraiint argc; 13426059Samuraichar **argv; 13436059Samurai{ 13446059Samurai if (argc > 0) 134526516Sbrian FindExec(SetCommands, argc, argv); 134626516Sbrian else if (VarTerm) 134726516Sbrian fprintf(VarTerm, "Use `set ?' to get a list or `set ? <var>' for" 134826516Sbrian " syntax help.\n"); 13496059Samurai else 135026516Sbrian LogPrintf(LogWARN, "set command must have arguments\n"); 135126516Sbrian 135226516Sbrian return 0; 13536059Samurai} 13546059Samurai 13556059Samurai 13566059Samuraistatic int 13576059SamuraiAddCommand(list, argc, argv) 13586059Samuraistruct cmdtab *list; 13596059Samuraiint argc; 13606059Samuraichar **argv; 13616059Samurai{ 13626059Samurai struct in_addr dest, gateway, netmask; 13636059Samurai 13646059Samurai if (argc == 3) { 136527011Sbrian if (strcasecmp(argv[0], "MYADDR") == 0) 136627011Sbrian dest = IpcpInfo.want_ipaddr; 136727011Sbrian else 136827011Sbrian dest = GetIpAddr(argv[0]); 13696059Samurai netmask = GetIpAddr(argv[1]); 137025566Sbrian if (strcasecmp(argv[2], "HISADDR") == 0) 13716059Samurai gateway = IpcpInfo.his_ipaddr; 13726059Samurai else 13736059Samurai gateway = GetIpAddr(argv[2]); 13746059Samurai OsSetRoute(RTM_ADD, dest, gateway, netmask); 137526516Sbrian return 0; 13766059Samurai } 137726516Sbrian 137826516Sbrian return -1; 13796059Samurai} 13806059Samurai 13816059Samuraistatic int 13826059SamuraiDeleteCommand(list, argc, argv) 13836059Samuraistruct cmdtab *list; 13846059Samuraiint argc; 13856059Samuraichar **argv; 13866059Samurai{ 13876059Samurai struct in_addr dest, gateway, netmask; 13886059Samurai 138926591Sbrian if (argc == 1 && strcasecmp(argv[0], "all") == 0) 139026591Sbrian DeleteIfRoutes(0); 139126591Sbrian else if (argc > 0 && argc < 4) { 139227011Sbrian if (strcasecmp(argv[0], "MYADDR") == 0) 139327011Sbrian dest = IpcpInfo.want_ipaddr; 139427011Sbrian else 139527011Sbrian dest = GetIpAddr(argv[0]); 139626591Sbrian netmask.s_addr = INADDR_ANY; 139726591Sbrian if (argc > 1) { 139826591Sbrian if (strcasecmp(argv[1], "HISADDR") == 0) 139926591Sbrian gateway = IpcpInfo.his_ipaddr; 140026591Sbrian else 140126591Sbrian gateway = GetIpAddr(argv[1]); 140226591Sbrian if (argc == 3) { 140326591Sbrian if (inet_aton(argv[2], &netmask) == 0) { 140426591Sbrian LogPrintf(LogWARN, "Bad netmask value.\n"); 140526591Sbrian return -1; 140626591Sbrian } 14076059Samurai } 140826591Sbrian } else 140926591Sbrian gateway.s_addr = INADDR_ANY; 14106059Samurai OsSetRoute(RTM_DELETE, dest, gateway, netmask); 141126516Sbrian } else 141226516Sbrian return -1; 141326516Sbrian 141426516Sbrian return 0; 14156059Samurai} 14166059Samurai 141726031Sbrianstatic int AliasEnable(); 141826031Sbrianstatic int AliasOption(); 141926031Sbrian 142026031Sbrianstatic struct cmdtab const AliasCommands[] = 142126031Sbrian{ 142226031Sbrian { "enable", NULL, AliasEnable, LOCAL_AUTH, 142326516Sbrian "enable IP aliasing", "alias enable [yes|no]"}, 142426031Sbrian { "port", NULL, AliasRedirectPort, LOCAL_AUTH, 142526516Sbrian "port redirection", "alias port [proto addr_local:port_local port_alias]"}, 142626031Sbrian { "addr", NULL, AliasRedirectAddr, LOCAL_AUTH, 142726516Sbrian "static address translation", "alias addr [addr_local addr_alias]"}, 142826031Sbrian { "deny_incoming", NULL, AliasOption, LOCAL_AUTH, 142926516Sbrian "stop incoming connections", "alias deny_incoming [yes|no]", 143026031Sbrian (void*)PKT_ALIAS_DENY_INCOMING}, 143126031Sbrian { "log", NULL, AliasOption, LOCAL_AUTH, 143226516Sbrian "log aliasing link creation", "alias log [yes|no]", 143326031Sbrian (void*)PKT_ALIAS_LOG}, 143426031Sbrian { "same_ports", NULL, AliasOption, LOCAL_AUTH, 143526516Sbrian "try to leave port numbers unchanged", "alias same_ports [yes|no]", 143626031Sbrian (void*)PKT_ALIAS_SAME_PORTS}, 143726031Sbrian { "use_sockets", NULL, AliasOption, LOCAL_AUTH, 143826516Sbrian "allocate host sockets", "alias use_sockets [yes|no]", 143926031Sbrian (void*)PKT_ALIAS_USE_SOCKETS }, 144026031Sbrian { "unregistered_only", NULL, AliasOption, LOCAL_AUTH, 144126516Sbrian "alias unregistered (private) IP address space only", 144226516Sbrian "alias unregistered_only [yes|no]", 144326031Sbrian (void*)PKT_ALIAS_UNREGISTERED_ONLY}, 144426031Sbrian { "help", "?", HelpCommand, LOCAL_AUTH | LOCAL_NO_AUTH, 144526698Sbrian "Display this message", "alias help|? [command]", 144626031Sbrian (void *)AliasCommands}, 144726031Sbrian { NULL, NULL, NULL }, 144826031Sbrian}; 144926031Sbrian 145026031Sbrian 145126031Sbrianstatic int 145226031SbrianAliasCommand(list, argc, argv) 145326031Sbrianstruct cmdtab *list; 145426031Sbrianint argc; 145526031Sbrianchar **argv; 145626031Sbrian{ 145726031Sbrian if (argc > 0) 145826516Sbrian FindExec(AliasCommands, argc, argv); 145926516Sbrian else if (VarTerm) 146026516Sbrian fprintf(VarTerm, "Use `alias help' to get a list or `alias help <option>'" 146126516Sbrian " for syntax help.\n"); 146226031Sbrian else 146326516Sbrian LogPrintf(LogWARN, "alias command must have arguments\n"); 146426516Sbrian 146526516Sbrian return 0; 146626031Sbrian} 146726031Sbrian 146826031Sbrianstatic int 146926031SbrianAliasEnable(list, argc, argv) 147026031Sbrianstruct cmdtab *list; 147126031Sbrianint argc; 147226031Sbrianchar **argv; 147326031Sbrian{ 147426516Sbrian if (argc == 1) 147526516Sbrian if (strcasecmp(argv[0], "yes") == 0) { 147626516Sbrian if (!(mode & MODE_ALIAS)) { 147726516Sbrian if (loadAliasHandlers(&VarAliasHandlers) == 0) { 147826516Sbrian mode |= MODE_ALIAS; 147926516Sbrian return 0; 148026142Sbrian } 148126516Sbrian LogPrintf(LogWARN, "Cannot load alias library\n"); 148226516Sbrian return 1; 148326516Sbrian } 148426516Sbrian return 0; 148526516Sbrian } else if (strcasecmp(argv[0], "no") == 0) { 148626516Sbrian if (mode & MODE_ALIAS) { 148726516Sbrian unloadAliasHandlers(); 148826516Sbrian mode &= ~MODE_ALIAS; 148926516Sbrian } 149026516Sbrian return 0; 149126142Sbrian } 149226516Sbrian 149326516Sbrian return -1; 149426031Sbrian} 149526031Sbrian 149626031Sbrian 149726031Sbrianstatic int 149826031SbrianAliasOption(list, argc, argv, param) 149926031Sbrianstruct cmdtab *list; 150026031Sbrianint argc; 150126031Sbrianchar **argv; 150226031Sbrianvoid* param; 150326031Sbrian{ 150426516Sbrian if (argc == 1) 150526516Sbrian if (strcasecmp(argv[0], "yes") == 0) { 150626516Sbrian if (mode & MODE_ALIAS) { 150726142Sbrian VarSetPacketAliasMode((unsigned)param, (unsigned)param); 150826516Sbrian return 0; 150926516Sbrian } 151026516Sbrian LogPrintf(LogWARN, "alias not enabled\n"); 151126516Sbrian } else if (strcmp(argv[0], "no") == 0) { 151226516Sbrian if (mode & MODE_ALIAS) { 151326142Sbrian VarSetPacketAliasMode(0, (unsigned)param); 151426516Sbrian return 0; 151526516Sbrian } 151626516Sbrian LogPrintf(LogWARN, "alias not enabled\n"); 151726516Sbrian } 151826516Sbrian 151926516Sbrian return -1; 152026031Sbrian} 1521