Attachment #2198 for bug #2234

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




        {
          Ipv6InterfaceAddress ifaddr = Ipv6InterfaceAddress (Ipv6Address::MakeAutoconfiguredLinkLocalAddress (Mac64Address::ConvertFrom (addr)), Ipv6Prefix (64));
          AddAddress (ifaddr);
          m_linkLocalAddress = ifaddr;
        }
      else if (Mac48Address::IsMatchingType (addr))
        {
          Ipv6InterfaceAddress ifaddr = Ipv6InterfaceAddress (Ipv6Address::MakeAutoconfiguredLinkLocalAddress (Mac48Address::ConvertFrom (addr)), Ipv6Prefix (64));
          AddAddress (ifaddr);
          m_linkLocalAddress = ifaddr;
        }
      else if (Mac16Address::IsMatchingType (addr))
        {
          Ipv6InterfaceAddress ifaddr = Ipv6InterfaceAddress (Ipv6Address::MakeAutoconfiguredLinkLocalAddress (Mac16Address::ConvertFrom (addr)), Ipv6Prefix (64));
          AddAddress (ifaddr);
          m_linkLocalAddress = ifaddr;
        }
      else
        {

    {
      for (Ipv6InterfaceAddressListCI it = m_addresses.begin (); it != m_addresses.end (); ++it)
        {
          if (it->first.GetAddress () == addr)
            {
              return false;
            }
        }

      Ipv6Address solicited = Ipv6Address::MakeSolicitedAddress (iface.GetAddress ());
      m_addresses.push_back (std::make_pair (iface, solicited));

      if (!addr.IsAny () || !addr.IsLocalhost ())
        {

  /* IPv6 interface has always at least one IPv6 link-local address */
  NS_LOG_FUNCTION_NOARGS ();

  return m_linkLocalAddress;
}

bool Ipv6Interface::IsSolicitedMulticastAddress (Ipv6Address address) const
{
  /* IPv6 interface has always at least one IPv6 Solicited Multicast address */
  NS_LOG_FUNCTION_NOARGS ();

  for (Ipv6InterfaceAddressListCI it = m_addresses.begin (); it != m_addresses.end (); ++it)
     {
       if (it->second == address)
         {
           return true;
         }
     }

  return false;
  return addr; /* quiet compiler */
}

Ipv6InterfaceAddress Ipv6Interface::GetAddress (uint32_t index) const

        {
          if (i == index)
            {
              return it->first;
            }
          i++;
        }

    {
      if (i == index)
        {
          Ipv6InterfaceAddress iface = it->first;
          m_addresses.erase (it);
          return iface;
        }


  for (Ipv6InterfaceAddressListI it = m_addresses.begin (); it != m_addresses.end (); ++it)
    {
      if(it->first.GetAddress () == address)
        {
          Ipv6InterfaceAddress iface = it->first;
          m_addresses.erase(it);
          return iface;
        }


  for (Ipv6InterfaceAddressList::const_iterator it = m_addresses.begin (); it != m_addresses.end (); ++it)
    {
      Ipv6InterfaceAddress ifaddr = it->first;

      if (ifaddr.GetPrefix ().IsMatch (ifaddr.GetAddress (), dst))
        {

  /* check if destination is for one of our interface */
  for (Ipv6InterfaceAddressListCI it = m_addresses.begin (); it != m_addresses.end (); ++it)
    {
      if (dest == it->first.GetAddress ())
        {
          ipv6->Receive (m_device, p, Ipv6L3Protocol::PROT_NUMBER,
                         m_device->GetBroadcast (),


  for (Ipv6InterfaceAddressListI it = m_addresses.begin (); it != m_addresses.end (); ++it)
    {
      if (it->first.GetAddress () == address)
        {
          it->first.SetState (state);
          return;
        }
    }


  for (Ipv6InterfaceAddressListI it = m_addresses.begin (); it != m_addresses.end (); ++it)
    {
      if (it->first.GetAddress () == address)
        {
          it->first.SetNsDadUid (uid);
          return;
        }
    }




  Ipv6InterfaceAddress GetLinkLocalAddress () const;

  /**
   * \brief Checks if the address is a Solicited Multicast address for this interface.
   * \param address the address to check.
   * \return true if it is a solicited multicast address.
   */
  bool IsSolicitedMulticastAddress (Ipv6Address address) const;

  /**
   * \brief Get an address from IPv6 interface.
   * \param index index
   * \return Ipv6InterfaceAddress address whose index is i

  /**
   * \brief Container for the Ipv6InterfaceAddresses.
   */
  typedef std::list<std::pair<Ipv6InterfaceAddress, Ipv6Address> > Ipv6InterfaceAddressList;

  /**
   * \brief Container Iterator for the Ipv6InterfaceAddresses.
   */
  typedef std::list<std::pair<Ipv6InterfaceAddress, Ipv6Address> >::iterator Ipv6InterfaceAddressListI;

  /**
   * \brief Const Container Iterator for the Ipv6InterfaceAddresses.
   */
  typedef std::list<std::pair<Ipv6InterfaceAddress, Ipv6Address> >::const_iterator Ipv6InterfaceAddressListCI;

  /**
   * \brief Initialize interface.

  Ipv6InterfaceAddressList m_addresses;

  /**
   * \brief The link-local addresses assigned to this interface.
   */
  Ipv6InterfaceAddress m_linkLocalAddress;

  /**
   * \brief The state of this interface.
   */
  bool m_ifup;




    }
  else
    {
      NS_LOG_LOGIC ("Interface " << int(i) << " is set to be down for IPv6. Reason: not respecting minimum IPv6 MTU (1280 octets)");
    }
}


        }
    }

  if (hdr.GetDestinationAddress ().IsAllNodesMulticast ())
  // This is wrong. We should only forward up what the node is interested into
  // and try to route anything other than ff01 or ff02.
  if (hdr.GetDestinationAddress ().IsLinkLocalMulticast ())
    {
      LocalDeliver (packet, hdr, interface);
      return;
    }
  else if (hdr.GetDestinationAddress ().IsAllRoutersMulticast() && ipv6Interface->IsForwarding ())
    {
      LocalDeliver (packet, hdr, interface);
      return;
    }
  else if (hdr.GetDestinationAddress ().IsMulticast ())
    {
      bool isSolicited = ipv6Interface->IsSolicitedMulticastAddress (hdr.GetDestinationAddress ());
      bool isRegisteredOnInterface = IsRegisteredMulticastAddress (hdr.GetDestinationAddress (), interface);
      bool isRegisteredGlobally = IsRegisteredMulticastAddress (hdr.GetDestinationAddress ());
      if (isSolicited || isRegisteredGlobally || isRegisteredOnInterface)
        {
          LocalDeliver (packet, hdr, interface);
          // do not return, the packet could be handled by a routing protocol
        }
    }


  for (uint32_t j = 0; j < GetNInterfaces (); j++)
    {

  m_dropTrace (ipHeader, p, dropReason, m_node->GetObject<Ipv6> (), 0);
}

void Ipv6L3Protocol::AddMulticastAddress (Ipv6Address address, uint32_t interface)
{
  NS_LOG_FUNCTION (address << interface);

  if (!address.IsMulticast ())
    {
      NS_LOG_LOGIC ("not adding a non-multicast address " << address);
      return;
    }

  Ipv6RegisteredMulticastAddressKey_t key = std::make_pair (address, interface);
  m_multicastAddresses[key] = true;
}

void Ipv6L3Protocol::AddMulticastAddress (Ipv6Address address)
{
  NS_LOG_FUNCTION (address);

  if (!address.IsMulticast ())
    {
      NS_LOG_LOGIC ("not adding a non-multicast address " << address);
      return;
    }

  m_multicastAddressesNoInterface[address] = true;
}

void Ipv6L3Protocol::RemoveMulticastAddress (Ipv6Address address, uint32_t interface)
{
  NS_LOG_FUNCTION (address << interface);

  Ipv6RegisteredMulticastAddressKey_t key = std::make_pair (address, interface);
  m_multicastAddresses.erase (key);
}

void Ipv6L3Protocol::RemoveMulticastAddress (Ipv6Address address)
{
  NS_LOG_FUNCTION (address);

  m_multicastAddressesNoInterface.erase (address);
}

bool Ipv6L3Protocol::IsRegisteredMulticastAddress (Ipv6Address address, uint32_t interface) const
{
  NS_LOG_FUNCTION (address << interface);

  Ipv6RegisteredMulticastAddressKey_t key = std::make_pair (address, interface);
  Ipv6RegisteredMulticastAddressCIter_t iter = m_multicastAddresses.find (key);

  if (iter == m_multicastAddresses.end ())
    {
      return false;
    }
  else if (iter->second == false)
    {
      return false;
    }
  return true;
}

bool Ipv6L3Protocol::IsRegisteredMulticastAddress (Ipv6Address address) const
{
  NS_LOG_FUNCTION (address);

  Ipv6RegisteredMulticastAddressNoInterfaceCIter_t iter = m_multicastAddressesNoInterface.find (address);

  if (iter == m_multicastAddressesNoInterface.end ())
    {
      return false;
    }
  else if (iter->second == false)
    {
      return false;
    }
  return true;
}

} /* namespace ns3 */





    (const Ipv6Header & header, Ptr<const Packet> packet,
     DropReason reason, Ptr<Ipv6> ipv6,
     uint32_t interface);

  /**
   * Adds a multicast address to the list of addresses to pass to local deliver.
   * \param address the address.
   */
  void AddMulticastAddress (Ipv6Address address);

  /**
   * Adds a multicast address to the list of addresses to pass to local deliver.
   * \param address the address.
   * \param interface the incoming interface.
   */
  void AddMulticastAddress (Ipv6Address address, uint32_t interface);

  /**
   * Removes a multicast address from the list of addresses to pass to local deliver.
   * \param address the address.
   */
  void RemoveMulticastAddress (Ipv6Address address);

  /**
   * Removes a multicast address from the list of addresses to pass to local deliver.
   * \param address the address.
   * \param interface the incoming interface.
   */
  void RemoveMulticastAddress (Ipv6Address address, uint32_t interface);

  /**
   * Checks if the address has been registered.
   * \param address the address.
   * \return true if the address is registered.
   */
  bool IsRegisteredMulticastAddress (Ipv6Address address) const;

  /**
   * Checks if the address has been registered for a specific interface.
   * \param address the address.
   * \param interface the incoming interface.
   * \return true if the address is registered.
   */
  bool IsRegisteredMulticastAddress (Ipv6Address address, uint32_t interface) const;

protected:
  /**
   * \brief Dispose object.

   * \brief Allow ICMPv6 Redirect sending state
   */
  bool m_sendIcmpv6Redirect;

  /**
   * \brief IPv6 multicast addresses / interface key.
   */
  typedef std::pair<Ipv6Address, uint64_t> Ipv6RegisteredMulticastAddressKey_t;

  /**
   * \brief Container of the IPv6 multicast addresses.
   */
  typedef std::map<Ipv6RegisteredMulticastAddressKey_t, bool> Ipv6RegisteredMulticastAddress_t;

  /**
   * \brief Container Iterator of the IPv6 multicast addresses.
   */
  typedef std::map<Ipv6RegisteredMulticastAddressKey_t, bool>::iterator Ipv6RegisteredMulticastAddressIter_t;

  /**
   * \brief Container Const Iterator of the IPv6 multicast addresses.
   */
  typedef std::map<Ipv6RegisteredMulticastAddressKey_t, bool>::const_iterator Ipv6RegisteredMulticastAddressCIter_t;

  /**
   * \brief Container of the IPv6 multicast addresses.
   */
  typedef std::map<Ipv6Address, bool> Ipv6RegisteredMulticastAddressNoInterface_t;

  /**
   * \brief Container Iterator of the IPv6 multicast addresses.
   */
  typedef std::map<Ipv6Address, bool>::iterator Ipv6RegisteredMulticastAddressNoInterfaceIter_t;

  /**
   * \brief Container Const Iterator of the IPv6 multicast addresses.
   */
  typedef std::map<Ipv6Address, bool>::const_iterator Ipv6RegisteredMulticastAddressNoInterfaceCIter_t;

  /**
   * \brief List of multicast IP addresses of interest, divided per interface.
   */
  Ipv6RegisteredMulticastAddress_t m_multicastAddresses;

  /**
   * \brief List of multicast IP addresses of interest for all the interfaces.
   */
  Ipv6RegisteredMulticastAddressNoInterface_t m_multicastAddressesNoInterface;
};

} /* namespace ns3 */




  NS_LOG_FUNCTION_NOARGS ();
  Ptr<Ipv6L3Protocol> ipv6 = m_node->GetObject<Ipv6L3Protocol> ();

  Ipv6LeaveGroup ();
  if (ipv6)
    {
      ipv6->DeleteRawSocket (this);

  return data.packet;
}

void
Ipv6RawSocketImpl::Ipv6JoinGroup (Ipv6Address address, Socket::Ipv6MulticastFilterMode filterMode, std::vector<Ipv6Address> sourceAddresses)
{
  NS_LOG_FUNCTION (this << address << &filterMode << &sourceAddresses);

  // We can join only one multicast group (or change its params)
  NS_ASSERT_MSG ((m_ipv6MulticastGroupAddress == address || m_ipv6MulticastGroupAddress.IsAny ()), "Can join only one IPv6 multicast group.");

  m_ipv6MulticastGroupAddress = address;

  Ptr<Ipv6L3Protocol> ipv6l3 = m_node->GetObject <Ipv6L3Protocol> ();
  if (ipv6l3)
    {
      if (filterMode == INCLUDE && sourceAddresses.empty ())
        {
          // it is a leave
          if (m_boundnetdevice)
            {
              int32_t index = ipv6l3->GetInterfaceForDevice (m_boundnetdevice);
              NS_ASSERT_MSG (index >= 0, "Interface without a valid index");
              ipv6l3->RemoveMulticastAddress (address, index);
            }
          else
            {
              ipv6l3->RemoveMulticastAddress (address);
            }
        }
      else
        {
          // it is a join or a modification
          if (m_boundnetdevice)
            {
              int32_t index = ipv6l3->GetInterfaceForDevice (m_boundnetdevice);
              NS_ASSERT_MSG (index >= 0, "Interface without a valid index");
              ipv6l3->AddMulticastAddress (address, index);
            }
          else
            {
              ipv6l3->AddMulticastAddress (address);
            }
        }
    }
}

uint32_t Ipv6RawSocketImpl::GetTxAvailable () const
{
  NS_LOG_FUNCTION_NOARGS ();

(-)a/src/internet/model/ipv6-raw-socket-impl.h (+1 lines)

Lines 107-112	Link Here

107

  virtual int SendTo (Ptr<Packet> p, uint32_t flags, const Address& toAddress);

107

  virtual int SendTo (Ptr<Packet> p, uint32_t flags, const Address& toAddress);

108

  virtual Ptr<Packet> Recv (uint32_t maxSize, uint32_t flags);

108

  virtual Ptr<Packet> Recv (uint32_t maxSize, uint32_t flags);

109

  virtual Ptr<Packet> RecvFrom (uint32_t maxSize, uint32_t flags, Address& fromAddress);

109

  virtual Ptr<Packet> RecvFrom (uint32_t maxSize, uint32_t flags, Address& fromAddress);

110

  virtual void Ipv6JoinGroup (Ipv6Address address, Socket::Ipv6MulticastFilterMode filterMode, std::vector<Ipv6Address> sourceAddresses);

110

111

/**

112

/**

112

   * \brief Set protocol field.

113

   * \brief Set protocol field.

(-)a/src/internet/model/ripng.cc (+2 lines)

Lines 119-124	Link Here

119

      if (m_interfaceExclusions.find (i) == m_interfaceExclusions.end ())

119

      if (m_interfaceExclusions.find (i) == m_interfaceExclusions.end ())

120

121

          activeInterface = true;

121

          activeInterface = true;

122

          m_ipv6->SetForwarding (i, true);

122

123

124

      for (uint32_t j = 0; j < m_ipv6->GetNAddresses (i); j++)

125

      for (uint32_t j = 0; j < m_ipv6->GetNAddresses (i); j++)

Lines 290-295	Link Here

290

  if (m_interfaceExclusions.find (i) == m_interfaceExclusions.end ())

291

  if (m_interfaceExclusions.find (i) == m_interfaceExclusions.end ())

291

292

      activeInterface = true;

293

      activeInterface = true;

294

      m_ipv6->SetForwarding (i, true);

293

295

294

296

295

  for (uint32_t j = 0; j < m_ipv6->GetNAddresses (i); j++)

297

  for (uint32_t j = 0; j < m_ipv6->GetNAddresses (i); j++)

(-)a/src/internet/model/udp-socket-impl.cc (+65 lines)

Lines 26-31	Link Here

#include "ns3/ipv6-route.h"

#include "ns3/ipv6-route.h"

#include "ns3/ipv4.h"

#include "ns3/ipv4.h"

#include "ns3/ipv6.h"

#include "ns3/ipv6.h"

#include "ns3/ipv6-l3-protocol.h"

#include "ns3/ipv4-header.h"

#include "ns3/ipv4-header.h"

#include "ns3/ipv4-routing-protocol.h"

#include "ns3/ipv4-routing-protocol.h"

#include "ns3/ipv6-routing-protocol.h"

#include "ns3/ipv6-routing-protocol.h"

Lines 305-310	Link Here

305

          m_errno = port ? ERROR_ADDRINUSE : ERROR_ADDRNOTAVAIL;

306

          m_errno = port ? ERROR_ADDRINUSE : ERROR_ADDRNOTAVAIL;

306

          return -1;

307

          return -1;

307

308

309

      if (ipv6.IsMulticast ())

310

311

          Ptr<Ipv6L3Protocol> ipv6l3 = m_node->GetObject <Ipv6L3Protocol> ();

312

          if (ipv6l3)

313

314

              ipv6l3->AddMulticastAddress (ipv6);

315

316

308

317

309

  else

318

  else

310

319

Lines 349-354	Link Here

349

      m_errno = Socket::ERROR_BADF;

358

      m_errno = Socket::ERROR_BADF;

350

      return -1;

359

      return -1;

351

360

361

  Ipv6LeaveGroup ();

352

  m_shutdownRecv = true;

362

  m_shutdownRecv = true;

353

  m_shutdownSend = true;

363

  m_shutdownSend = true;

354

  DeallocateEndPoint ();

364

  DeallocateEndPoint ();

Lines 955-960	Link Here

955

      NS_ASSERT (m_endPoint6 != 0);

965

      NS_ASSERT (m_endPoint6 != 0);

956

966

957

  m_endPoint6->BindToNetDevice (netdevice);

967

  m_endPoint6->BindToNetDevice (netdevice);

968

969

  if (m_endPoint6->GetLocalAddress ().IsMulticast ())

970

971

      Ptr<Ipv6L3Protocol> ipv6l3 = m_node->GetObject <Ipv6L3Protocol> ();

972

      if (ipv6l3)

973

974

          uint32_t index = ipv6l3->GetInterfaceForDevice (netdevice);

975

          ipv6l3->RemoveMulticastAddress (m_endPoint6->GetLocalAddress ());

976

          ipv6l3->AddMulticastAddress (m_endPoint6->GetLocalAddress (), index);

977

978

979

958

  return;

980

  return;

959

981

960

982

Lines 1169-1173	Link Here

1169

  return m_allowBroadcast;

1191

  return m_allowBroadcast;

1170

1192

1171

1193

1194

void

1195

UdpSocketImpl::Ipv6JoinGroup (Ipv6Address address, Socket::Ipv6MulticastFilterMode filterMode, std::vector<Ipv6Address> sourceAddresses)

1196

1197

  NS_LOG_FUNCTION (this << address << &filterMode << &sourceAddresses);

1198

1199

  // We can join only one multicast group (or change its params)

1200

  NS_ASSERT_MSG ((m_ipv6MulticastGroupAddress == address || m_ipv6MulticastGroupAddress.IsAny ()), "Can join only one IPv6 multicast group.");

1201

1202

  m_ipv6MulticastGroupAddress = address;

1203

1204

  Ptr<Ipv6L3Protocol> ipv6l3 = m_node->GetObject <Ipv6L3Protocol> ();

1205

  if (ipv6l3)

1206

1207

      if (filterMode == INCLUDE && sourceAddresses.empty ())

1208

1209

          // it is a leave

1210

          if (m_boundnetdevice)

1211

1212

              int32_t index = ipv6l3->GetInterfaceForDevice (m_boundnetdevice);

1213

              NS_ASSERT_MSG (index >= 0, "Interface without a valid index");

1214

              ipv6l3->RemoveMulticastAddress (address, index);

1215

1216

          else

1217

1218

              ipv6l3->RemoveMulticastAddress (address);

1219

1220

1221

      else

1222

1223

          // it is a join or a modification

1224

          if (m_boundnetdevice)

1225

1226

              int32_t index = ipv6l3->GetInterfaceForDevice (m_boundnetdevice);

1227

              NS_ASSERT_MSG (index >= 0, "Interface without a valid index");

1228

              ipv6l3->AddMulticastAddress (address, index);

1229

1230

          else

1231

1232

              ipv6l3->AddMulticastAddress (address);

1233

1234

1235

1236

1172

1237

1173

} // namespace ns3

1238

} // namespace ns3

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

Lines 98-103	Link Here

  virtual void BindToNetDevice (Ptr<NetDevice> netdevice);

  virtual void BindToNetDevice (Ptr<NetDevice> netdevice);

  virtual bool SetAllowBroadcast (bool allowBroadcast);

  virtual bool SetAllowBroadcast (bool allowBroadcast);

100

  virtual bool GetAllowBroadcast () const;

100

  virtual bool GetAllowBroadcast () const;

101

  virtual void Ipv6JoinGroup (Ipv6Address address, Socket::Ipv6MulticastFilterMode filterMode, std::vector<Ipv6Address> sourceAddresses);

101

102

private:

103

private:

103

  // Attributes set through UdpSocket base class

104

  // Attributes set through UdpSocket base class

(-)a/src/internet/test/ipv6-ripng-test.cc (+1 lines)

Lines 613-618	Link Here

613

  Ptr<SocketFactory> rxSocketFactory = listener->GetObject<UdpSocketFactory> ();

613

  Ptr<SocketFactory> rxSocketFactory = listener->GetObject<UdpSocketFactory> ();

614

  Ptr<Socket> rxSocket = rxSocketFactory->CreateSocket ();

614

  Ptr<Socket> rxSocket = rxSocketFactory->CreateSocket ();

615

  NS_TEST_EXPECT_MSG_EQ (rxSocket->Bind (Inet6SocketAddress (Ipv6Address ("ff02::9"), 521)), 0, "trivial");

615

  NS_TEST_EXPECT_MSG_EQ (rxSocket->Bind (Inet6SocketAddress (Ipv6Address ("ff02::9"), 521)), 0, "trivial");

616

  rxSocket->BindToNetDevice (listenerDev);

616

  rxSocket->SetRecvCallback (MakeCallback (&Ipv6RipngSplitHorizonStrategyTest::ReceivePktProbe, this));

617

  rxSocket->SetRecvCallback (MakeCallback (&Ipv6RipngSplitHorizonStrategyTest::ReceivePktProbe, this));

617

618

  // ------ Now the tests ------------

619

  // ------ Now the tests ------------




  return m_ipv6RecvHopLimit;
}

void
Socket::Ipv6JoinGroup (Ipv6Address address, Ipv6MulticastFilterMode filterMode, std::vector<Ipv6Address> sourceAddresses)
{
  NS_LOG_FUNCTION (this<<address<<&filterMode<<&sourceAddresses);
  NS_ASSERT_MSG (false,"Ipv6JoinGroup not implemented on this socket");
}

void
Socket::Ipv6JoinGroup (Ipv6Address address)
{
  NS_LOG_FUNCTION (this<<address);

  // Join Group. Note that joining a group with no sources means joining without source restrictions.
  std::vector<Ipv6Address> sourceAddresses;
  Ipv6JoinGroup (address, EXCLUDE, sourceAddresses);
}

void
Socket::Ipv6LeaveGroup (void)
{
  NS_LOG_FUNCTION (this);
  if(m_ipv6MulticastGroupAddress.IsAny () )
    {
      NS_LOG_INFO (" The socket was not bound to any group.");
      return;
    }
  // Leave Group. Note that joining a group with no sources means leaving it.
  std::vector<Ipv6Address> sourceAddresses;
  Ipv6JoinGroup (m_ipv6MulticastGroupAddress, INCLUDE, sourceAddresses);
  m_ipv6MulticastGroupAddress = Ipv6Address::GetAny ();
}

/***************************************************************
 *           Socket Tags
 ***************************************************************/

(-)a/src/network/model/socket.h (+34 lines)

Lines 109-114	Link Here

109

};

109

};

110

111

/**

111

/**

112

   * \enum Ipv6MulticastFilterMode

113

   * \brief Enumeration of the possible filter of a socket.

114

*/

115

  enum Ipv6MulticastFilterMode

116

117

    INCLUDE=1,

118

    EXCLUDE

119

};

120

121

/**

112

   * This method wraps the creation of sockets that is performed

122

   * This method wraps the creation of sockets that is performed

113

   * on a given node by a SocketFactory specified by TypeId.

123

   * on a given node by a SocketFactory specified by TypeId.

114

124

Lines 817-822	Link Here

817

*/

827

*/

818

  bool IsIpv6RecvHopLimit (void) const;

828

  bool IsIpv6RecvHopLimit (void) const;

819

829

830

/**

831

   * \brief Joins a IPv6 multicast group.

832

833

   * Based on the filter mode and source addresses this can be interpreted as a

834

   * join, leave, or modification to source filtering on a multicast group.

835

836

   * \param address Requested multicast address.

837

   * \param filterMode Socket filtering mode (INCLUDE | EXCLUDE).

838

   * \param sourceAddresses All the source addresses on which socket is interested or not interested.

839

*/

840

  virtual void Ipv6JoinGroup (Ipv6Address address, Ipv6MulticastFilterMode filterMode, std::vector<Ipv6Address> sourceAddresses);

841

842

/**

843

   * \brief Joins a IPv6 multicast group without filters.

844

   * \param address Group address on which socket wants to join.

845

*/

846

  virtual void Ipv6JoinGroup (Ipv6Address address);

847

848

/**

849

   * \brief Leaves IPv6 multicast group.

850

*/

851

  virtual void Ipv6LeaveGroup (void);

852

820

protected:

853

protected:

821

/**

854

/**

822

   * \brief Notify through the callback (if set) that the connection has been

855

   * \brief Notify through the callback (if set) that the connection has been

Lines 913-918	Link Here

913

946

914

  Ptr<NetDevice> m_boundnetdevice; //!< the device this socket is bound to (might be null).

947

  Ptr<NetDevice> m_boundnetdevice; //!< the device this socket is bound to (might be null).

915

  bool m_recvPktInfo; //!< if the socket should add packet info tags to the packet forwarded to L4.

948

  bool m_recvPktInfo; //!< if the socket should add packet info tags to the packet forwarded to L4.

949

  Ipv6Address m_ipv6MulticastGroupAddress; //!< IPv6 multicast group address.

916

950

917

private:

951

private:

918

  Callback<void, Ptr<Socket> >                   m_connectionSucceeded;  //!< connection succeeded callback

952

  Callback<void, Ptr<Socket> >                   m_connectionSucceeded;  //!< connection succeeded callback

Return to bug 2234