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

/*

 * Copyright (c) 2008 University of Washington

 *

 * 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

 */

#include "emu-net-device.h"

#include "emu-encode-decode.h"

#include "ns3/log.h"

#include "ns3/queue.h"

#include "ns3/simulator.h"

#include "ns3/ethernet-header.h"

#include "ns3/ethernet-trailer.h"

#include "ns3/llc-snap-header.h"

#include "ns3/boolean.h"

#include "ns3/uinteger.h"

#include "ns3/pointer.h"

#include "ns3/string.h"

#include "ns3/trace-source-accessor.h"

#include "ns3/channel.h"

#include "ns3/system-thread.h"

#include "ns3/realtime-simulator-impl.h"

#include "ns3/mac48-address.h"

#include <sys/wait.h>

#include <sys/stat.h>

#include <sys/socket.h>

#include <sys/un.h>

#include <sys/ioctl.h>

#include <net/ethernet.h>

#include <net/if.h>

#include <netinet/in.h>

#include <netpacket/packet.h>

#include <arpa/inet.h>

#include <errno.h>

#include <limits>

#include <stdlib.h>

NS_LOG_COMPONENT_DEFINE ("EmuNetDevice");

namespace ns3 {

NS_OBJECT_ENSURE_REGISTERED (EmuNetDevice);

#define EMU_MAGIC 65867

TypeId 

EmuNetDevice::GetTypeId (void)

{

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

    .SetParent<NetDevice> ()

    .AddConstructor<EmuNetDevice> ()

    .AddAttribute ("Address", 

                   "The ns-3 MAC address of this (virtual) device.",

                   Mac48AddressValue (Mac48Address ("ff:ff:ff:ff:ff:ff")),

                   MakeMac48AddressAccessor (&EmuNetDevice::m_address),

                   MakeMac48AddressChecker ())

    .AddAttribute ("DeviceName", 

                   "The name of the underlying real device (e.g. eth1).",

                   StringValue ("eth1"),

                   MakeStringAccessor (&EmuNetDevice::m_deviceName),

                   MakeStringChecker ())

    .AddAttribute ("Start", 

                   "The simulation time at which to spin up the device thread.",

                   TimeValue (Seconds (0.)),

                   MakeTimeAccessor (&EmuNetDevice::m_tStart),

                   MakeTimeChecker ())

    .AddAttribute ("Stop", 

                   "The simulation time at which to tear down the device thread.",

                   TimeValue (Seconds (0.)),

                   MakeTimeAccessor (&EmuNetDevice::m_tStop),

                   MakeTimeChecker ())

    //

    // Transmit queueing discipline for the device which includes its own set

    // of trace hooks.  Note that this is really going to run "on top of" the 

    // queueing discipline that will most likely be present in the devices of

    // the underlying operating system.

    //

    .AddAttribute ("TxQueue", 

                   "A queue to use as the transmit queue in the device.",

                   PointerValue (),

                   MakePointerAccessor (&EmuNetDevice::m_queue),

                   MakePointerChecker<Queue> ())

    //

    // Trace sources at the "top" of the net device, where packets transition

    // to/from higher layers.  These points do not really correspond to the 

    // MAC layer of the underlying operating system, but exist to provide 

    // a consitent tracing environment.  These trace hooks should really be

    // interpreted as the points at which a packet leaves the ns-3 environment

    // destined for the underlying operating system or vice-versa.

    //

    .AddTraceSource ("MacTx", 

                     "Trace source indicating a packet has arrived for transmission by this device",

                     MakeTraceSourceAccessor (&EmuNetDevice::m_macTxTrace))

    .AddTraceSource ("MacTxDrop", 

                     "Trace source indicating a packet has been dropped by the device before transmission",

                     MakeTraceSourceAccessor (&EmuNetDevice::m_macTxDropTrace))

    .AddTraceSource ("MacPromiscRx", 

                     "A packet has been received by this device, has been passed up from the physical layer "

                     "and is being forwarded up the local protocol stack.  This is a promiscuous trace,",

                     MakeTraceSourceAccessor (&EmuNetDevice::m_macPromiscRxTrace))

    .AddTraceSource ("MacRx", 

                     "A packet has been received by this device, has been passed up from the physical layer "

                     "and is being forwarded up the local protocol stack.  This is a non-promiscuous trace,",

                     MakeTraceSourceAccessor (&EmuNetDevice::m_macRxTrace))

#if 0

    // Not currently implemented for this device

    .AddTraceSource ("MacRxDrop", 

                     "Trace source indicating a packet was dropped before being forwarded up the stack",

                     MakeTraceSourceAccessor (&EmuNetDevice::m_macRxDropTrace))

#endif

    //

    // In normal ns-3 net devices, these trace souces correspond to the "bottom"

    // of the net device, where packets transition to/from the channel.  In 

    // the case of the emu device, there is no physical layer access -- all we

    // do is to send packets to another device that is really at a "real" MAC

    // level.  Since it could be misleading to call anything here PHY, we do not

    // implement these trace sources.

    //

#if 0

    .AddTraceSource ("PhyTxBegin", 

                     "Trace source indicating a packet has begun transmitting over the channel",

                     MakeTraceSourceAccessor (&EmuNetDevice::m_phyTxBeginTrace))

    .AddTraceSource ("PhyTxEnd", 

                     "Trace source indicating a packet has been completely transmitted over the channel",

                     MakeTraceSourceAccessor (&EmuNetDevice::m_phyTxEndTrace))

    .AddTraceSource ("PhyTxDrop", 

                     "Trace source indicating a packet has been dropped by the device during transmission",

                     MakeTraceSourceAccessor (&EmuNetDevice::m_phyTxDropTrace))

    .AddTraceSource ("PhyRxBegin", 

                     "Trace source indicating a packet has begun being received by the device",

                     MakeTraceSourceAccessor (&EmuNetDevice::m_phyRxBeginTrace))

    .AddTraceSource ("PhyRxEnd", 

                     "Trace source indicating a packet has been completely received by the device",

                     MakeTraceSourceAccessor (&EmuNetDevice::m_phyRxEndTrace))

    .AddTraceSource ("PhyRxDrop", 

                     "Trace source indicating a packet has been dropped by the device during reception",

                     MakeTraceSourceAccessor (&EmuNetDevice::m_phyRxDropTrace))

#endif

    //

    // Trace sources designed to simulate a packet sniffer facility (tcpdump). 

    //

    .AddTraceSource ("Sniffer", 

                     "Trace source simulating a non-promiscuous packet sniffer attached to the device",

                     MakeTraceSourceAccessor (&EmuNetDevice::m_snifferTrace))

    .AddTraceSource ("PromiscSniffer", 

                     "Trace source simulating a promiscuous packet sniffer attached to the device",

                     MakeTraceSourceAccessor (&EmuNetDevice::m_promiscSnifferTrace))

    ;

  return tid;

}

EmuNetDevice::EmuNetDevice () 

: 

  m_startEvent (),

  m_stopEvent (),

  m_sock (-1),

  m_readThread (0),

  m_ifIndex (std::numeric_limits<uint32_t>::max ()),  // absurdly large value

  m_sll_ifindex (-1),

  m_isBroadcast (true),

  m_isMulticast (false)

{

  NS_LOG_FUNCTION (this);

  Start (m_tStart);

}

EmuNetDevice::~EmuNetDevice ()

{

}

void 

EmuNetDevice::DoDispose()

{

  NS_LOG_FUNCTION_NOARGS ();

  m_node = 0;

  NetDevice::DoDispose ();

}

void

EmuNetDevice::Start (Time tStart)

{

  NS_LOG_FUNCTION (tStart);

  //

  // Cancel any pending start event and schedule a new one at some relative time in the future.

  //

  Simulator::Cancel (m_startEvent);

  m_startEvent = Simulator::Schedule (tStart, &EmuNetDevice::StartDevice, this);

}

  void

EmuNetDevice::Stop (Time tStop)

{

  NS_LOG_FUNCTION (tStop);

  //

  // Cancel any pending stop event and schedule a new one at some relative time in the future.

  //

  Simulator::Cancel (m_stopEvent);

  m_startEvent = Simulator::Schedule (tStop, &EmuNetDevice::StopDevice, this);

}

  void

EmuNetDevice::StartDevice (void)

{

  NS_LOG_FUNCTION_NOARGS ();

  //

  // Spin up the emu net device and start receiving packets.

  //

  if (m_sock != -1)

    {

      NS_FATAL_ERROR ("EmuNetDevice::StartDevice(): Device is already started");

    }

  NS_LOG_LOGIC ("Creating socket");

  //

  // Call out to a separate process running as suid root in order to get a raw 

  // socket.  We do this to avoid having the entire simulation running as root.

  // If this method returns, we'll have a raw socket waiting for us in m_sock.

  //

  CreateSocket ();

  //

  // Figure out which interface index corresponds to the device name in the corresponding attribute.

  //

  struct ifreq ifr;

  bzero (&ifr, sizeof(ifr));

  strncpy ((char *)ifr.ifr_name, m_deviceName.c_str (), IFNAMSIZ);

  NS_LOG_LOGIC ("Getting interface index");

  int32_t rc = ioctl (m_sock, SIOCGIFINDEX, &ifr);

  if (rc == -1)

    {

      NS_FATAL_ERROR ("EmuNetDevice::StartDevice(): Can't get interface index");

    }

  //

  // Save the real interface index for later calls to sendto

  //

  m_sll_ifindex = ifr.ifr_ifindex;

  //

  // Bind the socket to the interface we just found.

  //

  struct sockaddr_ll ll;

  bzero (&ll, sizeof(ll));

  ll.sll_family = AF_PACKET;

  ll.sll_ifindex = m_sll_ifindex;

  ll.sll_protocol = htons(ETH_P_ALL); 

  NS_LOG_LOGIC ("Binding socket to interface");

  rc = bind (m_sock, (struct sockaddr *)&ll, sizeof (ll));

  if (rc == -1)

    {

      NS_FATAL_ERROR ("EmuNetDevice::StartDevice(): Can't bind to specified interface");

    }

  rc = ioctl(m_sock, SIOCGIFFLAGS, &ifr);

  if (rc == -1)

    {

      NS_FATAL_ERROR ("EmuNetDevice::StartDevice(): Can't get interface flags");

    }

  //

  // This device only works if the underlying interface is up in promiscuous 

  // mode.  We could have turned it on in the socket creator, but the situation

  // is that we expect these devices to be used in conjunction with virtual 

  // machines with connected host-only (simulated) networks, or in a testbed.

  // There is a lot of setup and configuration happening outside of this one 

  // issue, and we expect that configuration to include choosing a valid

  // interface (e.g, "ath1"), ensuring that the device supports promiscuous 

  // mode, and placing it in promiscuous mode.  We just make sure of the

  // end result.

  //

  if ((ifr.ifr_flags & IFF_PROMISC) == 0)

    {

      NS_FATAL_ERROR ("EmuNetDevice::StartDevice(): " << m_deviceName << " is not in promiscuous mode");

    }

  if ((ifr.ifr_flags & IFF_BROADCAST) != IFF_BROADCAST)

    {

      // We default m_isBroadcast to true but turn it off here if not

      // supported, because in the common case, overlying IP code will 

      // assert during configuration time if this is false, before this

      // method has a chance to set it during runtime

      m_isBroadcast = false;

    }

  if ((ifr.ifr_flags & IFF_MULTICAST) == IFF_MULTICAST)

    {

      // This one is OK to enable at runtime

      m_isMulticast = true;

    }

  //

  // Now spin up a read thread to read packets.

  //

  if (m_readThread != 0)

    {

      NS_FATAL_ERROR ("EmuNetDevice::StartDevice(): Receive thread is already running");

    }

  NS_LOG_LOGIC ("Spinning up read thread");

  m_readThread = Create<SystemThread> (MakeCallback (&EmuNetDevice::ReadThread, this));

  m_readThread->Start ();

  NotifyLinkUp ();

}

void

EmuNetDevice::CreateSocket (void)

{

  NS_LOG_FUNCTION_NOARGS ();

  //

  // We want to create a raw socket for our net device.  Unfortunately for us

  // you have to have root privileges to do that.  Instead of running the 

  // entire simulation as root, we decided to make a small program who's whole

  // reason for being is to run as suid root and create a raw socket.  We're

  // going to fork and exec that program soon, but we need to have a socket

  // to talk to it with.  So we create a local interprocess (Unix) socket 

  // for that purpose.

  //

  int sock = socket (PF_UNIX, SOCK_DGRAM, 0);

  if (sock == -1)

    {

      NS_FATAL_ERROR ("EmuNetDevice::CreateSocket(): Unix socket creation error, errno = " << strerror (errno));

    }

  //

  // Bind to that socket and let the kernel allocate an endpoint

  //

  struct sockaddr_un un;

  memset (&un, 0, sizeof (un));

  un.sun_family = AF_UNIX;

  int status = bind (sock, (struct sockaddr*)&un, sizeof (sa_family_t));

  if (status == -1)

    {

      NS_FATAL_ERROR ("EmuNetDevice::CreateSocket(): Could not bind(): errno = " << strerror (errno));

    }

  NS_LOG_INFO ("Created Unix socket");

  NS_LOG_INFO ("sun_family = " << un.sun_family);

  NS_LOG_INFO ("sun_path = " << un.sun_path);

  //

  // We have a socket here, but we want to get it there -- to the program we're

  // going to exec.  What we'll do is to do a getsockname and then encode the

  // resulting address information as a string, and then send the string to the

  // program as an argument.  So we need to get the sock name.

  //

  socklen_t len = sizeof (un);

  status = getsockname (sock, (struct sockaddr*)&un, &len);

  if (status == -1)

    {

      NS_FATAL_ERROR ("EmuNetDevice::CreateSocket(): Could not getsockname(): errno = " << strerror (errno));

    }

  //

  // Now encode that socket name (family and path) as a string of hex digits

  //

  std::string path = EmuBufferToString((uint8_t *)&un, len);

  NS_LOG_INFO ("Encoded Unix socket as \"" << path << "\"");

  //

  // Fork and exec the process to create our socket.  If we're us (the parent)

  // we wait for the child (the socket creator) to complete and read the 

  // socket it created using the ancillary data mechanism.

  //

  pid_t pid = ::fork ();

  if (pid == 0)

    {

      NS_LOG_DEBUG ("Child process");

      //

      // build a command line argument from the encoded endpoint string that 

      // the socket creation process will use to figure out how to respond to

      // the (now) parent process.

      //

      std::ostringstream oss;

      oss << "-p" << path;

      NS_LOG_INFO ("Parameters set to \"" << oss.str () << "\"");

      //

      // Execute the socket creation process image.

      //

      status = ::execl (FindCreator ("emu-sock-creator").c_str (), 

                        "emu-sock-creator",                             // argv[0] (filename)

                        oss.str ().c_str (),                            // argv[1] (-p<path?

                        (char *)NULL);

      //

      // If the execl successfully completes, it never returns.  If it returns it failed or the OS is

      // broken.  In either case, we bail.

      //

      NS_FATAL_ERROR ("EmuNetDevice::CreateSocket(): Back from execl(), errno = " << ::strerror (errno));

    }

  else

    {

      NS_LOG_DEBUG ("Parent process");

      //

      // We're the process running the emu net device.  We need to wait for the

      // socket creator process to finish its job.

      //

      int st;

      pid_t waited = waitpid (pid, &st, 0);

      if (waited == -1)

	{

	  NS_FATAL_ERROR ("EmuNetDevice::CreateSocket(): waitpid() fails, errno = " << strerror (errno));

	}

      NS_ASSERT_MSG (pid == waited, "EmuNetDevice::CreateSocket(): pid mismatch");

      //

      // Check to see if the socket creator exited normally and then take a 

      // look at the exit code.  If it bailed, so should we.  If it didn't

      // even exit normally, we bail too.

      //

      if (WIFEXITED (st))

	{

          int exitStatus = WEXITSTATUS (st);

          if (exitStatus != 0)

            {

              NS_FATAL_ERROR ("EmuNetDevice::CreateSocket(): socket creator exited normally with status " << exitStatus);

            }

	}

      else 

	{

          NS_FATAL_ERROR ("EmuNetDevice::CreateSocket(): socket creator exited abnormally");

	}

      //

      // At this point, the socket creator has run successfully and should 

      // have created our raw socket and sent it back to the socket address

      // we provided.  Our socket should be waiting on the Unix socket.  We've

      // got to do a bunch of grunto work to get at it, though.

      //

      // The struct iovec below is part of a scatter-gather list.  It describes a

      // buffer.  In this case, it describes a buffer (an integer) that will

      // get the data that comes back from the socket creator process.  It will

      // be a magic number that we use as a consistency/sanity check.

      // 

      struct iovec iov;

      uint32_t magic;

      iov.iov_base = &magic;

      iov.iov_len = sizeof(magic);

      //

      // The CMSG macros you'll see below are used to create and access control 

      // messages (which is another name for ancillary data).  The ancillary 

      // data is made up of pairs of struct cmsghdr structures and associated

      // data arrays.

      //

      // First, we're going to allocate a buffer on the stack to receive our 

      // data array (that contains the socket).  Sometimes you'll see this called

      // an "ancillary element" but the msghdr uses the control message termimology

      // so we call it "control."

      //

      size_t msg_size = sizeof(int);

      char control[CMSG_SPACE(msg_size)];

      //

      // There is a msghdr that is used to minimize the number of parameters

      // passed to recvmsg (which we will use to receive our ancillary data).  

      // This structure uses terminology corresponding to control messages, so

      // you'll see msg_control, which is the pointer to the ancillary data and 

      // controllen which is the size of the ancillary data array.

      //

      // So, initialize the message header that describes the ancillary/control

      // data we expect to receive and point it to buffer.

      //

      struct msghdr msg;

      msg.msg_name = 0;

      msg.msg_namelen = 0;

      msg.msg_iov = &iov;

      msg.msg_iovlen = 1;

      msg.msg_control = control;

      msg.msg_controllen = sizeof (control);

      msg.msg_flags = 0;

      //

      // Now we can actually receive the interesting bits from the socket

      // creator process.

      //