/* -*-  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

 *

 * based on tcp-socket-impl.cc, Author: Raj Bhattacharjea <raj.b@gatech.edu>

 * Author: Florian Westphal <fw@strlen.de>

 */

#include "ns3/node.h"

#include "ns3/inet-socket-address.h"

#include "ns3/log.h"

#include "ns3/ipv4.h"

#include "ipv4-end-point.h"

#include "nsc-tcp-l4-protocol.h"

#include "nsc-tcp-socket-impl.h"

#include "ns3/simulation-singleton.h"

#include "tcp-typedefs.h"

#include "ns3/simulator.h"

#include "ns3/packet.h"

#include "ns3/uinteger.h"

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

#include <algorithm>

// for ntohs().

#include <arpa/inet.h>

#include <netinet/in.h>

#include "sim_interface.h"

#include "sim_errno.h"

NS_LOG_COMPONENT_DEFINE ("NscTcpSocketImpl");

using namespace std;

namespace ns3 {

NS_OBJECT_ENSURE_REGISTERED (NscTcpSocketImpl);

TypeId

NscTcpSocketImpl::GetTypeId ()

{

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

    .SetParent<TcpSocket> ()

    .AddTraceSource ("CongestionWindow",

                     "The TCP connection's congestion window",

                     MakeTraceSourceAccessor (&NscTcpSocketImpl::m_cWnd))

    ;

  return tid;

}

  NscTcpSocketImpl::NscTcpSocketImpl ()

  : m_endPoint (0),

    m_node (0),

    m_tcp (0),

    m_localAddress (Ipv4Address::GetZero ()),

    m_localPort (0),

    m_peerAddress ("0.0.0.0", 0),

    m_errno (ERROR_NOTERROR),

    m_shutdownSend (false),

    m_shutdownRecv (false),

    m_connected (false),

    m_state (CLOSED),

    m_closeOnEmpty (false),

    m_txBufferSize (0),

    m_rtt (0),

    m_lastMeasuredRtt (Seconds(0.0))

{

  NS_LOG_FUNCTION (this);

}

NscTcpSocketImpl::NscTcpSocketImpl(const NscTcpSocketImpl& sock)

  : TcpSocket(sock), //copy the base class callbacks

    m_delAckMaxCount (sock.m_delAckMaxCount),

    m_delAckTimeout (sock.m_delAckTimeout),

    m_endPoint (0),

    m_node (sock.m_node),

    m_tcp (sock.m_tcp),

    m_remoteAddress (sock.m_remoteAddress),

    m_remotePort (sock.m_remotePort),

    m_localAddress (sock.m_localAddress),

    m_localPort (sock.m_localPort),

    m_peerAddress (sock.m_peerAddress),

    m_errno (sock.m_errno),

    m_shutdownSend (sock.m_shutdownSend),

    m_shutdownRecv (sock.m_shutdownRecv),

    m_connected (sock.m_connected),

    m_state (sock.m_state),

    m_closeOnEmpty (sock.m_closeOnEmpty),

    m_segmentSize (sock.m_segmentSize),

    m_rxWindowSize (sock.m_rxWindowSize),

    m_advertisedWindowSize (sock.m_advertisedWindowSize),

    m_cWnd (sock.m_cWnd),

    m_ssThresh (sock.m_ssThresh),

    m_initialCWnd (sock.m_initialCWnd),

    m_rtt (0),

    m_lastMeasuredRtt (Seconds(0.0)),

    m_cnTimeout (sock.m_cnTimeout),

    m_cnCount (sock.m_cnCount),

    m_rxAvailable (0),

    m_nscTcpSocket (0),

    m_sndBufSize (sock.m_sndBufSize)

{

  NS_LOG_FUNCTION_NOARGS ();

  NS_LOG_LOGIC("Invoked the copy constructor");

  //copy the pending data if necessary

  if(!sock.m_txBuffer.empty () )

    {

      m_txBuffer = sock.m_txBuffer;

    }

  //copy the rtt if necessary

  if (sock.m_rtt)

    {

      m_rtt = sock.m_rtt->Copy();

    }

  //can't "copy" the endpoint just yes, must do this when we know the peer info

  //too; this is in SYN_ACK_TX

}

NscTcpSocketImpl::~NscTcpSocketImpl ()

{

  NS_LOG_FUNCTION(this);

  m_node = 0;

  if (m_endPoint != 0)

    {

      NS_ASSERT (m_tcp != 0);

      /**

       * Note that this piece of code is a bit tricky:

       * when DeAllocate is called, it will call into

       * Ipv4EndPointDemux::Deallocate which triggers

       * a delete of the associated endPoint which triggers

       * in turn a call to the method ::Destroy below

       * will will zero the m_endPoint field.

       */

      NS_ASSERT (m_endPoint != 0);

      m_tcp->DeAllocate (m_endPoint);

      NS_ASSERT (m_endPoint == 0);

    }

  m_tcp = 0;

}

void

NscTcpSocketImpl::SetNode (Ptr<Node> node)

{

  m_node = node;

  // Initialize some variables 

  m_cWnd = m_initialCWnd * m_segmentSize;

  m_rxWindowSize = m_advertisedWindowSize;

}

void 

NscTcpSocketImpl::SetTcp (Ptr<NscTcpL4Protocol> tcp)

{

  m_tcp = tcp;

  m_nscTcpSocket = m_node->GetNscInetStack()->new_tcp_socket();

}

void

NscTcpSocketImpl::SetRtt (Ptr<RttEstimator> rtt)

{

  m_rtt = rtt;

}

enum Socket::SocketErrno

NscTcpSocketImpl::GetErrno (void) const

{

  NS_LOG_FUNCTION_NOARGS ();

  return m_errno;

}

Ptr<Node>

NscTcpSocketImpl::GetNode (void) const

{

  NS_LOG_FUNCTION_NOARGS ();

  return m_node;

}

void 

NscTcpSocketImpl::Destroy (void)

{

  NS_LOG_FUNCTION_NOARGS ();

  m_node = 0;

  m_endPoint = 0;

  m_tcp = 0;

}

int

NscTcpSocketImpl::FinishBind (void)

{

  NS_LOG_FUNCTION_NOARGS ();

  if (m_endPoint == 0)

    {

      return -1;

    }

  m_endPoint->SetRxCallback (MakeCallback (&NscTcpSocketImpl::ForwardUp, Ptr<NscTcpSocketImpl>(this)));

  m_endPoint->SetDestroyCallback (MakeCallback (&NscTcpSocketImpl::Destroy, Ptr<NscTcpSocketImpl>(this)));

  m_localAddress = m_endPoint->GetLocalAddress ();

  m_localPort = m_endPoint->GetLocalPort ();

  return 0;

}

int

NscTcpSocketImpl::Bind (void)

{

  NS_LOG_FUNCTION_NOARGS ();

  m_endPoint = m_tcp->Allocate ();

  return FinishBind ();

}

int 

NscTcpSocketImpl::Bind (const Address &address)

{

  NS_LOG_FUNCTION (this<<address);

  if (!InetSocketAddress::IsMatchingType (address))

    {

      return ERROR_INVAL;

    }

  InetSocketAddress transport = InetSocketAddress::ConvertFrom (address);

  Ipv4Address ipv4 = transport.GetIpv4 ();

  uint16_t port = transport.GetPort ();

  if (ipv4 == Ipv4Address::GetAny () && port == 0)

    {

      m_endPoint = m_tcp->Allocate ();

      NS_LOG_LOGIC ("TcpSocketImpl "<<this<<" got an endpoint: "<<m_endPoint);

    }

  else if (ipv4 == Ipv4Address::GetAny () && port != 0)

    {

      m_endPoint = m_tcp->Allocate (port);

      NS_LOG_LOGIC ("TcpSocketImpl "<<this<<" got an endpoint: "<<m_endPoint);

    }

  else if (ipv4 != Ipv4Address::GetAny () && port == 0)

    {

      m_endPoint = m_tcp->Allocate (ipv4);

      NS_LOG_LOGIC ("TcpSocketImpl "<<this<<" got an endpoint: "<<m_endPoint);

    }

  else if (ipv4 != Ipv4Address::GetAny () && port != 0)

    {

      m_endPoint = m_tcp->Allocate (ipv4, port);

      NS_LOG_LOGIC ("TcpSocketImpl "<<this<<" got an endpoint: "<<m_endPoint);

    }

  m_localPort = port;

  return FinishBind ();

}

int 

NscTcpSocketImpl::ShutdownSend (void)

{

  NS_LOG_FUNCTION_NOARGS ();

  m_shutdownSend = true;

  return 0;

}

int 

NscTcpSocketImpl::ShutdownRecv (void)

{

  NS_LOG_FUNCTION_NOARGS ();

  m_shutdownRecv = true;

  return 0;

}

int

NscTcpSocketImpl::Close (void)

{

  NS_LOG_FUNCTION (this << m_state);

  if (m_state == CLOSED)

    {

      return -1;

    }

  if (!m_txBuffer.empty ())

    { // App close with pending data must wait until all data transmitted

      m_closeOnEmpty = true;

      NS_LOG_LOGIC("Socket " << this << 

                   " deferring close, state " << m_state);

      return 0;

    }

  m_nscTcpSocket->disconnect();

  m_state = CLOSED;

  ShutdownSend ();

  return 0;

}

int

NscTcpSocketImpl::Connect (const Address & address)

{

  NS_LOG_FUNCTION (this << address);

  if (m_endPoint == 0)

    {

      if (Bind () == -1)

        {

          NS_ASSERT (m_endPoint == 0);

          return -1;

        }

      NS_ASSERT (m_endPoint != 0);

    }

  InetSocketAddress transport = InetSocketAddress::ConvertFrom (address);

  m_remoteAddress = transport.GetIpv4 ();

  m_remotePort = transport.GetPort ();

  std::ostringstream ss;

  m_remoteAddress.Print(ss);

  std::string ipstring = ss.str ();

  m_nscTcpSocket->connect(ipstring.c_str (), m_remotePort);

  m_state = SYN_SENT;

  return 0;

}

int

NscTcpSocketImpl::Send (const Ptr<Packet> p, uint32_t flags)

{

  NS_LOG_FUNCTION (this << p);

  NS_ASSERT (p->GetSize () > 0);

  if (m_state == ESTABLISHED || m_state == SYN_SENT || m_state == CLOSE_WAIT)

  {

    if (p->GetSize () > GetTxAvailable ())

    {

      m_errno = ERROR_MSGSIZE;

      return -1;

    }

    uint32_t sent = p->GetSize ();

    if (m_state == ESTABLISHED)

      {

        m_txBuffer.push(p);

        m_txBufferSize += sent;

        SendPendingData();

      }

      else

      {  // SYN_SET -- Queue Data

         m_txBuffer.push(p);

         m_txBufferSize += sent;

      }

    return sent;

  }

  else

  {

    m_errno = ERROR_NOTCONN;

    return -1;

  }

}

int

NscTcpSocketImpl::SendTo (Ptr<Packet> p, uint32_t flags, const Address &address)

{

  NS_LOG_FUNCTION (this << address << p);

  if (!m_connected)

    {

      m_errno = ERROR_NOTCONN;

      return -1;

    }

  else

    {

      return Send (p, flags); //drop the address according to BSD manpages

    }

}

uint32_t

NscTcpSocketImpl::GetTxAvailable (void) const

{

  NS_LOG_FUNCTION_NOARGS ();

  if (m_txBufferSize != 0)

    {

      NS_ASSERT (m_txBufferSize <= m_sndBufSize);

      return m_sndBufSize - m_txBufferSize;

    }

  else

    {

      return m_sndBufSize;

    }

}

int

NscTcpSocketImpl::Listen (void)

{

  NS_LOG_FUNCTION (this);

  m_nscTcpSocket->listen(m_localPort);

  m_state = LISTEN;

  return 0;

}

void

NscTcpSocketImpl::NSCWakeup ()

{

  switch (m_state) {

  case SYN_SENT:

      if (!m_nscTcpSocket->is_connected())

          break;

      m_state = ESTABLISHED;

      Simulator::ScheduleNow(&NscTcpSocketImpl::ConnectionSucceeded, this);

      // fall through to schedule read/write events

  case ESTABLISHED:

      if (!m_txBuffer.empty ())

          Simulator::ScheduleNow(&NscTcpSocketImpl::SendPendingData, this);

      Simulator::ScheduleNow(&NscTcpSocketImpl::ReadPendingData, this);

      break;

  case LISTEN:

      Simulator::ScheduleNow(&NscTcpSocketImpl::Accept, this);

      break;

  case CLOSED: break;

  default:

      NS_LOG_DEBUG (this << " invalid state: " << m_state);

  }

}

Ptr<Packet>

NscTcpSocketImpl::Recv (uint32_t maxSize, uint32_t flags)

{

  NS_LOG_FUNCTION_NOARGS ();

  if (m_deliveryQueue.empty() )

    {

      m_errno = ERROR_AGAIN;

      return 0;

    }

  Ptr<Packet> p = m_deliveryQueue.front ();

  if (p->GetSize () <= maxSize)

    {

      m_deliveryQueue.pop ();

      m_rxAvailable -= p->GetSize ();

    }

  else

    {

      m_errno = ERROR_AGAIN;

      p = 0;

    }

  return p;

}

Ptr<Packet>

NscTcpSocketImpl::RecvFrom (uint32_t maxSize, uint32_t flags,

  Address &fromAddress)

{

  NS_LOG_FUNCTION (this << maxSize << flags);

  Ptr<Packet> packet = Recv (maxSize, flags);

  if (packet != 0)

    {

      SocketAddressTag tag;

      bool found;

      found = packet->PeekPacketTag (tag);

      NS_ASSERT (found);

      fromAddress = tag.GetAddress ();

    }

  return packet;

}

int

NscTcpSocketImpl::GetSockName (Address &address) const

{

  NS_LOG_FUNCTION_NOARGS ();

  address = InetSocketAddress(m_localAddress, m_localPort);

  return 0;

}

uint32_t

NscTcpSocketImpl::GetRxAvailable (void) const

{

  NS_LOG_FUNCTION_NOARGS ();

  // We separately maintain this state to avoid walking the queue 

  // every time this might be called

  return m_rxAvailable;

}

void

NscTcpSocketImpl::ForwardUp (Ptr<Packet> packet, Ipv4Address ipv4, uint16_t port)

{

  NSCWakeup();

}

void NscTcpSocketImpl::CompleteFork(void)

{

  // The address pairs (m_localAddress, m_localPort, m_remoteAddress, m_remotePort)

  // are bogus, but this isn't important at the moment, because

  // address <-> Socket handling is done by NSC internally.

  // We only need to add the new ns-3 socket to the list of sockets, so

  // we use plain Allocate() instead of Allocate(m_localAddress, ... )

  struct sockaddr_in sin;

  size_t sin_len = sizeof(sin);

  if (0 == m_nscTcpSocket->getpeername((struct sockaddr*) &sin, &sin_len)) {

    m_remotePort = ntohs(sin.sin_port);

    m_remoteAddress = m_remoteAddress.Deserialize((const uint8_t*) &sin.sin_addr);

    m_peerAddress = InetSocketAddress(m_remoteAddress, m_remotePort);

  }

  m_endPoint = m_tcp->Allocate ();

  //the cloned socket with be in listen state, so manually change state

  NS_ASSERT(m_state == LISTEN);

  m_state = ESTABLISHED;

  sin_len = sizeof(sin);

  if (0 == m_nscTcpSocket->getsockname((struct sockaddr *) &sin, &sin_len))

    m_localAddress = m_localAddress.Deserialize((const uint8_t*) &sin.sin_addr);

  NS_LOG_LOGIC ("NscTcpSocketImpl " << this << " accepted connection from " 

                 << m_remoteAddress << ":" << m_remotePort

                 << " to " << m_localAddress << ":" << m_localPort);

  //equivalent to FinishBind

  m_endPoint->SetRxCallback (MakeCallback (&NscTcpSocketImpl::ForwardUp, Ptr<NscTcpSocketImpl>(this)));

  m_endPoint->SetDestroyCallback (MakeCallback (&NscTcpSocketImpl::Destroy, Ptr<NscTcpSocketImpl>(this)));

  NotifyNewConnectionCreated (this, m_peerAddress);

}

void NscTcpSocketImpl::ConnectionSucceeded()

{ // We would preferred to have scheduled an event directly to

  // NotifyConnectionSucceeded, but (sigh) these are protected

  // and we can get the address of it :(

  struct sockaddr_in sin;

  size_t sin_len = sizeof(sin);

  if (0 == m_nscTcpSocket->getsockname((struct sockaddr *) &sin, &sin_len)) {

    m_localAddress = m_localAddress.Deserialize((const uint8_t*)&sin.sin_addr);

    m_localPort = ntohs(sin.sin_port);

  }

  NS_LOG_LOGIC ("NscTcpSocketImpl " << this << " connected to "

                 << m_remoteAddress << ":" << m_remotePort

                 << " from " << m_localAddress << ":" << m_localPort);

  NotifyConnectionSucceeded();

}

bool NscTcpSocketImpl::Accept (void)

{

  if (m_state == CLOSED)

    {  // Happens if application closes listening socket after Accept() was scheduled.

      return false;

    }

  NS_ASSERT (m_state == LISTEN);

  if (!m_nscTcpSocket->is_listening())

    {

      return false;

    }

  INetStreamSocket *newsock;

  int res = m_nscTcpSocket->accept(&newsock);

  if (res != 0)

    {

      return false;

    }

// We could obtain a fromAddress using getpeername, but we've already

// finished the tcp handshake here, i.e. this is a new connection

// and not a connection request.

// if (!NotifyConnectionRequest(fromAddress))

//   return true;

  // Clone the socket

  Ptr<NscTcpSocketImpl> newSock = Copy ();

  newSock->m_nscTcpSocket = newsock;

  NS_LOG_LOGIC ("Cloned a NscTcpSocketImpl " << newSock);

  Simulator::ScheduleNow (&NscTcpSocketImpl::CompleteFork, newSock);

  return true;

}

bool NscTcpSocketImpl::ReadPendingData (void)

{

  if (m_state != ESTABLISHED)

    {

      return false;

    }

  int len, err;

  uint8_t buffer[8192];

  len = sizeof(buffer);

  m_errno = ERROR_NOTERROR;

  err = m_nscTcpSocket->read_data(buffer, &len);

  if (err == 0 && len == 0)

    {

      NS_LOG_LOGIC ("ReadPendingData got EOF from socket");

      m_state = CLOSED;

      return false;

    }

  m_errno = GetNativeNs3Errno(err);

  switch (m_errno)

    {

      case ERROR_NOTERROR: break; // some data was sent

      case ERROR_AGAIN: return false;

      default:

        NS_LOG_WARN ("Error (" << err << ") " <<

                     "during read_data, ns-3 errno set to" << m_errno);

        m_state = CLOSED;

        return false;

    }

  Ptr<Packet> p =  Create<Packet> (buffer, len);

  SocketAddressTag tag;

  tag.SetAddress (m_peerAddress);

  p->AddPacketTag (tag);

  m_deliveryQueue.push (p);

  m_rxAvailable += p->GetSize ();

  NotifyDataRecv ();

  return true;

}

bool NscTcpSocketImpl::SendPendingData (void)

{

  NS_LOG_FUNCTION (this);

  NS_LOG_LOGIC ("ENTERING SendPendingData");

  if (m_txBuffer.empty ())

    {

      return false;

    }

  int ret;

  size_t size, written = 0;

  do {

    NS_ASSERT (!m_txBuffer.empty ());

    Ptr<Packet> &p = m_txBuffer.front ();

    size = p->GetSize ();

    NS_ASSERT (size > 0);

    m_errno = ERROR_NOTERROR;

    ret = m_nscTcpSocket->send_data((const char *)p->PeekData (), size);

    if (ret <= 0)

      {

        break;

      }

    written += ret;

    NS_ASSERT (m_txBufferSize >= (size_t)ret);

    m_txBufferSize -= ret;

    if ((size_t)ret < size)

      {

        p->RemoveAtStart(ret);

        break;

      }

    m_txBuffer.pop ();

    if (m_txBuffer.empty ())

      {

        if (m_closeOnEmpty)

          {

            m_nscTcpSocket->disconnect();

            m_state = CLOSED;

          }

        break;

      }

  } while ((size_t) ret == size);

  if (written > 0)

    {

      Simulator::ScheduleNow(&NscTcpSocketImpl::NotifyDataSent, this, ret);

      return true;

    }

  return false;

}

Ptr<NscTcpSocketImpl> NscTcpSocketImpl::Copy ()

{

  return CopyObject<NscTcpSocketImpl> (this);

}

void

NscTcpSocketImpl::SetSndBufSize (uint32_t size)

{

  m_sndBufSize = size;

}

uint32_t

NscTcpSocketImpl::GetSndBufSize (void) const

{

  return m_sndBufSize;

}

void

NscTcpSocketImpl::SetRcvBufSize (uint32_t size)

{

  m_rcvBufSize = size;

}

uint32_t

NscTcpSocketImpl::GetRcvBufSize (void) const

{

  return m_rcvBufSize;

}

void

NscTcpSocketImpl::SetSegSize (uint32_t size)

{

  m_segmentSize = size;

}

uint32_t

NscTcpSocketImpl::GetSegSize (void) const

{

  return m_segmentSize;

}

void

NscTcpSocketImpl::SetAdvWin (uint32_t window)

{

  m_advertisedWindowSize = window;

}

uint32_t

NscTcpSocketImpl::GetAdvWin (void) const

{

  return m_advertisedWindowSize;

}

void

NscTcpSocketImpl::SetSSThresh (uint32_t threshold)

{

  m_ssThresh = threshold;

}

uint32_t

NscTcpSocketImpl::GetSSThresh (void) const

{

  return m_ssThresh;

}

void

NscTcpSocketImpl::SetInitialCwnd (uint32_t cwnd)

{

  m_initialCWnd = cwnd;

}

uint32_t

NscTcpSocketImpl::GetInitialCwnd (void) const

{

  return m_initialCWnd;

}

void 

NscTcpSocketImpl::SetConnTimeout (Time timeout)

{

  m_cnTimeout = timeout;

}

Time

NscTcpSocketImpl::GetConnTimeout (void) const

{

  return m_cnTimeout;

}

void 

NscTcpSocketImpl::SetConnCount (uint32_t count)

{

  m_cnCount = count;

}

uint32_t 

NscTcpSocketImpl::GetConnCount (void) const

{

  return m_cnCount;

}

void 

NscTcpSocketImpl::SetDelAckTimeout (Time timeout)

{

  m_delAckTimeout = timeout;

}

Time

NscTcpSocketImpl::GetDelAckTimeout (void) const

{

  return m_delAckTimeout;

}

void

NscTcpSocketImpl::SetDelAckMaxCount (uint32_t count)

{

  m_delAckMaxCount = count;

}

uint32_t

NscTcpSocketImpl::GetDelAckMaxCount (void) const

{

  return m_delAckMaxCount;

}

enum Socket::SocketErrno

NscTcpSocketImpl::GetNativeNs3Errno(int error) const

{

  enum nsc_errno err;

  if (error >= 0)

    {

       return ERROR_NOTERROR;

    }

  err = (enum nsc_errno) error;

  switch (err)

    {

      case NSC_EADDRINUSE: // fallthrough

      case NSC_EADDRNOTAVAIL: return ERROR_AFNOSUPPORT;

      case NSC_EINPROGRESS: // Altough nsc sockets are nonblocking, we pretend they're not.

      case NSC_EAGAIN: return ERROR_AGAIN;

      case NSC_EISCONN: // fallthrough

      case NSC_EALREADY: return ERROR_ISCONN;

      case NSC_ECONNREFUSED: return ERROR_NOROUTETOHOST; // XXX, better mapping?

      case NSC_ECONNRESET: // for no, all of these fall through

      case NSC_EHOSTDOWN:

      case NSC_ENETUNREACH:

      case NSC_EHOSTUNREACH: return ERROR_NOROUTETOHOST;

      case NSC_EMSGSIZE: return ERROR_MSGSIZE;

      case NSC_ENOTCONN: return ERROR_NOTCONN;

      case NSC_ESHUTDOWN: return ERROR_SHUTDOWN;

      case NSC_ETIMEDOUT: return ERROR_NOTCONN; // XXX - this mapping isn't correct

      case NSC_ENOTDIR: // used by eg. sysctl(2). Shouldn't happen normally,

                        // but is triggered by e.g. show_config().

      case NSC_EUNKNOWN: return ERROR_INVAL; // Catches stacks that 'return -1' without real mapping

    }

  NS_ASSERT_MSG(0, "Unknown NSC error");

  return ERROR_INVAL;

}

}//namespace ns3