Attachment #2874 for bug #2758

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




    and <b>WifiPhy::MaxSupportedRxSpatialStreams</b>. A new attribute <b>WifiPhy::Antennas</b>
    was added to allow users to define the number of physical antennas on the device.
</li>
<li>Sockets do not receive anymore broadcast packets, unless they are bound to an "Any" address (0.0.0.0)
    or to a subnet-directed broadcast packet (e.g., x.y.z.0 for a /24 noterok).
    As in Linux, the following rules are now enforced:
    <ul>
    <li> A socket bound to 0.0.0.0 will receive everything.</li>
    <li> A socket bound to x.y.z.0/24 will receive subnet-directed broadcast (x.y.z.255) and unicast packets.</li>
    <li> A socket bound to x.y.z.w will only receive unicast packets.</li>
    </ul> 
    <b>Previously, a socket bound to an unicast address received also subnet-directed broadcast packets. 
    This is not anymore possible</b>.
</li>
</ul>
<h2>Changes to build system:</h2>
<ul>




  EndPoints retval3; // Matches all but local address
  EndPoints retval4; // Exact match on all 4

  NS_LOG_DEBUG ("Looking up endpoint for destination address " << daddr << ":" << dport);
  for (EndPointsI i = m_endPoints.begin (); i != m_endPoints.end (); i++) 
    {
      Ipv4EndPoint* endP = *i;

              continue;
            }
        }

      bool localAddressMatchesExact = false;
      bool localAddressIsAny = false;
      bool localAddressIsSubnetAny = false;

      // We have 3 cases:
      // 1) Exact local / destination address match
      // 2) Local endpoint bound to Any -> matches anything
      // 3) Local endpoint bound to x.y.z.0 -> matches Subnet-directed broadcast packet (e.g., x.y.z.255 in a /24 net) and direct destination match.

      if (endP->GetLocalAddress () == daddr)
        {
          // Case 1:
          localAddressMatchesExact = true;
        }
      else if (endP->GetLocalAddress () == Ipv4Address::GetAny ())
        {
          // Case 2:
          localAddressIsAny = true;
        }
      else
        {
          // Case 3:
          for (uint32_t i = 0; i < incomingInterface->GetNAddresses (); i++)
            {
              Ipv4InterfaceAddress addr = incomingInterface->GetAddress (i);

              Ipv4Address addrNetpart = addr.GetLocal ().CombineMask (addr.GetMask ());
              if (endP->GetLocalAddress () == addrNetpart)
                {
                  NS_LOG_LOGIC ("Endpoint is SubnetDirectedAny " << endP->GetLocalAddress () << "/" << addr.GetMask ().GetPrefixLength ());

                  Ipv4Address daddrNetPart = daddr.CombineMask (addr.GetMask ());
                  if (addrNetpart == daddrNetPart)
                    {
                      localAddressIsSubnetAny = true;
                    }
                }
            }
        }
      bool isBroadcast = (daddr.IsBroadcast () || subnetDirected == true);
      NS_LOG_DEBUG ("dest addr " << daddr << " broadcast? " << isBroadcast);
      bool localAddressMatchesWildCard = 
        endP->GetLocalAddress () == Ipv4Address::GetAny ();
      bool localAddressMatchesExact = endP->GetLocalAddress () == daddr;

          // if no match here, keep looking
          if (!localAddressIsSubnetAny)
            continue;
        }

      bool remotePortMatchesExact = endP->GetPeerPort () == sport;
      bool remotePortMatchesWildCard = endP->GetPeerPort () == 0;
          localAddressMatchesExact = (endP->GetLocalAddress () ==
                                      incomingInterfaceAddr);
        }
      // if no match here, keep looking
      if (!(localAddressMatchesExact || localAddressMatchesWildCard))
        continue; 
      bool remotePeerMatchesExact = endP->GetPeerPort () == sport;
      bool remotePeerMatchesWildCard = endP->GetPeerPort () == 0;
      bool remoteAddressMatchesExact = endP->GetPeerAddress () == saddr;
      bool remoteAddressMatchesWildCard = endP->GetPeerAddress () == Ipv4Address::GetAny ();

      // If remote does not match either with exact or wildcard,
      // skip this one
      if (!(remotePortMatchesExact || remotePortMatchesWildCard))
        continue;
      if (!(remoteAddressMatchesExact || remoteAddressMatchesWildCard))
        continue;

      bool localAddressMatchesWildCard = localAddressIsAny || localAddressIsSubnetAny;

//      std::cout << " *** Last checks " << endP->GetLocalAddress () << ":" << endP->GetLocalPort () <<
//          " " << localAddressMatchesExact <<
//          " " << localAddressMatchesWildCard <<
//          " " << remoteAddressMatchesExact <<
//          " " << remoteAddressMatchesWildCard <<
//          " " << remotePortMatchesExact <<
//          " " << remotePortMatchesWildCard << std::endl;


      if (localAddressMatchesExact && remoteAddressMatchesExact && remotePortMatchesExact)
        { // All 4 match - this is the case of an open TCP connection, for example.
          NS_LOG_LOGIC ("Found an endpoint for case 4, adding " << endP->GetLocalAddress () << ":" << endP->GetLocalPort ());
//          std::cout << "Found an endpoint for case 4, adding " << endP->GetLocalAddress () << ":" << endP->GetLocalPort () << std::endl;
          retval4.push_back (endP);
        }
      if (localAddressMatchesWildCard && remoteAddressMatchesExact && remotePortMatchesExact)
        { // All but local address - no idea what this case could be.
          NS_LOG_LOGIC ("Found an endpoint for case 3, adding " << endP->GetLocalAddress () << ":" << endP->GetLocalPort ());
//          std::cout << "Found an endpoint for case 3, adding " << endP->GetLocalAddress () << ":" << endP->GetLocalPort () << std::endl;
          retval3.push_back (endP);
        }
      if (localAddressMatchesExact && remoteAddressMatchesWildCard && remotePortMatchesWildCard)
        { // Only local port and local address matches exactly - Not yet opened connection
          NS_LOG_LOGIC ("Found an endpoint for case 2, adding " << endP->GetLocalAddress () << ":" << endP->GetLocalPort ());
//          std::cout << "Found an endpoint for case 2, adding " << endP->GetLocalAddress () << ":" << endP->GetLocalPort () << std::endl;
          retval2.push_back (endP);
        }
      if (localAddressMatchesWildCard && remoteAddressMatchesWildCard && remotePortMatchesWildCard)
        { // Only local port matches exactly - Endpoint open to "any" connection
          NS_LOG_LOGIC ("Found an endpoint for case 1, adding " << endP->GetLocalAddress () << ":" << endP->GetLocalPort ());
//          std::cout << "Found an endpoint for case 1, adding " << endP->GetLocalAddress () << ":" << endP->GetLocalPort () << std::endl;
          retval1.push_back (endP);
        }
      if (localAddressMatchesExact &&
          remotePeerMatchesExact &&
          remoteAddressMatchesExact)
        { // All 4 match
          retval4.push_back (endP);
        }
    }





              if (ipv4->GetNetDevice (i) != m_boundnetdevice)
                continue;
            }
          NS_LOG_LOGIC ("Sending one copy from " << addri << " to " << dest);
          m_udp->Send (p->Copy (), addri, dest,
                       m_endPoint->GetLocalPort (), port);
          NotifyDataSent (p->GetSize ());
          NotifySend (GetTxAvailable ());
                                                     << " (mask is " << maski << ")");
              m_udp->Send (p->Copy (), addri, dest,
                           m_endPoint->GetLocalPort (), port);
              NotifyDataSent (p->GetSize ());
              NotifySend (GetTxAvailable ());
            }
          else
            {
              // Convert to subnet-directed broadcast
              Ipv4Address bcast = addri.GetSubnetDirectedBroadcast (maski);
              NS_LOG_LOGIC ("Sending one copy from " << addri << " to " << bcast
                                                     << " (mask is " << maski << ")");
              m_udp->Send (p->Copy (), addri, bcast,
                           m_endPoint->GetLocalPort (), port);
              NotifyDataSent (p->GetSize ());
              NotifySend (GetTxAvailable ());
            }
        }
      NS_LOG_LOGIC ("Limited broadcast end.");
      return p->GetSize ();




  // Receiver Node
  ipv4 = rxNode->GetObject<Ipv4> ();
  netdev_idx = ipv4->AddInterface (net1.Get (0));
  ipv4Addr = Ipv4InterfaceAddress (Ipv4Address ("10.0.0.1"), Ipv4Mask ("/24"));
  ipv4->AddAddress (netdev_idx, ipv4Addr);
  ipv4->SetUp (netdev_idx);

  netdev_idx = ipv4->AddInterface (net2.Get (0));
  ipv4Addr = Ipv4InterfaceAddress (Ipv4Address ("10.0.1.1"), Ipv4Mask ("/24"));
  ipv4->AddAddress (netdev_idx, ipv4Addr);
  ipv4->SetUp (netdev_idx);

  // Sender Node
  ipv4 = txNode->GetObject<Ipv4> ();
  netdev_idx = ipv4->AddInterface (net1.Get (1));
  ipv4Addr = Ipv4InterfaceAddress (Ipv4Address ("10.0.0.2"), Ipv4Mask ("/24"));
  ipv4->AddAddress (netdev_idx, ipv4Addr);
  ipv4->SetUp (netdev_idx);

  netdev_idx = ipv4->AddInterface (net2.Get (1));
  ipv4Addr = Ipv4InterfaceAddress (Ipv4Address ("10.0.1.2"), Ipv4Mask ("/24"));
  ipv4->AddAddress (netdev_idx, ipv4Addr);
  ipv4->SetUp (netdev_idx);

  // Create the UDP sockets
  Ptr<SocketFactory> rxSocketFactory = rxNode->GetObject<UdpSocketFactory> ();

  Ptr<Socket> rxSocket = rxSocketFactory->CreateSocket ();
  NS_TEST_EXPECT_MSG_EQ (rxSocket->Bind (InetSocketAddress (Ipv4Address ("10.0.0.1"), 1234)), 0, "trivial");
  rxSocket->SetRecvCallback (MakeCallback (&UdpSocketImplTest::ReceivePkt, this));

  Ptr<Socket> rxSocket2 = rxSocketFactory->CreateSocket ();
  NS_TEST_EXPECT_MSG_EQ (rxSocket2->Bind (InetSocketAddress (Ipv4Address ("10.0.1.1"), 1234)), 0, "trivial");
  rxSocket2->SetRecvCallback (MakeCallback (&UdpSocketImplTest::ReceivePkt2, this));
  NS_TEST_EXPECT_MSG_EQ (rxSocket2->Bind (InetSocketAddress (Ipv4Address ("10.0.1.1"), 1234)), 0, "trivial");

  Ptr<SocketFactory> txSocketFactory = txNode->GetObject<UdpSocketFactory> ();
  Ptr<Socket> txSocket = txSocketFactory->CreateSocket ();

  // Unicast test
  SendDataTo (txSocket, "10.0.0.1");
  NS_TEST_EXPECT_MSG_EQ (m_receivedPacket->GetSize (), 123, "trivial");
  NS_TEST_EXPECT_MSG_EQ (m_receivedPacket2->GetSize (), 0, "second interface should not receive it");

  m_receivedPacket->RemoveAllByteTags ();
  m_receivedPacket2->RemoveAllByteTags ();

  // Simple broadcast test

  SendDataTo (txSocket, "255.255.255.255");
  NS_TEST_EXPECT_MSG_EQ (m_receivedPacket->GetSize (), 0, "first socket should not receive it (it is bound specifically to the first interface's address");
  NS_TEST_EXPECT_MSG_EQ (m_receivedPacket2->GetSize (), 0, "second socket should not receive it (it is bound specifically to the second interface's address");

  m_receivedPacket->RemoveAllByteTags ();

  NS_TEST_EXPECT_MSG_EQ (rxSocket2->Bind (InetSocketAddress (Ipv4Address ("0.0.0.0"), 1234)), 0, "trivial");

  SendDataTo (txSocket, "255.255.255.255");
  NS_TEST_EXPECT_MSG_EQ (m_receivedPacket->GetSize (), 0, "first socket should not receive it (it is bound specifically to the first interface's address");
  NS_TEST_EXPECT_MSG_EQ (m_receivedPacket2->GetSize (), 123, "trivial");

  m_receivedPacket = 0;


  txSocket->BindToNetDevice (net1.Get (1));
  SendDataTo (txSocket, "224.0.0.9");
  NS_TEST_EXPECT_MSG_EQ (m_receivedPacket->GetSize (), 0, "first socket should not receive it (it is bound specifically to the first interface's address");
  NS_TEST_EXPECT_MSG_EQ (m_receivedPacket2->GetSize (), 123, "recv2: 224.0.0.9");

  m_receivedPacket->RemoveAllByteTags ();

Return to bug 2758