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

/*

 * Copyright (c) 2007-2008 Louis Pasteur University

 *

 * 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: Sebastien Vincent <vincent@clarinet.u-strasbg.fr>

 */

#include <string.h>

#include "ns3/log.h"

#include "ipv6-address.h"

#include "ns3/assert.h"

#include "mac48-address.h"

#include <iomanip>

NS_LOG_COMPONENT_DEFINE ("Ipv6Address");

namespace ns3 {

#ifdef __cplusplus

extern "C"

{

#endif

  /**

   * \brief Get a hash key.

   * \param k the key

   * \param length the length of the key

   * \param level the previous hash, or an arbitrary value

   * \return hash

   * \note Adpated from Jens Jakobsen implementation (chillispot).

   */

  static uint32_t lookuphash (unsigned char* k, uint32_t length, uint32_t level)

  {

#define mix(a,b,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); \

    }

    typedef uint32_t  ub4;   /* unsigned 4-byte quantities */

    typedef unsigned  char ub1;   /* unsigned 1-byte quantities */

    uint32_t a,b,c,len;

    /* Set up the internal state */

    len = length;

    a = b = 0x9e3779b9;  /* the golden ratio; an arbitrary value */

    c = level;           /* the previous hash value */

    /*---------------------------------------- handle most of the key */

    while (len >= 12)

    {

      a += (k[0] +((ub4)k[1]<<8) +((ub4)k[2]<<16) +((ub4)k[3]<<24));

      b += (k[4] +((ub4)k[5]<<8) +((ub4)k[6]<<16) +((ub4)k[7]<<24));

      c += (k[8] +((ub4)k[9]<<8) +((ub4)k[10]<<16)+((ub4)k[11]<<24));

      mix(a,b,c);

      k += 12; len -= 12;

    }

    /*------------------------------------- handle the last 11 bytes */

    c += length;

    switch(len)              /* all the case statements fall through */

    {

      case 11: c+=((ub4)k[10]<<24);

      case 10: c+=((ub4)k[9]<<16);

      case 9 : c+=((ub4)k[8]<<8);

               /* the first byte of c is reserved for the length */

      case 8 : b+=((ub4)k[7]<<24);

      case 7 : b+=((ub4)k[6]<<16);

      case 6 : b+=((ub4)k[5]<<8);

      case 5 : b+=k[4];

      case 4 : a+=((ub4)k[3]<<24);

      case 3 : a+=((ub4)k[2]<<16);

      case 2 : a+=((ub4)k[1]<<8);

      case 1 : a+=k[0];

               /* case 0: nothing left to add */

    }

    mix(a,b,c);

    /*-------------------------------------------- report the result */

    return c;

  }

#ifdef __cplusplus

}

#endif

/**

 * \brief Convert an IPv6 C-string into a 128-bit representation.

 * \return 1 if OK, 0 if failure (bad format, ...)

 * \note This function is strongly inspired by inet_pton6() from Paul Vixie.

 * \todo Handle IPv6 address with decimal value for last four bytes.

 */

static int AsciiToIpv6Host (char const *address, uint8_t addr[16])

{

  static const char xdigits_l[] = "0123456789abcdef",

               xdigits_u[] = "0123456789ABCDEF";

  unsigned char tmp[16 /*NS_IN6ADDRSZ*/], *tp, *endp, *colonp;

  const char *xdigits, *curtok;

  int ch, seen_xdigits;

  unsigned int val;

  memset((tp = tmp), '\0', 16 /* NS_IN6ADDRSZ*/);

  endp = tp + 16 /*NS_IN6ADDRSZ*/;

  colonp = NULL;

  /* Leading :: requires some special handling. */

  if (*address == ':')

    if (*++address != ':')

      return (0);

  curtok = address;

  seen_xdigits = 0;

  val = 0;

  while ((ch = *address++) != '\0')

  {

    const char *pch;

    if ((pch = strchr((xdigits = xdigits_l), ch)) == NULL)

      pch = strchr((xdigits = xdigits_u), ch);

    if (pch != NULL)

    {

      val <<= 4;

      val |= (pch - xdigits);

      if (++seen_xdigits > 4)

        return (0);

      continue;

    }

    if (ch == ':')

    {

      curtok = address;

      if (!seen_xdigits)

      {

        if (colonp)

          return (0);

        colonp = tp;

        continue;

      }

      if (tp + 2 /*NS_INT16SZ*/ > endp)

        return (0);

      *tp++ = (unsigned char) (val >> 8) & 0xff;

      *tp++ = (unsigned char) val & 0xff;

      seen_xdigits = 0;

      val = 0;

      continue;

    }

    /* TODO Handle address like 2001::xxx.xxx.xxx.xxxx */

#if 0

    if (ch == '.' && ((tp + 4 /*NS_INADDRSZ*/) <= endp) &&

        inet_pton4(curtok, tp) > 0)

    {

      tp += 4 /*NS_INADDRSZ*/;

      seen_xdigits = 0;

      break;/* '\0' was seen by inet_pton4(). */

    }

#endif

    return (0);

  }

  if (seen_xdigits)

  {

    if (tp + 2/* NS_INT16SZ*/ > endp)

      return (0);

    *tp++ = (unsigned char) (val >> 8) & 0xff;

    *tp++ = (unsigned char) val & 0xff;

  }

  if (colonp != NULL)

  {

    /*

     * Since some memmove()'s erroneously fail to handle

     * overlapping regions, we'll do the shift by hand.

     */

    const int n = tp - colonp;

    int i;

    if (tp == endp)

      return (0);

    for (i = 1; i <= n; i++)

    {

      endp[- i] = colonp[n - i];

      colonp[n - i] = 0;

    }

    tp = endp;

  }

  if (tp != endp)

    return (0);

  /* memcpy(dst, tmp, NS_IN6ADDRSZ);  */

  memcpy(addr, tmp, 16);

  return (1);

}

Ipv6Address::Ipv6Address ()

{

  memset(m_address, 0x00, 16);

}

Ipv6Address::Ipv6Address (Ipv6Address const& addr)

{

  memcpy(m_address, addr.m_address, 16);

}

Ipv6Address::Ipv6Address (Ipv6Address const* addr)

{

  memcpy(m_address, addr->m_address, 16);

}

Ipv6Address::Ipv6Address (char const* address)

{

  AsciiToIpv6Host (address, m_address);

}

Ipv6Address::Ipv6Address (uint8_t address[16])

{

  /* 128 bit => 16 bytes */

  memcpy(m_address, address, 16);

}

Ipv6Address::~Ipv6Address ()

{

  /* do nothing */

}

void Ipv6Address::Set (char const* address)

{

  AsciiToIpv6Host (address, m_address);

}

void Ipv6Address::Set (uint8_t address[16])

{

  /* 128 bit => 16 bytes */

  memcpy(m_address, address, 16);

}

void Ipv6Address::Serialize (uint8_t buf[16]) const

{

  memcpy(buf, m_address, 16);

}

Ipv6Address Ipv6Address::Deserialize (const uint8_t buf[16])

{

  Ipv6Address ipv6((uint8_t*)buf);

  return ipv6;

}

Ipv6Address Ipv6Address::MakeAutoconfiguredAddress (Mac48Address addr, Ipv6Address prefix)

{

  Ipv6Address ret;

  uint8_t buf[16];

  uint8_t buf2[16];

  addr.CopyTo(buf);

  prefix.GetBytes(buf2);

  memcpy(buf2 + 8, buf, 3);

  buf2[11] = 0xff;

  buf2[12] = 0xfe;

  memcpy(buf2 + 13, buf + 3, 3);

  buf2[8] |= 0x02;

  ret.Set(buf2);

  return ret;

}

Ipv6Address Ipv6Address::MakeAutoconfiguredLinkLocalAddress (Mac48Address addr)

{

  Ipv6Address ret;

  uint8_t buf[16];

  uint8_t buf2[16];

  addr.CopyTo(buf);

  memset(buf2, 0x00, sizeof(buf2));

  buf2[0] = 0xfe;

  buf2[1] = 0x80;

  memcpy(buf2 + 8, buf, 3);

  buf2[11] = 0xff;

  buf2[12] = 0xfe;

  memcpy(buf2 + 13, buf + 3, 3);

  buf2[8] |= 0x02;

  ret.Set(buf2);

  return ret;

}

Ipv6Address Ipv6Address::MakeSolicitedAddress (Ipv6Address addr)

{

  uint8_t buf[16];

  uint8_t buf2[16];

  Ipv6Address ret;

  addr.Serialize(buf2);

  memset(buf, 0x00, sizeof(buf));

  buf[0] = 0xff;

  buf[1] = 0x02;

  buf[11] = 0x01;

  buf[12] = 0xff;

  buf[13] = buf2[13];

  buf[14] = buf2[14];

  buf[15] = buf2[15];

  ret.Set(buf);

  return ret;

}

void Ipv6Address::Print (std::ostream& os) const

{

  os << std::hex << std::setw(2) << std::setfill('0') << (unsigned int) m_address[0]

    << std::hex << std::setw(2) << std::setfill('0') << (unsigned int) m_address[1] << ":"

    << std::hex << std::setw(2) << std::setfill('0') << (unsigned int) m_address[2] 

    << std::hex << std::setw(2) << std::setfill('0') << (unsigned int) m_address[3] << ":"

    << std::hex << std::setw(2) << std::setfill('0') << (unsigned int) m_address[4]

    << std::hex << std::setw(2) << std::setfill('0') << (unsigned int) m_address[5] << ":"

    << std::hex << std::setw(2) << std::setfill('0') << (unsigned int) m_address[6]

    << std::hex << std::setw(2) << std::setfill('0') << (unsigned int) m_address[7] << ":"

    << std::hex << std::setw(2) << std::setfill('0') << (unsigned int) m_address[8]

    << std::hex << std::setw(2) << std::setfill('0') << (unsigned int) m_address[9] << ":"

    << std::hex << std::setw(2) << std::setfill('0') << (unsigned int) m_address[10]

    << std::hex << std::setw(2) << std::setfill('0') << (unsigned int) m_address[11] << ":"

    << std::hex << std::setw(2) << std::setfill('0') << (unsigned int) m_address[12]

    << std::hex << std::setw(2) << std::setfill('0') << (unsigned int) m_address[13] << ":"

    << std::hex << std::setw(2) << std::setfill('0') << (unsigned int) m_address[14]

    << std::hex << std::setw(2) << std::setfill('0') << (unsigned int) m_address[15];

}

bool Ipv6Address::IsLocalhost () const

{

  static Ipv6Address localhost("::1");

  return (*this == localhost);

}

bool Ipv6Address::IsMulticast () const

{

  if(m_address[0] == 0xff)

  {

    return true;

  }

  return false;

}

Ipv6Address Ipv6Address::CombinePrefix (Ipv6Prefix const & prefix)

{

  Ipv6Address ipv6;

  uint8_t addr[16];

  uint8_t pref[16];

  unsigned int i = 0;

  memcpy(addr, m_address, 16);

  ((Ipv6Prefix)prefix).GetBytes(pref);

  /* a little bit ugly... */

  for(i = 0 ; i < 16 ; i++)

  {

    addr[i] = addr[i] & pref[i];

  }

  ipv6.Set(addr);

  return ipv6;

}

bool Ipv6Address::IsSolicitedMulticast () const

{

  uint8_t buf[16];

  Serialize(buf);

  if(buf[0] == 0xff && 

      buf[1] == 0x02 &&

      buf[11] == 0x01 &&

      buf[12] == 0xff)

  {

    return true;

  }

  return false;

}

bool Ipv6Address::IsAllNodesMulticast () const

{

  static Ipv6Address allnodes("ff02::1");

  return (*this == allnodes);

}

bool Ipv6Address::IsAllRoutersMulticast () const

{

  static Ipv6Address allrouters("ff02::2");

  return (*this == allrouters);

}

bool Ipv6Address::IsAllHostsMulticast () const

{

  static Ipv6Address allhosts("ff02::3");

  return (*this == allhosts);

}

bool Ipv6Address::IsAny () const

{

  static Ipv6Address any("::");

  return (*this == any);

}

bool Ipv6Address::IsMatchingType (const Address& address)

{

  return address.CheckCompatible(GetType(), 16);

}

Ipv6Address::operator Address () const

{

  return ConvertTo ();

}

Address Ipv6Address::ConvertTo (void) const

{

  uint8_t buf[16];

  Serialize (buf);

  return Address(GetType(), buf, 16);

}

Ipv6Address Ipv6Address::ConvertFrom (const Address &address)

{

  NS_ASSERT (address.CheckCompatible (GetType (), 16));

  uint8_t buf[16];

  address.CopyTo (buf);

  return Deserialize (buf);

}

uint8_t Ipv6Address::GetType (void)

{

  static uint8_t type = Address::Register();

  return type;

}

Ipv6Address Ipv6Address::GetZero ()

{

  Ipv6Address zero("::");

  return zero;

}

Ipv6Address Ipv6Address::GetAny ()

{

  Ipv6Address any("::");

  return any;

}

Ipv6Address Ipv6Address::GetAllNodesMulticast ()

{

  Ipv6Address nmc("ff02::1");

  return nmc;

}

Ipv6Address Ipv6Address::GetAllRoutersMulticast ()

{

  Ipv6Address rmc("ff02::2");

  return rmc;

}

Ipv6Address Ipv6Address::GetAllHostsMulticast ()

{

  Ipv6Address hmc("ff02::3");

  return hmc;

}

Ipv6Address Ipv6Address::GetLoopback ()

{

  static Ipv6Address loopback("::1");

  return loopback;

}

void Ipv6Address::GetBytes (uint8_t buf[16]) const

{

  memcpy(buf, m_address, 16);

}

bool Ipv6Address::IsLinkLocal () const

{

  Ipv6Address linkLocal("fe80::0");

  if(!IsMulticast() && ((Ipv6Address*)this)->CombinePrefix(Ipv6Prefix(64))==linkLocal)

  {

    return true;

  }

  return false;

}

bool Ipv6Address::IsEqual (const Ipv6Address& other) const

{

  if(!memcmp(m_address, other.m_address, 16))

  {

    return true;

  }

  return false;

}

std::ostream& operator << (std::ostream& os, Ipv6Address const& address)

{

  address.Print(os);

  return os;

}

std::istream& operator >> (std::istream& is, Ipv6Address& address)

{

  std::string str;

  is >> str;

  address = Ipv6Address (str.c_str ());

  return is;

}

Ipv6Prefix::Ipv6Prefix ()

{

  memset(m_prefix, 0x00, 16);

}

Ipv6Prefix::Ipv6Prefix (char const* prefix)

{

  AsciiToIpv6Host(prefix, m_prefix);

}

Ipv6Prefix::Ipv6Prefix (uint8_t prefix[16])

{

  memcpy(m_prefix, prefix, 16);

}

Ipv6Prefix::Ipv6Prefix (uint8_t prefix)

{

  unsigned int nb=0;

  unsigned int mod=0;

  unsigned int i=0;

  memset(m_prefix, 0x00, 16);

  NS_ASSERT(prefix <= 128);

  nb = prefix / 8;

  mod = prefix % 8;

  memset(m_prefix, 0xff, nb);

  if(mod)

  {

    m_prefix[nb] = 0xff << (8-mod);

  }

  if(nb < 16)

  {

    nb++;

    for(i = nb; i < 16 ; i++)

    {

      m_prefix[i] = 0x00;

    }

  }

}

Ipv6Prefix::Ipv6Prefix (Ipv6Prefix const& prefix)

{

  memcpy(m_prefix, prefix.m_prefix, 16);

}

Ipv6Prefix::Ipv6Prefix (Ipv6Prefix const* prefix)

{

  memcpy(m_prefix, prefix->m_prefix, 16);

}

Ipv6Prefix::~Ipv6Prefix ()

{

  /* do nothing */

}

bool Ipv6Prefix::IsMatch (Ipv6Address a, Ipv6Address b) const

{

  uint8_t addrA[16];

  uint8_t addrB[16];

  unsigned int i = 0;

  a.GetBytes(addrA);

  b.GetBytes(addrB);

  /* a little bit ugly... */

  for(i = 0 ; i < 16 ; i++)

  {

    if((addrA[i] & m_prefix[i]) !=	(addrB[i] & m_prefix[i]))

    {

      return false;

    }

  }

  return true;

}

void Ipv6Prefix::Print (std::ostream &os) const

{

  os << std::hex << std::setw(2) << std::setfill('0') << (unsigned int) m_prefix[0]

    << std::hex << std::setw(2) << std::setfill('0') << (unsigned int) m_prefix[1] << ":"

    << std::hex << std::setw(2) << std::setfill('0') << (unsigned int) m_prefix[2]

    << std::hex << std::setw(2) << std::setfill('0') << (unsigned int) m_prefix[3] << ":"

    << std::hex << std::setw(2) << std::setfill('0') << (unsigned int) m_prefix[4]

    << std::hex << std::setw(2) << std::setfill('0') << (unsigned int) m_prefix[5] << ":"

    << std::hex << std::setw(2) << std::setfill('0') << (unsigned int) m_prefix[6]

    << std::hex << std::setw(2) << std::setfill('0') << (unsigned int) m_prefix[7] << ":"

    << std::hex << std::setw(2) << std::setfill('0') << (unsigned int) m_prefix[8]

    << std::hex << std::setw(2) << std::setfill('0') << (unsigned int) m_prefix[9] << ":"

    << std::hex << std::setw(2) << std::setfill('0') << (unsigned int) m_prefix[10]

    << std::hex << std::setw(2) << std::setfill('0') << (unsigned int) m_prefix[11] << ":"

    << std::hex << std::setw(2) << std::setfill('0') << (unsigned int) m_prefix[12]

    << std::hex << std::setw(2) << std::setfill('0') << (unsigned int) m_prefix[13] << ":"

    << std::hex << std::setw(2) << std::setfill('0') << (unsigned int) m_prefix[14]

    << std::hex << std::setw(2) << std::setfill('0') << (unsigned int) m_prefix[15];

}

Ipv6Prefix Ipv6Prefix::GetLoopback ()

{

  Ipv6Prefix prefix((uint8_t)128);

  return prefix;

}

Ipv6Prefix Ipv6Prefix::GetZero ()

{

  Ipv6Prefix prefix((uint8_t)0);

  return prefix;

}

void Ipv6Prefix::GetBytes (uint8_t buf[16]) const

{

  memcpy(buf, m_prefix, 16);

}

bool Ipv6Prefix::IsEqual (const Ipv6Prefix& other) const

{

  if(!memcmp(m_prefix, other.m_prefix, 16))

  {

    return true;

  }

  return false;

}

std::ostream& operator<< (std::ostream& os, Ipv6Prefix const& prefix)

{

  prefix.Print (os);

  return os;

}

std::istream& operator >> (std::istream& is, Ipv6Prefix& prefix)

{

  std::string str;

  is >> str;

  prefix = Ipv6Prefix (str.c_str ());

  return is;

}

bool operator == (Ipv6Prefix const &a, Ipv6Prefix const &b)

{

  return a.IsEqual (b);

}

bool operator != (Ipv6Prefix const &a, Ipv6Prefix const &b)

{

  return !a.IsEqual (b);

}

size_t Ipv6AddressHash::operator() (Ipv6Address const &x) const

{

  uint8_t buf[16];

  x.GetBytes(buf);

  return lookuphash(buf, sizeof(buf), 0);

}

ATTRIBUTE_HELPER_CPP (Ipv6Address);

ATTRIBUTE_HELPER_CPP (Ipv6Prefix);

} /* namespace ns3 */