pktTfc.c

Go to the documentation of this file.

/** \file pktTfc.c

\brief Routines for creating packets.

*/

#include "pkt.h"

/*---------------------------------------------------------------------------*/
/* Constant declarations                                                     */
/*---------------------------------------------------------------------------*/

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

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

static void assembleUdpPkt (Pkt_UdpHdr_t * result, u_int16_t srcPort,
                u_int16_t destPort, u_int16_t checkSum,
                util_byte_array_t * payload);
static void assembleTcpPkt (Pkt_TcpHdr_t * result, u_int16_t srcPort,
                u_int16_t destPort, u_int32_t seqNum,
                u_int32_t ackNum,
                Pkt_TcpResDoffFlags_t resDoffFlags,
                u_int16_t advWindow, u_int16_t checkSum,
                u_int16_t urgPtr, util_byte_array_t * payload);
static void assembleIpPkt (Pkt_IpHdr_t * pkt, u_int8_t ihl, u_int8_t version,
               u_int8_t TOS, u_int16_t length, u_int16_t id,
               Pkt_IpFlags_t ipFlags, st_table * ipOptions,
               u_int8_t TTL, u_int8_t protocol,
               u_int16_t checksum, u_int32_t sourceIp,
               u_int32_t destIp, util_byte_array_t * payload);
static int computeOptionsLength (st_table * ipoptions);

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

/** \brief  Create an ICMP packet
  
\sa Pkt_CreateTcpPkt
*/

util_byte_array_t *
Pkt_CreateIcmpPkt (array_t * typeArray,
           array_t * codeArray, array_t * idArray, array_t * seqArray)
{
  Pkt_IcmpHdr_t *pkt;

  u_int8_t type;
  u_int8_t code;
  u_int16_t checkSum;

  u_int16_t id;
  u_int16_t seq;

  float direct = 1.0;

  int index;
  if ((typeArray != NIL (array_t)) && (array_n (typeArray) != 0)
      && (util_unit_rand () < direct))
    {
      index = util_rand_int () % array_n (typeArray);
      type = array_fetch (u_int8_t, typeArray, index);
    }
  else
    {
      type = (u_int8_t) util_rand_int ();
    }
  if ((codeArray != NIL (array_t)) && (array_n (codeArray) != 0)
      && (util_unit_rand () < direct))
    {
      index = util_rand_int () % array_n (codeArray);
      code = array_fetch (u_int8_t, codeArray, index);
    }
  else
    {
      code = (u_int8_t) util_rand_int ();
    }
  if ((idArray != NIL (array_t)) && (array_n (idArray) != 0)
      && (util_unit_rand () < direct))
    {
      index = util_rand_int () % array_n (idArray);
      id = array_fetch (u_int8_t, idArray, index);
    }
  else
    {
      id = (u_int8_t) util_rand_int ();
    }
  if ((seqArray != NIL (array_t)) && (array_n (seqArray) != 0)
      && (util_unit_rand () < direct))
    {
      index = util_rand_int () % array_n (seqArray);
      seq = array_fetch (u_int8_t, seqArray, index);
    }
  else
    {
      seq = (u_int8_t) util_rand_int ();
    }

  pkt = (Pkt_IcmpHdr_t *) malloc (sizeof (Pkt_IcmpHdr_t));
  pkt->type = type;
  pkt->code = code;
  pkt->checksum = 0;
  (*pkt).un.echo.id = id;
  (*pkt).un.echo.sequence = seq;

  util_byte_array_t *result =
    (util_byte_array_t *) malloc (sizeof (util_byte_array_t));
  result->bytes = (char *) pkt;
  result->length = sizeof (Pkt_IcmpHdr_t);

  return result;
}


/**
  \brief  Create a UDP packet
  
User defines the "interesting" source and dest ports, 
and byteStrings to be inserted in the packet.  

  \sa Pkt_CreateTcpPkt
*/

util_byte_array_t *
Pkt_CreateUdpPkt (array_t * srcPorts,
          array_t * destPorts, array_t * sizes, array_t * byteStrings)
{
  Pkt_UdpHdr_t *pkt;

  u_int16_t srcPort;
  u_int16_t destPort;
  u_int16_t checkSum;

  u_int16_t payloadLength;

  util_byte_array_t *payload;

  float direct = 1.0;

  int index;
  if ((srcPorts != NIL (array_t)) && (array_n (srcPorts) != 0)
      && (util_unit_rand () < direct))
    {
      index = util_rand_int () % array_n (srcPorts);
      srcPort = array_fetch (u_int16_t, srcPorts, index);
    }
  else
    {
      srcPort = (u_int16_t) util_rand_int ();
    }
  if ((destPorts != NIL (array_t)) && (array_n (destPorts) != 0)
      && (util_unit_rand () < direct))
    {
      index = util_rand_int () % array_n (destPorts);
      destPort = array_fetch (u_int16_t, destPorts, index);
    }
  else
    {
      destPort = (u_int16_t) util_rand_int ();
    }

  bool useTargetStrings = false;
  int targetStringIndex = -1;
  if ((sizes != NIL (array_t)) && (array_n (sizes) != 0)
      && (util_unit_rand () < direct))
    {
      useTargetStrings = true;
      targetStringIndex = util_rand_int () % array_n (byteStrings);
      int sizesIndex = util_rand_int () % array_n (sizes);
      payloadLength = array_fetch (int, sizes, sizesIndex);
    }
  else
    {
      /// \todo the calculation above assumes no IP options - this is not a big deal
      /// because it's in random pkt gen mode, not going to be used
      /// outside of a test environment
      payloadLength = (util_rand_int () % (1500 - sizeof (Pkt_TcpHdr_t)
                       - sizeof (Pkt_IpHdr_t)
                       - sizeof (Pkt_EthernetHdr_t)));
    }
  payload = util_byte_array_create (NIL (char), payloadLength);

  int i;
  // cannot use the random result we got from malloc
  // because it fails purify checks
  // srand(0);
  for (i = 0; (i < payloadLength); i++)
    {
      payload->bytes[i] = (unsigned char) (rand ());
    }
  if (useTargetStrings == true)
    {
      util_byte_array_t *aByteString =
    array_fetch (util_byte_array_t *, byteStrings, targetStringIndex);
      // for testing other systems
      int offset = 0;
      if ( payloadLength != 0 ) {
        int offset = MAX( 0, ( (rand () % payloadLength) - aByteString->length) - 1 );
      }
      offset = (offset < 0) ? 0 : offset;
      for (i = 0; i < aByteString->length; i++)
    {
      payload->bytes[offset + i] = aByteString->bytes[i];
    }
    }

  pkt = (Pkt_UdpHdr_t *) malloc (payloadLength + sizeof (Pkt_UdpHdr_t));
  assembleUdpPkt (pkt, srcPort, destPort, checkSum, payload);

  util_byte_array_t *result =
    (util_byte_array_t *) malloc (sizeof (util_byte_array_t));
  result->bytes = (char *) pkt;
  result->length = payloadLength + sizeof (Pkt_UdpHdr_t);

  util_byte_array_free (payload);

  return result;
}


/**
  * \brief  Create a TCP packet
  * 
  * User defines
  * the "interesting" source and dest ports, seq numbers, ack numbers, sizes,
  * and byteStrings to be inserted in the packet.  If any of these arrays
  * are empty, we take the corresponding field to be un-constrained.
  *     Otherwise, the field takes a value with equal likelihood from the correp
  *     array.  (The array can be of length 1, which is useful for directed testing.)
  * 
  * User also define flags to be set by a st_table containing strings
  * "fin", "syn", "rst", "psh", "ack", "urg", "ece", "cwr" - default is 
  * set with prob 0.5.  If the st_table is NIL, flags are set at random.
  * 
  * Since there is no length field in the tcp header, we return a 
  * util_byte_array_t *, with the bytes entry being the actual packet,
  * and the length entry being the length of the packet.
  */

util_byte_array_t *
Pkt_CreateTcpPkt (array_t * srcPorts,
          array_t * destPorts,
          array_t * seqNums,
          array_t * ackNums,
          st_table * flags, array_t * sizes, array_t * byteStrings)
{
  Pkt_TcpHdr_t *pkt;

  u_int16_t srcPort;
  u_int16_t destPort;
  u_int32_t seqNum;
  u_int32_t ackNum;

  Pkt_TcpResDoffFlags_t resDoffFlags;

  u_int16_t advWindow;
  u_int16_t checkSum;
  u_int16_t urgPtr;

  u_int16_t payloadLength;

  util_byte_array_t *payload;

  float direct = 1.0;

  int index;
  if ((srcPorts != NIL (array_t)) && (array_n (srcPorts) != 0)
      && (util_unit_rand () < direct))
    {
      index = util_rand_int () % array_n (srcPorts);
      srcPort = array_fetch (u_int16_t, srcPorts, index);
    }
  else
    {
      srcPort = (u_int16_t) util_rand_int ();
    }
  if ((destPorts != NIL (array_t)) && (array_n (destPorts) != 0)
      && (util_unit_rand () < direct))
    {
      index = util_rand_int () % array_n (destPorts);
      destPort = array_fetch (u_int16_t, destPorts, index);
    }
  else
    {
      destPort = (u_int16_t) util_rand_int ();
    }
  if ((seqNums != NIL (array_t)) && (array_n (seqNums) != 0)
      && (util_unit_rand () < direct))
    {
      index = util_rand_int () % array_n (seqNums);
      seqNum = array_fetch (u_int32_t, seqNums, index);
    }
  else
    {
      seqNum = (u_int32_t) util_rand_int ();
    }
  if ((ackNums != NIL (array_t)) && (array_n (ackNums) != 0)
      && (util_unit_rand () < direct))
    {
      index = util_rand_int () % array_n (ackNums);
      ackNum = array_fetch (u_int32_t, ackNums, index);
    }
  else
    {
      ackNum = (u_int32_t) util_rand_int ();
    }

  resDoffFlags.res1 = 0;    /// \todo reserved bits, see if this needs flexibility
  resDoffFlags.doff = 5;    /// \todo no options for now, see if this needs flexibility

  int val;
  resDoffFlags.fin = Hash_Lookup (flags, "F", (char **) &val) ? val
    : 0;
  resDoffFlags.syn = Hash_Lookup (flags, "S", (char **) &val) ? val
    : 0;
  resDoffFlags.rst = Hash_Lookup (flags, "R", (char **) &val) ? val
    :0;
  resDoffFlags.psh = Hash_Lookup (flags, "P", (char **) &val) ? val
    : 0;
  resDoffFlags.ack = Hash_Lookup (flags, "A", (char **) &val) ? val
    : 0;
  resDoffFlags.urg = Hash_Lookup (flags, "U", (char **) &val) ? val
    : 0;
  resDoffFlags.ece = Hash_Lookup (flags, "E", (char **) &val) ? val
    : 0;
  resDoffFlags.cwr = Hash_Lookup (flags, "C", (char **) &val) ? val
    : 0;

  /// \todo see if we need the flexibility to set these
  advWindow = 0;
  checkSum = 0;
  urgPtr = 0;

  bool useTargetStrings = false;
  int targetStringIndex = -1;
  if ((sizes != NIL (array_t)) && (array_n (sizes) != 0)
      && (util_unit_rand () < direct))
    {
      useTargetStrings = true;
      targetStringIndex = util_rand_int () % array_n (byteStrings);
      int sizesIndex = util_rand_int () % array_n (sizes);
      payloadLength = array_fetch (int, sizes, sizesIndex);
    }
  else
    {
      payloadLength = (util_rand_int () % (1500 - sizeof (Pkt_TcpHdr_t)
                       - sizeof (Pkt_IpHdr_t)
                       - sizeof (Pkt_EthernetHdr_t)));
    }
  payload = util_byte_array_create (NIL (char), payloadLength);

  int i;
  // cannot use the random result we got from malloc
  // because it fails purify checks
  // srand(0);
  for (i = 0; (i < payloadLength); i++)
    {
      payload->bytes[i] = (unsigned char) (rand ());
    }
  if (useTargetStrings == true)
    {
      util_byte_array_t *aByteString =
    array_fetch (util_byte_array_t *, byteStrings, targetStringIndex);
      // for testing other systems
      // int offset = 0;
      int offset =
    (payloadLength ==
     0) ? 0 : (rand () % payloadLength) - aByteString->length;
      offset = (offset < 0) ? 0 : offset;
      // protect from user specifing size:4; content:"adnan"
      for (i = 0; i < MIN (aByteString->length, payload->length); i++)
    {
      payload->bytes[offset + i] = aByteString->bytes[i];
    }
    }

  pkt = (Pkt_TcpHdr_t *) malloc (payloadLength + sizeof (Pkt_TcpHdr_t));
  assembleTcpPkt (pkt,
          srcPort,
          destPort,
          seqNum,
          ackNum, resDoffFlags, advWindow, checkSum, urgPtr, payload);


  util_byte_array_t *result =
    (util_byte_array_t *) malloc (sizeof (util_byte_array_t));
  result->bytes = (char *) pkt;
  result->length = payloadLength + sizeof (Pkt_TcpHdr_t);

  util_byte_array_free (payload);

  return result;
}


/**
  * \brief  Assemble all the given arguments to create a udp pkt.
  * It is assumed there is enough space pointed to by result.
  */

static void
assembleUdpPkt (Pkt_UdpHdr_t * result,
        u_int16_t srcPort,
        u_int16_t destPort,
        u_int16_t checkSum, util_byte_array_t * payload)
{
  result->srcPort = srcPort;
  result->destPort = destPort;

  memcpy (((char *) result) + sizeof (Pkt_UdpHdr_t), payload->bytes,
      payload->length);

  result->checkSum = checkSum;
  result->length = payload->length + sizeof (Pkt_UdpHdr_t);
}


/**
  * \brief  Assemble all the given arguments to create a tcp pkt.
  *
  * It is assumed there is enough space pointed to by result
  */

static void
assembleTcpPkt (Pkt_TcpHdr_t * result,
        u_int16_t srcPort,
        u_int16_t destPort,
        u_int32_t seqNum,
        u_int32_t ackNum,
        Pkt_TcpResDoffFlags_t resDoffFlags,
        u_int16_t advWindow,
        u_int16_t checkSum,
        u_int16_t urgPtr, util_byte_array_t * payload)
{
  assert (resDoffFlags.doff >= 5);  // hdr length, multiples 4 bytes -> min is 5
  result->srcPort = srcPort;
  result->destPort = destPort;

  result->seqNum = seqNum;
  result->ackNum = ackNum;

  result->res1 = resDoffFlags.res1;
  result->doff = resDoffFlags.doff;

  result->fin = resDoffFlags.fin;
  result->syn = resDoffFlags.syn;
  result->rst = resDoffFlags.rst;
  result->psh = resDoffFlags.psh;
  result->ack = resDoffFlags.ack;
  result->urg = resDoffFlags.urg;
  result->ece = resDoffFlags.ece;
  result->cwr = resDoffFlags.cwr;

  result->advWindow = advWindow;
  result->checkSum = checkSum;
  result->urgPtr = urgPtr;

  memcpy (((char *) result) + (result->doff) * 4, payload->bytes,
      payload->length);

}


/**
  * \brief  Create a IP packet
  * 
  * User defines the "interesting" source and dest IP addresses.
  * If any of these arrays are empty, we take the corresponding field 
  * to be unconstrained.  
  *
  * Payload is constructed by calling function, which is responsible for freeing it.
  */

util_byte_array_t *
Pkt_CreateIpPkt (array_t * srcIps,
         array_t * destIps,
         st_table * ipFlagsTable,
         array_t * offsets,
         array_t * ids,
         st_table * ipOptions,
         array_t * ttls,
         util_byte_array_t * l4Payload, int l4Protocol)
{
  int optionsLength = computeOptionsLength (ipOptions);
  u_int8_t ihl;
  if ((optionsLength % 4) == 0)
    {
      ihl = 5 + (optionsLength / 4);
    }
  else
    {
      ihl = 5 + 1 + (optionsLength / 4);
    }
  u_int8_t version = 4;     // IPv4 only
  u_int8_t TOS = 0;     // not checked in the rules, using 0 
  u_int16_t checksum = 0;   // not checked in the rules, using 0

  u_int32_t srcIp;
  u_int32_t destIp;

  u_int16_t length;

  u_int16_t offset;     // will be converted to a 13 bit quantity
  u_int16_t id;
  u_int8_t ttl = 1;
  u_int8_t prot;

  Pkt_IpFlags_t ipFlags;
  /// \todo make direct user settable
  float direct = 1.0;
  int index;
  if ((srcIps != NIL (array_t)) && (array_n (srcIps) != 0)
      && (util_unit_rand () < direct))
    {
      index = util_rand_int () % array_n (srcIps);
      srcIp = array_fetch (u_int32_t, srcIps, index);
    }
  else
    {
      srcIp = (u_int32_t) util_rand_int ();
    }
  if ((destIps != NIL (array_t)) && (array_n (destIps) != 0)
      && (util_unit_rand () < direct))
    {
      index = util_rand_int () % array_n (destIps);
      destIp = array_fetch (u_int32_t, destIps, index);
    }
  else
    {
      destIp = (u_int32_t) util_rand_int ();
    }

  length =
    l4Payload->length + sizeof (Pkt_IpHdr_t) +
    computeOptionsLength (ipOptions);

  if ((offsets != NIL (array_t)) && (array_n (offsets) != 0)
      && (util_unit_rand () < direct))
    {
      index = util_rand_int () % array_n (offsets);
      offset = array_fetch (int, offsets, index);
    }
  else
    {
      offset = util_rand_int () % (2 << 13);
    }

  if ((ids != NIL (array_t)) && (array_n (ids) != 0)
      && (util_unit_rand () < direct))
    {
      id = util_rand_int () % array_n (ids);
      id = array_fetch (int, ids, index);
    }
  else
    {
      id = util_rand_int () % (2 << 16);
    }

  if ((ttls != NIL (array_t)) && (array_n (ttls) != 0)
      && (util_unit_rand () < direct))
    {
      index = util_rand_int () % array_n (ttls);
      ttl = array_fetch (u_int8_t, ttls, index);
    }
  else
    {
      ttl = util_rand_int () % (2 << 8);
    }
  ipFlags.offset = offset;

  int val;
  ipFlags.RB = Hash_Lookup (ipFlagsTable, (char *) "RB", (char **) &val) ? val :
    0;
  ipFlags.DF = Hash_Lookup (ipFlagsTable, (char *) "DF", (char **) &val) ? val :
    0;
  ipFlags.MF = Hash_Lookup (ipFlagsTable, (char *) "MF", (char **) &val) ? val :
    0;

  prot = l4Protocol;

  util_byte_array_t *result =
    (util_byte_array_t *) malloc (sizeof (util_byte_array_t));
  result->bytes = (char *) malloc (length);
  result->length = length;
  assembleIpPkt ((Pkt_IpHdr_t *) result->bytes,
         ihl,
         version,
         TOS,
         length,
         id,
         ipFlags,
         ipOptions, ttl, prot, checksum, srcIp, destIp, l4Payload);

  return result;
}


/**
  * \brief Create Ethernet packet with given params
  */

Pkt_EthernetHdr_t *
Pkt_CreateEthPkt (char *srcMac,
          char *destMac,
          util_byte_array_t * l3Payload, u_int16_t l3Protocol)
{
  char *result = (char *) malloc (sizeof (Pkt_EthernetHdr_t) + l3Payload->length);
  memcpy (result, srcMac, 6);
  memcpy (result + 6, destMac, 6);

  *((u_int16_t *) (result + 12)) = l3Protocol;
  memcpy (result + sizeof (Pkt_EthernetHdr_t), l3Payload->bytes,
      l3Payload->length);

  return (Pkt_EthernetHdr_t *) result;
}


/**
  * \brief  Assemble an IP pkt out of the given components
  * 
  * \todo todo Add ip options
  */

static void
assembleIpPkt (Pkt_IpHdr_t * pkt,
           u_int8_t ihl,
           u_int8_t version,
           u_int8_t TOS,
           u_int16_t length,
           u_int16_t id,
           Pkt_IpFlags_t ipFlags,
           st_table * ipOptions,
           u_int8_t TTL,
           u_int8_t protocol,
           u_int16_t checksum,
           u_int32_t sourceIp,
           u_int32_t destIp, util_byte_array_t * payload)
{
  pkt->ihl = ihl;
  pkt->version = version;
  pkt->TOS = TOS;
  pkt->length = length;
  pkt->id = id;
  pkt->RB = ipFlags.RB;
  pkt->DF = ipFlags.DF;
  pkt->MF = ipFlags.MF;
  pkt->offset = ipFlags.offset;
  pkt->TTL = TTL;
  pkt->protocol = protocol;
  pkt->checksum = checksum;
  pkt->sourceIp = sourceIp;
  pkt->destIp = destIp;

  int optionsLength = computeOptionsLength (ipOptions);
  char *optionsPtr = ((char *) pkt) + sizeof (Pkt_IpHdr_t);
  char *option;
  Hash_ForEachItemNew (ipOptions, (char **) &option, NIL (char * ))
  {
    if (util_strequal (option, "eol"))
      {
    *(u_int8_t *) optionsPtr = (u_int8_t) 0;
    optionsPtr += 1;
      }
    else if (util_strequal (option, "nop"))
      {
    *(u_int8_t *) optionsPtr = (u_int8_t) 1;
    optionsPtr += 1;
      }
    else if (util_strequal (option, "rr"))
      {
    *(u_int8_t *) optionsPtr = (u_int8_t) 7;
    optionsPtr += 1;
    *(u_int8_t *) optionsPtr = (u_int8_t) 4;    // length field
    optionsPtr += 3;
      }
    else if (util_strequal (option, "ts"))
      {
    *(u_int8_t *) optionsPtr = (u_int8_t) 68;
    optionsPtr += 1;
    *(u_int8_t *) optionsPtr = (u_int8_t) 4;    // length field
    optionsPtr += 3;
      }
    else if (util_strequal (option, "sec"))
      {
    *(u_int8_t *) optionsPtr = (u_int8_t) 130;
    optionsPtr += 1;
    *(u_int8_t *) optionsPtr = (u_int8_t) 4;    // length field
    optionsPtr += 3;
      }
    else if (util_strequal (option, "lsrr"))
      {
    *(u_int8_t *) optionsPtr = (u_int8_t) 131;
    optionsPtr += 1;
    *(u_int8_t *) optionsPtr = (u_int8_t) 4;    // length field
    optionsPtr += 3;
      }
    else if (util_strequal (option, "ssrr"))
      {
    *(u_int8_t *) optionsPtr = (u_int8_t) 137;
    optionsPtr += 1;
    *(u_int8_t *) optionsPtr = (u_int8_t) 4;    // length field
    optionsPtr += 3;
      }
    else if (util_strequal (option, "satid"))
      {
    *(u_int8_t *) optionsPtr = (u_int8_t) 136;
    optionsPtr += 1;
    *(u_int8_t *) optionsPtr = (u_int8_t) 4;    // length field
    optionsPtr += 3;
      }
  }

  char *pktPayload = Pkt_IpExtractPayload (pkt);
  // pad the 0-3 remaining bytes with eop
  while (optionsPtr != pktPayload)
    {
      *(u_int8_t *) optionsPtr = (u_int8_t) 0;
      optionsPtr++;
    }

  int headerLength = ihl * 4;
  memcpy (pktPayload, payload->bytes, length - headerLength);
}


/**
  * \brief  Create a random ethernet packet
  * 
  * For other systems, use Pkt_NetworkByteOrder_c for packet
  * For narya, use Pkt_HostByteOrder_c for packet
  * 
  * numSeeds is the number of packets that the routine
  * uses for seeding the array.
  */

Pkt_EthernetHdr_t *
Pkt_CreateRandEthPkt (array_t * tmpArray)
{
  static int index = 0;

  Pkt_EthernetHdr_t *result =
    array_fetch (Pkt_EthernetHdr_t *, tmpArray, index);
  index = (index + 1) % array_n (tmpArray);

  return result;
}


/** \brief  Create a random ethernet packet; only tcp for now.  */

array_t *
Pkt_SeedRandEthPktArray (Pkt_ByteOrder_t byteOrder,
             int numSeeds, Pkt_TfcMode_t * tfcMode)
{
  array_t *interestingSourcePorts = array_alloc (u_int16_t, 0);
  array_t *interestingDestPorts = array_alloc (u_int16_t, 0);
  array_t *interestingSeqNumbers = array_alloc (u_int32_t, 0);
  array_t *interestingAckNumbers = array_alloc (u_int32_t, 0);
  st_table *tcpFlags = Hash_InitTable ( ( int(*)() ) strcmp, ( int(*)() ) st_strhash);
  array_t *sizes = array_alloc (int, 0);
  array_t *byteStrings = array_alloc (util_byte_array_t *, 0);

  // 21 = ftp
  array_insert_last (u_int16_t, interestingSourcePorts, (u_int16_t) 21);

  array_insert_last (u_int16_t, interestingDestPorts, (u_int16_t) 80);

  array_insert_last (u_int32_t, interestingSeqNumbers, 101058054);

  array_insert_last (u_int32_t, interestingAckNumbers, 0);

  // if ack is present in tcpFlags, corresp value is used, else set randomly
  // same for other flags
  Hash_Insert (tcpFlags, "fin", 0);
  Hash_Insert (tcpFlags, "syn", 0);
  Hash_Insert (tcpFlags, "rst", 0);
  Hash_Insert (tcpFlags, "psh", 0);
  Hash_Insert (tcpFlags, "ack", 0);
  Hash_Insert (tcpFlags, "urg", 0);
  Hash_Insert (tcpFlags, "ece", 0);
  Hash_Insert (tcpFlags, "cwr", 0);

  // sizes is the size of the payload of the encapsulated tcp packet
  // array_insert_last( int, sizes, 1446 );
  array_insert_last (int, sizes, tfcMode->size);

  util_byte_array_t *testByteString1 = util_byte_array_create ("foobar", 6);
  array_insert_last (util_byte_array_t *, byteStrings, testByteString1);
  util_byte_array_t *testByteString2 = util_byte_array_create ("adnan!", 6);
  array_insert_last (util_byte_array_t *, byteStrings, testByteString2);

  array_t *srcIps = array_alloc (u_int32_t, 0);
  array_t *destIps = array_alloc (u_int32_t, 0);
  st_table *ipFlags = Hash_InitTable ( ( int(*)() ) strcmp, ( int(*)() ) st_strhash);
  st_table *ipOptions = Hash_InitTable ( ( int(*)() ) strcmp, ( int(*)() ) st_strhash);
  array_t *offsets = array_alloc (u_int16_t, 0);
  array_t *ids = array_alloc (u_int16_t, 0);
  array_t *ttls = array_alloc (u_int8_t, 0);
  array_t *protocols = array_alloc (u_int8_t, 0);

  array_insert_last (u_int32_t, srcIps, (u_int32_t) 3232235876);
  array_insert_last (u_int32_t, destIps, 3232235786);

  // all ip flags are set to 0
  Hash_Insert (ipFlags, "RB", (char *) 0);
  Hash_Insert (ipFlags, "DF", (char *) 0);
  Hash_Insert (ipFlags, "MF", (char *) 0);

  array_insert_last (u_int16_t, offsets, 0);
  array_insert_last (u_int16_t, ids, 0);
  array_insert_last (u_int8_t, ttls, 255);
  array_insert_last (u_int8_t, protocols, 6);

  array_t *pktArray = array_alloc (Pkt_EthernetHdr_t *, 0);
  int i;
  for (i = 0; i < numSeeds; i++)
    {
      util_byte_array_t *l4Packet =
    Pkt_CreateTcpPkt (interestingSourcePorts, interestingDestPorts,
              interestingSeqNumbers, interestingAckNumbers,
              tcpFlags, sizes, byteStrings);

      util_byte_array_t *l3Packet =
    Pkt_CreateIpPkt (srcIps, destIps, ipFlags, offsets, ids, ipOptions,
             ttls, l4Packet, Pkt_L4ProtTcp_c);

      assert (l3Packet->length <= 1500);
      assert (l3Packet->length >= 20);

      char *srcMac = tfcMode->srcMac;
      char *destMac = tfcMode->destMac;

      Pkt_EthernetHdr_t *result =
    Pkt_CreateEthPkt (srcMac, destMac, l3Packet, Pkt_L3ProtIp_c);

      memcpy ((char *) result + sizeof (Pkt_EthernetHdr_t), l3Packet->bytes,
          l3Packet->length);
      free (l3Packet);
      if (byteOrder == Pkt_NetworkByteOrder_c)
    {
      Pkt_HTON (result);
    }
      array_insert_last (Pkt_EthernetHdr_t *, pktArray, result);
    }

  return pktArray;
}


/**
  * \brief  Take an ethernet packet and convert it to network order.
  *
  * \todo make this work with other protocols, currently only support ip-tcp
  */

void
Pkt_HTON (Pkt_EthernetHdr_t * anEth)
{
  if (anEth->type != Pkt_L3ProtIp_c)
    {
      return;
    }
  Pkt_IpHdr_t *anIp = Pkt_EthernetExtractIp (anEth);

  /// \todo figure out why
  /// for some reason, it seems the translation should not
  /// touch the ethernet type
  /// anEth->type = htons( anEth->type );

  anIp->length = htons (anIp->length);
  anIp->id = htons (anIp->id);

  u_int16_t *RDMoffsetPtr = ((u_int16_t *) ((char *) anIp + 6));
  *RDMoffsetPtr = htons (*RDMoffsetPtr);

  anIp->checksum = htons (anIp->checksum);

  anIp->sourceIp = htonl (anIp->sourceIp);
  anIp->destIp = htonl (anIp->destIp);

  if (anIp->protocol != Pkt_L4ProtTcp_c)
    {
      return;
    }
  Pkt_TcpHdr_t *aTcp = Pkt_IpExtractTcp (anIp);

  aTcp->srcPort = htons (aTcp->srcPort);
  aTcp->destPort = htons (aTcp->destPort);

  aTcp->seqNum = htonl (aTcp->seqNum);
  aTcp->ackNum = htonl (aTcp->ackNum);

  u_int16_t *resdoffPtr USE = ((u_int16_t *) ((char *) aTcp + 12));
  /// \todo
  ///other systems seems to think that the reserved 4 bits and the offset 4 bits
  ///are a single byte (see decode.h), and the flags are another byte.
  ///this contradicts /usr/include/linux/tcp.h, where the two are a single
  ///u_int16_t.  i've turned off the htons to conform with other systems
  ///*resdoffPtr = htons( *resdoffPtr );

  aTcp->advWindow = htons (aTcp->advWindow);
  aTcp->checkSum = htons (aTcp->checkSum);
  aTcp->urgPtr = htons (aTcp->urgPtr);

  return;
}


/**
  * \brief  Take an ethernet packet and convert it to host order.
  *
  * \todo need to support other protocols beyond just tcp and ip
  */

void
Pkt_NTOH (Pkt_EthernetHdr_t * anEth)
{
  /// \todo seems ethernet type field is not
  /// tranlated to network order, vice versa
  /// anEth->type = ntohs( anEth->type );

  if (anEth->type != Pkt_L3ProtIp_c)
    {
      return;
    }

  // layer 3 
  Pkt_IpHdr_t *anIp = Pkt_EthernetExtractIp (anEth);
  anIp->length = ntohs (anIp->length);
  anIp->id = ntohs (anIp->id);

  u_int16_t *RDMoffsetPtr = ((u_int16_t *) ((char *) anIp + 6));
  *RDMoffsetPtr = ntohs (*RDMoffsetPtr);

  anIp->checksum = ntohs (anIp->checksum);

  anIp->sourceIp = ntohl (anIp->sourceIp);
  anIp->destIp = ntohl (anIp->destIp);

  if (anIp->protocol != Pkt_L4ProtTcp_c)
    {
      return;
    }

  // layer 4
  Pkt_TcpHdr_t *aTcp = Pkt_IpExtractTcp (anIp);
  aTcp->srcPort = ntohs (aTcp->srcPort);
  aTcp->destPort = ntohs (aTcp->destPort);
  aTcp->seqNum = ntohl (aTcp->seqNum);
  aTcp->ackNum = ntohl (aTcp->ackNum);

  u_int16_t *resdoffPtr USE = ((u_int16_t *) ((char *) aTcp + 12));
  /// \todo
  /// other systems seems to think that the reserved 4 bits and the offset 4 bits
  /// are a single byte (see decode.h), and the flags are another byte.
  /// this contradicts /usr/include/linux/tcp.h, where the two are a single
  /// u_int16_t.  i've turned off the htons to conform with other systems
  /// *resdoffPtr = htons( *resdoffPtr );

  aTcp->advWindow = ntohs (aTcp->advWindow);
  aTcp->checkSum = ntohs (aTcp->checkSum);
  aTcp->urgPtr = ntohs (aTcp->urgPtr);

  return;
}


/** \brief Compute the length of the ip options we are supposed to set */

static int
computeOptionsLength (st_table * ipoptions)
{
  int result = 0;

  char *option;
  Hash_ForEachItemNew (ipoptions, (char **) &option, NIL (char *))
  {
    if (util_strequal (option, "eol") || util_strequal (option, "nop"))
      {
    result += 1;
      }
    else
      {
    result += 4;        // not taking variable lenght options now
      }
  }
  return result;
}