rlpAct.c

Go to the documentation of this file.

/** \file rlpAct.c

  \brief Routines for manipulating action structures.

******************************************************************************/

#include "rlp.h"

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

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


/** \brief  Allocate an acction struct */

Rlp_Action_t *
Rlp_AllocActionStruct ()
{
  Rlp_Action_t *result = (Rlp_Action_t *) malloc (sizeof (Rlp_Action_t));
  result->type = Rlp_ActionUnassigned_c;
  result->dest = NIL (char);
  result->queue = NIL (char);
  result->classIndex = 0;

  result->uscript = NIL (char);

  result->ucodeName = NIL (char);
  result->ucodeFunction = NULL;
  result->ucodeFunctionState = NULL;

  result->argument = NIL (char);

  return result;
}


/** \brief  Create an action struct from raw text
  
  Raw text could be  
  <pre>
  drop;
  queue:foo;  class:1;
  dest:0;
  tcl-ext:puts "ouch";
  </pre>
  
  */

Rlp_Action_t *
Rlp_CreateActionFromRawText (char *rawFormula)
{
  Rlp_Action_t *result = Rlp_AllocActionStruct ();
  char *attribute;
  char *value;

  while (*rawFormula == ' ')
    {
      rawFormula++;
    }

  // Special case the case for tcl code so we don't have to worry about
  // ;'s in the tcl action string. this precludes us from using tcl
  // and non-tcl actions, but that seems like a reasonable restriction

  if (util_strequalN (rawFormula, "tcl-ext:", strlen ("tcl-ext:")) ||
      util_strequalN (rawFormula, "c-ext:", strlen ("c-ext:")))
    {
      char *dupString;
      if (util_strequalN (rawFormula, "tcl-ext:", strlen ("tcl-ext:")))
    {
      result->type = Rlp_ActionUscript_c;
      dupString = result->uscript =
        strdup (rawFormula + strlen ("tcl-ext:"));
    }
      else
    {
      result->type = Rlp_ActionUcode_c;
      dupString = result->ucodeName =
        strdup (rawFormula + strlen ("c-ext:"));
    }

      char *semicolonPtr;
      char *colonPtr;
      if (!(colonPtr = strchr (dupString, ':')))
    {
      // there's no argument
      // if there is we null terminate
      assert (NIL (char) != (semicolonPtr = strchr (dupString, ';')));
      *semicolonPtr = '\0';
    }
      else
    {
      // there is an argument
      // first null terminate the function name
      *colonPtr = '\0';
      // now get the argument
      char *argument = strdup (colonPtr + 1);
      // assume ends in a ;
      assert (argument[strlen (argument) - 2] == ';');
      argument[strlen (argument) - 1] = '\0';
      result->argument = argument;
    }
      return result;
    }


  // the call to Rlp_L7StringParse is overkill
  // since we don't have escaped stuff in the
  // text, but this should do the job of
  // creating the (char * attrib, char *val) pairs
  bool haveQueue = false;
  bool haveClass = false;
  array_t *attributesArray = Rlp_L7StringParse (rawFormula);
  int i;
  for (i = 0; i < array_n (attributesArray); i++)
    {
      Rlp_RuleComponent_t *aComponent = array_fetch (Rlp_RuleComponent_t *,
                             attributesArray, i);
      attribute = aComponent->rawAttribute;
      value = aComponent->rawValue;

      if (util_strequal (attribute, "drop"))
    {
      result->type = Rlp_ActionDrop_c;
    }
      else if (util_strequal (attribute, "queue"))
    {
      result->type = Rlp_ActionQueue_c;
      result->queue = strdup (value);
      haveQueue = true;
    }
      else if (util_strequal (attribute, "class"))
    {
      sscanf (value, "%d", &result->classIndex);
      haveClass = true;
    }
      else if (util_strequal (attribute, "route"))
    {
      result->type = Rlp_ActionRoute_c;
      char tmp[100];
      sscanf (value, "%s", tmp);
      result->dest = strdup (tmp);
    }
      else if (util_strequal (attribute, "tcl"))
    {
      printf ("PANIC: shold have picked up tcl earlier in code\n");
      assert (0);
    }
      else
    {
      printf ("PANIC: Don't support construct %s in action\n", attribute);
      assert (0);
    }
    }
  return result;
}


/** \brief  Print an action structure */

void
Rlp_ActionPrint (Rlp_Action_t * action)
{
  printf ("drop = %s; dest = %s ; queue = %s; class = %d\n",
      (action->type == Rlp_ActionDrop_c) ? "true" : "false", action->dest,
      action->queue, action->classIndex);
}