Attachment #1347 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->oif != -1 && 
          tag->oif != 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




  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))
    {
  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) )
    {

  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)
    {

      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)
            {

  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
    {




  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;





namespace ns3 {

#ifdef USE_FREE_LIST

struct PacketTagList::TagData *PacketTagList::g_free = 0;
uint32_t PacketTagList::g_nfree = 0;

struct PacketTagList::TagData *
PacketTagList::AllocData (void) const
{
  NS_LOG_FUNCTION (g_nfree);
  struct PacketTagList::TagData *retval;
  if (g_free != 0) 
    {
      retval = g_free;
      g_free = g_free->m_next;
      g_nfree--;
    } 
  else 
    {
      retval = new struct PacketTagList::TagData ();
    }
  return retval;
}

void
PacketTagList::Add (Ptr<const Tag> tag)
{
  NS_LOG_FUNCTION (g_nfree << data);
  if (g_nfree > 1000) 
    {
      delete data;
      return;
    }
  g_nfree++;
  data->next = g_free;
  data->tid = TypeId ();
  g_free = data;
}
#else
struct PacketTagList::TagData *
PacketTagList::AllocData (void) const
{
  NS_LOG_FUNCTION (this << tag->GetInstanceTypeId ());
  struct PacketTagList::TagData *retval;
  retval = new struct PacketTagList::TagData ();
  return retval;
}

  NS_ASSERT_MSG (Peek (tag->GetInstanceTypeId ()) == 0,
                 "Only one tag type per packet is allowed");

  push_back (tag);
  delete data;
}
#endif

Ptr<const Tag>
PacketTagList::Remove (TypeId tagType)
{
  NS_LOG_FUNCTION (this << tagType);
  
  for (iterator tag = begin (); tag != end (); tag++)
  for (struct TagData *cur = m_next; cur != 0; cur = cur->next) 
    {
      if (cur->tid == tid) 
        {
          found = true;
          tag.Deserialize (TagBuffer (cur->data, cur->data+PACKET_TAG_MAX_SIZE));
        }
    }
  if (!found) 
    {
      if ((*tag)->GetInstanceTypeId () == tagType)
    }
  struct TagData *start = 0;
  struct TagData **prevNext = &start;
  for (struct TagData *cur = m_next; cur != 0; cur = cur->next) 
    {
      if (cur->tid == tid) 
        {
          Ptr<const Tag> retval = *tag;
          erase (tag);
          return retval;
           * avoid copying each TagData located after the target id
           * and just link the already-copied list to the next tag.
           */
          continue;
        }
      struct TagData *copy = AllocData ();
      copy->tid = cur->tid;
      copy->count = 1;
      copy->next = 0;
      memcpy (copy->data, cur->data, PACKET_TAG_MAX_SIZE);
      *prevNext = copy;
      prevNext = &copy->next;
    }
  *prevNext = 0;
  RemoveAll ();
  m_next = start;
  return true;
}

  return 0;
PacketTagList::Add (const Tag &tag) const
{
  NS_LOG_FUNCTION (this << tag.GetInstanceTypeId ());
  // ensure this id was not yet added
  for (struct TagData *cur = m_next; cur != 0; cur = cur->next) 
    {
      NS_ASSERT (cur->tid != tag.GetInstanceTypeId ());
    }
  struct TagData *head = AllocData ();
  head->count = 1;
  head->next = 0;
  head->tid = tag.GetInstanceTypeId ();
  head->next = m_next;
  NS_ASSERT (tag.GetSerializedSize () <= PACKET_TAG_MAX_SIZE);
  tag.Serialize (TagBuffer (head->data, head->data+tag.GetSerializedSize ()));

  const_cast<PacketTagList *> (this)->m_next = head;
}

Ptr<const Tag>
PacketTagList::Peek (TypeId tagType) const
{
  NS_LOG_FUNCTION (this << tagType);
  for (const_iterator tag = begin (); tag != end (); tag++)
  for (struct TagData *cur = m_next; cur != 0; cur = cur->next) 
    {
      if ((*tag)->GetInstanceTypeId () == tagType)
        return *tag;
          /* found tag */
          tag.Deserialize (TagBuffer (cur->data, cur->data+PACKET_TAG_MAX_SIZE));
          return true;
        }
    }
  /* no tag found */
  return false;
}

  return 0;
PacketTagList::Head (void) const
{
  return m_next;
}


// bool
// PacketTagList::Remove (Tag &tag)
// {
//   NS_LOG_FUNCTION (this << tag.GetInstanceTypeId ());

//   return false;
  
//   // TypeId tid = tag.GetInstanceTypeId ();
//   // bool found = false;
//   // for (struct TagData *cur = m_next; cur != 0; cur = cur->next) 
//   //   {
//   //     if (cur->tid == tid) 
//   //       {
//   //         found = true;
//   //         tag.Deserialize (TagBuffer (cur->data, cur->data+PACKET_TAG_MAX_SIZE));
//   //       }
//   //   }
//   // if (!found) 
//   //   {
//   //     return false;
//   //   }
//   // struct TagData *start = 0;
//   // struct TagData **prevNext = &start;
//   // for (struct TagData *cur = m_next; cur != 0; cur = cur->next) 
//   //   {
//   //     if (cur->tid == tid) 
//   //       {
//   //         /**
//   //          * XXX
//   //          * Note: I believe that we could optimize this to
//   //          * avoid copying each TagData located after the target id
//   //          * and just link the already-copied list to the next tag.
//   //          */
//   //         continue;
//   //       }
//   //     struct TagData *copy = AllocData ();
//   //     copy->tid = cur->tid;
//   //     copy->count = 1;
//   //     copy->next = 0;
//   //     memcpy (copy->data, cur->data, PACKET_TAG_MAX_SIZE);
//   //     *prevNext = copy;
//   //     prevNext = &copy->next;
//   //   }
//   // *prevNext = 0;
//   // RemoveAll ();
//   // m_next = start;
//   // return true;
// }

// void 
// PacketTagList::Add (const Tag &tag) const
// {
//   NS_LOG_FUNCTION (this << tag.GetInstanceTypeId ());
//   // ensure this id was not yet added

//   // for (struct TagData *cur = m_next; cur != 0; cur = cur->next) 
//   //   {
//   //     NS_ASSERT (cur->tid != tag.GetInstanceTypeId ());
//   //   }

//   // struct TagData *head = AllocData ();
//   // head->count = 1;
//   // head->next = 0;
//   // head->tid = tag.GetInstanceTypeId ();
//   // head->next = m_next;
//   // NS_ASSERT (tag.GetSerializedSize () <= PACKET_TAG_MAX_SIZE);
//   // tag.Serialize (TagBuffer (head->data, head->data+tag.GetSerializedSize ()));

//   // const_cast<PacketTagList *> (this)->m_next = head;

//   // m_tags.
// }

// bool
// PacketTagList::Peek (Tag &tag) const
// {
//   NS_LOG_FUNCTION (this << tag.GetInstanceTypeId ());
//   // TypeId tid = tag.GetInstanceTypeId ();
//   // for (struct TagData *cur = m_next; cur != 0; cur = cur->next) 
//   //   {
//   //     if (cur->tid == tid) 
//   //       {
//   //         /* found tag */
//   //         tag.Deserialize (TagBuffer (cur->data, cur->data+PACKET_TAG_MAX_SIZE));
//   //         return true;
//   //       }
//   //   }
  
//   /* no tag found */
//   return false;
// }

// // const struct PacketTagList::TagData *
// // PacketTagList::Head (void) const
// // {
// //   return m_next;
// // }

} // namespace ns3





#define PACKET_TAG_LIST_H

#include <stdint.h>
#include <list>
#include "ns3/type-id.h"

namespace ns3 {

 * The maximum size (in bytes) of a Tag is stored
 * in this constant.
 */
// #define PACKET_TAG_MAX_SIZE 20

class PacketTagList : public std::list<Ptr<const Tag> >
{
public:
  // struct TagData {
  //   std::vector<uint8_t> data;
  //   TypeId tid;
  //   uint32_t count;
  // };
  };

  // inline PacketTagList ();
  // inline PacketTagList (PacketTagList const &o);
  // inline PacketTagList &operator = (PacketTagList const &o);
  // inline ~PacketTagList ();

  void
  Add (Ptr<const Tag> tag);
  bool Peek (Tag &tag) const;
  inline void RemoveAll (void);

  Ptr<const Tag>
  Remove (TypeId tagType);

  Ptr<const Tag>
  Peek (TypeId tagType) const;
  bool Remove (TypeId tid);
  struct PacketTagList::TagData *AllocData (void) const;
  void FreeData (struct TagData *data) const;

  static struct PacketTagList::TagData *g_free;
  static uint32_t g_nfree;

  struct TagData *m_next;
};

} // namespace ns3


namespace ns3 {

// PacketTagList::PacketTagList ()
// {
// }

// PacketTagList::PacketTagList (PacketTagList const &o)
//   : m_tags (o.m_tags)
// {
// }

// PacketTagList &
// PacketTagList::operator = (PacketTagList const &o)
// {
//   // self assignment
//   if (&o == this)
//     {
//       return *this;
//     }
//   // RemoveAll (); // ???
//   m_tags = o.m_tags;
//   return *this;
// }

// PacketTagList::~PacketTagList ()
// {
//   RemoveAll ();
// }

// void
// PacketTagList::RemoveAll (void)
// {
//   m_tags.clear ();
// }
{
  RemoveAll ();
}

void
PacketTagList::RemoveAll (void)
{
  struct TagData *prev = 0;
  for (struct TagData *cur = m_next; cur != 0; cur = cur->next) 
    {
      cur->count--;
      if (cur->count > 0) 
        {
          break;
        }
      if (prev != 0) 
        {
          FreeData (prev);
        }
      prev = cur;
    }
  if (prev != 0) 
    {
      FreeData (prev);
    }
  m_next = 0;
}

} // namespace ns3





}


// PacketTagIterator::PacketTagIterator (const struct PacketTagList::TagData *head)
//   : m_current (head)
// {
// }
// bool
// PacketTagIterator::HasNext (void) const
// {
//   return m_current != 0;
// }
// PacketTagIterator::Item
// PacketTagIterator::Next (void)
// {
//   NS_ASSERT (HasNext ());
//   const struct PacketTagList::TagData *prev = m_current;
//   m_current = m_current->next;
//   return PacketTagIterator::Item (prev);
// }

// PacketTagIterator::Item::Item (const struct PacketTagList::TagData *data)
//   : m_data (data)
// {
// }
// TypeId
// PacketTagIterator::Item::GetTypeId (void) const
// {
//   return m_data->tid;
// }
// void
// PacketTagIterator::Item::GetTag (Tag &tag) const
// {
//   NS_ASSERT (tag.GetInstanceTypeId () == m_data->tid);
//   tag.Deserialize (TagBuffer ((uint8_t*)m_data->data, (uint8_t*)m_data->data+PACKET_TAG_MAX_SIZE));
// }


Ptr<Packet> 

  return false;
}

// void 
// Packet::AddPacketTag (const Tag &tag) const
// {
//   NS_LOG_FUNCTION (this << tag.GetInstanceTypeId ().GetName () << tag.GetSerializedSize ());
//   m_packetTagList.Add (tag);
// }
// bool 
// Packet::RemovePacketTag (Tag &tag)
// {
//   NS_LOG_FUNCTION (this << tag.GetInstanceTypeId ().GetName () << tag.GetSerializedSize ());
//   bool found = m_packetTagList.Remove (tag);
//   return found;
// }
// bool 
// Packet::PeekPacketTag (Tag &tag) const
// {
//   bool found = m_packetTagList.Peek (tag);
//   return found;
// }

void
Packet::AddPacketTag (Ptr<const Tag> tag)
{
  NS_LOG_FUNCTION (this << tag.GetInstanceTypeId ().GetName () << tag.GetSerializedSize ());
  m_packetTagList.Add (tag);
}

Ptr<const Tag>
Packet::RemovePacketTag (TypeId tagType)
{
  return m_packetTagList.Remove (tagType);
  bool found = m_packetTagList.Remove (tag);
  return found;
}

Ptr<const Tag>
Packet::PeekPacketTag (TypeId tagType) const
{
  return m_packetTagList.Peek (tagType);
  return found;
}

void 
Packet::RemoveAllPacketTags (void)
{
  NS_LOG_FUNCTION (this);
  m_packetTagList.clear ();
}

void 
Packet::PrintPacketTags (std::ostream &os) const
{
  for (PacketTagList::const_iterator tag = m_packetTagList.begin ();
       tag != m_packetTagList.end ();
       tag++)
    {
      if (tag != m_packetTagList.begin ())
      NS_ASSERT (item.GetTypeId ().HasConstructor ());
      Callback<ObjectBase *> constructor = item.GetTypeId ().GetConstructor ();
      NS_ASSERT (!constructor.IsNull ());
      ObjectBase *instance = constructor ();
      Tag *tag = dynamic_cast<Tag *> (instance);
      NS_ASSERT (tag != 0);
      item.GetTag (*tag);
      tag->Print (os);
      delete tag;
      if (i.HasNext ())
        {
          os << " ";
        }
    }
}

      (*tag)->Print (os);
    }
  // PacketTagIterator i = GetPacketTagIterator ();
  // while (i.HasNext ())
  //   {
  //     PacketTagIterator::Item item = i.Next ();
  //     NS_ASSERT (item.GetTypeId ().HasConstructor ());
  //     Callback<ObjectBase *> constructor = item.GetTypeId ().GetConstructor ();
  //     NS_ASSERT (!constructor.IsNull ());
  //     ObjectBase *instance = constructor ();
  //     Tag *tag = dynamic_cast<Tag *> (instance);
  //     NS_ASSERT (tag != 0);
  //     item.GetTag (*tag);
  //     tag->Print (os);
  //     delete tag;
  //     if (i.HasNext ())
  //       {
  //         os << " ";
  //       }
  //   }
}

// PacketTagIterator 
// Packet::GetPacketTagIterator (void) const
// {
//   return PacketTagIterator (m_packetTagList.Head ());
// }

std::ostream& operator<< (std::ostream& os, const Packet &packet)
{




  ByteTagList::Iterator m_current;
};

// /**
//  * \ingroup packet
//  * \brief Iterator over the set of 'packet' tags in a packet
//  *
//  * This is a java-style iterator.
//  */
// class PacketTagIterator
// {
// public:
//   /**
//    * Identifies a tag within a packet.
//    */
//   class Item 
//   {
// public:
//     /**
//      * \returns the ns3::TypeId associated to this tag.
//      */
//     TypeId GetTypeId (void) const;
//     /**
//      * \param tag the user tag to which the data should be copied.
//      *
//      * Read the requested tag and store it in the user-provided
//      * tag instance. This method will crash if the type of the
//      * tag provided by the user does not match the type of
//      * the underlying tag.
//      */
//     void GetTag (Tag &tag) const;
// private:
//     friend class PacketTagIterator;
//     Item (const struct PacketTagList::TagData *data);
//     const struct PacketTagList::TagData *m_data;
//   };
//   /**
//    * \returns true if calling Next is safe, false otherwise.
//    */
//   bool HasNext (void) const;
//   /**
//    * \returns the next item found and prepare for the next one.
//    */
//   Item Next (void);
// private:
//   friend class Packet;
//   PacketTagIterator (const struct PacketTagList::TagData *head);
//   const struct PacketTagList::TagData *m_current;
// };

/**
 * \ingroup packet

   */
  void PrintByteTags (std::ostream &os) const;

  void
  AddPacketTag (Ptr<const Tag> tag);

  Ptr<const Tag>
  RemovePacketTag (TypeId tagType);

  template<class T>
  Ptr<const T>
  RemovePacketTag ()
  {
    return DynamicCast<const T> (RemovePacketTag (T::GetTypeId ()));
  }
  
  Ptr<const Tag>
  PeekPacketTag (TypeId tagType) const;

  template<class T>
  Ptr<const T>
  PeekPacketTag () const
  {
    return DynamicCast<const T> (PeekPacketTag (T::GetTypeId ()));
  }
  
  // /**
  //  * \param tag the tag to store in this packet
  //  *
  //  * Add a tag to this packet. This method calls the
  //  * Tag::GetSerializedSize and, then, Tag::Serialize.
  //  *
  //  * Note that this method is const, that is, it does not
  //  * modify the state of this packet, which is fairly
  //  * un-intuitive.
  //  */
  // void AddPacketTag (const Tag &tag) const;
  // /**
  //  * \param tag the tag to remove from this packet
  //  * \returns true if the requested tag is found, false
  //  *          otherwise.
  //  *
  //  * Remove a tag from this packet. This method calls
  //  * Tag::Deserialize if the tag is found.
  //  */
  // bool RemovePacketTag (Tag &tag);
  // /**
  //  * \param tag the tag to search in this packet
  //  * \returns true if the requested tag is found, false
  //  *          otherwise.
  //  *
  //  * Search a matching tag and call Tag::Deserialize if it is found.
  //  */
  // bool PeekPacketTag (Tag &tag) const;
  /**
   * Remove all packet tags.
   */

   * \returns an object which can be used to iterate over the list of
   *  packet tags.
   */
  // PacketTagIterator GetPacketTagIterator (void) const;

  /* Note: These functions support a temporary solution 
   * to a specific problem in this generic class, i.e. 

(-)a/src/network/model/tag.h (-2 / +9 lines)

Lines 20-26	Link Here

#ifndef TAG_H

#ifndef TAG_H

#define TAG_H

#define TAG_H

#include "ns3/object-base.h"

#include "ns3/object.h"

#include "tag-buffer.h"

#include "tag-buffer.h"

#include <stdint.h>

#include <stdint.h>

Lines 33-39 namespace ns3 {	Link Here

 * New kinds of tags can be created by subclassing this base class.

 * New kinds of tags can be created by subclassing this base class.

*/

*/

class Tag : public ObjectBase

class Tag : public Object

public:

public:

  static TypeId GetTypeId (void);

  static TypeId GetTypeId (void);

Lines 71-76 public:	Link Here

  virtual void Print (std::ostream &os) const = 0;

  virtual void Print (std::ostream &os) const = 0;

};

};

inline std::ostream &

operator << (std::ostream &os, const Tag &tag)

  tag.Print (os);

  return os;

} // namespace ns3

} // namespace ns3

#endif /* TAG_H */

#endif /* TAG_H */




  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