command.c revision 26031
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 * 2026031Sbrian * $Id: command.c,v 1.47 1997/05/19 01:59:59 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> 2826031Sbrian#include <netdb.h> 2926031Sbrian#include <sys/socket.h> 3026031Sbrian#include <netinet/in.h> 3126031Sbrian#include <arpa/inet.h> 3226031Sbrian#include <net/route.h> 3326031Sbrian#include <paths.h> 3426031Sbrian#include <alias.h> 356059Samurai#include "fsm.h" 366059Samurai#include "phase.h" 376059Samurai#include "lcp.h" 386059Samurai#include "ipcp.h" 396059Samurai#include "modem.h" 4013389Sphk#include "filter.h" 416059Samurai#include "command.h" 4226031Sbrian#include "alias_cmd.h" 436059Samurai#include "hdlc.h" 446059Samurai#include "vars.h" 4525630Sbrian#include "systems.h" 4625630Sbrian#include "chat.h" 476059Samurai#include "os.h" 4825560Sbrian#include "chat.h" 496059Samurai 506059Samuraiextern void Cleanup(), TtyTermMode(), PacketMode(); 516059Samuraiextern int EnableCommand(), DisableCommand(), DisplayCommand(); 526059Samuraiextern int AcceptCommand(), DenyCommand(); 5326031Sbrianstatic int AliasCommand(); 546735Samuraiextern int LocalAuthCommand(); 556059Samuraiextern int LoadCommand(), SaveCommand(); 566059Samuraiextern int ChangeParity(char *); 576059Samuraiextern int SelectSystem(); 586059Samuraiextern int ShowRoute(); 5910528Samuraiextern void TtyOldMode(), TtyCommandMode(); 606735Samuraiextern struct pppvars pppVars; 6114418Sacheextern struct cmdtab const SetCommands[]; 626059Samurai 6322973Sphkextern char *IfDevName; 6422973Sphk 656059Samuraistruct in_addr ifnetmask; 6623603Sacheint randinit; 676059Samurai 686059Samuraistatic int ShowCommand(), TerminalCommand(), QuitCommand(); 696059Samuraistatic int CloseCommand(), DialCommand(), DownCommand(); 706059Samuraistatic int SetCommand(), AddCommand(), DeleteCommand(); 7110528Samuraistatic int ShellCommand(); 726059Samurai 736059Samuraistatic int 746059SamuraiHelpCommand(list, argc, argv, plist) 756059Samuraistruct cmdtab *list; 766059Samuraiint argc; 776059Samuraichar **argv; 786059Samuraistruct cmdtab *plist; 796059Samurai{ 806059Samurai struct cmdtab *cmd; 816059Samurai int n; 826059Samurai char c; 836059Samurai 846059Samurai if (argc > 0) { 856059Samurai for (cmd = plist; cmd->name; cmd++) { 8625566Sbrian if (strcasecmp(cmd->name, *argv) == 0 && (cmd->lauth & VarLocalAuth)) { 8714418Sache if (plist == SetCommands) 8814418Sache printf("set "); 896059Samurai printf("%s %s\n", cmd->name, cmd->syntax); 906059Samurai return(1); 916059Samurai } 926059Samurai } 936059Samurai return(1); 946059Samurai } 956059Samurai n = 0; 966059Samurai for (cmd = plist; cmd->func; cmd++) { 976764Samurai if (cmd->name && (cmd->lauth & VarLocalAuth)) { 986764Samurai c = (n & 1)? '\n' : '\t'; 996059Samurai printf(" %-8s: %-20s%c", cmd->name, cmd->helpmes, c); 1006059Samurai n++; 1016059Samurai } 1026059Samurai } 1036059Samurai if (n & 1) 1046059Samurai printf("\n"); 1056059Samurai return(1); 1066059Samurai} 1076059Samurai 1086059Samuraiint 1096059SamuraiIsInteractive() 1106059Samurai{ 1116059Samurai char *mes = NULL; 1126059Samurai 11320120Snate if (mode & MODE_DDIAL) 11420120Snate mes = "Working in dedicated dial mode."; 11525908Sbrian else if (mode & MODE_BACKGROUND) 11625908Sbrian mes = "Working in background mode."; 11720120Snate else if (mode & MODE_AUTO) 11810528Samurai mes = "Working in auto mode."; 1196059Samurai else if (mode & MODE_DIRECT) 12010528Samurai mes = "Working in direct mode."; 1216059Samurai else if (mode & MODE_DEDICATED) 12210528Samurai mes = "Working in dedicated mode."; 1236059Samurai if (mes) { 1246059Samurai printf("%s\n", mes); 1256059Samurai return(0); 1266059Samurai } 1276059Samurai return(1); 1286059Samurai} 1296059Samurai 1306059Samuraistatic int 1316059SamuraiDialCommand(cmdlist, argc, argv) 1326059Samuraistruct cmdtab *cmdlist; 1336059Samuraiint argc; 1346059Samuraichar **argv; 1356059Samurai{ 13611336Samurai int tries; 13711336Samurai 1386059Samurai if (LcpFsm.state > ST_CLOSED) { 1396059Samurai printf("LCP state is [%s]\n", StateNames[LcpFsm.state]); 1406059Samurai return(1); 1416059Samurai } 1426059Samurai if (!IsInteractive()) 1436059Samurai return(1); 1446735Samurai if (argc > 0) { 1456735Samurai if (SelectSystem(*argv, CONFFILE) < 0) { 1466735Samurai printf("%s: not found.\n", *argv); 1476735Samurai return(1); 1486735Samurai } 1496735Samurai } 15011336Samurai tries = 0; 15111336Samurai do { 15225801Sbrian printf("Dial attempt %u of %d\n", ++tries, VarDialTries); 15311336Samurai modem = OpenModem(mode); 15411336Samurai if (modem < 0) { 15511336Samurai printf("failed to open modem.\n"); 15611336Samurai break; 15711336Samurai } 15811336Samurai if (DialModem()) { 15911336Samurai sleep(1); 16011336Samurai ModemTimeout(); 16111336Samurai PacketMode(); 16211336Samurai break; 16311336Samurai } 16411336Samurai } while (VarDialTries == 0 || tries < VarDialTries); 1656059Samurai return(1); 1666059Samurai} 1676059Samurai 16810528Samuraistatic int 16910528SamuraiShellCommand(cmdlist, argc, argv) 17010528Samuraistruct cmdtab *cmdlist; 17110528Samuraiint argc; 17210528Samuraichar **argv; 17310528Samurai{ 17410528Samurai const char *shell; 17510528Samurai pid_t shpid; 17620813Sjkh 17710528Samurai if((shell = getenv("SHELL")) == 0) { 17810528Samurai shell = _PATH_BSHELL; 17910528Samurai } 18018856Ssos#ifdef SHELL_ONLY_INTERACTIVELY 18110528Samurai#ifndef HAVE_SHELL_CMD_WITH_ANY_MODE 18210528Samurai if( mode != MODE_INTER) { 18310528Samurai fprintf(stdout, 18418911Ssos "Can only start a shell in interactive mode\n"); 18510528Samurai return(1); 18610528Samurai } 18710528Samurai#else 18810528Samurai if(argc == 0 && !(mode & MODE_INTER)) { 18910528Samurai fprintf(stderr, 19018911Ssos "Can only start an interactive shell in interactive mode\n"); 19110528Samurai return(1); 19210528Samurai } 19310528Samurai#endif /* HAVE_SHELL_CMD_WITH_ANY_MODE */ 19418911Ssos#else 19518911Ssos if ((mode & (MODE_AUTO|MODE_INTER)) == (MODE_AUTO|MODE_INTER)) { 19618911Ssos fprintf(stdout, 19718911Ssos "Shell is not allowed interactively in auto mode\n"); 19818911Ssos return(1); 19918911Ssos } 20018856Ssos#endif /* SHELL_ONLY_INTERACTIVELY */ 20110528Samurai if((shpid = fork()) == 0) { 20218531Sbde int dtablesize, i ; 20318531Sbde 20418531Sbde for (dtablesize = getdtablesize(), i = 3; i < dtablesize; i++) 20510528Samurai (void)close(i); 20610528Samurai 20710528Samurai /* 20810528Samurai * We are running setuid, we should change to 20910528Samurai * real user for avoiding security problems. 21010528Samurai */ 21116263Sache if (setgid(getgid()) < 0) { 21216263Sache perror("setgid"); 21316263Sache exit(1); 21416263Sache } 21516263Sache if (setuid(getuid()) < 0) { 21616263Sache perror("setuid"); 21716263Sache exit(1); 21816263Sache } 21910528Samurai TtyOldMode(); 22018790Ssos if(argc > 0) { 22118790Ssos /* substitute pseudo args */ 22218790Ssos for (i=1; i<argc; i++) { 22325566Sbrian if (strcasecmp(argv[i], "HISADDR") == 0) { 22418790Ssos argv[i] = strdup(inet_ntoa(IpcpInfo.his_ipaddr)); 22518790Ssos } 22625566Sbrian if (strcasecmp(argv[i], "INTERFACE") == 0) { 22722973Sphk argv[i] = strdup(IfDevName); 22822973Sphk } 22925566Sbrian if (strcasecmp(argv[i], "MYADDR") == 0) { 23018790Ssos argv[i] = strdup(inet_ntoa(IpcpInfo.want_ipaddr)); 23118790Ssos } 23218790Ssos } 23325630Sbrian (void)execvp(argv[0], argv); 23418790Ssos } 23510528Samurai else 23625630Sbrian (void)execl(shell, shell, NULL); 23720813Sjkh 23810528Samurai fprintf(stdout, "exec() of %s failed\n", argc > 0? argv[0]: shell); 23910528Samurai exit(255); 24010528Samurai } 24110528Samurai if( shpid == (pid_t)-1 ) { 24210528Samurai fprintf(stdout, "Fork failed\n"); 24310528Samurai } else { 24410528Samurai int status; 24510528Samurai (void)waitpid(shpid, &status, 0); 24610528Samurai } 24720813Sjkh 24810528Samurai TtyCommandMode(1); 24920813Sjkh 25010528Samurai return(0); 25110528Samurai} 25210528Samurai 2536059Samuraistatic char StrOption[] = "option .."; 2546059Samuraistatic char StrRemote[] = "[remote]"; 2556059Samuraichar StrNull[] = ""; 2566059Samurai 25713760Sphkstruct cmdtab const Commands[] = { 2586735Samurai { "accept", NULL, AcceptCommand, LOCAL_AUTH, 2596735Samurai "accept option request", StrOption}, 2606735Samurai { "add", NULL, AddCommand, LOCAL_AUTH, 2616735Samurai "add route", "dest mask gateway"}, 2626735Samurai { "close", NULL, CloseCommand, LOCAL_AUTH, 2636735Samurai "Close connection", StrNull}, 2646735Samurai { "delete", NULL, DeleteCommand, LOCAL_AUTH, 26514418Sache "delete route", "ALL | dest gateway [mask]"}, 2666735Samurai { "deny", NULL, DenyCommand, LOCAL_AUTH, 2676735Samurai "Deny option request", StrOption}, 2686735Samurai { "dial", "call", DialCommand, LOCAL_AUTH, 2696735Samurai "Dial and login", StrRemote}, 2706735Samurai { "disable", NULL, DisableCommand, LOCAL_AUTH, 2716735Samurai "Disable option", StrOption}, 2726735Samurai { "display", NULL, DisplayCommand, LOCAL_AUTH, 2736735Samurai "Display option configs", StrNull}, 2746735Samurai { "enable", NULL, EnableCommand, LOCAL_AUTH, 2756735Samurai "Enable option", StrOption}, 2766764Samurai { "passwd", NULL, LocalAuthCommand,LOCAL_NO_AUTH, 2779240Sphk "Password for manipulation", StrOption}, 2786735Samurai { "load", NULL, LoadCommand, LOCAL_AUTH, 2796735Samurai "Load settings", StrRemote}, 2806735Samurai { "save", NULL, SaveCommand, LOCAL_AUTH, 2816735Samurai "Save settings", StrNull}, 2826735Samurai { "set", "setup", SetCommand, LOCAL_AUTH, 2836735Samurai "Set parameters", "var value"}, 28410528Samurai { "shell", "!", ShellCommand, LOCAL_AUTH, 28510528Samurai "Run a subshell", "[sh command]"}, 2866735Samurai { "show", NULL, ShowCommand, LOCAL_AUTH, 2876735Samurai "Show status and statictics", "var"}, 2886735Samurai { "term", NULL, TerminalCommand,LOCAL_AUTH, 2896735Samurai "Enter to terminal mode", StrNull}, 29026031Sbrian { "alias", NULL, AliasCommand, LOCAL_AUTH, 29126031Sbrian "alias control", "option [yes|no]"}, 2926764Samurai { "quit", "bye", QuitCommand, LOCAL_AUTH | LOCAL_NO_AUTH, 29314418Sache "Quit PPP program", "[all]"}, 2946735Samurai { "help", "?", HelpCommand, LOCAL_AUTH | LOCAL_NO_AUTH, 2956059Samurai "Display this message", "[command]", (void *)Commands }, 2966735Samurai { NULL, "down", DownCommand, LOCAL_AUTH, 2976735Samurai "Generate down event", StrNull}, 2986059Samurai { NULL, NULL, NULL }, 2996059Samurai}; 3006059Samurai 3016059Samuraiextern int ReportCcpStatus(); 3026059Samuraiextern int ReportLcpStatus(); 3036059Samuraiextern int ReportIpcpStatus(); 3046059Samuraiextern int ReportProtStatus(); 3056059Samuraiextern int ReportCompress(); 3066059Samuraiextern int ShowModemStatus(); 3076059Samuraiextern int ReportHdlcStatus(); 3086059Samuraiextern int ShowMemMap(); 3096059Samurai 3106059Samuraistatic char *LogLevelName[] = { 31115738Sphk LM_PHASE, LM_CHAT, LM_LQM, LM_LCP, 31215738Sphk LM_TCPIP, LM_HDLC, LM_ASYNC, LM_LINK, 31315738Sphk LM_CONNECT, LM_CARRIER, 3146059Samurai}; 3156059Samurai 3166059Samuraistatic int ShowDebugLevel() 3176059Samurai{ 3186059Samurai int i; 3196059Samurai 3206059Samurai printf("%02x: ", loglevel); 3216059Samurai for (i = LOG_PHASE; i < MAXLOGLEVEL; i++) { 3226059Samurai if (loglevel & (1 << i)) 3236059Samurai printf("%s ", LogLevelName[i]); 3246059Samurai } 3256059Samurai printf("\n"); 3266059Samurai return(1); 3276059Samurai} 3286059Samurai 3296059Samuraistatic int ShowEscape() 3306059Samurai{ 3316059Samurai int code, bit; 3326059Samurai 3336059Samurai if (EscMap[32]) { 3346059Samurai for (code = 0; code < 32; code++) { 3356059Samurai if (EscMap[code]) { 3366059Samurai for (bit = 0; bit < 8; bit++) { 3376059Samurai if (EscMap[code] & (1<<bit)) { 3386059Samurai printf(" 0x%02x", (code << 3) + bit); 3396059Samurai } 3406059Samurai } 3416059Samurai } 3426059Samurai } 3436059Samurai printf("\n"); 3446059Samurai } 3456059Samurai return(1); 3466059Samurai} 3476059Samurai 3486059Samuraistatic int ShowTimeout() 3496059Samurai{ 3506735Samurai printf(" Idle Timer: %d secs LQR Timer: %d secs Retry Timer: %d secs\n", 3516735Samurai VarIdleTimeout, VarLqrTimeout, VarRetryTimeout); 3526059Samurai return(1); 3536059Samurai} 3546059Samurai 3556059Samuraistatic int ShowAuthKey() 3566059Samurai{ 3576059Samurai printf("AuthName = %s\n", VarAuthName); 3586059Samurai printf("AuthKey = %s\n", VarAuthKey); 3596059Samurai return(1); 3606059Samurai} 3616059Samurai 3626059Samuraistatic int ShowVersion() 3636059Samurai{ 36413389Sphk extern char VarVersion[]; 36513389Sphk extern char VarLocalVersion[]; 3666059Samurai 3679448Samurai printf("%s - %s \n", VarVersion, VarLocalVersion); 3686059Samurai return(1); 3696059Samurai} 3706059Samurai 3716059Samuraistatic int ShowLogList() 3726059Samurai{ 3736059Samurai ListLog(); 3746059Samurai return(1); 3756059Samurai} 3766059Samurai 37725067Sbrianstatic int ShowReconnect() 37825067Sbrian{ 37925067Sbrian printf(" Reconnect Timer: %d, %d tries\n", 38025067Sbrian VarReconnectTimer, VarReconnectTries); 38125067Sbrian return(1); 38225067Sbrian} 38325067Sbrian 38411336Samuraistatic int ShowRedial() 38511336Samurai{ 38611336Samurai printf(" Redial Timer: "); 38711336Samurai 38811336Samurai if (VarRedialTimeout >= 0) { 38911336Samurai printf(" %d seconds, ", VarRedialTimeout); 39011336Samurai } 39111336Samurai else { 39211336Samurai printf(" Random 0 - %d seconds, ", REDIAL_PERIOD); 39311336Samurai } 39411336Samurai 39524939Sbrian printf(" Redial Next Timer: "); 39624939Sbrian 39724939Sbrian if (VarRedialNextTimeout >= 0) { 39824939Sbrian printf(" %d seconds, ", VarRedialNextTimeout); 39924939Sbrian } 40024939Sbrian else { 40124939Sbrian printf(" Random 0 - %d seconds, ", REDIAL_PERIOD); 40224939Sbrian } 40324939Sbrian 40411336Samurai if (VarDialTries) 40511336Samurai printf("%d dial tries", VarDialTries); 40611336Samurai 40711336Samurai printf("\n"); 40811336Samurai 40911336Samurai return(1); 41011336Samurai} 41111336Samurai 41218752Sjkh#ifdef MSEXT 41318752Sjkhstatic int ShowMSExt() 41418752Sjkh{ 41518752Sjkh printf(" MS PPP extention values \n" ); 41618752Sjkh printf(" Primary NS : %s\n", inet_ntoa( ns_entries[0] )); 41718752Sjkh printf(" Secondary NS : %s\n", inet_ntoa( ns_entries[1] )); 41818752Sjkh printf(" Primary NBNS : %s\n", inet_ntoa( nbns_entries[0] )); 41918752Sjkh printf(" Secondary NBNS : %s\n", inet_ntoa( nbns_entries[1] )); 42011336Samurai 42118752Sjkh return(1); 42218752Sjkh} 42318752Sjkh#endif /* MSEXT */ 42418752Sjkh 4256735Samuraiextern int ShowIfilter(), ShowOfilter(), ShowDfilter(), ShowAfilter(); 4266059Samurai 42713760Sphkstruct cmdtab const ShowCommands[] = { 4286735Samurai { "afilter", NULL, ShowAfilter, LOCAL_AUTH, 4296735Samurai "Show keep Alive filters", StrOption}, 4306735Samurai { "auth", NULL, ShowAuthKey, LOCAL_AUTH, 4316735Samurai "Show auth name/key", StrNull}, 4326735Samurai { "ccp", NULL, ReportCcpStatus, LOCAL_AUTH, 4336735Samurai "Show CCP status", StrNull}, 4346735Samurai { "compress", NULL, ReportCompress, LOCAL_AUTH, 4356735Samurai "Show compression statictics", StrNull}, 4366735Samurai { "debug", NULL, ShowDebugLevel, LOCAL_AUTH, 4376735Samurai "Show current debug level", StrNull}, 4386735Samurai { "dfilter", NULL, ShowDfilter, LOCAL_AUTH, 4396735Samurai "Show Demand filters", StrOption}, 4406735Samurai { "escape", NULL, ShowEscape, LOCAL_AUTH, 4416735Samurai "Show escape characters", StrNull}, 4426735Samurai { "hdlc", NULL, ReportHdlcStatus, LOCAL_AUTH, 4436735Samurai "Show HDLC error summary", StrNull}, 4446735Samurai { "ifilter", NULL, ShowIfilter, LOCAL_AUTH, 4456735Samurai "Show Input filters", StrOption}, 4466735Samurai { "ipcp", NULL, ReportIpcpStatus, LOCAL_AUTH, 4476735Samurai "Show IPCP status", StrNull}, 4486735Samurai { "lcp", NULL, ReportLcpStatus, LOCAL_AUTH, 4496735Samurai "Show LCP status", StrNull}, 4506735Samurai { "log", NULL, ShowLogList, LOCAL_AUTH, 4516735Samurai "Show log records", StrNull}, 4526735Samurai { "mem", NULL, ShowMemMap, LOCAL_AUTH, 4536735Samurai "Show memory map", StrNull}, 4546735Samurai { "modem", NULL, ShowModemStatus, LOCAL_AUTH, 4556735Samurai "Show modem setups", StrNull}, 4566735Samurai { "ofilter", NULL, ShowOfilter, LOCAL_AUTH, 4576735Samurai "Show Output filters", StrOption}, 4586735Samurai { "proto", NULL, ReportProtStatus, LOCAL_AUTH, 4596735Samurai "Show protocol summary", StrNull}, 46025067Sbrian { "reconnect",NULL, ShowReconnect, LOCAL_AUTH, 46125690Sache "Show Reconnect timer,tries", StrNull}, 46225067Sbrian { "redial", NULL, ShowRedial, LOCAL_AUTH, 46325067Sbrian "Show Redial timeout value", StrNull}, 4646735Samurai { "route", NULL, ShowRoute, LOCAL_AUTH, 4656735Samurai "Show routing table", StrNull}, 4666735Samurai { "timeout", NULL, ShowTimeout, LOCAL_AUTH, 4676735Samurai "Show Idle timeout value", StrNull}, 46818752Sjkh#ifdef MSEXT 46918752Sjkh { "msext", NULL, ShowMSExt, LOCAL_AUTH, 47023598Sache "Show MS PPP extentions", StrNull}, 47118752Sjkh#endif /* MSEXT */ 4726735Samurai { "version", NULL, ShowVersion, LOCAL_NO_AUTH | LOCAL_AUTH, 4736735Samurai "Show version string", StrNull}, 4746735Samurai { "help", "?", HelpCommand, LOCAL_NO_AUTH | LOCAL_AUTH, 4756735Samurai "Display this message", StrNull, (void *)ShowCommands}, 4766059Samurai { NULL, NULL, NULL }, 4776059Samurai}; 4786059Samurai 4796059Samuraistruct cmdtab * 4806059SamuraiFindCommand(cmds, str, pmatch) 4816059Samuraistruct cmdtab *cmds; 4826059Samuraichar *str; 4836059Samuraiint *pmatch; 4846059Samurai{ 4856059Samurai int nmatch = 0; 4866059Samurai int len = strlen(str); 4876059Samurai struct cmdtab *found = NULL; 4886059Samurai 4896059Samurai while (cmds->func) { 49025566Sbrian if (cmds->name && strncasecmp(str, cmds->name, len) == 0) { 4916059Samurai nmatch++; 4926059Samurai found = cmds; 49325566Sbrian } else if (cmds->alias && strncasecmp(str, cmds->alias, len) == 0) { 4946059Samurai nmatch++; 4956059Samurai found = cmds; 4966059Samurai } 4976059Samurai cmds++; 4986059Samurai } 4996059Samurai *pmatch = nmatch; 5006059Samurai return(found); 5016059Samurai} 5026059Samurai 5036059Samuraiint 5046059SamuraiFindExec(cmdlist, argc, argv) 5056059Samuraistruct cmdtab *cmdlist; 5066059Samuraiint argc; 5076059Samuraichar **argv; 5086059Samurai{ 5096059Samurai struct cmdtab *cmd; 5106059Samurai int val = 1; 5116059Samurai int nmatch; 5126059Samurai 5136059Samurai cmd = FindCommand(cmdlist, *argv, &nmatch); 5146059Samurai if (nmatch > 1) 5156735Samurai printf("Ambiguous.\n"); 5166735Samurai else if (cmd && ( cmd->lauth & VarLocalAuth ) ) 5176059Samurai val = (cmd->func)(cmd, --argc, ++argv, cmd->args); 5186059Samurai else 5196059Samurai printf("what?\n"); 5206059Samurai return(val); 5216059Samurai} 5226059Samurai 52318885Sjkhint aft_cmd = 1; 52418885Sjkh 5256059Samuraivoid 52618885SjkhPrompt() 5276059Samurai{ 5286735Samurai char *pconnect, *pauth; 5296735Samurai 5306059Samurai if (!(mode & MODE_INTER)) 5316059Samurai return; 5326735Samurai 53318885Sjkh if (!aft_cmd) 53418885Sjkh printf("\n"); 53518885Sjkh else 53618885Sjkh aft_cmd = 0; 5376735Samurai 5386735Samurai if ( VarLocalAuth == LOCAL_AUTH ) 5396735Samurai pauth = " ON "; 5406735Samurai else 5416735Samurai pauth = " on "; 5426059Samurai if (IpcpFsm.state == ST_OPENED && phase == PHASE_NETWORK) 5436735Samurai pconnect = "PPP"; 5446059Samurai else 5456735Samurai pconnect = "ppp"; 5466735Samurai printf("%s%s%s> ", pconnect, pauth, VarShortHost); 5476059Samurai fflush(stdout); 5486059Samurai} 5496059Samurai 5506059Samuraivoid 5516059SamuraiDecodeCommand(buff, nb, prompt) 5526059Samuraichar *buff; 5536059Samuraiint nb; 5546059Samuraiint prompt; 5556059Samurai{ 5566059Samurai char *vector[20]; 5576059Samurai char **argv; 5586059Samurai int argc, val; 5596059Samurai char *cp; 5606059Samurai 5616059Samurai val = 1; 5626059Samurai if (nb > 0) { 5636059Samurai cp = buff + strcspn(buff, "\r\n"); 5646059Samurai if (cp) 5656059Samurai *cp = '\0'; 5666059Samurai { 56725560Sbrian argc = MakeArgs(buff, vector, VECSIZE(vector)); 5686059Samurai argv = vector; 5696059Samurai 5706059Samurai if (argc > 0) 5716059Samurai val = FindExec(Commands, argc, argv); 5726059Samurai } 5736059Samurai } 5746059Samurai if (val && prompt) 57525630Sbrian Prompt(); 5766059Samurai} 5776059Samurai 5786059Samuraistatic int 5796059SamuraiShowCommand(list, argc, argv) 5806059Samuraistruct cmdtab *list; 5816059Samuraiint argc; 5826059Samuraichar **argv; 5836059Samurai{ 5846059Samurai int val = 1; 5856059Samurai 5866059Samurai if (argc > 0) 5876059Samurai val = FindExec(ShowCommands, argc, argv); 5886059Samurai else 5896059Samurai printf("Use ``show ?'' to get a list.\n"); 5906059Samurai return(val); 5916059Samurai} 5926059Samurai 5936059Samuraistatic int 5946059SamuraiTerminalCommand() 5956059Samurai{ 5966059Samurai if (LcpFsm.state > ST_CLOSED) { 5976059Samurai printf("LCP state is [%s]\n", StateNames[LcpFsm.state]); 5986059Samurai return(1); 5996059Samurai } 6006059Samurai if (!IsInteractive()) 6016059Samurai return(1); 6026059Samurai modem = OpenModem(mode); 6036059Samurai if (modem < 0) { 6046059Samurai printf("failed to open modem.\n"); 6056059Samurai return(1); 6066059Samurai } 6076059Samurai printf("Enter to terminal mode.\n"); 6086059Samurai printf("Type `~?' for help.\n"); 6096059Samurai TtyTermMode(); 6106059Samurai return(0); 6116059Samurai} 6126059Samurai 6136059Samuraistatic int 6146059SamuraiQuitCommand(list, argc, argv) 6156059Samuraistruct cmdtab *list; 6166059Samuraiint argc; 6176059Samuraichar **argv; 6186059Samurai{ 6196059Samurai if (mode & (MODE_DIRECT|MODE_DEDICATED|MODE_AUTO)) { 6206764Samurai if (argc > 0 && (VarLocalAuth & LOCAL_AUTH)) { 6216059Samurai Cleanup(EX_NORMAL); 62218911Ssos mode &= ~MODE_INTER; 6236059Samurai } else { 62424753Sache LogPrintf(LOG_PHASE_BIT, "client connection closed.\n"); 6256735Samurai VarLocalAuth = LOCAL_NO_AUTH; 6266059Samurai close(netfd); 6276059Samurai close(1); 6287886Samurai dup2(2, 1); /* Have to have something here or the modem will be 1 */ 6296059Samurai netfd = -1; 6306059Samurai mode &= ~MODE_INTER; 6316059Samurai } 6326059Samurai } else 6336059Samurai Cleanup(EX_NORMAL); 6346059Samurai return(1); 6356059Samurai} 6366059Samurai 6376059Samuraistatic int 6386059SamuraiCloseCommand() 6396059Samurai{ 6406059Samurai LcpClose(); 64125908Sbrian reconnectCount = 0; 64225908Sbrian if (mode & MODE_BACKGROUND) 64325908Sbrian Cleanup(EX_NORMAL); 6446059Samurai return(1); 6456059Samurai} 6466059Samurai 6476059Samuraistatic int 6486059SamuraiDownCommand() 6496059Samurai{ 6506059Samurai LcpDown(); 6516059Samurai return(1); 6526059Samurai} 6536059Samurai 65425067Sbrianstatic int 65525067SbrianSetModemSpeed(list, argc, argv) 6566059Samuraistruct cmdtab *list; 6576059Samuraiint argc; 6586059Samuraichar **argv; 6596059Samurai{ 6606059Samurai int speed; 6616059Samurai 6626059Samurai if (argc > 0) { 6636735Samurai if (strcmp(*argv, "sync") == 0) { 6646735Samurai VarSpeed = 0; 6656735Samurai return(1); 6666735Samurai } 6676059Samurai speed = atoi(*argv); 6686735Samurai if (IntToSpeed(speed) != B0) { 6696735Samurai VarSpeed = speed; 6706735Samurai return(1); 6716059Samurai } 6726059Samurai printf("invalid speed.\n"); 6736059Samurai } 6746059Samurai return(1); 6756059Samurai} 6766059Samurai 67725067Sbrianstatic int 67825067SbrianSetReconnect(list, argc, argv) 67911336Samuraistruct cmdtab *list; 68011336Samuraiint argc; 68111336Samuraichar **argv; 68211336Samurai{ 68325067Sbrian if (argc == 2) { 68425067Sbrian VarReconnectTimer = atoi(argv[0]); 68525067Sbrian VarReconnectTries = atoi(argv[1]); 68625067Sbrian } else 68725067Sbrian printf("Usage: %s %s\n", list->name, list->syntax); 68825067Sbrian return(1); 68925067Sbrian} 69025067Sbrian 69125067Sbrianstatic int 69225067SbrianSetRedialTimeout(list, argc, argv) 69325067Sbrianstruct cmdtab *list; 69425067Sbrianint argc; 69525067Sbrianchar **argv; 69625067Sbrian{ 69711336Samurai int timeout; 69811336Samurai int tries; 69924939Sbrian char *dot; 70011336Samurai 70111336Samurai if (argc == 1 || argc == 2 ) { 70224939Sbrian if (strncasecmp(argv[0], "random", 6) == 0 && 70324939Sbrian (argv[0][6] == '\0' || argv[0][6] == '.')) { 70411336Samurai VarRedialTimeout = -1; 70511336Samurai printf("Using random redial timeout.\n"); 70623603Sache if (!randinit) { 70723603Sache randinit = 1; 70824217Sache if (srandomdev() < 0) 70924217Sache srandom((unsigned long)(time(NULL) ^ getpid())); 71023603Sache } 71111336Samurai } 71211336Samurai else { 71311336Samurai timeout = atoi(argv[0]); 71411336Samurai 71511336Samurai if (timeout >= 0) { 71611336Samurai VarRedialTimeout = timeout; 71711336Samurai } 71811336Samurai else { 71911336Samurai printf("invalid redial timeout\n"); 72011336Samurai printf("Usage: %s %s\n", list->name, list->syntax); 72111336Samurai } 72211336Samurai } 72324939Sbrian 72424939Sbrian dot = index(argv[0],'.'); 72524939Sbrian if (dot) { 72624939Sbrian if (strcasecmp(++dot, "random") == 0) { 72724939Sbrian VarRedialNextTimeout = -1; 72824939Sbrian printf("Using random next redial timeout.\n"); 72924939Sbrian if (!randinit) { 73024939Sbrian randinit = 1; 73124939Sbrian if (srandomdev() < 0) 73224939Sbrian srandom((unsigned long)(time(NULL) ^ getpid())); 73324939Sbrian } 73424939Sbrian } 73524939Sbrian else { 73624939Sbrian timeout = atoi(dot); 73724939Sbrian if (timeout >= 0) { 73824939Sbrian VarRedialNextTimeout = timeout; 73924939Sbrian } 74024939Sbrian else { 74124939Sbrian printf("invalid next redial timeout\n"); 74224939Sbrian printf("Usage: %s %s\n", list->name, list->syntax); 74324939Sbrian } 74424939Sbrian } 74524939Sbrian } 74624939Sbrian else 74724939Sbrian VarRedialNextTimeout = NEXT_REDIAL_PERIOD; /* Default next timeout */ 74824939Sbrian 74911336Samurai if (argc == 2) { 75011336Samurai tries = atoi(argv[1]); 75111336Samurai 75211336Samurai if (tries >= 0) { 75311336Samurai VarDialTries = tries; 75411336Samurai } 75511336Samurai else { 75611336Samurai printf("invalid retry value\n"); 75711336Samurai printf("Usage: %s %s\n", list->name, list->syntax); 75811336Samurai } 75911336Samurai } 76011336Samurai } 76111336Samurai else { 76211336Samurai printf("Usage: %s %s\n", list->name, list->syntax); 76311336Samurai } 76411336Samurai return(1); 76511336Samurai} 76611336Samurai 76725067Sbrianstatic int 76825067SbrianSetModemParity(list, argc, argv) 7696059Samuraistruct cmdtab *list; 7706059Samuraiint argc; 7716059Samuraichar **argv; 7726059Samurai{ 7736059Samurai int parity; 7746059Samurai 7756059Samurai if (argc > 0) { 7766059Samurai parity = ChangeParity(*argv); 7776059Samurai if (parity < 0) 7786059Samurai printf("Invalid parity.\n"); 7796059Samurai else 7806059Samurai VarParity = parity; 7816059Samurai } 7826059Samurai return(1); 7836059Samurai} 7846059Samurai 7856059Samuraistatic int 7866059SamuraiSetDebugLevel(list, argc, argv) 7876059Samuraistruct cmdtab *list; 7886059Samuraiint argc; 7896059Samuraichar **argv; 7906059Samurai{ 7916059Samurai int level, w; 7926059Samurai 7936059Samurai for (level = 0; argc-- > 0; argv++) { 7946059Samurai if (isdigit(**argv)) { 7956059Samurai w = atoi(*argv); 7966059Samurai if (w < 0 || w >= MAXLOGLEVEL) { 7976059Samurai printf("invalid log level.\n"); 7986059Samurai break; 7996059Samurai } else 8006059Samurai level |= (1 << w); 8016059Samurai } else { 8026059Samurai for (w = 0; w < MAXLOGLEVEL; w++) { 8036059Samurai if (strcasecmp(*argv, LogLevelName[w]) == 0) { 8046059Samurai level |= (1 << w); 8056059Samurai continue; 8066059Samurai } 8076059Samurai } 8086059Samurai } 8096059Samurai } 8106059Samurai loglevel = level; 8116059Samurai return(1); 8126059Samurai} 8136059Samurai 8146059Samuraistatic int 8156059SamuraiSetEscape(list, argc, argv) 8166059Samuraistruct cmdtab *list; 8176059Samuraiint argc; 8186059Samuraichar **argv; 8196059Samurai{ 8206059Samurai int code; 8216059Samurai 8226059Samurai for (code = 0; code < 33; code++) 8236059Samurai EscMap[code] = 0; 8246059Samurai while (argc-- > 0) { 8256059Samurai sscanf(*argv++, "%x", &code); 8266059Samurai code &= 0xff; 8276059Samurai EscMap[code >> 3] |= (1 << (code&7)); 8286059Samurai EscMap[32] = 1; 8296059Samurai } 8306059Samurai return(1); 8316059Samurai} 8326059Samurai 8336059Samuraistatic int 8346059SamuraiSetInitialMRU(list, argc, argv) 8356059Samuraistruct cmdtab *list; 8366059Samuraiint argc; 8376059Samuraichar **argv; 8386059Samurai{ 8396059Samurai int mru; 8406059Samurai 8416059Samurai if (argc > 0) { 8426059Samurai mru = atoi(*argv); 8436059Samurai if (mru < 100) 8446059Samurai printf("given value is too small.\n"); 8456059Samurai else if (mru > MAX_MRU) 8466059Samurai printf("given value is too big.\n"); 8476059Samurai else 8486059Samurai VarMRU = mru; 8496059Samurai } 8506059Samurai return(1); 8516059Samurai} 8526059Samurai 8536059Samuraistatic int 8546059SamuraiSetIdleTimeout(list, argc, argv) 8556059Samuraistruct cmdtab *list; 8566059Samuraiint argc; 8576059Samuraichar **argv; 8586059Samurai{ 8596059Samurai if (argc-- > 0) { 8606059Samurai VarIdleTimeout = atoi(*argv++); 8616735Samurai if (argc-- > 0) { 8626735Samurai VarLqrTimeout = atoi(*argv++); 8636735Samurai if (VarLqrTimeout < 1) 8646735Samurai VarLqrTimeout = 30; 8656735Samurai if (argc > 0) { 8666735Samurai VarRetryTimeout = atoi(*argv); 8676735Samurai if (VarRetryTimeout < 1 || VarRetryTimeout > 10) 8686735Samurai VarRetryTimeout = 3; 8696735Samurai } 8706735Samurai } 8716059Samurai } 8726059Samurai return(1); 8736059Samurai} 8746059Samurai 8756059Samuraistruct in_addr 8766059SamuraiGetIpAddr(cp) 8776059Samuraichar *cp; 8786059Samurai{ 8796059Samurai struct hostent *hp; 8806059Samurai struct in_addr ipaddr; 8816059Samurai 8826059Samurai hp = gethostbyname(cp); 8836059Samurai if (hp && hp->h_addrtype == AF_INET) 8846059Samurai bcopy(hp->h_addr, &ipaddr, hp->h_length); 8856059Samurai else if (inet_aton(cp, &ipaddr) == 0) 8866059Samurai ipaddr.s_addr = 0; 8876059Samurai return(ipaddr); 8886059Samurai} 8896059Samurai 8906059Samuraistatic int 8916059SamuraiSetInterfaceAddr(list, argc, argv) 8926059Samuraistruct cmdtab *list; 8936059Samuraiint argc; 8946059Samuraichar **argv; 8956059Samurai{ 8966059Samurai 8976059Samurai DefMyAddress.ipaddr.s_addr = DefHisAddress.ipaddr.s_addr = 0L; 89825630Sbrian if (argc > 4) { 89925630Sbrian printf("set ifaddr: too many arguments (%d > 4)\n", argc); 90025630Sbrian return(0); 90125630Sbrian } 9026059Samurai if (argc > 0) { 90325630Sbrian if (ParseAddr(argc, argv++, 90425630Sbrian &DefMyAddress.ipaddr, 90525630Sbrian &DefMyAddress.mask, 90625630Sbrian &DefMyAddress.width) == 0) 90725630Sbrian return(0); 9086059Samurai if (--argc > 0) { 90925630Sbrian if (ParseAddr(argc, argv++, 91025630Sbrian &DefHisAddress.ipaddr, 91125630Sbrian &DefHisAddress.mask, 91225630Sbrian &DefHisAddress.width) == 0) 91325630Sbrian return(0); 9146059Samurai if (--argc > 0) { 9156059Samurai ifnetmask = GetIpAddr(*argv); 9169440Samurai if (--argc > 0) { 91725630Sbrian if (ParseAddr(argc, argv++, 91825630Sbrian &DefTriggerAddress.ipaddr, 91925630Sbrian &DefTriggerAddress.mask, 92025630Sbrian &DefTriggerAddress.width) == 0) 92125630Sbrian return(0); 9229440Samurai } 9236059Samurai } 9246059Samurai } 9256059Samurai } 9266059Samurai /* 9276059Samurai * For backwards compatibility, 0.0.0.0 means any address. 9286059Samurai */ 9296059Samurai if (DefMyAddress.ipaddr.s_addr == 0) { 9306059Samurai DefMyAddress.mask.s_addr = 0; 9316059Samurai DefMyAddress.width = 0; 9326059Samurai } 9336059Samurai if (DefHisAddress.ipaddr.s_addr == 0) { 9346059Samurai DefHisAddress.mask.s_addr = 0; 9356059Samurai DefHisAddress.width = 0; 9366059Samurai } 9376059Samurai 9386735Samurai if ((mode & MODE_AUTO) || 9396059Samurai ((mode & MODE_DEDICATED) && dstsystem)) { 94025630Sbrian if (OsSetIpaddress(DefMyAddress.ipaddr, DefHisAddress.ipaddr, ifnetmask) < 0) 94125630Sbrian return(0); 9426059Samurai } 9436059Samurai return(1); 9446059Samurai} 9456059Samurai 94618752Sjkh#ifdef MSEXT 9476059Samurai 94818752Sjkhvoid 94918752SjkhSetMSEXT(pri_addr, sec_addr, argc, argv) 95018752Sjkhstruct in_addr *pri_addr; 95118752Sjkhstruct in_addr *sec_addr; 95218752Sjkhint argc; 95318752Sjkhchar **argv; 95418752Sjkh{ 95518752Sjkh int dummyint; 95618752Sjkh struct in_addr dummyaddr; 95718752Sjkh 95818752Sjkh pri_addr->s_addr = sec_addr->s_addr = 0L; 95918752Sjkh 96018752Sjkh if( argc > 0 ) { 96118752Sjkh ParseAddr(argc, argv++, pri_addr, &dummyaddr, &dummyint); 96218752Sjkh if( --argc > 0 ) 96318752Sjkh ParseAddr(argc, argv++, sec_addr, &dummyaddr, &dummyint); 96418752Sjkh else 96518752Sjkh sec_addr->s_addr = pri_addr->s_addr; 96618752Sjkh } 96718752Sjkh 96818752Sjkh /* 96918752Sjkh * if the primary/secondary ns entries are 0.0.0.0 we should 97018752Sjkh * set them to either the localhost's ip, or the values in 97118752Sjkh * /etc/resolv.conf ?? 97218752Sjkh * 97318752Sjkh * up to you if you want to implement this... 97418752Sjkh */ 97518752Sjkh 97618752Sjkh} 97718752Sjkh 97818752Sjkhstatic int 97918752SjkhSetNS(list, argc, argv) 98018752Sjkhstruct cmdtab *list; 98118752Sjkhint argc; 98218752Sjkhchar **argv; 98318752Sjkh{ 98418752Sjkh SetMSEXT(&ns_entries[0], &ns_entries[1], argc, argv); 98518752Sjkh return(1); 98618752Sjkh} 98718752Sjkh 98818752Sjkhstatic int 98918752SjkhSetNBNS(list, argc, argv) 99018752Sjkhstruct cmdtab *list; 99118752Sjkhint argc; 99218752Sjkhchar **argv; 99318752Sjkh{ 99418752Sjkh SetMSEXT(&nbns_entries[0], &nbns_entries[1], argc, argv); 99518752Sjkh return(1); 99618752Sjkh} 99718752Sjkh 99818752Sjkh#endif /* MS_EXT */ 99918752Sjkh 10006059Samurai#define VAR_AUTHKEY 0 10016059Samurai#define VAR_DIAL 1 10026059Samurai#define VAR_LOGIN 2 10036059Samurai#define VAR_AUTHNAME 3 10046059Samurai#define VAR_DEVICE 4 10056059Samurai#define VAR_ACCMAP 5 10066059Samurai#define VAR_PHONE 6 10076059Samurai 10086059Samuraistatic int 10096059SamuraiSetVariable(list, argc, argv, param) 10106059Samuraistruct cmdtab *list; 10116059Samuraiint argc; 10126059Samuraichar **argv; 10136059Samuraiint param; 10146059Samurai{ 10156059Samurai u_long map; 10166059Samurai 10176059Samurai if (argc > 0) { 10186059Samurai switch (param) { 10196059Samurai case VAR_AUTHKEY: 10206059Samurai strncpy(VarAuthKey, *argv, sizeof(VarAuthKey)-1); 102121488Simp VarAuthKey[sizeof(VarAuthKey)-1] = '\0'; 10226059Samurai break; 10236059Samurai case VAR_AUTHNAME: 10246059Samurai strncpy(VarAuthName, *argv, sizeof(VarAuthName)-1); 102521488Simp VarAuthName[sizeof(VarAuthName)-1] = '\0'; 10266059Samurai break; 10276059Samurai case VAR_DIAL: 10286059Samurai strncpy(VarDialScript, *argv, sizeof(VarDialScript)-1); 102921488Simp VarDialScript[sizeof(VarDialScript)-1] = '\0'; 10306059Samurai break; 10316059Samurai case VAR_LOGIN: 103222225Sjoerg strncpy(VarLoginScript, *argv, sizeof(VarLoginScript)-1); 103321488Simp VarLoginScript[sizeof(VarLoginScript)-1] = '\0'; 10346059Samurai break; 10356059Samurai case VAR_DEVICE: 10366059Samurai strncpy(VarDevice, *argv, sizeof(VarDevice)-1); 103721488Simp VarDevice[sizeof(VarDevice)-1] = '\0'; 103825634Sbrian VarBaseDevice = rindex(VarDevice, '/'); 103925634Sbrian VarBaseDevice = VarBaseDevice ? VarBaseDevice + 1 : ""; 10406059Samurai break; 10416059Samurai case VAR_ACCMAP: 104213389Sphk sscanf(*argv, "%lx", &map); 10436059Samurai VarAccmap = map; 10446059Samurai break; 10456059Samurai case VAR_PHONE: 104614418Sache strncpy(VarPhoneList, *argv, sizeof(VarPhoneList)-1); 104721488Simp VarPhoneList[sizeof(VarPhoneList)-1] = '\0'; 104814423Sache strcpy(VarPhoneCopy, VarPhoneList); 104914423Sache VarNextPhone = VarPhoneCopy; 10506059Samurai break; 10516059Samurai } 10526059Samurai } 10536059Samurai return(1); 10546059Samurai} 10556059Samurai 105620812Sjkhstatic int SetCtsRts(list, argc, argv) 105720812Sjkhstruct cmdtab *list; 105820812Sjkhint argc; 105920812Sjkhchar **argv; 106020812Sjkh{ 106120812Sjkh if (argc > 0) { 106220812Sjkh if (strcmp(*argv, "on") == 0) 106320812Sjkh VarCtsRts = TRUE; 106420812Sjkh else if (strcmp(*argv, "off") == 0) 106520812Sjkh VarCtsRts = FALSE; 106620812Sjkh else 106720812Sjkh printf("usage: set ctsrts [on|off].\n"); 106820812Sjkh } 106920812Sjkh return(1); 107020812Sjkh} 107120812Sjkh 107220812Sjkh 10736059Samuraistatic int SetOpenMode(list, argc, argv) 10746059Samuraistruct cmdtab *list; 10756059Samuraiint argc; 10766059Samuraichar **argv; 10776059Samurai{ 10786059Samurai if (argc > 0) { 10796059Samurai if (strcmp(*argv, "active") == 0) 10806059Samurai VarOpenMode = OPEN_ACTIVE; 10816059Samurai else if (strcmp(*argv, "passive") == 0) 10826059Samurai VarOpenMode = OPEN_PASSIVE; 10836059Samurai else 10846059Samurai printf("Invalid mode.\n"); 10856059Samurai } 10866059Samurai return(1); 10876059Samurai} 10886059Samuraistatic char StrChatStr[] = "chat-script"; 10896059Samuraistatic char StrValue[] = "value"; 10906059Samurai 10916735Samuraiextern int SetIfilter(), SetOfilter(), SetDfilter(), SetAfilter(); 10926059Samurai 109313760Sphkstruct cmdtab const SetCommands[] = { 10946735Samurai { "accmap", NULL, SetVariable, LOCAL_AUTH, 10956735Samurai "Set accmap value", "hex-value", (void *)VAR_ACCMAP}, 10966735Samurai { "afilter", NULL, SetAfilter, LOCAL_AUTH, 10976735Samurai "Set keep Alive filter", "..."}, 10986735Samurai { "authkey", "key", SetVariable, LOCAL_AUTH, 10996735Samurai "Set authentication key", "key", (void *)VAR_AUTHKEY}, 11006735Samurai { "authname", NULL, SetVariable, LOCAL_AUTH, 11016735Samurai "Set authentication name", "name", (void *)VAR_AUTHNAME}, 110220812Sjkh { "ctsrts", NULL, SetCtsRts, LOCAL_AUTH, 110320812Sjkh "Use CTS/RTS modem signalling", "[on|off]"}, 11046735Samurai { "debug", NULL, SetDebugLevel, LOCAL_AUTH, 11056735Samurai "Set debug level", StrValue}, 11066735Samurai { "device", "line", SetVariable, LOCAL_AUTH, 11076735Samurai "Set modem device name", "device-name", (void *)VAR_DEVICE}, 11086735Samurai { "dfilter", NULL, SetDfilter, LOCAL_AUTH, 11096735Samurai "Set demand filter", "..."}, 11106735Samurai { "dial", NULL, SetVariable, LOCAL_AUTH, 11116735Samurai "Set dialing script", StrChatStr, (void *)VAR_DIAL}, 11126735Samurai { "escape", NULL, SetEscape, LOCAL_AUTH, 11136735Samurai "Set escape characters", "hex-digit ..."}, 11146735Samurai { "ifaddr", NULL, SetInterfaceAddr, LOCAL_AUTH, 111514418Sache "Set destination address", "[src-addr [dst-addr [netmask [trg-addr]]]]"}, 11166735Samurai { "ifilter", NULL, SetIfilter, LOCAL_AUTH, 11176735Samurai "Set input filter", "..."}, 11186735Samurai { "login", NULL, SetVariable, LOCAL_AUTH, 11196735Samurai "Set login script", StrChatStr, (void *)VAR_LOGIN }, 11206735Samurai { "mru", "mtu", SetInitialMRU, LOCAL_AUTH, 11216735Samurai "Set Initial MRU value", StrValue }, 11226735Samurai { "ofilter", NULL, SetOfilter, LOCAL_AUTH, 11236735Samurai "Set output filter", "..." }, 11246735Samurai { "openmode", NULL, SetOpenMode, LOCAL_AUTH, 11256735Samurai "Set open mode", "[active|passive]"}, 11266735Samurai { "parity", NULL, SetModemParity, LOCAL_AUTH, 11276735Samurai "Set modem parity", "[odd|even|none]"}, 11286735Samurai { "phone", NULL, SetVariable, LOCAL_AUTH, 112914418Sache "Set telephone number(s)", "phone1[:phone2[...]]", (void *)VAR_PHONE }, 113025067Sbrian { "reconnect",NULL, SetReconnect, LOCAL_AUTH, 113125067Sbrian "Set Reconnect timeout", "value ntries"}, 113225067Sbrian { "redial", NULL, SetRedialTimeout, LOCAL_AUTH, 113325067Sbrian "Set Redial timeout", "value|random[.value|random] [dial_attempts]"}, 11346735Samurai { "speed", NULL, SetModemSpeed, LOCAL_AUTH, 11356735Samurai "Set modem speed", "speed"}, 11366735Samurai { "timeout", NULL, SetIdleTimeout, LOCAL_AUTH, 11376735Samurai "Set Idle timeout", StrValue}, 113818752Sjkh#ifdef MSEXT 113918752Sjkh { "ns", NULL, SetNS, LOCAL_AUTH, 114018752Sjkh "Set NameServer", "pri-addr [sec-addr]"}, 114118752Sjkh { "nbns", NULL, SetNBNS, LOCAL_AUTH, 114218752Sjkh "Set NetBIOS NameServer", "pri-addr [sec-addr]"}, 114318752Sjkh#endif /* MSEXT */ 11446735Samurai { "help", "?", HelpCommand, LOCAL_AUTH | LOCAL_NO_AUTH, 11456735Samurai "Display this message", StrNull, (void *)SetCommands}, 11466059Samurai { NULL, NULL, NULL }, 11476059Samurai}; 11486059Samurai 11496059Samuraistatic int 11506059SamuraiSetCommand(list, argc, argv) 11516059Samuraistruct cmdtab *list; 11526059Samuraiint argc; 11536059Samuraichar **argv; 11546059Samurai{ 11556059Samurai int val = 1; 11566059Samurai 11576059Samurai if (argc > 0) 11586059Samurai val = FindExec(SetCommands, argc, argv); 11596059Samurai else 116014418Sache printf("Use `set ?' to get a list or `set ? <var>' for syntax help.\n"); 11616059Samurai return(val); 11626059Samurai} 11636059Samurai 11646059Samurai 11656059Samuraistatic int 11666059SamuraiAddCommand(list, argc, argv) 11676059Samuraistruct cmdtab *list; 11686059Samuraiint argc; 11696059Samuraichar **argv; 11706059Samurai{ 11716059Samurai struct in_addr dest, gateway, netmask; 11726059Samurai 11736059Samurai if (argc == 3) { 11746059Samurai dest = GetIpAddr(argv[0]); 11756059Samurai netmask = GetIpAddr(argv[1]); 117625566Sbrian if (strcasecmp(argv[2], "HISADDR") == 0) 11776059Samurai gateway = IpcpInfo.his_ipaddr; 11786059Samurai else 11796059Samurai gateway = GetIpAddr(argv[2]); 11806059Samurai OsSetRoute(RTM_ADD, dest, gateway, netmask); 11816059Samurai } else { 11826059Samurai printf("Usage: %s %s\n", list->name, list->syntax); 11836059Samurai } 11846059Samurai return(1); 11856059Samurai} 11866059Samurai 11876059Samuraistatic int 11886059SamuraiDeleteCommand(list, argc, argv) 11896059Samuraistruct cmdtab *list; 11906059Samuraiint argc; 11916059Samuraichar **argv; 11926059Samurai{ 11936059Samurai struct in_addr dest, gateway, netmask; 11946059Samurai 11956059Samurai if (argc >= 2) { 11966059Samurai dest = GetIpAddr(argv[0]); 119725566Sbrian if (strcasecmp(argv[1], "HISADDR") == 0) 11986059Samurai gateway = IpcpInfo.his_ipaddr; 11996059Samurai else 12006059Samurai gateway = GetIpAddr(argv[1]); 12016059Samurai netmask.s_addr = 0; 12026059Samurai if (argc == 3) { 12036059Samurai if (inet_aton(argv[1], &netmask) == 0) { 12046059Samurai printf("bad netmask value.\n"); 12056059Samurai return(1); 12066059Samurai } 12076059Samurai } 12086059Samurai OsSetRoute(RTM_DELETE, dest, gateway, netmask); 120925566Sbrian } else if (argc == 1 && strcasecmp(argv[0], "ALL") == 0) { 12106059Samurai DeleteIfRoutes(0); 12116059Samurai } else { 12126059Samurai printf("Usage: %s %s\n", list->name, list->syntax); 12136059Samurai } 12146059Samurai return(1); 12156059Samurai} 12166059Samurai 121726031Sbrian 121826031Sbrianstatic int AliasEnable(); 121926031Sbrianstatic int AliasOption(); 122026031Sbrian 122126031Sbrian 122226031Sbrianstatic struct cmdtab const AliasCommands[] = 122326031Sbrian{ 122426031Sbrian { "enable", NULL, AliasEnable, LOCAL_AUTH, 122526031Sbrian "enable IP aliasing", "[yes|no]"}, 122626031Sbrian { "port", NULL, AliasRedirectPort, LOCAL_AUTH, 122726031Sbrian "port redirection", "[proto addr_local:port_local port_alias]"}, 122826031Sbrian { "addr", NULL, AliasRedirectAddr, LOCAL_AUTH, 122926031Sbrian "static address translation", "[addr_local addr_alias]"}, 123026031Sbrian { "deny_incoming", NULL, AliasOption, LOCAL_AUTH, 123126031Sbrian "stop incoming connections", "[yes|no]", 123226031Sbrian (void*)PKT_ALIAS_DENY_INCOMING}, 123326031Sbrian { "log", NULL, AliasOption, LOCAL_AUTH, 123426031Sbrian "log aliasing link creation", "[yes|no]", 123526031Sbrian (void*)PKT_ALIAS_LOG}, 123626031Sbrian { "same_ports", NULL, AliasOption, LOCAL_AUTH, 123726031Sbrian "try to leave port numbers unchanged", "[yes|no]", 123826031Sbrian (void*)PKT_ALIAS_SAME_PORTS}, 123926031Sbrian { "use_sockets", NULL, AliasOption, LOCAL_AUTH, 124026031Sbrian "allocate host sockets", "[yes|no]", 124126031Sbrian (void*)PKT_ALIAS_USE_SOCKETS }, 124226031Sbrian { "unregistered_only", NULL, AliasOption, LOCAL_AUTH, 124326031Sbrian "alias unregistered (private) IP address space only", "[yes|no]", 124426031Sbrian (void*)PKT_ALIAS_UNREGISTERED_ONLY}, 124526031Sbrian { "help", "?", HelpCommand, LOCAL_AUTH | LOCAL_NO_AUTH, 124626031Sbrian "Display this message", StrNull, 124726031Sbrian (void *)AliasCommands}, 124826031Sbrian { NULL, NULL, NULL }, 124926031Sbrian}; 125026031Sbrian 125126031Sbrian 125226031Sbrianstatic int 125326031SbrianAliasCommand(list, argc, argv) 125426031Sbrianstruct cmdtab *list; 125526031Sbrianint argc; 125626031Sbrianchar **argv; 125726031Sbrian{ 125826031Sbrian int val = 1; 125926031Sbrian 126026031Sbrian if (argc > 0) 126126031Sbrian val = FindExec(AliasCommands, argc, argv); 126226031Sbrian else 126326031Sbrian printf("Use `alias help' to get a list or `alias help <option>' for syntax h 126426031Sbrianelp.\n"); 126526031Sbrian return(val); 126626031Sbrian} 126726031Sbrian 126826031Sbrian 126926031Sbrianstatic int 127026031SbrianAliasEnable(list, argc, argv) 127126031Sbrianstruct cmdtab *list; 127226031Sbrianint argc; 127326031Sbrianchar **argv; 127426031Sbrian{ 127526031Sbrian if (argc == 1 && strcmp(argv[0], "yes") == 0) { 127626031Sbrian mode |= MODE_ALIAS; 127726031Sbrian } else if (argc == 1 && strcmp(argv[0], "no") == 0) { 127826031Sbrian mode &= ~MODE_ALIAS; 127926031Sbrian } else { 128026031Sbrian printf("Usage: alias %s %s\n", list->name, list->syntax); 128126031Sbrian } 128226031Sbrian return(1); 128326031Sbrian} 128426031Sbrian 128526031Sbrian 128626031Sbrianstatic int 128726031SbrianAliasOption(list, argc, argv, param) 128826031Sbrianstruct cmdtab *list; 128926031Sbrianint argc; 129026031Sbrianchar **argv; 129126031Sbrianvoid* param; 129226031Sbrian{ 129326031Sbrian if (argc == 1 && strcmp(argv[0], "yes") == 0) { 129426031Sbrian SetPacketAliasMode((unsigned)param, (unsigned)param); 129526031Sbrian } else if (argc == 1 && strcmp(argv[0], "no") == 0) { 129626031Sbrian SetPacketAliasMode(0, (unsigned)param); 129726031Sbrian } else { 129826031Sbrian printf("Usage: alias %s %s\n", list->name, list->syntax); 129926031Sbrian } 130026031Sbrian return(1); 130126031Sbrian} 1302