/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */

/* 

 * Copyright (c) 2009 University of Texas at Dallas

 * 

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 as

 * published by the Free Software Foundation;

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 * 

 * Author: Qasim Javed <qasim@utdallas.edu>

 */

#include "netfilter-conntrack-tuple.h"

NS_LOG_COMPONENT_DEFINE ("ConntrackTupleHash");

namespace ns3 {

NetfilterConntrackTuple::NetfilterConntrackTuple ()

{

  m_l4Source = 0;

  m_l4Destination = 0;

}

NetfilterConntrackTuple::NetfilterConntrackTuple (Ipv4Address src, uint16_t srcPort, Ipv4Address dst, uint16_t dstPort)

{

  m_l3Source = src;

  m_l4Source = srcPort;

  m_l3Destination = dst;

  m_l4Destination = dstPort;

}

bool 

NetfilterConntrackTuple::operator== (const NetfilterConntrackTuple t) const

{

  return (m_l3Source == t.m_l3Source) &&

    (m_l4Source == t.m_l4Source) &&

      (m_l3Destination == t.m_l3Destination) &&

        (m_l4Destination == t.m_l4Destination);

}

bool 

NetfilterConntrackTuple::SourceEqual (NetfilterConntrackTuple t1, NetfilterConntrackTuple t2)

{

  return (t1.m_l3Source == t2.m_l3Source) &&

    (t1.m_l4Source == t2.m_l4Source);

}

bool 

NetfilterConntrackTuple::DestinationEqual (NetfilterConntrackTuple t1, NetfilterConntrackTuple t2)

{

  return (t1.m_l3Destination == t2.m_l3Destination) &&

    (t1.m_l4Destination == t2.m_l4Destination);

}

Ipv4Address 

NetfilterConntrackTuple::GetSource () const

{

  return m_l3Source;

}

void 

NetfilterConntrackTuple::SetSource (Ipv4Address source) 

{

  m_l3Source = source;

}

void 

NetfilterConntrackTuple::SetSourcePort (uint16_t port)

{

  m_l4Source = port;

}

void 

NetfilterConntrackTuple::SetDestination (Ipv4Address destination) 

{

  m_l3Destination = destination;

}

void 

NetfilterConntrackTuple::SetDestinationPort (uint16_t destination) 

{

  m_l4Destination = destination;

}

Ipv4Address 

NetfilterConntrackTuple::GetDestination () const

{

  return m_l3Destination;

}

uint16_t 

NetfilterConntrackTuple::GetSourcePort () const

{

  return m_l4Source;

}

uint16_t 

NetfilterConntrackTuple::GetDestinationPort () const

{

  return m_l4Destination;

}

uint16_t 

NetfilterConntrackTuple::GetDestinationProtocol () const

{

  return m_protocolNumber;

}

void 

NetfilterConntrackTuple::SetProtocol (uint16_t protocol) 

{

  m_l3Protocol = protocol;

}

uint16_t NetfilterConntrackTuple::GetProtocol ()

{

  return m_l3Protocol;

}

void 

NetfilterConntrackTuple::SetDirection (ConntrackDirection_t direction)

{

  m_direction = (uint8_t)direction;

}

uint8_t 

NetfilterConntrackTuple::GetDirection () const

{

  return m_direction;

}

char* 

NetfilterConntrackTuple::ToString () const

{

  return (char *)this;

}

NetfilterConntrackTuple 

NetfilterConntrackTuple::Invert ()

{

  NetfilterConntrackTuple inverse (GetDestination (), GetDestinationPort (), GetSource (), GetSourcePort ());

  inverse.SetDirection (this->GetDirection () == IP_CT_DIR_ORIGINAL ? IP_CT_DIR_REPLY : IP_CT_DIR_ORIGINAL);

  return inverse;

}

void 

NetfilterConntrackTuple::Print (std::ostream &os) const

{

  os << "( " << GetSource () << "," << GetSourcePort () << "," << GetDestination () << "," << GetDestinationPort () << (int)GetDirection () << ")";

}

NetfilterConntrackTuple&

NetfilterConntrackTuple::operator= (const NetfilterConntrackTuple&  tuple)

{

  if (this != &tuple)

  {

    m_l3Source = tuple.m_l3Source;

    m_l4Source = tuple.m_l4Source;

    m_l3Destination = tuple.m_l3Destination;

    m_l4Destination = tuple.m_l4Destination;

    m_l3Protocol = tuple.m_l3Protocol;

    m_protocolNumber = tuple.m_protocolNumber;

    m_direction = tuple.m_direction;

  }

  return *this;

}

std::ostream& operator << (std::ostream& os, NetfilterConntrackTuple const& tuple)

{

  os << "( " << tuple.GetSource () << "," << tuple.GetSourcePort () << "," << tuple.GetDestination () << "," << tuple.GetDestinationPort () << ", " << (int)tuple.GetDirection () << ")";

  return os;

}

#define JHASH_GOLDEN_RATIO  0x9e3779b9

void 

JHashMix (uint32_t a, uint32_t b, uint32_t c)

{

  a -= b; a -= c; a ^= (c>>13);

  b -= c; b -= a; b ^= (a<<8);

  c -= a; c -= b; c ^= (b>>13);

  a -= b; a -= c; a ^= (c>>12);

  b -= c; b -= a; b ^= (a<<16);

  c -= a; c -= b; c ^= (b>>5);

  a -= b; a -= c; a ^= (c>>3);

  b -= c; b -= a; b ^= (a<<10);

  c -= a; c -= b; c ^= (b>>15);

}

uint32_t 

JHash2 (const uint32_t *k, uint32_t length, uint32_t initval)

{

  uint32_t a, b, c, len;

  a = b = JHASH_GOLDEN_RATIO;

  c = initval;

  len = length;

  while (len >= 3) {

    a += k[0];

    b += k[1];

    c += k[2];

    JHashMix (a, b, c);

    k += 3; len -= 3;

  }

  c += length * 4;

  switch (len) {

    case 2 : b += k[1];

    case 1 : a += k[0];

  };

  JHashMix (a,b,c);

  return c;

}

size_t 

ConntrackTupleHash::operator() (const NetfilterConntrackTuple &x) const

{

  uint32_t n;

  uint32_t h;

  uint16_t rnd = 2;

  uint32_t size = 12;

  n = (sizeof (x.GetSource ())+ sizeof (x.GetSourcePort ()) +

        sizeof (x.GetDestination())+ sizeof (x.GetDestinationPort ()))/sizeof (uint32_t);

  h = JHash2 ((uint32_t*)(x.ToString ()), n, rnd ^ (((x.GetDestinationPort ()) << 16) | x.GetDestinationProtocol ()));

  NS_LOG_DEBUG ("Hashing ==> Tuple " <<  "( " << x.GetSource () << "," << x.GetSourcePort () << "," << x.GetDestination () << "," << x.GetDestinationPort () << "," << (int)x.GetDirection () << ")" << " Hash: " << (((uint64_t)h * size) >> 32));

  return ((uint64_t)h * size) >> 32;

}

}