//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

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;

}