Attachment #1379 for bug #1383

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




std::string
PrintReceivedPacket (Ptr<Socket> socket, Ptr<Packet> packet)
{
  Ptr<const SocketAddressTag> tag = packet->PeekPacketTag<SocketAddressTag> ();
  bool found;
  found = packet->PeekPacketTag (tag);
  std::ostringstream oss;

  oss << Simulator::Now ().GetSeconds () << " " << socket->GetNode ()->GetId ();

  if (tag != 0)
        {
      InetSocketAddress addr = InetSocketAddress::ConvertFrom (tag->GetAddress ());
      oss << " received one packet from " << addr.GetIpv4 ();
        }
      else
        {
      oss << " received one packet!";
        }
  return oss.str ();
    }

void
RoutingExperiment::ReceivePacket (Ptr<Socket> socket)

      bytesTotal += packet->GetSize ();
      packetsReceived += 1;
      NS_LOG_UNCOND (PrintReceivedPacket (socket, packet));
}
}

void




  // Actual route request will be deferred until packet will be fully formed, 
  // routed to loopback, received from loopback and passed to RouteInput (see below)
  uint32_t iif = (oif ? m_ipv4->GetInterfaceForDevice (oif) : -1);
  if (p->PeekPacketTag<DeferredRouteOutputTag> () == 0)
  if (!p->PeekPacketTag (tag))
    {
      Ptr<DeferredRouteOutputTag> tag = CreateObject<DeferredRouteOutputTag> (iif);
      p->AddPacketTag (tag);
    }
  return LoopbackRoute (header, oif);

  // Deferred route request
  if (idev == m_lo)
    {
      if (p->PeekPacketTag<DeferredRouteOutputTag> () != 0)
      if (p->PeekPacketTag (tag))
        {
          DeferredRouteOutput (p, header, ucb, ecb);
          return true;

  QueueEntry queueEntry;
  while (m_queue.Dequeue (dst, queueEntry))
    {
      DeferredRouteOutputTag tag;
      Ptr<Packet> p = ConstCast<Packet> (queueEntry.GetPacket ());
      Ptr<const DeferredRouteOutputTag> tag = p->RemovePacketTag<DeferredRouteOutputTag> ();
      if (tag != 0 && 
          tag->GetInterface() != -1 && 
          tag->GetInterface() != m_ipv4->GetInterfaceForDevice (route->GetOutputDevice ()))
        {
          NS_LOG_DEBUG ("Output device doesn't match. Dropped.");
          return;

(-)a/src/applications/model/radvd.cc (-2 / +2 lines)

Lines 211-218 void Radvd::Send (Ptr<RadvdInterface> config, Ipv6Address dst, bool reschedule)	Link Here

211

  /* Router advertisements MUST always have a ttl of 255

211

  /* Router advertisements MUST always have a ttl of 255

212

   * The ttl value should be set as a socket option, but this is not yet implemented

212

   * The ttl value should be set as a socket option, but this is not yet implemented

213

*/

213

*/

214

  SocketIpTtlTag ttl;

214

  Ptr<SocketIpTtlTag> ttl = CreateObject<SocketIpTtlTag> ();

215

  ttl.SetTtl (255);

215

  ttl->SetTtl (255);

216

  p->AddPacketTag (ttl);

216

  p->AddPacketTag (ttl);

217

218

  /* send RA */

218

  /* send RA */




  if (EnableBuffering)
    {
      uint32_t iif = (oif ? m_ipv4->GetInterfaceForDevice (oif) : -1);
      if (p->PeekPacketTag<DeferredRouteOutputTag> () == 0)
      if (!p->PeekPacketTag (tag))
        {
          p->AddPacketTag (CreateObject<DeferredRouteOutputTag> (iif));
        }
    }
  return LoopbackRoute (header,oif);

  // Deferred route request
  if (EnableBuffering == true && idev == m_lo)
    {
      if (p->PeekPacketTag<DeferredRouteOutputTag> () != 0)
      if (p->PeekPacketTag (tag))
        {
          DeferredRouteOutput (p,header,ucb,ecb);
          return true;

  QueueEntry queueEntry;
  if (m_queue.Dequeue (dst,queueEntry))
    {
      DeferredRouteOutputTag tag;
      Ptr<Packet> p = ConstCast<Packet> (queueEntry.GetPacket ());
      Ptr<const DeferredRouteOutputTag> tag = p->RemovePacketTag<DeferredRouteOutputTag> ();
      if (tag != 0)
        {
          if (tag->oif != -1 && tag->oif != m_ipv4->GetInterfaceForDevice (route->GetOutputDevice ()))
            {
              NS_LOG_DEBUG ("Output device doesn't match. Dropped.");
              return;





      // tag the packet with the flow id and packet id, so that the packet can be identified even
      // when Ipv4Header is not accessible at some non-IPv4 protocol layer
      Ptr<Ipv4FlowProbeTag> fTag = CreateObject<Ipv4FlowProbeTag> (flowId, packetId, size);
      ConstCast<Packet> (ipPayload)->AddPacketTag (fTag);
    }
}


  if (m_classifier->Classify (ipHeader, ipPayload, &flowId, &packetId))
    {
      // remove the tags that are added by Ipv4FlowProbe::SendOutgoingLogger ()
      Ipv4FlowProbeTag fTag;

      // ConstCast: see http://www.nsnam.org/bugzilla/show_bug.cgi?id=904
      ConstCast<Packet> (ipPayload)->RemovePacketTag<Ipv4FlowProbeTag> ();

      uint32_t size = (ipPayload->GetSize () + ipHeader.GetSerializedSize ());
      NS_LOG_DEBUG ("ReportLastRx ("<<this<<", "<<flowId<<", "<<packetId<<", "<<size<<");");

  if (m_classifier->Classify (ipHeader, ipPayload, &flowId, &packetId))
    {
      // remove the tags that are added by Ipv4FlowProbe::SendOutgoingLogger ()
      Ipv4FlowProbeTag fTag;

      // ConstCast: see http://www.nsnam.org/bugzilla/show_bug.cgi?id=904
      ConstCast<Packet> (ipPayload)->RemovePacketTag<Ipv4FlowProbeTag> ();

      uint32_t size = (ipPayload->GetSize () + ipHeader.GetSerializedSize ());
      NS_LOG_DEBUG ("Drop ("<<this<<", "<<flowId<<", "<<packetId<<", "<<size<<", " << reason 

Ipv4FlowProbe::QueueDropLogger (Ptr<const Packet> ipPayload)
{
  // remove the tags that are added by Ipv4FlowProbe::SendOutgoingLogger ()
  Ipv4FlowProbeTag fTag;

  // ConstCast: see http://www.nsnam.org/bugzilla/show_bug.cgi?id=904
  Ptr<const Ipv4FlowProbeTag> fTag = ConstCast<Packet> (ipPayload)->RemovePacketTag<Ipv4FlowProbeTag> ();
  tagFound = ConstCast<Packet> (ipPayload)->RemovePacketTag (fTag);
  if (!tagFound)
    {
      return;
    }

  FlowId flowId = fTag->GetFlowId ();
  FlowPacketId packetId = fTag->GetPacketId ();
  uint32_t size = fTag->GetPacketSize ();

  NS_LOG_DEBUG ("Drop ("<<this<<", "<<flowId<<", "<<packetId<<", "<<size<<", " << DROP_QUEUE 
                        << "); ");




{
  NS_LOG_FUNCTION (this << packet << src << dst << (uint32_t)ttl);
  Ptr<Ipv6L3Protocol> ipv6 = m_node->GetObject<Ipv6L3Protocol> ();
  SocketIpTtlTag tag;
  NS_ASSERT (ipv6 != 0);

  Ptr<SocketIpTtlTag> tag = CreateObject<SocketIpTtlTag> ();
  tag->SetTtl (ttl);
  packet->AddPacketTag (tag);
  m_downTarget (packet, src, dst, PROT_NUMBER, 0);
}

  Ptr<Ipv6L3Protocol> ipv6 = m_node->GetObject<Ipv6L3Protocol> ();
  NS_ASSERT (ipv6 != 0 && ipv6->GetRoutingProtocol () != 0);
  Ipv6Header header;
  SocketIpTtlTag tag;
  Socket::SocketErrno err;
  Ptr<Ipv6Route> route;
  Ptr<NetDevice> oif (0); //specify non-zero if bound to a source address

  if (route != 0)
    {
      NS_LOG_LOGIC ("Route exists");
      Ptr<SocketIpTtlTag> tag = CreateObject<SocketIpTtlTag> ();
      tag->SetTtl (ttl);
      packet->AddPacketTag (tag);
      Ipv6Address src = route->GetSource ();


(-)a/src/internet/model/ipv4-l3-protocol.cc (-4 / +3 lines)

Lines 547-557 Ipv4L3Protocol::Send (Ptr<Packet> packet,	Link Here

547

  Ipv4Header ipHeader;

547

  Ipv4Header ipHeader;

548

  bool mayFragment = true;

548

  bool mayFragment = true;

549

  uint8_t ttl = m_defaultTtl;

549

  uint8_t ttl = m_defaultTtl;

550

  SocketIpTtlTag tag;

550

  Ptr<const SocketIpTtlTag> tag = packet->RemovePacketTag<SocketIpTtlTag> ();

551

  bool found = packet->RemovePacketTag (tag);

551

  if (tag != 0)

552

  if (found)

553

552

554

      ttl = tag.GetTtl ();

553

      ttl = tag->GetTtl ();

555

554

556

555

557

  // Handle a few cases:

556

  // Handle a few cases:

(-)a/src/internet/model/ipv4-raw-socket-impl.cc (-3 / +4 lines)

Lines 320-328 Ipv4RawSocketImpl::ForwardUp (Ptr<const Packet> p, Ipv4Header ipHeader, Ptr<Ipv4	Link Here

320

      // Should check via getsockopt ()..

320

      // Should check via getsockopt ()..

321

      if (IsRecvPktInfo ())

321

      if (IsRecvPktInfo ())

322

323

          Ipv4PacketInfoTag tag;

323

          Ptr<const Ipv4PacketInfoTag> origTag = copy->RemovePacketTag<Ipv4PacketInfoTag> ();

324

          copy->RemovePacketTag (tag);

324

          NS_ASSERT (origTag != 0);

325

          tag.SetRecvIf (incomingInterface->GetDevice ()->GetIfIndex ());

325

          Ptr<Ipv4PacketInfoTag> tag = CreateObject<Ipv4PacketInfoTag> (*origTag);

326

          tag->SetRecvIf (incomingInterface->GetDevice ()->GetIfIndex ());

326

          copy->AddPacketTag (tag);

327

          copy->AddPacketTag (tag);

327

328

      if (m_protocol == 1)

329

      if (m_protocol == 1)




  NS_LOG_FUNCTION (this << packet << source << destination << (uint32_t)protocol << route);
  Ipv6Header hdr;
  uint8_t ttl = m_defaultTtl;
  Ptr<const SocketIpTtlTag> tag = packet->RemovePacketTag<SocketIpTtlTag> ();
  bool found = packet->RemovePacketTag (tag);

  if (tag != 0)
    {
      ttl = tag->GetTtl ();
    }

  /* Handle 3 cases:

(-)a/src/internet/model/ipv6-raw-socket-impl.cc (-3 / +3 lines)

Lines 340-348 bool Ipv6RawSocketImpl::ForwardUp (Ptr<const Packet> p, Ipv6Header hdr, Ptr<NetD	Link Here

340

      // Should check via getsockopt ()..

340

      // Should check via getsockopt ()..

341

      if (IsRecvPktInfo ())

341

      if (IsRecvPktInfo ())

342

343

          Ipv6PacketInfoTag tag;

343

          Ptr<const Ipv6PacketInfoTag> origTag = copy->RemovePacketTag<Ipv6PacketInfoTag> ();

344

          copy->RemovePacketTag (tag);

344

          Ptr<Ipv6PacketInfoTag> tag = CreateObject<Ipv6PacketInfoTag> (*origTag);

345

          tag.SetRecvIf (device->GetIfIndex ());

345

          tag->SetRecvIf (device->GetIfIndex ());

346

          copy->AddPacketTag (tag);

346

          copy->AddPacketTag (tag);

347

348




    {
      m_errno = ERROR_ADDRNOTAVAIL;
      return -1;
}
  m_tcp->m_sockets.push_back (this);
  return SetupCallback ();
}

  NS_LOG_FUNCTION (this << address);
  if (InetSocketAddress::IsMatchingType (address))
    {
  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 ();
    }
  else if (ipv4 == Ipv4Address::GetAny () && port != 0)
    {
      m_endPoint = m_tcp->Allocate (port);
    }
  else if (ipv4 != Ipv4Address::GetAny () && port == 0)
    {
      m_endPoint = m_tcp->Allocate (ipv4);
    }
  else if (ipv4 != Ipv4Address::GetAny () && port != 0)
    {
      m_endPoint = m_tcp->Allocate (ipv4, port);
    }
  if (0 == m_endPoint)
    {
      m_errno = port ? ERROR_ADDRINUSE : ERROR_ADDRNOTAVAIL;
      return -1;
    }
    }
  else if (Inet6SocketAddress::IsMatchingType (address))
    {

  // If haven't do so, Bind() this socket first
  if (InetSocketAddress::IsMatchingType (address) && m_endPoint6 == 0)
    {
  if (m_endPoint == 0)
    {
      if (Bind () == -1)
        {
          NS_ASSERT (m_endPoint == 0);
          return -1; // Bind() failed
              NS_ASSERT (m_endPoint == 0);
              return -1; // Bind() failed
            }
          NS_ASSERT (m_endPoint != 0);
        }
      NS_ASSERT (m_endPoint != 0);
    }
  InetSocketAddress transport = InetSocketAddress::ConvertFrom (address);
  m_endPoint->SetPeer (transport.GetIpv4 (), transport.GetPort ());
      m_endPoint6 = 0;

  // Get the appropriate local address and port number from the routing protocol and set up endpoint
  if (SetupEndpoint () != 0)
    { // Route to destination does not exist
      return -1;
    }
    }
  else if (Inet6SocketAddress::IsMatchingType (address)  && m_endPoint == 0)
    {

      if (v6Addr.IsIpv4MappedAddress () == true)
        {
          Ipv4Address v4Addr = v6Addr.GetIpv4MappedAddress ();
          return Connect(InetSocketAddress(v4Addr, transport.GetPort ()));
        }

      if (m_endPoint6 == 0)

  Ptr<Packet> outPacket = m_rxBuffer.Extract (maxSize);
  if (outPacket != 0 && outPacket->GetSize () != 0)
    {
      Ptr<SocketAddressTag> tag = CreateObject<SocketAddressTag> ();
      if (m_endPoint != 0)
        {
          tag->SetAddress (InetSocketAddress (m_endPoint->GetPeerAddress (), m_endPoint->GetPeerPort ()));
        }
      else if (m_endPoint6 != 0)
        {
          tag->SetAddress (Inet6SocketAddress (m_endPoint6->GetPeerAddress (), m_endPoint6->GetPeerPort ()));
        }
      
      outPacket->AddPacketTag (tag);
    }
  return outPacket;


  if (m_endPoint != 0)
    {
  m_endPoint->BindToNetDevice (netdevice);
    }
  // No BindToNetDevice() for Ipv6EndPoint
  return;

    }
  if (m_endPoint != 0)
    {
  m_endPoint->SetRxCallback (MakeCallback (&TcpSocketBase::ForwardUp, Ptr<TcpSocketBase> (this)));
  m_endPoint->SetDestroyCallback (MakeCallback (&TcpSocketBase::Destroy, Ptr<TcpSocketBase> (this)));
    }
  if (m_endPoint6 != 0)
    {

  TcpHeader tcpHeader;
  packet->RemoveHeader (tcpHeader);
  if (tcpHeader.GetFlags () & TcpHeader::ACK)
    { 
      EstimateRtt (tcpHeader);
    }
  ReadOptions (tcpHeader);

    {
      NS_LOG_LOGIC ("At state " << TcpStateName[m_state] <<
                    " received packet of seq [" << tcpHeader.GetSequenceNumber () <<
                    ":" << tcpHeader.GetSequenceNumber () + packet->GetSize() <<
                    ") out of range [" << m_rxBuffer.NextRxSequence () << ":" <<
                    m_rxBuffer.MaxRxSequence () << ")");
      // Acknowledgement should be sent for all unacceptable packets (RFC793, p.69)

    {
      NS_LOG_LOGIC ("At state " << TcpStateName[m_state] <<
                    " received packet of seq [" << tcpHeader.GetSequenceNumber () <<
                    ":" << tcpHeader.GetSequenceNumber () + packet->GetSize() <<
                    ") out of range [" << m_rxBuffer.NextRxSequence () << ":" <<
                    m_rxBuffer.MaxRxSequence () << ")");
      // Acknowledgement should be sent for all unacceptable packets (RFC793, p.69)

    { // Other in-sequence input
      if (tcpflags != TcpHeader::RST)
        { // When (1) rx of FIN+ACK; (2) rx of FIN; (3) rx of bad flags
          NS_LOG_LOGIC ("Illegal flag " << std::hex << static_cast<uint32_t>(tcpflags) << std::dec << " received. Reset packet is sent.");
          SendRST ();
        }
      CloseAndNotify ();


  if (tcpflags == 0
      || (tcpflags == TcpHeader::ACK
       && m_nextTxSequence + SequenceNumber32 (1) == tcpHeader.GetAckNumber ()))
    { // If it is bare data, accept it and move to ESTABLISHED state. This is
      // possibly due to ACK lost in 3WHS. If in-sequence ACK is received, the
      // handshake is completed nicely.

      m_txBuffer.SetHeadSequence (m_nextTxSequence);
      if (m_endPoint)
        {
      m_endPoint->SetPeer (InetSocketAddress::ConvertFrom (fromAddress).GetIpv4 (),
                           InetSocketAddress::ConvertFrom (fromAddress).GetPort ());
        }
      else if (m_endPoint6)
        {

          m_txBuffer.SetHeadSequence (m_nextTxSequence);
          if (m_endPoint)
            {
          m_endPoint->SetPeer (InetSocketAddress::ConvertFrom (fromAddress).GetIpv4 (),
                               InetSocketAddress::ConvertFrom (fromAddress).GetPort ());
            }
          else if (m_endPoint6)
            {

          NS_LOG_LOGIC ("Illegal flag " << tcpflags << " received. Reset packet is sent.");
          if (m_endPoint)
            {
          m_endPoint->SetPeer (InetSocketAddress::ConvertFrom (fromAddress).GetIpv4 (),
                               InetSocketAddress::ConvertFrom (fromAddress).GetPort ());
            }
          else if (m_endPoint6)
            {

      if (!m_shutdownRecv)
        {
          NotifyDataRecv ();
        }
    }
}
}

/** Received a packet upon CLOSING */
void

  m_endPoint = 0;
  if (m_tcp != 0)
    {
  std::vector<Ptr<TcpSocketBase> >::iterator it
    = std::find (m_tcp->m_sockets.begin (), m_tcp->m_sockets.end (), this);
  if (it != m_tcp->m_sockets.end ())
    {
      m_tcp->m_sockets.erase (it);
    }
    }
  NS_LOG_LOGIC (this << " Cancelled ReTxTimeout event which was set to expire at " <<
                (Simulator::Now () + Simulator::GetDelayLeft (m_retxEvent)).GetSeconds ());

  header.SetAckNumber (m_rxBuffer.NextRxSequence ());
  if (m_endPoint != 0)
    {
  header.SetSourcePort (m_endPoint->GetLocalPort ());
  header.SetDestinationPort (m_endPoint->GetPeerPort ());
    }
  else
    {

      if (it != m_tcp->m_sockets.end ())
        {
          m_tcp->m_sockets.erase (it);
}
      CancelAllTimers ();
    }
}

  // Get port and address from peer (connecting host)
  if (InetSocketAddress::IsMatchingType (toAddress))
    {
  m_endPoint = m_tcp->Allocate (InetSocketAddress::ConvertFrom (toAddress).GetIpv4 (),
                                InetSocketAddress::ConvertFrom (toAddress).GetPort (),
                                InetSocketAddress::ConvertFrom (fromAddress).GetIpv4 (),
                                InetSocketAddress::ConvertFrom (fromAddress).GetPort ());
      m_endPoint6 = 0;
    }
  else if (Inet6SocketAddress::IsMatchingType (toAddress))

  header.SetAckNumber (m_rxBuffer.NextRxSequence ());
  if (m_endPoint)
    {
  header.SetSourcePort (m_endPoint->GetLocalPort ());
  header.SetDestinationPort (m_endPoint->GetPeerPort ());
    }
  else
    {

  NS_LOG_LOGIC ("Send packet via TcpL4Protocol with flags 0x" << std::hex << static_cast<uint32_t> (flags) << std::dec);
  if (m_endPoint)
    {
  m_tcp->SendPacket (p, header, m_endPoint->GetLocalAddress (),
                     m_endPoint->GetPeerAddress (), m_boundnetdevice);
    }
  else
    {

  tcpHeader.SetWindowSize (AdvertisedWindowSize ());
  if (m_endPoint != 0)
    {
  tcpHeader.SetSourcePort (m_endPoint->GetLocalPort ());
  tcpHeader.SetDestinationPort (m_endPoint->GetPeerPort ());
    }
  else
    {


  if (m_endPoint != 0)
    {
  m_tcp->SendPacket (p, tcpHeader, m_endPoint->GetLocalAddress (),
                     m_endPoint->GetPeerAddress (), m_boundnetdevice);
    }
  else
    {

  CancelAllTimers ();
  // Move from TIME_WAIT to CLOSED after 2*MSL. Max segment lifetime is 2 min
  // according to RFC793, p.28
  m_timewaitEvent = Simulator::Schedule (Seconds (2*m_msl),
                                         &TcpSocketBase::CloseAndNotify, this);
}





  bool done = false;
  if (m_endPoint != 0)
    {
  m_endPoint->SetRxCallback (MakeCallback (&UdpSocketImpl::ForwardUp, Ptr<UdpSocketImpl> (this)));
  m_endPoint->SetIcmpCallback (MakeCallback (&UdpSocketImpl::ForwardIcmp, Ptr<UdpSocketImpl> (this)));
  m_endPoint->SetDestroyCallback (MakeCallback (&UdpSocketImpl::Destroy, Ptr<UdpSocketImpl> (this)));
      done = true;
    }
  if (m_endPoint6 != 0)

    }
  if (done)
    {
  return 0;
}
  return -1;
}


  return FinishBind ();
}

int 
UdpSocketImpl::Bind6 (void)
{
  NS_LOG_FUNCTION_NOARGS ();


  if (InetSocketAddress::IsMatchingType (address))
    {
  InetSocketAddress transport = InetSocketAddress::ConvertFrom (address);
  Ipv4Address ipv4 = transport.GetIpv4 ();
  uint16_t port = transport.GetPort ();
  if (ipv4 == Ipv4Address::GetAny () && port == 0)
    {
      m_endPoint = m_udp->Allocate ();
    }
  else if (ipv4 == Ipv4Address::GetAny () && port != 0)
    {
      m_endPoint = m_udp->Allocate (port);
    }
  else if (ipv4 != Ipv4Address::GetAny () && port == 0)
    {
      m_endPoint = m_udp->Allocate (ipv4);
    }
  else if (ipv4 != Ipv4Address::GetAny () && port != 0)
    {
      m_endPoint = m_udp->Allocate (ipv4, port);
    }
    }
  else if (Inet6SocketAddress::IsMatchingType (address))
    {

  NS_LOG_FUNCTION (this << address);
  if (InetSocketAddress::IsMatchingType(address) == true)
    {
  InetSocketAddress transport = InetSocketAddress::ConvertFrom (address);
      m_defaultAddress = Address(transport.GetIpv4 ());
  m_defaultPort = transport.GetPort ();
  m_connected = true;
  NotifyConnectionSucceeded ();
    }
  else if (Inet6SocketAddress::IsMatchingType(address) == true)
    {

      NS_LOG_LOGIC ("Not connected");
      if (InetSocketAddress::IsMatchingType(address) == true)
        {
      InetSocketAddress transport = InetSocketAddress::ConvertFrom (address);
      Ipv4Address ipv4 = transport.GetIpv4 ();
      uint16_t port = transport.GetPort ();
      return DoSendTo (p, ipv4, port);
    }
      else if (Inet6SocketAddress::IsMatchingType(address) == true)
        {
          Inet6SocketAddress transport = Inet6SocketAddress::ConvertFrom (address);

          uint16_t port = transport.GetPort ();
          return DoSendTo (p, ipv6, port);
        }
  else
    {
          return -1;
        }
    }

      if (Ipv4Address::IsMatchingType(m_defaultAddress))
        {
          return DoSendTo (p, Ipv4Address::ConvertFrom(m_defaultAddress), m_defaultPort);
    }
      else if (Ipv6Address::IsMatchingType(m_defaultAddress))
        {
          return DoSendTo (p, Ipv6Address::ConvertFrom(m_defaultAddress), m_defaultPort);
}
    }
  m_errno = ERROR_AFNOSUPPORT;
  return(-1);

  // the same as a unicast, but it will be fixed further down the stack
  if (m_ipMulticastTtl != 0 && dest.IsMulticast ())
    {
      Ptr<SocketIpTtlTag> tag = CreateObject<SocketIpTtlTag> ();
      tag->SetTtl (m_ipMulticastTtl);
      p->AddPacketTag (tag);
    }
  else if (m_ipTtl != 0 && !dest.IsMulticast () && !dest.IsBroadcast ())
    {
      Ptr<SocketIpTtlTag> tag = CreateObject<SocketIpTtlTag> ();
      tag->SetTtl (m_ipTtl);
      p->AddPacketTag (tag);
    }
  {

    // !!! Previously, header was removed, checked, but never added back.  Guess, this was wrong
    if (p->PeekPacketTag<SocketSetDontFragmentTag> () == 0)
      {
        Ptr<SocketSetDontFragmentTag> tag = CreateObject<SocketSetDontFragmentTag> ();
        if (m_mtuDiscover)
          {
            tag->Enable ();
          }
        else
          {
            tag->Disable ();
          }
        p->AddPacketTag (tag);
      }

  // the same as a unicast, but it will be fixed further down the stack
  if (m_ipMulticastTtl != 0 && dest.IsMulticast ())
    {
      Ptr<SocketIpTtlTag> tag = CreateObject<SocketIpTtlTag> ();
      tag->SetTtl (m_ipMulticastTtl);
      p->AddPacketTag (tag);
    }
  else if (m_ipTtl != 0 && !dest.IsMulticast ())
    {
      Ptr<SocketIpTtlTag> tag = CreateObject<SocketIpTtlTag> ();
      tag->SetTtl (m_ipTtl);
      p->AddPacketTag (tag);
    }
  // There is no analgous to an IPv4 broadcast address in IPv6.

  NS_LOG_FUNCTION (this << p << flags << address);
  if (InetSocketAddress::IsMatchingType (address))
    {
  InetSocketAddress transport = InetSocketAddress::ConvertFrom (address);
  Ipv4Address ipv4 = transport.GetIpv4 ();
  uint16_t port = transport.GetPort ();
  return DoSendTo (p, ipv4, port);
}
  else if (Inet6SocketAddress::IsMatchingType (address))
    {
      Inet6SocketAddress transport = Inet6SocketAddress::ConvertFrom (address);

  Ptr<Packet> packet = Recv (maxSize, flags);
  if (packet != 0)
    {
      Ptr<const SocketAddressTag> tag = packet->PeekPacketTag<SocketAddressTag> ();
      NS_ASSERT (tag != 0);
      fromAddress = tag->GetAddress ();
      NS_ASSERT (found);
      fromAddress = tag.GetAddress ();
    }
  return packet;
}

  // Should check via getsockopt ()..
  if (IsRecvPktInfo ())
    {
      Ptr<const Ipv4PacketInfoTag> origTag = packet->RemovePacketTag<Ipv4PacketInfoTag> ();
      Ptr<Ipv4PacketInfoTag> tag = CreateObject<Ipv4PacketInfoTag> (*origTag);      
      tag->SetRecvIf (incomingInterface->GetDevice ()->GetIfIndex ());
      packet->AddPacketTag (tag);
    }

  if ((m_rxAvailable + packet->GetSize ()) <= m_rcvBufSize)
    {
      Address address = InetSocketAddress (header.GetSource (), port);
      Ptr<SocketAddressTag> tag = CreateObject<SocketAddressTag> ();
      tag->SetAddress (address);
      packet->AddPacketTag (tag);
      m_deliveryQueue.push (packet);
      m_rxAvailable += packet->GetSize ();

    }
}

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

  if ((m_rxAvailable + packet->GetSize ()) <= m_rcvBufSize)
    {
      Address address = Inet6SocketAddress (saddr, port);
      Ptr<SocketAddressTag> tag = CreateObject<SocketAddressTag> ();
      tag->SetAddress (address);
      packet->AddPacketTag (tag);
      m_deliveryQueue.push (packet);
      m_rxAvailable += packet->GetSize ();




  NS_ASSERT (header.IsData ());

  MeshHeader meshHdr;
  if (packet->PeekPacketTag<HwmpTag> () != 0)
  if (packet->PeekPacketTag (tag))
    {
      NS_FATAL_ERROR ("HWMP tag is not supposed to be received by network");
    }

      NS_FATAL_ERROR (
        "6-address scheme is not yet supported and 4-address extension is not supposed to be used for data frames.");
    }
  Ptr<HwmpTag> tag = CreateObject<HwmpTag> ();
  tag->SetSeqno (meshHdr.GetMeshSeqno ());
  tag->SetTtl (meshHdr.GetMeshTtl ());
  packet->AddPacketTag (tag);

  if ((destination == Mac48Address::GetBroadcast ()) && (m_protocol->DropDataFrame (meshHdr.GetMeshSeqno (),

    {
      return true;
    }
  Ptr<const HwmpTag> tag = packet->RemovePacketTag<HwmpTag> ();
  if (tag == 0)
  if (!tagExists)
    {
      NS_FATAL_ERROR ("HWMP tag must exist at this point");
    }
  m_stats.txData++;
  m_stats.txDataBytes += packet->GetSize ();
  MeshHeader meshHdr;
  meshHdr.SetMeshSeqno (tag->GetSeqno ());
  meshHdr.SetMeshTtl (tag->GetTtl ());
  packet->AddHeader (meshHdr);
  header.SetAddr1 (tag->GetAddress ());
  return true;
}
WifiActionHeader




  )
{
  Ptr <Packet> packet = constPacket->Copy ();
  Ptr<HwmpTag> tag = 0;
  if (sourceIface == GetMeshPoint ()->GetIfIndex ())
    {
      // packet from level 3
      if (packet->PeekPacketTag<HwmpTag> () != 0)
        {
          NS_FATAL_ERROR ("HWMP tag has come with a packet from upper layer. This must not occur...");
        }
      tag = CreateObject<HwmpTag> ();
      //Filling TAG:
      if (destination == Mac48Address::GetBroadcast ())
        {
          tag->SetSeqno (m_dataSeqno++);
        }
      tag->SetTtl (m_maxTtl);
    }
  else
    {
      Ptr<const HwmpTag> origTag = packet->RemovePacketTag<HwmpTag> ();
      if (!packet->RemovePacketTag<HwmpTag> ())
        {
          NS_FATAL_ERROR ("HWMP tag is supposed to be here at this point.");
        }
      tag = CreateObject<HwmpTag> (*origTag);
      tag->DecrementTtl ();
      if (tag->GetTtl () == 0)
        {
          m_stats.droppedTtl++;
          return false;

            {
              Ptr<Packet> packetCopy = packet->Copy ();
              //
              // 64-bit Intel valgrind complains about tag->SetAddress (*i).  It
              // likes this just fine.
              //
              Mac48Address address = *i;
              tag->SetAddress (address);
              packetCopy->AddPacketTag (tag);
              routeReply (true, packetCopy, source, destination, protocolType, plugin->first);
            }

    }
  else
    {
      return ForwardUnicast (sourceIface, source, destination, packet, protocolType, routeReply, tag->GetTtl ());
    }
  return true;
}

HwmpProtocol::RemoveRoutingStuff (uint32_t fromIface, const Mac48Address source,
                                  const Mac48Address destination, Ptr<Packet>  packet, uint16_t&  protocolType)
{
  Ptr<const HwmpTag> tag = packet->RemovePacketTag<HwmpTag> ();
  if (tag == 0)
    {
      NS_FATAL_ERROR ("HWMP tag must exist when packet received from the network");
    }

    {
      result = m_rtable->LookupProactive ();
    }
  Ptr<HwmpTag> tag = CreateObject<HwmpTag> ();
  tag->SetAddress (result.retransmitter);
  tag->SetTtl (ttl);
  //seqno and metric is not used;
  packet->AddPacketTag (tag);
  if (result.retransmitter != Mac48Address::GetBroadcast ())

  while (packet.pkt != 0)
    {
      //set RA tag for retransmitter:
      Ptr<const HwmpTag> origTag = packet.pkt->RemovePacketTag<HwmpTag> ();
      if (origTag == 0)
        {
          NS_FATAL_ERROR ("HWMP tag must be present at this point");
        }
      Ptr<HwmpTag> tag = CreateObject<HwmpTag> (*origTag);
      tag->SetAddress (result.retransmitter);
      packet.pkt->AddPacketTag (tag);
      m_stats.txUnicast++;
      m_stats.txBytes += packet.pkt->GetSize ();

  while (packet.pkt != 0)
    {
      //set RA tag for retransmitter:
      Ptr<const HwmpTag> origTag = packet.pkt->RemovePacketTag<HwmpTag> ();
      if (origTag == 0)
        {
          NS_FATAL_ERROR ("HWMP tag must be present at this point");
        }
      Ptr<HwmpTag> tag = CreateObject<HwmpTag> (*origTag);
      tag->SetAddress (result.retransmitter);
      packet.pkt->AddPacketTag (tag);
      m_stats.txUnicast++;
      m_stats.txBytes += packet.pkt->GetSize ();




}

Mac48Address
HwmpTag::GetAddress () const
{
  return m_address;
}

}

uint8_t
HwmpTag::GetTtl () const
{
  return m_ttl;
}

}

uint32_t
HwmpTag::GetMetric () const
{
  return m_metric;
}

}

uint32_t
HwmpTag::GetSeqno () const
{
  return m_seqno;
}




  HwmpTag ();
  ~HwmpTag ();
  void  SetAddress (Mac48Address retransmitter);
  Mac48Address GetAddress () const;
  void  SetTtl (uint8_t ttl);
  uint8_t GetTtl () const;
  void  SetMetric (uint32_t metric);
  uint32_t GetMetric () const;
  void  SetSeqno (uint32_t seqno);
  uint32_t GetSeqno () const;
  void  DecrementTtl ();

  static  TypeId  GetTypeId ();




    {
      return true;
    }
  if (packet->PeekPacketTag<FlameTag> () != 0)
  if (packet->PeekPacketTag (tag))
    {
      NS_FATAL_ERROR ("FLAME tag is not supposed to be received by network");
    }
  Ptr<FlameTag> tag = CreateObject<FlameTag> ();
  tag->receiver = header.GetAddr1 ();
  tag->transmitter = header.GetAddr2 ();
  if (tag->receiver == Mac48Address::GetBroadcast ())
    {
      m_stats.rxBroadcast++;
    }

    {
      return true;
    }
  Ptr<const FlameTag> tag = packet->RemovePacketTag<FlameTag> ();
  if (tag == 0)
    {
      NS_FATAL_ERROR ("FLAME tag must exist here");
    }
  header.SetAddr1 (tag->receiver);
  if (tag->receiver == Mac48Address::GetBroadcast ())
    {
      m_stats.txBroadcast++;
    }




  if (sourceIface == m_mp->GetIfIndex ())
    {
      //Packet from upper layer!
      if (packet->PeekPacketTag<FlameTag> () != 0)
      if (packet->PeekPacketTag (tag))
        {
          NS_FATAL_ERROR ("FLAME tag is not supposed to be received from upper layers");
        }

      flameHdr.SetOrigSrc (source);
      m_stats.txBytes += packet->GetSize ();
      packet->AddHeader (flameHdr);
      Ptr<FlameTag> tag = CreateObject<FlameTag> ();
      tag->receiver = result.retransmitter;
      if (result.retransmitter == Mac48Address::GetBroadcast ())
        {
          m_stats.txBroadcast++;

        {
          m_stats.txUnicast++;
        }
      NS_LOG_DEBUG ("Source: send packet with RA = " << tag->receiver);
      packet->AddPacketTag (tag);
      routeReply (true, packet, source, destination, FLAME_PROTOCOL, result.ifIndex);
    }

    {
      FlameHeader flameHdr;
      packet->RemoveHeader (flameHdr);
      FlameTag tag;

      Ptr<const FlameTag> origTag = packet->RemovePacketTag<FlameTag> ();
      if (origTag == 0)
        {
          NS_FATAL_ERROR ("FLAME tag must exist here");
        }
      
      if (destination == Mac48Address::GetBroadcast ())
        {
          //Broadcast always is forwarded as broadcast!
          NS_ASSERT (HandleDataFrame (flameHdr.GetSeqno (), source, flameHdr, origTag->transmitter, sourceIface));
          Ptr<FlameTag> tag = CreateObject<FlameTag> (Mac48Address::GetBroadcast ());
          flameHdr.AddCost (1);
          m_stats.txBytes += packet->GetSize ();
          packet->AddHeader (flameHdr);

        }
      else
        {
          Ptr<FlameTag> tag = CreateObject<FlameTag> (*origTag);
          // We check sequence only when forward unicast, because broadcast-checks were done
          // inside remove routing stuff.
          if (HandleDataFrame (flameHdr.GetSeqno (), source, flameHdr, tag->transmitter, sourceIface))
            {
              return false;
            }
          FlameRtable::LookupResult result = m_rtable->Lookup (destination);
          if (origTag->receiver != Mac48Address::GetBroadcast ())
            {
              if (result.retransmitter == Mac48Address::GetBroadcast ())
                {
                  NS_LOG_DEBUG ("unicast packet dropped, because no route! I am " << GetAddress ()
                                                                                  << ", RA = " << origTag->receiver << ", TA = " << origTag->transmitter);
                  m_stats.totalDropped++;
                  return false;
                }
              tag->receiver = result.retransmitter;
            }
          else
            {
              tag->receiver = Mac48Address::GetBroadcast ();
            }
          if (result.retransmitter == Mac48Address::GetBroadcast ())
            {

      NS_LOG_DEBUG ("Dropped my own frame!");
      return false;
    }
  Ptr<const FlameTag> tag = packet->RemovePacketTag <FlameTag> ();
  if (tag == 0)
    {
      NS_FATAL_ERROR ("FLAME tag must exist when packet is coming to protocol");
    }
  FlameHeader flameHdr;
  packet->RemoveHeader (flameHdr);
  if (HandleDataFrame (flameHdr.GetSeqno (), source, flameHdr, tag->transmitter, fromIface))
    {
      return false;
    }




  //Classify: application sets a tag, which is removed here
  // Get Qos tag:
  AcIndex ac = AC_BE;
  Ptr<const QosTag> tag = packet->RemovePacketTag<QosTag> ();
  if (tag != 0)
    {
      hdr.SetType (WIFI_MAC_QOSDATA);
      hdr.SetQosTid (tag->GetTid ());
      //Aftre setting type DsFrom and DsTo fields are reset.
      hdr.SetDsFrom ();
      hdr.SetDsTo ();
      ac = QosUtilsMapTidToAc (tag->GetTid ());
    }
  m_stats.sentFrames++;
  m_stats.sentBytes += packet->GetSize ();

  // Check if QoS tag exists and add it:
  if (hdr->IsQosData ())
    {
      packet->AddPacketTag (CreateObject<QosTag> (hdr->GetQosTid ()));
    }
  // Forward data up
  if (hdr->IsData ())




int main (int argc, char *argv[])
{
  // create a tag.
  Ptr<MyTag> tag = CreateObject<MyTag> ();
  tag->SetSimpleValue (0x56);

  // store the tag in a packet.
  Ptr<Packet> p = Create<Packet> (100);

  Ptr<Packet> aCopy = p->Copy ();

  // read the tag from the packet copy
  Ptr<const MyTag> tagCopy = p->PeekPacketTag<MyTag> ();
  p->PeekPacketTag (tagCopy);

  // the copy and the original are the same !
  NS_ASSERT (tagCopy->GetSimpleValue () == tag->GetSimpleValue ());

  aCopy->PrintPacketTags (std::cout);
  std::cout << std::endl;




  if ((m_rxAvailable + packet->GetSize ()) <= m_rcvBufSize)
    {
      Ptr<Packet> copy = packet->Copy ();
      Ptr<DeviceNameTag> dnt = CreateObject<DeviceNameTag> ();
      dnt->SetDeviceName (device->GetTypeId ().GetName ());
      Ptr<PacketSocketTag> pst = CreateObject<PacketSocketTag> ();
      pst->SetPacketType (packetType);
      pst->SetDestAddress (to);
      Ptr<SocketAddressTag> tag = CreateObject<SocketAddressTag> ();
      tag->SetAddress (address);
      copy->AddPacketTag (tag); // Attach From Physical Address
      copy->AddPacketTag (pst); // Attach Packet Type and Dest Address
      copy->AddPacketTag (dnt); // Attach device source name

  Ptr<Packet> packet = Recv (maxSize, flags);
  if (packet != 0)
    {
      Ptr<const SocketAddressTag> tag = packet->PeekPacketTag<SocketAddressTag> ();
      NS_ASSERT (tag != 0);
      fromAddress = tag->GetAddress ();
      NS_ASSERT (found);
      fromAddress = tag.GetAddress ();
    }
  return packet;
}

DeviceNameTag::GetSerializedSize (void) const
{
  uint32_t s = 1 + m_deviceName.size();
  return s;
}
void
DeviceNameTag::Serialize (TagBuffer i) const

  const char *n = m_deviceName.c_str();
  uint8_t l = (uint8_t) strlen (n);

  if ( ( 1 + l ) > PACKET_TAG_MAX_SIZE ) l = PACKET_TAG_MAX_SIZE - 1;

  i.WriteU8 (l);
  i.Write ( (uint8_t*) n , (uint32_t) l );
}




  {
    Ptr<Packet> packet = socket->Recv (65535, 0);
    NS_LOG_DEBUG ("N3SocketRecv: " << *packet);
    packet->RemovePacketTag<SocketAddressTag> ();
    packet->RemovePacketTag (socketAddressTag);
    m_n3Tap->Receive (packet, 0x0800, m_n3Tap->GetAddress (), m_n3Tap->GetAddress (), NetDevice::PACKET_HOST);
  }


  {
    Ptr<Packet> packet = socket->Recv (65535, 0);
    NS_LOG_DEBUG ("N0SocketRecv: " << *packet);
    packet->RemovePacketTag<SocketAddressTag> ();
    packet->RemovePacketTag (socketAddressTag);
    m_n0Tap->Receive (packet, 0x0800, m_n0Tap->GetAddress (), m_n0Tap->GetAddress (), NetDevice::PACKET_HOST);
  }


  {
    Ptr<Packet> packet = socket->Recv (65535, 0);
    NS_LOG_DEBUG ("N1SocketRecv: " << *packet);
    packet->RemovePacketTag<SocketAddressTag> ();
    packet->RemovePacketTag (socketAddressTag);
    m_n1Tap->Receive (packet, 0x0800, m_n1Tap->GetAddress (), m_n1Tap->GetAddress (), NetDevice::PACKET_HOST);
  }





           && m_currentPacket != 0)
    {
      NS_LOG_DEBUG ("receive cts from=" << m_currentHdr.GetAddr1 ());
      Ptr<const SnrTag> tag = packet->RemovePacketTag<SnrTag> ();
      packet->RemovePacketTag (tag);
      m_stationManager->ReportRxOk (m_currentHdr.GetAddr1 (), &m_currentHdr,
                                    rxSnr, txMode);
      m_stationManager->ReportRtsOk (m_currentHdr.GetAddr1 (), &m_currentHdr,
                                     rxSnr, txMode, tag->Get ());

      m_ctsTimeoutEvent.Cancel ();
      NotifyCtsTimeoutResetNow ();

           && m_txParams.MustWaitAck ())
    {
      NS_LOG_DEBUG ("receive ack from=" << m_currentHdr.GetAddr1 ());
      Ptr<const SnrTag> tag = packet->RemovePacketTag<SnrTag> ();
      packet->RemovePacketTag (tag);
      m_stationManager->ReportRxOk (m_currentHdr.GetAddr1 (), &m_currentHdr,
                                    rxSnr, txMode);
      m_stationManager->ReportDataOk (m_currentHdr.GetAddr1 (), &m_currentHdr,
                                      rxSnr, txMode, tag->Get ());
      bool gotAck = false;
      if (m_txParams.MustWaitNormalAck ()
          && m_normalAckTimeoutEvent.IsRunning ())

  WifiMacTrailer fcs;
  packet->AddTrailer (fcs);

  Ptr<SnrTag> tag = CreateObject<SnrTag> ();
  tag->Set (rtsSnr);
  packet->AddPacketTag (tag);

  ForwardDown (packet, &cts, ctsTxMode);

  WifiMacTrailer fcs;
  packet->AddTrailer (fcs);

  Ptr<SnrTag> tag = CreateObject<SnrTag> ();
  tag->Set (dataSnr);
  packet->AddPacketTag (tag);

  ForwardDown (packet, &ack, ackTxMode);




uint8_t
QosUtilsGetTidForPacket (Ptr<const Packet> packet)
{
  Ptr<const QosTag> qos = packet->PeekPacketTag<QosTag> ();
  uint8_t tid = 8;
  if (qos != 0)
    {
      if (qos->GetTid () < 8)
        {
          tid = qos->GetTid ();
        }
    }
  return tid;




  WifiRemoteStation *station = Lookup (address, header);
  WifiMode rts = DoGetRtsMode (station);
  WifiMode data = DoGetDataMode (station, fullPacketSize);
  
  // first, make sure that the tag is not here anymore.
  ConstCast<Packet> (packet)->RemovePacketTag<TxModeTag> ();
  Ptr<TxModeTag> tag = CreateObject<TxModeTag> (rts, data);
  // and then, add it back
  ConstCast<Packet> (packet)->AddPacketTag (tag);
}
WifiMode
WifiRemoteStationManager::GetDataMode (Mac48Address address, const WifiMacHeader *header,

    }
  if (!IsLowLatency ())
    {
      Ptr<const TxModeTag> tag = packet->PeekPacketTag<TxModeTag> ();
      NS_ASSERT (tag != 0);
      return tag->GetDataMode ();
      NS_ASSERT (found);
      return tag.GetDataMode ();
    }
  return DoGetDataMode (Lookup (address, header), fullPacketSize);
}

  NS_ASSERT (!address.IsGroup ());
  if (!IsLowLatency ())
    {
      Ptr<const TxModeTag> tag = packet->PeekPacketTag<TxModeTag> ();
      NS_ASSERT (tag != 0);
      return tag->GetRtsMode ();
      NS_ASSERT (found);
      return tag.GetRtsMode ();
    }
  return DoGetRtsMode (Lookup (address, header));
}




{
  BenchHeader<25> ipv4;
  BenchHeader<8> udp;
  BenchTag<16> tag1;
  BenchTag<17> tag2;

  for (uint32_t i = 0; i < n; i++) {
    Ptr<Packet> p = Create<Packet> (2000);
    p->AddPacketTag (CreateObject<BenchTag<16> > ());
    p->AddHeader (udp);
    p->RemovePacketTag (BenchTag<16>::GetTypeId ());
    
    p->AddPacketTag (CreateObject<BenchTag<17> > ());
    p->AddHeader (ipv4);
    
    Ptr<Packet> o = p->Copy ();
    o->RemoveHeader (ipv4);
    p->RemovePacketTag (BenchTag<17>::GetTypeId ());
    o->RemoveHeader (udp);
  }
}
- 

Return to bug 1383