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

/*

 * 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: Blake Hurd  <naimorai@gmail.com>

 */

#ifdef NS3_OPENFLOW

#include "openflow-switch-net-device.h"

NS_LOG_COMPONENT_DEFINE ("OpenFlowSwitchNetDevice");

namespace ns3 {

NS_OBJECT_ENSURE_REGISTERED (OpenFlowSwitchNetDevice);

const char *

OpenFlowSwitchNetDevice::GetManufacturerDescription ()

{

  return "The ns-3 team";

}

const char *

OpenFlowSwitchNetDevice::GetHardwareDescription ()

{

  return "N/A";

}

const char *

OpenFlowSwitchNetDevice::GetSoftwareDescription ()

{

  return "Simulated OpenFlow Switch";

}

const char *

OpenFlowSwitchNetDevice::GetSerialNumber ()

{

  return "N/A";

}

static uint64_t

GenerateId ()

{

  uint8_t ea[ETH_ADDR_LEN];

  eth_addr_random (ea);

  return eth_addr_to_uint64 (ea);

}

TypeId

OpenFlowSwitchNetDevice::GetTypeId (void)

{

  static TypeId tid = TypeId ("ns3::OpenFlowSwitchNetDevice")

    .SetParent<NetDevice> ()

    .AddConstructor<OpenFlowSwitchNetDevice> ()

    .AddAttribute ("ID",

                   "The identification of the OpenFlowSwitchNetDevice/Datapath, needed for OpenFlow compatibility.",

                   UintegerValue (GenerateId ()),

                   MakeUintegerAccessor (&OpenFlowSwitchNetDevice::m_id),

                   MakeUintegerChecker<uint64_t> ())

    .AddAttribute ("FlowTableLookupDelay",

                   "A real switch will have an overhead for looking up in the flow table. For the default, we simulate a standard TCAM on an FPGA.",

                   TimeValue (NanoSeconds (30)),

                   MakeTimeAccessor (&OpenFlowSwitchNetDevice::m_lookupDelay),

                   MakeTimeChecker ())

    .AddAttribute ("Flags", // Note: The Controller can configure this value, overriding the user's setting.

                   "Flags to turn different functionality on/off, such as whether to inform the controller when a flow expires, or how to handle fragments.",

                   UintegerValue (0), // Look at the ofp_config_flags enum in openflow/include/openflow.h for options.

                   MakeUintegerAccessor (&OpenFlowSwitchNetDevice::m_flags),

                   MakeUintegerChecker<uint16_t> ())

    .AddAttribute ("FlowTableMissSendLength", // Note: The Controller can configure this value, overriding the user's setting.

                   "When forwarding a packet the switch didn't match up to the controller, it can be more efficient to forward only the first x bytes.",

                   UintegerValue (OFP_DEFAULT_MISS_SEND_LEN), // 128 bytes

                   MakeUintegerAccessor (&OpenFlowSwitchNetDevice::m_missSendLen),

                   MakeUintegerChecker<uint16_t> ())

  ;

  return tid;

}

OpenFlowSwitchNetDevice::OpenFlowSwitchNetDevice ()

  : m_node (0),

    m_ifIndex (0),

    m_mtu (0xffff)

{

  NS_LOG_FUNCTION_NOARGS ();

  m_channel = CreateObject<BridgeChannel> ();

  time_init (); // OFSI's clock; needed to use the buffer storage system.

  // m_lastTimeout = time_now ();

  m_controller = 0;

  // m_listenPVConn = 0;

  m_chain = chain_create ();

  if (m_chain == 0)

    {

      NS_LOG_ERROR ("Not enough memory to create the flow table.");

    }

  m_ports.reserve (DP_MAX_PORTS);

  vport_table_init (&m_vportTable);

}

OpenFlowSwitchNetDevice::~OpenFlowSwitchNetDevice ()

{

  NS_LOG_FUNCTION_NOARGS ();

}

void

OpenFlowSwitchNetDevice::DoDispose ()

{

  NS_LOG_FUNCTION_NOARGS ();

  for (Ports_t::iterator b = m_ports.begin (), e = m_ports.end (); b != e; b++)

    {

      SendPortStatus (*b, OFPPR_DELETE);

      b->netdev = 0;

    }

  m_ports.clear ();

  m_controller = 0;

  chain_destroy (m_chain);

  RBTreeDestroy (m_vportTable.table);

  m_channel = 0;

  m_node = 0;

  NetDevice::DoDispose ();

}

void

OpenFlowSwitchNetDevice::SetController (Ptr<ofi::Controller> c)

{

  if (m_controller != 0)

    {

      NS_LOG_ERROR ("Controller already set.");

      return;

    }

  m_controller = c;

  m_controller->AddSwitch (this);

}

int

OpenFlowSwitchNetDevice::AddSwitchPort (Ptr<NetDevice> switchPort)

{

  NS_LOG_FUNCTION_NOARGS ();

  NS_ASSERT (switchPort != this);

  if (!Mac48Address::IsMatchingType (switchPort->GetAddress ()))

    {

      NS_FATAL_ERROR ("Device does not support eui 48 addresses: cannot be added to switch.");

    }

  if (!switchPort->SupportsSendFrom ())

    {

      NS_FATAL_ERROR ("Device does not support SendFrom: cannot be added to switch.");

    }

  if (m_address == Mac48Address ())

    {

      m_address = Mac48Address::ConvertFrom (switchPort->GetAddress ());

    }

  if (m_ports.size () < DP_MAX_PORTS)

    {

      ofi::Port p;

      p.config = 0;

      p.netdev = switchPort;

      m_ports.push_back (p);

      // Notify the controller that this port has been added

      SendPortStatus (p, OFPPR_ADD);

      NS_LOG_DEBUG ("RegisterProtocolHandler for " << switchPort->GetInstanceTypeId ().GetName ());

      m_node->RegisterProtocolHandler (MakeCallback (&OpenFlowSwitchNetDevice::ReceiveFromDevice, this),

                                       0, switchPort, true);

      m_channel->AddChannel (switchPort->GetChannel ());

    }

  else

    {

      return EXFULL;

    }

  return 0;

}

void

OpenFlowSwitchNetDevice::SetIfIndex (const uint32_t index)

{

  NS_LOG_FUNCTION_NOARGS ();

  m_ifIndex = index;

}

uint32_t

OpenFlowSwitchNetDevice::GetIfIndex (void) const

{

  NS_LOG_FUNCTION_NOARGS ();

  return m_ifIndex;

}

Ptr<Channel>

OpenFlowSwitchNetDevice::GetChannel (void) const

{

  NS_LOG_FUNCTION_NOARGS ();

  return m_channel;

}

void

OpenFlowSwitchNetDevice::SetAddress (Address address)

{

  NS_LOG_FUNCTION_NOARGS ();

  m_address = Mac48Address::ConvertFrom (address);

}

Address

OpenFlowSwitchNetDevice::GetAddress (void) const

{

  NS_LOG_FUNCTION_NOARGS ();

  return m_address;

}

bool

OpenFlowSwitchNetDevice::SetMtu (const uint16_t mtu)

{

  NS_LOG_FUNCTION_NOARGS ();

  m_mtu = mtu;

  return true;

}

uint16_t

OpenFlowSwitchNetDevice::GetMtu (void) const

{

  NS_LOG_FUNCTION_NOARGS ();

  return m_mtu;

}

bool

OpenFlowSwitchNetDevice::IsLinkUp (void) const

{

  NS_LOG_FUNCTION_NOARGS ();

  return true;

}

void

OpenFlowSwitchNetDevice::AddLinkChangeCallback (Callback<void> callback)

{

}

bool

OpenFlowSwitchNetDevice::IsBroadcast (void) const

{

  NS_LOG_FUNCTION_NOARGS ();

  return true;

}

Address

OpenFlowSwitchNetDevice::GetBroadcast (void) const

{

  NS_LOG_FUNCTION_NOARGS ();

  return Mac48Address ("ff:ff:ff:ff:ff:ff");

}

bool

OpenFlowSwitchNetDevice::IsMulticast (void) const

{

  NS_LOG_FUNCTION_NOARGS ();

  return true;

}

Address

OpenFlowSwitchNetDevice::GetMulticast (Ipv4Address multicastGroup) const

{

  NS_LOG_FUNCTION (this << multicastGroup);

  Mac48Address multicast = Mac48Address::GetMulticast (multicastGroup);

  return multicast;

}

bool

OpenFlowSwitchNetDevice::IsPointToPoint (void) const

{

  NS_LOG_FUNCTION_NOARGS ();

  return false;

}

bool

OpenFlowSwitchNetDevice::IsBridge (void) const

{

  NS_LOG_FUNCTION_NOARGS ();

  return true;

}

void

OpenFlowSwitchNetDevice::DoOutput (uint32_t packet_uid, int in_port, size_t max_len, int out_port, bool ignore_no_fwd)

{

  if (out_port != OFPP_CONTROLLER)

    {

      OutputPort (packet_uid, in_port, out_port, ignore_no_fwd);

    }

  else

    {

      OutputControl (packet_uid, in_port, max_len, OFPR_ACTION);

    }

}

bool

OpenFlowSwitchNetDevice::Send (Ptr<Packet> packet, const Address& dest, uint16_t protocolNumber)

{

  NS_LOG_FUNCTION_NOARGS ();

  return SendFrom (packet, m_address, dest, protocolNumber);

}

bool

OpenFlowSwitchNetDevice::SendFrom (Ptr<Packet> packet, const Address& src, const Address& dest, uint16_t protocolNumber)

{

  NS_LOG_FUNCTION_NOARGS ();

  ofpbuf *buffer = BufferFromPacket (packet,src,dest,GetMtu (),protocolNumber);

  uint32_t packet_uid = save_buffer (buffer);

  ofi::SwitchPacketMetadata data;

  data.packet = packet;

  data.buffer = buffer;

  data.protocolNumber = protocolNumber;

  data.src = Address (src);

  data.dst = Address (dest);

  m_packetData.insert (std::make_pair (packet_uid, data));

  RunThroughFlowTable (packet_uid, -1);

  return true;

}

Ptr<Node>

OpenFlowSwitchNetDevice::GetNode (void) const

{

  NS_LOG_FUNCTION_NOARGS ();

  return m_node;

}

void

OpenFlowSwitchNetDevice::SetNode (Ptr<Node> node)

{

  NS_LOG_FUNCTION_NOARGS ();

  m_node = node;

}

bool

OpenFlowSwitchNetDevice::NeedsArp (void) const

{

  NS_LOG_FUNCTION_NOARGS ();

  return true;

}

void

OpenFlowSwitchNetDevice::SetReceiveCallback (NetDevice::ReceiveCallback cb)

{

  NS_LOG_FUNCTION_NOARGS ();

  m_rxCallback = cb;

}

void

OpenFlowSwitchNetDevice::SetPromiscReceiveCallback (NetDevice::PromiscReceiveCallback cb)

{

  NS_LOG_FUNCTION_NOARGS ();

  m_promiscRxCallback = cb;

}

bool

OpenFlowSwitchNetDevice::SupportsSendFrom () const

{

  NS_LOG_FUNCTION_NOARGS ();

  return true;

}

Address

OpenFlowSwitchNetDevice::GetMulticast (Ipv6Address addr) const

{

  NS_LOG_FUNCTION (this << addr);

  return Mac48Address::GetMulticast (addr);

}

// Add a virtual port table entry.

int

OpenFlowSwitchNetDevice::AddVPort (const ofp_vport_mod *ovpm)

{

  size_t actions_len = ntohs (ovpm->header.length) - sizeof *ovpm;

  unsigned int vport = ntohl (ovpm->vport);

  unsigned int parent_port = ntohl (ovpm->parent_port);

  // check whether port table entry exists for specified port number

  vport_table_entry *vpe = vport_table_lookup (&m_vportTable, vport);

  if (vpe != 0)

    {

      NS_LOG_ERROR ("vport " << vport << " already exists!");

      SendErrorMsg (OFPET_BAD_ACTION, OFPET_VPORT_MOD_FAILED, ovpm, ntohs (ovpm->header.length));

      return EINVAL;

    }

  // check whether actions are valid

  uint16_t v_code = ofi::ValidateVPortActions (ovpm->actions, actions_len);

  if (v_code != ACT_VALIDATION_OK)

    {

      SendErrorMsg (OFPET_BAD_ACTION, v_code, ovpm, ntohs (ovpm->header.length));

      return EINVAL;

    }

  vpe = vport_table_entry_alloc (actions_len);

  vpe->vport = vport;

  vpe->parent_port = parent_port;

  if (vport < OFPP_VP_START || vport > OFPP_VP_END)

    {

      NS_LOG_ERROR ("port " << vport << " is not in the virtual port range (" << OFPP_VP_START << "-" << OFPP_VP_END << ")");

      SendErrorMsg (OFPET_BAD_ACTION, OFPET_VPORT_MOD_FAILED, ovpm, ntohs (ovpm->header.length));

      free_vport_table_entry (vpe); // free allocated entry

      return EINVAL;

    }

  vpe->port_acts->actions_len = actions_len;

  memcpy (vpe->port_acts->actions, ovpm->actions, actions_len);

  int error = insert_vport_table_entry (&m_vportTable, vpe);

  if (error)

    {

      NS_LOG_ERROR ("could not insert port table entry for port " << vport);

    }

  return error;

}

ofpbuf *

OpenFlowSwitchNetDevice::BufferFromPacket (Ptr<Packet> packet, Address src, Address dst, int mtu, uint16_t protocol)

{

  NS_LOG_INFO ("Creating Openflow buffer from packet.");

  /*

   * Allocate buffer with some headroom to add headers in forwarding

   * to the controller or adding a vlan tag, plus an extra 2 bytes to

   * allow IP headers to be aligned on a 4-byte boundary.

   */

  const int headroom = 128 + 2;

  const int hard_header = VLAN_ETH_HEADER_LEN;

  ofpbuf *buffer = ofpbuf_new (headroom + hard_header + mtu);

  buffer->data = (char*)buffer->data + headroom + hard_header;

  int l2_length = 0, l3_length = 0, l4_length = 0;

  // Load headers

  EthernetHeader eth_hd;

  if (packet->PeekHeader (eth_hd))

    {

      buffer->l2 = new eth_header;

      eth_header* eth_h = (eth_header*)buffer->l2;

      dst.CopyTo (eth_h->eth_dst);              // Destination Mac Address

      src.CopyTo (eth_h->eth_src);              // Source Mac Address

      eth_h->eth_type = htons (ETH_TYPE_IP);    // Ether Type

      NS_LOG_INFO ("Parsed EthernetHeader");

      l2_length = ETH_HEADER_LEN;

    }

  // We have to wrap this because PeekHeader has an assert fail if we check for an Ipv4Header that isn't there.

  if (protocol == Ipv4L3Protocol::PROT_NUMBER)

    {

      Ipv4Header ip_hd;

      if (packet->PeekHeader (ip_hd))

        {

          buffer->l3 = new ip_header;

          ip_header* ip_h = (ip_header*)buffer->l3;

          ip_h->ip_ihl_ver  = IP_IHL_VER (5, IP_VERSION);       // Version

          ip_h->ip_tos      = ip_hd.GetTos ();                  // Type of Service/Differentiated Services

          ip_h->ip_tot_len  = packet->GetSize ();               // Total Length

          ip_h->ip_id       = ip_hd.GetIdentification ();       // Identification

          ip_h->ip_frag_off = ip_hd.GetFragmentOffset ();       // Fragment Offset

          ip_h->ip_ttl      = ip_hd.GetTtl ();                  // Time to Live

          ip_h->ip_proto    = ip_hd.GetProtocol ();             // Protocol

          ip_h->ip_src      = htonl (ip_hd.GetSource ().Get ()); // Source Address

          ip_h->ip_dst      = htonl (ip_hd.GetDestination ().Get ()); // Destination Address

          ip_h->ip_csum     = csum (&ip_h, sizeof ip_h);        // Header Checksum

          NS_LOG_INFO ("Parsed Ipv4Header");

          l3_length = IP_HEADER_LEN;

        }

    }

  else

    {

      // ARP Packet; the underlying OpenFlow header isn't used to match, so this is probably superfluous.

      ArpHeader arp_hd;

      if (packet->PeekHeader (arp_hd))

        {

          buffer->l3 = new arp_eth_header;

          arp_eth_header* arp_h = (arp_eth_header*)buffer->l3;

          arp_h->ar_hrd = ARP_HRD_ETHERNET;                             // Hardware type.

          arp_h->ar_pro = ARP_PRO_IP;                                   // Protocol type.

          arp_h->ar_op = arp_hd.m_type;                                 // Opcode.

          arp_hd.GetDestinationHardwareAddress ().CopyTo (arp_h->ar_tha); // Target hardware address.

          arp_hd.GetSourceHardwareAddress ().CopyTo (arp_h->ar_sha);    // Sender hardware address.

          arp_h->ar_tpa = arp_hd.GetDestinationIpv4Address ().Get ();   // Target protocol address.

          arp_h->ar_spa = arp_hd.GetSourceIpv4Address ().Get ();        // Sender protocol address.

          arp_h->ar_hln = sizeof arp_h->ar_tha;                         // Hardware address length.

          arp_h->ar_pln = sizeof arp_h->ar_tpa;                         // Protocol address length.

          NS_LOG_INFO ("Parsed ArpHeader");

          l3_length = ARP_ETH_HEADER_LEN;

        }

    }

    {