From 33613a85afc4b1481367fbe92a17ee59c240250b Mon Sep 17 00:00:00 2001 From: Sven Eisenhauer Date: Fri, 10 Nov 2023 15:11:48 +0100 Subject: add new repo --- .../en_CCNA4_v30/elabs/Engine/actions_commands.txt | 1593 ++++++++++++++++++++ 1 file changed, 1593 insertions(+) create mode 100644 Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/actions_commands.txt (limited to 'Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/actions_commands.txt') 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 . +//DO: add a new subcommand to this command +//OUT: +// +// 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 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: +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 +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 +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")) + { + 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 +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; i1 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 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 longest) + { + longest = commandArray[i].length; + } + } + + //for-loop to iterate through all subcommands in 'commandArray' + for (var i=0; i" + _root.deebug1 = commandArray + ";" + typeof(commandArray.enter); + if ((typeof(commandArray.enter) == "function") || (commandArray.enter == true)) + { + output_write(" \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; +} + -- cgit v1.2.3