command.c revision 25566
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 * 2025566Sbrian * $Id: command.c,v 1.40 1997/05/07 23:01:25 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" 376735Samurai#include "auth.h" 386059Samurai#include <netdb.h> 396059Samurai#include <sys/socket.h> 406059Samurai#include <arpa/inet.h> 416059Samurai#include <net/route.h> 426059Samurai#include "os.h" 4310528Samurai#include <paths.h> 4425560Sbrian#include "chat.h" 456059Samurai 466059Samuraiextern void Cleanup(), TtyTermMode(), PacketMode(); 476059Samuraiextern int EnableCommand(), DisableCommand(), DisplayCommand(); 486059Samuraiextern int AcceptCommand(), DenyCommand(); 496735Samuraiextern int LocalAuthCommand(); 506059Samuraiextern int LoadCommand(), SaveCommand(); 516059Samuraiextern int ChangeParity(char *); 526059Samuraiextern int SelectSystem(); 536059Samuraiextern int ShowRoute(); 5410528Samuraiextern void TtyOldMode(), TtyCommandMode(); 556735Samuraiextern struct pppvars pppVars; 5614418Sacheextern struct cmdtab const SetCommands[]; 576059Samurai 5822973Sphkextern char *IfDevName; 5922973Sphk 606059Samuraistruct in_addr ifnetmask; 6123603Sacheint randinit; 626059Samurai 636059Samuraistatic int ShowCommand(), TerminalCommand(), QuitCommand(); 646059Samuraistatic int CloseCommand(), DialCommand(), DownCommand(); 656059Samuraistatic int SetCommand(), AddCommand(), DeleteCommand(); 6610528Samuraistatic int ShellCommand(); 676059Samurai 686059Samuraistatic int 696059SamuraiHelpCommand(list, argc, argv, plist) 706059Samuraistruct cmdtab *list; 716059Samuraiint argc; 726059Samuraichar **argv; 736059Samuraistruct cmdtab *plist; 746059Samurai{ 756059Samurai struct cmdtab *cmd; 766059Samurai int n; 776059Samurai char c; 786059Samurai 796059Samurai if (argc > 0) { 806059Samurai for (cmd = plist; cmd->name; cmd++) { 8125566Sbrian if (strcasecmp(cmd->name, *argv) == 0 && (cmd->lauth & VarLocalAuth)) { 8214418Sache if (plist == SetCommands) 8314418Sache printf("set "); 846059Samurai printf("%s %s\n", cmd->name, cmd->syntax); 856059Samurai return(1); 866059Samurai } 876059Samurai } 886059Samurai return(1); 896059Samurai } 906059Samurai n = 0; 916059Samurai for (cmd = plist; cmd->func; cmd++) { 926764Samurai if (cmd->name && (cmd->lauth & VarLocalAuth)) { 936764Samurai c = (n & 1)? '\n' : '\t'; 946059Samurai printf(" %-8s: %-20s%c", cmd->name, cmd->helpmes, c); 956059Samurai n++; 966059Samurai } 976059Samurai } 986059Samurai if (n & 1) 996059Samurai printf("\n"); 1006059Samurai return(1); 1016059Samurai} 1026059Samurai 1036059Samuraiint 1046059SamuraiIsInteractive() 1056059Samurai{ 1066059Samurai char *mes = NULL; 1076059Samurai 10820120Snate if (mode & MODE_DDIAL) 10920120Snate mes = "Working in dedicated dial mode."; 11020120Snate else if (mode & MODE_AUTO) 11110528Samurai mes = "Working in auto mode."; 1126059Samurai else if (mode & MODE_DIRECT) 11310528Samurai mes = "Working in direct mode."; 1146059Samurai else if (mode & MODE_DEDICATED) 11510528Samurai mes = "Working in dedicated mode."; 1166059Samurai if (mes) { 1176059Samurai printf("%s\n", mes); 1186059Samurai return(0); 1196059Samurai } 1206059Samurai return(1); 1216059Samurai} 1226059Samurai 1236059Samuraistatic int 1246059SamuraiDialCommand(cmdlist, argc, argv) 1256059Samuraistruct cmdtab *cmdlist; 1266059Samuraiint argc; 1276059Samuraichar **argv; 1286059Samurai{ 12911336Samurai int tries; 13011336Samurai 1316059Samurai if (LcpFsm.state > ST_CLOSED) { 1326059Samurai printf("LCP state is [%s]\n", StateNames[LcpFsm.state]); 1336059Samurai return(1); 1346059Samurai } 1356059Samurai if (!IsInteractive()) 1366059Samurai return(1); 1376735Samurai if (argc > 0) { 1386735Samurai if (SelectSystem(*argv, CONFFILE) < 0) { 1396735Samurai printf("%s: not found.\n", *argv); 1406735Samurai return(1); 1416735Samurai } 1426735Samurai } 14311336Samurai tries = 0; 14411336Samurai do { 14511336Samurai printf("Dial attempt %u\n", ++tries); 14611336Samurai modem = OpenModem(mode); 14711336Samurai if (modem < 0) { 14811336Samurai printf("failed to open modem.\n"); 14911336Samurai break; 15011336Samurai } 15111336Samurai if (DialModem()) { 15211336Samurai sleep(1); 15311336Samurai ModemTimeout(); 15411336Samurai PacketMode(); 15511336Samurai break; 15611336Samurai } 15711336Samurai } while (VarDialTries == 0 || tries < VarDialTries); 1586059Samurai return(1); 1596059Samurai} 1606059Samurai 16110528Samuraistatic int 16210528SamuraiShellCommand(cmdlist, argc, argv) 16310528Samuraistruct cmdtab *cmdlist; 16410528Samuraiint argc; 16510528Samuraichar **argv; 16610528Samurai{ 16710528Samurai const char *shell; 16810528Samurai pid_t shpid; 16920813Sjkh 17010528Samurai if((shell = getenv("SHELL")) == 0) { 17110528Samurai shell = _PATH_BSHELL; 17210528Samurai } 17318856Ssos#ifdef SHELL_ONLY_INTERACTIVELY 17410528Samurai#ifndef HAVE_SHELL_CMD_WITH_ANY_MODE 17510528Samurai if( mode != MODE_INTER) { 17610528Samurai fprintf(stdout, 17718911Ssos "Can only start a shell in interactive mode\n"); 17810528Samurai return(1); 17910528Samurai } 18010528Samurai#else 18110528Samurai if(argc == 0 && !(mode & MODE_INTER)) { 18210528Samurai fprintf(stderr, 18318911Ssos "Can only start an interactive shell in interactive mode\n"); 18410528Samurai return(1); 18510528Samurai } 18610528Samurai#endif /* HAVE_SHELL_CMD_WITH_ANY_MODE */ 18718911Ssos#else 18818911Ssos if ((mode & (MODE_AUTO|MODE_INTER)) == (MODE_AUTO|MODE_INTER)) { 18918911Ssos fprintf(stdout, 19018911Ssos "Shell is not allowed interactively in auto mode\n"); 19118911Ssos return(1); 19218911Ssos } 19318856Ssos#endif /* SHELL_ONLY_INTERACTIVELY */ 19410528Samurai if((shpid = fork()) == 0) { 19518531Sbde int dtablesize, i ; 19618531Sbde 19718531Sbde for (dtablesize = getdtablesize(), i = 3; i < dtablesize; i++) 19810528Samurai (void)close(i); 19910528Samurai 20010528Samurai /* 20110528Samurai * We are running setuid, we should change to 20210528Samurai * real user for avoiding security problems. 20310528Samurai */ 20416263Sache if (setgid(getgid()) < 0) { 20516263Sache perror("setgid"); 20616263Sache exit(1); 20716263Sache } 20816263Sache if (setuid(getuid()) < 0) { 20916263Sache perror("setuid"); 21016263Sache exit(1); 21116263Sache } 21210528Samurai TtyOldMode(); 21318790Ssos if(argc > 0) { 21418790Ssos /* substitute pseudo args */ 21518790Ssos for (i=1; i<argc; i++) { 21625566Sbrian if (strcasecmp(argv[i], "HISADDR") == 0) { 21718790Ssos argv[i] = strdup(inet_ntoa(IpcpInfo.his_ipaddr)); 21818790Ssos } 21925566Sbrian if (strcasecmp(argv[i], "INTERFACE") == 0) { 22022973Sphk argv[i] = strdup(IfDevName); 22122973Sphk } 22225566Sbrian if (strcasecmp(argv[i], "MYADDR") == 0) { 22318790Ssos argv[i] = strdup(inet_ntoa(IpcpInfo.want_ipaddr)); 22418790Ssos } 22518790Ssos } 22610528Samurai execvp(argv[0], argv); 22718790Ssos } 22810528Samurai else 22910528Samurai execl(shell, shell, NULL); 23020813Sjkh 23110528Samurai fprintf(stdout, "exec() of %s failed\n", argc > 0? argv[0]: shell); 23210528Samurai exit(255); 23310528Samurai } 23410528Samurai if( shpid == (pid_t)-1 ) { 23510528Samurai fprintf(stdout, "Fork failed\n"); 23610528Samurai } else { 23710528Samurai int status; 23810528Samurai (void)waitpid(shpid, &status, 0); 23910528Samurai } 24020813Sjkh 24110528Samurai TtyCommandMode(1); 24220813Sjkh 24310528Samurai return(0); 24410528Samurai} 24510528Samurai 2466059Samuraistatic char StrOption[] = "option .."; 2476059Samuraistatic char StrRemote[] = "[remote]"; 2486059Samuraichar StrNull[] = ""; 2496059Samurai 25013760Sphkstruct cmdtab const Commands[] = { 2516735Samurai { "accept", NULL, AcceptCommand, LOCAL_AUTH, 2526735Samurai "accept option request", StrOption}, 2536735Samurai { "add", NULL, AddCommand, LOCAL_AUTH, 2546735Samurai "add route", "dest mask gateway"}, 2556735Samurai { "close", NULL, CloseCommand, LOCAL_AUTH, 2566735Samurai "Close connection", StrNull}, 2576735Samurai { "delete", NULL, DeleteCommand, LOCAL_AUTH, 25814418Sache "delete route", "ALL | dest gateway [mask]"}, 2596735Samurai { "deny", NULL, DenyCommand, LOCAL_AUTH, 2606735Samurai "Deny option request", StrOption}, 2616735Samurai { "dial", "call", DialCommand, LOCAL_AUTH, 2626735Samurai "Dial and login", StrRemote}, 2636735Samurai { "disable", NULL, DisableCommand, LOCAL_AUTH, 2646735Samurai "Disable option", StrOption}, 2656735Samurai { "display", NULL, DisplayCommand, LOCAL_AUTH, 2666735Samurai "Display option configs", StrNull}, 2676735Samurai { "enable", NULL, EnableCommand, LOCAL_AUTH, 2686735Samurai "Enable option", StrOption}, 2696764Samurai { "passwd", NULL, LocalAuthCommand,LOCAL_NO_AUTH, 2709240Sphk "Password for manipulation", StrOption}, 2716735Samurai { "load", NULL, LoadCommand, LOCAL_AUTH, 2726735Samurai "Load settings", StrRemote}, 2736735Samurai { "save", NULL, SaveCommand, LOCAL_AUTH, 2746735Samurai "Save settings", StrNull}, 2756735Samurai { "set", "setup", SetCommand, LOCAL_AUTH, 2766735Samurai "Set parameters", "var value"}, 27710528Samurai { "shell", "!", ShellCommand, LOCAL_AUTH, 27810528Samurai "Run a subshell", "[sh command]"}, 2796735Samurai { "show", NULL, ShowCommand, LOCAL_AUTH, 2806735Samurai "Show status and statictics", "var"}, 2816735Samurai { "term", NULL, TerminalCommand,LOCAL_AUTH, 2826735Samurai "Enter to terminal mode", StrNull}, 2836764Samurai { "quit", "bye", QuitCommand, LOCAL_AUTH | LOCAL_NO_AUTH, 28414418Sache "Quit PPP program", "[all]"}, 2856735Samurai { "help", "?", HelpCommand, LOCAL_AUTH | LOCAL_NO_AUTH, 2866059Samurai "Display this message", "[command]", (void *)Commands }, 2876735Samurai { NULL, "down", DownCommand, LOCAL_AUTH, 2886735Samurai "Generate down event", StrNull}, 2896059Samurai { NULL, NULL, NULL }, 2906059Samurai}; 2916059Samurai 2926059Samuraiextern int ReportCcpStatus(); 2936059Samuraiextern int ReportLcpStatus(); 2946059Samuraiextern int ReportIpcpStatus(); 2956059Samuraiextern int ReportProtStatus(); 2966059Samuraiextern int ReportCompress(); 2976059Samuraiextern int ShowModemStatus(); 2986059Samuraiextern int ReportHdlcStatus(); 2996059Samuraiextern int ShowMemMap(); 3006059Samurai 3016059Samuraistatic char *LogLevelName[] = { 30215738Sphk LM_PHASE, LM_CHAT, LM_LQM, LM_LCP, 30315738Sphk LM_TCPIP, LM_HDLC, LM_ASYNC, LM_LINK, 30415738Sphk LM_CONNECT, LM_CARRIER, 3056059Samurai}; 3066059Samurai 3076059Samuraistatic int ShowDebugLevel() 3086059Samurai{ 3096059Samurai int i; 3106059Samurai 3116059Samurai printf("%02x: ", loglevel); 3126059Samurai for (i = LOG_PHASE; i < MAXLOGLEVEL; i++) { 3136059Samurai if (loglevel & (1 << i)) 3146059Samurai printf("%s ", LogLevelName[i]); 3156059Samurai } 3166059Samurai printf("\n"); 3176059Samurai return(1); 3186059Samurai} 3196059Samurai 3206059Samuraistatic int ShowEscape() 3216059Samurai{ 3226059Samurai int code, bit; 3236059Samurai 3246059Samurai if (EscMap[32]) { 3256059Samurai for (code = 0; code < 32; code++) { 3266059Samurai if (EscMap[code]) { 3276059Samurai for (bit = 0; bit < 8; bit++) { 3286059Samurai if (EscMap[code] & (1<<bit)) { 3296059Samurai printf(" 0x%02x", (code << 3) + bit); 3306059Samurai } 3316059Samurai } 3326059Samurai } 3336059Samurai } 3346059Samurai printf("\n"); 3356059Samurai } 3366059Samurai return(1); 3376059Samurai} 3386059Samurai 3396059Samuraistatic int ShowTimeout() 3406059Samurai{ 3416735Samurai printf(" Idle Timer: %d secs LQR Timer: %d secs Retry Timer: %d secs\n", 3426735Samurai VarIdleTimeout, VarLqrTimeout, VarRetryTimeout); 3436059Samurai return(1); 3446059Samurai} 3456059Samurai 3466059Samuraistatic int ShowAuthKey() 3476059Samurai{ 3486059Samurai printf("AuthName = %s\n", VarAuthName); 3496059Samurai printf("AuthKey = %s\n", VarAuthKey); 3506059Samurai return(1); 3516059Samurai} 3526059Samurai 3536059Samuraistatic int ShowVersion() 3546059Samurai{ 35513389Sphk extern char VarVersion[]; 35613389Sphk extern char VarLocalVersion[]; 3576059Samurai 3589448Samurai printf("%s - %s \n", VarVersion, VarLocalVersion); 3596059Samurai return(1); 3606059Samurai} 3616059Samurai 3626059Samuraistatic int ShowLogList() 3636059Samurai{ 3646059Samurai ListLog(); 3656059Samurai return(1); 3666059Samurai} 3676059Samurai 36825067Sbrianstatic int ShowReconnect() 36925067Sbrian{ 37025067Sbrian printf(" Reconnect Timer: %d, %d tries\n", 37125067Sbrian VarReconnectTimer, VarReconnectTries); 37225067Sbrian return(1); 37325067Sbrian} 37425067Sbrian 37511336Samuraistatic int ShowRedial() 37611336Samurai{ 37711336Samurai printf(" Redial Timer: "); 37811336Samurai 37911336Samurai if (VarRedialTimeout >= 0) { 38011336Samurai printf(" %d seconds, ", VarRedialTimeout); 38111336Samurai } 38211336Samurai else { 38311336Samurai printf(" Random 0 - %d seconds, ", REDIAL_PERIOD); 38411336Samurai } 38511336Samurai 38624939Sbrian printf(" Redial Next Timer: "); 38724939Sbrian 38824939Sbrian if (VarRedialNextTimeout >= 0) { 38924939Sbrian printf(" %d seconds, ", VarRedialNextTimeout); 39024939Sbrian } 39124939Sbrian else { 39224939Sbrian printf(" Random 0 - %d seconds, ", REDIAL_PERIOD); 39324939Sbrian } 39424939Sbrian 39511336Samurai if (VarDialTries) 39611336Samurai printf("%d dial tries", VarDialTries); 39711336Samurai 39811336Samurai printf("\n"); 39911336Samurai 40011336Samurai return(1); 40111336Samurai} 40211336Samurai 40318752Sjkh#ifdef MSEXT 40418752Sjkhstatic int ShowMSExt() 40518752Sjkh{ 40618752Sjkh printf(" MS PPP extention values \n" ); 40718752Sjkh printf(" Primary NS : %s\n", inet_ntoa( ns_entries[0] )); 40818752Sjkh printf(" Secondary NS : %s\n", inet_ntoa( ns_entries[1] )); 40918752Sjkh printf(" Primary NBNS : %s\n", inet_ntoa( nbns_entries[0] )); 41018752Sjkh printf(" Secondary NBNS : %s\n", inet_ntoa( nbns_entries[1] )); 41111336Samurai 41218752Sjkh return(1); 41318752Sjkh} 41418752Sjkh#endif /* MSEXT */ 41518752Sjkh 4166735Samuraiextern int ShowIfilter(), ShowOfilter(), ShowDfilter(), ShowAfilter(); 4176059Samurai 41813760Sphkstruct cmdtab const ShowCommands[] = { 4196735Samurai { "afilter", NULL, ShowAfilter, LOCAL_AUTH, 4206735Samurai "Show keep Alive filters", StrOption}, 4216735Samurai { "auth", NULL, ShowAuthKey, LOCAL_AUTH, 4226735Samurai "Show auth name/key", StrNull}, 4236735Samurai { "ccp", NULL, ReportCcpStatus, LOCAL_AUTH, 4246735Samurai "Show CCP status", StrNull}, 4256735Samurai { "compress", NULL, ReportCompress, LOCAL_AUTH, 4266735Samurai "Show compression statictics", StrNull}, 4276735Samurai { "debug", NULL, ShowDebugLevel, LOCAL_AUTH, 4286735Samurai "Show current debug level", StrNull}, 4296735Samurai { "dfilter", NULL, ShowDfilter, LOCAL_AUTH, 4306735Samurai "Show Demand filters", StrOption}, 4316735Samurai { "escape", NULL, ShowEscape, LOCAL_AUTH, 4326735Samurai "Show escape characters", StrNull}, 4336735Samurai { "hdlc", NULL, ReportHdlcStatus, LOCAL_AUTH, 4346735Samurai "Show HDLC error summary", StrNull}, 4356735Samurai { "ifilter", NULL, ShowIfilter, LOCAL_AUTH, 4366735Samurai "Show Input filters", StrOption}, 4376735Samurai { "ipcp", NULL, ReportIpcpStatus, LOCAL_AUTH, 4386735Samurai "Show IPCP status", StrNull}, 4396735Samurai { "lcp", NULL, ReportLcpStatus, LOCAL_AUTH, 4406735Samurai "Show LCP status", StrNull}, 4416735Samurai { "log", NULL, ShowLogList, LOCAL_AUTH, 4426735Samurai "Show log records", StrNull}, 4436735Samurai { "mem", NULL, ShowMemMap, LOCAL_AUTH, 4446735Samurai "Show memory map", StrNull}, 4456735Samurai { "modem", NULL, ShowModemStatus, LOCAL_AUTH, 4466735Samurai "Show modem setups", StrNull}, 4476735Samurai { "ofilter", NULL, ShowOfilter, LOCAL_AUTH, 4486735Samurai "Show Output filters", StrOption}, 4496735Samurai { "proto", NULL, ReportProtStatus, LOCAL_AUTH, 4506735Samurai "Show protocol summary", StrNull}, 45125067Sbrian { "reconnect",NULL, ShowReconnect, LOCAL_AUTH, 45225067Sbrian "Show Reconnect timer ntries", StrNull}, 45325067Sbrian { "redial", NULL, ShowRedial, LOCAL_AUTH, 45425067Sbrian "Show Redial timeout value", StrNull}, 4556735Samurai { "route", NULL, ShowRoute, LOCAL_AUTH, 4566735Samurai "Show routing table", StrNull}, 4576735Samurai { "timeout", NULL, ShowTimeout, LOCAL_AUTH, 4586735Samurai "Show Idle timeout value", StrNull}, 45918752Sjkh#ifdef MSEXT 46018752Sjkh { "msext", NULL, ShowMSExt, LOCAL_AUTH, 46123598Sache "Show MS PPP extentions", StrNull}, 46218752Sjkh#endif /* MSEXT */ 4636735Samurai { "version", NULL, ShowVersion, LOCAL_NO_AUTH | LOCAL_AUTH, 4646735Samurai "Show version string", StrNull}, 4656735Samurai { "help", "?", HelpCommand, LOCAL_NO_AUTH | LOCAL_AUTH, 4666735Samurai "Display this message", StrNull, (void *)ShowCommands}, 4676059Samurai { NULL, NULL, NULL }, 4686059Samurai}; 4696059Samurai 4706059Samuraistruct cmdtab * 4716059SamuraiFindCommand(cmds, str, pmatch) 4726059Samuraistruct cmdtab *cmds; 4736059Samuraichar *str; 4746059Samuraiint *pmatch; 4756059Samurai{ 4766059Samurai int nmatch = 0; 4776059Samurai int len = strlen(str); 4786059Samurai struct cmdtab *found = NULL; 4796059Samurai 4806059Samurai while (cmds->func) { 48125566Sbrian if (cmds->name && strncasecmp(str, cmds->name, len) == 0) { 4826059Samurai nmatch++; 4836059Samurai found = cmds; 48425566Sbrian } else if (cmds->alias && strncasecmp(str, cmds->alias, len) == 0) { 4856059Samurai nmatch++; 4866059Samurai found = cmds; 4876059Samurai } 4886059Samurai cmds++; 4896059Samurai } 4906059Samurai *pmatch = nmatch; 4916059Samurai return(found); 4926059Samurai} 4936059Samurai 4946059Samuraiint 4956059SamuraiFindExec(cmdlist, argc, argv) 4966059Samuraistruct cmdtab *cmdlist; 4976059Samuraiint argc; 4986059Samuraichar **argv; 4996059Samurai{ 5006059Samurai struct cmdtab *cmd; 5016059Samurai int val = 1; 5026059Samurai int nmatch; 5036059Samurai 5046059Samurai cmd = FindCommand(cmdlist, *argv, &nmatch); 5056059Samurai if (nmatch > 1) 5066735Samurai printf("Ambiguous.\n"); 5076735Samurai else if (cmd && ( cmd->lauth & VarLocalAuth ) ) 5086059Samurai val = (cmd->func)(cmd, --argc, ++argv, cmd->args); 5096059Samurai else 5106059Samurai printf("what?\n"); 5116059Samurai return(val); 5126059Samurai} 5136059Samurai 51418885Sjkhint aft_cmd = 1; 51518885Sjkh 5166059Samuraivoid 51718885SjkhPrompt() 5186059Samurai{ 5196735Samurai char *pconnect, *pauth; 5206735Samurai 5216059Samurai if (!(mode & MODE_INTER)) 5226059Samurai return; 5236735Samurai 52418885Sjkh if (!aft_cmd) 52518885Sjkh printf("\n"); 52618885Sjkh else 52718885Sjkh aft_cmd = 0; 5286735Samurai 5296735Samurai if ( VarLocalAuth == LOCAL_AUTH ) 5306735Samurai pauth = " ON "; 5316735Samurai else 5326735Samurai pauth = " on "; 5336059Samurai if (IpcpFsm.state == ST_OPENED && phase == PHASE_NETWORK) 5346735Samurai pconnect = "PPP"; 5356059Samurai else 5366735Samurai pconnect = "ppp"; 5376735Samurai printf("%s%s%s> ", pconnect, pauth, VarShortHost); 5386059Samurai fflush(stdout); 5396059Samurai} 5406059Samurai 5416059Samuraivoid 5426059SamuraiDecodeCommand(buff, nb, prompt) 5436059Samuraichar *buff; 5446059Samuraiint nb; 5456059Samuraiint prompt; 5466059Samurai{ 5476059Samurai char *vector[20]; 5486059Samurai char **argv; 5496059Samurai int argc, val; 5506059Samurai char *cp; 5516059Samurai 5526059Samurai val = 1; 5536059Samurai if (nb > 0) { 5546059Samurai cp = buff + strcspn(buff, "\r\n"); 5556059Samurai if (cp) 5566059Samurai *cp = '\0'; 5576059Samurai { 55825560Sbrian argc = MakeArgs(buff, vector, VECSIZE(vector)); 5596059Samurai argv = vector; 5606059Samurai 5616059Samurai if (argc > 0) 5626059Samurai val = FindExec(Commands, argc, argv); 5636059Samurai } 5646059Samurai } 5656059Samurai if (val && prompt) 5666059Samurai Prompt(0); 5676059Samurai} 5686059Samurai 5696059Samuraistatic int 5706059SamuraiShowCommand(list, argc, argv) 5716059Samuraistruct cmdtab *list; 5726059Samuraiint argc; 5736059Samuraichar **argv; 5746059Samurai{ 5756059Samurai int val = 1; 5766059Samurai 5776059Samurai if (argc > 0) 5786059Samurai val = FindExec(ShowCommands, argc, argv); 5796059Samurai else 5806059Samurai printf("Use ``show ?'' to get a list.\n"); 5816059Samurai return(val); 5826059Samurai} 5836059Samurai 5846059Samuraistatic int 5856059SamuraiTerminalCommand() 5866059Samurai{ 5876059Samurai if (LcpFsm.state > ST_CLOSED) { 5886059Samurai printf("LCP state is [%s]\n", StateNames[LcpFsm.state]); 5896059Samurai return(1); 5906059Samurai } 5916059Samurai if (!IsInteractive()) 5926059Samurai return(1); 5936059Samurai modem = OpenModem(mode); 5946059Samurai if (modem < 0) { 5956059Samurai printf("failed to open modem.\n"); 5966059Samurai return(1); 5976059Samurai } 5986059Samurai printf("Enter to terminal mode.\n"); 5996059Samurai printf("Type `~?' for help.\n"); 6006059Samurai TtyTermMode(); 6016059Samurai return(0); 6026059Samurai} 6036059Samurai 6046059Samuraistatic int 6056059SamuraiQuitCommand(list, argc, argv) 6066059Samuraistruct cmdtab *list; 6076059Samuraiint argc; 6086059Samuraichar **argv; 6096059Samurai{ 6106059Samurai if (mode & (MODE_DIRECT|MODE_DEDICATED|MODE_AUTO)) { 6116764Samurai if (argc > 0 && (VarLocalAuth & LOCAL_AUTH)) { 6126059Samurai Cleanup(EX_NORMAL); 61318911Ssos mode &= ~MODE_INTER; 6146059Samurai } else { 61524753Sache LogPrintf(LOG_PHASE_BIT, "client connection closed.\n"); 6166735Samurai VarLocalAuth = LOCAL_NO_AUTH; 6176059Samurai close(netfd); 6186059Samurai close(1); 6197886Samurai dup2(2, 1); /* Have to have something here or the modem will be 1 */ 6206059Samurai netfd = -1; 6216059Samurai mode &= ~MODE_INTER; 6226059Samurai } 6236059Samurai } else 6246059Samurai Cleanup(EX_NORMAL); 6256059Samurai return(1); 6266059Samurai} 6276059Samurai 6286059Samuraistatic int 6296059SamuraiCloseCommand() 6306059Samurai{ 6316059Samurai LcpClose(); 6326059Samurai return(1); 6336059Samurai} 6346059Samurai 6356059Samuraistatic int 6366059SamuraiDownCommand() 6376059Samurai{ 6386059Samurai LcpDown(); 6396059Samurai return(1); 6406059Samurai} 6416059Samurai 64225067Sbrianstatic int 64325067SbrianSetModemSpeed(list, argc, argv) 6446059Samuraistruct cmdtab *list; 6456059Samuraiint argc; 6466059Samuraichar **argv; 6476059Samurai{ 6486059Samurai int speed; 6496059Samurai 6506059Samurai if (argc > 0) { 6516735Samurai if (strcmp(*argv, "sync") == 0) { 6526735Samurai VarSpeed = 0; 6536735Samurai return(1); 6546735Samurai } 6556059Samurai speed = atoi(*argv); 6566735Samurai if (IntToSpeed(speed) != B0) { 6576735Samurai VarSpeed = speed; 6586735Samurai return(1); 6596059Samurai } 6606059Samurai printf("invalid speed.\n"); 6616059Samurai } 6626059Samurai return(1); 6636059Samurai} 6646059Samurai 66525067Sbrianstatic int 66625067SbrianSetReconnect(list, argc, argv) 66711336Samuraistruct cmdtab *list; 66811336Samuraiint argc; 66911336Samuraichar **argv; 67011336Samurai{ 67125067Sbrian if (argc == 2) { 67225067Sbrian VarReconnectTimer = atoi(argv[0]); 67325067Sbrian VarReconnectTries = atoi(argv[1]); 67425067Sbrian } else 67525067Sbrian printf("Usage: %s %s\n", list->name, list->syntax); 67625067Sbrian return(1); 67725067Sbrian} 67825067Sbrian 67925067Sbrianstatic int 68025067SbrianSetRedialTimeout(list, argc, argv) 68125067Sbrianstruct cmdtab *list; 68225067Sbrianint argc; 68325067Sbrianchar **argv; 68425067Sbrian{ 68511336Samurai int timeout; 68611336Samurai int tries; 68724939Sbrian char *dot; 68811336Samurai 68911336Samurai if (argc == 1 || argc == 2 ) { 69024939Sbrian if (strncasecmp(argv[0], "random", 6) == 0 && 69124939Sbrian (argv[0][6] == '\0' || argv[0][6] == '.')) { 69211336Samurai VarRedialTimeout = -1; 69311336Samurai printf("Using random redial timeout.\n"); 69423603Sache if (!randinit) { 69523603Sache randinit = 1; 69624217Sache if (srandomdev() < 0) 69724217Sache srandom((unsigned long)(time(NULL) ^ getpid())); 69823603Sache } 69911336Samurai } 70011336Samurai else { 70111336Samurai timeout = atoi(argv[0]); 70211336Samurai 70311336Samurai if (timeout >= 0) { 70411336Samurai VarRedialTimeout = timeout; 70511336Samurai } 70611336Samurai else { 70711336Samurai printf("invalid redial timeout\n"); 70811336Samurai printf("Usage: %s %s\n", list->name, list->syntax); 70911336Samurai } 71011336Samurai } 71124939Sbrian 71224939Sbrian dot = index(argv[0],'.'); 71324939Sbrian if (dot) { 71424939Sbrian if (strcasecmp(++dot, "random") == 0) { 71524939Sbrian VarRedialNextTimeout = -1; 71624939Sbrian printf("Using random next redial timeout.\n"); 71724939Sbrian if (!randinit) { 71824939Sbrian randinit = 1; 71924939Sbrian if (srandomdev() < 0) 72024939Sbrian srandom((unsigned long)(time(NULL) ^ getpid())); 72124939Sbrian } 72224939Sbrian } 72324939Sbrian else { 72424939Sbrian timeout = atoi(dot); 72524939Sbrian if (timeout >= 0) { 72624939Sbrian VarRedialNextTimeout = timeout; 72724939Sbrian } 72824939Sbrian else { 72924939Sbrian printf("invalid next redial timeout\n"); 73024939Sbrian printf("Usage: %s %s\n", list->name, list->syntax); 73124939Sbrian } 73224939Sbrian } 73324939Sbrian } 73424939Sbrian else 73524939Sbrian VarRedialNextTimeout = NEXT_REDIAL_PERIOD; /* Default next timeout */ 73624939Sbrian 73711336Samurai if (argc == 2) { 73811336Samurai tries = atoi(argv[1]); 73911336Samurai 74011336Samurai if (tries >= 0) { 74111336Samurai VarDialTries = tries; 74211336Samurai } 74311336Samurai else { 74411336Samurai printf("invalid retry value\n"); 74511336Samurai printf("Usage: %s %s\n", list->name, list->syntax); 74611336Samurai } 74711336Samurai } 74811336Samurai } 74911336Samurai else { 75011336Samurai printf("Usage: %s %s\n", list->name, list->syntax); 75111336Samurai } 75211336Samurai return(1); 75311336Samurai} 75411336Samurai 75525067Sbrianstatic int 75625067SbrianSetModemParity(list, argc, argv) 7576059Samuraistruct cmdtab *list; 7586059Samuraiint argc; 7596059Samuraichar **argv; 7606059Samurai{ 7616059Samurai int parity; 7626059Samurai 7636059Samurai if (argc > 0) { 7646059Samurai parity = ChangeParity(*argv); 7656059Samurai if (parity < 0) 7666059Samurai printf("Invalid parity.\n"); 7676059Samurai else 7686059Samurai VarParity = parity; 7696059Samurai } 7706059Samurai return(1); 7716059Samurai} 7726059Samurai 7736059Samuraistatic int 7746059SamuraiSetDebugLevel(list, argc, argv) 7756059Samuraistruct cmdtab *list; 7766059Samuraiint argc; 7776059Samuraichar **argv; 7786059Samurai{ 7796059Samurai int level, w; 7806059Samurai 7816059Samurai for (level = 0; argc-- > 0; argv++) { 7826059Samurai if (isdigit(**argv)) { 7836059Samurai w = atoi(*argv); 7846059Samurai if (w < 0 || w >= MAXLOGLEVEL) { 7856059Samurai printf("invalid log level.\n"); 7866059Samurai break; 7876059Samurai } else 7886059Samurai level |= (1 << w); 7896059Samurai } else { 7906059Samurai for (w = 0; w < MAXLOGLEVEL; w++) { 7916059Samurai if (strcasecmp(*argv, LogLevelName[w]) == 0) { 7926059Samurai level |= (1 << w); 7936059Samurai continue; 7946059Samurai } 7956059Samurai } 7966059Samurai } 7976059Samurai } 7986059Samurai loglevel = level; 7996059Samurai return(1); 8006059Samurai} 8016059Samurai 8026059Samuraistatic int 8036059SamuraiSetEscape(list, argc, argv) 8046059Samuraistruct cmdtab *list; 8056059Samuraiint argc; 8066059Samuraichar **argv; 8076059Samurai{ 8086059Samurai int code; 8096059Samurai 8106059Samurai for (code = 0; code < 33; code++) 8116059Samurai EscMap[code] = 0; 8126059Samurai while (argc-- > 0) { 8136059Samurai sscanf(*argv++, "%x", &code); 8146059Samurai code &= 0xff; 8156059Samurai EscMap[code >> 3] |= (1 << (code&7)); 8166059Samurai EscMap[32] = 1; 8176059Samurai } 8186059Samurai return(1); 8196059Samurai} 8206059Samurai 8216059Samuraistatic int 8226059SamuraiSetInitialMRU(list, argc, argv) 8236059Samuraistruct cmdtab *list; 8246059Samuraiint argc; 8256059Samuraichar **argv; 8266059Samurai{ 8276059Samurai int mru; 8286059Samurai 8296059Samurai if (argc > 0) { 8306059Samurai mru = atoi(*argv); 8316059Samurai if (mru < 100) 8326059Samurai printf("given value is too small.\n"); 8336059Samurai else if (mru > MAX_MRU) 8346059Samurai printf("given value is too big.\n"); 8356059Samurai else 8366059Samurai VarMRU = mru; 8376059Samurai } 8386059Samurai return(1); 8396059Samurai} 8406059Samurai 8416059Samuraistatic int 8426059SamuraiSetIdleTimeout(list, argc, argv) 8436059Samuraistruct cmdtab *list; 8446059Samuraiint argc; 8456059Samuraichar **argv; 8466059Samurai{ 8476059Samurai if (argc-- > 0) { 8486059Samurai VarIdleTimeout = atoi(*argv++); 8496735Samurai if (argc-- > 0) { 8506735Samurai VarLqrTimeout = atoi(*argv++); 8516735Samurai if (VarLqrTimeout < 1) 8526735Samurai VarLqrTimeout = 30; 8536735Samurai if (argc > 0) { 8546735Samurai VarRetryTimeout = atoi(*argv); 8556735Samurai if (VarRetryTimeout < 1 || VarRetryTimeout > 10) 8566735Samurai VarRetryTimeout = 3; 8576735Samurai } 8586735Samurai } 8596059Samurai } 8606059Samurai return(1); 8616059Samurai} 8626059Samurai 8636059Samuraistruct in_addr 8646059SamuraiGetIpAddr(cp) 8656059Samuraichar *cp; 8666059Samurai{ 8676059Samurai struct hostent *hp; 8686059Samurai struct in_addr ipaddr; 8696059Samurai 8706059Samurai hp = gethostbyname(cp); 8716059Samurai if (hp && hp->h_addrtype == AF_INET) 8726059Samurai bcopy(hp->h_addr, &ipaddr, hp->h_length); 8736059Samurai else if (inet_aton(cp, &ipaddr) == 0) 8746059Samurai ipaddr.s_addr = 0; 8756059Samurai return(ipaddr); 8766059Samurai} 8776059Samurai 8786059Samuraistatic int 8796059SamuraiSetInterfaceAddr(list, argc, argv) 8806059Samuraistruct cmdtab *list; 8816059Samuraiint argc; 8826059Samuraichar **argv; 8836059Samurai{ 8846059Samurai 8856059Samurai DefMyAddress.ipaddr.s_addr = DefHisAddress.ipaddr.s_addr = 0L; 8866059Samurai if (argc > 0) { 8876059Samurai ParseAddr(argc, argv++, 8886059Samurai &DefMyAddress.ipaddr, &DefMyAddress.mask, &DefMyAddress.width); 8896059Samurai if (--argc > 0) { 8906059Samurai ParseAddr(argc, argv++, 8916059Samurai &DefHisAddress.ipaddr, &DefHisAddress.mask, &DefHisAddress.width); 8926059Samurai if (--argc > 0) { 8936059Samurai ifnetmask = GetIpAddr(*argv); 8949440Samurai if (--argc > 0) { 8959440Samurai ParseAddr(argc, argv++, 8969440Samurai &DefTriggerAddress.ipaddr, 89720813Sjkh &DefTriggerAddress.mask, 8989440Samurai &DefTriggerAddress.width); 8999440Samurai } 9006059Samurai } 9016059Samurai } 9026059Samurai } 9036059Samurai /* 9046059Samurai * For backwards compatibility, 0.0.0.0 means any address. 9056059Samurai */ 9066059Samurai if (DefMyAddress.ipaddr.s_addr == 0) { 9076059Samurai DefMyAddress.mask.s_addr = 0; 9086059Samurai DefMyAddress.width = 0; 9096059Samurai } 9106059Samurai if (DefHisAddress.ipaddr.s_addr == 0) { 9116059Samurai DefHisAddress.mask.s_addr = 0; 9126059Samurai DefHisAddress.width = 0; 9136059Samurai } 9146059Samurai 9156735Samurai if ((mode & MODE_AUTO) || 9166059Samurai ((mode & MODE_DEDICATED) && dstsystem)) { 9176059Samurai OsSetIpaddress(DefMyAddress.ipaddr, DefHisAddress.ipaddr, ifnetmask); 9186059Samurai } 9196059Samurai return(1); 9206059Samurai} 9216059Samurai 92218752Sjkh#ifdef MSEXT 9236059Samurai 92418752Sjkhvoid 92518752SjkhSetMSEXT(pri_addr, sec_addr, argc, argv) 92618752Sjkhstruct in_addr *pri_addr; 92718752Sjkhstruct in_addr *sec_addr; 92818752Sjkhint argc; 92918752Sjkhchar **argv; 93018752Sjkh{ 93118752Sjkh int dummyint; 93218752Sjkh struct in_addr dummyaddr; 93318752Sjkh 93418752Sjkh pri_addr->s_addr = sec_addr->s_addr = 0L; 93518752Sjkh 93618752Sjkh if( argc > 0 ) { 93718752Sjkh ParseAddr(argc, argv++, pri_addr, &dummyaddr, &dummyint); 93818752Sjkh if( --argc > 0 ) 93918752Sjkh ParseAddr(argc, argv++, sec_addr, &dummyaddr, &dummyint); 94018752Sjkh else 94118752Sjkh sec_addr->s_addr = pri_addr->s_addr; 94218752Sjkh } 94318752Sjkh 94418752Sjkh /* 94518752Sjkh * if the primary/secondary ns entries are 0.0.0.0 we should 94618752Sjkh * set them to either the localhost's ip, or the values in 94718752Sjkh * /etc/resolv.conf ?? 94818752Sjkh * 94918752Sjkh * up to you if you want to implement this... 95018752Sjkh */ 95118752Sjkh 95218752Sjkh} 95318752Sjkh 95418752Sjkhstatic int 95518752SjkhSetNS(list, argc, argv) 95618752Sjkhstruct cmdtab *list; 95718752Sjkhint argc; 95818752Sjkhchar **argv; 95918752Sjkh{ 96018752Sjkh SetMSEXT(&ns_entries[0], &ns_entries[1], argc, argv); 96118752Sjkh return(1); 96218752Sjkh} 96318752Sjkh 96418752Sjkhstatic int 96518752SjkhSetNBNS(list, argc, argv) 96618752Sjkhstruct cmdtab *list; 96718752Sjkhint argc; 96818752Sjkhchar **argv; 96918752Sjkh{ 97018752Sjkh SetMSEXT(&nbns_entries[0], &nbns_entries[1], argc, argv); 97118752Sjkh return(1); 97218752Sjkh} 97318752Sjkh 97418752Sjkh#endif /* MS_EXT */ 97518752Sjkh 9766059Samurai#define VAR_AUTHKEY 0 9776059Samurai#define VAR_DIAL 1 9786059Samurai#define VAR_LOGIN 2 9796059Samurai#define VAR_AUTHNAME 3 9806059Samurai#define VAR_DEVICE 4 9816059Samurai#define VAR_ACCMAP 5 9826059Samurai#define VAR_PHONE 6 9836059Samurai 9846059Samuraistatic int 9856059SamuraiSetVariable(list, argc, argv, param) 9866059Samuraistruct cmdtab *list; 9876059Samuraiint argc; 9886059Samuraichar **argv; 9896059Samuraiint param; 9906059Samurai{ 9916059Samurai u_long map; 9926059Samurai 9936059Samurai if (argc > 0) { 9946059Samurai switch (param) { 9956059Samurai case VAR_AUTHKEY: 9966059Samurai strncpy(VarAuthKey, *argv, sizeof(VarAuthKey)-1); 99721488Simp VarAuthKey[sizeof(VarAuthKey)-1] = '\0'; 9986059Samurai break; 9996059Samurai case VAR_AUTHNAME: 10006059Samurai strncpy(VarAuthName, *argv, sizeof(VarAuthName)-1); 100121488Simp VarAuthName[sizeof(VarAuthName)-1] = '\0'; 10026059Samurai break; 10036059Samurai case VAR_DIAL: 10046059Samurai strncpy(VarDialScript, *argv, sizeof(VarDialScript)-1); 100521488Simp VarDialScript[sizeof(VarDialScript)-1] = '\0'; 10066059Samurai break; 10076059Samurai case VAR_LOGIN: 100822225Sjoerg strncpy(VarLoginScript, *argv, sizeof(VarLoginScript)-1); 100921488Simp VarLoginScript[sizeof(VarLoginScript)-1] = '\0'; 10106059Samurai break; 10116059Samurai case VAR_DEVICE: 10126059Samurai strncpy(VarDevice, *argv, sizeof(VarDevice)-1); 101321488Simp VarDevice[sizeof(VarDevice)-1] = '\0'; 10146059Samurai break; 10156059Samurai case VAR_ACCMAP: 101613389Sphk sscanf(*argv, "%lx", &map); 10176059Samurai VarAccmap = map; 10186059Samurai break; 10196059Samurai case VAR_PHONE: 102014418Sache strncpy(VarPhoneList, *argv, sizeof(VarPhoneList)-1); 102121488Simp VarPhoneList[sizeof(VarPhoneList)-1] = '\0'; 102214423Sache strcpy(VarPhoneCopy, VarPhoneList); 102314423Sache VarNextPhone = VarPhoneCopy; 10246059Samurai break; 10256059Samurai } 10266059Samurai } 10276059Samurai return(1); 10286059Samurai} 10296059Samurai 103020812Sjkhstatic int SetCtsRts(list, argc, argv) 103120812Sjkhstruct cmdtab *list; 103220812Sjkhint argc; 103320812Sjkhchar **argv; 103420812Sjkh{ 103520812Sjkh if (argc > 0) { 103620812Sjkh if (strcmp(*argv, "on") == 0) 103720812Sjkh VarCtsRts = TRUE; 103820812Sjkh else if (strcmp(*argv, "off") == 0) 103920812Sjkh VarCtsRts = FALSE; 104020812Sjkh else 104120812Sjkh printf("usage: set ctsrts [on|off].\n"); 104220812Sjkh } 104320812Sjkh return(1); 104420812Sjkh} 104520812Sjkh 104620812Sjkh 10476059Samuraistatic int SetOpenMode(list, argc, argv) 10486059Samuraistruct cmdtab *list; 10496059Samuraiint argc; 10506059Samuraichar **argv; 10516059Samurai{ 10526059Samurai if (argc > 0) { 10536059Samurai if (strcmp(*argv, "active") == 0) 10546059Samurai VarOpenMode = OPEN_ACTIVE; 10556059Samurai else if (strcmp(*argv, "passive") == 0) 10566059Samurai VarOpenMode = OPEN_PASSIVE; 10576059Samurai else 10586059Samurai printf("Invalid mode.\n"); 10596059Samurai } 10606059Samurai return(1); 10616059Samurai} 10626059Samuraistatic char StrChatStr[] = "chat-script"; 10636059Samuraistatic char StrValue[] = "value"; 10646059Samurai 10656735Samuraiextern int SetIfilter(), SetOfilter(), SetDfilter(), SetAfilter(); 10666059Samurai 106713760Sphkstruct cmdtab const SetCommands[] = { 10686735Samurai { "accmap", NULL, SetVariable, LOCAL_AUTH, 10696735Samurai "Set accmap value", "hex-value", (void *)VAR_ACCMAP}, 10706735Samurai { "afilter", NULL, SetAfilter, LOCAL_AUTH, 10716735Samurai "Set keep Alive filter", "..."}, 10726735Samurai { "authkey", "key", SetVariable, LOCAL_AUTH, 10736735Samurai "Set authentication key", "key", (void *)VAR_AUTHKEY}, 10746735Samurai { "authname", NULL, SetVariable, LOCAL_AUTH, 10756735Samurai "Set authentication name", "name", (void *)VAR_AUTHNAME}, 107620812Sjkh { "ctsrts", NULL, SetCtsRts, LOCAL_AUTH, 107720812Sjkh "Use CTS/RTS modem signalling", "[on|off]"}, 10786735Samurai { "debug", NULL, SetDebugLevel, LOCAL_AUTH, 10796735Samurai "Set debug level", StrValue}, 10806735Samurai { "device", "line", SetVariable, LOCAL_AUTH, 10816735Samurai "Set modem device name", "device-name", (void *)VAR_DEVICE}, 10826735Samurai { "dfilter", NULL, SetDfilter, LOCAL_AUTH, 10836735Samurai "Set demand filter", "..."}, 10846735Samurai { "dial", NULL, SetVariable, LOCAL_AUTH, 10856735Samurai "Set dialing script", StrChatStr, (void *)VAR_DIAL}, 10866735Samurai { "escape", NULL, SetEscape, LOCAL_AUTH, 10876735Samurai "Set escape characters", "hex-digit ..."}, 10886735Samurai { "ifaddr", NULL, SetInterfaceAddr, LOCAL_AUTH, 108914418Sache "Set destination address", "[src-addr [dst-addr [netmask [trg-addr]]]]"}, 10906735Samurai { "ifilter", NULL, SetIfilter, LOCAL_AUTH, 10916735Samurai "Set input filter", "..."}, 10926735Samurai { "login", NULL, SetVariable, LOCAL_AUTH, 10936735Samurai "Set login script", StrChatStr, (void *)VAR_LOGIN }, 10946735Samurai { "mru", "mtu", SetInitialMRU, LOCAL_AUTH, 10956735Samurai "Set Initial MRU value", StrValue }, 10966735Samurai { "ofilter", NULL, SetOfilter, LOCAL_AUTH, 10976735Samurai "Set output filter", "..." }, 10986735Samurai { "openmode", NULL, SetOpenMode, LOCAL_AUTH, 10996735Samurai "Set open mode", "[active|passive]"}, 11006735Samurai { "parity", NULL, SetModemParity, LOCAL_AUTH, 11016735Samurai "Set modem parity", "[odd|even|none]"}, 11026735Samurai { "phone", NULL, SetVariable, LOCAL_AUTH, 110314418Sache "Set telephone number(s)", "phone1[:phone2[...]]", (void *)VAR_PHONE }, 110425067Sbrian { "reconnect",NULL, SetReconnect, LOCAL_AUTH, 110525067Sbrian "Set Reconnect timeout", "value ntries"}, 110625067Sbrian { "redial", NULL, SetRedialTimeout, LOCAL_AUTH, 110725067Sbrian "Set Redial timeout", "value|random[.value|random] [dial_attempts]"}, 11086735Samurai { "speed", NULL, SetModemSpeed, LOCAL_AUTH, 11096735Samurai "Set modem speed", "speed"}, 11106735Samurai { "timeout", NULL, SetIdleTimeout, LOCAL_AUTH, 11116735Samurai "Set Idle timeout", StrValue}, 111218752Sjkh#ifdef MSEXT 111318752Sjkh { "ns", NULL, SetNS, LOCAL_AUTH, 111418752Sjkh "Set NameServer", "pri-addr [sec-addr]"}, 111518752Sjkh { "nbns", NULL, SetNBNS, LOCAL_AUTH, 111618752Sjkh "Set NetBIOS NameServer", "pri-addr [sec-addr]"}, 111718752Sjkh#endif /* MSEXT */ 11186735Samurai { "help", "?", HelpCommand, LOCAL_AUTH | LOCAL_NO_AUTH, 11196735Samurai "Display this message", StrNull, (void *)SetCommands}, 11206059Samurai { NULL, NULL, NULL }, 11216059Samurai}; 11226059Samurai 11236059Samuraistatic int 11246059SamuraiSetCommand(list, argc, argv) 11256059Samuraistruct cmdtab *list; 11266059Samuraiint argc; 11276059Samuraichar **argv; 11286059Samurai{ 11296059Samurai int val = 1; 11306059Samurai 11316059Samurai if (argc > 0) 11326059Samurai val = FindExec(SetCommands, argc, argv); 11336059Samurai else 113414418Sache printf("Use `set ?' to get a list or `set ? <var>' for syntax help.\n"); 11356059Samurai return(val); 11366059Samurai} 11376059Samurai 11386059Samurai 11396059Samuraistatic int 11406059SamuraiAddCommand(list, argc, argv) 11416059Samuraistruct cmdtab *list; 11426059Samuraiint argc; 11436059Samuraichar **argv; 11446059Samurai{ 11456059Samurai struct in_addr dest, gateway, netmask; 11466059Samurai 11476059Samurai if (argc == 3) { 11486059Samurai dest = GetIpAddr(argv[0]); 11496059Samurai netmask = GetIpAddr(argv[1]); 115025566Sbrian if (strcasecmp(argv[2], "HISADDR") == 0) 11516059Samurai gateway = IpcpInfo.his_ipaddr; 11526059Samurai else 11536059Samurai gateway = GetIpAddr(argv[2]); 11546059Samurai OsSetRoute(RTM_ADD, dest, gateway, netmask); 11556059Samurai } else { 11566059Samurai printf("Usage: %s %s\n", list->name, list->syntax); 11576059Samurai } 11586059Samurai return(1); 11596059Samurai} 11606059Samurai 11616059Samuraistatic int 11626059SamuraiDeleteCommand(list, argc, argv) 11636059Samuraistruct cmdtab *list; 11646059Samuraiint argc; 11656059Samuraichar **argv; 11666059Samurai{ 11676059Samurai struct in_addr dest, gateway, netmask; 11686059Samurai 11696059Samurai if (argc >= 2) { 11706059Samurai dest = GetIpAddr(argv[0]); 117125566Sbrian if (strcasecmp(argv[1], "HISADDR") == 0) 11726059Samurai gateway = IpcpInfo.his_ipaddr; 11736059Samurai else 11746059Samurai gateway = GetIpAddr(argv[1]); 11756059Samurai netmask.s_addr = 0; 11766059Samurai if (argc == 3) { 11776059Samurai if (inet_aton(argv[1], &netmask) == 0) { 11786059Samurai printf("bad netmask value.\n"); 11796059Samurai return(1); 11806059Samurai } 11816059Samurai } 11826059Samurai OsSetRoute(RTM_DELETE, dest, gateway, netmask); 118325566Sbrian } else if (argc == 1 && strcasecmp(argv[0], "ALL") == 0) { 11846059Samurai DeleteIfRoutes(0); 11856059Samurai } else { 11866059Samurai printf("Usage: %s %s\n", list->name, list->syntax); 11876059Samurai } 11886059Samurai return(1); 11896059Samurai} 11906059Samurai 1191