diff options
| author | Sven Eisenhauer <sven@sven-eisenhauer.net> | 2023-11-10 15:11:48 +0100 |
|---|---|---|
| committer | Sven Eisenhauer <sven@sven-eisenhauer.net> | 2023-11-10 15:11:48 +0100 |
| commit | 33613a85afc4b1481367fbe92a17ee59c240250b (patch) | |
| tree | 670b842326116b376b505ec2263878912fca97e2 /Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/actions_commands.txt | |
| download | Studium-master.tar.gz Studium-master.tar.bz2 | |
Diffstat (limited to 'Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/actions_commands.txt')
| -rw-r--r-- | Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/actions_commands.txt | 1593 |
1 files changed, 1593 insertions, 0 deletions
diff --git a/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/actions_commands.txt b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/actions_commands.txt new file mode 100644 index 0000000..8e189c9 --- /dev/null +++ b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/actions_commands.txt @@ -0,0 +1,1593 @@ +//zmg, 03.01.01
+//this file needs a better description!
+//
+//
+
+// these are the command arrays
+// the "C" stands for Command
+userC = new Array(); // user mode commands
+enableC = new Array(); // privileged mode commands
+globalC = new Array(); // global config mode commands
+
+routerRIPC = new Array(); // RIP
+routerIGRPC = new Array(); // IGRP
+routerEIGRPC = new Array(); // EIGRP
+routerOSPFC = new Array(); // OSPF
+routerBGPC = new Array(); // BGP
+routerAFC = new Array(); // BGP address-family
+routerISISC = new Array(); // IS-IS
+
+lineconC = new Array(); // line console
+lineauxC = new Array(); // line aux
+linevtyC = new Array(); // line vty
+linettyC = new Array(); // line tty
+
+intATMC= new Array(); //ATM for dsl
+intDialerC = new Array(); // dialer
+intEC = new Array(); // ethernet
+intFC = new Array(); // fast ethernet
+intGC = new Array(); // gigabit ethernet
+intSC = new Array(); // serial
+intBriC = new Array(); // bri
+intLoopBackC = new Array(); // loopback
+intAsyncC = new Array(); // async
+intVlanC = new Array(); // vlan interface
+
+// sub interfaces
+
+subintDialerC = new Array();
+subintEC = new Array();
+subintFC = new Array();
+subintGC = new Array();
+subintSC = new Array();
+subintBriC = new Array();
+subintLoopBackC = new Array();
+subintAsyncC = new Array();
+subintVlanC = new Array();
+
+vlanDBC = new Array(); // vlan database mode
+controllerT1C = new Array(); // T1 controller
+extNaclC = new Array(); // extended named access-list
+stdNaclC = new Array(); // Standard named access-list
+mapClassC = new Array(); // map-class
+timeRangeC = new Array(); // time-range
+dhcpC = new Array(); // ip dhcp
+routeMapC = new Array(); // route-map
+classMapC = new Array(); // class-map
+policyMapC = new Array(); // policy-map
+policyMapClassC = new Array(); // policy-map class
+ATMPVCC = new Array(); //atm pvc
+
+correctCommand = null; // This global variable is used to store the function that needs to be run.
+
+completeKeywordneeded = new Array(15); // This global variable is needed for remembering which keyword needs to be checked fully
+fillcompleteKeyword(true);
+
+//begin for the configuration mode of the routers -- suresh
+var configRouterA = String("normal");
+var configRouterB = String("normal");
+var configRouterC = String("normal");
+var configRouterD = String("normal");
+var configRouterE = String("normal");
+
+//end for the configuration mode of the routers -- suresh
+
+// ***** Array.addSC (str, str, bool) *****
+//-----------------------------------------------------------------------------
+//IN: commandName = string, the new subcommand name
+// descript = string, the description of the new subcommand
+// noUse = bool, whether or not the subcommand is there to help
+// people or a real subcommand (zmg: which is T and which is F?) (?)
+//
+// NOTE: Most commands and subcommands are stored as arrays.
+//
+// For example, all the commands in the user mode are stored in
+// the array 'userC'. When the command:
+//
+// userC.add("enable","Turn on privileged commands");
+//
+// is called, the following happens:
+//
+// 1) the "enable" subcommand is added to the 'userC'
+// array (userC[])
+// 2) stores the string "enable" in one of the elements
+// in userC[]
+// 3) userC.enable is created as a new array
+// 4) the description of the new subcommand is stored
+// in 'userC.enable.descript'
+// > if the description is omitted, then the subcommand
+// can still be used, however, it will not show up in
+// partial or full help.
+// > the noUse argument can be omitted (as it is in this
+// example). It then has the value 'null'.
+//
+// zmg: the following is quite possibly the worst comment
+// I have ever read. i dont know how to translate
+// this into usable English, so I'll leave it here
+// for now.
+//
+// > The 'noUse' attribute is only for things like WORD.
+// WORD is something to show the user what to put, but
+// it is not really a subcommand. For subcommands like
+// WORD or LINE, noUse is <true>.
+//DO: add a new subcommand to this command
+//OUT: <none>
+//
+// adds the addSC method for the Array object; assigns commands_addSubCommand function to Array.addSC
+Array.prototype.addSC = commands_addSubCommand;
+//
+function commands_addSubCommand(commandName, descript)
+{
+ this[this.length] = commandName; //this specific command is added to
+ //the current command Array
+
+ this[commandName] = new Array(); //a new subcommand array is created
+ this[commandName].descript = descript; //description is stored
+// this[commandName].noUse = noUse; //'noUse' attribute is stored
+
+ // if the command name is in the format of <xxx-yyy> where xxx and yyy are integers and xxx <= yyy
+ if (commandName.charAt(0) == "<")
+ {
+ var str = commandName.substring(1, commandName.length-1); // take out "<" and ">"
+ var num = str.split("-"); // separate the numbers
+
+ if (num.length == 2)
+ {
+ this[commandName].startNum = Number(num[0]); // assign the starting number to startNum
+ this[commandName].endNum = Number(num[1]); // assign the ending number to endNum
+ }
+ }
+}
+
+/*
+globalC.interface.Serial.addMC("<0-1>", "Serial interface number");
+ globalC.interface.Serial["<0-1>"].addSIC("<0-1>", "Serial interface number");
+ globalC.interface.Serial["<0-1>"]["<0-1>"].addSC("<0-4294967295>");
+
+globalC.interface.Serial["<0-1>"]["<0-1>"].enter = true;
+globalC.interface.Serial["<0-1>"]["<0-1>"]["<0-4294967295>"].enter = true;
+*/
+Array.prototype.addMC = commands_addModuleCommand;
+function commands_addModuleCommand(commandName, descript)
+{
+ this.addSC(commandName, descript);
+ this.isSpecial = true;
+ this.hasModule = true;
+ this[commandName].isSpecial = true;
+ this[commandName].isModule = true;
+}
+
+Array.prototype.addSIC = commands_addSubInterfaceCommand;
+function commands_addSubInterfaceCommand(commandName, descript)
+{
+ this.addSC(commandName, descript);
+ this.isSpecial = true;
+ this.hasSI = true;
+ this[commandName].isSpecial = true;
+ this[commandName].isSI = true;
+}
+
+
+// ***** commands_deleteSubCommand (str, str, bool) *****
+//IN: commandArray = string, name of the command array that contains
+// the subcommand being deleted
+// commandNameToDel = string, name of subcommand that is being deleted
+// all = bool, true: delete every subcommand in 'commandArray'
+// false: delete the subcommand 'commandNameToDel'
+//DO: delete the subcommand 'commandNameToDel' in 'commandArray', or if
+// all==true, all of the subcommands
+//OUT: <none>
+function commands_deleteSubCommand(commandArray, commandName, all)
+{
+ //get a pointer to the command array
+ var commandArray = eval(commandArray);
+
+ if (all == true)
+ {
+ //delete all the subcommands in this command array (all==true),
+ //and reset the command array's length to 0.
+ for (var i=0; i<commandArray.length; i++)
+ delete commandArray[commandArray[i]];
+ commandArray.length = 0;
+ }
+ else
+ {
+ //all == false, we are going to delete the
+ //specific subcommand 'commandNameToDel'
+
+ //for-loop finds the subcommand in question
+ var i = 0;
+ for (var i=0; i<commandArray.length; i++) {
+
+ //search through all subcommands--if there is a match,
+ //then break the loop. after the for-loop, i will be
+ //equal to the subcommand to be deleted
+ if (commandArray[i] == commandName)
+ break;
+ }
+
+ //zmg: I added this line...do we need to just return if
+ //the command doesn't exist?
+ //if (commandArray.length == i) return; //the command to delete DNE in 'captr'
+
+ //remove the ith ('commandNameToDel')
+ //subcommand from the command array
+ commandArray.splice(i,1);
+
+ //delete the subcommand's array from memory
+ delete commandArray[commandName];
+ }
+}
+
+
+
+
+
+
+
+// ***** commands_sortSubCommand(array) *****
+//IN: commandArName = the name of a command array
+//DO: sorts the command array, so when the user presses "?", it will show in
+// alphabetical order. the 'noUse' subcommands will be sorted to the front.
+//OUT: the alpha-sorted command array 'commandArName'
+function commands_sortSubCommand(commandName)
+{
+ // use this as a pointer to the command array
+ var commandArray = eval(commandName);
+
+ // sort this array in alpha order
+ commandArray.sort();
+
+ var noUseElements = 0; //number of 'noUse' commands
+ for (var i=0; i<commandArray.length; i++)
+ {
+ //commands_sortSubCommand(commandName + "." + commandArray[i]);
+ if (commandArray[commandArray[i]].noUse == true)
+ {
+ //if this is a 'noUse' command, then put it in the
+ //front of the sorted list
+ //
+ //zmg: does this put the 'noUse' commands in alpha
+ // order? does it matter? (?)
+ commandArray.splice(noUseElements,0,commandArray.splice(i,1).toString());
+
+ //increment the number of 'noUse' commands
+ noUseElements++;
+ }
+ }
+}
+
+
+
+
+
+// ***** commands_copyCommand(str, str, str, bool) *****
+//DO: copies the 'scArrayName' from 'fromArray' to 'toArray'.
+// ** NOTE: If the 'scArrayName' argument is omitted, then every
+// subcommand will be copied from 'fromArray' to 'toArray'
+//
+//IN: fromArray = string, name of the command array to copy from
+// toArray = string, name of the command array to copy to
+// scArrayName = string, name of the subcommand being copied (if ==null,
+// then all of the attribs of this subcommand are copied)
+// noCommand = boolean, whether the command is "no"
+//OUT: <none>
+function commands_copyCommand(fromArray, toArray, commandArray, noCommand)
+{
+ if (commandArray != null)
+ {
+ // if scArrayName is not omitted, then copy all the attributes of this subcommand
+ eval(toArray)[eval(toArray).length] = commandArray;
+ eval(toArray)[commandArray] = new Array();
+ eval(toArray)[commandArray].descript = eval(fromArray)[commandArray].descript;
+ eval(toArray)[commandArray].enter = eval(fromArray)[commandArray].enter;
+ eval(toArray)[commandArray].mustEnter = eval(fromArray)[commandArray].mustEnter;
+ eval(toArray)[commandArray].mustHelp = eval(fromArray)[commandArray].mustHelp;
+ eval(toArray)[commandArray].noUse = eval(fromArray)[commandArray].noUse;
+
+ // copy all subcommands of this command
+ for (var i=0; i<eval(fromArray)[commandArray].length; i++)
+ {
+ commands_copyCommand((fromArray+"."+commandArray), (toArray+"."+commandArray), eval(fromArray)[commandArray][i]);
+ }
+
+ }
+ else
+ {
+ //if 'scArrayName' is omitted, then copy all subcommands from
+ //'fromArray' to 'toArray'
+ for (var j=0; j<eval(fromArray).length; j++)
+ {
+ commandArray = eval(fromArray)[j];
+
+ if (eval(fromArray)[j] != "no")
+ {
+ //the current subcommand name is not "no",
+ //so copy the subcommand
+ eval(toArray)[eval(toArray).length] = commandArray;
+ eval(toArray)[commandArray] = new Array();
+ eval(toArray)[commandArray].descript = eval(fromArray)[commandArray].descript;
+
+ if (noCommand != true)
+ {
+ //if the from command array is not a "no" command,
+ //then copy the enter and mustEnter functions
+ eval(toArray)[commandArray].enter = eval(fromArray)[commandArray].enter;
+ eval(toArray)[commandArray].mustEnter = eval(fromArray)[commandArray].mustEnter;
+ }
+
+ eval(toArray)[commandArray].mustHelp = eval(fromArray)[commandArray].mustHelp;
+ eval(toArray)[commandArray].noUse = eval(fromArray)[commandArray].noUse;
+
+ // copy all subcommands in this commandArray
+ for (var i=0; i<eval(fromArray)[commandArray].length; i++)
+ {
+ commands_copyCommand((fromArray+"."+commandArray), (toArray+"."+commandArray), eval(fromArray)[commandArray][i]);
+ }
+ }
+ }
+ }
+}
+
+
+
+
+
+
+
+spaces = " ";
+
+// ***** commands_invalidInput(array, int) *****
+//IN: commandArray = the name of a command array
+// subCIndex = int, index of invalid input element
+//DO: prints out the caret (^) and message indicating error
+//OUT: prints out an error message to the user, with a ^ pointing
+// to the first invalid character in the command string
+function commands_invalidInput(commandArray, subCNum)
+{
+ // use this as a pointer to the router object
+ var rptr = eval("_root.r" + _root.active_router);
+
+ //if the input command is only one word long..
+ if (COMMAND.length == 1)
+ {
+ if ((rptr.MODE == "user") || (rptr.MODE == "enable"))
+ {
+ //the router is in user or enable mode, so print out
+ //this error message, and exit the
+ //commands_invalidInput() function
+ output_write("Translating \"" + COMMAND[0] + "\"...domain server (255.255.255.255)\n");
+ output_write("% Unknown command or computer name, or unable to find computer address\n");
+ return;
+ }
+ }
+
+ //this for-loop starts with the first character of the invalid input
+ //element, and determines which character is incorrect
+ for (var j=1; j<=COMMAND[subCNum].length; j++)
+ {
+ match = false; //tmp.flag variable
+
+ //loop through all subcommands in this commmand array
+ for (var i=0; i<commandArray.length; i++)
+ {
+ //this if-statement skips 'noUse' commands
+ if (commandArray[commandArray[i]].noUse != true)
+ {
+ //if the first j characters of the input
+ //element match the first j characters of the
+ //subcommand in this command array, then set
+ //match to 'true'
+ if (COMMAND[subCNum].substring(0,j).toLowerCase() == commandArray[i].substring(0,j).toLowerCase())
+ {
+ match = true;
+ }
+ }
+ }
+
+ //if the first j characters of the input element does not
+ //match with any of the subcommands, then exit this loop
+ if (match == false)
+ break;
+ }
+
+ //get the length of the input before the error character
+ previousEleLength = commands_inputEleTo(subCNum).length - COMMAND[subCNum].length;
+ invalidCharAt = rptr.PROMPT.length + previousEleLength + j - 1;
+
+ //print spaces and error message, alerting the user
+ //to the location of the invalid character
+ output_write(spaces.substring(0,invalidCharAt));
+ output_write("^\n",
+ "% Invalid input detected at '^' marker.\n",
+ "\n");
+}
+
+
+
+
+
+
+// ***** commands_inputEleTo(int) *****
+//IN: subCIndex = int, representing which input element it is to
+//DO: returns the string of the input from beginning to this element
+//OUT: returns the string of the input from beginning to this element
+function commands_inputEleTo(subCNum)
+{
+ // use this as a pointer to the router object
+ var rptr = eval("_root.r" + _root.VISIBLE_ROUTER);
+
+ //split the command line input at the spaces, and put
+ //the pieces into the elements of 'inputArray'
+ inputArray = rptr.INPUT.split(" ");
+ inputSC = "";
+
+ //this for-loop returns the first 'subCIndex' words from
+ //the rptr.INPUT (command line input) string
+ for (var k=0, inputEle=0; ((k<inputArray.length) && (inputEle<=subCNum)); k++)
+ {
+ if (inputArray[k] != "")
+ inputEle++;
+ inputSC += inputArray[k] + " ";
+ }
+
+ //return the truncated, newly-built string
+ return(inputSC.substring(0,inputSC.length-1));
+}
+
+
+
+
+
+
+
+// ***** commands_useCommand(array, int) *****
+//IN: commandArray = the command array
+// subCIndex = int, representing which input element this fct is interpreting
+//DO: searches through 'commandArray' for a subcommand that matches the
+// subCIndex'th element of the command line input. If it is found, then
+// that subcommand's array will be used to search for the next element
+// of the input. (this is a recursive function)
+//OUT: <none>
+function commands_useCommand(commandArray, subCNum)
+{
+//trace("commandArray = " + commandArray);
+//trace("COMMAND = " + COMMAND);
+//trace("COMMAND.length = " + COMMAND.length);
+//trace("commandArray.length = " + commandArray.length);
+//trace("subCNum = " + subCNum);
+
+ // use this as a pointer to the active router object
+ var rptr = eval("_root.r" + _root.active_router);
+ var vptr = eval("_root.r" + _root.VISIBLE_ROUTER);
+
+//trace("COMMAND[subCNum] = " + COMMAND[subCNum]);
+//trace("commandArray.length = " + commandArray.length);
+//trace("commandArray.enter = " + commandArray.enter);
+
+ if (commandArray.isSpecial)
+ {
+ // if command has a slot subcommand and this is not the last command part entered
+ if ((commandArray.hasModule) && (subCNum < COMMAND.length))
+ {
+ var parts = COMMAND[subCNum].split("/");
+
+ if (parts.length != 2)
+ {
+ if (!rptr.HELPING)
+ {
+ parsestatus = UNSUCCESSFULregcmd;
+ }
+ else
+ {
+ // show slash
+ if ((subCNum == (COMMAND.length-1)) && (vptr.INPUT.charAt(vptr.INPUT.length-1) != " "))
+ {
+ output_write("/\n", "\n");
+ parsestatus = SUCCESSFULhelpcmd;
+ }
+ else
+ {
+ parsestatus = UNSUCCESSFULhelpcmd;
+ output_write("% Unrecognized command\n");
+ }
+ }
+ return;
+ }
+ else
+ {
+ // trace("COMMAND[] = " + COMMAND.join());
+ COMMAND[subCNum] = parts[1];
+ COMMAND.splice(subCNum, 0, parts[0]);
+ trace("COMMAND[] = " + COMMAND.join());
+ }
+ }
+ else if (commandArray.isModule)
+ {
+// trace("is module " + COMMAND[subCNum]);
+
+ if (COMMAND[subCNum] == "")
+ {
+ if (!rptr.HELPING)
+ {
+ parsestatus = UNSUCCESSFULregcmd;
+ }
+ else
+ {
+ // show help
+ if ((subCNum == (COMMAND.length-1)) && (vptr.INPUT.charAt(vptr.INPUT.length-1) != " "))
+ {
+ commands_helpCommand(commandArray);
+ parsestatus = SUCCESSFULhelpcmd;
+ }
+ else
+ {
+ parsestatus = UNSUCCESSFULhelpcmd;
+ output_write("% Unrecognized command\n");
+ }
+ }
+ return;
+ }
+ }
+
+ if (commandArray.hasSI)
+ {
+// trace("has SI " + COMMAND[subCNum]);
+
+ var parts = COMMAND[subCNum].split(".");
+ if (parts.length == 2)
+ {
+ COMMAND[subCNum] = parts[1];
+ COMMAND.splice(subCNum, 0, parts[0]);
+ trace("COMMAND[] = " + COMMAND.join());
+ }
+ }
+ else if (commandArray.isSI)
+ {
+// trace("is SI " + COMMAND[subCNum]);
+
+ if (COMMAND[subCNum] == "")
+ {
+ if (!rptr.HELPING)
+ {
+ parsestatus = UNSUCCESSFULregcmd;
+ }
+ else
+ {
+ // show help
+ if ((subCNum == (COMMAND.length-1)) && (vptr.INPUT.charAt(vptr.INPUT.length-1) != " "))
+ {
+ output_write(" " + commandArray[0] + " " + commandArray.descript + "\n", "\n");
+// commands_helpCommand(commandArray);
+ parsestatus = SUCCESSFULhelpcmd;
+ }
+ else
+ {
+ parsestatus = UNSUCCESSFULhelpcmd;
+ output_write("% Unrecognized command\n");
+ }
+ }
+ return;
+ }
+ }
+ }
+
+//trace("vptr = " + (vptr.INPUT.charAt(vptr.INPUT.length-1)) + "a");
+ if (subCNum >= COMMAND.length)
+ {
+trace("alternate step: 1");
+//trace("last command " + COMMAND[subCNum]);
+ // 2nd case: subCNum passes command.length, we exhausted the array.
+ // -Helping ver
+ if (rptr.Helping == true)
+ {
+//trace("help for " + COMMAND[subCNum - 1]);
+ //the "?" has been pressed, show full help
+ parsestatus = SUCCESSFULhelpcmd;
+ commands_helpCommand(commandArray);
+ return;
+ }
+ else
+ {
+ // Non-Helping ver
+ if ((typeof(commandArray.enter) != "function") && (commandArray.enter != true))
+ {
+ // the functions for this command does not exist but it works.
+ //return;
+ parsestatus = SUCCESSFULregcmd;
+ return;
+ }
+ else
+ {
+ // the functions for this command exists.
+ parsestatus = SUCCESSFULregcmd;
+ return;
+ }
+ }
+ }
+ else if (commandArray.length == 0)
+ {
+ trace("alternate step: 2");
+ // 1st case: no further command array left.
+ //Non-Helping ver
+ if (rptr.HELPING == false)
+ {
+ if ((typeof(commandArray.enter) != "function") && (commandArray.enter != true))
+ {
+ // the functions for this command does not exist.
+ parsestatus = SUCCESSFULregcmd; // <-- the command is not supported but has to be successful to parse
+ return;
+ }
+ else
+ {
+ // the functions for this command exists.
+ // Note: is there even this case ?
+//trace("Case 1, help = false, functions exists");
+ _root.correctCommand = commandArray.enter;
+ parsestatus = SUCCESSFULregcmd;
+ }
+ }
+ else
+ {
+ //Helping ver
+ parsestatus = UNSUCCESSFULhelpcmd;
+ output_write("% Unrecognized command\n");
+ return;
+/*
+ if ((typeof(commandArray.enter) != "function") && (commandArray.enter != true))
+ {
+ // the functions for this command does not exist. <-- the command is not supported but help might be.
+//trace("Case 1, help = true, functions not exists");
+ parsestatus = UNSUPPORTEDhelpcmd;
+
+ //commands_helpListCommand(commandArray, COMMAND[0]);
+ return;
+ }
+ else
+ {
+ // the functions for this command exists.
+ // Note: is there even this case ?
+//trace("Case 1, help = true, functions exists");
+ parsestatus = UNSUPPORTEDhelpcmd;
+ return;
+ }
+*/
+ }
+ }
+ else
+ {
+ // All other case: More command array to check.
+ // Try to match the commandArray with the command typed (other function)
+//var startTime=getTimer();
+//trace("Matching command - startTime = " + startTime);
+ var matchRet = matchingCommand(commandArray, subCNum);
+//var endTime=getTimer();
+//trace("Matching command - endTime = " + endTime);
+//trace("Matching command - elapsed time = " + ((endTime-startTime)/1000) + "\n");
+
+trace("Match Return = " + matchRet);
+
+ // if it doesn't match, it is an invalid input, incorrect input
+ if (matchRet == -2)
+ {
+ if (rptr.HELPING == true)
+ {
+ parsestatus = UNSUCCESSFULhelpcmd;
+ output_write("% Unrecognized command\n");
+ //trace("COMMAND = " + COMMAND);
+//trace("matchRet = -2, HELPING");
+ }
+ else
+ {
+ parsestatus = UNSUCCESSFULregcmd;
+ }
+ return;
+ }
+ else if ((subCNum == (COMMAND.length-1)) && (rptr.HELPING == true) && (vptr.INPUT.charAt(vptr.INPUT.length-1) != " "))
+ {
+ // else if the cmd line matches valid command
+ //"?" is pressed, and is calling for partial help,
+ //so list out the commands that start with the typed
+ //characters, then list out those commands
+ //commands_helpListCommand(commandArray,COMMAND[subCNum]);
+ parsestatus = SUCCESSFULhelpcmd; // command was successful
+//trace("Case else, help = true, parsestatus =5");
+//trace("list commands for " + COMMAND[subCNum]);
+ commands_helpListCommand(commandArray, COMMAND[subCNum]);
+ return;
+ }
+ else if (matchRet == -1)
+ {
+ // else if match detects ambiguous cmd
+ output_write("% Ambiguous command: \"" + commands_inputEleTo(subCNum) + "\"\n");
+ parsestatus = AMBIGUOUSregcmd;
+ return;
+ }
+ else
+ {
+ // other wise, we recurse the function
+//trace("matchRet = " + matchRet);
+//trace("commandArray[matchRet] = " + matchRet);
+//trace("commandArray[commandArray[matchRet]] = " + commandArray[matchRet]);
+
+ if (commandArray.isSpecial)
+ {
+ if (commandArray.isModule)
+ {
+ COMMAND[subCNum-1] = COMMAND[subCNum-1] + "/" + COMMAND[subCNum];
+ COMMAND.splice(subCNum, 1);
+ subCNum--;
+ }
+ else if (commandArray.isSI)
+ {
+ COMMAND[subCNum-1] = COMMAND[subCNum-1] + "." + COMMAND[subCNum];
+ COMMAND.splice(subCNum, 1);
+ subCNum--;
+ }
+ }
+
+
+ commands_useCommand(commandArray[matchRet],subCNum+1);
+ }
+ }
+}
+
+
+/*
+// IN: commandArray = the array we are checking
+ subCNum = the case we are checking now
+// DO: tries to match the command with a valid command Array
+// OUT: -2 Invalid input
+ -1 Ambiguous command
+ 0
+ +n
+// WORD, LINE, <>, A.B.C.D, H.H.H - added by Kalven
+*/
+
+function matchingCommand(commandArray, subCNum)
+{
+ //var match = -2;
+
+ _root.completeKeywordneeded[subCNum] = false; // does the default step
+
+ //Try to improve this function with Binary Search -Kalven
+//trace("Match Command");
+//trace("Specials");
+//trace("subCNum="+subCNum);
+ if( (typeof(commandArray["WORD"]) == "object") && (commandArray[commandArray["WORD"]].noUse != true) )
+ {
+ _root.completeKeywordneeded[subCNum]= true;
+ return "WORD";
+ }
+ else if( (subCNum > 0) && (typeof(commandArray["LINE"]) == "object") && (commandArray.line.descript.indexOf("line") < 0))
+ {
+
+ _root.completeKeywordneeded[subCNum] = true;
+ return "LINE";
+ }
+ else if( (typeof(commandArray["A.B.C.D"]) == "object") && (commandArray[commandArray["A.B.C.D"]].noUse != true) )
+ {
+ _root.completeKeywordneeded[subCNum] = true;
+ if(commands_checkABCD(COMMAND[subCNum]))
+ {
+ return "A.B.C.D";
+ }
+ }
+ else if( (typeof(commandArray["H.H.H"]) == "object") && (commandArray[commandArray["H.H.H"]].noUse != true) )
+ {
+ if(commands_checkHHH(COMMAND[subCNum]))
+ {
+ _root.completeKeywordneeded[subCNum] = true;
+ return "H.H.H";
+ }
+ }
+//trace("<>");
+ // check the ranges, first check the front of the list, and then check the end of the list
+ var i = 0;
+ while( (commandArray[i].charAt(0) == "<") && (commandArray[i].charAt(commandArray[i].length-1) == ">"))
+ {
+ if(commandArray[commandArray[i]].noUse != true)
+ {
+ if( commandArray[i].indexOf("-") >= 0)
+ {
+ _root.completeKeywordneeded[subCNum] = true;
+ if ((!isNaN(COMMAND[subCNum])) && (Number(COMMAND[subCNum]) >= commandArray[commandArray[i]].startNum) && (Number(COMMAND[subCNum]) <= commandArray[commandArray[i]].endNum))
+ {
+ return commandArray[i];
+ }
+ }
+ else
+ {
+ _root.completeKeywordneeded[subCNum] = true;
+ return commandArray[i];
+ }
+ }
+ i++;
+ }
+
+ i = commandArray.length-1;
+ while( (commandArray[i].charAt(0) == "<") && (commandArray[i].charAt(commandArray[i].length-1) == ">"))
+ {
+ if(commandArray[commandArray[i]].noUse != true)
+ {
+ if( commandArray[i].indexOf("-") >= 0)
+ {
+ _root.completeKeywordneeded[subCNum] = true;
+ if ((!isNaN(COMMAND[subCNum])) && (Number(COMMAND[subCNum]) >= commandArray[commandArray[i]].startNum) && (Number(COMMAND[subCNum]) <= commandArray[commandArray[i]].endNum))
+ {
+ return commandArray[i];
+ }
+ }
+ else
+ {
+ _root.completeKeywordneeded[subCNum] = true;
+ return commandArray[i];
+ }
+ }
+ i--;
+ }
+//trace("Binary Search");
+ // now search for ambiguous or correct command
+ var left = 0; // left side of the array
+ var right = commandArray.length-1; // right side of the array
+ var sw = false; // flag for a match
+ var middle = 0; // middle of the array that we use to check against
+ var word = COMMAND[subCNum].toLowerCase(); //the command we're checking
+ while (sw == false && left <= right)
+ {
+ middle=Math.floor((left+right)/2);
+ trace(commandArray[middle].toLowerCase());
+ if ((word == commandArray[middle].toLowerCase()) && (commandArray[commandArray[middle]].noUse != true) )
+ {
+ // found
+ //msgNotice("FOUND1");
+ trace("found");
+ trace(commandArray[middle].toLowerCase());
+ sw=true;
+ _root.completeKeywordneeded[subCNum] = false;
+ return commandArray[middle];
+ }
+ else if((middle-1 >= 0) && (word == commandArray[middle-1].toLowerCase()) && (commandArray[commandArray[middle-1]].noUse != true))
+ {
+ // found
+ // msgNotice("FOUND2");
+ trace("found");
+ trace(commandArray[middle-1].toLowerCase());
+ sw=true;
+ _root.completeKeywordneeded[subCNum] = false;
+ return commandArray[middle-1];
+
+ }
+ else if( (middle+1 < commandArray.length) && (word == commandArray[middle+1].toLowerCase()) && (commandArray[commandArray[middle+1]].noUse != true) )
+ {
+ //msgNotice("FOUND3");
+ // found
+ trace("found");
+ trace(commandArray[middle+1].toLowerCase());
+ sw=true;
+ _root.completeKeywordneeded[subCNum] = false;
+ return commandArray[middle+1];
+
+ }
+ else if( (word == commandArray[middle].substring(0,word.length).toLowerCase()) && (commandArray[commandArray[middle]].noUse != true))
+ {
+ // the fist j characters of the input element match the first j chars of subcommand
+ // see if word matches with the previous or the next command.
+ if(
+ ( (middle-1 >= 0) && (word == commandArray[middle-1].substring(0,word.length).toLowerCase()) && (commandArray[commandArray[middle-1]].noUse != true))
+ ||
+ ( (middle+1 < commandArray.length) && (word == commandArray[middle+1].substring(0,word.length).toLowerCase()) && (commandArray[commandArray[middle+1]].noUse != true))
+ )
+ {
+ // ambiguous command
+ trace("ambigous command");
+ _root.completeKeywordneeded[subCNum] = false;
+ if ( (commandArray[middle] == "e0") || (commandArray[middle] == "e1") || (commandArray[middle] == "s0") || (commandArray[middle] == "s1") )
+ {
+ trace("ambigous");
+ _root.completeKeywordneeded[subCNum] = true;
+ return -2;
+ }
+ else return -1;
+ }
+ else return commandArray[middle];
+ }
+ else
+ {
+ if (word < commandArray[middle].toLowerCase()) right=middle-1;
+ if (word > commandArray[middle].toLowerCase()) left=middle+1;
+ }
+ }
+ if (sw == false)
+ {
+ // not found
+ trace("not found");
+ _root.completeKeywordneeded[subCNum] = true;
+ return -2;
+ }
+
+/*
+ //this for-loop loops through all subcommands in this 'commandArray'
+ for (var i=0; i<commandArray.length; i++)
+ {
+//trace("commandArray[i] = " + commandArray[i] + ", i = " + i);
+ //this if-statement skips 'noUse' commands
+
+
+ if (commandArray[commandArray[i]].noUse != true)
+ {
+ if ((commandArray[i] == "WORD") || (commandArray[i] == "LINE"))
+ {
+ // if the subcommand is a word or a line that the user can type in,
+ // then use the WORD or LINE command array accordingly.
+ match = i;
+ _root.completeKeywordneeded[subCNum] = true;
+ break;
+ }
+ else if ((commandArray[i].charAt(0) == "<") && (commandArray[i].charAt(commandArray[i].length-1) == ">"))
+ {
+ if (commandArray[i].indexOf("-") >= 0)
+ {
+ _root.completeKeywordneeded[subCNum] = true;
+ if ((!isNaN(COMMAND[subCNum])) && (Number(COMMAND[subCNum]) >= commandArray[commandArray[i]].startNum) && (Number(COMMAND[subCNum]) <= commandArray[commandArray[i]].endNum))
+ {
+ match = i;
+ break;
+ }
+ }
+ else
+ {
+ match = i;
+ _root.completeKeywordneeded[subCNum] = true;
+ break;
+ }
+ }
+ else if (commandArray[i].indexOf("A.B.C.D") >= 0)
+ {
+ _root.completeKeywordneeded[subCNum] = true;
+
+ if (commands_checkABCD(COMMAND[subCNum]))
+ {
+ match = i;
+ break;
+ }
+ }
+ else if (commandArray[i] == "H.H.H")
+ {
+ if (commands_checkHHH(COMMAND[subCNum]))
+ {
+ match = i;
+ _root.completeKeywordneeded[subCNum] = true;
+ break;
+ }
+ }
+ else if (COMMAND[subCNum].toLowerCase() == commandArray[i].toLowerCase())
+ {
+ //the command line input element matches the
+ //current (ith) subcommand--set it to match,
+ //then exit the loop
+ match = i;
+
+ _root.completeKeywordneeded[subCNum] = false;
+ break;
+ }
+ else if (COMMAND[subCNum].toLowerCase() == commandArray[i].substring(0,COMMAND[subCNum].length).toLowerCase())
+ {
+ //the first j characters of the input element
+ //match the first j characters of the subcommand
+ if (match == -2)
+ {
+ //if there was no match before this
+ //iteration, so set 'match' to this
+ //iteration's number (i)
+ match = i;
+ }
+ else
+ {
+ //there was a match before this
+ //iteration, so set 'match' to -1
+ //(this means this is an ambiguous
+ //command), and exit the loop
+ //begin condition added by suresh
+ //reason is if the user types "int e ?" in config mode
+ // it was printing ambiguous command as we have both ethernet and e0,e1 in globalC array
+
+ _root.completeKeywordneeded[subCNum] = false;
+
+ if ( (commandArray[i] == "e0") || (commandArray[i] == "e1") || (commandArray[i] == "s0") || (commandArray[i] == "s1") )
+ {
+ }
+ else
+ match = -1;
+ //end condition added by suresh
+ break;
+ }
+ }
+ }
+ }
+
+ // if we still have match = -2, we have to have full check for the keyword
+ if (match == -2)
+ {
+ _root.completeKeywordneeded[subCNum] = true;
+ }
+
+ return match;
+ */
+}
+
+function fillcompleteKeyword(k)
+{
+ for (var i=0; i < _root.completeKeywordneeded.length;i++)
+ _root.completeKeywordneeded[i] = k;
+}
+
+// ***** commands_helpListCommand(array, str) *****
+//IN: commandArray = command array
+// inputCommand = string, the input command
+//DO: lists out all the commands with the same spelling as the given command
+// fragment. (ex: when the user types "t?", all commands that start with
+// "t" will be printed to the console)
+//OUT: list of matching commands printed to the console
+function commands_helpListCommand(commandArray, inputCommand)
+{
+ if (typeof(commandArray["WORD"]) == "object")
+ {
+ output_write("WORD ");
+ }
+
+ else if ((typeof(commandArray["LINE"]) == "object") && (commandArray.line.descript.indexOf("line") < 0))
+ {
+ output_write("LINE ");
+ }
+
+ if (typeof(commandArray["A.B.C.D"]) == "object")
+ {
+ output_write("A.B.C.D ");
+ }
+
+ if (typeof(commandArray["H.H.H"]) == "object")
+ {
+ output_write("H.H.H");
+ }
+
+ if (commandArray.hasSI)
+ {
+ output_write(". ");
+ }
+
+ if ((commandArray[0].charAt(0) == "<") && (commandArray[0].charAt(commandArray[0].length-1) == ">"))
+ {
+ if ((!isNaN(inputCommand)) && (Number(inputCommand) >= commandArray[commandArray[0]].startNum) && (Number(inputCommand) <= commandArray[commandArray[0]].endNum))
+ {
+ output_write(commandArray[0] + " ");
+ }
+ }
+
+ //this for-loop iterates through all of the
+ //subcommands in this 'commandArray'
+ for (var i=0; i<commandArray.length; i++)
+ {
+ //this if-statement will skip 'noUse' commands, and those commands
+ //that do not have descriptions
+ if (commandArray[commandArray[i]].descript != null)
+ {
+ //if the first j characters of the command line input
+ //match the first j characters of the subcommand,
+ //then print that subcommand out in the help listing
+ if (inputCommand.toLowerCase() == commandArray[i].substring(0,inputCommand.length).toLowerCase())
+ {
+ output_write(commandArray[i] + " ");
+ }
+ }
+ }
+ //newlines...
+ output_write("\n","\n");
+}
+
+
+
+
+// ***** commands_tabCompleteCommand(array, str) *****
+//IN: commandArray = command array
+// cmdLineInput = string, the current command line input
+//DO: fills the commandline with the rest of the text of the command that the
+// input matches, or just repeats the current input on the next line if
+// the current input is invalid or ambiguous
+//OUT: <none>
+function commands_tabCompleteCommand(commandArray, cmdLineInput)
+{
+ var rptr = eval("_root.r" + _root.VISIBLE_ROUTER);
+
+ var matchingCmds = 0; //# matching commands for current part of commandline input
+ var matchingCmdIndex = -1; //index in currentArray of the matching command
+ var error = 0; //flag, to determine if there is a good match (error = 0), or
+ //there is no matching command (error = 1)
+
+ var fullCmdName = ""; //string, after the for-loops contains the string of the valid
+ //command that the command line input matches
+
+
+ //split the command line input into an array, with
+ //each element containing one token (word)
+ //
+ var extraSpaces = 0; //number of extra spaces in the command line input
+ var trailingSpace = 0; //flag, 1 if there is are trailing spaces in the command
+ //line input
+
+ partialInput = new Array();
+ partialInput = cmdLineInput.split(" ");
+ for (var i = 0; i < partialInput.length; i++)
+ {
+ //removes the empty "" elements from
+ //the 'partialInput' array
+ if (partialInput[i] == "")
+ {
+ partialInput.splice(i,1);
+ i--;
+ extraSpaces++;
+
+ if ((i+1) == partialInput.length)
+ {
+ trailingSpace = 1;
+ }
+ }
+ }
+
+
+ //if there is a trailing space in the command line input, then
+ //no command will match. the first part of this if-statement
+ //takes care of that case. if there isn't a trailing space,
+ //then we need to try to match the command.
+ //
+ if (trailingSpace == 1)
+ {
+ //if there is a trailing space, no command will match,
+ //so set the error flag right away
+ error = 1;
+
+ }
+ else
+ {
+ //there is no trailing space in the command line input
+
+ //these doubly nested for-loops compare 'partialInput' to the the
+ //command arrays for the current mode, and determine if there is
+ //a uniquely matching command. if there is, 'error' will be 0, and
+ //'fullCmdName' will hold the name of the matching command.
+ //
+ for (var k = 0; k < partialInput.length; k++)
+ {
+ matchingCmds = 0;
+
+ //this for-loop iterates through all of the
+ //subcommands in this 'commandArray'
+ for (var i = 0; i<commandArray.length; i++)
+ {
+ //this if-statement will skip 'noUse' commands, and those commands
+ //that do not have descriptions
+ if ((commandArray[commandArray[i]].noUse != true) && (commandArray[commandArray[i]].descript != null))
+ {
+ if (partialInput[k].toLowerCase() == commandArray[i].substring(0,partialInput[k].length).toLowerCase())
+ {
+ //if the first j characters of the command line input
+ //match the first j characters of the subcommand,
+
+ // update the necessary 'matchingCmd' counters.
+ matchingCmdIndex = i;
+
+ if (partialInput[k].length == commandArray[i].length)
+ {
+ // if the input matches the whole command array element
+ // then it has an exact match, then break the loop
+
+ matchingCmds = 1;
+ break;
+ }
+ else
+ {
+ matchingCmds += 1;
+ }
+ }
+ }
+ }
+
+ if (matchingCmds != 1)
+ {
+ //if there are 0, or >1 matching commands,
+ //end the search process, this commandline
+ //input already is ambiguous or invalid
+ error = 1;
+ break;
+ }
+
+
+ //keep building up the currently matching command
+ if (fullCmdName != "")
+ fullCmdName += " ";
+ fullCmdName += commandArray[matchingCmdIndex];
+
+ //we have matching possibilities at this token level,
+ //so now set currentArray to the next subarray deeper
+ //(matchedCmd.allOfItsSubCmds[]), and the next iteration
+ //will try to find a match there as well
+ commandArray = commandArray[commandArray[matchingCmdIndex]];
+ } //end k for-loop
+ }
+
+ //
+ //at this point, the 'error' flag has been set, and 'fullCmdName'
+ //contains the full name of the matching command, if applicable
+ //
+
+ if (error == 0)
+ {
+ //the command line input entered so far exactly matches
+ //one command, so complete the input..
+
+ //at this point, fullCmdName is equal to the full name
+ //of the command that is matched, for example, "show running-config",
+ //regardless if the command line input is "show ru", "sh run" or
+ //whatever. this block of code sets 'finalMatch' equal to the
+ //command line input, except it replaces the last token with the
+ //full command. For example, "sh ru" becomes "sh running-config".
+ //this is so, the completed command will be displayed right later.
+ //
+
+ //split the full command name into the array 'fcArray'
+ fcArray = new Array();
+ fcArray = fullCmdName.split(" ");
+
+ //declare the destination string variable
+ var finalMatch = "";
+
+ //iterates through all of the pieces of the full command name
+ for (var ix = 0; ix < fcArray.length-1; ix++)
+ {
+ if (fcArray[ix] == partialInput[ix])
+ {
+ //if the full command name, and the command line
+ //input match, (ex. "show" is on the command line),
+ //then add this token to the final matching string
+ finalMatch += fcArray[ix];
+
+ }
+ else
+ {
+ //if the full command name and the command line
+ //input don't match, add the fragment from the
+ //command line to the final matching string
+ finalMatch += partialInput[ix];
+ }
+ //separate each token with a space
+ finalMatch += " ";
+ }
+
+ //add the full string corresponding to the last token
+ finalMatch += fcArray[fcArray.length-1];
+
+ //determine 'restOfCmd', the rest of the command string
+ //that will be "filled in" by pressing the <Tab> key.
+ var restOfCmd = finalMatch.substring(cmdLineInput.length-extraSpaces,finalMatch.length);
+
+
+ //add the rest of the command to the command line buffer
+ //and to the output, and then refresh the Hyperterminal window
+ rptr.line[rptr.lastLine] += restOfCmd;
+ rptr.INPUT += restOfCmd;
+ output_write();
+
+ //update the cursor pointer to point to the
+ //end of the newly added command
+ rptr.lineIndexCounter += restOfCmd.length;
+
+ }
+ else
+ {
+ //the current command line input is ambiguous, or
+ //doesn't match anything at all...print the same
+ //command line input on the next line.
+ //
+
+ //print a newline, the prompt, and the
+ //same command line input, again.
+ output_write("\n");
+ output_write(rptr.PROMPT);
+
+ rptr.INPUT = cmdLineInput;
+ output_write(rptr.INPUT);
+ }
+}
+
+
+
+
+// ***** commands_helpCommand(array) *****
+//IN: commandArray = command array
+//DO: print all of the subcommands of this command,
+// along with their descriptions
+//OUT: a listing of all available subcommands & their descriptions
+function commands_helpCommand(commandArray)
+{
+ var longest = 0; //tmp.var to hold the length of the
+ //longest command name
+
+
+ //this for-loop iterates through all subcommands in 'commandArray'
+ //to find the longest command name, and stores it in 'longest'
+ for (var i=0; i<commandArray.length; i++)
+ {
+ if (commandArray[i].length > longest)
+ {
+ longest = commandArray[i].length;
+ }
+ }
+
+ //for-loop to iterate through all subcommands in 'commandArray'
+ for (var i=0; i<commandArray.length; i++)
+ {
+ // skip commands with no description
+ if (commandArray[commandArray[i]].descript != null)
+ {
+ //print out the subcommand name and description
+ output_write(" " + commandArray[i] + spaces.substring(0,(longest-commandArray[i].length)));
+ if ((longest + 4 + commandArray[commandArray[i]].descript.length) <= 80)
+ {
+ output_write(" " + commandArray[commandArray[i]].descript + "\n");
+ }
+ else
+ {
+ var cutChar = commandArray[commandArray[i]].descript.substring(0,80-4-longest).lastIndexOf(" ");
+ output_write(" " + commandArray[commandArray[i]].descript.substring(0,cutChar) + "\n");
+ output_write(spaces.substring(0,(longest+4)) + commandArray[commandArray[i]].descript.substring((cutChar+1),commandArray[commandArray[i]].descript.length) + "\n");
+ }
+ }
+ }
+
+ //if the enter function exists for this 'commandArray,'
+ //then print " <cr>"
+ _root.deebug1 = commandArray + ";" + typeof(commandArray.enter);
+ if ((typeof(commandArray.enter) == "function") || (commandArray.enter == true))
+ {
+ output_write(" <cr>\n");
+ }
+
+ //newline
+ output_write("\n");
+}
+
+
+
+
+
+// ***** commands_run(str) *****
+// IN: a string of commands to be ran
+// DO: run this line of command
+// NOTE:
+// this function is for testing only
+function commands_run(commands) {
+
+ // use this as a pointer to the active router object
+ var r = eval("_root.r" + _root.active_router);
+
+ // reset the scroll line; for more function
+ r.scrollStartLine = r.lastDLine - 23;
+
+ r.INPUT = commands;
+ output_write(commands);
+ commandline_parseCommandLine(1,1);
+}
+
+
+// ***** displayProtocolDetail(interfacename) *****
+// IN: interface name
+// DO: to display the protocol details when the user type show protocol command
+// NOTE:
+
+function commands_displayProtocolDetail(interfacename)
+{
+ var rptr = eval("_root.r" + _root.active_router + ".run." + interfaceName );
+ if (rptr.shutdown == true)
+ {
+ output_write(interfacename);
+ output_write(" is administratively down, line protocol is down\n");
+ }
+ else
+ {
+ output_write(interfacename);
+ output_write(" is up, line protocol is up\n");
+ }
+
+ if ( rptr.ip != "")
+ {
+ output_write(" Internet address is ");
+ output_write(rptr.ip);
+ output_write("\n");
+ }
+}
+
+
+// ***** displayInterfaceDetail(interfacename) *****
+// IN: interface name
+// DO: to display the interface details when the user type show interface command
+// NOTE:
+
+function commands_displayInterfaceDetail(interfacename)
+{
+ var rptr = eval("_root.r" + _root.active_router + ".run." + interfaceName );
+
+ if (rptr.shutdown == true)
+ {
+ output_write(" is administratively down, line protocol is down\n");
+ }
+ else
+ {
+ output_write(" is up, line protocol is up\n");
+ }
+
+ if (rptr.mac != "")
+ output_write(" Hardware is Lance, address is " + rptr.mac + "(bia " + rptr.mac + ")\n");
+
+ if ( rptr.ip != "")
+ {
+ output_write(" Internet address is ");
+ output_write(rptr.ip);
+ }
+
+ if ( rptr.subnet != "")
+ {
+ output_write("/" + findOneTotal(rptr.subnet));
+ output_write("\n");
+ }
+}
+
+function commands_displayInterfaceE0()
+{
+ output_write(" MTU 1500 bytes, BW 10000 Kbit, DLY 1000 usec,\n");
+ output_write(" reliability 252/255, txload 1/255, rxload 1/255\n");
+ output_write(" Encapsulation ARPA, loopback not set\n");
+ output_write(" Keepalive set (10 sec)\n");
+ output_write(" ARP type: ARPA, ARP Timeout 04:00:00\n");
+ output_write(" Last input never, output 00:00:20, output hang never\n");
+ output_write(" Last clearing of \"show interface\" counters never\n");
+ output_write(" Queueing strategy: fifo\n");
+ output_write(" Output queue 0/40, 0 drops; input queue 0/75, 0 drops\n");
+ output_write(" 5 minute input rate 0 bits/sec, 0 packets/sec\n");
+ output_write(" 5 minute output rate 0 bits/sec, 0 packets/sec\n");
+ output_write(" 0 packets input, 0 bytes, 0 no buffer\n");
+ output_write(" Received 0 broadcasts, 0 runts, 0 giants, 0 throttles\n");
+ output_write(" 0 input errors, 0 CRC, 0 frame, 0 overrun, 0 ignored\n");
+ output_write(" 0 input packets with dribble condition detected\n");
+ output_write(" 6 packets output, 360 bytes, 0 underruns\n");
+ output_write(" 6 output errors, 0 collisions, 3 interface resets\n");
+ output_write(" 0 babbles, 0 late collision, 0 deferred\n");
+ output_write(" 6 lost carrier, 0 no carrier\n");
+ output_write(" 0 output buffer failures, 0 output buffers swapped out\n");
+}
+
+function commands_displayInterfaceS0()
+{
+ output_write(" Hardware is HD64570\n");
+ output_write(" MTU 1500 bytes, BW 1544 Kbit, DLY 20000 usec,\n");
+ output_write(" reliability 255/255, txload 1/255, rxload 1/255\n");
+ output_write(" Encapsulation HDLC, loopback not set\n");
+ output_write(" Keepalive set (10 sec)\n");
+ output_write(" Last input never, output never, output hang never\n");
+ output_write(" Last clearing of \"show interface\" counters never\n");
+ output_write(" Input queue: 0/75/0 (size/max/drops); Total output drops: 0\n");
+ output_write(" Queueing strategy: weighted fair\n");
+ output_write(" Output queue: 0/1000/64/0 (size/max total/threshold/drops)\n");
+ output_write(" Conversations 0/0/256 (active/max active/max total)\n");
+ output_write(" Reserved Conversations 0/0 (allocated/max allocated)\n");
+ output_write(" 5 minute input rate 0 bits/sec, 0 packets/sec\n");
+ output_write(" 5 minute output rate 0 bits/sec, 0 packets/sec\n");
+ output_write(" 0 packets input, 0 bytes, 0 no buffer\n");
+ output_write(" Received 0 broadcasts, 0 runts, 0 giants, 0 throttles\n");
+ output_write(" 0 input errors, 0 CRC, 0 frame, 0 overrun, 0 ignored, 0 abort\n");
+ output_write(" 0 packets output, 0 bytes, 0 underruns\n");
+ output_write(" 0 output errors, 0 collisions, 1 interface resets\n");
+ output_write(" 0 output buffer failures, 0 output buffers swapped out\n");
+ output_write(" 0 carrier transitions\n");
+ output_write(" DCD=down DSR=down DTR=down RTS=down CTS=down\n");
+}
+
+
+// ***** findOneTotal(subnetmask) *****
+// IN: subnetmask
+// DO: find the number of continuous one's in an subnet mask
+// NOTE:
+
+function findOneTotal(subnetmask)
+{
+ var total = 0;
+ var ipArray = subnetmask.split(".");
+ if (ipArray.length == 4)
+ {
+ for (var i = 0; i < 4; i++)
+ {
+ total = total + checkBits(ipArray[i]);
+ if ( ( (total % 8) != 0) || (total == 0) )
+ break;
+ }
+ }
+ else
+ {
+ total = 0;
+ }
+
+ return total;
+}
+
+
+
+function checkBits(num)
+{
+ var remainder = 0;
+ var binaryArray = new Array();
+ ctr = 0;
+ if (num == 0)
+ return_value = 0;
+ else
+ return_value = 8;
+
+ while (num > 0)
+ {
+ remainder = num % 2;
+ num = int( num / 2 );
+ binaryArray[ctr] = remainder;
+ ctr = ctr + 1;
+ }
+
+ for (var i = 0; i < binaryArray.length; i++)
+ {
+ if ( binaryArray[binaryArray.length - 1 - i] == 0)
+ {
+ return_value = i;
+ break;
+ }
+ }
+ return return_value;
+}
+
+
+function commands_checkABCD(abcd)
+{
+ var octet = abcd.split(".");
+
+ if (octet.length != 4)
+ return false;
+
+ for (var i=0; i<4; i++)
+ {
+ if (isNaN(octet[i]))
+ return false;
+
+ if ((Number(octet[i]) < 0) || (Number(octet[i]) > 255))
+ return false;
+ }
+
+ return true;
+}
+
+function commands_checkHHH(hhh)
+{
+ var hexPart = hhh.split(".");
+ var hexValue;
+
+ if (hexPart.length != 3)
+ return false;
+
+ for (var i=0; i<3; i++)
+ {
+ hexValue = parseInt(hexPart[i], 16);
+
+ if (isNaN(hexValue))
+ return false;
+
+ if ((hexValue < 0) || (hexValue > 0xffff))
+ return false;
+ }
+
+ return true;
+}
+
|