command.c revision 26142
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 * 2026142Sbrian * $Id: command.c,v 1.49 1997/05/24 17:32:33 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" 4426142Sbrian#include "loadalias.h" 456059Samurai#include "vars.h" 4625630Sbrian#include "systems.h" 4725630Sbrian#include "chat.h" 486059Samurai#include "os.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 836059Samurai if (argc > 0) { 846059Samurai for (cmd = plist; cmd->name; cmd++) { 8525566Sbrian if (strcasecmp(cmd->name, *argv) == 0 && (cmd->lauth & VarLocalAuth)) { 8614418Sache if (plist == SetCommands) 8714418Sache printf("set "); 886059Samurai printf("%s %s\n", cmd->name, cmd->syntax); 896059Samurai return(1); 906059Samurai } 916059Samurai } 926059Samurai return(1); 936059Samurai } 946059Samurai n = 0; 956059Samurai for (cmd = plist; cmd->func; cmd++) { 966764Samurai if (cmd->name && (cmd->lauth & VarLocalAuth)) { 9726142Sbrian printf(" %-8s: %-20s\n", cmd->name, cmd->helpmes); 986059Samurai n++; 996059Samurai } 1006059Samurai } 1016059Samurai if (n & 1) 1026059Samurai printf("\n"); 1036059Samurai return(1); 1046059Samurai} 1056059Samurai 1066059Samuraiint 1076059SamuraiIsInteractive() 1086059Samurai{ 1096059Samurai char *mes = NULL; 1106059Samurai 11120120Snate if (mode & MODE_DDIAL) 11220120Snate mes = "Working in dedicated dial mode."; 11325908Sbrian else if (mode & MODE_BACKGROUND) 11425908Sbrian mes = "Working in background mode."; 11520120Snate else if (mode & MODE_AUTO) 11610528Samurai mes = "Working in auto mode."; 1176059Samurai else if (mode & MODE_DIRECT) 11810528Samurai mes = "Working in direct mode."; 1196059Samurai else if (mode & MODE_DEDICATED) 12010528Samurai mes = "Working in dedicated mode."; 1216059Samurai if (mes) { 1226059Samurai printf("%s\n", mes); 1236059Samurai return(0); 1246059Samurai } 1256059Samurai return(1); 1266059Samurai} 1276059Samurai 1286059Samuraistatic int 1296059SamuraiDialCommand(cmdlist, argc, argv) 1306059Samuraistruct cmdtab *cmdlist; 1316059Samuraiint argc; 1326059Samuraichar **argv; 1336059Samurai{ 13411336Samurai int tries; 13511336Samurai 1366059Samurai if (LcpFsm.state > ST_CLOSED) { 1376059Samurai printf("LCP state is [%s]\n", StateNames[LcpFsm.state]); 1386059Samurai return(1); 1396059Samurai } 1406059Samurai if (!IsInteractive()) 1416059Samurai return(1); 1426735Samurai if (argc > 0) { 1436735Samurai if (SelectSystem(*argv, CONFFILE) < 0) { 1446735Samurai printf("%s: not found.\n", *argv); 1456735Samurai return(1); 1466735Samurai } 1476735Samurai } 14811336Samurai tries = 0; 14911336Samurai do { 15025801Sbrian printf("Dial attempt %u of %d\n", ++tries, VarDialTries); 15111336Samurai modem = OpenModem(mode); 15211336Samurai if (modem < 0) { 15311336Samurai printf("failed to open modem.\n"); 15411336Samurai break; 15511336Samurai } 15611336Samurai if (DialModem()) { 15711336Samurai sleep(1); 15811336Samurai ModemTimeout(); 15911336Samurai PacketMode(); 16011336Samurai break; 16111336Samurai } 16211336Samurai } while (VarDialTries == 0 || tries < VarDialTries); 1636059Samurai return(1); 1646059Samurai} 1656059Samurai 16610528Samuraistatic int 16710528SamuraiShellCommand(cmdlist, argc, argv) 16810528Samuraistruct cmdtab *cmdlist; 16910528Samuraiint argc; 17010528Samuraichar **argv; 17110528Samurai{ 17210528Samurai const char *shell; 17310528Samurai pid_t shpid; 17420813Sjkh 17510528Samurai if((shell = getenv("SHELL")) == 0) { 17610528Samurai shell = _PATH_BSHELL; 17710528Samurai } 17818856Ssos#ifdef SHELL_ONLY_INTERACTIVELY 17910528Samurai#ifndef HAVE_SHELL_CMD_WITH_ANY_MODE 18010528Samurai if( mode != MODE_INTER) { 18110528Samurai fprintf(stdout, 18218911Ssos "Can only start a shell in interactive mode\n"); 18310528Samurai return(1); 18410528Samurai } 18510528Samurai#else 18610528Samurai if(argc == 0 && !(mode & MODE_INTER)) { 18710528Samurai fprintf(stderr, 18818911Ssos "Can only start an interactive shell in interactive mode\n"); 18910528Samurai return(1); 19010528Samurai } 19110528Samurai#endif /* HAVE_SHELL_CMD_WITH_ANY_MODE */ 19218911Ssos#else 19318911Ssos if ((mode & (MODE_AUTO|MODE_INTER)) == (MODE_AUTO|MODE_INTER)) { 19418911Ssos fprintf(stdout, 19518911Ssos "Shell is not allowed interactively in auto mode\n"); 19618911Ssos return(1); 19718911Ssos } 19818856Ssos#endif /* SHELL_ONLY_INTERACTIVELY */ 19910528Samurai if((shpid = fork()) == 0) { 20018531Sbde int dtablesize, i ; 20118531Sbde 20218531Sbde for (dtablesize = getdtablesize(), i = 3; i < dtablesize; i++) 20310528Samurai (void)close(i); 20410528Samurai 20510528Samurai /* 20610528Samurai * We are running setuid, we should change to 20710528Samurai * real user for avoiding security problems. 20810528Samurai */ 20916263Sache if (setgid(getgid()) < 0) { 21016263Sache perror("setgid"); 21116263Sache exit(1); 21216263Sache } 21316263Sache if (setuid(getuid()) < 0) { 21416263Sache perror("setuid"); 21516263Sache exit(1); 21616263Sache } 21710528Samurai TtyOldMode(); 21818790Ssos if(argc > 0) { 21918790Ssos /* substitute pseudo args */ 22018790Ssos for (i=1; i<argc; i++) { 22125566Sbrian if (strcasecmp(argv[i], "HISADDR") == 0) { 22218790Ssos argv[i] = strdup(inet_ntoa(IpcpInfo.his_ipaddr)); 22318790Ssos } 22425566Sbrian if (strcasecmp(argv[i], "INTERFACE") == 0) { 22522973Sphk argv[i] = strdup(IfDevName); 22622973Sphk } 22725566Sbrian if (strcasecmp(argv[i], "MYADDR") == 0) { 22818790Ssos argv[i] = strdup(inet_ntoa(IpcpInfo.want_ipaddr)); 22918790Ssos } 23018790Ssos } 23125630Sbrian (void)execvp(argv[0], argv); 23218790Ssos } 23310528Samurai else 23425630Sbrian (void)execl(shell, shell, NULL); 23520813Sjkh 23610528Samurai fprintf(stdout, "exec() of %s failed\n", argc > 0? argv[0]: shell); 23710528Samurai exit(255); 23810528Samurai } 23910528Samurai if( shpid == (pid_t)-1 ) { 24010528Samurai fprintf(stdout, "Fork failed\n"); 24110528Samurai } else { 24210528Samurai int status; 24310528Samurai (void)waitpid(shpid, &status, 0); 24410528Samurai } 24520813Sjkh 24610528Samurai TtyCommandMode(1); 24720813Sjkh 24810528Samurai return(0); 24910528Samurai} 25010528Samurai 2516059Samuraistatic char StrOption[] = "option .."; 2526059Samuraistatic char StrRemote[] = "[remote]"; 2536059Samuraichar StrNull[] = ""; 2546059Samurai 25513760Sphkstruct cmdtab const Commands[] = { 2566735Samurai { "accept", NULL, AcceptCommand, LOCAL_AUTH, 2576735Samurai "accept option request", StrOption}, 2586735Samurai { "add", NULL, AddCommand, LOCAL_AUTH, 2596735Samurai "add route", "dest mask gateway"}, 2606735Samurai { "close", NULL, CloseCommand, LOCAL_AUTH, 2616735Samurai "Close connection", StrNull}, 2626735Samurai { "delete", NULL, DeleteCommand, LOCAL_AUTH, 26314418Sache "delete route", "ALL | dest gateway [mask]"}, 2646735Samurai { "deny", NULL, DenyCommand, LOCAL_AUTH, 2656735Samurai "Deny option request", StrOption}, 2666735Samurai { "dial", "call", DialCommand, LOCAL_AUTH, 2676735Samurai "Dial and login", StrRemote}, 2686735Samurai { "disable", NULL, DisableCommand, LOCAL_AUTH, 2696735Samurai "Disable option", StrOption}, 2706735Samurai { "display", NULL, DisplayCommand, LOCAL_AUTH, 2716735Samurai "Display option configs", StrNull}, 2726735Samurai { "enable", NULL, EnableCommand, LOCAL_AUTH, 2736735Samurai "Enable option", StrOption}, 2746764Samurai { "passwd", NULL, LocalAuthCommand,LOCAL_NO_AUTH, 2759240Sphk "Password for manipulation", StrOption}, 2766735Samurai { "load", NULL, LoadCommand, LOCAL_AUTH, 2776735Samurai "Load settings", StrRemote}, 2786735Samurai { "save", NULL, SaveCommand, LOCAL_AUTH, 2796735Samurai "Save settings", StrNull}, 2806735Samurai { "set", "setup", SetCommand, LOCAL_AUTH, 2816735Samurai "Set parameters", "var value"}, 28210528Samurai { "shell", "!", ShellCommand, LOCAL_AUTH, 28310528Samurai "Run a subshell", "[sh command]"}, 2846735Samurai { "show", NULL, ShowCommand, LOCAL_AUTH, 2856735Samurai "Show status and statictics", "var"}, 2866735Samurai { "term", NULL, TerminalCommand,LOCAL_AUTH, 2876735Samurai "Enter to terminal mode", StrNull}, 28826031Sbrian { "alias", NULL, AliasCommand, LOCAL_AUTH, 28926031Sbrian "alias control", "option [yes|no]"}, 2906764Samurai { "quit", "bye", QuitCommand, LOCAL_AUTH | LOCAL_NO_AUTH, 29114418Sache "Quit PPP program", "[all]"}, 2926735Samurai { "help", "?", HelpCommand, LOCAL_AUTH | LOCAL_NO_AUTH, 2936059Samurai "Display this message", "[command]", (void *)Commands }, 2946735Samurai { NULL, "down", DownCommand, LOCAL_AUTH, 2956735Samurai "Generate down event", StrNull}, 2966059Samurai { NULL, NULL, NULL }, 2976059Samurai}; 2986059Samurai 2996059Samuraiextern int ReportCcpStatus(); 3006059Samuraiextern int ReportLcpStatus(); 3016059Samuraiextern int ReportIpcpStatus(); 3026059Samuraiextern int ReportProtStatus(); 3036059Samuraiextern int ReportCompress(); 3046059Samuraiextern int ShowModemStatus(); 3056059Samuraiextern int ReportHdlcStatus(); 3066059Samuraiextern int ShowMemMap(); 3076059Samurai 3086059Samuraistatic char *LogLevelName[] = { 30915738Sphk LM_PHASE, LM_CHAT, LM_LQM, LM_LCP, 31015738Sphk LM_TCPIP, LM_HDLC, LM_ASYNC, LM_LINK, 31115738Sphk LM_CONNECT, LM_CARRIER, 3126059Samurai}; 3136059Samurai 3146059Samuraistatic int ShowDebugLevel() 3156059Samurai{ 3166059Samurai int i; 3176059Samurai 3186059Samurai printf("%02x: ", loglevel); 3196059Samurai for (i = LOG_PHASE; i < MAXLOGLEVEL; i++) { 3206059Samurai if (loglevel & (1 << i)) 3216059Samurai printf("%s ", LogLevelName[i]); 3226059Samurai } 3236059Samurai printf("\n"); 3246059Samurai return(1); 3256059Samurai} 3266059Samurai 3276059Samuraistatic int ShowEscape() 3286059Samurai{ 3296059Samurai int code, bit; 3306059Samurai 3316059Samurai if (EscMap[32]) { 3326059Samurai for (code = 0; code < 32; code++) { 3336059Samurai if (EscMap[code]) { 3346059Samurai for (bit = 0; bit < 8; bit++) { 3356059Samurai if (EscMap[code] & (1<<bit)) { 3366059Samurai printf(" 0x%02x", (code << 3) + bit); 3376059Samurai } 3386059Samurai } 3396059Samurai } 3406059Samurai } 3416059Samurai printf("\n"); 3426059Samurai } 3436059Samurai return(1); 3446059Samurai} 3456059Samurai 3466059Samuraistatic int ShowTimeout() 3476059Samurai{ 3486735Samurai printf(" Idle Timer: %d secs LQR Timer: %d secs Retry Timer: %d secs\n", 3496735Samurai VarIdleTimeout, VarLqrTimeout, VarRetryTimeout); 3506059Samurai return(1); 3516059Samurai} 3526059Samurai 3536059Samuraistatic int ShowAuthKey() 3546059Samurai{ 3556059Samurai printf("AuthName = %s\n", VarAuthName); 3566059Samurai printf("AuthKey = %s\n", VarAuthKey); 3576059Samurai return(1); 3586059Samurai} 3596059Samurai 3606059Samuraistatic int ShowVersion() 3616059Samurai{ 36213389Sphk extern char VarVersion[]; 36313389Sphk extern char VarLocalVersion[]; 3646059Samurai 3659448Samurai printf("%s - %s \n", VarVersion, VarLocalVersion); 3666059Samurai return(1); 3676059Samurai} 3686059Samurai 3696059Samuraistatic int ShowLogList() 3706059Samurai{ 3716059Samurai ListLog(); 3726059Samurai return(1); 3736059Samurai} 3746059Samurai 37525067Sbrianstatic int ShowReconnect() 37625067Sbrian{ 37725067Sbrian printf(" Reconnect Timer: %d, %d tries\n", 37825067Sbrian VarReconnectTimer, VarReconnectTries); 37925067Sbrian return(1); 38025067Sbrian} 38125067Sbrian 38211336Samuraistatic int ShowRedial() 38311336Samurai{ 38411336Samurai printf(" Redial Timer: "); 38511336Samurai 38611336Samurai if (VarRedialTimeout >= 0) { 38711336Samurai printf(" %d seconds, ", VarRedialTimeout); 38811336Samurai } 38911336Samurai else { 39011336Samurai printf(" Random 0 - %d seconds, ", REDIAL_PERIOD); 39111336Samurai } 39211336Samurai 39324939Sbrian printf(" Redial Next Timer: "); 39424939Sbrian 39524939Sbrian if (VarRedialNextTimeout >= 0) { 39624939Sbrian printf(" %d seconds, ", VarRedialNextTimeout); 39724939Sbrian } 39824939Sbrian else { 39924939Sbrian printf(" Random 0 - %d seconds, ", REDIAL_PERIOD); 40024939Sbrian } 40124939Sbrian 40211336Samurai if (VarDialTries) 40311336Samurai printf("%d dial tries", VarDialTries); 40411336Samurai 40511336Samurai printf("\n"); 40611336Samurai 40711336Samurai return(1); 40811336Samurai} 40911336Samurai 41018752Sjkh#ifdef MSEXT 41118752Sjkhstatic int ShowMSExt() 41218752Sjkh{ 41318752Sjkh printf(" MS PPP extention values \n" ); 41418752Sjkh printf(" Primary NS : %s\n", inet_ntoa( ns_entries[0] )); 41518752Sjkh printf(" Secondary NS : %s\n", inet_ntoa( ns_entries[1] )); 41618752Sjkh printf(" Primary NBNS : %s\n", inet_ntoa( nbns_entries[0] )); 41718752Sjkh printf(" Secondary NBNS : %s\n", inet_ntoa( nbns_entries[1] )); 41811336Samurai 41918752Sjkh return(1); 42018752Sjkh} 42118752Sjkh#endif /* MSEXT */ 42218752Sjkh 4236735Samuraiextern int ShowIfilter(), ShowOfilter(), ShowDfilter(), ShowAfilter(); 4246059Samurai 42513760Sphkstruct cmdtab const ShowCommands[] = { 4266735Samurai { "afilter", NULL, ShowAfilter, LOCAL_AUTH, 4276735Samurai "Show keep Alive filters", StrOption}, 4286735Samurai { "auth", NULL, ShowAuthKey, LOCAL_AUTH, 4296735Samurai "Show auth name/key", StrNull}, 4306735Samurai { "ccp", NULL, ReportCcpStatus, LOCAL_AUTH, 4316735Samurai "Show CCP status", StrNull}, 4326735Samurai { "compress", NULL, ReportCompress, LOCAL_AUTH, 4336735Samurai "Show compression statictics", StrNull}, 4346735Samurai { "debug", NULL, ShowDebugLevel, LOCAL_AUTH, 4356735Samurai "Show current debug level", StrNull}, 4366735Samurai { "dfilter", NULL, ShowDfilter, LOCAL_AUTH, 4376735Samurai "Show Demand filters", StrOption}, 4386735Samurai { "escape", NULL, ShowEscape, LOCAL_AUTH, 4396735Samurai "Show escape characters", StrNull}, 4406735Samurai { "hdlc", NULL, ReportHdlcStatus, LOCAL_AUTH, 4416735Samurai "Show HDLC error summary", StrNull}, 4426735Samurai { "ifilter", NULL, ShowIfilter, LOCAL_AUTH, 4436735Samurai "Show Input filters", StrOption}, 4446735Samurai { "ipcp", NULL, ReportIpcpStatus, LOCAL_AUTH, 4456735Samurai "Show IPCP status", StrNull}, 4466735Samurai { "lcp", NULL, ReportLcpStatus, LOCAL_AUTH, 4476735Samurai "Show LCP status", StrNull}, 4486735Samurai { "log", NULL, ShowLogList, LOCAL_AUTH, 4496735Samurai "Show log records", StrNull}, 4506735Samurai { "mem", NULL, ShowMemMap, LOCAL_AUTH, 4516735Samurai "Show memory map", StrNull}, 4526735Samurai { "modem", NULL, ShowModemStatus, LOCAL_AUTH, 4536735Samurai "Show modem setups", StrNull}, 4546735Samurai { "ofilter", NULL, ShowOfilter, LOCAL_AUTH, 4556735Samurai "Show Output filters", StrOption}, 4566735Samurai { "proto", NULL, ReportProtStatus, LOCAL_AUTH, 4576735Samurai "Show protocol summary", StrNull}, 45825067Sbrian { "reconnect",NULL, ShowReconnect, LOCAL_AUTH, 45925690Sache "Show Reconnect timer,tries", StrNull}, 46025067Sbrian { "redial", NULL, ShowRedial, LOCAL_AUTH, 46125067Sbrian "Show Redial timeout value", StrNull}, 4626735Samurai { "route", NULL, ShowRoute, LOCAL_AUTH, 4636735Samurai "Show routing table", StrNull}, 4646735Samurai { "timeout", NULL, ShowTimeout, LOCAL_AUTH, 4656735Samurai "Show Idle timeout value", StrNull}, 46618752Sjkh#ifdef MSEXT 46718752Sjkh { "msext", NULL, ShowMSExt, LOCAL_AUTH, 46823598Sache "Show MS PPP extentions", StrNull}, 46918752Sjkh#endif /* MSEXT */ 4706735Samurai { "version", NULL, ShowVersion, LOCAL_NO_AUTH | LOCAL_AUTH, 4716735Samurai "Show version string", StrNull}, 4726735Samurai { "help", "?", HelpCommand, LOCAL_NO_AUTH | LOCAL_AUTH, 4736735Samurai "Display this message", StrNull, (void *)ShowCommands}, 4746059Samurai { NULL, NULL, NULL }, 4756059Samurai}; 4766059Samurai 4776059Samuraistruct cmdtab * 4786059SamuraiFindCommand(cmds, str, pmatch) 4796059Samuraistruct cmdtab *cmds; 4806059Samuraichar *str; 4816059Samuraiint *pmatch; 4826059Samurai{ 4836059Samurai int nmatch = 0; 4846059Samurai int len = strlen(str); 4856059Samurai struct cmdtab *found = NULL; 4866059Samurai 4876059Samurai while (cmds->func) { 48825566Sbrian if (cmds->name && strncasecmp(str, cmds->name, len) == 0) { 4896059Samurai nmatch++; 4906059Samurai found = cmds; 49125566Sbrian } else if (cmds->alias && strncasecmp(str, cmds->alias, len) == 0) { 4926059Samurai nmatch++; 4936059Samurai found = cmds; 4946059Samurai } 4956059Samurai cmds++; 4966059Samurai } 4976059Samurai *pmatch = nmatch; 4986059Samurai return(found); 4996059Samurai} 5006059Samurai 5016059Samuraiint 5026059SamuraiFindExec(cmdlist, argc, argv) 5036059Samuraistruct cmdtab *cmdlist; 5046059Samuraiint argc; 5056059Samuraichar **argv; 5066059Samurai{ 5076059Samurai struct cmdtab *cmd; 5086059Samurai int val = 1; 5096059Samurai int nmatch; 5106059Samurai 5116059Samurai cmd = FindCommand(cmdlist, *argv, &nmatch); 5126059Samurai if (nmatch > 1) 5136735Samurai printf("Ambiguous.\n"); 5146735Samurai else if (cmd && ( cmd->lauth & VarLocalAuth ) ) 5156059Samurai val = (cmd->func)(cmd, --argc, ++argv, cmd->args); 5166059Samurai else 5176059Samurai printf("what?\n"); 5186059Samurai return(val); 5196059Samurai} 5206059Samurai 52118885Sjkhint aft_cmd = 1; 52218885Sjkh 5236059Samuraivoid 52418885SjkhPrompt() 5256059Samurai{ 5266735Samurai char *pconnect, *pauth; 5276735Samurai 5286059Samurai if (!(mode & MODE_INTER)) 5296059Samurai return; 5306735Samurai 53118885Sjkh if (!aft_cmd) 53218885Sjkh printf("\n"); 53318885Sjkh else 53418885Sjkh aft_cmd = 0; 5356735Samurai 5366735Samurai if ( VarLocalAuth == LOCAL_AUTH ) 5376735Samurai pauth = " ON "; 5386735Samurai else 5396735Samurai pauth = " on "; 5406059Samurai if (IpcpFsm.state == ST_OPENED && phase == PHASE_NETWORK) 5416735Samurai pconnect = "PPP"; 5426059Samurai else 5436735Samurai pconnect = "ppp"; 5446735Samurai printf("%s%s%s> ", pconnect, pauth, VarShortHost); 5456059Samurai fflush(stdout); 5466059Samurai} 5476059Samurai 5486059Samuraivoid 5496059SamuraiDecodeCommand(buff, nb, prompt) 5506059Samuraichar *buff; 5516059Samuraiint nb; 5526059Samuraiint prompt; 5536059Samurai{ 5546059Samurai char *vector[20]; 5556059Samurai char **argv; 5566059Samurai int argc, val; 5576059Samurai char *cp; 5586059Samurai 5596059Samurai val = 1; 5606059Samurai if (nb > 0) { 5616059Samurai cp = buff + strcspn(buff, "\r\n"); 5626059Samurai if (cp) 5636059Samurai *cp = '\0'; 5646059Samurai { 56525560Sbrian argc = MakeArgs(buff, vector, VECSIZE(vector)); 5666059Samurai argv = vector; 5676059Samurai 5686059Samurai if (argc > 0) 5696059Samurai val = FindExec(Commands, argc, argv); 5706059Samurai } 5716059Samurai } 5726059Samurai if (val && prompt) 57325630Sbrian Prompt(); 5746059Samurai} 5756059Samurai 5766059Samuraistatic int 5776059SamuraiShowCommand(list, argc, argv) 5786059Samuraistruct cmdtab *list; 5796059Samuraiint argc; 5806059Samuraichar **argv; 5816059Samurai{ 5826059Samurai int val = 1; 5836059Samurai 5846059Samurai if (argc > 0) 5856059Samurai val = FindExec(ShowCommands, argc, argv); 5866059Samurai else 5876059Samurai printf("Use ``show ?'' to get a list.\n"); 5886059Samurai return(val); 5896059Samurai} 5906059Samurai 5916059Samuraistatic int 5926059SamuraiTerminalCommand() 5936059Samurai{ 5946059Samurai if (LcpFsm.state > ST_CLOSED) { 5956059Samurai printf("LCP state is [%s]\n", StateNames[LcpFsm.state]); 5966059Samurai return(1); 5976059Samurai } 5986059Samurai if (!IsInteractive()) 5996059Samurai return(1); 6006059Samurai modem = OpenModem(mode); 6016059Samurai if (modem < 0) { 6026059Samurai printf("failed to open modem.\n"); 6036059Samurai return(1); 6046059Samurai } 6056059Samurai printf("Enter to terminal mode.\n"); 6066059Samurai printf("Type `~?' for help.\n"); 6076059Samurai TtyTermMode(); 6086059Samurai return(0); 6096059Samurai} 6106059Samurai 6116059Samuraistatic int 6126059SamuraiQuitCommand(list, argc, argv) 6136059Samuraistruct cmdtab *list; 6146059Samuraiint argc; 6156059Samuraichar **argv; 6166059Samurai{ 6176059Samurai if (mode & (MODE_DIRECT|MODE_DEDICATED|MODE_AUTO)) { 6186764Samurai if (argc > 0 && (VarLocalAuth & LOCAL_AUTH)) { 6196059Samurai Cleanup(EX_NORMAL); 62018911Ssos mode &= ~MODE_INTER; 6216059Samurai } else { 62224753Sache LogPrintf(LOG_PHASE_BIT, "client connection closed.\n"); 6236735Samurai VarLocalAuth = LOCAL_NO_AUTH; 6246059Samurai close(netfd); 6256059Samurai close(1); 6267886Samurai dup2(2, 1); /* Have to have something here or the modem will be 1 */ 6276059Samurai netfd = -1; 6286059Samurai mode &= ~MODE_INTER; 6296059Samurai } 6306059Samurai } else 6316059Samurai Cleanup(EX_NORMAL); 6326059Samurai return(1); 6336059Samurai} 6346059Samurai 6356059Samuraistatic int 6366059SamuraiCloseCommand() 6376059Samurai{ 63826098Sbrian reconnect(RECON_FALSE); 6396059Samurai LcpClose(); 64025908Sbrian if (mode & MODE_BACKGROUND) 64125908Sbrian Cleanup(EX_NORMAL); 6426059Samurai return(1); 6436059Samurai} 6446059Samurai 6456059Samuraistatic int 6466059SamuraiDownCommand() 6476059Samurai{ 6486059Samurai LcpDown(); 6496059Samurai return(1); 6506059Samurai} 6516059Samurai 65225067Sbrianstatic int 65325067SbrianSetModemSpeed(list, argc, argv) 6546059Samuraistruct cmdtab *list; 6556059Samuraiint argc; 6566059Samuraichar **argv; 6576059Samurai{ 6586059Samurai int speed; 6596059Samurai 6606059Samurai if (argc > 0) { 6616735Samurai if (strcmp(*argv, "sync") == 0) { 6626735Samurai VarSpeed = 0; 6636735Samurai return(1); 6646735Samurai } 6656059Samurai speed = atoi(*argv); 6666735Samurai if (IntToSpeed(speed) != B0) { 6676735Samurai VarSpeed = speed; 6686735Samurai return(1); 6696059Samurai } 6706059Samurai printf("invalid speed.\n"); 6716059Samurai } 6726059Samurai return(1); 6736059Samurai} 6746059Samurai 67525067Sbrianstatic int 67625067SbrianSetReconnect(list, argc, argv) 67711336Samuraistruct cmdtab *list; 67811336Samuraiint argc; 67911336Samuraichar **argv; 68011336Samurai{ 68125067Sbrian if (argc == 2) { 68225067Sbrian VarReconnectTimer = atoi(argv[0]); 68325067Sbrian VarReconnectTries = atoi(argv[1]); 68425067Sbrian } else 68525067Sbrian printf("Usage: %s %s\n", list->name, list->syntax); 68625067Sbrian return(1); 68725067Sbrian} 68825067Sbrian 68925067Sbrianstatic int 69025067SbrianSetRedialTimeout(list, argc, argv) 69125067Sbrianstruct cmdtab *list; 69225067Sbrianint argc; 69325067Sbrianchar **argv; 69425067Sbrian{ 69511336Samurai int timeout; 69611336Samurai int tries; 69724939Sbrian char *dot; 69811336Samurai 69911336Samurai if (argc == 1 || argc == 2 ) { 70024939Sbrian if (strncasecmp(argv[0], "random", 6) == 0 && 70124939Sbrian (argv[0][6] == '\0' || argv[0][6] == '.')) { 70211336Samurai VarRedialTimeout = -1; 70311336Samurai printf("Using random redial timeout.\n"); 70423603Sache if (!randinit) { 70523603Sache randinit = 1; 70624217Sache if (srandomdev() < 0) 70724217Sache srandom((unsigned long)(time(NULL) ^ getpid())); 70823603Sache } 70911336Samurai } 71011336Samurai else { 71111336Samurai timeout = atoi(argv[0]); 71211336Samurai 71311336Samurai if (timeout >= 0) { 71411336Samurai VarRedialTimeout = timeout; 71511336Samurai } 71611336Samurai else { 71711336Samurai printf("invalid redial timeout\n"); 71811336Samurai printf("Usage: %s %s\n", list->name, list->syntax); 71911336Samurai } 72011336Samurai } 72124939Sbrian 72224939Sbrian dot = index(argv[0],'.'); 72324939Sbrian if (dot) { 72424939Sbrian if (strcasecmp(++dot, "random") == 0) { 72524939Sbrian VarRedialNextTimeout = -1; 72624939Sbrian printf("Using random next redial timeout.\n"); 72724939Sbrian if (!randinit) { 72824939Sbrian randinit = 1; 72924939Sbrian if (srandomdev() < 0) 73024939Sbrian srandom((unsigned long)(time(NULL) ^ getpid())); 73124939Sbrian } 73224939Sbrian } 73324939Sbrian else { 73424939Sbrian timeout = atoi(dot); 73524939Sbrian if (timeout >= 0) { 73624939Sbrian VarRedialNextTimeout = timeout; 73724939Sbrian } 73824939Sbrian else { 73924939Sbrian printf("invalid next redial timeout\n"); 74024939Sbrian printf("Usage: %s %s\n", list->name, list->syntax); 74124939Sbrian } 74224939Sbrian } 74324939Sbrian } 74424939Sbrian else 74524939Sbrian VarRedialNextTimeout = NEXT_REDIAL_PERIOD; /* Default next timeout */ 74624939Sbrian 74711336Samurai if (argc == 2) { 74811336Samurai tries = atoi(argv[1]); 74911336Samurai 75011336Samurai if (tries >= 0) { 75111336Samurai VarDialTries = tries; 75211336Samurai } 75311336Samurai else { 75411336Samurai printf("invalid retry value\n"); 75511336Samurai printf("Usage: %s %s\n", list->name, list->syntax); 75611336Samurai } 75711336Samurai } 75811336Samurai } 75911336Samurai else { 76011336Samurai printf("Usage: %s %s\n", list->name, list->syntax); 76111336Samurai } 76211336Samurai return(1); 76311336Samurai} 76411336Samurai 76525067Sbrianstatic int 76625067SbrianSetModemParity(list, argc, argv) 7676059Samuraistruct cmdtab *list; 7686059Samuraiint argc; 7696059Samuraichar **argv; 7706059Samurai{ 7716059Samurai int parity; 7726059Samurai 7736059Samurai if (argc > 0) { 7746059Samurai parity = ChangeParity(*argv); 7756059Samurai if (parity < 0) 7766059Samurai printf("Invalid parity.\n"); 7776059Samurai else 7786059Samurai VarParity = parity; 7796059Samurai } 7806059Samurai return(1); 7816059Samurai} 7826059Samurai 7836059Samuraistatic int 7846059SamuraiSetDebugLevel(list, argc, argv) 7856059Samuraistruct cmdtab *list; 7866059Samuraiint argc; 7876059Samuraichar **argv; 7886059Samurai{ 7896059Samurai int level, w; 7906059Samurai 7916059Samurai for (level = 0; argc-- > 0; argv++) { 7926059Samurai if (isdigit(**argv)) { 7936059Samurai w = atoi(*argv); 7946059Samurai if (w < 0 || w >= MAXLOGLEVEL) { 7956059Samurai printf("invalid log level.\n"); 7966059Samurai break; 7976059Samurai } else 7986059Samurai level |= (1 << w); 7996059Samurai } else { 8006059Samurai for (w = 0; w < MAXLOGLEVEL; w++) { 8016059Samurai if (strcasecmp(*argv, LogLevelName[w]) == 0) { 8026059Samurai level |= (1 << w); 8036059Samurai continue; 8046059Samurai } 8056059Samurai } 8066059Samurai } 8076059Samurai } 8086059Samurai loglevel = level; 8096059Samurai return(1); 8106059Samurai} 8116059Samurai 8126059Samuraistatic int 8136059SamuraiSetEscape(list, argc, argv) 8146059Samuraistruct cmdtab *list; 8156059Samuraiint argc; 8166059Samuraichar **argv; 8176059Samurai{ 8186059Samurai int code; 8196059Samurai 8206059Samurai for (code = 0; code < 33; code++) 8216059Samurai EscMap[code] = 0; 8226059Samurai while (argc-- > 0) { 8236059Samurai sscanf(*argv++, "%x", &code); 8246059Samurai code &= 0xff; 8256059Samurai EscMap[code >> 3] |= (1 << (code&7)); 8266059Samurai EscMap[32] = 1; 8276059Samurai } 8286059Samurai return(1); 8296059Samurai} 8306059Samurai 8316059Samuraistatic int 8326059SamuraiSetInitialMRU(list, argc, argv) 8336059Samuraistruct cmdtab *list; 8346059Samuraiint argc; 8356059Samuraichar **argv; 8366059Samurai{ 8376059Samurai int mru; 8386059Samurai 8396059Samurai if (argc > 0) { 8406059Samurai mru = atoi(*argv); 8416059Samurai if (mru < 100) 8426059Samurai printf("given value is too small.\n"); 8436059Samurai else if (mru > MAX_MRU) 8446059Samurai printf("given value is too big.\n"); 8456059Samurai else 8466059Samurai VarMRU = mru; 8476059Samurai } 8486059Samurai return(1); 8496059Samurai} 8506059Samurai 8516059Samuraistatic int 8526059SamuraiSetIdleTimeout(list, argc, argv) 8536059Samuraistruct cmdtab *list; 8546059Samuraiint argc; 8556059Samuraichar **argv; 8566059Samurai{ 8576059Samurai if (argc-- > 0) { 8586059Samurai VarIdleTimeout = atoi(*argv++); 8596735Samurai if (argc-- > 0) { 8606735Samurai VarLqrTimeout = atoi(*argv++); 8616735Samurai if (VarLqrTimeout < 1) 8626735Samurai VarLqrTimeout = 30; 8636735Samurai if (argc > 0) { 8646735Samurai VarRetryTimeout = atoi(*argv); 8656735Samurai if (VarRetryTimeout < 1 || VarRetryTimeout > 10) 8666735Samurai VarRetryTimeout = 3; 8676735Samurai } 8686735Samurai } 8696059Samurai } 8706059Samurai return(1); 8716059Samurai} 8726059Samurai 8736059Samuraistruct in_addr 8746059SamuraiGetIpAddr(cp) 8756059Samuraichar *cp; 8766059Samurai{ 8776059Samurai struct hostent *hp; 8786059Samurai struct in_addr ipaddr; 8796059Samurai 8806059Samurai hp = gethostbyname(cp); 8816059Samurai if (hp && hp->h_addrtype == AF_INET) 8826059Samurai bcopy(hp->h_addr, &ipaddr, hp->h_length); 8836059Samurai else if (inet_aton(cp, &ipaddr) == 0) 8846059Samurai ipaddr.s_addr = 0; 8856059Samurai return(ipaddr); 8866059Samurai} 8876059Samurai 8886059Samuraistatic int 8896059SamuraiSetInterfaceAddr(list, argc, argv) 8906059Samuraistruct cmdtab *list; 8916059Samuraiint argc; 8926059Samuraichar **argv; 8936059Samurai{ 8946059Samurai 8956059Samurai DefMyAddress.ipaddr.s_addr = DefHisAddress.ipaddr.s_addr = 0L; 89625630Sbrian if (argc > 4) { 89725630Sbrian printf("set ifaddr: too many arguments (%d > 4)\n", argc); 89825630Sbrian return(0); 89925630Sbrian } 9006059Samurai if (argc > 0) { 90125630Sbrian if (ParseAddr(argc, argv++, 90225630Sbrian &DefMyAddress.ipaddr, 90325630Sbrian &DefMyAddress.mask, 90425630Sbrian &DefMyAddress.width) == 0) 90525630Sbrian return(0); 9066059Samurai if (--argc > 0) { 90725630Sbrian if (ParseAddr(argc, argv++, 90825630Sbrian &DefHisAddress.ipaddr, 90925630Sbrian &DefHisAddress.mask, 91025630Sbrian &DefHisAddress.width) == 0) 91125630Sbrian return(0); 9126059Samurai if (--argc > 0) { 9136059Samurai ifnetmask = GetIpAddr(*argv); 9149440Samurai if (--argc > 0) { 91525630Sbrian if (ParseAddr(argc, argv++, 91625630Sbrian &DefTriggerAddress.ipaddr, 91725630Sbrian &DefTriggerAddress.mask, 91825630Sbrian &DefTriggerAddress.width) == 0) 91925630Sbrian return(0); 9209440Samurai } 9216059Samurai } 9226059Samurai } 9236059Samurai } 9246059Samurai /* 9256059Samurai * For backwards compatibility, 0.0.0.0 means any address. 9266059Samurai */ 9276059Samurai if (DefMyAddress.ipaddr.s_addr == 0) { 9286059Samurai DefMyAddress.mask.s_addr = 0; 9296059Samurai DefMyAddress.width = 0; 9306059Samurai } 9316059Samurai if (DefHisAddress.ipaddr.s_addr == 0) { 9326059Samurai DefHisAddress.mask.s_addr = 0; 9336059Samurai DefHisAddress.width = 0; 9346059Samurai } 9356059Samurai 9366735Samurai if ((mode & MODE_AUTO) || 9376059Samurai ((mode & MODE_DEDICATED) && dstsystem)) { 93825630Sbrian if (OsSetIpaddress(DefMyAddress.ipaddr, DefHisAddress.ipaddr, ifnetmask) < 0) 93925630Sbrian return(0); 9406059Samurai } 9416059Samurai return(1); 9426059Samurai} 9436059Samurai 94418752Sjkh#ifdef MSEXT 9456059Samurai 94618752Sjkhvoid 94718752SjkhSetMSEXT(pri_addr, sec_addr, argc, argv) 94818752Sjkhstruct in_addr *pri_addr; 94918752Sjkhstruct in_addr *sec_addr; 95018752Sjkhint argc; 95118752Sjkhchar **argv; 95218752Sjkh{ 95318752Sjkh int dummyint; 95418752Sjkh struct in_addr dummyaddr; 95518752Sjkh 95618752Sjkh pri_addr->s_addr = sec_addr->s_addr = 0L; 95718752Sjkh 95818752Sjkh if( argc > 0 ) { 95918752Sjkh ParseAddr(argc, argv++, pri_addr, &dummyaddr, &dummyint); 96018752Sjkh if( --argc > 0 ) 96118752Sjkh ParseAddr(argc, argv++, sec_addr, &dummyaddr, &dummyint); 96218752Sjkh else 96318752Sjkh sec_addr->s_addr = pri_addr->s_addr; 96418752Sjkh } 96518752Sjkh 96618752Sjkh /* 96718752Sjkh * if the primary/secondary ns entries are 0.0.0.0 we should 96818752Sjkh * set them to either the localhost's ip, or the values in 96918752Sjkh * /etc/resolv.conf ?? 97018752Sjkh * 97118752Sjkh * up to you if you want to implement this... 97218752Sjkh */ 97318752Sjkh 97418752Sjkh} 97518752Sjkh 97618752Sjkhstatic int 97718752SjkhSetNS(list, argc, argv) 97818752Sjkhstruct cmdtab *list; 97918752Sjkhint argc; 98018752Sjkhchar **argv; 98118752Sjkh{ 98218752Sjkh SetMSEXT(&ns_entries[0], &ns_entries[1], argc, argv); 98318752Sjkh return(1); 98418752Sjkh} 98518752Sjkh 98618752Sjkhstatic int 98718752SjkhSetNBNS(list, argc, argv) 98818752Sjkhstruct cmdtab *list; 98918752Sjkhint argc; 99018752Sjkhchar **argv; 99118752Sjkh{ 99218752Sjkh SetMSEXT(&nbns_entries[0], &nbns_entries[1], argc, argv); 99318752Sjkh return(1); 99418752Sjkh} 99518752Sjkh 99618752Sjkh#endif /* MS_EXT */ 99718752Sjkh 9986059Samurai#define VAR_AUTHKEY 0 9996059Samurai#define VAR_DIAL 1 10006059Samurai#define VAR_LOGIN 2 10016059Samurai#define VAR_AUTHNAME 3 10026059Samurai#define VAR_DEVICE 4 10036059Samurai#define VAR_ACCMAP 5 10046059Samurai#define VAR_PHONE 6 10056059Samurai 10066059Samuraistatic int 10076059SamuraiSetVariable(list, argc, argv, param) 10086059Samuraistruct cmdtab *list; 10096059Samuraiint argc; 10106059Samuraichar **argv; 10116059Samuraiint param; 10126059Samurai{ 10136059Samurai u_long map; 10146059Samurai 10156059Samurai if (argc > 0) { 10166059Samurai switch (param) { 10176059Samurai case VAR_AUTHKEY: 10186059Samurai strncpy(VarAuthKey, *argv, sizeof(VarAuthKey)-1); 101921488Simp VarAuthKey[sizeof(VarAuthKey)-1] = '\0'; 10206059Samurai break; 10216059Samurai case VAR_AUTHNAME: 10226059Samurai strncpy(VarAuthName, *argv, sizeof(VarAuthName)-1); 102321488Simp VarAuthName[sizeof(VarAuthName)-1] = '\0'; 10246059Samurai break; 10256059Samurai case VAR_DIAL: 10266059Samurai strncpy(VarDialScript, *argv, sizeof(VarDialScript)-1); 102721488Simp VarDialScript[sizeof(VarDialScript)-1] = '\0'; 10286059Samurai break; 10296059Samurai case VAR_LOGIN: 103022225Sjoerg strncpy(VarLoginScript, *argv, sizeof(VarLoginScript)-1); 103121488Simp VarLoginScript[sizeof(VarLoginScript)-1] = '\0'; 10326059Samurai break; 10336059Samurai case VAR_DEVICE: 10346059Samurai strncpy(VarDevice, *argv, sizeof(VarDevice)-1); 103521488Simp VarDevice[sizeof(VarDevice)-1] = '\0'; 103625634Sbrian VarBaseDevice = rindex(VarDevice, '/'); 103725634Sbrian VarBaseDevice = VarBaseDevice ? VarBaseDevice + 1 : ""; 10386059Samurai break; 10396059Samurai case VAR_ACCMAP: 104013389Sphk sscanf(*argv, "%lx", &map); 10416059Samurai VarAccmap = map; 10426059Samurai break; 10436059Samurai case VAR_PHONE: 104414418Sache strncpy(VarPhoneList, *argv, sizeof(VarPhoneList)-1); 104521488Simp VarPhoneList[sizeof(VarPhoneList)-1] = '\0'; 104614423Sache strcpy(VarPhoneCopy, VarPhoneList); 104714423Sache VarNextPhone = VarPhoneCopy; 10486059Samurai break; 10496059Samurai } 10506059Samurai } 10516059Samurai return(1); 10526059Samurai} 10536059Samurai 105420812Sjkhstatic int SetCtsRts(list, argc, argv) 105520812Sjkhstruct cmdtab *list; 105620812Sjkhint argc; 105720812Sjkhchar **argv; 105820812Sjkh{ 105920812Sjkh if (argc > 0) { 106020812Sjkh if (strcmp(*argv, "on") == 0) 106120812Sjkh VarCtsRts = TRUE; 106220812Sjkh else if (strcmp(*argv, "off") == 0) 106320812Sjkh VarCtsRts = FALSE; 106420812Sjkh else 106520812Sjkh printf("usage: set ctsrts [on|off].\n"); 106620812Sjkh } 106720812Sjkh return(1); 106820812Sjkh} 106920812Sjkh 107020812Sjkh 10716059Samuraistatic int SetOpenMode(list, argc, argv) 10726059Samuraistruct cmdtab *list; 10736059Samuraiint argc; 10746059Samuraichar **argv; 10756059Samurai{ 10766059Samurai if (argc > 0) { 10776059Samurai if (strcmp(*argv, "active") == 0) 10786059Samurai VarOpenMode = OPEN_ACTIVE; 10796059Samurai else if (strcmp(*argv, "passive") == 0) 10806059Samurai VarOpenMode = OPEN_PASSIVE; 10816059Samurai else 10826059Samurai printf("Invalid mode.\n"); 10836059Samurai } 10846059Samurai return(1); 10856059Samurai} 10866059Samuraistatic char StrChatStr[] = "chat-script"; 10876059Samuraistatic char StrValue[] = "value"; 10886059Samurai 10896735Samuraiextern int SetIfilter(), SetOfilter(), SetDfilter(), SetAfilter(); 10906059Samurai 109113760Sphkstruct cmdtab const SetCommands[] = { 10926735Samurai { "accmap", NULL, SetVariable, LOCAL_AUTH, 10936735Samurai "Set accmap value", "hex-value", (void *)VAR_ACCMAP}, 10946735Samurai { "afilter", NULL, SetAfilter, LOCAL_AUTH, 10956735Samurai "Set keep Alive filter", "..."}, 10966735Samurai { "authkey", "key", SetVariable, LOCAL_AUTH, 10976735Samurai "Set authentication key", "key", (void *)VAR_AUTHKEY}, 10986735Samurai { "authname", NULL, SetVariable, LOCAL_AUTH, 10996735Samurai "Set authentication name", "name", (void *)VAR_AUTHNAME}, 110020812Sjkh { "ctsrts", NULL, SetCtsRts, LOCAL_AUTH, 110120812Sjkh "Use CTS/RTS modem signalling", "[on|off]"}, 11026735Samurai { "debug", NULL, SetDebugLevel, LOCAL_AUTH, 11036735Samurai "Set debug level", StrValue}, 11046735Samurai { "device", "line", SetVariable, LOCAL_AUTH, 11056735Samurai "Set modem device name", "device-name", (void *)VAR_DEVICE}, 11066735Samurai { "dfilter", NULL, SetDfilter, LOCAL_AUTH, 11076735Samurai "Set demand filter", "..."}, 11086735Samurai { "dial", NULL, SetVariable, LOCAL_AUTH, 11096735Samurai "Set dialing script", StrChatStr, (void *)VAR_DIAL}, 11106735Samurai { "escape", NULL, SetEscape, LOCAL_AUTH, 11116735Samurai "Set escape characters", "hex-digit ..."}, 11126735Samurai { "ifaddr", NULL, SetInterfaceAddr, LOCAL_AUTH, 111314418Sache "Set destination address", "[src-addr [dst-addr [netmask [trg-addr]]]]"}, 11146735Samurai { "ifilter", NULL, SetIfilter, LOCAL_AUTH, 11156735Samurai "Set input filter", "..."}, 11166735Samurai { "login", NULL, SetVariable, LOCAL_AUTH, 11176735Samurai "Set login script", StrChatStr, (void *)VAR_LOGIN }, 11186735Samurai { "mru", "mtu", SetInitialMRU, LOCAL_AUTH, 11196735Samurai "Set Initial MRU value", StrValue }, 11206735Samurai { "ofilter", NULL, SetOfilter, LOCAL_AUTH, 11216735Samurai "Set output filter", "..." }, 11226735Samurai { "openmode", NULL, SetOpenMode, LOCAL_AUTH, 11236735Samurai "Set open mode", "[active|passive]"}, 11246735Samurai { "parity", NULL, SetModemParity, LOCAL_AUTH, 11256735Samurai "Set modem parity", "[odd|even|none]"}, 11266735Samurai { "phone", NULL, SetVariable, LOCAL_AUTH, 112714418Sache "Set telephone number(s)", "phone1[:phone2[...]]", (void *)VAR_PHONE }, 112825067Sbrian { "reconnect",NULL, SetReconnect, LOCAL_AUTH, 112925067Sbrian "Set Reconnect timeout", "value ntries"}, 113025067Sbrian { "redial", NULL, SetRedialTimeout, LOCAL_AUTH, 113125067Sbrian "Set Redial timeout", "value|random[.value|random] [dial_attempts]"}, 11326735Samurai { "speed", NULL, SetModemSpeed, LOCAL_AUTH, 11336735Samurai "Set modem speed", "speed"}, 11346735Samurai { "timeout", NULL, SetIdleTimeout, LOCAL_AUTH, 11356735Samurai "Set Idle timeout", StrValue}, 113618752Sjkh#ifdef MSEXT 113718752Sjkh { "ns", NULL, SetNS, LOCAL_AUTH, 113818752Sjkh "Set NameServer", "pri-addr [sec-addr]"}, 113918752Sjkh { "nbns", NULL, SetNBNS, LOCAL_AUTH, 114018752Sjkh "Set NetBIOS NameServer", "pri-addr [sec-addr]"}, 114118752Sjkh#endif /* MSEXT */ 11426735Samurai { "help", "?", HelpCommand, LOCAL_AUTH | LOCAL_NO_AUTH, 11436735Samurai "Display this message", StrNull, (void *)SetCommands}, 11446059Samurai { NULL, NULL, NULL }, 11456059Samurai}; 11466059Samurai 11476059Samuraistatic int 11486059SamuraiSetCommand(list, argc, argv) 11496059Samuraistruct cmdtab *list; 11506059Samuraiint argc; 11516059Samuraichar **argv; 11526059Samurai{ 11536059Samurai int val = 1; 11546059Samurai 11556059Samurai if (argc > 0) 11566059Samurai val = FindExec(SetCommands, argc, argv); 11576059Samurai else 115814418Sache printf("Use `set ?' to get a list or `set ? <var>' for syntax help.\n"); 11596059Samurai return(val); 11606059Samurai} 11616059Samurai 11626059Samurai 11636059Samuraistatic int 11646059SamuraiAddCommand(list, argc, argv) 11656059Samuraistruct cmdtab *list; 11666059Samuraiint argc; 11676059Samuraichar **argv; 11686059Samurai{ 11696059Samurai struct in_addr dest, gateway, netmask; 11706059Samurai 11716059Samurai if (argc == 3) { 11726059Samurai dest = GetIpAddr(argv[0]); 11736059Samurai netmask = GetIpAddr(argv[1]); 117425566Sbrian if (strcasecmp(argv[2], "HISADDR") == 0) 11756059Samurai gateway = IpcpInfo.his_ipaddr; 11766059Samurai else 11776059Samurai gateway = GetIpAddr(argv[2]); 11786059Samurai OsSetRoute(RTM_ADD, dest, gateway, netmask); 11796059Samurai } else { 11806059Samurai printf("Usage: %s %s\n", list->name, list->syntax); 11816059Samurai } 11826059Samurai return(1); 11836059Samurai} 11846059Samurai 11856059Samuraistatic int 11866059SamuraiDeleteCommand(list, argc, argv) 11876059Samuraistruct cmdtab *list; 11886059Samuraiint argc; 11896059Samuraichar **argv; 11906059Samurai{ 11916059Samurai struct in_addr dest, gateway, netmask; 11926059Samurai 11936059Samurai if (argc >= 2) { 11946059Samurai dest = GetIpAddr(argv[0]); 119525566Sbrian if (strcasecmp(argv[1], "HISADDR") == 0) 11966059Samurai gateway = IpcpInfo.his_ipaddr; 11976059Samurai else 11986059Samurai gateway = GetIpAddr(argv[1]); 11996059Samurai netmask.s_addr = 0; 12006059Samurai if (argc == 3) { 12016059Samurai if (inet_aton(argv[1], &netmask) == 0) { 12026059Samurai printf("bad netmask value.\n"); 12036059Samurai return(1); 12046059Samurai } 12056059Samurai } 12066059Samurai OsSetRoute(RTM_DELETE, dest, gateway, netmask); 120725566Sbrian } else if (argc == 1 && strcasecmp(argv[0], "ALL") == 0) { 12086059Samurai DeleteIfRoutes(0); 12096059Samurai } else { 12106059Samurai printf("Usage: %s %s\n", list->name, list->syntax); 12116059Samurai } 12126059Samurai return(1); 12136059Samurai} 12146059Samurai 121526031Sbrian 121626031Sbrianstatic int AliasEnable(); 121726031Sbrianstatic int AliasOption(); 121826031Sbrian 121926031Sbrian 122026031Sbrianstatic struct cmdtab const AliasCommands[] = 122126031Sbrian{ 122226031Sbrian { "enable", NULL, AliasEnable, LOCAL_AUTH, 122326031Sbrian "enable IP aliasing", "[yes|no]"}, 122426031Sbrian { "port", NULL, AliasRedirectPort, LOCAL_AUTH, 122526031Sbrian "port redirection", "[proto addr_local:port_local port_alias]"}, 122626031Sbrian { "addr", NULL, AliasRedirectAddr, LOCAL_AUTH, 122726031Sbrian "static address translation", "[addr_local addr_alias]"}, 122826031Sbrian { "deny_incoming", NULL, AliasOption, LOCAL_AUTH, 122926031Sbrian "stop incoming connections", "[yes|no]", 123026031Sbrian (void*)PKT_ALIAS_DENY_INCOMING}, 123126031Sbrian { "log", NULL, AliasOption, LOCAL_AUTH, 123226031Sbrian "log aliasing link creation", "[yes|no]", 123326031Sbrian (void*)PKT_ALIAS_LOG}, 123426031Sbrian { "same_ports", NULL, AliasOption, LOCAL_AUTH, 123526031Sbrian "try to leave port numbers unchanged", "[yes|no]", 123626031Sbrian (void*)PKT_ALIAS_SAME_PORTS}, 123726031Sbrian { "use_sockets", NULL, AliasOption, LOCAL_AUTH, 123826031Sbrian "allocate host sockets", "[yes|no]", 123926031Sbrian (void*)PKT_ALIAS_USE_SOCKETS }, 124026031Sbrian { "unregistered_only", NULL, AliasOption, LOCAL_AUTH, 124126031Sbrian "alias unregistered (private) IP address space only", "[yes|no]", 124226031Sbrian (void*)PKT_ALIAS_UNREGISTERED_ONLY}, 124326031Sbrian { "help", "?", HelpCommand, LOCAL_AUTH | LOCAL_NO_AUTH, 124426031Sbrian "Display this message", StrNull, 124526031Sbrian (void *)AliasCommands}, 124626031Sbrian { NULL, NULL, NULL }, 124726031Sbrian}; 124826031Sbrian 124926031Sbrian 125026031Sbrianstatic int 125126031SbrianAliasCommand(list, argc, argv) 125226031Sbrianstruct cmdtab *list; 125326031Sbrianint argc; 125426031Sbrianchar **argv; 125526031Sbrian{ 125626031Sbrian int val = 1; 125726031Sbrian 125826031Sbrian if (argc > 0) 125926031Sbrian val = FindExec(AliasCommands, argc, argv); 126026031Sbrian else 126126031Sbrian printf("Use `alias help' to get a list or `alias help <option>' for syntax h 126226031Sbrianelp.\n"); 126326031Sbrian return(val); 126426031Sbrian} 126526031Sbrian 126626031Sbrian 126726031Sbrianstatic int 126826031SbrianAliasEnable(list, argc, argv) 126926031Sbrianstruct cmdtab *list; 127026031Sbrianint argc; 127126031Sbrianchar **argv; 127226031Sbrian{ 127326142Sbrian if (argc == 1 && strcmp(argv[0], "yes") == 0) { 127426142Sbrian if (!(mode & MODE_ALIAS)) 127526142Sbrian if (loadAliasHandlers(&VarAliasHandlers) == 0) 127626142Sbrian mode |= MODE_ALIAS; 127726142Sbrian else 127826142Sbrian printf("Cannot load alias library\n"); 127926142Sbrian } else if (argc == 1 && strcmp(argv[0], "no") == 0) { 128026142Sbrian if (mode & MODE_ALIAS) { 128126142Sbrian unloadAliasHandlers(); 128226142Sbrian mode &= ~MODE_ALIAS; 128326142Sbrian } 128426142Sbrian } else { 128526142Sbrian printf("Usage: alias %s %s\n", list->name, list->syntax); 128626142Sbrian } 128726142Sbrian return(1); 128826031Sbrian} 128926031Sbrian 129026031Sbrian 129126031Sbrianstatic int 129226031SbrianAliasOption(list, argc, argv, param) 129326031Sbrianstruct cmdtab *list; 129426031Sbrianint argc; 129526031Sbrianchar **argv; 129626031Sbrianvoid* param; 129726031Sbrian{ 129826031Sbrian if (argc == 1 && strcmp(argv[0], "yes") == 0) { 129926142Sbrian if (mode & MODE_ALIAS) 130026142Sbrian VarSetPacketAliasMode((unsigned)param, (unsigned)param); 130126142Sbrian else 130226142Sbrian printf("alias not enabled\n"); 130326031Sbrian } else if (argc == 1 && strcmp(argv[0], "no") == 0) { 130426142Sbrian if (mode & MODE_ALIAS) 130526142Sbrian VarSetPacketAliasMode(0, (unsigned)param); 130626142Sbrian else 130726142Sbrian printf("alias not enabled\n"); 130826031Sbrian } else { 130926031Sbrian printf("Usage: alias %s %s\n", list->name, list->syntax); 131026031Sbrian } 131126031Sbrian return(1); 131226031Sbrian} 1313