command.c revision 25630
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 * 2025630Sbrian * $Id: command.c,v 1.42 1997/05/09 23:34:56 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."; 11120120Snate else if (mode & MODE_AUTO) 11210528Samurai mes = "Working in auto mode."; 1136059Samurai else if (mode & MODE_DIRECT) 11410528Samurai mes = "Working in direct mode."; 1156059Samurai else if (mode & MODE_DEDICATED) 11610528Samurai mes = "Working in dedicated mode."; 1176059Samurai if (mes) { 1186059Samurai printf("%s\n", mes); 1196059Samurai return(0); 1206059Samurai } 1216059Samurai return(1); 1226059Samurai} 1236059Samurai 1246059Samuraistatic int 1256059SamuraiDialCommand(cmdlist, argc, argv) 1266059Samuraistruct cmdtab *cmdlist; 1276059Samuraiint argc; 1286059Samuraichar **argv; 1296059Samurai{ 13011336Samurai int tries; 13111336Samurai 1326059Samurai if (LcpFsm.state > ST_CLOSED) { 1336059Samurai printf("LCP state is [%s]\n", StateNames[LcpFsm.state]); 1346059Samurai return(1); 1356059Samurai } 1366059Samurai if (!IsInteractive()) 1376059Samurai return(1); 1386735Samurai if (argc > 0) { 1396735Samurai if (SelectSystem(*argv, CONFFILE) < 0) { 1406735Samurai printf("%s: not found.\n", *argv); 1416735Samurai return(1); 1426735Samurai } 1436735Samurai } 14411336Samurai tries = 0; 14511336Samurai do { 14611336Samurai printf("Dial attempt %u\n", ++tries); 14711336Samurai modem = OpenModem(mode); 14811336Samurai if (modem < 0) { 14911336Samurai printf("failed to open modem.\n"); 15011336Samurai break; 15111336Samurai } 15211336Samurai if (DialModem()) { 15311336Samurai sleep(1); 15411336Samurai ModemTimeout(); 15511336Samurai PacketMode(); 15611336Samurai break; 15711336Samurai } 15811336Samurai } while (VarDialTries == 0 || tries < VarDialTries); 1596059Samurai return(1); 1606059Samurai} 1616059Samurai 16210528Samuraistatic int 16310528SamuraiShellCommand(cmdlist, argc, argv) 16410528Samuraistruct cmdtab *cmdlist; 16510528Samuraiint argc; 16610528Samuraichar **argv; 16710528Samurai{ 16810528Samurai const char *shell; 16910528Samurai pid_t shpid; 17020813Sjkh 17110528Samurai if((shell = getenv("SHELL")) == 0) { 17210528Samurai shell = _PATH_BSHELL; 17310528Samurai } 17418856Ssos#ifdef SHELL_ONLY_INTERACTIVELY 17510528Samurai#ifndef HAVE_SHELL_CMD_WITH_ANY_MODE 17610528Samurai if( mode != MODE_INTER) { 17710528Samurai fprintf(stdout, 17818911Ssos "Can only start a shell in interactive mode\n"); 17910528Samurai return(1); 18010528Samurai } 18110528Samurai#else 18210528Samurai if(argc == 0 && !(mode & MODE_INTER)) { 18310528Samurai fprintf(stderr, 18418911Ssos "Can only start an interactive shell in interactive mode\n"); 18510528Samurai return(1); 18610528Samurai } 18710528Samurai#endif /* HAVE_SHELL_CMD_WITH_ANY_MODE */ 18818911Ssos#else 18918911Ssos if ((mode & (MODE_AUTO|MODE_INTER)) == (MODE_AUTO|MODE_INTER)) { 19018911Ssos fprintf(stdout, 19118911Ssos "Shell is not allowed interactively in auto mode\n"); 19218911Ssos return(1); 19318911Ssos } 19418856Ssos#endif /* SHELL_ONLY_INTERACTIVELY */ 19510528Samurai if((shpid = fork()) == 0) { 19618531Sbde int dtablesize, i ; 19718531Sbde 19818531Sbde for (dtablesize = getdtablesize(), i = 3; i < dtablesize; i++) 19910528Samurai (void)close(i); 20010528Samurai 20110528Samurai /* 20210528Samurai * We are running setuid, we should change to 20310528Samurai * real user for avoiding security problems. 20410528Samurai */ 20516263Sache if (setgid(getgid()) < 0) { 20616263Sache perror("setgid"); 20716263Sache exit(1); 20816263Sache } 20916263Sache if (setuid(getuid()) < 0) { 21016263Sache perror("setuid"); 21116263Sache exit(1); 21216263Sache } 21310528Samurai TtyOldMode(); 21418790Ssos if(argc > 0) { 21518790Ssos /* substitute pseudo args */ 21618790Ssos for (i=1; i<argc; i++) { 21725566Sbrian if (strcasecmp(argv[i], "HISADDR") == 0) { 21818790Ssos argv[i] = strdup(inet_ntoa(IpcpInfo.his_ipaddr)); 21918790Ssos } 22025566Sbrian if (strcasecmp(argv[i], "INTERFACE") == 0) { 22122973Sphk argv[i] = strdup(IfDevName); 22222973Sphk } 22325566Sbrian if (strcasecmp(argv[i], "MYADDR") == 0) { 22418790Ssos argv[i] = strdup(inet_ntoa(IpcpInfo.want_ipaddr)); 22518790Ssos } 22618790Ssos } 22725630Sbrian (void)execvp(argv[0], argv); 22818790Ssos } 22910528Samurai else 23025630Sbrian (void)execl(shell, shell, NULL); 23120813Sjkh 23210528Samurai fprintf(stdout, "exec() of %s failed\n", argc > 0? argv[0]: shell); 23310528Samurai exit(255); 23410528Samurai } 23510528Samurai if( shpid == (pid_t)-1 ) { 23610528Samurai fprintf(stdout, "Fork failed\n"); 23710528Samurai } else { 23810528Samurai int status; 23910528Samurai (void)waitpid(shpid, &status, 0); 24010528Samurai } 24120813Sjkh 24210528Samurai TtyCommandMode(1); 24320813Sjkh 24410528Samurai return(0); 24510528Samurai} 24610528Samurai 2476059Samuraistatic char StrOption[] = "option .."; 2486059Samuraistatic char StrRemote[] = "[remote]"; 2496059Samuraichar StrNull[] = ""; 2506059Samurai 25113760Sphkstruct cmdtab const Commands[] = { 2526735Samurai { "accept", NULL, AcceptCommand, LOCAL_AUTH, 2536735Samurai "accept option request", StrOption}, 2546735Samurai { "add", NULL, AddCommand, LOCAL_AUTH, 2556735Samurai "add route", "dest mask gateway"}, 2566735Samurai { "close", NULL, CloseCommand, LOCAL_AUTH, 2576735Samurai "Close connection", StrNull}, 2586735Samurai { "delete", NULL, DeleteCommand, LOCAL_AUTH, 25914418Sache "delete route", "ALL | dest gateway [mask]"}, 2606735Samurai { "deny", NULL, DenyCommand, LOCAL_AUTH, 2616735Samurai "Deny option request", StrOption}, 2626735Samurai { "dial", "call", DialCommand, LOCAL_AUTH, 2636735Samurai "Dial and login", StrRemote}, 2646735Samurai { "disable", NULL, DisableCommand, LOCAL_AUTH, 2656735Samurai "Disable option", StrOption}, 2666735Samurai { "display", NULL, DisplayCommand, LOCAL_AUTH, 2676735Samurai "Display option configs", StrNull}, 2686735Samurai { "enable", NULL, EnableCommand, LOCAL_AUTH, 2696735Samurai "Enable option", StrOption}, 2706764Samurai { "passwd", NULL, LocalAuthCommand,LOCAL_NO_AUTH, 2719240Sphk "Password for manipulation", StrOption}, 2726735Samurai { "load", NULL, LoadCommand, LOCAL_AUTH, 2736735Samurai "Load settings", StrRemote}, 2746735Samurai { "save", NULL, SaveCommand, LOCAL_AUTH, 2756735Samurai "Save settings", StrNull}, 2766735Samurai { "set", "setup", SetCommand, LOCAL_AUTH, 2776735Samurai "Set parameters", "var value"}, 27810528Samurai { "shell", "!", ShellCommand, LOCAL_AUTH, 27910528Samurai "Run a subshell", "[sh command]"}, 2806735Samurai { "show", NULL, ShowCommand, LOCAL_AUTH, 2816735Samurai "Show status and statictics", "var"}, 2826735Samurai { "term", NULL, TerminalCommand,LOCAL_AUTH, 2836735Samurai "Enter to terminal mode", StrNull}, 2846764Samurai { "quit", "bye", QuitCommand, LOCAL_AUTH | LOCAL_NO_AUTH, 28514418Sache "Quit PPP program", "[all]"}, 2866735Samurai { "help", "?", HelpCommand, LOCAL_AUTH | LOCAL_NO_AUTH, 2876059Samurai "Display this message", "[command]", (void *)Commands }, 2886735Samurai { NULL, "down", DownCommand, LOCAL_AUTH, 2896735Samurai "Generate down event", StrNull}, 2906059Samurai { NULL, NULL, NULL }, 2916059Samurai}; 2926059Samurai 2936059Samuraiextern int ReportCcpStatus(); 2946059Samuraiextern int ReportLcpStatus(); 2956059Samuraiextern int ReportIpcpStatus(); 2966059Samuraiextern int ReportProtStatus(); 2976059Samuraiextern int ReportCompress(); 2986059Samuraiextern int ShowModemStatus(); 2996059Samuraiextern int ReportHdlcStatus(); 3006059Samuraiextern int ShowMemMap(); 3016059Samurai 3026059Samuraistatic char *LogLevelName[] = { 30315738Sphk LM_PHASE, LM_CHAT, LM_LQM, LM_LCP, 30415738Sphk LM_TCPIP, LM_HDLC, LM_ASYNC, LM_LINK, 30515738Sphk LM_CONNECT, LM_CARRIER, 3066059Samurai}; 3076059Samurai 3086059Samuraistatic int ShowDebugLevel() 3096059Samurai{ 3106059Samurai int i; 3116059Samurai 3126059Samurai printf("%02x: ", loglevel); 3136059Samurai for (i = LOG_PHASE; i < MAXLOGLEVEL; i++) { 3146059Samurai if (loglevel & (1 << i)) 3156059Samurai printf("%s ", LogLevelName[i]); 3166059Samurai } 3176059Samurai printf("\n"); 3186059Samurai return(1); 3196059Samurai} 3206059Samurai 3216059Samuraistatic int ShowEscape() 3226059Samurai{ 3236059Samurai int code, bit; 3246059Samurai 3256059Samurai if (EscMap[32]) { 3266059Samurai for (code = 0; code < 32; code++) { 3276059Samurai if (EscMap[code]) { 3286059Samurai for (bit = 0; bit < 8; bit++) { 3296059Samurai if (EscMap[code] & (1<<bit)) { 3306059Samurai printf(" 0x%02x", (code << 3) + bit); 3316059Samurai } 3326059Samurai } 3336059Samurai } 3346059Samurai } 3356059Samurai printf("\n"); 3366059Samurai } 3376059Samurai return(1); 3386059Samurai} 3396059Samurai 3406059Samuraistatic int ShowTimeout() 3416059Samurai{ 3426735Samurai printf(" Idle Timer: %d secs LQR Timer: %d secs Retry Timer: %d secs\n", 3436735Samurai VarIdleTimeout, VarLqrTimeout, VarRetryTimeout); 3446059Samurai return(1); 3456059Samurai} 3466059Samurai 3476059Samuraistatic int ShowAuthKey() 3486059Samurai{ 3496059Samurai printf("AuthName = %s\n", VarAuthName); 3506059Samurai printf("AuthKey = %s\n", VarAuthKey); 3516059Samurai return(1); 3526059Samurai} 3536059Samurai 3546059Samuraistatic int ShowVersion() 3556059Samurai{ 35613389Sphk extern char VarVersion[]; 35713389Sphk extern char VarLocalVersion[]; 3586059Samurai 3599448Samurai printf("%s - %s \n", VarVersion, VarLocalVersion); 3606059Samurai return(1); 3616059Samurai} 3626059Samurai 3636059Samuraistatic int ShowLogList() 3646059Samurai{ 3656059Samurai ListLog(); 3666059Samurai return(1); 3676059Samurai} 3686059Samurai 36925067Sbrianstatic int ShowReconnect() 37025067Sbrian{ 37125067Sbrian printf(" Reconnect Timer: %d, %d tries\n", 37225067Sbrian VarReconnectTimer, VarReconnectTries); 37325067Sbrian return(1); 37425067Sbrian} 37525067Sbrian 37611336Samuraistatic int ShowRedial() 37711336Samurai{ 37811336Samurai printf(" Redial Timer: "); 37911336Samurai 38011336Samurai if (VarRedialTimeout >= 0) { 38111336Samurai printf(" %d seconds, ", VarRedialTimeout); 38211336Samurai } 38311336Samurai else { 38411336Samurai printf(" Random 0 - %d seconds, ", REDIAL_PERIOD); 38511336Samurai } 38611336Samurai 38724939Sbrian printf(" Redial Next Timer: "); 38824939Sbrian 38924939Sbrian if (VarRedialNextTimeout >= 0) { 39024939Sbrian printf(" %d seconds, ", VarRedialNextTimeout); 39124939Sbrian } 39224939Sbrian else { 39324939Sbrian printf(" Random 0 - %d seconds, ", REDIAL_PERIOD); 39424939Sbrian } 39524939Sbrian 39611336Samurai if (VarDialTries) 39711336Samurai printf("%d dial tries", VarDialTries); 39811336Samurai 39911336Samurai printf("\n"); 40011336Samurai 40111336Samurai return(1); 40211336Samurai} 40311336Samurai 40418752Sjkh#ifdef MSEXT 40518752Sjkhstatic int ShowMSExt() 40618752Sjkh{ 40718752Sjkh printf(" MS PPP extention values \n" ); 40818752Sjkh printf(" Primary NS : %s\n", inet_ntoa( ns_entries[0] )); 40918752Sjkh printf(" Secondary NS : %s\n", inet_ntoa( ns_entries[1] )); 41018752Sjkh printf(" Primary NBNS : %s\n", inet_ntoa( nbns_entries[0] )); 41118752Sjkh printf(" Secondary NBNS : %s\n", inet_ntoa( nbns_entries[1] )); 41211336Samurai 41318752Sjkh return(1); 41418752Sjkh} 41518752Sjkh#endif /* MSEXT */ 41618752Sjkh 4176735Samuraiextern int ShowIfilter(), ShowOfilter(), ShowDfilter(), ShowAfilter(); 4186059Samurai 41913760Sphkstruct cmdtab const ShowCommands[] = { 4206735Samurai { "afilter", NULL, ShowAfilter, LOCAL_AUTH, 4216735Samurai "Show keep Alive filters", StrOption}, 4226735Samurai { "auth", NULL, ShowAuthKey, LOCAL_AUTH, 4236735Samurai "Show auth name/key", StrNull}, 4246735Samurai { "ccp", NULL, ReportCcpStatus, LOCAL_AUTH, 4256735Samurai "Show CCP status", StrNull}, 4266735Samurai { "compress", NULL, ReportCompress, LOCAL_AUTH, 4276735Samurai "Show compression statictics", StrNull}, 4286735Samurai { "debug", NULL, ShowDebugLevel, LOCAL_AUTH, 4296735Samurai "Show current debug level", StrNull}, 4306735Samurai { "dfilter", NULL, ShowDfilter, LOCAL_AUTH, 4316735Samurai "Show Demand filters", StrOption}, 4326735Samurai { "escape", NULL, ShowEscape, LOCAL_AUTH, 4336735Samurai "Show escape characters", StrNull}, 4346735Samurai { "hdlc", NULL, ReportHdlcStatus, LOCAL_AUTH, 4356735Samurai "Show HDLC error summary", StrNull}, 4366735Samurai { "ifilter", NULL, ShowIfilter, LOCAL_AUTH, 4376735Samurai "Show Input filters", StrOption}, 4386735Samurai { "ipcp", NULL, ReportIpcpStatus, LOCAL_AUTH, 4396735Samurai "Show IPCP status", StrNull}, 4406735Samurai { "lcp", NULL, ReportLcpStatus, LOCAL_AUTH, 4416735Samurai "Show LCP status", StrNull}, 4426735Samurai { "log", NULL, ShowLogList, LOCAL_AUTH, 4436735Samurai "Show log records", StrNull}, 4446735Samurai { "mem", NULL, ShowMemMap, LOCAL_AUTH, 4456735Samurai "Show memory map", StrNull}, 4466735Samurai { "modem", NULL, ShowModemStatus, LOCAL_AUTH, 4476735Samurai "Show modem setups", StrNull}, 4486735Samurai { "ofilter", NULL, ShowOfilter, LOCAL_AUTH, 4496735Samurai "Show Output filters", StrOption}, 4506735Samurai { "proto", NULL, ReportProtStatus, LOCAL_AUTH, 4516735Samurai "Show protocol summary", StrNull}, 45225067Sbrian { "reconnect",NULL, ShowReconnect, LOCAL_AUTH, 45325067Sbrian "Show Reconnect timer ntries", StrNull}, 45425067Sbrian { "redial", NULL, ShowRedial, LOCAL_AUTH, 45525067Sbrian "Show Redial timeout value", StrNull}, 4566735Samurai { "route", NULL, ShowRoute, LOCAL_AUTH, 4576735Samurai "Show routing table", StrNull}, 4586735Samurai { "timeout", NULL, ShowTimeout, LOCAL_AUTH, 4596735Samurai "Show Idle timeout value", StrNull}, 46018752Sjkh#ifdef MSEXT 46118752Sjkh { "msext", NULL, ShowMSExt, LOCAL_AUTH, 46223598Sache "Show MS PPP extentions", StrNull}, 46318752Sjkh#endif /* MSEXT */ 4646735Samurai { "version", NULL, ShowVersion, LOCAL_NO_AUTH | LOCAL_AUTH, 4656735Samurai "Show version string", StrNull}, 4666735Samurai { "help", "?", HelpCommand, LOCAL_NO_AUTH | LOCAL_AUTH, 4676735Samurai "Display this message", StrNull, (void *)ShowCommands}, 4686059Samurai { NULL, NULL, NULL }, 4696059Samurai}; 4706059Samurai 4716059Samuraistruct cmdtab * 4726059SamuraiFindCommand(cmds, str, pmatch) 4736059Samuraistruct cmdtab *cmds; 4746059Samuraichar *str; 4756059Samuraiint *pmatch; 4766059Samurai{ 4776059Samurai int nmatch = 0; 4786059Samurai int len = strlen(str); 4796059Samurai struct cmdtab *found = NULL; 4806059Samurai 4816059Samurai while (cmds->func) { 48225566Sbrian if (cmds->name && strncasecmp(str, cmds->name, len) == 0) { 4836059Samurai nmatch++; 4846059Samurai found = cmds; 48525566Sbrian } else if (cmds->alias && strncasecmp(str, cmds->alias, len) == 0) { 4866059Samurai nmatch++; 4876059Samurai found = cmds; 4886059Samurai } 4896059Samurai cmds++; 4906059Samurai } 4916059Samurai *pmatch = nmatch; 4926059Samurai return(found); 4936059Samurai} 4946059Samurai 4956059Samuraiint 4966059SamuraiFindExec(cmdlist, argc, argv) 4976059Samuraistruct cmdtab *cmdlist; 4986059Samuraiint argc; 4996059Samuraichar **argv; 5006059Samurai{ 5016059Samurai struct cmdtab *cmd; 5026059Samurai int val = 1; 5036059Samurai int nmatch; 5046059Samurai 5056059Samurai cmd = FindCommand(cmdlist, *argv, &nmatch); 5066059Samurai if (nmatch > 1) 5076735Samurai printf("Ambiguous.\n"); 5086735Samurai else if (cmd && ( cmd->lauth & VarLocalAuth ) ) 5096059Samurai val = (cmd->func)(cmd, --argc, ++argv, cmd->args); 5106059Samurai else 5116059Samurai printf("what?\n"); 5126059Samurai return(val); 5136059Samurai} 5146059Samurai 51518885Sjkhint aft_cmd = 1; 51618885Sjkh 5176059Samuraivoid 51818885SjkhPrompt() 5196059Samurai{ 5206735Samurai char *pconnect, *pauth; 5216735Samurai 5226059Samurai if (!(mode & MODE_INTER)) 5236059Samurai return; 5246735Samurai 52518885Sjkh if (!aft_cmd) 52618885Sjkh printf("\n"); 52718885Sjkh else 52818885Sjkh aft_cmd = 0; 5296735Samurai 5306735Samurai if ( VarLocalAuth == LOCAL_AUTH ) 5316735Samurai pauth = " ON "; 5326735Samurai else 5336735Samurai pauth = " on "; 5346059Samurai if (IpcpFsm.state == ST_OPENED && phase == PHASE_NETWORK) 5356735Samurai pconnect = "PPP"; 5366059Samurai else 5376735Samurai pconnect = "ppp"; 5386735Samurai printf("%s%s%s> ", pconnect, pauth, VarShortHost); 5396059Samurai fflush(stdout); 5406059Samurai} 5416059Samurai 5426059Samuraivoid 5436059SamuraiDecodeCommand(buff, nb, prompt) 5446059Samuraichar *buff; 5456059Samuraiint nb; 5466059Samuraiint prompt; 5476059Samurai{ 5486059Samurai char *vector[20]; 5496059Samurai char **argv; 5506059Samurai int argc, val; 5516059Samurai char *cp; 5526059Samurai 5536059Samurai val = 1; 5546059Samurai if (nb > 0) { 5556059Samurai cp = buff + strcspn(buff, "\r\n"); 5566059Samurai if (cp) 5576059Samurai *cp = '\0'; 5586059Samurai { 55925560Sbrian argc = MakeArgs(buff, vector, VECSIZE(vector)); 5606059Samurai argv = vector; 5616059Samurai 5626059Samurai if (argc > 0) 5636059Samurai val = FindExec(Commands, argc, argv); 5646059Samurai } 5656059Samurai } 5666059Samurai if (val && prompt) 56725630Sbrian Prompt(); 5686059Samurai} 5696059Samurai 5706059Samuraistatic int 5716059SamuraiShowCommand(list, argc, argv) 5726059Samuraistruct cmdtab *list; 5736059Samuraiint argc; 5746059Samuraichar **argv; 5756059Samurai{ 5766059Samurai int val = 1; 5776059Samurai 5786059Samurai if (argc > 0) 5796059Samurai val = FindExec(ShowCommands, argc, argv); 5806059Samurai else 5816059Samurai printf("Use ``show ?'' to get a list.\n"); 5826059Samurai return(val); 5836059Samurai} 5846059Samurai 5856059Samuraistatic int 5866059SamuraiTerminalCommand() 5876059Samurai{ 5886059Samurai if (LcpFsm.state > ST_CLOSED) { 5896059Samurai printf("LCP state is [%s]\n", StateNames[LcpFsm.state]); 5906059Samurai return(1); 5916059Samurai } 5926059Samurai if (!IsInteractive()) 5936059Samurai return(1); 5946059Samurai modem = OpenModem(mode); 5956059Samurai if (modem < 0) { 5966059Samurai printf("failed to open modem.\n"); 5976059Samurai return(1); 5986059Samurai } 5996059Samurai printf("Enter to terminal mode.\n"); 6006059Samurai printf("Type `~?' for help.\n"); 6016059Samurai TtyTermMode(); 6026059Samurai return(0); 6036059Samurai} 6046059Samurai 6056059Samuraistatic int 6066059SamuraiQuitCommand(list, argc, argv) 6076059Samuraistruct cmdtab *list; 6086059Samuraiint argc; 6096059Samuraichar **argv; 6106059Samurai{ 6116059Samurai if (mode & (MODE_DIRECT|MODE_DEDICATED|MODE_AUTO)) { 6126764Samurai if (argc > 0 && (VarLocalAuth & LOCAL_AUTH)) { 6136059Samurai Cleanup(EX_NORMAL); 61418911Ssos mode &= ~MODE_INTER; 6156059Samurai } else { 61624753Sache LogPrintf(LOG_PHASE_BIT, "client connection closed.\n"); 6176735Samurai VarLocalAuth = LOCAL_NO_AUTH; 6186059Samurai close(netfd); 6196059Samurai close(1); 6207886Samurai dup2(2, 1); /* Have to have something here or the modem will be 1 */ 6216059Samurai netfd = -1; 6226059Samurai mode &= ~MODE_INTER; 6236059Samurai } 6246059Samurai } else 6256059Samurai Cleanup(EX_NORMAL); 6266059Samurai return(1); 6276059Samurai} 6286059Samurai 6296059Samuraistatic int 6306059SamuraiCloseCommand() 6316059Samurai{ 6326059Samurai LcpClose(); 63325628Sbrian lostCarrier = 0; 6346059Samurai return(1); 6356059Samurai} 6366059Samurai 6376059Samuraistatic int 6386059SamuraiDownCommand() 6396059Samurai{ 6406059Samurai LcpDown(); 6416059Samurai return(1); 6426059Samurai} 6436059Samurai 64425067Sbrianstatic int 64525067SbrianSetModemSpeed(list, argc, argv) 6466059Samuraistruct cmdtab *list; 6476059Samuraiint argc; 6486059Samuraichar **argv; 6496059Samurai{ 6506059Samurai int speed; 6516059Samurai 6526059Samurai if (argc > 0) { 6536735Samurai if (strcmp(*argv, "sync") == 0) { 6546735Samurai VarSpeed = 0; 6556735Samurai return(1); 6566735Samurai } 6576059Samurai speed = atoi(*argv); 6586735Samurai if (IntToSpeed(speed) != B0) { 6596735Samurai VarSpeed = speed; 6606735Samurai return(1); 6616059Samurai } 6626059Samurai printf("invalid speed.\n"); 6636059Samurai } 6646059Samurai return(1); 6656059Samurai} 6666059Samurai 66725067Sbrianstatic int 66825067SbrianSetReconnect(list, argc, argv) 66911336Samuraistruct cmdtab *list; 67011336Samuraiint argc; 67111336Samuraichar **argv; 67211336Samurai{ 67325067Sbrian if (argc == 2) { 67425067Sbrian VarReconnectTimer = atoi(argv[0]); 67525067Sbrian VarReconnectTries = atoi(argv[1]); 67625067Sbrian } else 67725067Sbrian printf("Usage: %s %s\n", list->name, list->syntax); 67825067Sbrian return(1); 67925067Sbrian} 68025067Sbrian 68125067Sbrianstatic int 68225067SbrianSetRedialTimeout(list, argc, argv) 68325067Sbrianstruct cmdtab *list; 68425067Sbrianint argc; 68525067Sbrianchar **argv; 68625067Sbrian{ 68711336Samurai int timeout; 68811336Samurai int tries; 68924939Sbrian char *dot; 69011336Samurai 69111336Samurai if (argc == 1 || argc == 2 ) { 69224939Sbrian if (strncasecmp(argv[0], "random", 6) == 0 && 69324939Sbrian (argv[0][6] == '\0' || argv[0][6] == '.')) { 69411336Samurai VarRedialTimeout = -1; 69511336Samurai printf("Using random redial timeout.\n"); 69623603Sache if (!randinit) { 69723603Sache randinit = 1; 69824217Sache if (srandomdev() < 0) 69924217Sache srandom((unsigned long)(time(NULL) ^ getpid())); 70023603Sache } 70111336Samurai } 70211336Samurai else { 70311336Samurai timeout = atoi(argv[0]); 70411336Samurai 70511336Samurai if (timeout >= 0) { 70611336Samurai VarRedialTimeout = timeout; 70711336Samurai } 70811336Samurai else { 70911336Samurai printf("invalid redial timeout\n"); 71011336Samurai printf("Usage: %s %s\n", list->name, list->syntax); 71111336Samurai } 71211336Samurai } 71324939Sbrian 71424939Sbrian dot = index(argv[0],'.'); 71524939Sbrian if (dot) { 71624939Sbrian if (strcasecmp(++dot, "random") == 0) { 71724939Sbrian VarRedialNextTimeout = -1; 71824939Sbrian printf("Using random next redial timeout.\n"); 71924939Sbrian if (!randinit) { 72024939Sbrian randinit = 1; 72124939Sbrian if (srandomdev() < 0) 72224939Sbrian srandom((unsigned long)(time(NULL) ^ getpid())); 72324939Sbrian } 72424939Sbrian } 72524939Sbrian else { 72624939Sbrian timeout = atoi(dot); 72724939Sbrian if (timeout >= 0) { 72824939Sbrian VarRedialNextTimeout = timeout; 72924939Sbrian } 73024939Sbrian else { 73124939Sbrian printf("invalid next redial timeout\n"); 73224939Sbrian printf("Usage: %s %s\n", list->name, list->syntax); 73324939Sbrian } 73424939Sbrian } 73524939Sbrian } 73624939Sbrian else 73724939Sbrian VarRedialNextTimeout = NEXT_REDIAL_PERIOD; /* Default next timeout */ 73824939Sbrian 73911336Samurai if (argc == 2) { 74011336Samurai tries = atoi(argv[1]); 74111336Samurai 74211336Samurai if (tries >= 0) { 74311336Samurai VarDialTries = tries; 74411336Samurai } 74511336Samurai else { 74611336Samurai printf("invalid retry value\n"); 74711336Samurai printf("Usage: %s %s\n", list->name, list->syntax); 74811336Samurai } 74911336Samurai } 75011336Samurai } 75111336Samurai else { 75211336Samurai printf("Usage: %s %s\n", list->name, list->syntax); 75311336Samurai } 75411336Samurai return(1); 75511336Samurai} 75611336Samurai 75725067Sbrianstatic int 75825067SbrianSetModemParity(list, argc, argv) 7596059Samuraistruct cmdtab *list; 7606059Samuraiint argc; 7616059Samuraichar **argv; 7626059Samurai{ 7636059Samurai int parity; 7646059Samurai 7656059Samurai if (argc > 0) { 7666059Samurai parity = ChangeParity(*argv); 7676059Samurai if (parity < 0) 7686059Samurai printf("Invalid parity.\n"); 7696059Samurai else 7706059Samurai VarParity = parity; 7716059Samurai } 7726059Samurai return(1); 7736059Samurai} 7746059Samurai 7756059Samuraistatic int 7766059SamuraiSetDebugLevel(list, argc, argv) 7776059Samuraistruct cmdtab *list; 7786059Samuraiint argc; 7796059Samuraichar **argv; 7806059Samurai{ 7816059Samurai int level, w; 7826059Samurai 7836059Samurai for (level = 0; argc-- > 0; argv++) { 7846059Samurai if (isdigit(**argv)) { 7856059Samurai w = atoi(*argv); 7866059Samurai if (w < 0 || w >= MAXLOGLEVEL) { 7876059Samurai printf("invalid log level.\n"); 7886059Samurai break; 7896059Samurai } else 7906059Samurai level |= (1 << w); 7916059Samurai } else { 7926059Samurai for (w = 0; w < MAXLOGLEVEL; w++) { 7936059Samurai if (strcasecmp(*argv, LogLevelName[w]) == 0) { 7946059Samurai level |= (1 << w); 7956059Samurai continue; 7966059Samurai } 7976059Samurai } 7986059Samurai } 7996059Samurai } 8006059Samurai loglevel = level; 8016059Samurai return(1); 8026059Samurai} 8036059Samurai 8046059Samuraistatic int 8056059SamuraiSetEscape(list, argc, argv) 8066059Samuraistruct cmdtab *list; 8076059Samuraiint argc; 8086059Samuraichar **argv; 8096059Samurai{ 8106059Samurai int code; 8116059Samurai 8126059Samurai for (code = 0; code < 33; code++) 8136059Samurai EscMap[code] = 0; 8146059Samurai while (argc-- > 0) { 8156059Samurai sscanf(*argv++, "%x", &code); 8166059Samurai code &= 0xff; 8176059Samurai EscMap[code >> 3] |= (1 << (code&7)); 8186059Samurai EscMap[32] = 1; 8196059Samurai } 8206059Samurai return(1); 8216059Samurai} 8226059Samurai 8236059Samuraistatic int 8246059SamuraiSetInitialMRU(list, argc, argv) 8256059Samuraistruct cmdtab *list; 8266059Samuraiint argc; 8276059Samuraichar **argv; 8286059Samurai{ 8296059Samurai int mru; 8306059Samurai 8316059Samurai if (argc > 0) { 8326059Samurai mru = atoi(*argv); 8336059Samurai if (mru < 100) 8346059Samurai printf("given value is too small.\n"); 8356059Samurai else if (mru > MAX_MRU) 8366059Samurai printf("given value is too big.\n"); 8376059Samurai else 8386059Samurai VarMRU = mru; 8396059Samurai } 8406059Samurai return(1); 8416059Samurai} 8426059Samurai 8436059Samuraistatic int 8446059SamuraiSetIdleTimeout(list, argc, argv) 8456059Samuraistruct cmdtab *list; 8466059Samuraiint argc; 8476059Samuraichar **argv; 8486059Samurai{ 8496059Samurai if (argc-- > 0) { 8506059Samurai VarIdleTimeout = atoi(*argv++); 8516735Samurai if (argc-- > 0) { 8526735Samurai VarLqrTimeout = atoi(*argv++); 8536735Samurai if (VarLqrTimeout < 1) 8546735Samurai VarLqrTimeout = 30; 8556735Samurai if (argc > 0) { 8566735Samurai VarRetryTimeout = atoi(*argv); 8576735Samurai if (VarRetryTimeout < 1 || VarRetryTimeout > 10) 8586735Samurai VarRetryTimeout = 3; 8596735Samurai } 8606735Samurai } 8616059Samurai } 8626059Samurai return(1); 8636059Samurai} 8646059Samurai 8656059Samuraistruct in_addr 8666059SamuraiGetIpAddr(cp) 8676059Samuraichar *cp; 8686059Samurai{ 8696059Samurai struct hostent *hp; 8706059Samurai struct in_addr ipaddr; 8716059Samurai 8726059Samurai hp = gethostbyname(cp); 8736059Samurai if (hp && hp->h_addrtype == AF_INET) 8746059Samurai bcopy(hp->h_addr, &ipaddr, hp->h_length); 8756059Samurai else if (inet_aton(cp, &ipaddr) == 0) 8766059Samurai ipaddr.s_addr = 0; 8776059Samurai return(ipaddr); 8786059Samurai} 8796059Samurai 8806059Samuraistatic int 8816059SamuraiSetInterfaceAddr(list, argc, argv) 8826059Samuraistruct cmdtab *list; 8836059Samuraiint argc; 8846059Samuraichar **argv; 8856059Samurai{ 8866059Samurai 8876059Samurai DefMyAddress.ipaddr.s_addr = DefHisAddress.ipaddr.s_addr = 0L; 88825630Sbrian if (argc > 4) { 88925630Sbrian printf("set ifaddr: too many arguments (%d > 4)\n", argc); 89025630Sbrian return(0); 89125630Sbrian } 8926059Samurai if (argc > 0) { 89325630Sbrian if (ParseAddr(argc, argv++, 89425630Sbrian &DefMyAddress.ipaddr, 89525630Sbrian &DefMyAddress.mask, 89625630Sbrian &DefMyAddress.width) == 0) 89725630Sbrian return(0); 8986059Samurai if (--argc > 0) { 89925630Sbrian if (ParseAddr(argc, argv++, 90025630Sbrian &DefHisAddress.ipaddr, 90125630Sbrian &DefHisAddress.mask, 90225630Sbrian &DefHisAddress.width) == 0) 90325630Sbrian return(0); 9046059Samurai if (--argc > 0) { 9056059Samurai ifnetmask = GetIpAddr(*argv); 9069440Samurai if (--argc > 0) { 90725630Sbrian if (ParseAddr(argc, argv++, 90825630Sbrian &DefTriggerAddress.ipaddr, 90925630Sbrian &DefTriggerAddress.mask, 91025630Sbrian &DefTriggerAddress.width) == 0) 91125630Sbrian return(0); 9129440Samurai } 9136059Samurai } 9146059Samurai } 9156059Samurai } 9166059Samurai /* 9176059Samurai * For backwards compatibility, 0.0.0.0 means any address. 9186059Samurai */ 9196059Samurai if (DefMyAddress.ipaddr.s_addr == 0) { 9206059Samurai DefMyAddress.mask.s_addr = 0; 9216059Samurai DefMyAddress.width = 0; 9226059Samurai } 9236059Samurai if (DefHisAddress.ipaddr.s_addr == 0) { 9246059Samurai DefHisAddress.mask.s_addr = 0; 9256059Samurai DefHisAddress.width = 0; 9266059Samurai } 9276059Samurai 9286735Samurai if ((mode & MODE_AUTO) || 9296059Samurai ((mode & MODE_DEDICATED) && dstsystem)) { 93025630Sbrian if (OsSetIpaddress(DefMyAddress.ipaddr, DefHisAddress.ipaddr, ifnetmask) < 0) 93125630Sbrian return(0); 9326059Samurai } 9336059Samurai return(1); 9346059Samurai} 9356059Samurai 93618752Sjkh#ifdef MSEXT 9376059Samurai 93818752Sjkhvoid 93918752SjkhSetMSEXT(pri_addr, sec_addr, argc, argv) 94018752Sjkhstruct in_addr *pri_addr; 94118752Sjkhstruct in_addr *sec_addr; 94218752Sjkhint argc; 94318752Sjkhchar **argv; 94418752Sjkh{ 94518752Sjkh int dummyint; 94618752Sjkh struct in_addr dummyaddr; 94718752Sjkh 94818752Sjkh pri_addr->s_addr = sec_addr->s_addr = 0L; 94918752Sjkh 95018752Sjkh if( argc > 0 ) { 95118752Sjkh ParseAddr(argc, argv++, pri_addr, &dummyaddr, &dummyint); 95218752Sjkh if( --argc > 0 ) 95318752Sjkh ParseAddr(argc, argv++, sec_addr, &dummyaddr, &dummyint); 95418752Sjkh else 95518752Sjkh sec_addr->s_addr = pri_addr->s_addr; 95618752Sjkh } 95718752Sjkh 95818752Sjkh /* 95918752Sjkh * if the primary/secondary ns entries are 0.0.0.0 we should 96018752Sjkh * set them to either the localhost's ip, or the values in 96118752Sjkh * /etc/resolv.conf ?? 96218752Sjkh * 96318752Sjkh * up to you if you want to implement this... 96418752Sjkh */ 96518752Sjkh 96618752Sjkh} 96718752Sjkh 96818752Sjkhstatic int 96918752SjkhSetNS(list, argc, argv) 97018752Sjkhstruct cmdtab *list; 97118752Sjkhint argc; 97218752Sjkhchar **argv; 97318752Sjkh{ 97418752Sjkh SetMSEXT(&ns_entries[0], &ns_entries[1], argc, argv); 97518752Sjkh return(1); 97618752Sjkh} 97718752Sjkh 97818752Sjkhstatic int 97918752SjkhSetNBNS(list, argc, argv) 98018752Sjkhstruct cmdtab *list; 98118752Sjkhint argc; 98218752Sjkhchar **argv; 98318752Sjkh{ 98418752Sjkh SetMSEXT(&nbns_entries[0], &nbns_entries[1], argc, argv); 98518752Sjkh return(1); 98618752Sjkh} 98718752Sjkh 98818752Sjkh#endif /* MS_EXT */ 98918752Sjkh 9906059Samurai#define VAR_AUTHKEY 0 9916059Samurai#define VAR_DIAL 1 9926059Samurai#define VAR_LOGIN 2 9936059Samurai#define VAR_AUTHNAME 3 9946059Samurai#define VAR_DEVICE 4 9956059Samurai#define VAR_ACCMAP 5 9966059Samurai#define VAR_PHONE 6 9976059Samurai 9986059Samuraistatic int 9996059SamuraiSetVariable(list, argc, argv, param) 10006059Samuraistruct cmdtab *list; 10016059Samuraiint argc; 10026059Samuraichar **argv; 10036059Samuraiint param; 10046059Samurai{ 10056059Samurai u_long map; 10066059Samurai 10076059Samurai if (argc > 0) { 10086059Samurai switch (param) { 10096059Samurai case VAR_AUTHKEY: 10106059Samurai strncpy(VarAuthKey, *argv, sizeof(VarAuthKey)-1); 101121488Simp VarAuthKey[sizeof(VarAuthKey)-1] = '\0'; 10126059Samurai break; 10136059Samurai case VAR_AUTHNAME: 10146059Samurai strncpy(VarAuthName, *argv, sizeof(VarAuthName)-1); 101521488Simp VarAuthName[sizeof(VarAuthName)-1] = '\0'; 10166059Samurai break; 10176059Samurai case VAR_DIAL: 10186059Samurai strncpy(VarDialScript, *argv, sizeof(VarDialScript)-1); 101921488Simp VarDialScript[sizeof(VarDialScript)-1] = '\0'; 10206059Samurai break; 10216059Samurai case VAR_LOGIN: 102222225Sjoerg strncpy(VarLoginScript, *argv, sizeof(VarLoginScript)-1); 102321488Simp VarLoginScript[sizeof(VarLoginScript)-1] = '\0'; 10246059Samurai break; 10256059Samurai case VAR_DEVICE: 10266059Samurai strncpy(VarDevice, *argv, sizeof(VarDevice)-1); 102721488Simp VarDevice[sizeof(VarDevice)-1] = '\0'; 10286059Samurai break; 10296059Samurai case VAR_ACCMAP: 103013389Sphk sscanf(*argv, "%lx", &map); 10316059Samurai VarAccmap = map; 10326059Samurai break; 10336059Samurai case VAR_PHONE: 103414418Sache strncpy(VarPhoneList, *argv, sizeof(VarPhoneList)-1); 103521488Simp VarPhoneList[sizeof(VarPhoneList)-1] = '\0'; 103614423Sache strcpy(VarPhoneCopy, VarPhoneList); 103714423Sache VarNextPhone = VarPhoneCopy; 10386059Samurai break; 10396059Samurai } 10406059Samurai } 10416059Samurai return(1); 10426059Samurai} 10436059Samurai 104420812Sjkhstatic int SetCtsRts(list, argc, argv) 104520812Sjkhstruct cmdtab *list; 104620812Sjkhint argc; 104720812Sjkhchar **argv; 104820812Sjkh{ 104920812Sjkh if (argc > 0) { 105020812Sjkh if (strcmp(*argv, "on") == 0) 105120812Sjkh VarCtsRts = TRUE; 105220812Sjkh else if (strcmp(*argv, "off") == 0) 105320812Sjkh VarCtsRts = FALSE; 105420812Sjkh else 105520812Sjkh printf("usage: set ctsrts [on|off].\n"); 105620812Sjkh } 105720812Sjkh return(1); 105820812Sjkh} 105920812Sjkh 106020812Sjkh 10616059Samuraistatic int SetOpenMode(list, argc, argv) 10626059Samuraistruct cmdtab *list; 10636059Samuraiint argc; 10646059Samuraichar **argv; 10656059Samurai{ 10666059Samurai if (argc > 0) { 10676059Samurai if (strcmp(*argv, "active") == 0) 10686059Samurai VarOpenMode = OPEN_ACTIVE; 10696059Samurai else if (strcmp(*argv, "passive") == 0) 10706059Samurai VarOpenMode = OPEN_PASSIVE; 10716059Samurai else 10726059Samurai printf("Invalid mode.\n"); 10736059Samurai } 10746059Samurai return(1); 10756059Samurai} 10766059Samuraistatic char StrChatStr[] = "chat-script"; 10776059Samuraistatic char StrValue[] = "value"; 10786059Samurai 10796735Samuraiextern int SetIfilter(), SetOfilter(), SetDfilter(), SetAfilter(); 10806059Samurai 108113760Sphkstruct cmdtab const SetCommands[] = { 10826735Samurai { "accmap", NULL, SetVariable, LOCAL_AUTH, 10836735Samurai "Set accmap value", "hex-value", (void *)VAR_ACCMAP}, 10846735Samurai { "afilter", NULL, SetAfilter, LOCAL_AUTH, 10856735Samurai "Set keep Alive filter", "..."}, 10866735Samurai { "authkey", "key", SetVariable, LOCAL_AUTH, 10876735Samurai "Set authentication key", "key", (void *)VAR_AUTHKEY}, 10886735Samurai { "authname", NULL, SetVariable, LOCAL_AUTH, 10896735Samurai "Set authentication name", "name", (void *)VAR_AUTHNAME}, 109020812Sjkh { "ctsrts", NULL, SetCtsRts, LOCAL_AUTH, 109120812Sjkh "Use CTS/RTS modem signalling", "[on|off]"}, 10926735Samurai { "debug", NULL, SetDebugLevel, LOCAL_AUTH, 10936735Samurai "Set debug level", StrValue}, 10946735Samurai { "device", "line", SetVariable, LOCAL_AUTH, 10956735Samurai "Set modem device name", "device-name", (void *)VAR_DEVICE}, 10966735Samurai { "dfilter", NULL, SetDfilter, LOCAL_AUTH, 10976735Samurai "Set demand filter", "..."}, 10986735Samurai { "dial", NULL, SetVariable, LOCAL_AUTH, 10996735Samurai "Set dialing script", StrChatStr, (void *)VAR_DIAL}, 11006735Samurai { "escape", NULL, SetEscape, LOCAL_AUTH, 11016735Samurai "Set escape characters", "hex-digit ..."}, 11026735Samurai { "ifaddr", NULL, SetInterfaceAddr, LOCAL_AUTH, 110314418Sache "Set destination address", "[src-addr [dst-addr [netmask [trg-addr]]]]"}, 11046735Samurai { "ifilter", NULL, SetIfilter, LOCAL_AUTH, 11056735Samurai "Set input filter", "..."}, 11066735Samurai { "login", NULL, SetVariable, LOCAL_AUTH, 11076735Samurai "Set login script", StrChatStr, (void *)VAR_LOGIN }, 11086735Samurai { "mru", "mtu", SetInitialMRU, LOCAL_AUTH, 11096735Samurai "Set Initial MRU value", StrValue }, 11106735Samurai { "ofilter", NULL, SetOfilter, LOCAL_AUTH, 11116735Samurai "Set output filter", "..." }, 11126735Samurai { "openmode", NULL, SetOpenMode, LOCAL_AUTH, 11136735Samurai "Set open mode", "[active|passive]"}, 11146735Samurai { "parity", NULL, SetModemParity, LOCAL_AUTH, 11156735Samurai "Set modem parity", "[odd|even|none]"}, 11166735Samurai { "phone", NULL, SetVariable, LOCAL_AUTH, 111714418Sache "Set telephone number(s)", "phone1[:phone2[...]]", (void *)VAR_PHONE }, 111825067Sbrian { "reconnect",NULL, SetReconnect, LOCAL_AUTH, 111925067Sbrian "Set Reconnect timeout", "value ntries"}, 112025067Sbrian { "redial", NULL, SetRedialTimeout, LOCAL_AUTH, 112125067Sbrian "Set Redial timeout", "value|random[.value|random] [dial_attempts]"}, 11226735Samurai { "speed", NULL, SetModemSpeed, LOCAL_AUTH, 11236735Samurai "Set modem speed", "speed"}, 11246735Samurai { "timeout", NULL, SetIdleTimeout, LOCAL_AUTH, 11256735Samurai "Set Idle timeout", StrValue}, 112618752Sjkh#ifdef MSEXT 112718752Sjkh { "ns", NULL, SetNS, LOCAL_AUTH, 112818752Sjkh "Set NameServer", "pri-addr [sec-addr]"}, 112918752Sjkh { "nbns", NULL, SetNBNS, LOCAL_AUTH, 113018752Sjkh "Set NetBIOS NameServer", "pri-addr [sec-addr]"}, 113118752Sjkh#endif /* MSEXT */ 11326735Samurai { "help", "?", HelpCommand, LOCAL_AUTH | LOCAL_NO_AUTH, 11336735Samurai "Display this message", StrNull, (void *)SetCommands}, 11346059Samurai { NULL, NULL, NULL }, 11356059Samurai}; 11366059Samurai 11376059Samuraistatic int 11386059SamuraiSetCommand(list, argc, argv) 11396059Samuraistruct cmdtab *list; 11406059Samuraiint argc; 11416059Samuraichar **argv; 11426059Samurai{ 11436059Samurai int val = 1; 11446059Samurai 11456059Samurai if (argc > 0) 11466059Samurai val = FindExec(SetCommands, argc, argv); 11476059Samurai else 114814418Sache printf("Use `set ?' to get a list or `set ? <var>' for syntax help.\n"); 11496059Samurai return(val); 11506059Samurai} 11516059Samurai 11526059Samurai 11536059Samuraistatic int 11546059SamuraiAddCommand(list, argc, argv) 11556059Samuraistruct cmdtab *list; 11566059Samuraiint argc; 11576059Samuraichar **argv; 11586059Samurai{ 11596059Samurai struct in_addr dest, gateway, netmask; 11606059Samurai 11616059Samurai if (argc == 3) { 11626059Samurai dest = GetIpAddr(argv[0]); 11636059Samurai netmask = GetIpAddr(argv[1]); 116425566Sbrian if (strcasecmp(argv[2], "HISADDR") == 0) 11656059Samurai gateway = IpcpInfo.his_ipaddr; 11666059Samurai else 11676059Samurai gateway = GetIpAddr(argv[2]); 11686059Samurai OsSetRoute(RTM_ADD, dest, gateway, netmask); 11696059Samurai } else { 11706059Samurai printf("Usage: %s %s\n", list->name, list->syntax); 11716059Samurai } 11726059Samurai return(1); 11736059Samurai} 11746059Samurai 11756059Samuraistatic int 11766059SamuraiDeleteCommand(list, argc, argv) 11776059Samuraistruct cmdtab *list; 11786059Samuraiint argc; 11796059Samuraichar **argv; 11806059Samurai{ 11816059Samurai struct in_addr dest, gateway, netmask; 11826059Samurai 11836059Samurai if (argc >= 2) { 11846059Samurai dest = GetIpAddr(argv[0]); 118525566Sbrian if (strcasecmp(argv[1], "HISADDR") == 0) 11866059Samurai gateway = IpcpInfo.his_ipaddr; 11876059Samurai else 11886059Samurai gateway = GetIpAddr(argv[1]); 11896059Samurai netmask.s_addr = 0; 11906059Samurai if (argc == 3) { 11916059Samurai if (inet_aton(argv[1], &netmask) == 0) { 11926059Samurai printf("bad netmask value.\n"); 11936059Samurai return(1); 11946059Samurai } 11956059Samurai } 11966059Samurai OsSetRoute(RTM_DELETE, dest, gateway, netmask); 119725566Sbrian } else if (argc == 1 && strcasecmp(argv[0], "ALL") == 0) { 11986059Samurai DeleteIfRoutes(0); 11996059Samurai } else { 12006059Samurai printf("Usage: %s %s\n", list->name, list->syntax); 12016059Samurai } 12026059Samurai return(1); 12036059Samurai} 12046059Samurai 1205