Attachment #749 for bug #748

View | Details | Raw Unified | Return to bug 748
Collapse All | Expand All




}

void 
Ipv4EndPoint::SetRxCallback (Callback<void,Ptr<Packet>, Ipv4Address, Ipv4Address, uint16_t> callback)
{
  m_rxCallback = callback;
}

}

void 
Ipv4EndPoint::ForwardUp (Ptr<Packet> p, Ipv4Address saddr, Ipv4Address daddr, uint16_t sport)
{
  if (!m_rxCallback.IsNull ())
    {
      Simulator::ScheduleNow (&Ipv4EndPoint::DoForwardUp, this, p, saddr, daddr, sport);
    }
}
void 
Ipv4EndPoint::DoForwardUp (Ptr<Packet> p, Ipv4Address saddr, Ipv4Address daddr, uint16_t sport)
{
  m_rxCallback (p, saddr, daddr, sport);
}

void 




  Ptr<NetDevice> GetBoundNetDevice (void);

  // Called from socket implementations to get notified about important events.
  void SetRxCallback (Callback<void,Ptr<Packet>, Ipv4Address, Ipv4Address, uint16_t> callback);
  void SetIcmpCallback (Callback<void,Ipv4Address,uint8_t,uint8_t,uint8_t,uint32_t> callback);
  void SetDestroyCallback (Callback<void> callback);

  // Called from an L4Protocol implementation to notify an endpoint of a
  // packet reception.
  void ForwardUp (Ptr<Packet> p, Ipv4Address saddr, Ipv4Address daddr, uint16_t sport);
  // Called from an L4Protocol implementation to notify an endpoint of
  // an icmp message reception.
  void ForwardIcmp (Ipv4Address icmpSource, uint8_t icmpTtl, 

                    uint32_t icmpInfo);

private:
  void DoForwardUp (Ptr<Packet> p, Ipv4Address saddr, Ipv4Address daddr, uint16_t sport);
  void DoForwardIcmp (Ipv4Address icmpSource, uint8_t icmpTtl, 
                      uint8_t icmpType, uint8_t icmpCode,
                      uint32_t icmpInfo);

  Ipv4Address m_peerAddr;
  uint16_t m_peerPort;
  Ptr<NetDevice> m_boundnetdevice;
  Callback<void,Ptr<Packet>, Ipv4Address, Ipv4Address, uint16_t> m_rxCallback;
  Callback<void,Ipv4Address,uint8_t,uint8_t,uint8_t,uint32_t> m_icmpCallback;
  Callback<void> m_destroyCallback;
};

(-)a/src/internet-stack/nsc-tcp-l4-protocol.cc (-1 / +1 lines)

Lines 382-388	Link Here

382

  for (Ipv4EndPointDemux::EndPointsI endPoint = endPoints.begin ();

382

  for (Ipv4EndPointDemux::EndPointsI endPoint = endPoints.begin ();

383

       endPoint != endPoints.end (); endPoint++) {

383

       endPoint != endPoints.end (); endPoint++) {

384

          // NSC HACK: (ab)use TcpSocket::ForwardUp for signalling

384

          // NSC HACK: (ab)use TcpSocket::ForwardUp for signalling

385

          (*endPoint)->ForwardUp (NULL, Ipv4Address(), 0);

385

          (*endPoint)->ForwardUp (NULL, Ipv4Address(), Ipv4Address(), 0);

386

387

388

(-)a/src/internet-stack/nsc-tcp-socket-impl.cc (-1 / +1 lines)

Lines 465-471	Link Here

465

466

467

void

467

void

468

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

468

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

469

470

  NSCWakeup();

470

  NSCWakeup();

471

(-)a/src/internet-stack/nsc-tcp-socket-impl.h (-1 / +1 lines)

Lines 88-94	Link Here

  friend class Tcp;

  friend class Tcp;

  // invoked by Tcp class

  // invoked by Tcp class

  int FinishBind (void);

  int FinishBind (void);

  void ForwardUp (Ptr<Packet> p, Ipv4Address ipv4, uint16_t port);

  void ForwardUp (Ptr<Packet> p, Ipv4Address saddr, Ipv4Address daddr, uint16_t port);

  void Destroy (void);

  void Destroy (void);

  //methods for state

  //methods for state

  bool SendPendingData(void);

  bool SendPendingData(void);

(-)a/src/internet-stack/tcp-l4-protocol.cc (-1 / +1 lines)

Lines 546-552	Link Here

546

547

  NS_ASSERT_MSG (endPoints.size() == 1 , "Demux returned more than one endpoint");

547

  NS_ASSERT_MSG (endPoints.size() == 1 , "Demux returned more than one endpoint");

548

  NS_LOG_LOGIC ("TcpL4Protocol "<<this<<" forwarding up to endpoint/socket");

548

  NS_LOG_LOGIC ("TcpL4Protocol "<<this<<" forwarding up to endpoint/socket");

549

  (*endPoints.begin ())->ForwardUp (packet, source, tcpHeader.GetSourcePort ());

549

  (*endPoints.begin ())->ForwardUp (packet, source, destination, tcpHeader.GetSourcePort ());

550

  return Ipv4L4Protocol::RX_OK;

550

  return Ipv4L4Protocol::RX_OK;

551

552




    m_endPoint (0),
    m_node (0),
    m_tcp (0),
    m_localAddress (Ipv4Address::GetZero ()),
    m_localPort (0),
    m_errno (ERROR_NOTERROR),
    m_shutdownSend (false),
    m_shutdownRecv (false),

    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_errno (sock.m_errno),
    m_shutdownSend (sock.m_shutdownSend),
    m_shutdownRecv (sock.m_shutdownRecv),

    }
  m_endPoint->SetRxCallback (MakeCallback (&TcpSocketImpl::ForwardUp, Ptr<TcpSocketImpl>(this)));
  m_endPoint->SetDestroyCallback (MakeCallback (&TcpSocketImpl::Destroy, Ptr<TcpSocketImpl>(this)));
  m_localAddress = m_endPoint->GetLocalAddress ();
  m_localPort = m_endPoint->GetLocalPort ();
  return 0;
}


      NS_ASSERT (m_endPoint != 0);
    }
  InetSocketAddress transport = InetSocketAddress::ConvertFrom (address);
  m_endPoint->SetPeer(transport.GetIpv4 (), transport.GetPort ());
  m_remotePort = transport.GetPort ();
  
  if (ipv4->GetRoutingProtocol () != 0)
    {
      Ipv4Header header;
      header.SetDestination (m_endPoint->GetPeerAddress());
      Socket::SocketErrno errno_;
      Ptr<Ipv4Route> route;
      Ptr<NetDevice> oif = m_boundnetdevice; //specify non-zero if bound to a source address

        }
      else
        {
          NS_LOG_LOGIC ("TcpSocketImpl::Connect():  Route to " << m_endPoint->GetPeerAddress() << " does not exist");
          NS_LOG_ERROR (errno_);
          m_errno = errno_;
          return -1;

    }
  }
  SocketAddressTag tag;
  tag.SetAddress (InetSocketAddress (m_endPoint->GetPeerAddress(), m_endPoint->GetPeerPort()));
  outPacket->AddPacketTag (tag);
  return outPacket;
}

TcpSocketImpl::GetSockName (Address &address) const
{
  NS_LOG_FUNCTION_NOARGS ();
  address = InetSocketAddress(m_endPoint->GetLocalAddress (), 
                              m_endPoint->GetLocalPort ());
  return 0;
}


}

void
TcpSocketImpl::ForwardUp (Ptr<Packet> packet, Ipv4Address saddr, Ipv4Address daddr, uint16_t port)
{
  NS_LOG_DEBUG("Socket " << this << " got forward up" <<
               " dport " << m_endPoint->GetLocalPort() <<

               " sport " << m_endPoint->GetPeerPort() <<
               " saddr " << m_endPoint->GetPeerAddress());

  NS_LOG_FUNCTION (this << packet << saddr << daddr << port);

  Address fromAddress = InetSocketAddress (saddr, port);
  Address toAddress = InetSocketAddress (daddr, m_endPoint->GetLocalPort());

  if (m_shutdownRecv)
    {
      return;


  Events_t event = SimulationSingleton<TcpStateMachine>::Get ()->FlagsEvent (tcpHeader.GetFlags () );
  Actions_t action = ProcessEvent (event); //updates the state
  Address address = InetSocketAddress (ipv4, port);
  NS_LOG_DEBUG("Socket " << this << 
               " processing pkt action, " << action <<
               " current state " << m_state);
  ProcessPacketAction (action, packet, tcpHeader, fromAddress, toAddress);
}

Actions_t TcpSocketImpl::ProcessEvent (Events_t e)

    {
      Simulator::ScheduleNow(&TcpSocketImpl::ConnectionSucceeded, this);
      m_connected = true;
      m_endPoint->SetPeer (m_remoteAddress, m_remotePort);
      NS_LOG_LOGIC ("TcpSocketImpl " << this << " Connected!");
    }
  if (saveState < CLOSING && (m_state == CLOSING || m_state == TIMED_WAIT) )

  header.SetSequenceNumber (m_nextTxSequence);
  header.SetAckNumber (m_nextRxSequence);
  header.SetSourcePort (m_endPoint->GetLocalPort ());
  header.SetDestinationPort (m_endPoint->GetPeerPort ());
  header.SetWindowSize (AdvertisedWindowSize());
  m_tcp->SendPacket (p, header, m_endPoint->GetLocalAddress (), 
    m_endPoint->GetPeerAddress (), m_boundnetdevice);
  Time rto = m_rtt->RetransmitTimeout ();
  bool hasSyn = flags & TcpHeader::SYN;
  bool hasFin = flags & TcpHeader::FIN;


bool TcpSocketImpl::ProcessPacketAction (Actions_t a, Ptr<Packet> p,
                                     const TcpHeader& tcpHeader,
                                     const Address& fromAddress,
                                     const Address& toAddress)
{
  NS_LOG_FUNCTION (this << a << p  << fromAddress);
  Ptr<Ipv4> ipv4 = m_node->GetObject<Ipv4> ();

          NS_LOG_LOGIC ("Cloned a TcpSocketImpl " << newSock);
          //this listening socket should do nothing more
          Simulator::ScheduleNow (&TcpSocketImpl::CompleteFork, newSock,
                                  p, tcpHeader, fromAddress, toAddress);
          return true;
        }
      else
        {
          // This is the cloned endpoint
          // TCP SYN consumes one byte
          m_nextRxSequence = tcpHeader.GetSequenceNumber () 
                             + SequenceNumber (1);
          SendEmptyPacket (TcpHeader::SYN | TcpHeader::ACK);
        }

        // Look up the source address
        if (ipv4->GetRoutingProtocol () != 0)
          {
            Ipv4Header header;
            Socket::SocketErrno errno_;
            Ptr<Ipv4Route> route;
            Ptr<NetDevice> oif = m_boundnetdevice; //specify non-zero if bound to a source address
            header.SetDestination (m_remoteAddress);
            route = ipv4->GetRoutingProtocol ()->RouteOutput (Ptr<Packet> (), header, oif, errno_);
            if (route != 0)
              {
                NS_LOG_LOGIC ("Route exists");
                m_endPoint->SetLocalAddress (route->GetSource ());
              }
            else
              {
                NS_LOG_ERROR (errno_);
                m_errno = errno_;
                return -1;
              }
          }
        else
          {
            NS_FATAL_ERROR ("No Ipv4RoutingProtocol in the node");
          }
        // TCP SYN consumes one byte
        m_nextRxSequence = tcpHeader.GetSequenceNumber() + SequenceNumber(1);
        SendEmptyPacket (TcpHeader::SYN | TcpHeader::ACK);
      break;
    case ACK_TX_1:
      NS_LOG_LOGIC ("TcpSocketImpl " << this <<" Action ACK_TX_1");

                                 NEW_SEQ_RX,
                                 p,
                                 tcpHeader,
                                 fromAddress,
                                 toAddress);
        }
      if (tcpHeader.GetAckNumber () < m_highestRxAck) //old ack, do nothing
      {

      break;
    case NEW_SEQ_RX:
      NS_LOG_LOGIC ("TcpSocketImpl " << this <<" Action NEW_SEQ_RX");
      NewRx (p, tcpHeader, fromAddress, toAddress); // Process new data received
      break;
    case PEER_CLOSE:
    {

          NS_LOG_LOGIC ("TcpSocketImpl " << this << " setting pendingClose" 
            << " rxseq " << tcpHeader.GetSequenceNumber () 
            << " nextRxSeq " << m_nextRxSequence);
          NewRx (p, tcpHeader, fromAddress, toAddress);
          return true;
        }
      // Now we need to see if any data came with the FIN
      // if so, call NewRx
      if (p->GetSize () != 0)
        {
          NewRx (p, tcpHeader, fromAddress, toAddress);
        }
      ++m_nextRxSequence; //bump this to account for the FIN
      States_t saveState = m_state; // Used to see if app responds

      NS_LOG_LOGIC ("TcpSocketImpl " << this <<" Action SERV_NOTIFY");
      NS_LOG_LOGIC ("TcpSocketImpl " << this << " Connected!");
      m_connected = true; // ! This is bogus; fix when we clone the tcp
      m_endPoint->SetPeer (m_endPoint->GetPeerAddress(), m_endPoint->GetPeerPort());
      //treat the connection orientation final ack as a newack
      CommonNewAck (tcpHeader.GetAckNumber (), true);
      NotifyNewConnectionCreated (this, fromAddress);

  return true;
}

void TcpSocketImpl::CompleteFork(Ptr<Packet> p, const TcpHeader& h, const Address& fromAddress, const Address& toAddress)
{
  // Get port and address from peer (connecting host)
  m_endPoint = m_tcp->Allocate (InetSocketAddress::ConvertFrom(toAddress).GetIpv4 (),
                                InetSocketAddress::ConvertFrom(toAddress).GetPort (),
                                InetSocketAddress::ConvertFrom (fromAddress).GetIpv4 (),
                                InetSocketAddress::ConvertFrom (fromAddress).GetPort ());
                                m_remoteAddress,
                                m_remotePort);
  //the cloned socket with be in listen state, so manually change state
  m_state = SYN_RCVD;
  //equivalent to FinishBind
  m_endPoint->SetRxCallback (MakeCallback (&TcpSocketImpl::ForwardUp, Ptr<TcpSocketImpl>(this)));
  m_endPoint->SetDestroyCallback (MakeCallback (&TcpSocketImpl::Destroy, Ptr<TcpSocketImpl>(this)));
  ProcessPacketAction(SYN_ACK_TX, p, h, fromAddress, toAddress);
 }

void TcpSocketImpl::ConnectionSucceeded()

      header.SetSequenceNumber (m_nextTxSequence);
      header.SetAckNumber (m_nextRxSequence);
      header.SetSourcePort (m_endPoint->GetLocalPort());
      header.SetDestinationPort (m_endPoint->GetPeerPort());
      header.SetWindowSize (AdvertisedWindowSize());
      if (m_shutdownSend)
        {

      NS_LOG_LOGIC ("About to send a packet with flags: " << flags);
      m_tcp->SendPacket (p, header,
                         m_endPoint->GetLocalAddress (),
                         m_endPoint->GetPeerAddress (), 
                         m_boundnetdevice);
      m_rtt->SentSeq(m_nextTxSequence, sz);       // notify the RTT
      // Notify the application of the data being sent
      Simulator::ScheduleNow(&TcpSocketImpl::NotifyDataSent, this, sz);


void TcpSocketImpl::NewRx (Ptr<Packet> p,
                        const TcpHeader& tcpHeader, 
                        const Address& fromAddress,
                        const Address& toAddress)
{
  NS_LOG_FUNCTION (this << p << "tcpHeader " << fromAddress);
  NS_LOG_LOGIC ("TcpSocketImpl " << this << " NewRx,"

        { // See if we can close now
          if (m_bufferedData.empty())
            {
              ProcessPacketAction (PEER_CLOSE, p, tcpHeader, fromAddress, toAddress);
            }
        }
    }

  tcpHeader.SetSequenceNumber (m_nextTxSequence);
  tcpHeader.SetAckNumber (m_nextRxSequence);
  tcpHeader.SetSourcePort (m_endPoint->GetLocalPort());
  tcpHeader.SetDestinationPort (m_endPoint->GetPeerPort ());
  tcpHeader.SetWindowSize (AdvertisedWindowSize());

  m_tcp->SendPacket (p, tcpHeader, m_endPoint->GetLocalAddress (),
    m_endPoint->GetPeerAddress (), m_boundnetdevice);
  NS_LOG_LOGIC ("Schedule persist timeout at time " 
                    <<Simulator::Now ().GetSeconds () << " to expire at time "
                    << (Simulator::Now () + m_persistTime).GetSeconds());

  tcpHeader.SetSequenceNumber (m_nextTxSequence);
  tcpHeader.SetAckNumber (m_nextRxSequence);
  tcpHeader.SetSourcePort (m_endPoint->GetLocalPort());
  tcpHeader.SetDestinationPort (m_endPoint->GetPeerPort ());
  tcpHeader.SetFlags (flags);
  tcpHeader.SetWindowSize (AdvertisedWindowSize());

  m_tcp->SendPacket (p, tcpHeader, m_endPoint->GetLocalAddress (),
    m_endPoint->GetPeerAddress (), m_boundnetdevice);
}

void




  friend class Tcp;
  // invoked by Tcp class
  int FinishBind (void);
  void ForwardUp (Ptr<Packet> p, Ipv4Address saddr, Ipv4Address daddr, uint16_t port);
  void Destroy (void);
  int DoSendTo (Ptr<Packet> p, const Address &daddr);
  int DoSendTo (Ptr<Packet> p, Ipv4Address daddr, uint16_t dport);

                      Ipv4Address saddr, Ipv4Address daddr);
  bool ProcessPacketAction (Actions_t a, Ptr<Packet> p,
                                       const TcpHeader& tcpHeader,
                                       const Address& fromAddress,
                                       const Address& toAddress);
  Actions_t ProcessEvent (Events_t e);
  bool SendPendingData(bool withAck = false);
  void CompleteFork(Ptr<Packet>, const TcpHeader&, const Address& fromAddress, const Address& toAddress);
  void ConnectionSucceeded();
  
  //methods for window management

  uint16_t AdvertisedWindowSize();

  // Manage data tx/rx
  void NewRx (Ptr<Packet>, const TcpHeader&, const Address& fromAddress, const Address& toAddress);
  void RxBufFinishInsert (SequenceNumber);
  Ptr<TcpSocketImpl> Copy ();
  virtual void NewAck (SequenceNumber seq); 

  Ipv4EndPoint *m_endPoint;
  Ptr<Node> m_node;
  Ptr<TcpL4Protocol> m_tcp;

  uint16_t m_remotePort;
  //these two are so that the socket/endpoint cloning works
  Ipv4Address m_localAddress;
  uint16_t m_localPort;
  enum SocketErrno m_errno;
  bool m_shutdownSend;
  bool m_shutdownRecv;

(-)a/src/internet-stack/udp-l4-protocol.cc (-1 / +1 lines)

Lines 230-236	Link Here

230

  for (Ipv4EndPointDemux::EndPointsI endPoint = endPoints.begin ();

230

  for (Ipv4EndPointDemux::EndPointsI endPoint = endPoints.begin ();

231

       endPoint != endPoints.end (); endPoint++)

231

       endPoint != endPoints.end (); endPoint++)

232

233

      (*endPoint)->ForwardUp (packet->Copy (), source, udpHeader.GetSourcePort ());

233

      (*endPoint)->ForwardUp (packet->Copy (), source, destination, udpHeader.GetSourcePort ());

234

235

  return Ipv4L4Protocol::RX_OK;

235

  return Ipv4L4Protocol::RX_OK;

236




}

void 
UdpSocketImpl::ForwardUp (Ptr<Packet> packet, Ipv4Address saddr, Ipv4Address daddr, uint16_t port)
{
  NS_LOG_FUNCTION (this << packet << saddr << daddr << port);

  if (m_shutdownRecv)
    {

    }
  if ((m_rxAvailable + packet->GetSize ()) <= m_rcvBufSize)
    {
      Address address = InetSocketAddress (saddr, port);
      SocketAddressTag tag;
      tag.SetAddress (address);
      packet->AddPacketTag (tag);

(-)a/src/internet-stack/udp-socket-impl.h (-1 / +1 lines)

Lines 98-104	Link Here

  friend class UdpSocketFactory;

  friend class UdpSocketFactory;

  // invoked by Udp class

  // invoked by Udp class

100

  int FinishBind (void);

100

  int FinishBind (void);

101

  void ForwardUp (Ptr<Packet> p, Ipv4Address ipv4, uint16_t port);

101

  void ForwardUp (Ptr<Packet> p, Ipv4Address saddr, Ipv4Address daddr, uint16_t port);

102

  void Destroy (void);

102

  void Destroy (void);

103

  int DoSend (Ptr<Packet> p);

103

  int DoSend (Ptr<Packet> p);

104

  int DoSendTo (Ptr<Packet> p, const Address &daddr);

104

  int DoSendTo (Ptr<Packet> p, const Address &daddr);

Return to bug 748