evlAct.c

Go to the documentation of this file.

/** \file evlAct.c

  \brief Implement actions on packets.

*/



#include "evl.h"

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

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

static int compareQueueNames (char *q1, char *q2);
static int compareQueuePriorities (char *q1, char *q2);

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


/**
  * \brief Compare function for queues, uses names to 
  * impose order on queues.
  *
  */

static int
compareQueueNames (char *q1, char *q2)
{
  return strcmp (((Q_Q_t *) q1)->name, ((Q_Q_t *) q2)->name);
}


/**
  * \brief  Create a heap of Q_Q_t's , whose priorities are given by the
  * currentPriority field.
  * 
  */

Heap_t *
Evl_AllocateQueueHeap (st_table * queueTable)
{
  Heap_t *result;

  result = Heap_Init (compareQueuePriorities);
  st_generator *stGen;
  char *qName;
  Q_Q_t *aQ;

  // doing this to get a deterministic order for the
  // queues in the heap
  array_t *qArray = array_alloc (Q_Q_t *, 0);

  st_foreach_item (queueTable, stGen, (char **) &qName, (char **) &aQ)
  {
    array_insert_last (Q_Q_t *, qArray, aQ);
  }
  array_sort (qArray, ( int(*)() ) compareQueueNames);
  int i;
  for (i = 0; i < array_n (qArray); i++)
    {
      aQ = array_fetch (Q_Q_t *, qArray, i);
      Heap_Insert (result, (char *) aQ);
    }
  return result;
}


/**
  * \brief  Compare to Q_Q_t's based on currentPriority field
  * 
  * Compare to Q_Q_t's based on currentPriority field
  * 
  */

static int
compareQueuePriorities (char *q1, char *q2)
{
  if (((Q_Q_t *) q1)->currentPriority < ((Q_Q_t *) q2)->currentPriority)
    {
      return 1;
    }
  return 0;
}


/**
  * \brief  Set the route for the packet
  */

void
Evl_RoutePkt (Evl_Action_t * action,
          Evl_Bridge_t * bridge, Pkt_ProcessPkt_t * pp)
{
  assert (action->parsedAction->type == Rlp_ActionRoute_c);
  int i;
  if (action->outIf != NIL (Pkt_LibNet_t))
    {
      pp->outIf = action->outIf;
      return;
    }

  for (i = 0; i < array_n (bridge->outArray); i++)
    {
      Pkt_LibNet_t *outIf = array_fetch (Pkt_LibNet_t *, bridge->outArray, i);
      if (util_strequal (action->parsedAction->dest, outIf->interfaceName))
    {
      pp->outIf = outIf;
      action->outIf = outIf;
      return;
    }
    }

  return;
}


/**
  * \brief  Perform action desired by user, specified as a tcl proc.
  *
  *     Action is a tcl proc which takes two parameters, specifically
  * a mgr and a pointer to a packet (well the int ids that we're using 
  * in place of the pointers).
  */

void
Evl_UscriptAction (Rlp_Action_t * action,
           Evl_Manager_t * mgr, Pkt_ProcessPkt_t * pp)
{
  assert (action->type == Rlp_ActionUscript_c);
  Pkt_EthernetHdr_t *pkt = pp->pkt;

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

  char *tclRuleString = action->uscript;
  Tcl_Obj *tmpPtr = Tcl_NewStringObj (strdup (tclRuleString), -1);
  tmpObjv[0] = tmpPtr;

  int resultId = Nm_TclCDStorePtr ((Nm_TclCD_t *) mgr->cd, (void *) mgr);
  tmpObjv[1] = Tcl_NewIntObj (resultId);

  resultId = Nm_TclCDStorePtr ((Nm_TclCD_t *) mgr->cd, (void *) pkt);
  tmpObjv[2] = Tcl_NewIntObj (resultId);

  // three arguments, in the array of Tcl_Obj *s : one is the function's name, the
  // next is the "pointer" to the manager, then a pointer to the pkt 
  int retCode = Tcl_EvalObjv (mgr->interp, numArgsToTclFunction, tmpObjv,
                  TCL_EVAL_GLOBAL);
  if (retCode != TCL_OK)
    {
      printf ("Error in invoking script %s\n", action->uscript);
      printf ("\ttcl interp error message is: %s\n",
          Tcl_GetStringResult (mgr->interp));
    }

  return;
}


/**
  * \brief  Perform action desired by user, implemented by C code that's been
  * dynamically linked in previously.
  *
  *     Action is a C function which takes several parameters
  *   - a pointer to the manager
  *   - a pointer to the pp structure encapsulating the packet
  *   - a pointer to a pointer var that can be used to store state
  *   - a charstring argument
  */

int
Evl_UcodeAction (Rlp_Action_t * action,
         Evl_Manager_t * mgr, Pkt_ProcessPkt_t * pp)
{
  assert (action->type == Rlp_ActionUcode_c);

  if ((action->ucodeFunction == 0))
    {
      if (!Hash_Lookup
      (mgr->ucodeNameToFunction, action->ucodeName,
       (char **) &action->ucodeFunction))
    {
      printf
        ("Error: did not find function with name %s, did you register it?\n",
         action->ucodeName);
      assert (0);
    }
    }

  // int retCode = ( ( int()( Evl_Manager_t *, Pkt_ProcessPkt_t *, void **, char * ) ) action->ucodeFunction ) (mgr, pp, &action->ucodeFunctionState, action->argument);

  int retCode = action->ucodeFunction ( (void*) mgr,  (void*) pp, &action->ucodeFunctionState, action->argument);

  return retCode;
}