nmTcl.c

Go to the documentation of this file.

/** \file    nmTcl.c
\brief Routines needed to interface with Tcl
*/


#include "nm.h"
#include "evl.h"

/*---------------------------------------------------------------------------*/
/* Variable declarations                                                     */
/*---------------------------------------------------------------------------*/

/**AutomaticStart*************************************************************/

/*---------------------------------------------------------------------------*/
/* Static function prototypes                                                */
/*---------------------------------------------------------------------------*/

static void registerTclCommands (Tcl_Interp * interp, Nm_TclCD_t * cd);
static int tclEvlMgrPrintRules (ClientData cd, Tcl_Interp * interp,
                   int objc, Tcl_Obj * const objv[]);
static int tclEvlMgrRegisterUcode (ClientData cd, Tcl_Interp * interp,
                   int objc, Tcl_Obj * const objv[]);
static int tclEvlRoute (ClientData cd, Tcl_Interp * interp, int objc,
            Tcl_Obj * const objv[]);
static int tclEvlBuildManagerFromText (ClientData cd , Tcl_Interp * interp,
                       int objc, Tcl_Obj * const objv[]);
static int tclEvlBuildManagerFromFile (ClientData cd , Tcl_Interp * interp,
                       int objc, Tcl_Obj * const objv[]);
static int tclStopProfiler (ClientData cd , Tcl_Interp * interp, int objc,
                Tcl_Obj * const objv[]);
static int tclCreatePktFromText (ClientData cd , Tcl_Interp * interp,
                 int objc, Tcl_Obj * const objv[]);
static int tclCreatePktArrayFromText (ClientData cd , Tcl_Interp * interp,
                      int objc, Tcl_Obj * const objv[]);
static int tclEvlDoTclActions (ClientData cd , Tcl_Interp * interp,
                   int objc, Tcl_Obj * const objv[]);
static int tclEvlComputeRuleSetForEth (ClientData cd, Tcl_Interp * interp,
                       int objc, Tcl_Obj * const objv[]);
static int tclEvlComputeRuleSetForEthSTRING (ClientData cd ,
                         Tcl_Interp * interp, int objc,
                         Tcl_Obj * const objv[]);
static char *computeStringFromIpAddress (u_int32_t aNumIp);
static int pktReadIpInfo (ClientData cd , Tcl_Interp * interp, int objc,
              Tcl_Obj * const objv[]);
static int pktReadIpFlags (ClientData cd , Tcl_Interp * interp, int objc,
               Tcl_Obj * const objv[]);
static int pktReadTcpFlags (ClientData cd , Tcl_Interp * interp, int objc,
                Tcl_Obj * const objv[]);
static int tclTestC (ClientData cd , Tcl_Interp * interp, int objc,
             Tcl_Obj * const objv[]);
static int tclTestTk (ClientData cd , Tcl_Interp * interp, int objc,
             Tcl_Obj * const objv[]);
// static int tclTestCplusplus (ClientData cd , Tcl_Interp * interp, int objc,
//           Tcl_Obj * const objv[]);
static int tclTestParser (ClientData cd , Tcl_Interp * interp, int objc,
              Tcl_Obj * const objv[]);
static int tclGetFileAsText (ClientData cd , Tcl_Interp * interp, int objc,
                 Tcl_Obj * const objv[]);
static int tclBufferWritePkts (ClientData cd , Tcl_Interp * interp,
                   int objc , Tcl_Obj * const objv[]);
static int tclWritePkts (ClientData cd , Tcl_Interp * interp, int objc ,
             Tcl_Obj * const objv[]);
static int tclTxPkt (ClientData cd , Tcl_Interp * interp, int objc ,
             Tcl_Obj * const objv[]);
static int tclInjectPkts (ClientData cd , Tcl_Interp * interp,
              int objc , Tcl_Obj * const objv[]);
static Pkt_TfcMode_t *readTfcModeParams (Tcl_Interp * interp);
static int tclTestTclAction (ClientData cd , Tcl_Interp * interp,
                 int objc , Tcl_Obj * const objv[]);
static int tclStTestPerf (ClientData cd , Tcl_Interp * interp, int objc ,
              Tcl_Obj * const objv[]);
static int tclStTest (ClientData cd , Tcl_Interp * interp, int objc ,
              Tcl_Obj * const objv[]);
static int tclCompressTestPerf (ClientData cd , Tcl_Interp * interp,
                int objc , Tcl_Obj * const objv[]);
static int tclCompressTestReduction (ClientData cd , Tcl_Interp * interp,
                     int objc , Tcl_Obj * const objv[]);
static int tclArrayTest (ClientData cd , Tcl_Interp * interp, int objc ,
             Tcl_Obj * const objv[]);
static int tclEvlMgrInsertPktIntoInputBuffer (ClientData cd ,
                          Tcl_Interp * interp,
                          int objc ,
                          Tcl_Obj * const objv[]);
static double computeRate (int size, int numPackets, util_timing_t diffTime);

/**AutomaticEnd***************************************************************/


/**
  * \brief Maps tcl values (strings) to C pointers
  *
  *     This table is needed because tcl operates on strings,
  * and when we want to return a pointer, it gets confused.
  * So we simply return a string that is the pointer in text
  * via sprintf( a, "%p", ptr ). When we need to pointer we
  * do a look-up on the passed argument.
  *
  *
  */

static st_table *tclToC = NIL (st_table);


/**
  * \brief If we want to use narya with a tcl script,
  * we call this function to register the commands exported
  *     from C, initialize the tclToC table, and then invoke the
  * script.
  */

int
Nm_Tcl (Tcl_Interp * interp, Nm_TclCD_t * cd)
{
  registerTclCommands (interp, cd);

  /// \todo Figure out a more meaninful way of having an init file
  sourceTclrc (interp);

/* 
From http://www.cs.ucla.edu/classes/cs217/ns-allinone-2.1b4/tcl-debug-1.9/INSTALL
1) The absolute simplest way is add the following line at some point
in your initialization.  (It always returns TCL_OK.)

    Tcldbg_Init(interp);

This will add a "debug" command to your interpreter.  (Inside your
application, "debug 1" will start the interpreter.  "debug 0" will
stop it.  When the debugger prompts for a command, type "h" for help.)

In the same file, add the following directive before the Dbg_On call:

    #include "tcldbg.h"

Add the libtcldebug.a to your link line.  Re-Make your application.

Print the document tcl-debug.ps to get the complete instructions on
how to hook the debugger into any Tcl program.  This describes other
options such as invoking the debugger on ^C, as well as the debugger
commands themselves.

*/

  // Tcldbg_Init (interp);

  return TCL_OK;
}


/**
  * \brief Source an init file called .tclrc.
  *
  * Look in local directory only.
  */

int
sourceTclrc (Tcl_Interp * interp)
{
  return Tcl_EvalFile (interp, ".tclrc");
}


/**
  * \brief Register all the commands exported to tcl
  */

static void
registerTclCommands (Tcl_Interp * interp, Nm_TclCD_t * cd)
{
  tclToC = Hash_InitTable ( ( int(*)() ) strcmp,  ( int(*)() ) st_strhash);
  array_t *cmdNames = array_alloc (char *, 0);
  array_t *cmdFunctions = array_alloc (Tcl_ObjCmdProc *, 0);

  array_insert_last (char *, cmdNames, "testact");
  array_insert_last (Tcl_ObjCmdProc *, cmdFunctions, tclTestTclAction);

  array_insert_last (char *, cmdNames, "test_tk");
  array_insert_last (Tcl_ObjCmdProc *, cmdFunctions, tclTestTk );

  array_insert_last (char *, cmdNames, "testC1");
  array_insert_last (Tcl_ObjCmdProc *, cmdFunctions, tclTestC );

  array_insert_last (char *, cmdNames, "testC2");
  array_insert_last (Tcl_ObjCmdProc *, cmdFunctions, tclTestC );

  array_insert_last (char *, cmdNames, "testC3");
  array_insert_last (Tcl_ObjCmdProc *, cmdFunctions, tclTestC );

  array_insert_last (char *, cmdNames, "testParser");
  array_insert_last (Tcl_ObjCmdProc *, cmdFunctions, tclTestParser );

  array_insert_last (char *, cmdNames, "getFileAsText");
  array_insert_last (Tcl_ObjCmdProc *, cmdFunctions, tclGetFileAsText );

  array_insert_last (char *, cmdNames, "evlRoute");
  array_insert_last (Tcl_ObjCmdProc *, cmdFunctions, tclEvlRoute );

  array_insert_last (char *, cmdNames, "evlBuildManagerFromText");
  array_insert_last (Tcl_ObjCmdProc *, cmdFunctions,
             tclEvlBuildManagerFromText);

  array_insert_last (char *, cmdNames, "testEvlBuildManagerFromFile");
  array_insert_last (Tcl_ObjCmdProc *, cmdFunctions,
             tclEvlBuildManagerFromFile);

  array_insert_last (char *, cmdNames, "evlBuildManagerFromFile");
  array_insert_last (Tcl_ObjCmdProc *, cmdFunctions,
             tclEvlBuildManagerFromFile);

  array_insert_last (char *, cmdNames, "evlComputeRuleSetForEth");
  array_insert_last (Tcl_ObjCmdProc *, cmdFunctions,
             tclEvlComputeRuleSetForEth);

  array_insert_last (char *, cmdNames, "evlComputeRuleSetForEthSTRING");
  array_insert_last (Tcl_ObjCmdProc *, cmdFunctions,
             tclEvlComputeRuleSetForEthSTRING);

  array_insert_last (char *, cmdNames, "createPktFromText");
  array_insert_last (Tcl_ObjCmdProc *, cmdFunctions, tclCreatePktFromText);

  array_insert_last (char *, cmdNames, "createPktArrayFromText");
  array_insert_last (Tcl_ObjCmdProc *, cmdFunctions,
             tclCreatePktArrayFromText);

  array_insert_last (char *, cmdNames, "evlDoTclActions");
  array_insert_last (Tcl_ObjCmdProc *, cmdFunctions, tclEvlDoTclActions);

  array_insert_last (char *, cmdNames, "pktReadSrcIp");
  array_insert_last (Tcl_ObjCmdProc *, cmdFunctions, pktReadIpInfo);

  array_insert_last (char *, cmdNames, "pktReadContent");
  array_insert_last (Tcl_ObjCmdProc *, cmdFunctions, pktReadIpInfo);

  array_insert_last (char *, cmdNames, "pktReadDestIp");
  array_insert_last (Tcl_ObjCmdProc *, cmdFunctions, pktReadIpInfo);

  array_insert_last (char *, cmdNames, "pktReadTtl");
  array_insert_last (Tcl_ObjCmdProc *, cmdFunctions, pktReadIpInfo);

  array_insert_last (char *, cmdNames, "pktReadOffset");
  array_insert_last (Tcl_ObjCmdProc *, cmdFunctions, pktReadIpInfo);

  array_insert_last (char *, cmdNames, "pktReadLength");
  array_insert_last (Tcl_ObjCmdProc *, cmdFunctions, pktReadIpInfo);

  array_insert_last (char *, cmdNames, "pktReadIpFlags");
  array_insert_last (Tcl_ObjCmdProc *, cmdFunctions, pktReadIpFlags);

  array_insert_last (char *, cmdNames, "pktReadTcpDestPort");
  array_insert_last (Tcl_ObjCmdProc *, cmdFunctions, pktReadTcpInfo);

  array_insert_last (char *, cmdNames, "pktReadTcpSrcPort");
  array_insert_last (Tcl_ObjCmdProc *, cmdFunctions, pktReadTcpInfo);

  array_insert_last (char *, cmdNames, "pktReadTcpSeqNum");
  array_insert_last (Tcl_ObjCmdProc *, cmdFunctions, pktReadTcpInfo);

  array_insert_last (char *, cmdNames, "pktReadTcpAckNum");
  array_insert_last (Tcl_ObjCmdProc *, cmdFunctions, pktReadTcpInfo);

  array_insert_last (char *, cmdNames, "pktReadTcpFlags");
  array_insert_last (Tcl_ObjCmdProc *, cmdFunctions, pktReadTcpFlags);

  array_insert_last (char *, cmdNames, "checkHardware");
  array_insert_last (Tcl_ObjCmdProc *, cmdFunctions, Perf_CheckHardware);

  array_insert_last (char *, cmdNames, "timePerf");
  array_insert_last (Tcl_ObjCmdProc *, cmdFunctions, Perf_TimePerf);

  array_insert_last (char *, cmdNames, "timePerf2");
  array_insert_last (Tcl_ObjCmdProc *, cmdFunctions, Perf_TimePerf2);

  array_insert_last (char *, cmdNames, "spacePerf");
  array_insert_last (Tcl_ObjCmdProc *, cmdFunctions, Perf_SpacePerf);

  array_insert_last (char *, cmdNames, "injectPkts");
  array_insert_last (Tcl_ObjCmdProc *, cmdFunctions, tclInjectPkts);

  array_insert_last (char *, cmdNames, "txPkt");
  array_insert_last (Tcl_ObjCmdProc *, cmdFunctions, tclTxPkt);

  array_insert_last (char *, cmdNames, "writePkts");
  array_insert_last (Tcl_ObjCmdProc *, cmdFunctions, tclWritePkts);

  array_insert_last (char *, cmdNames, "bufferWritePkts");
  array_insert_last (Tcl_ObjCmdProc *, cmdFunctions, tclBufferWritePkts);

  array_insert_last (char *, cmdNames, "timingCheck");
  array_insert_last (Tcl_ObjCmdProc *, cmdFunctions, Perf_CheckTimingCode);

  array_insert_last (char *, cmdNames, "compTestPerf");
  array_insert_last (Tcl_ObjCmdProc *, cmdFunctions, tclCompressTestPerf);

  array_insert_last (char *, cmdNames, "compTestReduction");
  array_insert_last (Tcl_ObjCmdProc *, cmdFunctions,
             tclCompressTestReduction);

  array_insert_last (char *, cmdNames, "evlMgrRegisterUcode");
  array_insert_last (Tcl_ObjCmdProc *, cmdFunctions, tclEvlMgrRegisterUcode);

  // alias evlMgrRegisterUcode to register_c-ext 
  array_insert_last (char *, cmdNames, "register_c-ext");
  array_insert_last (Tcl_ObjCmdProc *, cmdFunctions, tclEvlMgrRegisterUcode);

  array_insert_last (char *, cmdNames, "evlMgrPrintRules");
  array_insert_last (Tcl_ObjCmdProc *, cmdFunctions, tclEvlMgrPrintRules);

  array_insert_last (char *, cmdNames, "evlMgrInsertPktIntoInputBuffer");
  array_insert_last (Tcl_ObjCmdProc *, cmdFunctions,
             tclEvlMgrInsertPktIntoInputBuffer);

  array_insert_last (char *, cmdNames, "array_test");
  array_insert_last (Tcl_ObjCmdProc *, cmdFunctions, tclArrayTest);

  array_insert_last (char *, cmdNames, "st_test_perf");
  array_insert_last (Tcl_ObjCmdProc *, cmdFunctions, tclStTestPerf);

  array_insert_last (char *, cmdNames, "st_test");
  array_insert_last (Tcl_ObjCmdProc *, cmdFunctions, tclStTest);

  array_insert_last (char *, cmdNames, "stop_profiler");
  array_insert_last (Tcl_ObjCmdProc *, cmdFunctions, tclStopProfiler);

  // array_insert_last (char *, cmdNames, "test_cpp");
  // array_insert_last (Tcl_ObjCmdProc *, cmdFunctions, tclTestCplusplus);

  int i;
  for (i = 0; i < array_n (cmdNames); i++)
    {
      char *cmdName = array_fetch (char *, cmdNames, i);
      Tcl_ObjCmdProc *cmdFunc =
    array_fetch (Tcl_ObjCmdProc *, cmdFunctions, i);
      Tcl_CreateObjCommand (interp, cmdName, cmdFunc, cd,
                NIL (Tcl_CmdDeleteProc));
    }
}


/**
  *     \brief Print rules associated with manager
  *
  */

static int
tclEvlMgrPrintRules (ClientData cd,
            Tcl_Interp * interp,
            int objc, Tcl_Obj * const objv[])
{
  assert (objc == 2);

  Evl_Manager_t *mgr =
    (Evl_Manager_t *) Nm_TclCDReadPtrFromObj (interp, (Nm_TclCD_t *) cd, objv[1]);

  int i;
  for ( i = 0 ; i < mgr->numAllRules; i++ ) {
    char *aRule = array_fetch( char *, mgr->rawRules, i );
    printf("Rule %d: %s\n", i, aRule );
  }
  return TCL_OK;

}

/**
  *     \brief Register a new function with given name
  *
  * Command is evlMgrRegisterUcode $mgr "functionName" "/home/adnan/pathToLib"
  */

static int
tclEvlMgrRegisterUcode (ClientData cd,
            Tcl_Interp * interp,
            int objc, Tcl_Obj * const objv[])
{
  assert (objc == 4);

  Evl_Manager_t *mgr =
    (Evl_Manager_t *) Nm_TclCDReadPtrFromObj (interp, (Nm_TclCD_t *) cd, objv[1]);
  char *ucodeName = strdup (objv[2]->bytes);
  char *ucodeLibrary = strdup (objv[3]->bytes);

  Os_DynamicallyLinkFunction (mgr->ucodeNameToFunction, ucodeName,
                  ucodeLibrary);

  return TCL_OK;

}


/**
  *     \brief Tcl code that checks performance of Narya on synthetic traffic.
  */

static int
tclEvlRoute (ClientData cd,
         Tcl_Interp * interp, int objc, Tcl_Obj * const objv[])
{
  int iBufSize = 2;
  Nm_TclGetIntVar (interp, "iBufSize", &iBufSize);

  int ppCacheSize = 2;
  Nm_TclGetIntVar (interp, "ppCacheSize", &ppCacheSize);

  int oBufSize = 2;
  Nm_TclGetIntVar (interp, "oBufSize", &oBufSize);

  int actionBufSize = 2;
  Nm_TclGetIntVar (interp, "actionBufSize", &actionBufSize);

  int numIterations = 1;
  Nm_TclGetIntVar (interp, "numIterations", &numIterations);

  int maxNumPktsToRead = 1;
  Nm_TclGetIntVar (interp, "maxNumPktsToRead", &maxNumPktsToRead);

  char *basicSliceString = "0.001";
  Nm_TclGetStringVar (interp, "basicSlice", &basicSliceString);
  double basicSlice;
  sscanf (basicSliceString, "%lf", &basicSlice);

  int getPacketsWeight = 1;
  Nm_TclGetIntVar (interp, "getPacketsWeight", &getPacketsWeight);

  int computeActionsWeight = 1;
  Nm_TclGetIntVar (interp, "computeActionsWeight", &computeActionsWeight);

  int performActionsWeight = 1;
  Nm_TclGetIntVar (interp, "performActionsWeight", &performActionsWeight);

  int queuingWeight = 1;
  Nm_TclGetIntVar (interp, "queuingWeight", &queuingWeight);

  int writePacketsWeight = 1;
  Nm_TclGetIntVar (interp, "writePacketWeight", &writePacketsWeight);

  int recordPktsWritten = 0;
  Nm_TclGetIntVar (interp, "recordPktsWritten", &recordPktsWritten);

  int recordStats = 0;
  Nm_TclGetIntVar (interp, "recordStats", &recordStats);
  Evl_BridgeStats_t *stats;
  Evl_BridgeStats_t **statsPtr = NIL (Evl_BridgeStats_t *);
  if (recordStats)
    {
      statsPtr = &stats;
    }

  assert (objc >= 2);       // pktArray is optional, used only in synthetic mode

  Evl_Manager_t *mgr =
    (Evl_Manager_t *) Nm_TclCDReadPtrFromObj (interp, (Nm_TclCD_t *) cd, objv[1]);
  array_t *pktArray = NIL (array_t);
  int useSynthetic = 0;
  array_t *ackSeqNumArray = NIL (array_t);
  if (objc == 3)
    {
      // two arguments -> must be synthetic case
      pktArray = (array_t *) Nm_TclCDReadPtrFromObj (interp, (Nm_TclCD_t *) cd, objv[2]);
      useSynthetic = 1;
      if (recordPktsWritten)
    {
      ackSeqNumArray = array_alloc (Pkt_EthernetHdr_t *, 0);
    }
    }

  array_t *inArray = array_alloc (char *, 0);
  array_t *outArray = array_alloc (char *, 0);
  if (!useSynthetic)
    {
      Nm_TclGetArrayVar (interp, "ineth", inArray);
      Nm_TclGetArrayVar (interp, "outeth", outArray);
    }


  Evl_Route (mgr, pktArray, iBufSize, ppCacheSize, oBufSize,
         actionBufSize, maxNumPktsToRead,
         numIterations, useSynthetic, inArray, outArray,
         basicSlice, getPacketsWeight, computeActionsWeight,
         performActionsWeight, queuingWeight, writePacketsWeight,
         ackSeqNumArray, statsPtr);

  Tcl_Obj *resultObj = Tcl_NewStringObj ("", -1);
  if (statsPtr != NIL (Evl_BridgeStats_t *))
    {
      char statsString[1000];
      sprintf (statsString,
           "Start time\t\t= %f\n"
           "Finish time\t\t= %f\n"
           "Num entered\t\t= %d\n"
           "Num exited\t\t= %d\n"
           "Bytes written\t\t= %d\n"
           "Num Drop: FullRuleCacheArray\t= %d\n"
           "Num Drop: FullActionBuf\t\t= %d\n"
           "Num Drop: FullObuf\t\t= %d\n"
           "Num Drop: FullQueue\t\t= %d\n"
           "Num Drop: Action\t\t= %d\n"
           "Num Drop: OverRate\t\t= %d\n"
           "Num Drop: OverFlowRate\t\t= %d\n",
           util_timing_secs (stats->startTime),
           util_timing_secs (stats->finishTime),
           stats->numEntered,
           stats->numExited,
           stats->bytesWritten,
           stats->numDroppedFullRuleCacheArray,
           stats->numDroppedFullActionBuf,
           stats->numDroppedFullObuf,
           stats->numDroppedFullQueue,
           stats->numDroppedBecauseOfAction,
           stats->numDroppedOverRate, stats->numDroppedOverFlowRate);
      // printf("all stats:\n%s\n", statsString );
      char rateString[100];
      double delta =
    util_timing_secs (stats->lastPktWritten) -
    util_timing_secs (stats->firstPktRead);
      double rate = (8.0 * (double) stats->bytesWritten) / delta;
      sprintf (rateString, "%.1f", rate);
      char *memEffResult = strdup (rateString);
      Tcl_SetStringObj (resultObj, memEffResult, -1);
    }
  else if (ackSeqNumArray != NIL (array_t))
    {
      // estimate 10 bytes for each int id plus bytes for space
      char *seqTxt = (char *) malloc (1 + (array_n (ackSeqNumArray)) * 12);
      seqTxt[0] = '\0';     // in case there are no applicable rules
      char *tmp = seqTxt;
      int i;
      for (i = 0; i < array_n (ackSeqNumArray); i++)
    {
      Pkt_EthernetHdr_t *aPkt =
        array_fetch (Pkt_EthernetHdr_t *, ackSeqNumArray, i);
      if (Pkt_EthernetReadL3Type (aPkt) != Pkt_L3ProtIp_c)
        {
          // need this because we may be creating a compressed packet, which isnt ip
          continue;
        }
      Pkt_TcpHdr_t *aTcpPkt = Pkt_EthernetExtractTcp (aPkt);
      sprintf (tmp, "%d%s",
           aTcpPkt->ackNum,
           ((i == (array_n (ackSeqNumArray) - 1)) ? "" : ","));
      tmp += strlen (tmp);
    }
      array_free (ackSeqNumArray);
      char *memEffResult = strdup (seqTxt);
      free (seqTxt);
      Tcl_SetStringObj (resultObj, memEffResult, -1);
    }
  else
    {
      Tcl_SetStringObj (resultObj, "", -1);
    }
  Tcl_SetObjResult (interp, resultObj);

  return TCL_OK;
}


/**
  * \brief Tcl code that builds a manager from a set of rules described in text
  */

static int
tclEvlBuildManagerFromText (ClientData cd ,
                Tcl_Interp * interp,
                int objc, Tcl_Obj * const objv[])
{
  assert (objc == 2);

  char *mgrText = Tcl_GetStringFromObj (objv[1], NIL (int));
  Evl_Manager_t *result = Evl_BuildManager (mgrText, interp, cd);

  Nm_TclResult (interp, (Nm_TclCD_t *) cd, result);

  return TCL_OK;
}


/**
  * \brief Tcl code that builds a manager from a set of rules described in a file
  */

static int
tclEvlBuildManagerFromFile (ClientData cd ,
                Tcl_Interp * interp,
                int objc, Tcl_Obj * const objv[])
{
  assert (objc == 2);

  char *fileName = Tcl_GetStringFromObj (objv[1], NIL (int));
  FILE *ruleFile = fopen (fileName, "r");
  if (ruleFile == NIL (FILE))
    {
      printf
    ("Error, could not open file %s, returning without building manager from file\n",
     fileName);
      return TCL_OK;
    }
  char *ruleFileInText = util_file_to_string (ruleFile);
  fclose (ruleFile);

  Evl_Manager_t *result = Evl_BuildManager (ruleFileInText, interp, cd);

  char *cmdName = Tcl_GetStringFromObj (objv[0], NIL (int));
  if (util_strequal (cmdName, "evlBuildManagerFromFile"))
    {
      Nm_TclResult (interp, cd, result);
    }
  else
    {
      assert (util_strequal (cmdName, "testEvlBuildManagerFromFile"));
      Tcl_Obj *resultObj = Tcl_GetObjResult (interp);
      Tcl_SetIntObj (resultObj, 0);
    }

  return TCL_OK;
}


/**
  * \brief Code to take a raw pointer and set it as the result of a tcl command
  */

void
Nm_TclResult (Tcl_Interp * interp, ClientData cd, void *ptr)
{
  int resultId = Nm_TclCDStorePtr ((Nm_TclCD_t *) cd, ptr);
  Tcl_Obj *resultObj = Tcl_GetObjResult (interp);
  Tcl_SetIntObj (resultObj, resultId);
}


/**
  * \brief Build a packet from the given text string
  */

static int
tclCreatePktFromText (ClientData cd ,
              Tcl_Interp * interp, int objc, Tcl_Obj * const objv[])
{
  assert (objc == 2);
  char *pktText = Tcl_GetStringFromObj (objv[1], NIL (int));
  Pkt_EthernetHdr_t *result = Pkt_CreatePktFromString (pktText);

  Nm_TclResult (interp, (Nm_TclCD_t *) cd, (void *) result);

  return TCL_OK;
}


/**
  * \brief Build a packet from the given text string
  */

static int
tclCreatePktArrayFromText (ClientData cd ,
               Tcl_Interp * interp,
               int objc, Tcl_Obj * const objv[])
{
  assert (objc == 2);

  array_t *result = array_alloc (Pkt_EthernetHdr_t *, 0);

  int numPkts;
  Tcl_Obj **objArray;
  Tcl_ListObjGetElements (interp, objv[1], &numPkts, &objArray);

  int i;
  for (i = 0; i < numPkts; i++)
    {
      Tcl_Obj *pktObj;
      int code  = Tcl_ListObjIndex (interp, objv[1], i, &pktObj);
      char *pktText = Tcl_GetStringFromObj (pktObj, NIL (int));
      Pkt_EthernetHdr_t *pkt = Pkt_CreatePktFromString (pktText);
      array_insert_last (Pkt_EthernetHdr_t *, result, pkt);
    }

  Nm_TclResult (interp, (Nm_TclCD_t *) cd, (void *) result);

  return TCL_OK;
}


/**
  * \brief Perform tcl actions on a given packet - pass in
  *     a manager and an array of rules.
  */

static int
tclEvlDoTclActions (ClientData cd ,
            Tcl_Interp * interp, int objc, Tcl_Obj * const objv[])
{
  assert (objc == 4);

  Evl_Manager_t *mgr =
    (Evl_Manager_t *) Nm_TclCDReadPtrFromObj (interp, (Nm_TclCD_t *) cd, objv[1]);
  array_t *applicableRules =
    (array_t *) Nm_TclCDReadPtrFromObj (interp, (Nm_TclCD_t *) cd, objv[2]);
  Pkt_EthernetHdr_t *pkt =
    (Pkt_EthernetHdr_t *) Nm_TclCDReadPtrFromObj (interp, (Nm_TclCD_t *) cd, objv[3]);

  Tcl_Obj *listPtr = Tcl_NewListObj (0, (Tcl_Obj **) NULL);

  char *tmp = (char *) malloc (2048 * mgr->numAllRules);    // AA: need better estimate
  tmp[0] = '\0';
  int i;
  for (i = 0; i < array_n (applicableRules); i++)
    {
      int ruleId = array_fetch (int, applicableRules, i);
      Rlp_Action_t *action =
    array_fetch (Rlp_Action_t *, mgr->actionArray, ruleId);
      if (action->type != Rlp_ActionUscript_c)
    {
      continue;
    }
      char *tclRuleString = action->uscript;
      sprintf (tmp, "%s", tclRuleString);
      Tcl_Obj *tmpObjv[2];
      Tcl_Obj *tmpPtr = Tcl_NewStringObj (strdup (tmp), -1);
      tmpObjv[0] = tmpPtr;
      int resultId = Nm_TclCDStorePtr ((Nm_TclCD_t *) cd, pkt);
      tmpObjv[1] = Tcl_NewIntObj (resultId);
      Tcl_EvalObjv (interp, 2, tmpObjv, 0);
      Tcl_ListObjAppendElement (interp, listPtr, tmpPtr);
    }
  array_free (applicableRules);

  Tcl_SetObjResult (interp, listPtr);

  return TCL_OK;
}


/**
  * \brief Compute rules applicable to a given packet.
  *
  * Pass in a manager and a pkt, get back an id to an array of integers, indexing
  * the manager rules that were applicable.
  */

static int
tclEvlComputeRuleSetForEth (ClientData cd,
                Tcl_Interp * interp,
                int objc, Tcl_Obj * const objv[])
{
  assert (objc == 3);

  Evl_Manager_t *mgr =
    (Evl_Manager_t *) Nm_TclCDReadPtrFromObj (interp, (Nm_TclCD_t *) cd, objv[1]);
  Pkt_EthernetHdr_t *pkt =
    (Pkt_EthernetHdr_t *) Nm_TclCDReadPtrFromObj (interp, (Nm_TclCD_t *) cd, objv[2]);
  array_t *applicableRules = array_alloc (int, 0);
  Pkt_ProcessPkt_t pp;
  pp.pkt = pkt;
  pp.applicableRules = applicableRules;
  Evl_ComputeRuleSetForEth (&pp, mgr);

  array_t *result = array_dup (applicableRules);
  Nm_TclResult (interp, (Nm_TclCD_t *) cd, (void *) result);

  return TCL_OK;
}


/**
  * \brief Compute rules applicable to a given packet 
  *
  * Pass in a manager and a pkt, get back a string of integers, indexing
  * the manager rules that were applicable.
  */

static int
tclEvlComputeRuleSetForEthSTRING (ClientData cd ,
                  Tcl_Interp * interp,
                  int objc, Tcl_Obj * const objv[])
{
  assert (objc == 3);

  Evl_Manager_t *mgr =
    (Evl_Manager_t *) Nm_TclCDReadPtrFromObj (interp, (Nm_TclCD_t *) cd, objv[1]);
  Pkt_EthernetHdr_t *pkt =
    (Pkt_EthernetHdr_t *) Nm_TclCDReadPtrFromObj (interp, (Nm_TclCD_t *) cd, objv[2]);

  array_t *applicableRules = array_alloc (int, 0);
  Pkt_ProcessPkt_t pp;
  pp.pkt = pkt;
  pp.applicableRules = applicableRules;
  pp.inIf = NIL (Pkt_LibPcap_t);
  Evl_ComputeRuleSetForEth (&pp, mgr);

  char *result = (char *) malloc (mgr->numAllRules * 12);   // estimate 10 bytes for each int id plus bytes for space
  result[0] = '\0';     // in case there are no applicable rules
  char *tmp = result;
  int i;
  for (i = 0; i < array_n (applicableRules); i++)
    {
      int ruleid = array_fetch (int, applicableRules, i);
      sprintf (tmp, "%d%s", ruleid,
           ((i == (array_n (applicableRules) - 1)) ? "" : ","));
      tmp += strlen (tmp);
    }
  array_free (applicableRules);
  char *memEffResult = strdup (result);
  free (result);

  Tcl_Obj *resultObj = Tcl_GetObjResult (interp);
  Tcl_SetStringObj (resultObj, memEffResult, -1);

  return TCL_OK;
}


/**
  * \brief Code encapsulating getting a string var from Tcl environment
  */

int
Nm_TclGetStringVar (Tcl_Interp * interp, char *tclVarName, char **result)
{
  const char *tmp = Tcl_GetVar (interp, tclVarName, 0);
  if (tmp != NIL (char))
    {
      *result = strdup (tmp);
      return true;
    }
  return false;
}


/**
  * \brief Code encapsulating getting a double var from Tcl environment
  */

int
Nm_TclGetDoubleVar (Tcl_Interp * interp, char *tclVarName, double *result)
{
  const char *tmp = Tcl_GetVar (interp, tclVarName, 0);
  double tmpDouble;
  if (tmp != NIL (char))
    {
      sscanf (tmp, "%lf", &tmpDouble);
      *result = tmpDouble;
      return true;
    }
  return false;
}


/**
  * \brief Code encapsulating getting an array var from Tcl environment
  */

int
Nm_TclGetArrayVar (Tcl_Interp * interp, char *tclVarName, array_t * result)
{
  const char *tmp = Tcl_GetVar (interp, tclVarName, 0);
  int listArgc;
  const char **listArgv;
  if (Tcl_SplitList (interp, tmp, &listArgc, &listArgv) != TCL_OK)
    {
      return false;
    }
  int i;
  for (i = 0; i < listArgc; i++)
    {
      printf ("%s\n", listArgv[i]);
      char *dupName = strdup (listArgv[i]);
      array_insert_last (char *, result, dupName);
    }
  return true;

}


/**
  * \brief Code encapsulating getting an int var from Tcl environment
  */

int
Nm_TclGetIntVar (Tcl_Interp * interp, char *tclVarName, int *result)
{
  const char *tmp = Tcl_GetVar (interp, tclVarName, 0);
  if (tmp != NIL (char))
    {
      *result = atoi (tmp);
      return true;
    }
  return false;
}


/**
  * \brief Allocate a client data structure
  */

Nm_TclCD_t *
Nm_TclCDInit ()
{
  Nm_TclCD_t *result = (Nm_TclCD_t *) malloc (sizeof (Nm_TclCD_t));
  result->idToPtr = array_alloc (char *, 0);
  result->freeIds = array_alloc (int, 0);

  return result;
}


/**
  * \brief Store a pointer in the CD structure.  Return the
  * int id of this pointer.
  */

int
Nm_TclCDStorePtr (Nm_TclCD_t * cd, void *ptr)
{
  int result;
  int index;

  if (array_n (cd->freeIds) == 0)
    {
      result = array_n (cd->idToPtr) + Nm_TclNumRetCodes_c;
      array_insert_last (void *, cd->idToPtr, ptr);
    }
  else
    {
      index = array_delete_last (int, cd->freeIds);
      array_insert (void *, cd->idToPtr, index, ptr);
      result = index + Nm_TclNumRetCodes_c;
    }
  return result;
}


/**
  * \brief Read a pointer from the CD structure from obj argument.
  */

void *
Nm_TclCDReadPtrFromObj (Tcl_Interp * interp,
            Nm_TclCD_t * cd, Tcl_Obj * const obj)
{
  int id;
  assert (TCL_OK == Tcl_GetIntFromObj (interp, obj, &id));
  return Nm_TclCDReadPtr (cd, id);
}


/**
  * \brief Read a pointer from the CD structure.
  */

void *
Nm_TclCDReadPtr (Nm_TclCD_t * cd, int id)
{
  int index = id - Nm_TclNumRetCodes_c;
  void *result = array_fetch (void *, cd->idToPtr, index);
  return result;
}


/**
  * \brief Return an id to the pool of available ids
  */

void
Nm_TclCDReuseId (Nm_TclCD_t * cd, int id)
{
  int index = id - Nm_TclNumRetCodes_c;
  array_insert_last (int, cd->freeIds, index);
}


/**
  * \brief Compute the string equivalent of an ip address
  */

static char *
computeStringFromIpAddress (u_int32_t aNumIp)
{
  char tmpbuf[40];

  u_int32_t mask = 0377;    // start with 0 means octal

  u_int32_t a1;
  u_int32_t a2;
  u_int32_t a3;
  u_int32_t a4;

  a1 = aNumIp & mask;
  a2 = (aNumIp >> 8) & mask;
  a3 = (aNumIp >> 16) & mask;
  a4 = (aNumIp >> 24) & mask;
  sprintf (tmpbuf, "%u.%u.%u.%u", a4, a3, a2, a1);

  return strdup (tmpbuf);
}


/**
  * \brief Get a tcl string for various numerical values in the ip pkt
  */

static int
pktReadIpInfo (ClientData cd ,
           Tcl_Interp * interp, int objc, Tcl_Obj * const objv[])
{
  assert (objc == 2);

  Pkt_EthernetHdr_t *pkt =
    (Pkt_EthernetHdr_t *) Nm_TclCDReadPtrFromObj (interp, (Nm_TclCD_t *) cd, objv[1]);
  Pkt_IpHdr_t *ipPkt = Pkt_EthernetExtractIp (pkt);
  u_int32_t result;
  u_int16_t length;
  char tmpbuf[2000];
  char *cmdName = Tcl_GetStringFromObj (objv[0], NIL (int));
  int computeIpAddressFlag = false;
  int getContent = false;
  char *resultString;

  if (util_strequal (cmdName, "pktReadSrcIp"))
    {
      result = ipPkt->sourceIp;
      computeIpAddressFlag = true;
    }
  else if (util_strequal (cmdName, "pktReadDestIp"))
    {
      result = ipPkt->destIp;
      computeIpAddressFlag = true;
    }
  else if (util_strequal (cmdName, "pktReadOffset"))
    {
      result = ipPkt->offset;
      assert (result < 65536);
    }
  else if (util_strequal (cmdName, "pktReadTtl"))
    {
      result = ipPkt->TTL;
      assert (result < 256);
    }
  else if (util_strequal (cmdName, "pktReadLength"))
    {
      result = ipPkt->length;
      assert (result < 65526);
    }
  else if (util_strequal (cmdName, "pktReadContent"))
    {
      getContent = true;
      // length = ntohs( ipPkt->length );
      length = ipPkt->length;
      assert (length < 65526);
      resultString = (char *) malloc (length + 1);
      memcpy (resultString, ipPkt, length);
      unsigned int i;
      for (i = 0; i < length; i++)
    {
      if (!isprint (resultString[i]))
        {
          resultString[i] = '.';
        }
    }
      resultString[length] = '\0';
    }
  else
    {
      assert (0);
    }

  if (!(getContent))
    {
      if (!computeIpAddressFlag)
    {
      sprintf (tmpbuf, "%u", result);
      resultString = strdup (tmpbuf);
    }
      else
    {
      resultString = computeStringFromIpAddress (result);
    }
    }

  Tcl_Obj *resultObj = Tcl_GetObjResult (interp);
  Tcl_SetStringObj (resultObj, resultString, -1);

  return TCL_OK;
}


/**
  * \brief Get tcl string representation of the packet ipflags
  */

static int
pktReadIpFlags (ClientData cd ,
        Tcl_Interp * interp, int objc, Tcl_Obj * const objv[])
{
  assert (objc == 2);

  Pkt_EthernetHdr_t *pkt =
    (Pkt_EthernetHdr_t *) Nm_TclCDReadPtrFromObj (interp, (Nm_TclCD_t *) cd, objv[1]);
  Pkt_IpHdr_t *ipPkt  = Pkt_EthernetExtractIp (pkt);
  char tmpbuf[64];

  // u_int16_t  RB:1,
  //            DF:1,
  //            MF:1,
  //            offset:13;
  sprintf (tmpbuf, "RB:%d; DF:%d; MF:%d; offset:%d;", ipPkt->RB, ipPkt->DF,
       ipPkt->MF, ipPkt->offset);

  char *resultString = strdup (tmpbuf);
  Tcl_Obj *resultObj = Tcl_GetObjResult (interp);
  Tcl_SetStringObj (resultObj, resultString, -1);

  return TCL_OK;
}


/**
  * \brief Return information in tcl string form for the tcp packet
  */

int
pktReadTcpInfo (ClientData cd ,
        Tcl_Interp * interp, int objc, Tcl_Obj * const objv[])
{
  assert (objc == 2);
  char *cmdName = Tcl_GetStringFromObj (objv[0], NIL (int));

  Pkt_EthernetHdr_t *pkt =
    (Pkt_EthernetHdr_t *) Nm_TclCDReadPtrFromObj (interp, (Nm_TclCD_t *) cd, objv[1]);
  Pkt_TcpHdr_t *tcpPkt = Pkt_EthernetExtractTcp (pkt);
  u_int32_t result;

  if (util_strequal (cmdName, "pktReadTcpDestPort"))
    {
      result = tcpPkt->destPort;
      assert (result < 65536);
    }
  else if (util_strequal (cmdName, "pktReadTcpSrcPort"))
    {
      result = tcpPkt->srcPort;
      assert (result < 65536);
    }
  else if (util_strequal (cmdName, "pktReadTcpSeqNum"))
    {
      result = tcpPkt->seqNum;
    }
  else if (util_strequal (cmdName, "pktReadTcpAckNum"))
    {
      result = tcpPkt->ackNum;
    }
  else
    {
      assert (0);
    }
  char tmpbuf[40];
  sprintf (tmpbuf, "%u", result);

  char *resultString = strdup (tmpbuf);
  Tcl_Obj *resultObj = Tcl_GetObjResult (interp);
  Tcl_SetStringObj (resultObj, resultString, -1);

  return TCL_OK;
}


/**
  * \brief Get tcl string representation of the tcp flags
  */

static int
pktReadTcpFlags (ClientData cd ,
         Tcl_Interp * interp, int objc, Tcl_Obj * const objv[])
{
  assert (objc == 2);

  Pkt_EthernetHdr_t *pkt =
    (Pkt_EthernetHdr_t *) Nm_TclCDReadPtrFromObj (interp, (Nm_TclCD_t *) cd, objv[1]);
  Pkt_TcpHdr_t *tcp = Pkt_EthernetExtractTcp (pkt);
  char tmpbuf[100];

  // fin,syn,rst,psh,ack,urg,ece,cwr
  sprintf (tmpbuf, "%s%s%s%s%s%s%s%s",
       (tcp->fin ? "fin," : "!fin,"),
       (tcp->syn ? "syn," : "!syn,"),
       (tcp->rst ? "rst," : "!rst,"),
       (tcp->psh ? "psh," : "!psh,"),
       (tcp->ack ? "ack," : "!ack,"),
       (tcp->urg ? "urg," : "!urg,"),
       (tcp->ece ? "ece," : "!ece,"), (tcp->cwr ? "cwr," : "!cwr"));

  char *resultString = strdup (tmpbuf);
  Tcl_Obj *resultObj = Tcl_GetObjResult (interp);
  Tcl_SetStringObj (resultObj, resultString, -1);

  return TCL_OK;
}


/**
  * \brief Some code to understand ways in which to execute tcl code from C
  */

static int
tclTestC (ClientData cd ,
      Tcl_Interp * interp, int objc, Tcl_Obj * const objv[])
{
  int count = 1000;
  char *cmdName = Tcl_GetStringFromObj (objv[0], NIL (int));
  if (objc == 3)
    {
      assert (TCL_OK == Tcl_GetIntFromObj (interp, objv[2], &count));
    }
  int i;

  if (util_strequal (cmdName, "testC1"))
    {
      for (i = 0; i < count; i++)
    {
      Tcl_EvalObjEx (interp, objv[1], 0);
    }
    }
  else if (util_strequal (cmdName, "testC2"))
    {
      for (i = 0; i < count; i++)
    {
      char *cmdString = Tcl_GetString (objv[1]);
      Tcl_Eval (interp, cmdString);
    }
    }
  else if (util_strequal (cmdName, "testC3"))
    {
      char *cmdString = Tcl_GetString (objv[1]);
      int cmdStringLength = strlen (cmdString);
      for (i = 0; i < count; i++)
    {
      Tcl_EvalEx (interp, cmdString, cmdStringLength, 0);
    }
    }
  else
    {
      printf ("Error in tclTestC\n");
      assert (0);
    }

  return TCL_OK;
}


/**
  * \brief Code that calls Rlp_ParseFile on the given file.
  * Used for testing the parser
  */

static int
tclTestParser (ClientData cd ,
           Tcl_Interp * interp, int objc, Tcl_Obj * const objv[])
{
  assert (objc == 2);

  char *fileName = Tcl_GetStringFromObj (objv[1], NIL (int));
  FILE *ruleFile = fopen (fileName, "r");
  if (ruleFile == NIL (FILE))
    {
      printf
    ("Error, could not open file %s, returning without testing parser\n",
     fileName);
      return TCL_OK;
    }
  char *ruleFileInText = util_file_to_string (ruleFile);
  array_t *result  = util_process_file (ruleFileInText);
  free (ruleFileInText);
  fclose (ruleFile);

  // we set the result to 0 which indicates that the 
  // function completed, we don't care about actual return codes
  Tcl_Obj *resultObj = Tcl_GetObjResult (interp);
  Tcl_SetIntObj (resultObj, 0);

  return TCL_OK;
}


/**
  * \brief Code that gets a test string that is the entire contents of a file.
  * File must be ascii, i.e., no NULLs in the file.
  */

static int
tclGetFileAsText (ClientData cd ,
          Tcl_Interp * interp, int objc, Tcl_Obj * const objv[])
{
  assert (objc == 2);

  char *fileName = Tcl_GetStringFromObj (objv[1], NIL (int));
  FILE *ruleFile = fopen (fileName, "r");
  if (ruleFile == NIL (FILE))
    {
      printf
    ("Error, could not open file %s, returning without generating string\n",
     fileName);
      return TCL_OK;
    }
  char *ruleFileInText = util_file_to_string (ruleFile);
  fclose (ruleFile);

  Tcl_Obj *resultObj = Tcl_GetObjResult (interp);
  Tcl_SetStringObj (resultObj, ruleFileInText, strlen (ruleFileInText));

  return TCL_OK;
}


/**
  * \brief Code for testing sys call speed
  */

static int
tclBufferWritePkts (ClientData cd ,
            Tcl_Interp * interp,
            int objc , Tcl_Obj * const objv[])
{
  int numPackets = 1;
  Nm_TclGetIntVar (interp, "numPackets", &numPackets);

  char *fileName = "/dev/null";
  Nm_TclGetStringVar (interp, "fileName", &fileName);
  // int destFile = creat( fileName, 0755 );
  FILE *destFile = fopen (fileName, "w");

  int i;
  int aPktLength = 64;
  char aPkt[64];
  // printf("About to write %d pkts to %s\n", numPackets, fileName );
  for (i = 0; i < numPackets; i++)
    {
      int numWritten = fwrite (aPkt, 4, aPktLength, destFile);
      if (numWritten != aPktLength)
    {
      printf ("Unsucc write: numWritten = %d, aPktLength = %d\n",
          numWritten, aPktLength);
    }
    }

  return TCL_OK;
}


/**
  * \brief Code for testing sys call speed
  */

static int
tclWritePkts (ClientData cd ,
          Tcl_Interp * interp, int objc , Tcl_Obj * const objv[])
{
  int numPackets = 1;
  Nm_TclGetIntVar (interp, "numpkt", &numPackets);

  char *fileName = "/dev/null";
  Nm_TclGetStringVar (interp, "fileName", &fileName);
  // int destFile = creat( fileName, 0755 );
  int destFile = open (fileName, O_RDWR, 0);
  if (destFile == -1)
    {
      destFile = creat (fileName, 0755);
    }
  if (destFile == -1)
    {
      printf ("Could not open or create file %s\n", fileName);
    }

  int i;
  array_t *timeStamps = util_time_stamp_init (numPackets + 1);

  int aPktLength = 64;
  char aPkt[64];
  printf ("About to write %d pkts to %s\n", numPackets, fileName);
  util_time_stamp_set (timeStamps, 0);
  for (i = 0; i < numPackets; i++)
    {
      int numWritten = write (destFile, aPkt, aPktLength);
      util_time_stamp_set (timeStamps, (i + 1));
      if (numWritten != aPktLength)
    {
      printf
        ("Unsucc write: numWritten = %d, aPktLength = %d, destFile = %d\n",
         numWritten, aPktLength, destFile);
    }
    }
  util_time_stamp_print (timeStamps);
  array_free (timeStamps);

  return TCL_OK;
}


/**
  * \brief Code for injecting crafted packets 
  */

static int
tclTxPkt (ClientData cd ,
      Tcl_Interp * interp, int objc , Tcl_Obj * const objv[])
{
  char *ifName = "eth1";
  Nm_TclGetStringVar (interp, "ifname", &ifName);
  static Pkt_LibNet_t *alibnet;

  if (alibnet == NIL (Pkt_LibNet_t))
    {
      alibnet = Pkt_InitLibNet (ifName);
    }
  else
    {
      if (util_strequal (ifName, alibnet->interfaceName))
    {
      // keep it
    }
      else
    {
      // update it
      Pkt_LibNetFinish (alibnet);
      alibnet = Pkt_InitLibNet (ifName);
    }
    }

  Pkt_EthernetHdr_t *pkt =
    (Pkt_EthernetHdr_t *) Nm_TclCDReadPtrFromObj (interp, (Nm_TclCD_t *) cd, objv[1]);
  int aPktLength = Pkt_EthernetPktHdrReadLength (pkt);
  Pkt_HTON (pkt);
  Pkt_EthPktWrite (pkt, aPktLength, alibnet);
  Pkt_NTOH (pkt);

  return TCL_OK;
}


/**
  * \brief Code for testing packet injection speeds
  */

static int
tclInjectPkts (ClientData cd ,
           Tcl_Interp * interp, int objc , Tcl_Obj * const objv[])
{

  int index;

  int numPackets = 21;
  Nm_TclGetIntVar (interp, "numpkt", &numPackets);

  char *ifName = "eth1";
  Nm_TclGetStringVar (interp, "ifname", &ifName);

  int printTimeStamps = 0;
  Nm_TclGetIntVar (interp, "ts", &printTimeStamps);

  double rate;
  double rateLimit = 0.0;
  Nm_TclGetDoubleVar (interp, "ratelimit", &rateLimit);

  Pkt_TfcMode_t *tfcMode = readTfcModeParams (interp);
  Pkt_LibNet_t *alibnet = Pkt_InitLibNet (ifName);

  array_t *pktArray =
    Pkt_SeedRandEthPktArray (Pkt_HostByteOrder_c, tfcMode->numSeeds, tfcMode);

  int i;
  printf ("Writing %d pkts\n", numPackets);
  util_timing_t startTime;
  util_timing_t finishTime;

  array_t *timeStamps;

  if (printTimeStamps)
    {
      timeStamps = util_time_stamp_init (numPackets + 1);
    }

  if (printTimeStamps)
    {
      util_time_stamp_set (timeStamps, 0);
    }

  util_timing_set (&startTime);
  util_timing_t pauseTime = util_timing_pair (tfcMode->pktGap);

  util_timing_t difftime;

  Pkt_EthernetHdr_t *aPkt = Pkt_CreateRandEthPkt (pktArray);
  Pkt_IpHdr_t *ipPkt = Pkt_EthernetExtractIp (aPkt);
  int ipPktLength = ipPkt->length;
  int aPktLength = ipPktLength + sizeof (Pkt_EthernetHdr_t);

  int count = 0;
  int bytesTx;
  while (1)
    {
      int bytesTx = Pkt_EthPktWrite (aPkt, aPktLength, alibnet);
      if (bytesTx != 0)
    {
      count++;
      if (count >= numPackets)
        {
          break;
        }
    }
      util_timing_pause (pauseTime);
      if (printTimeStamps)
    {
      util_time_stamp_set (timeStamps, (count + 1));
    }
      if (rateLimit != 0.0)
    {
      while (1)
        {
          util_timing_set (&finishTime);
          util_timing_t difftime =
        util_timing_diff (finishTime, startTime);
          rate = computeRate (tfcMode->size, count, difftime);
          if (rate < rateLimit)
        {
          break;
        }
        }
    }
    }
  util_timing_set (&finishTime);
  difftime = util_timing_diff (finishTime, startTime);

  rate = computeRate (tfcMode->size, numPackets, difftime);

  double kbits =
    (8.0 * (7 + 1 + 6 + 6 + 2 + (MAX (46, (40 + tfcMode->size))) + 12) *
     (((double) numPackets) / 1000.0));
  double difftimeDouble = util_timing_secs (difftime);
  printf ("Transmitted %d payload byte L4 packets: %.0f kbits "
      "(incl preamble,sfd,fcs,frame-gap) "
      "in %.2f seconds, rate = %.0f Mbps, %.4f Kpps\n",
      (tfcMode->size), kbits, difftimeDouble, rate,
      (0.001 * (double) numPackets) / difftimeDouble);

  if (printTimeStamps)
    {
      util_time_stamp_print (timeStamps);
      array_free (timeStamps);
    }

  Pkt_LibNetFinish (alibnet);

  return TCL_OK;
}


/**
  * \brief Create the basic parameters for the call to Pkt_CreateRandEthPkt
  *
  */

static Pkt_TfcMode_t *
readTfcModeParams (Tcl_Interp * interp)
{
  int size = 10;
  Nm_TclGetIntVar (interp, "pktsize", &size);

  Pkt_TfcMode_t *tfcMode = (Pkt_TfcMode_t *) malloc (sizeof (Pkt_TfcMode_t));
  tfcMode->size = size;

  char Nm_EvgaSrcMac[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0xaa };
  char Nm_EvgaDestMac[] = { 0x00, 0x15, 0x17, 0x20, 0xE1, 0x80 };

  /// \todo add function to read these directly from shell
  tfcMode->srcMac = Nm_EvgaSrcMac;
  tfcMode->destMac = Nm_EvgaDestMac;

  int numSeeds = 1;
  Nm_TclGetIntVar (interp, "numSeeds", &numSeeds);
  tfcMode->numSeeds = numSeeds;

  double delay = 0.0;
  Nm_TclGetDoubleVar (interp, "pktgap", &delay);
  tfcMode->pktGap = delay * 0.000001;   // pktgap is given in usec

  return tfcMode;
}


/**
  *     \brief  Perform action desired by user.
  *
  *     Action is a tcl function which takes a single parameter, specifically
  *     a pointer to a packet (well the int id that we're using in place of the pointer).
  */

static int
tclTestTclAction (ClientData cd ,
          Tcl_Interp * interp,
          int objc , Tcl_Obj * const objv[])
{

  const int numArgsToTclFunction = 2;
  Tcl_Obj *tmpObjv[numArgsToTclFunction];

  char *procedure = "dummy";
  Tcl_Obj *tmpPtr = Tcl_NewStringObj (strdup (procedure), -1);
  tmpObjv[0] = tmpPtr;

  char *dummyarg = "dummyarg";
  tmpObjv[1] = Tcl_NewStringObj (strdup (dummyarg), -1);

  // two arguments, in the array of Tcl_Obj *s : one is the function's name, the
  // other is the "pointer" to the packet
  int code = Tcl_EvalObjv (interp, numArgsToTclFunction, tmpObjv, 0);
  return code;

}


/**
  * \brief Perform performance test of compress code
  *
  */

static int
tclCompressTestPerf (ClientData cd ,
             Tcl_Interp * interp,
             int objc , Tcl_Obj * const objv[])
{
  int len = 1000000;
  Nm_TclGetIntVar (interp, "length", &len);
  int count = 10;
  Nm_TclGetIntVar (interp, "count", &count);
  int srcLen = len;
  int destLen = 2 * len;
  char *src = (char *) malloc (srcLen);
  char *dest = (char *) malloc (destLen);

  util_timing_t startTime;
  util_timing_t finishTime;

  int i;
  util_timing_set (&startTime);
  for (i = 0; i < count; i++)
    {
      /// \todo removed because of linker issues
      /// compress( dest, & destLen, src, srcLen );
    }
  util_timing_set (&finishTime);
  util_timing_t difftime = util_timing_diff (finishTime, startTime);
  double difftimeDouble = util_timing_secs (difftime);
  double rate = len * count / (difftimeDouble * 1000.0);
  printf ("compress %d iters, %d bytes per iter: rate %.4f MBytes/sec\n",
      count, len,
      ((double) count * (double) len) / (1000000.0 * difftimeDouble));
  fflush (stdout);

  return TCL_OK;
}


/**
  * \brief Perform compression of compress code
  *
  * \ingroup doc \b compTestReduction Perform a check of the amount
  * of data compression the underlying lzo compression library implements.
  *
  */

static int
tclCompressTestReduction (ClientData cd ,
              Tcl_Interp * interp,
              int objc , Tcl_Obj * const objv[])
{
  char *fileName = "a.txt";
  Nm_TclGetStringVar (interp, "filename", &fileName);
  int blockSize = 1000;
  Nm_TclGetIntVar (interp, "blocksize", &blockSize);

  int destLen = 2 * blockSize;
  char *dest = (char *) malloc (destLen);

  FILE *f = fopen (fileName, "r");
  if (f == NIL (FILE))
    {
      printf ("Could not open file %s\n", fileName);
      return TCL_OK;
    }

  char *text = util_file_to_string (f);
  int textLength = strlen (text);
  int i;
  int numBlocks = textLength / blockSize;
  textLength = numBlocks * blockSize;   // make an integer number of blocks

  int totalCompressedBytes = 0;
  for (i = 0; i < numBlocks; i++)
    {
      // compress( dest, & destLen, text + blockSize * i, blockSize );
      totalCompressedBytes += (destLen > blockSize) ? blockSize : destLen;
    }

  int fullFileLength = 2 * textLength;
  char *fullFile = (char *) malloc (2 * textLength);
  // compress( fullFile, & fullFileLength, text, textLength );

  printf ("For file %s, using %d sized blocks:\n"
      "\tTotal length = %d\n"
      "\tCompressed flat = %d\n"
      "\tCompressed segments = %d)\n",
      fileName, blockSize, textLength, fullFileLength,
      totalCompressedBytes);
  return TCL_OK;
}


/**
  * \brief \b array_test Run tests on array package
  *
  * \ingroup com 
  *
  */

static int
tclArrayTest (ClientData cd ,
          Tcl_Interp * interp, int objc , Tcl_Obj * const objv[])
{
  Array_Test ();
  return TCL_OK;
}


/**
  * \brief Take a packet crafed with tcl, and insert it into the 
  * managers input buffer.  Used to create tcl actions that 
  * generate packets.
  */

static int
tclEvlMgrInsertPktIntoInputBuffer (ClientData cd ,
                   Tcl_Interp * interp,
                   int objc , Tcl_Obj * const objv[])
{
  assert (objc == 3);
  Tcl_Obj *mgrObj = objv[1];
  Tcl_Obj *pktObj = objv[2];

  Evl_Manager_t *mgr = (Evl_Manager_t *) Nm_TclCDReadPtrFromObj (interp, (Nm_TclCD_t *) cd, mgrObj);
  Pkt_EthernetHdr_t *pkt = (Pkt_EthernetHdr_t *) Nm_TclCDReadPtrFromObj (interp, (Nm_TclCD_t *) cd, pktObj);
  Evl_Bridge_t *bridge = mgr->bridge;

  Evl_BridgeInsertPktInIbuf (bridge, pkt);
  return TCL_OK;
}


/**
  * \brief
  */

static double
computeRate (int size, int numPackets, util_timing_t diffTime)
{
  double kbits = (8.0 * (7 + 1 + 6 + 6 + 2 + (MAX (46, (40 + size))) + 12) *
          (((double) numPackets) / 1000.0));
  double difftimeDouble = util_timing_secs (diffTime);
  double rate = kbits / (difftimeDouble * 1000.0);

  return rate;
}


/**
  * \brief End profiler
  *
  */

static int
tclStopProfiler (ClientData cd ,
         Tcl_Interp * interp, int objc , Tcl_Obj * const objv[])
{
  // ProfilerStop ();

  return TCL_OK;
}

/** \brief Perform test of st code */

static int
tclStTest(ClientData cd ,
       Tcl_Interp * interp, int objc , Tcl_Obj * const objv[])
{
  Hash_Test();

  return TCL_OK;
}

/** \brief Perform test of st code performance */

static int
tclStTestPerf (ClientData cd ,
       Tcl_Interp * interp, int objc , Tcl_Obj * const objv[])
{
  int numIter = 10;
  Nm_TclGetIntVar (interp, "num", &numIter);
  char *aString = (char *) malloc (100);
  int i;
  for (i = 0; i < 99; i++)
    {
      aString[i] = 'x';
    }
  aString[5] = '\0';

  util_timing_t startTime;
  util_timing_t finishTime;
  util_timing_t difftime;
  double difftimeDouble;

  st_table *stringTable = Hash_InitTable ( ( int(*)() ) strcmp,  ( int(*)() ) st_strhash);
  util_timing_set (&startTime);
  for (i = 0; i < numIter; i++)
    {
      *(int *) (aString + 1) = i + 1;
      Hash_Insert (stringTable, aString, 0);
    }
  util_timing_set (&finishTime);
  difftime = util_timing_diff (finishTime, startTime);
  difftimeDouble = util_timing_secs (difftime);
  printf ("Time to insert foo %d times is %f => %f iter per sec\n",
      numIter, difftimeDouble, (numIter / difftimeDouble));

  util_timing_set (&startTime);
  for (i = 0; i < numIter; i++)
    {
      // *(int *) (aString + 1 )= i + 1;
      Hash_Lookup (stringTable, aString, 0);
    }
  util_timing_set (&finishTime);
  difftime = util_timing_diff (finishTime, startTime);
  difftimeDouble = util_timing_secs (difftime);
  printf ("Time to lookup foo %d times is %f => %f iter per sec\n",
      numIter, difftimeDouble, (numIter / difftimeDouble));
  return TCL_OK;
}

/** \brief For tk testing

*/


static int *dummy( Tcl_Interp *interp ) {
  return TCL_OK;
}

/** \brief Trivial tk call

*/

static int
tclTestTk (ClientData cd ,
       Tcl_Interp * interp, int objc , Tcl_Obj * const objv[])
{
  // char *screenName = "daisy:0";
  // char *appName = "azinix tk";
  // char *className = "Azinix";
  // Tk_Window tkwin = Tk_CreateMainWindow( interp, screenName, appName, className );
  // Tk_CreateWindow( interp, NULL, "Azinix", "daisy:4" );
  return TCL_OK;

  //AA int tkwinCode = Tk_Init( interp );
  //AA if ( tkwinCode == TCL_OK ) {
  //AA   printf("Tk_Init succ\n");
  //AA }
  //AA else {
  //AA   printf("Tk_Init unsucc\n");
  //AA }

  //AA // three arguments, in the array of Tcl_Obj *s : one is the function's name, the
  //AA // next is the "pointer" to the manager, then a pointer to the pkt
  //AA const int numArgsToTclFunction = 1;
  //AA Tcl_Obj *tmpObjv[numArgsToTclFunction];
  //AA char *tclRuleString = "wm title . \"hi!\"\n"
  //AA              "button .hello -text \"Hello World!\" -command exit\n"
  //AA              "pack .hello\n";
  //AA Tcl_Obj *tmpPtr = Tcl_NewStringObj (strdup (tclRuleString), -1);
  //AA tmpObjv[0] = tmpPtr;

  //AA int retCode = Tcl_EvalObjv ( interp, 1, tmpObjv, TCL_EVAL_GLOBAL);
 

  //AA // Tk_Main( 1, argv, dummy );

  //AA return TCL_OK;
}

/** \brief Small function to test C++ linkage

*/

// class Point_t {
//   public: int x;
//        int y;
//    void print() { printf("x is %d, y is %d\n", x, y ); }
//    void print( char *s ) { printf("%s: x is %d, y is %d\n", s, x, y ); }
// };

// #include "/nfs/narya/pf/STLport-5.1.4/stlport/vector"
// #include <iostream>
// #include <vector>
// #include <string>
// using namespace std;
// 
// static int tclTestCplusplus( ClientData cd ,
//      Tcl_Interp * interp, 
//      int objc , 
//      Tcl_Obj * const objv[]  )
// {
// 
//   Point_t aPoint;
//   aPoint.x = 1;
//   aPoint.y = 2;
//   aPoint.print();
//   aPoint.print("a mesg");
// 
//   vector<int> av;
//   av.push_back(1);
//   printf("av[0] is %d\n", av[0] );
// 
//   return TCL_OK;
// }

/*
#include <qt3/qapplication.h>
#include <qt3/qpushbutton.h>

int main_qt( int argc, char **argv )
{
    QApplication a( argc, argv );

    QPushButton hello( "Hello world!", 0 );
    hello.resize( 100, 30 );

    a.setMainWidget( &hello );
    hello.show();
    return a.exec();
}

static int tclTestQt( ClientData cd ,
        Tcl_Interp * interp, 
        int objc , 
        Tcl_Obj * const objv[]  )
{
  main_qt( 1, NIL( char *) );
  return TCL_OK;
}
*/