command.c revision 25908
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 * 2025908Sbrian * $Id: command.c,v 1.46 1997/05/14 01:18:50 brian Exp $ 218857Srgrimes * 226059Samurai */ 2313379Sphk#include <sys/types.h> 246059Samurai#include <ctype.h> 256735Samurai#include <termios.h> 2613385Speter#include <sys/wait.h> 2713379Sphk#include <time.h> 286059Samurai#include "fsm.h" 296059Samurai#include "phase.h" 306059Samurai#include "lcp.h" 316059Samurai#include "ipcp.h" 326059Samurai#include "modem.h" 3313389Sphk#include "filter.h" 346059Samurai#include "command.h" 356059Samurai#include "hdlc.h" 366059Samurai#include "vars.h" 3725630Sbrian#include "systems.h" 3825630Sbrian#include "chat.h" 396059Samurai#include <netdb.h> 406059Samurai#include <sys/socket.h> 416059Samurai#include <arpa/inet.h> 426059Samurai#include <net/route.h> 436059Samurai#include "os.h" 4410528Samurai#include <paths.h> 4525560Sbrian#include "chat.h" 466059Samurai 476059Samuraiextern void Cleanup(), TtyTermMode(), PacketMode(); 486059Samuraiextern int EnableCommand(), DisableCommand(), DisplayCommand(); 496059Samuraiextern int AcceptCommand(), DenyCommand(); 506735Samuraiextern int LocalAuthCommand(); 516059Samuraiextern int LoadCommand(), SaveCommand(); 526059Samuraiextern int ChangeParity(char *); 536059Samuraiextern int SelectSystem(); 546059Samuraiextern int ShowRoute(); 5510528Samuraiextern void TtyOldMode(), TtyCommandMode(); 566735Samuraiextern struct pppvars pppVars; 5714418Sacheextern struct cmdtab const SetCommands[]; 586059Samurai 5922973Sphkextern char *IfDevName; 6022973Sphk 616059Samuraistruct in_addr ifnetmask; 6223603Sacheint randinit; 636059Samurai 646059Samuraistatic int ShowCommand(), TerminalCommand(), QuitCommand(); 656059Samuraistatic int CloseCommand(), DialCommand(), DownCommand(); 666059Samuraistatic int SetCommand(), AddCommand(), DeleteCommand(); 6710528Samuraistatic int ShellCommand(); 686059Samurai 696059Samuraistatic int 706059SamuraiHelpCommand(list, argc, argv, plist) 716059Samuraistruct cmdtab *list; 726059Samuraiint argc; 736059Samuraichar **argv; 746059Samuraistruct cmdtab *plist; 756059Samurai{ 766059Samurai struct cmdtab *cmd; 776059Samurai int n; 786059Samurai char c; 796059Samurai 806059Samurai if (argc > 0) { 816059Samurai for (cmd = plist; cmd->name; cmd++) { 8225566Sbrian if (strcasecmp(cmd->name, *argv) == 0 && (cmd->lauth & VarLocalAuth)) { 8314418Sache if (plist == SetCommands) 8414418Sache printf("set "); 856059Samurai printf("%s %s\n", cmd->name, cmd->syntax); 866059Samurai return(1); 876059Samurai } 886059Samurai } 896059Samurai return(1); 906059Samurai } 916059Samurai n = 0; 926059Samurai for (cmd = plist; cmd->func; cmd++) { 936764Samurai if (cmd->name && (cmd->lauth & VarLocalAuth)) { 946764Samurai c = (n & 1)? '\n' : '\t'; 956059Samurai printf(" %-8s: %-20s%c", cmd->name, cmd->helpmes, c); 966059Samurai n++; 976059Samurai } 986059Samurai } 996059Samurai if (n & 1) 1006059Samurai printf("\n"); 1016059Samurai return(1); 1026059Samurai} 1036059Samurai 1046059Samuraiint 1056059SamuraiIsInteractive() 1066059Samurai{ 1076059Samurai char *mes = NULL; 1086059Samurai 10920120Snate if (mode & MODE_DDIAL) 11020120Snate mes = "Working in dedicated dial mode."; 11125908Sbrian else if (mode & MODE_BACKGROUND) 11225908Sbrian mes = "Working in background mode."; 11320120Snate else if (mode & MODE_AUTO) 11410528Samurai mes = "Working in auto mode."; 1156059Samurai else if (mode & MODE_DIRECT) 11610528Samurai mes = "Working in direct mode."; 1176059Samurai else if (mode & MODE_DEDICATED) 11810528Samurai mes = "Working in dedicated mode."; 1196059Samurai if (mes) { 1206059Samurai printf("%s\n", mes); 1216059Samurai return(0); 1226059Samurai } 1236059Samurai return(1); 1246059Samurai} 1256059Samurai 1266059Samuraistatic int 1276059SamuraiDialCommand(cmdlist, argc, argv) 1286059Samuraistruct cmdtab *cmdlist; 1296059Samuraiint argc; 1306059Samuraichar **argv; 1316059Samurai{ 13211336Samurai int tries; 13311336Samurai 1346059Samurai if (LcpFsm.state > ST_CLOSED) { 1356059Samurai printf("LCP state is [%s]\n", StateNames[LcpFsm.state]); 1366059Samurai return(1); 1376059Samurai } 1386059Samurai if (!IsInteractive()) 1396059Samurai return(1); 1406735Samurai if (argc > 0) { 1416735Samurai if (SelectSystem(*argv, CONFFILE) < 0) { 1426735Samurai printf("%s: not found.\n", *argv); 1436735Samurai return(1); 1446735Samurai } 1456735Samurai } 14611336Samurai tries = 0; 14711336Samurai do { 14825801Sbrian printf("Dial attempt %u of %d\n", ++tries, VarDialTries); 14911336Samurai modem = OpenModem(mode); 15011336Samurai if (modem < 0) { 15111336Samurai printf("failed to open modem.\n"); 15211336Samurai break; 15311336Samurai } 15411336Samurai if (DialModem()) { 15511336Samurai sleep(1); 15611336Samurai ModemTimeout(); 15711336Samurai PacketMode(); 15811336Samurai break; 15911336Samurai } 16011336Samurai } while (VarDialTries == 0 || tries < VarDialTries); 1616059Samurai return(1); 1626059Samurai} 1636059Samurai 16410528Samuraistatic int 16510528SamuraiShellCommand(cmdlist, argc, argv) 16610528Samuraistruct cmdtab *cmdlist; 16710528Samuraiint argc; 16810528Samuraichar **argv; 16910528Samurai{ 17010528Samurai const char *shell; 17110528Samurai pid_t shpid; 17220813Sjkh 17310528Samurai if((shell = getenv("SHELL")) == 0) { 17410528Samurai shell = _PATH_BSHELL; 17510528Samurai } 17618856Ssos#ifdef SHELL_ONLY_INTERACTIVELY 17710528Samurai#ifndef HAVE_SHELL_CMD_WITH_ANY_MODE 17810528Samurai if( mode != MODE_INTER) { 17910528Samurai fprintf(stdout, 18018911Ssos "Can only start a shell in interactive mode\n"); 18110528Samurai return(1); 18210528Samurai } 18310528Samurai#else 18410528Samurai if(argc == 0 && !(mode & MODE_INTER)) { 18510528Samurai fprintf(stderr, 18618911Ssos "Can only start an interactive shell in interactive mode\n"); 18710528Samurai return(1); 18810528Samurai } 18910528Samurai#endif /* HAVE_SHELL_CMD_WITH_ANY_MODE */ 19018911Ssos#else 19118911Ssos if ((mode & (MODE_AUTO|MODE_INTER)) == (MODE_AUTO|MODE_INTER)) { 19218911Ssos fprintf(stdout, 19318911Ssos "Shell is not allowed interactively in auto mode\n"); 19418911Ssos return(1); 19518911Ssos } 19618856Ssos#endif /* SHELL_ONLY_INTERACTIVELY */ 19710528Samurai if((shpid = fork()) == 0) { 19818531Sbde int dtablesize, i ; 19918531Sbde 20018531Sbde for (dtablesize = getdtablesize(), i = 3; i < dtablesize; i++) 20110528Samurai (void)close(i); 20210528Samurai 20310528Samurai /* 20410528Samurai * We are running setuid, we should change to 20510528Samurai * real user for avoiding security problems. 20610528Samurai */ 20716263Sache if (setgid(getgid()) < 0) { 20816263Sache perror("setgid"); 20916263Sache exit(1); 21016263Sache } 21116263Sache if (setuid(getuid()) < 0) { 21216263Sache perror("setuid"); 21316263Sache exit(1); 21416263Sache } 21510528Samurai TtyOldMode(); 21618790Ssos if(argc > 0) { 21718790Ssos /* substitute pseudo args */ 21818790Ssos for (i=1; i<argc; i++) { 21925566Sbrian if (strcasecmp(argv[i], "HISADDR") == 0) { 22018790Ssos argv[i] = strdup(inet_ntoa(IpcpInfo.his_ipaddr)); 22118790Ssos } 22225566Sbrian if (strcasecmp(argv[i], "INTERFACE") == 0) { 22322973Sphk argv[i] = strdup(IfDevName); 22422973Sphk } 22525566Sbrian if (strcasecmp(argv[i], "MYADDR") == 0) { 22618790Ssos argv[i] = strdup(inet_ntoa(IpcpInfo.want_ipaddr)); 22718790Ssos } 22818790Ssos } 22925630Sbrian (void)execvp(argv[0], argv); 23018790Ssos } 23110528Samurai else 23225630Sbrian (void)execl(shell, shell, NULL); 23320813Sjkh 23410528Samurai fprintf(stdout, "exec() of %s failed\n", argc > 0? argv[0]: shell); 23510528Samurai exit(255); 23610528Samurai } 23710528Samurai if( shpid == (pid_t)-1 ) { 23810528Samurai fprintf(stdout, "Fork failed\n"); 23910528Samurai } else { 24010528Samurai int status; 24110528Samurai (void)waitpid(shpid, &status, 0); 24210528Samurai } 24320813Sjkh 24410528Samurai TtyCommandMode(1); 24520813Sjkh 24610528Samurai return(0); 24710528Samurai} 24810528Samurai 2496059Samuraistatic char StrOption[] = "option .."; 2506059Samuraistatic char StrRemote[] = "[remote]"; 2516059Samuraichar StrNull[] = ""; 2526059Samurai 25313760Sphkstruct cmdtab const Commands[] = { 2546735Samurai { "accept", NULL, AcceptCommand, LOCAL_AUTH, 2556735Samurai "accept option request", StrOption}, 2566735Samurai { "add", NULL, AddCommand, LOCAL_AUTH, 2576735Samurai "add route", "dest mask gateway"}, 2586735Samurai { "close", NULL, CloseCommand, LOCAL_AUTH, 2596735Samurai "Close connection", StrNull}, 2606735Samurai { "delete", NULL, DeleteCommand, LOCAL_AUTH, 26114418Sache "delete route", "ALL | dest gateway [mask]"}, 2626735Samurai { "deny", NULL, DenyCommand, LOCAL_AUTH, 2636735Samurai "Deny option request", StrOption}, 2646735Samurai { "dial", "call", DialCommand, LOCAL_AUTH, 2656735Samurai "Dial and login", StrRemote}, 2666735Samurai { "disable", NULL, DisableCommand, LOCAL_AUTH, 2676735Samurai "Disable option", StrOption}, 2686735Samurai { "display", NULL, DisplayCommand, LOCAL_AUTH, 2696735Samurai "Display option configs", StrNull}, 2706735Samurai { "enable", NULL, EnableCommand, LOCAL_AUTH, 2716735Samurai "Enable option", StrOption}, 2726764Samurai { "passwd", NULL, LocalAuthCommand,LOCAL_NO_AUTH, 2739240Sphk "Password for manipulation", StrOption}, 2746735Samurai { "load", NULL, LoadCommand, LOCAL_AUTH, 2756735Samurai "Load settings", StrRemote}, 2766735Samurai { "save", NULL, SaveCommand, LOCAL_AUTH, 2776735Samurai "Save settings", StrNull}, 2786735Samurai { "set", "setup", SetCommand, LOCAL_AUTH, 2796735Samurai "Set parameters", "var value"}, 28010528Samurai { "shell", "!", ShellCommand, LOCAL_AUTH, 28110528Samurai "Run a subshell", "[sh command]"}, 2826735Samurai { "show", NULL, ShowCommand, LOCAL_AUTH, 2836735Samurai "Show status and statictics", "var"}, 2846735Samurai { "term", NULL, TerminalCommand,LOCAL_AUTH, 2856735Samurai "Enter to terminal mode", StrNull}, 2866764Samurai { "quit", "bye", QuitCommand, LOCAL_AUTH | LOCAL_NO_AUTH, 28714418Sache "Quit PPP program", "[all]"}, 2886735Samurai { "help", "?", HelpCommand, LOCAL_AUTH | LOCAL_NO_AUTH, 2896059Samurai "Display this message", "[command]", (void *)Commands }, 2906735Samurai { NULL, "down", DownCommand, LOCAL_AUTH, 2916735Samurai "Generate down event", StrNull}, 2926059Samurai { NULL, NULL, NULL }, 2936059Samurai}; 2946059Samurai 2956059Samuraiextern int ReportCcpStatus(); 2966059Samuraiextern int ReportLcpStatus(); 2976059Samuraiextern int ReportIpcpStatus(); 2986059Samuraiextern int ReportProtStatus(); 2996059Samuraiextern int ReportCompress(); 3006059Samuraiextern int ShowModemStatus(); 3016059Samuraiextern int ReportHdlcStatus(); 3026059Samuraiextern int ShowMemMap(); 3036059Samurai 3046059Samuraistatic char *LogLevelName[] = { 30515738Sphk LM_PHASE, LM_CHAT, LM_LQM, LM_LCP, 30615738Sphk LM_TCPIP, LM_HDLC, LM_ASYNC, LM_LINK, 30715738Sphk LM_CONNECT, LM_CARRIER, 3086059Samurai}; 3096059Samurai 3106059Samuraistatic int ShowDebugLevel() 3116059Samurai{ 3126059Samurai int i; 3136059Samurai 3146059Samurai printf("%02x: ", loglevel); 3156059Samurai for (i = LOG_PHASE; i < MAXLOGLEVEL; i++) { 3166059Samurai if (loglevel & (1 << i)) 3176059Samurai printf("%s ", LogLevelName[i]); 3186059Samurai } 3196059Samurai printf("\n"); 3206059Samurai return(1); 3216059Samurai} 3226059Samurai 3236059Samuraistatic int ShowEscape() 3246059Samurai{ 3256059Samurai int code, bit; 3266059Samurai 3276059Samurai if (EscMap[32]) { 3286059Samurai for (code = 0; code < 32; code++) { 3296059Samurai if (EscMap[code]) { 3306059Samurai for (bit = 0; bit < 8; bit++) { 3316059Samurai if (EscMap[code] & (1<<bit)) { 3326059Samurai printf(" 0x%02x", (code << 3) + bit); 3336059Samurai } 3346059Samurai } 3356059Samurai } 3366059Samurai } 3376059Samurai printf("\n"); 3386059Samurai } 3396059Samurai return(1); 3406059Samurai} 3416059Samurai 3426059Samuraistatic int ShowTimeout() 3436059Samurai{ 3446735Samurai printf(" Idle Timer: %d secs LQR Timer: %d secs Retry Timer: %d secs\n", 3456735Samurai VarIdleTimeout, VarLqrTimeout, VarRetryTimeout); 3466059Samurai return(1); 3476059Samurai} 3486059Samurai 3496059Samuraistatic int ShowAuthKey() 3506059Samurai{ 3516059Samurai printf("AuthName = %s\n", VarAuthName); 3526059Samurai printf("AuthKey = %s\n", VarAuthKey); 3536059Samurai return(1); 3546059Samurai} 3556059Samurai 3566059Samuraistatic int ShowVersion() 3576059Samurai{ 35813389Sphk extern char VarVersion[]; 35913389Sphk extern char VarLocalVersion[]; 3606059Samurai 3619448Samurai printf("%s - %s \n", VarVersion, VarLocalVersion); 3626059Samurai return(1); 3636059Samurai} 3646059Samurai 3656059Samuraistatic int ShowLogList() 3666059Samurai{ 3676059Samurai ListLog(); 3686059Samurai return(1); 3696059Samurai} 3706059Samurai 37125067Sbrianstatic int ShowReconnect() 37225067Sbrian{ 37325067Sbrian printf(" Reconnect Timer: %d, %d tries\n", 37425067Sbrian VarReconnectTimer, VarReconnectTries); 37525067Sbrian return(1); 37625067Sbrian} 37725067Sbrian 37811336Samuraistatic int ShowRedial() 37911336Samurai{ 38011336Samurai printf(" Redial Timer: "); 38111336Samurai 38211336Samurai if (VarRedialTimeout >= 0) { 38311336Samurai printf(" %d seconds, ", VarRedialTimeout); 38411336Samurai } 38511336Samurai else { 38611336Samurai printf(" Random 0 - %d seconds, ", REDIAL_PERIOD); 38711336Samurai } 38811336Samurai 38924939Sbrian printf(" Redial Next Timer: "); 39024939Sbrian 39124939Sbrian if (VarRedialNextTimeout >= 0) { 39224939Sbrian printf(" %d seconds, ", VarRedialNextTimeout); 39324939Sbrian } 39424939Sbrian else { 39524939Sbrian printf(" Random 0 - %d seconds, ", REDIAL_PERIOD); 39624939Sbrian } 39724939Sbrian 39811336Samurai if (VarDialTries) 39911336Samurai printf("%d dial tries", VarDialTries); 40011336Samurai 40111336Samurai printf("\n"); 40211336Samurai 40311336Samurai return(1); 40411336Samurai} 40511336Samurai 40618752Sjkh#ifdef MSEXT 40718752Sjkhstatic int ShowMSExt() 40818752Sjkh{ 40918752Sjkh printf(" MS PPP extention values \n" ); 41018752Sjkh printf(" Primary NS : %s\n", inet_ntoa( ns_entries[0] )); 41118752Sjkh printf(" Secondary NS : %s\n", inet_ntoa( ns_entries[1] )); 41218752Sjkh printf(" Primary NBNS : %s\n", inet_ntoa( nbns_entries[0] )); 41318752Sjkh printf(" Secondary NBNS : %s\n", inet_ntoa( nbns_entries[1] )); 41411336Samurai 41518752Sjkh return(1); 41618752Sjkh} 41718752Sjkh#endif /* MSEXT */ 41818752Sjkh 4196735Samuraiextern int ShowIfilter(), ShowOfilter(), ShowDfilter(), ShowAfilter(); 4206059Samurai 42113760Sphkstruct cmdtab const ShowCommands[] = { 4226735Samurai { "afilter", NULL, ShowAfilter, LOCAL_AUTH, 4236735Samurai "Show keep Alive filters", StrOption}, 4246735Samurai { "auth", NULL, ShowAuthKey, LOCAL_AUTH, 4256735Samurai "Show auth name/key", StrNull}, 4266735Samurai { "ccp", NULL, ReportCcpStatus, LOCAL_AUTH, 4276735Samurai "Show CCP status", StrNull}, 4286735Samurai { "compress", NULL, ReportCompress, LOCAL_AUTH, 4296735Samurai "Show compression statictics", StrNull}, 4306735Samurai { "debug", NULL, ShowDebugLevel, LOCAL_AUTH, 4316735Samurai "Show current debug level", StrNull}, 4326735Samurai { "dfilter", NULL, ShowDfilter, LOCAL_AUTH, 4336735Samurai "Show Demand filters", StrOption}, 4346735Samurai { "escape", NULL, ShowEscape, LOCAL_AUTH, 4356735Samurai "Show escape characters", StrNull}, 4366735Samurai { "hdlc", NULL, ReportHdlcStatus, LOCAL_AUTH, 4376735Samurai "Show HDLC error summary", StrNull}, 4386735Samurai { "ifilter", NULL, ShowIfilter, LOCAL_AUTH, 4396735Samurai "Show Input filters", StrOption}, 4406735Samurai { "ipcp", NULL, ReportIpcpStatus, LOCAL_AUTH, 4416735Samurai "Show IPCP status", StrNull}, 4426735Samurai { "lcp", NULL, ReportLcpStatus, LOCAL_AUTH, 4436735Samurai "Show LCP status", StrNull}, 4446735Samurai { "log", NULL, ShowLogList, LOCAL_AUTH, 4456735Samurai "Show log records", StrNull}, 4466735Samurai { "mem", NULL, ShowMemMap, LOCAL_AUTH, 4476735Samurai "Show memory map", StrNull}, 4486735Samurai { "modem", NULL, ShowModemStatus, LOCAL_AUTH, 4496735Samurai "Show modem setups", StrNull}, 4506735Samurai { "ofilter", NULL, ShowOfilter, LOCAL_AUTH, 4516735Samurai "Show Output filters", StrOption}, 4526735Samurai { "proto", NULL, ReportProtStatus, LOCAL_AUTH, 4536735Samurai "Show protocol summary", StrNull}, 45425067Sbrian { "reconnect",NULL, ShowReconnect, LOCAL_AUTH, 45525690Sache "Show Reconnect timer,tries", StrNull}, 45625067Sbrian { "redial", NULL, ShowRedial, LOCAL_AUTH, 45725067Sbrian "Show Redial timeout value", StrNull}, 4586735Samurai { "route", NULL, ShowRoute, LOCAL_AUTH, 4596735Samurai "Show routing table", StrNull}, 4606735Samurai { "timeout", NULL, ShowTimeout, LOCAL_AUTH, 4616735Samurai "Show Idle timeout value", StrNull}, 46218752Sjkh#ifdef MSEXT 46318752Sjkh { "msext", NULL, ShowMSExt, LOCAL_AUTH, 46423598Sache "Show MS PPP extentions", StrNull}, 46518752Sjkh#endif /* MSEXT */ 4666735Samurai { "version", NULL, ShowVersion, LOCAL_NO_AUTH | LOCAL_AUTH, 4676735Samurai "Show version string", StrNull}, 4686735Samurai { "help", "?", HelpCommand, LOCAL_NO_AUTH | LOCAL_AUTH, 4696735Samurai "Display this message", StrNull, (void *)ShowCommands}, 4706059Samurai { NULL, NULL, NULL }, 4716059Samurai}; 4726059Samurai 4736059Samuraistruct cmdtab * 4746059SamuraiFindCommand(cmds, str, pmatch) 4756059Samuraistruct cmdtab *cmds; 4766059Samuraichar *str; 4776059Samuraiint *pmatch; 4786059Samurai{ 4796059Samurai int nmatch = 0; 4806059Samurai int len = strlen(str); 4816059Samurai struct cmdtab *found = NULL; 4826059Samurai 4836059Samurai while (cmds->func) { 48425566Sbrian if (cmds->name && strncasecmp(str, cmds->name, len) == 0) { 4856059Samurai nmatch++; 4866059Samurai found = cmds; 48725566Sbrian } else if (cmds->alias && strncasecmp(str, cmds->alias, len) == 0) { 4886059Samurai nmatch++; 4896059Samurai found = cmds; 4906059Samurai } 4916059Samurai cmds++; 4926059Samurai } 4936059Samurai *pmatch = nmatch; 4946059Samurai return(found); 4956059Samurai} 4966059Samurai 4976059Samuraiint 4986059SamuraiFindExec(cmdlist, argc, argv) 4996059Samuraistruct cmdtab *cmdlist; 5006059Samuraiint argc; 5016059Samuraichar **argv; 5026059Samurai{ 5036059Samurai struct cmdtab *cmd; 5046059Samurai int val = 1; 5056059Samurai int nmatch; 5066059Samurai 5076059Samurai cmd = FindCommand(cmdlist, *argv, &nmatch); 5086059Samurai if (nmatch > 1) 5096735Samurai printf("Ambiguous.\n"); 5106735Samurai else if (cmd && ( cmd->lauth & VarLocalAuth ) ) 5116059Samurai val = (cmd->func)(cmd, --argc, ++argv, cmd->args); 5126059Samurai else 5136059Samurai printf("what?\n"); 5146059Samurai return(val); 5156059Samurai} 5166059Samurai 51718885Sjkhint aft_cmd = 1; 51818885Sjkh 5196059Samuraivoid 52018885SjkhPrompt() 5216059Samurai{ 5226735Samurai char *pconnect, *pauth; 5236735Samurai 5246059Samurai if (!(mode & MODE_INTER)) 5256059Samurai return; 5266735Samurai 52718885Sjkh if (!aft_cmd) 52818885Sjkh printf("\n"); 52918885Sjkh else 53018885Sjkh aft_cmd = 0; 5316735Samurai 5326735Samurai if ( VarLocalAuth == LOCAL_AUTH ) 5336735Samurai pauth = " ON "; 5346735Samurai else 5356735Samurai pauth = " on "; 5366059Samurai if (IpcpFsm.state == ST_OPENED && phase == PHASE_NETWORK) 5376735Samurai pconnect = "PPP"; 5386059Samurai else 5396735Samurai pconnect = "ppp"; 5406735Samurai printf("%s%s%s> ", pconnect, pauth, VarShortHost); 5416059Samurai fflush(stdout); 5426059Samurai} 5436059Samurai 5446059Samuraivoid 5456059SamuraiDecodeCommand(buff, nb, prompt) 5466059Samuraichar *buff; 5476059Samuraiint nb; 5486059Samuraiint prompt; 5496059Samurai{ 5506059Samurai char *vector[20]; 5516059Samurai char **argv; 5526059Samurai int argc, val; 5536059Samurai char *cp; 5546059Samurai 5556059Samurai val = 1; 5566059Samurai if (nb > 0) { 5576059Samurai cp = buff + strcspn(buff, "\r\n"); 5586059Samurai if (cp) 5596059Samurai *cp = '\0'; 5606059Samurai { 56125560Sbrian argc = MakeArgs(buff, vector, VECSIZE(vector)); 5626059Samurai argv = vector; 5636059Samurai 5646059Samurai if (argc > 0) 5656059Samurai val = FindExec(Commands, argc, argv); 5666059Samurai } 5676059Samurai } 5686059Samurai if (val && prompt) 56925630Sbrian Prompt(); 5706059Samurai} 5716059Samurai 5726059Samuraistatic int 5736059SamuraiShowCommand(list, argc, argv) 5746059Samuraistruct cmdtab *list; 5756059Samuraiint argc; 5766059Samuraichar **argv; 5776059Samurai{ 5786059Samurai int val = 1; 5796059Samurai 5806059Samurai if (argc > 0) 5816059Samurai val = FindExec(ShowCommands, argc, argv); 5826059Samurai else 5836059Samurai printf("Use ``show ?'' to get a list.\n"); 5846059Samurai return(val); 5856059Samurai} 5866059Samurai 5876059Samuraistatic int 5886059SamuraiTerminalCommand() 5896059Samurai{ 5906059Samurai if (LcpFsm.state > ST_CLOSED) { 5916059Samurai printf("LCP state is [%s]\n", StateNames[LcpFsm.state]); 5926059Samurai return(1); 5936059Samurai } 5946059Samurai if (!IsInteractive()) 5956059Samurai return(1); 5966059Samurai modem = OpenModem(mode); 5976059Samurai if (modem < 0) { 5986059Samurai printf("failed to open modem.\n"); 5996059Samurai return(1); 6006059Samurai } 6016059Samurai printf("Enter to terminal mode.\n"); 6026059Samurai printf("Type `~?' for help.\n"); 6036059Samurai TtyTermMode(); 6046059Samurai return(0); 6056059Samurai} 6066059Samurai 6076059Samuraistatic int 6086059SamuraiQuitCommand(list, argc, argv) 6096059Samuraistruct cmdtab *list; 6106059Samuraiint argc; 6116059Samuraichar **argv; 6126059Samurai{ 6136059Samurai if (mode & (MODE_DIRECT|MODE_DEDICATED|MODE_AUTO)) { 6146764Samurai if (argc > 0 && (VarLocalAuth & LOCAL_AUTH)) { 6156059Samurai Cleanup(EX_NORMAL); 61618911Ssos mode &= ~MODE_INTER; 6176059Samurai } else { 61824753Sache LogPrintf(LOG_PHASE_BIT, "client connection closed.\n"); 6196735Samurai VarLocalAuth = LOCAL_NO_AUTH; 6206059Samurai close(netfd); 6216059Samurai close(1); 6227886Samurai dup2(2, 1); /* Have to have something here or the modem will be 1 */ 6236059Samurai netfd = -1; 6246059Samurai mode &= ~MODE_INTER; 6256059Samurai } 6266059Samurai } else 6276059Samurai Cleanup(EX_NORMAL); 6286059Samurai return(1); 6296059Samurai} 6306059Samurai 6316059Samuraistatic int 6326059SamuraiCloseCommand() 6336059Samurai{ 6346059Samurai LcpClose(); 63525908Sbrian reconnectCount = 0; 63625908Sbrian if (mode & MODE_BACKGROUND) 63725908Sbrian Cleanup(EX_NORMAL); 6386059Samurai return(1); 6396059Samurai} 6406059Samurai 6416059Samuraistatic int 6426059SamuraiDownCommand() 6436059Samurai{ 6446059Samurai LcpDown(); 6456059Samurai return(1); 6466059Samurai} 6476059Samurai 64825067Sbrianstatic int 64925067SbrianSetModemSpeed(list, argc, argv) 6506059Samuraistruct cmdtab *list; 6516059Samuraiint argc; 6526059Samuraichar **argv; 6536059Samurai{ 6546059Samurai int speed; 6556059Samurai 6566059Samurai if (argc > 0) { 6576735Samurai if (strcmp(*argv, "sync") == 0) { 6586735Samurai VarSpeed = 0; 6596735Samurai return(1); 6606735Samurai } 6616059Samurai speed = atoi(*argv); 6626735Samurai if (IntToSpeed(speed) != B0) { 6636735Samurai VarSpeed = speed; 6646735Samurai return(1); 6656059Samurai } 6666059Samurai printf("invalid speed.\n"); 6676059Samurai } 6686059Samurai return(1); 6696059Samurai} 6706059Samurai 67125067Sbrianstatic int 67225067SbrianSetReconnect(list, argc, argv) 67311336Samuraistruct cmdtab *list; 67411336Samuraiint argc; 67511336Samuraichar **argv; 67611336Samurai{ 67725067Sbrian if (argc == 2) { 67825067Sbrian VarReconnectTimer = atoi(argv[0]); 67925067Sbrian VarReconnectTries = atoi(argv[1]); 68025067Sbrian } else 68125067Sbrian printf("Usage: %s %s\n", list->name, list->syntax); 68225067Sbrian return(1); 68325067Sbrian} 68425067Sbrian 68525067Sbrianstatic int 68625067SbrianSetRedialTimeout(list, argc, argv) 68725067Sbrianstruct cmdtab *list; 68825067Sbrianint argc; 68925067Sbrianchar **argv; 69025067Sbrian{ 69111336Samurai int timeout; 69211336Samurai int tries; 69324939Sbrian char *dot; 69411336Samurai 69511336Samurai if (argc == 1 || argc == 2 ) { 69624939Sbrian if (strncasecmp(argv[0], "random", 6) == 0 && 69724939Sbrian (argv[0][6] == '\0' || argv[0][6] == '.')) { 69811336Samurai VarRedialTimeout = -1; 69911336Samurai printf("Using random redial timeout.\n"); 70023603Sache if (!randinit) { 70123603Sache randinit = 1; 70224217Sache if (srandomdev() < 0) 70324217Sache srandom((unsigned long)(time(NULL) ^ getpid())); 70423603Sache } 70511336Samurai } 70611336Samurai else { 70711336Samurai timeout = atoi(argv[0]); 70811336Samurai 70911336Samurai if (timeout >= 0) { 71011336Samurai VarRedialTimeout = timeout; 71111336Samurai } 71211336Samurai else { 71311336Samurai printf("invalid redial timeout\n"); 71411336Samurai printf("Usage: %s %s\n", list->name, list->syntax); 71511336Samurai } 71611336Samurai } 71724939Sbrian 71824939Sbrian dot = index(argv[0],'.'); 71924939Sbrian if (dot) { 72024939Sbrian if (strcasecmp(++dot, "random") == 0) { 72124939Sbrian VarRedialNextTimeout = -1; 72224939Sbrian printf("Using random next redial timeout.\n"); 72324939Sbrian if (!randinit) { 72424939Sbrian randinit = 1; 72524939Sbrian if (srandomdev() < 0) 72624939Sbrian srandom((unsigned long)(time(NULL) ^ getpid())); 72724939Sbrian } 72824939Sbrian } 72924939Sbrian else { 73024939Sbrian timeout = atoi(dot); 73124939Sbrian if (timeout >= 0) { 73224939Sbrian VarRedialNextTimeout = timeout; 73324939Sbrian } 73424939Sbrian else { 73524939Sbrian printf("invalid next redial timeout\n"); 73624939Sbrian printf("Usage: %s %s\n", list->name, list->syntax); 73724939Sbrian } 73824939Sbrian } 73924939Sbrian } 74024939Sbrian else 74124939Sbrian VarRedialNextTimeout = NEXT_REDIAL_PERIOD; /* Default next timeout */ 74224939Sbrian 74311336Samurai if (argc == 2) { 74411336Samurai tries = atoi(argv[1]); 74511336Samurai 74611336Samurai if (tries >= 0) { 74711336Samurai VarDialTries = tries; 74811336Samurai } 74911336Samurai else { 75011336Samurai printf("invalid retry value\n"); 75111336Samurai printf("Usage: %s %s\n", list->name, list->syntax); 75211336Samurai } 75311336Samurai } 75411336Samurai } 75511336Samurai else { 75611336Samurai printf("Usage: %s %s\n", list->name, list->syntax); 75711336Samurai } 75811336Samurai return(1); 75911336Samurai} 76011336Samurai 76125067Sbrianstatic int 76225067SbrianSetModemParity(list, argc, argv) 7636059Samuraistruct cmdtab *list; 7646059Samuraiint argc; 7656059Samuraichar **argv; 7666059Samurai{ 7676059Samurai int parity; 7686059Samurai 7696059Samurai if (argc > 0) { 7706059Samurai parity = ChangeParity(*argv); 7716059Samurai if (parity < 0) 7726059Samurai printf("Invalid parity.\n"); 7736059Samurai else 7746059Samurai VarParity = parity; 7756059Samurai } 7766059Samurai return(1); 7776059Samurai} 7786059Samurai 7796059Samuraistatic int 7806059SamuraiSetDebugLevel(list, argc, argv) 7816059Samuraistruct cmdtab *list; 7826059Samuraiint argc; 7836059Samuraichar **argv; 7846059Samurai{ 7856059Samurai int level, w; 7866059Samurai 7876059Samurai for (level = 0; argc-- > 0; argv++) { 7886059Samurai if (isdigit(**argv)) { 7896059Samurai w = atoi(*argv); 7906059Samurai if (w < 0 || w >= MAXLOGLEVEL) { 7916059Samurai printf("invalid log level.\n"); 7926059Samurai break; 7936059Samurai } else 7946059Samurai level |= (1 << w); 7956059Samurai } else { 7966059Samurai for (w = 0; w < MAXLOGLEVEL; w++) { 7976059Samurai if (strcasecmp(*argv, LogLevelName[w]) == 0) { 7986059Samurai level |= (1 << w); 7996059Samurai continue; 8006059Samurai } 8016059Samurai } 8026059Samurai } 8036059Samurai } 8046059Samurai loglevel = level; 8056059Samurai return(1); 8066059Samurai} 8076059Samurai 8086059Samuraistatic int 8096059SamuraiSetEscape(list, argc, argv) 8106059Samuraistruct cmdtab *list; 8116059Samuraiint argc; 8126059Samuraichar **argv; 8136059Samurai{ 8146059Samurai int code; 8156059Samurai 8166059Samurai for (code = 0; code < 33; code++) 8176059Samurai EscMap[code] = 0; 8186059Samurai while (argc-- > 0) { 8196059Samurai sscanf(*argv++, "%x", &code); 8206059Samurai code &= 0xff; 8216059Samurai EscMap[code >> 3] |= (1 << (code&7)); 8226059Samurai EscMap[32] = 1; 8236059Samurai } 8246059Samurai return(1); 8256059Samurai} 8266059Samurai 8276059Samuraistatic int 8286059SamuraiSetInitialMRU(list, argc, argv) 8296059Samuraistruct cmdtab *list; 8306059Samuraiint argc; 8316059Samuraichar **argv; 8326059Samurai{ 8336059Samurai int mru; 8346059Samurai 8356059Samurai if (argc > 0) { 8366059Samurai mru = atoi(*argv); 8376059Samurai if (mru < 100) 8386059Samurai printf("given value is too small.\n"); 8396059Samurai else if (mru > MAX_MRU) 8406059Samurai printf("given value is too big.\n"); 8416059Samurai else 8426059Samurai VarMRU = mru; 8436059Samurai } 8446059Samurai return(1); 8456059Samurai} 8466059Samurai 8476059Samuraistatic int 8486059SamuraiSetIdleTimeout(list, argc, argv) 8496059Samuraistruct cmdtab *list; 8506059Samuraiint argc; 8516059Samuraichar **argv; 8526059Samurai{ 8536059Samurai if (argc-- > 0) { 8546059Samurai VarIdleTimeout = atoi(*argv++); 8556735Samurai if (argc-- > 0) { 8566735Samurai VarLqrTimeout = atoi(*argv++); 8576735Samurai if (VarLqrTimeout < 1) 8586735Samurai VarLqrTimeout = 30; 8596735Samurai if (argc > 0) { 8606735Samurai VarRetryTimeout = atoi(*argv); 8616735Samurai if (VarRetryTimeout < 1 || VarRetryTimeout > 10) 8626735Samurai VarRetryTimeout = 3; 8636735Samurai } 8646735Samurai } 8656059Samurai } 8666059Samurai return(1); 8676059Samurai} 8686059Samurai 8696059Samuraistruct in_addr 8706059SamuraiGetIpAddr(cp) 8716059Samuraichar *cp; 8726059Samurai{ 8736059Samurai struct hostent *hp; 8746059Samurai struct in_addr ipaddr; 8756059Samurai 8766059Samurai hp = gethostbyname(cp); 8776059Samurai if (hp && hp->h_addrtype == AF_INET) 8786059Samurai bcopy(hp->h_addr, &ipaddr, hp->h_length); 8796059Samurai else if (inet_aton(cp, &ipaddr) == 0) 8806059Samurai ipaddr.s_addr = 0; 8816059Samurai return(ipaddr); 8826059Samurai} 8836059Samurai 8846059Samuraistatic int 8856059SamuraiSetInterfaceAddr(list, argc, argv) 8866059Samuraistruct cmdtab *list; 8876059Samuraiint argc; 8886059Samuraichar **argv; 8896059Samurai{ 8906059Samurai 8916059Samurai DefMyAddress.ipaddr.s_addr = DefHisAddress.ipaddr.s_addr = 0L; 89225630Sbrian if (argc > 4) { 89325630Sbrian printf("set ifaddr: too many arguments (%d > 4)\n", argc); 89425630Sbrian return(0); 89525630Sbrian } 8966059Samurai if (argc > 0) { 89725630Sbrian if (ParseAddr(argc, argv++, 89825630Sbrian &DefMyAddress.ipaddr, 89925630Sbrian &DefMyAddress.mask, 90025630Sbrian &DefMyAddress.width) == 0) 90125630Sbrian return(0); 9026059Samurai if (--argc > 0) { 90325630Sbrian if (ParseAddr(argc, argv++, 90425630Sbrian &DefHisAddress.ipaddr, 90525630Sbrian &DefHisAddress.mask, 90625630Sbrian &DefHisAddress.width) == 0) 90725630Sbrian return(0); 9086059Samurai if (--argc > 0) { 9096059Samurai ifnetmask = GetIpAddr(*argv); 9109440Samurai if (--argc > 0) { 91125630Sbrian if (ParseAddr(argc, argv++, 91225630Sbrian &DefTriggerAddress.ipaddr, 91325630Sbrian &DefTriggerAddress.mask, 91425630Sbrian &DefTriggerAddress.width) == 0) 91525630Sbrian return(0); 9169440Samurai } 9176059Samurai } 9186059Samurai } 9196059Samurai } 9206059Samurai /* 9216059Samurai * For backwards compatibility, 0.0.0.0 means any address. 9226059Samurai */ 9236059Samurai if (DefMyAddress.ipaddr.s_addr == 0) { 9246059Samurai DefMyAddress.mask.s_addr = 0; 9256059Samurai DefMyAddress.width = 0; 9266059Samurai } 9276059Samurai if (DefHisAddress.ipaddr.s_addr == 0) { 9286059Samurai DefHisAddress.mask.s_addr = 0; 9296059Samurai DefHisAddress.width = 0; 9306059Samurai } 9316059Samurai 9326735Samurai if ((mode & MODE_AUTO) || 9336059Samurai ((mode & MODE_DEDICATED) && dstsystem)) { 93425630Sbrian if (OsSetIpaddress(DefMyAddress.ipaddr, DefHisAddress.ipaddr, ifnetmask) < 0) 93525630Sbrian return(0); 9366059Samurai } 9376059Samurai return(1); 9386059Samurai} 9396059Samurai 94018752Sjkh#ifdef MSEXT 9416059Samurai 94218752Sjkhvoid 94318752SjkhSetMSEXT(pri_addr, sec_addr, argc, argv) 94418752Sjkhstruct in_addr *pri_addr; 94518752Sjkhstruct in_addr *sec_addr; 94618752Sjkhint argc; 94718752Sjkhchar **argv; 94818752Sjkh{ 94918752Sjkh int dummyint; 95018752Sjkh struct in_addr dummyaddr; 95118752Sjkh 95218752Sjkh pri_addr->s_addr = sec_addr->s_addr = 0L; 95318752Sjkh 95418752Sjkh if( argc > 0 ) { 95518752Sjkh ParseAddr(argc, argv++, pri_addr, &dummyaddr, &dummyint); 95618752Sjkh if( --argc > 0 ) 95718752Sjkh ParseAddr(argc, argv++, sec_addr, &dummyaddr, &dummyint); 95818752Sjkh else 95918752Sjkh sec_addr->s_addr = pri_addr->s_addr; 96018752Sjkh } 96118752Sjkh 96218752Sjkh /* 96318752Sjkh * if the primary/secondary ns entries are 0.0.0.0 we should 96418752Sjkh * set them to either the localhost's ip, or the values in 96518752Sjkh * /etc/resolv.conf ?? 96618752Sjkh * 96718752Sjkh * up to you if you want to implement this... 96818752Sjkh */ 96918752Sjkh 97018752Sjkh} 97118752Sjkh 97218752Sjkhstatic int 97318752SjkhSetNS(list, argc, argv) 97418752Sjkhstruct cmdtab *list; 97518752Sjkhint argc; 97618752Sjkhchar **argv; 97718752Sjkh{ 97818752Sjkh SetMSEXT(&ns_entries[0], &ns_entries[1], argc, argv); 97918752Sjkh return(1); 98018752Sjkh} 98118752Sjkh 98218752Sjkhstatic int 98318752SjkhSetNBNS(list, argc, argv) 98418752Sjkhstruct cmdtab *list; 98518752Sjkhint argc; 98618752Sjkhchar **argv; 98718752Sjkh{ 98818752Sjkh SetMSEXT(&nbns_entries[0], &nbns_entries[1], argc, argv); 98918752Sjkh return(1); 99018752Sjkh} 99118752Sjkh 99218752Sjkh#endif /* MS_EXT */ 99318752Sjkh 9946059Samurai#define VAR_AUTHKEY 0 9956059Samurai#define VAR_DIAL 1 9966059Samurai#define VAR_LOGIN 2 9976059Samurai#define VAR_AUTHNAME 3 9986059Samurai#define VAR_DEVICE 4 9996059Samurai#define VAR_ACCMAP 5 10006059Samurai#define VAR_PHONE 6 10016059Samurai 10026059Samuraistatic int 10036059SamuraiSetVariable(list, argc, argv, param) 10046059Samuraistruct cmdtab *list; 10056059Samuraiint argc; 10066059Samuraichar **argv; 10076059Samuraiint param; 10086059Samurai{ 10096059Samurai u_long map; 10106059Samurai 10116059Samurai if (argc > 0) { 10126059Samurai switch (param) { 10136059Samurai case VAR_AUTHKEY: 10146059Samurai strncpy(VarAuthKey, *argv, sizeof(VarAuthKey)-1); 101521488Simp VarAuthKey[sizeof(VarAuthKey)-1] = '\0'; 10166059Samurai break; 10176059Samurai case VAR_AUTHNAME: 10186059Samurai strncpy(VarAuthName, *argv, sizeof(VarAuthName)-1); 101921488Simp VarAuthName[sizeof(VarAuthName)-1] = '\0'; 10206059Samurai break; 10216059Samurai case VAR_DIAL: 10226059Samurai strncpy(VarDialScript, *argv, sizeof(VarDialScript)-1); 102321488Simp VarDialScript[sizeof(VarDialScript)-1] = '\0'; 10246059Samurai break; 10256059Samurai case VAR_LOGIN: 102622225Sjoerg strncpy(VarLoginScript, *argv, sizeof(VarLoginScript)-1); 102721488Simp VarLoginScript[sizeof(VarLoginScript)-1] = '\0'; 10286059Samurai break; 10296059Samurai case VAR_DEVICE: 10306059Samurai strncpy(VarDevice, *argv, sizeof(VarDevice)-1); 103121488Simp VarDevice[sizeof(VarDevice)-1] = '\0'; 103225634Sbrian VarBaseDevice = rindex(VarDevice, '/'); 103325634Sbrian VarBaseDevice = VarBaseDevice ? VarBaseDevice + 1 : ""; 10346059Samurai break; 10356059Samurai case VAR_ACCMAP: 103613389Sphk sscanf(*argv, "%lx", &map); 10376059Samurai VarAccmap = map; 10386059Samurai break; 10396059Samurai case VAR_PHONE: 104014418Sache strncpy(VarPhoneList, *argv, sizeof(VarPhoneList)-1); 104121488Simp VarPhoneList[sizeof(VarPhoneList)-1] = '\0'; 104214423Sache strcpy(VarPhoneCopy, VarPhoneList); 104314423Sache VarNextPhone = VarPhoneCopy; 10446059Samurai break; 10456059Samurai } 10466059Samurai } 10476059Samurai return(1); 10486059Samurai} 10496059Samurai 105020812Sjkhstatic int SetCtsRts(list, argc, argv) 105120812Sjkhstruct cmdtab *list; 105220812Sjkhint argc; 105320812Sjkhchar **argv; 105420812Sjkh{ 105520812Sjkh if (argc > 0) { 105620812Sjkh if (strcmp(*argv, "on") == 0) 105720812Sjkh VarCtsRts = TRUE; 105820812Sjkh else if (strcmp(*argv, "off") == 0) 105920812Sjkh VarCtsRts = FALSE; 106020812Sjkh else 106120812Sjkh printf("usage: set ctsrts [on|off].\n"); 106220812Sjkh } 106320812Sjkh return(1); 106420812Sjkh} 106520812Sjkh 106620812Sjkh 10676059Samuraistatic int SetOpenMode(list, argc, argv) 10686059Samuraistruct cmdtab *list; 10696059Samuraiint argc; 10706059Samuraichar **argv; 10716059Samurai{ 10726059Samurai if (argc > 0) { 10736059Samurai if (strcmp(*argv, "active") == 0) 10746059Samurai VarOpenMode = OPEN_ACTIVE; 10756059Samurai else if (strcmp(*argv, "passive") == 0) 10766059Samurai VarOpenMode = OPEN_PASSIVE; 10776059Samurai else 10786059Samurai printf("Invalid mode.\n"); 10796059Samurai } 10806059Samurai return(1); 10816059Samurai} 10826059Samuraistatic char StrChatStr[] = "chat-script"; 10836059Samuraistatic char StrValue[] = "value"; 10846059Samurai 10856735Samuraiextern int SetIfilter(), SetOfilter(), SetDfilter(), SetAfilter(); 10866059Samurai 108713760Sphkstruct cmdtab const SetCommands[] = { 10886735Samurai { "accmap", NULL, SetVariable, LOCAL_AUTH, 10896735Samurai "Set accmap value", "hex-value", (void *)VAR_ACCMAP}, 10906735Samurai { "afilter", NULL, SetAfilter, LOCAL_AUTH, 10916735Samurai "Set keep Alive filter", "..."}, 10926735Samurai { "authkey", "key", SetVariable, LOCAL_AUTH, 10936735Samurai "Set authentication key", "key", (void *)VAR_AUTHKEY}, 10946735Samurai { "authname", NULL, SetVariable, LOCAL_AUTH, 10956735Samurai "Set authentication name", "name", (void *)VAR_AUTHNAME}, 109620812Sjkh { "ctsrts", NULL, SetCtsRts, LOCAL_AUTH, 109720812Sjkh "Use CTS/RTS modem signalling", "[on|off]"}, 10986735Samurai { "debug", NULL, SetDebugLevel, LOCAL_AUTH, 10996735Samurai "Set debug level", StrValue}, 11006735Samurai { "device", "line", SetVariable, LOCAL_AUTH, 11016735Samurai "Set modem device name", "device-name", (void *)VAR_DEVICE}, 11026735Samurai { "dfilter", NULL, SetDfilter, LOCAL_AUTH, 11036735Samurai "Set demand filter", "..."}, 11046735Samurai { "dial", NULL, SetVariable, LOCAL_AUTH, 11056735Samurai "Set dialing script", StrChatStr, (void *)VAR_DIAL}, 11066735Samurai { "escape", NULL, SetEscape, LOCAL_AUTH, 11076735Samurai "Set escape characters", "hex-digit ..."}, 11086735Samurai { "ifaddr", NULL, SetInterfaceAddr, LOCAL_AUTH, 110914418Sache "Set destination address", "[src-addr [dst-addr [netmask [trg-addr]]]]"}, 11106735Samurai { "ifilter", NULL, SetIfilter, LOCAL_AUTH, 11116735Samurai "Set input filter", "..."}, 11126735Samurai { "login", NULL, SetVariable, LOCAL_AUTH, 11136735Samurai "Set login script", StrChatStr, (void *)VAR_LOGIN }, 11146735Samurai { "mru", "mtu", SetInitialMRU, LOCAL_AUTH, 11156735Samurai "Set Initial MRU value", StrValue }, 11166735Samurai { "ofilter", NULL, SetOfilter, LOCAL_AUTH, 11176735Samurai "Set output filter", "..." }, 11186735Samurai { "openmode", NULL, SetOpenMode, LOCAL_AUTH, 11196735Samurai "Set open mode", "[active|passive]"}, 11206735Samurai { "parity", NULL, SetModemParity, LOCAL_AUTH, 11216735Samurai "Set modem parity", "[odd|even|none]"}, 11226735Samurai { "phone", NULL, SetVariable, LOCAL_AUTH, 112314418Sache "Set telephone number(s)", "phone1[:phone2[...]]", (void *)VAR_PHONE }, 112425067Sbrian { "reconnect",NULL, SetReconnect, LOCAL_AUTH, 112525067Sbrian "Set Reconnect timeout", "value ntries"}, 112625067Sbrian { "redial", NULL, SetRedialTimeout, LOCAL_AUTH, 112725067Sbrian "Set Redial timeout", "value|random[.value|random] [dial_attempts]"}, 11286735Samurai { "speed", NULL, SetModemSpeed, LOCAL_AUTH, 11296735Samurai "Set modem speed", "speed"}, 11306735Samurai { "timeout", NULL, SetIdleTimeout, LOCAL_AUTH, 11316735Samurai "Set Idle timeout", StrValue}, 113218752Sjkh#ifdef MSEXT 113318752Sjkh { "ns", NULL, SetNS, LOCAL_AUTH, 113418752Sjkh "Set NameServer", "pri-addr [sec-addr]"}, 113518752Sjkh { "nbns", NULL, SetNBNS, LOCAL_AUTH, 113618752Sjkh "Set NetBIOS NameServer", "pri-addr [sec-addr]"}, 113718752Sjkh#endif /* MSEXT */ 11386735Samurai { "help", "?", HelpCommand, LOCAL_AUTH | LOCAL_NO_AUTH, 11396735Samurai "Display this message", StrNull, (void *)SetCommands}, 11406059Samurai { NULL, NULL, NULL }, 11416059Samurai}; 11426059Samurai 11436059Samuraistatic int 11446059SamuraiSetCommand(list, argc, argv) 11456059Samuraistruct cmdtab *list; 11466059Samuraiint argc; 11476059Samuraichar **argv; 11486059Samurai{ 11496059Samurai int val = 1; 11506059Samurai 11516059Samurai if (argc > 0) 11526059Samurai val = FindExec(SetCommands, argc, argv); 11536059Samurai else 115414418Sache printf("Use `set ?' to get a list or `set ? <var>' for syntax help.\n"); 11556059Samurai return(val); 11566059Samurai} 11576059Samurai 11586059Samurai 11596059Samuraistatic int 11606059SamuraiAddCommand(list, argc, argv) 11616059Samuraistruct cmdtab *list; 11626059Samuraiint argc; 11636059Samuraichar **argv; 11646059Samurai{ 11656059Samurai struct in_addr dest, gateway, netmask; 11666059Samurai 11676059Samurai if (argc == 3) { 11686059Samurai dest = GetIpAddr(argv[0]); 11696059Samurai netmask = GetIpAddr(argv[1]); 117025566Sbrian if (strcasecmp(argv[2], "HISADDR") == 0) 11716059Samurai gateway = IpcpInfo.his_ipaddr; 11726059Samurai else 11736059Samurai gateway = GetIpAddr(argv[2]); 11746059Samurai OsSetRoute(RTM_ADD, dest, gateway, netmask); 11756059Samurai } else { 11766059Samurai printf("Usage: %s %s\n", list->name, list->syntax); 11776059Samurai } 11786059Samurai return(1); 11796059Samurai} 11806059Samurai 11816059Samuraistatic int 11826059SamuraiDeleteCommand(list, argc, argv) 11836059Samuraistruct cmdtab *list; 11846059Samuraiint argc; 11856059Samuraichar **argv; 11866059Samurai{ 11876059Samurai struct in_addr dest, gateway, netmask; 11886059Samurai 11896059Samurai if (argc >= 2) { 11906059Samurai dest = GetIpAddr(argv[0]); 119125566Sbrian if (strcasecmp(argv[1], "HISADDR") == 0) 11926059Samurai gateway = IpcpInfo.his_ipaddr; 11936059Samurai else 11946059Samurai gateway = GetIpAddr(argv[1]); 11956059Samurai netmask.s_addr = 0; 11966059Samurai if (argc == 3) { 11976059Samurai if (inet_aton(argv[1], &netmask) == 0) { 11986059Samurai printf("bad netmask value.\n"); 11996059Samurai return(1); 12006059Samurai } 12016059Samurai } 12026059Samurai OsSetRoute(RTM_DELETE, dest, gateway, netmask); 120325566Sbrian } else if (argc == 1 && strcasecmp(argv[0], "ALL") == 0) { 12046059Samurai DeleteIfRoutes(0); 12056059Samurai } else { 12066059Samurai printf("Usage: %s %s\n", list->name, list->syntax); 12076059Samurai } 12086059Samurai return(1); 12096059Samurai} 12106059Samurai 1211