NS_LOG_FUNCTION (this << tft);

  NS_LOG_FUNCTION (this << tft << id);

  if (direction ==  EpcTft::UPLINK)

  // Added to be able to classify fragmented packets

    {

  // The map key is taken from the Ipv4L3Protocol::ProcessFragment method

      localAddress = ipv4Header.GetSource ();

  // as it is the method used to keep track of fragmented IP packets

      remoteAddress = ipv4Header.GetDestination ();

  uint64_t addressCombination = uint64_t (ipv4Header.GetSource ().Get ()) << 32 | 

    }

                                uint64_t (ipv4Header.GetDestination ().Get ());

  else

  uint32_t idProto = uint32_t (ipv4Header.GetIdentification ()) << 16 | 

    { 

                     uint32_t (ipv4Header.GetProtocol ());

      NS_ASSERT (direction ==  EpcTft::DOWNLINK);

  std::pair <uint64_t, uint32_t> key;

      remoteAddress = ipv4Header.GetSource ();

  key.first = addressCombination;

      localAddress = ipv4Header.GetDestination ();      

  key.second = idProto;

    }

  // If an extry exists in the map, it means we already 

  uint8_t protocol = ipv4Header.GetProtocol ();

  // classified the first fragment.

  uint32_t teid = 0;

  uint8_t tos = ipv4Header.GetTos ();

  std::map <std::pair <uint64_t, uint32_t>, uint32_t>::iterator it = m_classifiedIpv4Fragments.find (key);

  uint16_t localPort = 0;

  if (it != m_classifiedIpv4Fragments.end ())

  uint16_t remotePort = 0;

  if (protocol == UdpL4Protocol::PROT_NUMBER)

      UdpHeader udpHeader;

      // The entry exists, so we use the teid stored 

      pCopy->RemoveHeader (udpHeader);

      // when the first fragment was classified

      teid = it->second;

      if (direction ==  EpcTft::UPLINK)

	{

      // If this is the last fragment, delete the entry. 

	  localPort = udpHeader.GetSourcePort ();

      // It is possible that the last fragment arrives before all intermediate

	  remotePort = udpHeader.GetDestinationPort ();

      // fragments have been classified; in this case, those intermediate fragments

	}

      // will be sent through the default bearer.

      else

      //

	{

      // Also, as this is the only mechanism to delete entries from the map, it is

	  remotePort = udpHeader.GetSourcePort ();

      // possible that if the last fragment is received before the first fragment,

	  localPort = udpHeader.GetDestinationPort ();

      // an entry is never deleted.

	}

      // 

    }

      // It is possible to address these two potential issues with a stateful 

  else if (protocol == TcpL4Protocol::PROT_NUMBER)

      // classifier.

    {

      if (ipv4Header.IsLastFragment ())

      TcpHeader tcpHeader;

        {

      pCopy->RemoveHeader (tcpHeader);

          m_classifiedIpv4Fragments.erase (key);

      if (direction ==  EpcTft::UPLINK)

        }

	{

	  localPort = tcpHeader.GetSourcePort ();

	  remotePort = tcpHeader.GetDestinationPort ();

	}

      else

	{

	  remotePort = tcpHeader.GetSourcePort ();

	  localPort = tcpHeader.GetDestinationPort ();

	}

      NS_LOG_INFO ("Unknown protocol: " << protocol);

      // There is no entry in the map.

      return 0;  // no match

      // Now we have three options:

    }

      //   - This is not the first fragment. We send it through the

      //   default bearer.

      //   - This is the first fragment  but it is not big enough to 

      //   hold all the information we may need from L4 for a classification. 

      //   In this case we send all the fragments through the default bearer.

      //   - This is the first fragment and we can obtain all information

      //   we may need for the classification from L4, so we classify as usual.

      uint16_t payloadSize = ipv4Header.GetPayloadSize ();

  NS_LOG_INFO ("Classifing packet:"

      if (ipv4Header.GetFragmentOffset () > 0 )

	       << " localAddr="  << localAddress 

	       << " remoteAddr=" << remoteAddress 

	       << " localPort="  << localPort 

	       << " remotePort=" << remotePort 

	       << " tos=0x" << (uint16_t) tos );

  // now it is possible to classify the packet!

  // we use a reverse iterator since filter priority is not implemented properly.

  // This way, since the default bearer is expected to be added first, it will be evaluated last.

  std::map <uint32_t, Ptr<EpcTft> >::const_reverse_iterator it;

  NS_LOG_LOGIC ("TFT MAP size: " << m_tftMap.size ());

  for (it = m_tftMap.rbegin (); it != m_tftMap.rend (); ++it)

    {

      NS_LOG_LOGIC ("TFT id: " << it->first );

      NS_LOG_LOGIC (" Ptr<EpcTft>: " << it->second);

      Ptr<EpcTft> tft = it->second;         

      if (tft->Matches (direction, remoteAddress, localAddress, remotePort, localPort, tos))

	  NS_LOG_LOGIC ("matches with TFT ID = " << it->first);

          // Not the first fragment.

	  return it->first; // the id of the matching TFT

          teid = m_tftMap.begin ()->first;

        }

      else 

        {

          uint8_t protocol = ipv4Header.GetProtocol ();

          uint8_t tos = ipv4Header.GetTos ();

          uint16_t localPort = 0;

          uint16_t remotePort = 0;

          if ( (protocol == UdpL4Protocol::PROT_NUMBER && payloadSize < 8) || 

              (protocol == TcpL4Protocol::PROT_NUMBER && payloadSize < 20) )

            {

              // First fragment, but with not enough information to classify it.

              // The whole packet will be sent through the default bearer.

              teid = m_tftMap.begin ()->first;

              m_classifiedIpv4Fragments.insert (std::make_pair (key, teid));

            }

          else 

            {

              // First fragment. Classify as usual.

              if (direction ==  EpcTft::UPLINK)

                {

                  localAddress = ipv4Header.GetSource ();

                  remoteAddress = ipv4Header.GetDestination ();

                }

              else

                { 

                  NS_ASSERT (direction ==  EpcTft::DOWNLINK);

                  remoteAddress = ipv4Header.GetSource ();

                  localAddress = ipv4Header.GetDestination ();      

                }

              if (protocol == UdpL4Protocol::PROT_NUMBER)

                {

                  UdpHeader udpHeader;

                  pCopy->RemoveHeader (udpHeader);

                  if (direction ==  EpcTft::UPLINK)

                    {

                      localPort = udpHeader.GetSourcePort ();

                      remotePort = udpHeader.GetDestinationPort ();

                    }

                  else

                    {

                      remotePort = udpHeader.GetSourcePort ();

                      localPort = udpHeader.GetDestinationPort ();

                    }

                }

              else if (protocol == TcpL4Protocol::PROT_NUMBER)

                {

                  TcpHeader tcpHeader;

                  pCopy->RemoveHeader (tcpHeader);

                  if (direction ==  EpcTft::UPLINK)

                    {

                      localPort = tcpHeader.GetSourcePort ();

                      remotePort = tcpHeader.GetDestinationPort ();

                    }

                  else

                    {

                      remotePort = tcpHeader.GetSourcePort ();

                      localPort = tcpHeader.GetDestinationPort ();

                    }

                }

              else

                {

                  NS_LOG_INFO ("Unknown protocol: " << protocol);

                  return 0;  // no match

                }

              NS_LOG_INFO ("Classifing packet:"

                  << " localAddr="  << localAddress 

                  << " remoteAddr=" << remoteAddress 

                  << " localPort="  << localPort 

                  << " remotePort=" << remotePort 

                  << " tos=0x" << (uint16_t) tos );

              // now it is possible to classify the packet!

              // we use a reverse iterator since filter priority is not implemented properly.

              // This way, since the default bearer is expected to be added first, it will be evaluated last.

              std::map <uint32_t, Ptr<EpcTft> >::const_reverse_iterator it;

              NS_LOG_LOGIC ("TFT MAP size: " << m_tftMap.size ());

              for (it = m_tftMap.rbegin (); it != m_tftMap.rend () && teid == 0; ++it)

                {

                  NS_LOG_LOGIC ("TFT id: " << it->first );

                  NS_LOG_LOGIC (" Ptr<EpcTft>: " << it->second);

                  Ptr<EpcTft> tft = it->second;         

                  if (tft->Matches (direction, remoteAddress, localAddress, remotePort, localPort, tos))

                    {

                      NS_LOG_LOGIC ("matches with TFT ID = " << it->first);

                      teid = it->first; // the id of the matching TFT

                      // If there are going to be more fragments, create an entry 

                      // in the map with the classified IP fragments

                      if (! ipv4Header.IsLastFragment ())

                        {

                          m_classifiedIpv4Fragments.insert (std::make_pair (key, teid));

                        }

                    }

                }

            }

  NS_LOG_LOGIC ("no match");

  return 0;  // no match

  return teid;  // will be 0 if there is no match