command.c revision 20120
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 * 2020120Snate * $Id: command.c,v 1.24 1996/10/13 15:05:14 sos Exp $ 218857Srgrimes * 226059Samurai */ 2313379Sphk#include <sys/types.h> 246059Samurai#include <ctype.h> 256735Samurai#include <termios.h> 2613385Speter#include <sys/wait.h> 2713379Sphk#include <time.h> 286059Samurai#include "fsm.h" 296059Samurai#include "phase.h" 306059Samurai#include "lcp.h" 316059Samurai#include "ipcp.h" 326059Samurai#include "modem.h" 3313389Sphk#include "filter.h" 346059Samurai#include "command.h" 356059Samurai#include "hdlc.h" 366059Samurai#include "vars.h" 376735Samurai#include "auth.h" 386059Samurai#include <netdb.h> 396059Samurai#include <sys/socket.h> 406059Samurai#include <arpa/inet.h> 416059Samurai#include <net/route.h> 426059Samurai#include "os.h" 4310528Samurai#include <paths.h> 446059Samurai 456059Samuraiextern int MakeArgs(); 466059Samuraiextern void Cleanup(), TtyTermMode(), PacketMode(); 476059Samuraiextern int EnableCommand(), DisableCommand(), DisplayCommand(); 486059Samuraiextern int AcceptCommand(), DenyCommand(); 496735Samuraiextern int LocalAuthCommand(); 506059Samuraiextern int LoadCommand(), SaveCommand(); 516059Samuraiextern int ChangeParity(char *); 526059Samuraiextern int SelectSystem(); 536059Samuraiextern int ShowRoute(); 5410528Samuraiextern void TtyOldMode(), TtyCommandMode(); 556735Samuraiextern struct pppvars pppVars; 5614418Sacheextern struct cmdtab const SetCommands[]; 576059Samurai 586059Samuraistruct in_addr ifnetmask; 596059Samurai 606059Samuraistatic int ShowCommand(), TerminalCommand(), QuitCommand(); 616059Samuraistatic int CloseCommand(), DialCommand(), DownCommand(); 626059Samuraistatic int SetCommand(), AddCommand(), DeleteCommand(); 6310528Samuraistatic int ShellCommand(); 646059Samurai 656059Samuraistatic int 666059SamuraiHelpCommand(list, argc, argv, plist) 676059Samuraistruct cmdtab *list; 686059Samuraiint argc; 696059Samuraichar **argv; 706059Samuraistruct cmdtab *plist; 716059Samurai{ 726059Samurai struct cmdtab *cmd; 736059Samurai int n; 746059Samurai char c; 756059Samurai 766059Samurai if (argc > 0) { 776059Samurai for (cmd = plist; cmd->name; cmd++) { 786764Samurai if (strcmp(cmd->name, *argv) == 0 && (cmd->lauth & VarLocalAuth)) { 7914418Sache if (plist == SetCommands) 8014418Sache printf("set "); 816059Samurai printf("%s %s\n", cmd->name, cmd->syntax); 826059Samurai return(1); 836059Samurai } 846059Samurai } 856059Samurai return(1); 866059Samurai } 876059Samurai n = 0; 886059Samurai for (cmd = plist; cmd->func; cmd++) { 896764Samurai if (cmd->name && (cmd->lauth & VarLocalAuth)) { 906764Samurai c = (n & 1)? '\n' : '\t'; 916059Samurai printf(" %-8s: %-20s%c", cmd->name, cmd->helpmes, c); 926059Samurai n++; 936059Samurai } 946059Samurai } 956059Samurai if (n & 1) 966059Samurai printf("\n"); 976059Samurai return(1); 986059Samurai} 996059Samurai 1006059Samuraiint 1016059SamuraiIsInteractive() 1026059Samurai{ 1036059Samurai char *mes = NULL; 1046059Samurai 10520120Snate if (mode & MODE_DDIAL) 10620120Snate mes = "Working in dedicated dial mode."; 10720120Snate else if (mode & MODE_AUTO) 10810528Samurai mes = "Working in auto mode."; 1096059Samurai else if (mode & MODE_DIRECT) 11010528Samurai mes = "Working in direct mode."; 1116059Samurai else if (mode & MODE_DEDICATED) 11210528Samurai mes = "Working in dedicated mode."; 1136059Samurai if (mes) { 1146059Samurai printf("%s\n", mes); 1156059Samurai return(0); 1166059Samurai } 1176059Samurai return(1); 1186059Samurai} 1196059Samurai 1206059Samuraistatic int 1216059SamuraiDialCommand(cmdlist, argc, argv) 1226059Samuraistruct cmdtab *cmdlist; 1236059Samuraiint argc; 1246059Samuraichar **argv; 1256059Samurai{ 12611336Samurai int tries; 12711336Samurai 1286059Samurai if (LcpFsm.state > ST_CLOSED) { 1296059Samurai printf("LCP state is [%s]\n", StateNames[LcpFsm.state]); 1306059Samurai return(1); 1316059Samurai } 1326059Samurai if (!IsInteractive()) 1336059Samurai return(1); 1346735Samurai if (argc > 0) { 1356735Samurai if (SelectSystem(*argv, CONFFILE) < 0) { 1366735Samurai printf("%s: not found.\n", *argv); 1376735Samurai return(1); 1386735Samurai } 1396735Samurai } 14011336Samurai tries = 0; 14111336Samurai do { 14211336Samurai printf("Dial attempt %u\n", ++tries); 14311336Samurai modem = OpenModem(mode); 14411336Samurai if (modem < 0) { 14511336Samurai printf("failed to open modem.\n"); 14611336Samurai modem = 0; 14711336Samurai break; 14811336Samurai } 14911336Samurai if (DialModem()) { 15011336Samurai sleep(1); 15111336Samurai ModemTimeout(); 15211336Samurai PacketMode(); 15311336Samurai break; 15411336Samurai } 15511336Samurai } while (VarDialTries == 0 || tries < VarDialTries); 1566059Samurai return(1); 1576059Samurai} 1586059Samurai 15910528Samuraistatic int 16010528SamuraiShellCommand(cmdlist, argc, argv) 16110528Samuraistruct cmdtab *cmdlist; 16210528Samuraiint argc; 16310528Samuraichar **argv; 16410528Samurai{ 16510528Samurai const char *shell; 16610528Samurai pid_t shpid; 16710528Samurai 16810528Samurai if((shell = getenv("SHELL")) == 0) { 16910528Samurai shell = _PATH_BSHELL; 17010528Samurai } 17118856Ssos#ifdef SHELL_ONLY_INTERACTIVELY 17210528Samurai#ifndef HAVE_SHELL_CMD_WITH_ANY_MODE 17310528Samurai if( mode != MODE_INTER) { 17410528Samurai fprintf(stdout, 17518911Ssos "Can only start a shell in interactive mode\n"); 17610528Samurai return(1); 17710528Samurai } 17810528Samurai#else 17910528Samurai if(argc == 0 && !(mode & MODE_INTER)) { 18010528Samurai fprintf(stderr, 18118911Ssos "Can only start an interactive shell in interactive mode\n"); 18210528Samurai return(1); 18310528Samurai } 18410528Samurai#endif /* HAVE_SHELL_CMD_WITH_ANY_MODE */ 18518911Ssos#else 18618911Ssos if ((mode & (MODE_AUTO|MODE_INTER)) == (MODE_AUTO|MODE_INTER)) { 18718911Ssos fprintf(stdout, 18818911Ssos "Shell is not allowed interactively in auto mode\n"); 18918911Ssos return(1); 19018911Ssos } 19118856Ssos#endif /* SHELL_ONLY_INTERACTIVELY */ 19210528Samurai if((shpid = fork()) == 0) { 19318531Sbde int dtablesize, i ; 19418531Sbde 19518531Sbde for (dtablesize = getdtablesize(), i = 3; i < dtablesize; i++) 19610528Samurai (void)close(i); 19710528Samurai 19810528Samurai /* 19910528Samurai * We are running setuid, we should change to 20010528Samurai * real user for avoiding security problems. 20110528Samurai */ 20216263Sache if (setgid(getgid()) < 0) { 20316263Sache perror("setgid"); 20416263Sache exit(1); 20516263Sache } 20616263Sache if (setuid(getuid()) < 0) { 20716263Sache perror("setuid"); 20816263Sache exit(1); 20916263Sache } 21010528Samurai TtyOldMode(); 21118790Ssos if(argc > 0) { 21218790Ssos /* substitute pseudo args */ 21318790Ssos for (i=1; i<argc; i++) { 21418790Ssos if (strcmp(argv[i], "HISADDR") == 0) { 21518790Ssos argv[i] = strdup(inet_ntoa(IpcpInfo.his_ipaddr)); 21618790Ssos } 21718790Ssos if (strcmp(argv[i], "MYADDR") == 0) { 21818790Ssos argv[i] = strdup(inet_ntoa(IpcpInfo.want_ipaddr)); 21918790Ssos } 22018790Ssos } 22110528Samurai execvp(argv[0], argv); 22218790Ssos } 22310528Samurai else 22410528Samurai execl(shell, shell, NULL); 22510528Samurai 22610528Samurai fprintf(stdout, "exec() of %s failed\n", argc > 0? argv[0]: shell); 22710528Samurai exit(255); 22810528Samurai } 22910528Samurai if( shpid == (pid_t)-1 ) { 23010528Samurai fprintf(stdout, "Fork failed\n"); 23110528Samurai } else { 23210528Samurai int status; 23310528Samurai (void)waitpid(shpid, &status, 0); 23410528Samurai } 23510528Samurai 23610528Samurai TtyCommandMode(1); 23710528Samurai 23810528Samurai return(0); 23910528Samurai} 24010528Samurai 2416059Samuraistatic char StrOption[] = "option .."; 2426059Samuraistatic char StrRemote[] = "[remote]"; 2436059Samuraichar StrNull[] = ""; 2446059Samurai 24513760Sphkstruct cmdtab const Commands[] = { 2466735Samurai { "accept", NULL, AcceptCommand, LOCAL_AUTH, 2476735Samurai "accept option request", StrOption}, 2486735Samurai { "add", NULL, AddCommand, LOCAL_AUTH, 2496735Samurai "add route", "dest mask gateway"}, 2506735Samurai { "close", NULL, CloseCommand, LOCAL_AUTH, 2516735Samurai "Close connection", StrNull}, 2526735Samurai { "delete", NULL, DeleteCommand, LOCAL_AUTH, 25314418Sache "delete route", "ALL | dest gateway [mask]"}, 2546735Samurai { "deny", NULL, DenyCommand, LOCAL_AUTH, 2556735Samurai "Deny option request", StrOption}, 2566735Samurai { "dial", "call", DialCommand, LOCAL_AUTH, 2576735Samurai "Dial and login", StrRemote}, 2586735Samurai { "disable", NULL, DisableCommand, LOCAL_AUTH, 2596735Samurai "Disable option", StrOption}, 2606735Samurai { "display", NULL, DisplayCommand, LOCAL_AUTH, 2616735Samurai "Display option configs", StrNull}, 2626735Samurai { "enable", NULL, EnableCommand, LOCAL_AUTH, 2636735Samurai "Enable option", StrOption}, 2646764Samurai { "passwd", NULL, LocalAuthCommand,LOCAL_NO_AUTH, 2659240Sphk "Password for manipulation", StrOption}, 2666735Samurai { "load", NULL, LoadCommand, LOCAL_AUTH, 2676735Samurai "Load settings", StrRemote}, 2686735Samurai { "save", NULL, SaveCommand, LOCAL_AUTH, 2696735Samurai "Save settings", StrNull}, 2706735Samurai { "set", "setup", SetCommand, LOCAL_AUTH, 2716735Samurai "Set parameters", "var value"}, 27210528Samurai { "shell", "!", ShellCommand, LOCAL_AUTH, 27310528Samurai "Run a subshell", "[sh command]"}, 2746735Samurai { "show", NULL, ShowCommand, LOCAL_AUTH, 2756735Samurai "Show status and statictics", "var"}, 2766735Samurai { "term", NULL, TerminalCommand,LOCAL_AUTH, 2776735Samurai "Enter to terminal mode", StrNull}, 2786764Samurai { "quit", "bye", QuitCommand, LOCAL_AUTH | LOCAL_NO_AUTH, 27914418Sache "Quit PPP program", "[all]"}, 2806735Samurai { "help", "?", HelpCommand, LOCAL_AUTH | LOCAL_NO_AUTH, 2816059Samurai "Display this message", "[command]", (void *)Commands }, 2826735Samurai { NULL, "down", DownCommand, LOCAL_AUTH, 2836735Samurai "Generate down event", StrNull}, 2846059Samurai { NULL, NULL, NULL }, 2856059Samurai}; 2866059Samurai 2876059Samuraiextern int ReportCcpStatus(); 2886059Samuraiextern int ReportLcpStatus(); 2896059Samuraiextern int ReportIpcpStatus(); 2906059Samuraiextern int ReportProtStatus(); 2916059Samuraiextern int ReportCompress(); 2926059Samuraiextern int ShowModemStatus(); 2936059Samuraiextern int ReportHdlcStatus(); 2946059Samuraiextern int ShowMemMap(); 2956059Samurai 2966059Samuraistatic char *LogLevelName[] = { 29715738Sphk LM_PHASE, LM_CHAT, LM_LQM, LM_LCP, 29815738Sphk LM_TCPIP, LM_HDLC, LM_ASYNC, LM_LINK, 29915738Sphk LM_CONNECT, LM_CARRIER, 3006059Samurai}; 3016059Samurai 3026059Samuraistatic int ShowDebugLevel() 3036059Samurai{ 3046059Samurai int i; 3056059Samurai 3066059Samurai printf("%02x: ", loglevel); 3076059Samurai for (i = LOG_PHASE; i < MAXLOGLEVEL; i++) { 3086059Samurai if (loglevel & (1 << i)) 3096059Samurai printf("%s ", LogLevelName[i]); 3106059Samurai } 3116059Samurai printf("\n"); 3126059Samurai return(1); 3136059Samurai} 3146059Samurai 3156059Samuraistatic int ShowEscape() 3166059Samurai{ 3176059Samurai int code, bit; 3186059Samurai 3196059Samurai if (EscMap[32]) { 3206059Samurai for (code = 0; code < 32; code++) { 3216059Samurai if (EscMap[code]) { 3226059Samurai for (bit = 0; bit < 8; bit++) { 3236059Samurai if (EscMap[code] & (1<<bit)) { 3246059Samurai printf(" 0x%02x", (code << 3) + bit); 3256059Samurai } 3266059Samurai } 3276059Samurai } 3286059Samurai } 3296059Samurai printf("\n"); 3306059Samurai } 3316059Samurai return(1); 3326059Samurai} 3336059Samurai 3346059Samuraistatic int ShowTimeout() 3356059Samurai{ 3366735Samurai printf(" Idle Timer: %d secs LQR Timer: %d secs Retry Timer: %d secs\n", 3376735Samurai VarIdleTimeout, VarLqrTimeout, VarRetryTimeout); 3386059Samurai return(1); 3396059Samurai} 3406059Samurai 3416059Samuraistatic int ShowAuthKey() 3426059Samurai{ 3436059Samurai printf("AuthName = %s\n", VarAuthName); 3446059Samurai printf("AuthKey = %s\n", VarAuthKey); 3456059Samurai return(1); 3466059Samurai} 3476059Samurai 3486059Samuraistatic int ShowVersion() 3496059Samurai{ 35013389Sphk extern char VarVersion[]; 35113389Sphk extern char VarLocalVersion[]; 3526059Samurai 3539448Samurai printf("%s - %s \n", VarVersion, VarLocalVersion); 3546059Samurai return(1); 3556059Samurai} 3566059Samurai 3576059Samuraistatic int ShowLogList() 3586059Samurai{ 3596059Samurai ListLog(); 3606059Samurai return(1); 3616059Samurai} 3626059Samurai 36311336Samuraistatic int ShowRedial() 36411336Samurai{ 36511336Samurai printf(" Redial Timer: "); 36611336Samurai 36711336Samurai if (VarRedialTimeout >= 0) { 36811336Samurai printf(" %d seconds, ", VarRedialTimeout); 36911336Samurai } 37011336Samurai else { 37111336Samurai printf(" Random 0 - %d seconds, ", REDIAL_PERIOD); 37211336Samurai } 37311336Samurai 37411336Samurai if (VarDialTries) 37511336Samurai printf("%d dial tries", VarDialTries); 37611336Samurai 37711336Samurai printf("\n"); 37811336Samurai 37911336Samurai return(1); 38011336Samurai} 38111336Samurai 38218752Sjkh#ifdef MSEXT 38318752Sjkhstatic int ShowMSExt() 38418752Sjkh{ 38518752Sjkh printf(" MS PPP extention values \n" ); 38618752Sjkh printf(" Primary NS : %s\n", inet_ntoa( ns_entries[0] )); 38718752Sjkh printf(" Secondary NS : %s\n", inet_ntoa( ns_entries[1] )); 38818752Sjkh printf(" Primary NBNS : %s\n", inet_ntoa( nbns_entries[0] )); 38918752Sjkh printf(" Secondary NBNS : %s\n", inet_ntoa( nbns_entries[1] )); 39011336Samurai 39118752Sjkh return(1); 39218752Sjkh} 39318752Sjkh#endif /* MSEXT */ 39418752Sjkh 3956735Samuraiextern int ShowIfilter(), ShowOfilter(), ShowDfilter(), ShowAfilter(); 3966059Samurai 39713760Sphkstruct cmdtab const ShowCommands[] = { 3986735Samurai { "afilter", NULL, ShowAfilter, LOCAL_AUTH, 3996735Samurai "Show keep Alive filters", StrOption}, 4006735Samurai { "auth", NULL, ShowAuthKey, LOCAL_AUTH, 4016735Samurai "Show auth name/key", StrNull}, 4026735Samurai { "ccp", NULL, ReportCcpStatus, LOCAL_AUTH, 4036735Samurai "Show CCP status", StrNull}, 4046735Samurai { "compress", NULL, ReportCompress, LOCAL_AUTH, 4056735Samurai "Show compression statictics", StrNull}, 4066735Samurai { "debug", NULL, ShowDebugLevel, LOCAL_AUTH, 4076735Samurai "Show current debug level", StrNull}, 4086735Samurai { "dfilter", NULL, ShowDfilter, LOCAL_AUTH, 4096735Samurai "Show Demand filters", StrOption}, 4106735Samurai { "escape", NULL, ShowEscape, LOCAL_AUTH, 4116735Samurai "Show escape characters", StrNull}, 4126735Samurai { "hdlc", NULL, ReportHdlcStatus, LOCAL_AUTH, 4136735Samurai "Show HDLC error summary", StrNull}, 4146735Samurai { "ifilter", NULL, ShowIfilter, LOCAL_AUTH, 4156735Samurai "Show Input filters", StrOption}, 4166735Samurai { "ipcp", NULL, ReportIpcpStatus, LOCAL_AUTH, 4176735Samurai "Show IPCP status", StrNull}, 4186735Samurai { "lcp", NULL, ReportLcpStatus, LOCAL_AUTH, 4196735Samurai "Show LCP status", StrNull}, 4206735Samurai { "log", NULL, ShowLogList, LOCAL_AUTH, 4216735Samurai "Show log records", StrNull}, 4226735Samurai { "mem", NULL, ShowMemMap, LOCAL_AUTH, 4236735Samurai "Show memory map", StrNull}, 4246735Samurai { "modem", NULL, ShowModemStatus, LOCAL_AUTH, 4256735Samurai "Show modem setups", StrNull}, 4266735Samurai { "ofilter", NULL, ShowOfilter, LOCAL_AUTH, 4276735Samurai "Show Output filters", StrOption}, 4286735Samurai { "proto", NULL, ReportProtStatus, LOCAL_AUTH, 4296735Samurai "Show protocol summary", StrNull}, 4306735Samurai { "route", NULL, ShowRoute, LOCAL_AUTH, 4316735Samurai "Show routing table", StrNull}, 4326735Samurai { "timeout", NULL, ShowTimeout, LOCAL_AUTH, 4336735Samurai "Show Idle timeout value", StrNull}, 43411336Samurai { "redial", NULL, ShowRedial, LOCAL_AUTH, 43511336Samurai "Show Redial timeout value", StrNull}, 43618752Sjkh#ifdef MSEXT 43718752Sjkh { "msext", NULL, ShowMSExt, LOCAL_AUTH, 43818752Sjkh "Show MS PPP extention values", StrNull}, 43918752Sjkh#endif /* MSEXT */ 4406735Samurai { "version", NULL, ShowVersion, LOCAL_NO_AUTH | LOCAL_AUTH, 4416735Samurai "Show version string", StrNull}, 4426735Samurai { "help", "?", HelpCommand, LOCAL_NO_AUTH | LOCAL_AUTH, 4436735Samurai "Display this message", StrNull, (void *)ShowCommands}, 4446059Samurai { NULL, NULL, NULL }, 4456059Samurai}; 4466059Samurai 4476059Samuraistruct cmdtab * 4486059SamuraiFindCommand(cmds, str, pmatch) 4496059Samuraistruct cmdtab *cmds; 4506059Samuraichar *str; 4516059Samuraiint *pmatch; 4526059Samurai{ 4536059Samurai int nmatch = 0; 4546059Samurai int len = strlen(str); 4556059Samurai struct cmdtab *found = NULL; 4566059Samurai 4576059Samurai while (cmds->func) { 4586059Samurai if (cmds->name && strncmp(str, cmds->name, len) == 0) { 4596059Samurai nmatch++; 4606059Samurai found = cmds; 4616059Samurai } else if (cmds->alias && strncmp(str, cmds->alias, len) == 0) { 4626059Samurai nmatch++; 4636059Samurai found = cmds; 4646059Samurai } 4656059Samurai cmds++; 4666059Samurai } 4676059Samurai *pmatch = nmatch; 4686059Samurai return(found); 4696059Samurai} 4706059Samurai 4716059Samuraiint 4726059SamuraiFindExec(cmdlist, argc, argv) 4736059Samuraistruct cmdtab *cmdlist; 4746059Samuraiint argc; 4756059Samuraichar **argv; 4766059Samurai{ 4776059Samurai struct cmdtab *cmd; 4786059Samurai int val = 1; 4796059Samurai int nmatch; 4806059Samurai 4816059Samurai cmd = FindCommand(cmdlist, *argv, &nmatch); 4826059Samurai if (nmatch > 1) 4836735Samurai printf("Ambiguous.\n"); 4846735Samurai else if (cmd && ( cmd->lauth & VarLocalAuth ) ) 4856059Samurai val = (cmd->func)(cmd, --argc, ++argv, cmd->args); 4866059Samurai else 4876059Samurai printf("what?\n"); 4886059Samurai return(val); 4896059Samurai} 4906059Samurai 49118885Sjkhint aft_cmd = 1; 49218885Sjkh 4936059Samuraivoid 49418885SjkhPrompt() 4956059Samurai{ 4966735Samurai char *pconnect, *pauth; 4976735Samurai 4986059Samurai if (!(mode & MODE_INTER)) 4996059Samurai return; 5006735Samurai 50118885Sjkh if (!aft_cmd) 50218885Sjkh printf("\n"); 50318885Sjkh else 50418885Sjkh aft_cmd = 0; 5056735Samurai 5066735Samurai if ( VarLocalAuth == LOCAL_AUTH ) 5076735Samurai pauth = " ON "; 5086735Samurai else 5096735Samurai pauth = " on "; 5106059Samurai if (IpcpFsm.state == ST_OPENED && phase == PHASE_NETWORK) 5116735Samurai pconnect = "PPP"; 5126059Samurai else 5136735Samurai pconnect = "ppp"; 5146735Samurai printf("%s%s%s> ", pconnect, pauth, VarShortHost); 5156059Samurai fflush(stdout); 5166059Samurai} 5176059Samurai 5186059Samuraivoid 5196059SamuraiDecodeCommand(buff, nb, prompt) 5206059Samuraichar *buff; 5216059Samuraiint nb; 5226059Samuraiint prompt; 5236059Samurai{ 5246059Samurai char *vector[20]; 5256059Samurai char **argv; 5266059Samurai int argc, val; 5276059Samurai char *cp; 5286059Samurai 5296059Samurai val = 1; 5306059Samurai if (nb > 0) { 5316059Samurai cp = buff + strcspn(buff, "\r\n"); 5326059Samurai if (cp) 5336059Samurai *cp = '\0'; 5346059Samurai { 5356059Samurai argc = MakeArgs(buff, &vector); 5366059Samurai argv = vector; 5376059Samurai 5386059Samurai if (argc > 0) 5396059Samurai val = FindExec(Commands, argc, argv); 5406059Samurai } 5416059Samurai } 5426059Samurai if (val && prompt) 5436059Samurai Prompt(0); 5446059Samurai} 5456059Samurai 5466059Samuraistatic int 5476059SamuraiShowCommand(list, argc, argv) 5486059Samuraistruct cmdtab *list; 5496059Samuraiint argc; 5506059Samuraichar **argv; 5516059Samurai{ 5526059Samurai int val = 1; 5536059Samurai 5546059Samurai if (argc > 0) 5556059Samurai val = FindExec(ShowCommands, argc, argv); 5566059Samurai else 5576059Samurai printf("Use ``show ?'' to get a list.\n"); 5586059Samurai return(val); 5596059Samurai} 5606059Samurai 5616059Samuraistatic int 5626059SamuraiTerminalCommand() 5636059Samurai{ 5646059Samurai if (LcpFsm.state > ST_CLOSED) { 5656059Samurai printf("LCP state is [%s]\n", StateNames[LcpFsm.state]); 5666059Samurai return(1); 5676059Samurai } 5686059Samurai if (!IsInteractive()) 5696059Samurai return(1); 5706059Samurai modem = OpenModem(mode); 5716059Samurai if (modem < 0) { 5726059Samurai printf("failed to open modem.\n"); 5736059Samurai modem = 0; 5746059Samurai return(1); 5756059Samurai } 5766059Samurai printf("Enter to terminal mode.\n"); 5776059Samurai printf("Type `~?' for help.\n"); 5786059Samurai TtyTermMode(); 5796059Samurai return(0); 5806059Samurai} 5816059Samurai 5826059Samuraistatic int 5836059SamuraiQuitCommand(list, argc, argv) 5846059Samuraistruct cmdtab *list; 5856059Samuraiint argc; 5866059Samuraichar **argv; 5876059Samurai{ 5886059Samurai if (mode & (MODE_DIRECT|MODE_DEDICATED|MODE_AUTO)) { 5896764Samurai if (argc > 0 && (VarLocalAuth & LOCAL_AUTH)) { 5906059Samurai Cleanup(EX_NORMAL); 59118911Ssos mode &= ~MODE_INTER; 5926059Samurai } else { 5936735Samurai VarLocalAuth = LOCAL_NO_AUTH; 5946059Samurai close(netfd); 5956059Samurai close(1); 5967886Samurai dup2(2, 1); /* Have to have something here or the modem will be 1 */ 5976059Samurai netfd = -1; 5986059Samurai mode &= ~MODE_INTER; 5996059Samurai } 6006059Samurai } else 6016059Samurai Cleanup(EX_NORMAL); 6026059Samurai return(1); 6036059Samurai} 6046059Samurai 6056059Samuraistatic int 6066059SamuraiCloseCommand() 6076059Samurai{ 6086059Samurai LcpClose(); 6096059Samurai return(1); 6106059Samurai} 6116059Samurai 6126059Samuraistatic int 6136059SamuraiDownCommand() 6146059Samurai{ 6156059Samurai LcpDown(); 6166059Samurai return(1); 6176059Samurai} 6186059Samurai 6196059Samuraistatic int SetModemSpeed(list, argc, argv) 6206059Samuraistruct cmdtab *list; 6216059Samuraiint argc; 6226059Samuraichar **argv; 6236059Samurai{ 6246059Samurai int speed; 6256059Samurai 6266059Samurai if (argc > 0) { 6276735Samurai if (strcmp(*argv, "sync") == 0) { 6286735Samurai VarSpeed = 0; 6296735Samurai return(1); 6306735Samurai } 6316059Samurai speed = atoi(*argv); 6326735Samurai if (IntToSpeed(speed) != B0) { 6336735Samurai VarSpeed = speed; 6346735Samurai return(1); 6356059Samurai } 6366059Samurai printf("invalid speed.\n"); 6376059Samurai } 6386059Samurai return(1); 6396059Samurai} 6406059Samurai 64111336Samuraistatic int SetRedialTimeout(list, argc, argv) 64211336Samuraistruct cmdtab *list; 64311336Samuraiint argc; 64411336Samuraichar **argv; 64511336Samurai{ 64611336Samurai int timeout; 64711336Samurai int tries; 64811336Samurai 64911336Samurai if (argc == 1 || argc == 2 ) { 65011336Samurai if (strcasecmp(argv[0], "random") == 0) { 65111336Samurai VarRedialTimeout = -1; 65211336Samurai printf("Using random redial timeout.\n"); 65311336Samurai srandom(time(0)); 65411336Samurai } 65511336Samurai else { 65611336Samurai timeout = atoi(argv[0]); 65711336Samurai 65811336Samurai if (timeout >= 0) { 65911336Samurai VarRedialTimeout = timeout; 66011336Samurai } 66111336Samurai else { 66211336Samurai printf("invalid redial timeout\n"); 66311336Samurai printf("Usage: %s %s\n", list->name, list->syntax); 66411336Samurai } 66511336Samurai } 66611336Samurai if (argc == 2) { 66711336Samurai tries = atoi(argv[1]); 66811336Samurai 66911336Samurai if (tries >= 0) { 67011336Samurai VarDialTries = tries; 67111336Samurai } 67211336Samurai else { 67311336Samurai printf("invalid retry value\n"); 67411336Samurai printf("Usage: %s %s\n", list->name, list->syntax); 67511336Samurai } 67611336Samurai } 67711336Samurai } 67811336Samurai else { 67911336Samurai printf("Usage: %s %s\n", list->name, list->syntax); 68011336Samurai } 68111336Samurai return(1); 68211336Samurai} 68311336Samurai 6846059Samuraistatic int SetModemParity(list, argc, argv) 6856059Samuraistruct cmdtab *list; 6866059Samuraiint argc; 6876059Samuraichar **argv; 6886059Samurai{ 6896059Samurai int parity; 6906059Samurai 6916059Samurai if (argc > 0) { 6926059Samurai parity = ChangeParity(*argv); 6936059Samurai if (parity < 0) 6946059Samurai printf("Invalid parity.\n"); 6956059Samurai else 6966059Samurai VarParity = parity; 6976059Samurai } 6986059Samurai return(1); 6996059Samurai} 7006059Samurai 7016059Samuraistatic int 7026059SamuraiSetDebugLevel(list, argc, argv) 7036059Samuraistruct cmdtab *list; 7046059Samuraiint argc; 7056059Samuraichar **argv; 7066059Samurai{ 7076059Samurai int level, w; 7086059Samurai 7096059Samurai for (level = 0; argc-- > 0; argv++) { 7106059Samurai if (isdigit(**argv)) { 7116059Samurai w = atoi(*argv); 7126059Samurai if (w < 0 || w >= MAXLOGLEVEL) { 7136059Samurai printf("invalid log level.\n"); 7146059Samurai break; 7156059Samurai } else 7166059Samurai level |= (1 << w); 7176059Samurai } else { 7186059Samurai for (w = 0; w < MAXLOGLEVEL; w++) { 7196059Samurai if (strcasecmp(*argv, LogLevelName[w]) == 0) { 7206059Samurai level |= (1 << w); 7216059Samurai continue; 7226059Samurai } 7236059Samurai } 7246059Samurai } 7256059Samurai } 7266059Samurai loglevel = level; 7276059Samurai return(1); 7286059Samurai} 7296059Samurai 7306059Samuraistatic int 7316059SamuraiSetEscape(list, argc, argv) 7326059Samuraistruct cmdtab *list; 7336059Samuraiint argc; 7346059Samuraichar **argv; 7356059Samurai{ 7366059Samurai int code; 7376059Samurai 7386059Samurai for (code = 0; code < 33; code++) 7396059Samurai EscMap[code] = 0; 7406059Samurai while (argc-- > 0) { 7416059Samurai sscanf(*argv++, "%x", &code); 7426059Samurai code &= 0xff; 7436059Samurai EscMap[code >> 3] |= (1 << (code&7)); 7446059Samurai EscMap[32] = 1; 7456059Samurai } 7466059Samurai return(1); 7476059Samurai} 7486059Samurai 7496059Samuraistatic int 7506059SamuraiSetInitialMRU(list, argc, argv) 7516059Samuraistruct cmdtab *list; 7526059Samuraiint argc; 7536059Samuraichar **argv; 7546059Samurai{ 7556059Samurai int mru; 7566059Samurai 7576059Samurai if (argc > 0) { 7586059Samurai mru = atoi(*argv); 7596059Samurai if (mru < 100) 7606059Samurai printf("given value is too small.\n"); 7616059Samurai else if (mru > MAX_MRU) 7626059Samurai printf("given value is too big.\n"); 7636059Samurai else 7646059Samurai VarMRU = mru; 7656059Samurai } 7666059Samurai return(1); 7676059Samurai} 7686059Samurai 7696059Samuraistatic int 7706059SamuraiSetIdleTimeout(list, argc, argv) 7716059Samuraistruct cmdtab *list; 7726059Samuraiint argc; 7736059Samuraichar **argv; 7746059Samurai{ 7756059Samurai if (argc-- > 0) { 7766059Samurai VarIdleTimeout = atoi(*argv++); 7776735Samurai if (argc-- > 0) { 7786735Samurai VarLqrTimeout = atoi(*argv++); 7796735Samurai if (VarLqrTimeout < 1) 7806735Samurai VarLqrTimeout = 30; 7816735Samurai if (argc > 0) { 7826735Samurai VarRetryTimeout = atoi(*argv); 7836735Samurai if (VarRetryTimeout < 1 || VarRetryTimeout > 10) 7846735Samurai VarRetryTimeout = 3; 7856735Samurai } 7866735Samurai } 7876059Samurai } 7886059Samurai return(1); 7896059Samurai} 7906059Samurai 7916059Samuraistruct in_addr 7926059SamuraiGetIpAddr(cp) 7936059Samuraichar *cp; 7946059Samurai{ 7956059Samurai struct hostent *hp; 7966059Samurai struct in_addr ipaddr; 7976059Samurai 7986059Samurai hp = gethostbyname(cp); 7996059Samurai if (hp && hp->h_addrtype == AF_INET) 8006059Samurai bcopy(hp->h_addr, &ipaddr, hp->h_length); 8016059Samurai else if (inet_aton(cp, &ipaddr) == 0) 8026059Samurai ipaddr.s_addr = 0; 8036059Samurai return(ipaddr); 8046059Samurai} 8056059Samurai 8066059Samuraistatic int 8076059SamuraiSetInterfaceAddr(list, argc, argv) 8086059Samuraistruct cmdtab *list; 8096059Samuraiint argc; 8106059Samuraichar **argv; 8116059Samurai{ 8126059Samurai 8136059Samurai DefMyAddress.ipaddr.s_addr = DefHisAddress.ipaddr.s_addr = 0L; 8146059Samurai if (argc > 0) { 8156059Samurai ParseAddr(argc, argv++, 8166059Samurai &DefMyAddress.ipaddr, &DefMyAddress.mask, &DefMyAddress.width); 8176059Samurai if (--argc > 0) { 8186059Samurai ParseAddr(argc, argv++, 8196059Samurai &DefHisAddress.ipaddr, &DefHisAddress.mask, &DefHisAddress.width); 8206059Samurai if (--argc > 0) { 8216059Samurai ifnetmask = GetIpAddr(*argv); 8229440Samurai if (--argc > 0) { 8239440Samurai ParseAddr(argc, argv++, 8249440Samurai &DefTriggerAddress.ipaddr, 8259440Samurai &DefTriggerAddress.mask, 8269440Samurai &DefTriggerAddress.width); 8279440Samurai } 8286059Samurai } 8296059Samurai } 8306059Samurai } 8316059Samurai /* 8326059Samurai * For backwards compatibility, 0.0.0.0 means any address. 8336059Samurai */ 8346059Samurai if (DefMyAddress.ipaddr.s_addr == 0) { 8356059Samurai DefMyAddress.mask.s_addr = 0; 8366059Samurai DefMyAddress.width = 0; 8376059Samurai } 8386059Samurai if (DefHisAddress.ipaddr.s_addr == 0) { 8396059Samurai DefHisAddress.mask.s_addr = 0; 8406059Samurai DefHisAddress.width = 0; 8416059Samurai } 8426059Samurai 8436735Samurai if ((mode & MODE_AUTO) || 8446059Samurai ((mode & MODE_DEDICATED) && dstsystem)) { 8456059Samurai OsSetIpaddress(DefMyAddress.ipaddr, DefHisAddress.ipaddr, ifnetmask); 8466059Samurai } 8476059Samurai return(1); 8486059Samurai} 8496059Samurai 85018752Sjkh#ifdef MSEXT 8516059Samurai 85218752Sjkhvoid 85318752SjkhSetMSEXT(pri_addr, sec_addr, argc, argv) 85418752Sjkhstruct in_addr *pri_addr; 85518752Sjkhstruct in_addr *sec_addr; 85618752Sjkhint argc; 85718752Sjkhchar **argv; 85818752Sjkh{ 85918752Sjkh int dummyint; 86018752Sjkh struct in_addr dummyaddr; 86118752Sjkh 86218752Sjkh pri_addr->s_addr = sec_addr->s_addr = 0L; 86318752Sjkh 86418752Sjkh if( argc > 0 ) { 86518752Sjkh ParseAddr(argc, argv++, pri_addr, &dummyaddr, &dummyint); 86618752Sjkh if( --argc > 0 ) 86718752Sjkh ParseAddr(argc, argv++, sec_addr, &dummyaddr, &dummyint); 86818752Sjkh else 86918752Sjkh sec_addr->s_addr = pri_addr->s_addr; 87018752Sjkh } 87118752Sjkh 87218752Sjkh /* 87318752Sjkh * if the primary/secondary ns entries are 0.0.0.0 we should 87418752Sjkh * set them to either the localhost's ip, or the values in 87518752Sjkh * /etc/resolv.conf ?? 87618752Sjkh * 87718752Sjkh * up to you if you want to implement this... 87818752Sjkh */ 87918752Sjkh 88018752Sjkh} 88118752Sjkh 88218752Sjkhstatic int 88318752SjkhSetNS(list, argc, argv) 88418752Sjkhstruct cmdtab *list; 88518752Sjkhint argc; 88618752Sjkhchar **argv; 88718752Sjkh{ 88818752Sjkh SetMSEXT(&ns_entries[0], &ns_entries[1], argc, argv); 88918752Sjkh return(1); 89018752Sjkh} 89118752Sjkh 89218752Sjkhstatic int 89318752SjkhSetNBNS(list, argc, argv) 89418752Sjkhstruct cmdtab *list; 89518752Sjkhint argc; 89618752Sjkhchar **argv; 89718752Sjkh{ 89818752Sjkh SetMSEXT(&nbns_entries[0], &nbns_entries[1], argc, argv); 89918752Sjkh return(1); 90018752Sjkh} 90118752Sjkh 90218752Sjkh#endif /* MS_EXT */ 90318752Sjkh 9046059Samurai#define VAR_AUTHKEY 0 9056059Samurai#define VAR_DIAL 1 9066059Samurai#define VAR_LOGIN 2 9076059Samurai#define VAR_AUTHNAME 3 9086059Samurai#define VAR_DEVICE 4 9096059Samurai#define VAR_ACCMAP 5 9106059Samurai#define VAR_PHONE 6 9116059Samurai 9126059Samuraistatic int 9136059SamuraiSetVariable(list, argc, argv, param) 9146059Samuraistruct cmdtab *list; 9156059Samuraiint argc; 9166059Samuraichar **argv; 9176059Samuraiint param; 9186059Samurai{ 9196059Samurai u_long map; 9206059Samurai 9216059Samurai if (argc > 0) { 9226059Samurai switch (param) { 9236059Samurai case VAR_AUTHKEY: 9246059Samurai strncpy(VarAuthKey, *argv, sizeof(VarAuthKey)-1); 9256059Samurai break; 9266059Samurai case VAR_AUTHNAME: 9276059Samurai strncpy(VarAuthName, *argv, sizeof(VarAuthName)-1); 9286059Samurai break; 9296059Samurai case VAR_DIAL: 9306059Samurai strncpy(VarDialScript, *argv, sizeof(VarDialScript)-1); 9316059Samurai break; 9326059Samurai case VAR_LOGIN: 9336059Samurai strncpy(VarLoginScript, *argv, sizeof(VarDialScript)-1); 9346059Samurai break; 9356059Samurai case VAR_DEVICE: 9366059Samurai strncpy(VarDevice, *argv, sizeof(VarDevice)-1); 9376059Samurai break; 9386059Samurai case VAR_ACCMAP: 93913389Sphk sscanf(*argv, "%lx", &map); 9406059Samurai VarAccmap = map; 9416059Samurai break; 9426059Samurai case VAR_PHONE: 94314418Sache strncpy(VarPhoneList, *argv, sizeof(VarPhoneList)-1); 94414423Sache strcpy(VarPhoneCopy, VarPhoneList); 94514423Sache VarNextPhone = VarPhoneCopy; 9466059Samurai break; 9476059Samurai } 9486059Samurai } 9496059Samurai return(1); 9506059Samurai} 9516059Samurai 9526059Samuraistatic int SetOpenMode(list, argc, argv) 9536059Samuraistruct cmdtab *list; 9546059Samuraiint argc; 9556059Samuraichar **argv; 9566059Samurai{ 9576059Samurai if (argc > 0) { 9586059Samurai if (strcmp(*argv, "active") == 0) 9596059Samurai VarOpenMode = OPEN_ACTIVE; 9606059Samurai else if (strcmp(*argv, "passive") == 0) 9616059Samurai VarOpenMode = OPEN_PASSIVE; 9626059Samurai else 9636059Samurai printf("Invalid mode.\n"); 9646059Samurai } 9656059Samurai return(1); 9666059Samurai} 9676059Samurai 9686059Samuraistatic char StrChatStr[] = "chat-script"; 9696059Samuraistatic char StrValue[] = "value"; 9706059Samurai 9716735Samuraiextern int SetIfilter(), SetOfilter(), SetDfilter(), SetAfilter(); 9726059Samurai 97313760Sphkstruct cmdtab const SetCommands[] = { 9746735Samurai { "accmap", NULL, SetVariable, LOCAL_AUTH, 9756735Samurai "Set accmap value", "hex-value", (void *)VAR_ACCMAP}, 9766735Samurai { "afilter", NULL, SetAfilter, LOCAL_AUTH, 9776735Samurai "Set keep Alive filter", "..."}, 9786735Samurai { "authkey", "key", SetVariable, LOCAL_AUTH, 9796735Samurai "Set authentication key", "key", (void *)VAR_AUTHKEY}, 9806735Samurai { "authname", NULL, SetVariable, LOCAL_AUTH, 9816735Samurai "Set authentication name", "name", (void *)VAR_AUTHNAME}, 9826735Samurai { "debug", NULL, SetDebugLevel, LOCAL_AUTH, 9836735Samurai "Set debug level", StrValue}, 9846735Samurai { "device", "line", SetVariable, LOCAL_AUTH, 9856735Samurai "Set modem device name", "device-name", (void *)VAR_DEVICE}, 9866735Samurai { "dfilter", NULL, SetDfilter, LOCAL_AUTH, 9876735Samurai "Set demand filter", "..."}, 9886735Samurai { "dial", NULL, SetVariable, LOCAL_AUTH, 9896735Samurai "Set dialing script", StrChatStr, (void *)VAR_DIAL}, 9906735Samurai { "escape", NULL, SetEscape, LOCAL_AUTH, 9916735Samurai "Set escape characters", "hex-digit ..."}, 9926735Samurai { "ifaddr", NULL, SetInterfaceAddr, LOCAL_AUTH, 99314418Sache "Set destination address", "[src-addr [dst-addr [netmask [trg-addr]]]]"}, 9946735Samurai { "ifilter", NULL, SetIfilter, LOCAL_AUTH, 9956735Samurai "Set input filter", "..."}, 9966735Samurai { "login", NULL, SetVariable, LOCAL_AUTH, 9976735Samurai "Set login script", StrChatStr, (void *)VAR_LOGIN }, 9986735Samurai { "mru", "mtu", SetInitialMRU, LOCAL_AUTH, 9996735Samurai "Set Initial MRU value", StrValue }, 10006735Samurai { "ofilter", NULL, SetOfilter, LOCAL_AUTH, 10016735Samurai "Set output filter", "..." }, 10026735Samurai { "openmode", NULL, SetOpenMode, LOCAL_AUTH, 10036735Samurai "Set open mode", "[active|passive]"}, 10046735Samurai { "parity", NULL, SetModemParity, LOCAL_AUTH, 10056735Samurai "Set modem parity", "[odd|even|none]"}, 10066735Samurai { "phone", NULL, SetVariable, LOCAL_AUTH, 100714418Sache "Set telephone number(s)", "phone1[:phone2[...]]", (void *)VAR_PHONE }, 10086735Samurai { "speed", NULL, SetModemSpeed, LOCAL_AUTH, 10096735Samurai "Set modem speed", "speed"}, 10106735Samurai { "timeout", NULL, SetIdleTimeout, LOCAL_AUTH, 10116735Samurai "Set Idle timeout", StrValue}, 101211336Samurai { "redial", NULL, SetRedialTimeout, LOCAL_AUTH, 101311336Samurai "Set Redial timeout", "value|random [dial_attempts]"}, 101418752Sjkh#ifdef MSEXT 101518752Sjkh { "ns", NULL, SetNS, LOCAL_AUTH, 101618752Sjkh "Set NameServer", "pri-addr [sec-addr]"}, 101718752Sjkh { "nbns", NULL, SetNBNS, LOCAL_AUTH, 101818752Sjkh "Set NetBIOS NameServer", "pri-addr [sec-addr]"}, 101918752Sjkh#endif /* MSEXT */ 10206735Samurai { "help", "?", HelpCommand, LOCAL_AUTH | LOCAL_NO_AUTH, 10216735Samurai "Display this message", StrNull, (void *)SetCommands}, 10226059Samurai { NULL, NULL, NULL }, 10236059Samurai}; 10246059Samurai 10256059Samuraistatic int 10266059SamuraiSetCommand(list, argc, argv) 10276059Samuraistruct cmdtab *list; 10286059Samuraiint argc; 10296059Samuraichar **argv; 10306059Samurai{ 10316059Samurai int val = 1; 10326059Samurai 10336059Samurai if (argc > 0) 10346059Samurai val = FindExec(SetCommands, argc, argv); 10356059Samurai else 103614418Sache printf("Use `set ?' to get a list or `set ? <var>' for syntax help.\n"); 10376059Samurai return(val); 10386059Samurai} 10396059Samurai 10406059Samurai 10416059Samuraistatic int 10426059SamuraiAddCommand(list, argc, argv) 10436059Samuraistruct cmdtab *list; 10446059Samuraiint argc; 10456059Samuraichar **argv; 10466059Samurai{ 10476059Samurai struct in_addr dest, gateway, netmask; 10486059Samurai 10496059Samurai if (argc == 3) { 10506059Samurai dest = GetIpAddr(argv[0]); 10516059Samurai netmask = GetIpAddr(argv[1]); 10526059Samurai if (strcmp(argv[2], "HISADDR") == 0) 10536059Samurai gateway = IpcpInfo.his_ipaddr; 10546059Samurai else 10556059Samurai gateway = GetIpAddr(argv[2]); 10566059Samurai OsSetRoute(RTM_ADD, dest, gateway, netmask); 10576059Samurai } else { 10586059Samurai printf("Usage: %s %s\n", list->name, list->syntax); 10596059Samurai } 10606059Samurai return(1); 10616059Samurai} 10626059Samurai 10636059Samuraistatic int 10646059SamuraiDeleteCommand(list, argc, argv) 10656059Samuraistruct cmdtab *list; 10666059Samuraiint argc; 10676059Samuraichar **argv; 10686059Samurai{ 10696059Samurai struct in_addr dest, gateway, netmask; 10706059Samurai 10716059Samurai if (argc >= 2) { 10726059Samurai dest = GetIpAddr(argv[0]); 10736059Samurai if (strcmp(argv[1], "HISADDR") == 0) 10746059Samurai gateway = IpcpInfo.his_ipaddr; 10756059Samurai else 10766059Samurai gateway = GetIpAddr(argv[1]); 10776059Samurai netmask.s_addr = 0; 10786059Samurai if (argc == 3) { 10796059Samurai if (inet_aton(argv[1], &netmask) == 0) { 10806059Samurai printf("bad netmask value.\n"); 10816059Samurai return(1); 10826059Samurai } 10836059Samurai } 10846059Samurai OsSetRoute(RTM_DELETE, dest, gateway, netmask); 10856059Samurai } else if (argc == 1 && strcmp(argv[0], "ALL") == 0) { 10866059Samurai DeleteIfRoutes(0); 10876059Samurai } else { 10886059Samurai printf("Usage: %s %s\n", list->name, list->syntax); 10896059Samurai } 10906059Samurai return(1); 10916059Samurai} 10926059Samurai 1093