668 lines
16 KiB
C++
668 lines
16 KiB
C++
/* -*- Mode: C++; c-file-style: "gnu"; indent-tabs-mode:nil; -*- */
|
|
/*
|
|
* Copyright (c) 2007 INRIA
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License version 2 as
|
|
* published by the Free Software Foundation;
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
*
|
|
* Author: Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
|
|
*/
|
|
|
|
#include "ns3/log.h"
|
|
#include "ns3/node.h"
|
|
#include "ns3/inet-socket-address.h"
|
|
#include "ns3/ipv4-route.h"
|
|
#include "ns3/ipv4.h"
|
|
#include "ns3/ipv4-header.h"
|
|
#include "ns3/ipv4-routing-protocol.h"
|
|
#include "ns3/udp-socket-factory.h"
|
|
#include "ns3/trace-source-accessor.h"
|
|
#include "udp-socket-impl.h"
|
|
#include "udp-l4-protocol.h"
|
|
#include "ipv4-end-point.h"
|
|
#include <limits>
|
|
|
|
NS_LOG_COMPONENT_DEFINE ("UdpSocketImpl");
|
|
|
|
namespace ns3 {
|
|
|
|
static const uint32_t MAX_IPV4_UDP_DATAGRAM_SIZE = 65507;
|
|
|
|
// Add attributes generic to all UdpSockets to base class UdpSocket
|
|
TypeId
|
|
UdpSocketImpl::GetTypeId (void)
|
|
{
|
|
static TypeId tid = TypeId ("ns3::UdpSocketImpl")
|
|
.SetParent<UdpSocket> ()
|
|
.AddConstructor<UdpSocketImpl> ()
|
|
.AddTraceSource ("Drop", "Drop UDP packet due to receive buffer overflow",
|
|
MakeTraceSourceAccessor (&UdpSocketImpl::m_dropTrace))
|
|
.AddAttribute ("IcmpCallback", "Callback invoked whenever an icmp error is received on this socket.",
|
|
CallbackValue (),
|
|
MakeCallbackAccessor (&UdpSocketImpl::m_icmpCallback),
|
|
MakeCallbackChecker ())
|
|
;
|
|
return tid;
|
|
}
|
|
|
|
UdpSocketImpl::UdpSocketImpl ()
|
|
: m_endPoint (0),
|
|
m_node (0),
|
|
m_udp (0),
|
|
m_errno (ERROR_NOTERROR),
|
|
m_shutdownSend (false),
|
|
m_shutdownRecv (false),
|
|
m_connected (false),
|
|
m_rxAvailable (0)
|
|
{
|
|
NS_LOG_FUNCTION_NOARGS ();
|
|
}
|
|
|
|
UdpSocketImpl::~UdpSocketImpl ()
|
|
{
|
|
NS_LOG_FUNCTION_NOARGS ();
|
|
|
|
// XXX todo: leave any multicast groups that have been joined
|
|
m_node = 0;
|
|
if (m_endPoint != 0)
|
|
{
|
|
NS_ASSERT (m_udp != 0);
|
|
/**
|
|
* Note that this piece of code is a bit tricky:
|
|
* when DeAllocate is called, it will call into
|
|
* Ipv4EndPointDemux::Deallocate which triggers
|
|
* a delete of the associated endPoint which triggers
|
|
* in turn a call to the method ::Destroy below
|
|
* will will zero the m_endPoint field.
|
|
*/
|
|
NS_ASSERT (m_endPoint != 0);
|
|
m_udp->DeAllocate (m_endPoint);
|
|
NS_ASSERT (m_endPoint == 0);
|
|
}
|
|
m_udp = 0;
|
|
}
|
|
|
|
void
|
|
UdpSocketImpl::SetNode (Ptr<Node> node)
|
|
{
|
|
NS_LOG_FUNCTION_NOARGS ();
|
|
m_node = node;
|
|
|
|
}
|
|
void
|
|
UdpSocketImpl::SetUdp (Ptr<UdpL4Protocol> udp)
|
|
{
|
|
NS_LOG_FUNCTION_NOARGS ();
|
|
m_udp = udp;
|
|
}
|
|
|
|
|
|
enum Socket::SocketErrno
|
|
UdpSocketImpl::GetErrno (void) const
|
|
{
|
|
NS_LOG_FUNCTION_NOARGS ();
|
|
return m_errno;
|
|
}
|
|
|
|
Ptr<Node>
|
|
UdpSocketImpl::GetNode (void) const
|
|
{
|
|
NS_LOG_FUNCTION_NOARGS ();
|
|
return m_node;
|
|
}
|
|
|
|
void
|
|
UdpSocketImpl::Destroy (void)
|
|
{
|
|
NS_LOG_FUNCTION_NOARGS ();
|
|
m_node = 0;
|
|
m_endPoint = 0;
|
|
m_udp = 0;
|
|
}
|
|
|
|
int
|
|
UdpSocketImpl::FinishBind (void)
|
|
{
|
|
NS_LOG_FUNCTION_NOARGS ();
|
|
if (m_endPoint == 0)
|
|
{
|
|
return -1;
|
|
}
|
|
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)));
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
UdpSocketImpl::Bind (void)
|
|
{
|
|
NS_LOG_FUNCTION_NOARGS ();
|
|
m_endPoint = m_udp->Allocate ();
|
|
return FinishBind ();
|
|
}
|
|
|
|
int
|
|
UdpSocketImpl::Bind (const Address &address)
|
|
{
|
|
NS_LOG_FUNCTION (this << address);
|
|
|
|
if (!InetSocketAddress::IsMatchingType (address))
|
|
{
|
|
NS_LOG_ERROR ("Not IsMatchingType");
|
|
m_errno = ERROR_INVAL;
|
|
return -1;
|
|
}
|
|
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);
|
|
}
|
|
|
|
return FinishBind ();
|
|
}
|
|
|
|
int
|
|
UdpSocketImpl::ShutdownSend (void)
|
|
{
|
|
NS_LOG_FUNCTION_NOARGS ();
|
|
m_shutdownSend = true;
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
UdpSocketImpl::ShutdownRecv (void)
|
|
{
|
|
NS_LOG_FUNCTION_NOARGS ();
|
|
m_shutdownRecv = true;
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
UdpSocketImpl::Close (void)
|
|
{
|
|
NS_LOG_FUNCTION_NOARGS ();
|
|
if (m_shutdownRecv == true && m_shutdownSend == true)
|
|
{
|
|
m_errno = Socket::ERROR_BADF;
|
|
return -1;
|
|
}
|
|
m_shutdownRecv = true;
|
|
m_shutdownSend = true;
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
UdpSocketImpl::Connect(const Address & address)
|
|
{
|
|
NS_LOG_FUNCTION (this << address);
|
|
InetSocketAddress transport = InetSocketAddress::ConvertFrom (address);
|
|
m_defaultAddress = transport.GetIpv4 ();
|
|
m_defaultPort = transport.GetPort ();
|
|
NotifyConnectionSucceeded ();
|
|
m_connected = true;
|
|
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
UdpSocketImpl::Listen (void)
|
|
{
|
|
m_errno = Socket::ERROR_OPNOTSUPP;
|
|
return -1;
|
|
}
|
|
|
|
int
|
|
UdpSocketImpl::Send (Ptr<Packet> p, uint32_t flags)
|
|
{
|
|
NS_LOG_FUNCTION (this << p << flags);
|
|
|
|
if (!m_connected)
|
|
{
|
|
m_errno = ERROR_NOTCONN;
|
|
return -1;
|
|
}
|
|
return DoSend (p);
|
|
}
|
|
|
|
int
|
|
UdpSocketImpl::DoSend (Ptr<Packet> p)
|
|
{
|
|
NS_LOG_FUNCTION (this << p);
|
|
if (m_endPoint == 0)
|
|
{
|
|
if (Bind () == -1)
|
|
{
|
|
NS_ASSERT (m_endPoint == 0);
|
|
return -1;
|
|
}
|
|
NS_ASSERT (m_endPoint != 0);
|
|
}
|
|
if (m_shutdownSend)
|
|
{
|
|
m_errno = ERROR_SHUTDOWN;
|
|
return -1;
|
|
}
|
|
|
|
return DoSendTo (p, m_defaultAddress, m_defaultPort);
|
|
}
|
|
|
|
int
|
|
UdpSocketImpl::DoSendTo (Ptr<Packet> p, const Address &address)
|
|
{
|
|
NS_LOG_FUNCTION (this << p << address);
|
|
|
|
if (!m_connected)
|
|
{
|
|
NS_LOG_LOGIC ("Not connected");
|
|
InetSocketAddress transport = InetSocketAddress::ConvertFrom (address);
|
|
Ipv4Address ipv4 = transport.GetIpv4 ();
|
|
uint16_t port = transport.GetPort ();
|
|
return DoSendTo (p, ipv4, port);
|
|
}
|
|
else
|
|
{
|
|
// connected UDP socket must use default addresses
|
|
NS_LOG_LOGIC ("Connected");
|
|
return DoSendTo (p, m_defaultAddress, m_defaultPort);
|
|
}
|
|
}
|
|
|
|
int
|
|
UdpSocketImpl::DoSendTo (Ptr<Packet> p, Ipv4Address dest, uint16_t port)
|
|
{
|
|
NS_LOG_FUNCTION (this << p << dest << port);
|
|
|
|
if (m_endPoint == 0)
|
|
{
|
|
if (Bind () == -1)
|
|
{
|
|
NS_ASSERT (m_endPoint == 0);
|
|
return -1;
|
|
}
|
|
NS_ASSERT (m_endPoint != 0);
|
|
}
|
|
if (m_shutdownSend)
|
|
{
|
|
m_errno = ERROR_SHUTDOWN;
|
|
return -1;
|
|
}
|
|
|
|
if (p->GetSize () > GetTxAvailable () )
|
|
{
|
|
m_errno = ERROR_MSGSIZE;
|
|
return -1;
|
|
}
|
|
|
|
Ptr<Ipv4> ipv4 = m_node->GetObject<Ipv4> ();
|
|
|
|
// Locally override the IP TTL for this socket
|
|
// We cannot directly modify the TTL at this stage, so we set a Packet tag
|
|
// The destination can be either multicast, unicast/anycast, or
|
|
// either all-hosts broadcast or limited (subnet-directed) broadcast.
|
|
// For the latter two broadcast types, the TTL will later be set to one
|
|
// irrespective of what is set in these socket options. So, this tagging
|
|
// may end up setting the TTL of a limited broadcast packet to be
|
|
// the same as a unicast, but it will be fixed further down the stack
|
|
if (m_ipMulticastTtl != 0 && dest.IsMulticast ())
|
|
{
|
|
SocketIpTtlTag tag;
|
|
tag.SetTtl (m_ipMulticastTtl);
|
|
p->AddPacketTag (tag);
|
|
}
|
|
else if (m_ipTtl != 0 && !dest.IsMulticast () && !dest.IsBroadcast ())
|
|
{
|
|
SocketIpTtlTag tag;
|
|
tag.SetTtl (m_ipTtl);
|
|
p->AddPacketTag (tag);
|
|
}
|
|
{
|
|
SocketSetDontFragmentTag tag;
|
|
bool found = p->RemovePacketTag (tag);
|
|
if (!found)
|
|
{
|
|
if (m_mtuDiscover)
|
|
{
|
|
tag.Enable ();
|
|
}
|
|
else
|
|
{
|
|
tag.Disable ();
|
|
}
|
|
p->AddPacketTag (tag);
|
|
}
|
|
}
|
|
//
|
|
// If dest is set to the limited broadcast address (all ones),
|
|
// convert it to send a copy of the packet out of every
|
|
// interface as a subnet-directed broadcast.
|
|
// Exception: if the interface has a /32 address, there is no
|
|
// valid subnet-directed broadcast, so send it as limited broadcast
|
|
// Note also that some systems will only send limited broadcast packets
|
|
// out of the "default" interface; here we send it out all interfaces
|
|
//
|
|
if (dest.IsBroadcast ())
|
|
{
|
|
NS_LOG_LOGIC ("Limited broadcast start.");
|
|
for (uint32_t i = 0; i < ipv4->GetNInterfaces (); i++ )
|
|
{
|
|
// Get the primary address
|
|
Ipv4InterfaceAddress iaddr = ipv4->GetAddress (i, 0);
|
|
Ipv4Address addri = iaddr.GetLocal ();
|
|
Ipv4Mask maski = iaddr.GetMask ();
|
|
if (maski == Ipv4Mask::GetOnes ())
|
|
{
|
|
// if the network mask is 255.255.255.255, do not convert dest
|
|
NS_LOG_LOGIC ("Sending one copy from " << addri << " to " << dest
|
|
<< " (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();
|
|
}
|
|
else if (ipv4->GetRoutingProtocol () != 0)
|
|
{
|
|
Ipv4Header header;
|
|
header.SetDestination (dest);
|
|
Socket::SocketErrno errno_;
|
|
Ptr<Ipv4Route> route;
|
|
uint32_t oif = 0; //specify non-zero if bound to a source address
|
|
// TBD-- we could cache the route and just check its validity
|
|
route = ipv4->GetRoutingProtocol ()->RouteOutput (p, header, oif, errno_);
|
|
if (route != 0)
|
|
{
|
|
NS_LOG_LOGIC ("Route exists");
|
|
header.SetSource (route->GetSource ());
|
|
m_udp->Send (p->Copy (), header.GetSource (), header.GetDestination (),
|
|
m_endPoint->GetLocalPort (), port, route);
|
|
NotifyDataSent (p->GetSize ());
|
|
return p->GetSize();
|
|
}
|
|
else
|
|
{
|
|
NS_LOG_LOGIC ("No route to destination");
|
|
NS_LOG_ERROR (errno_);
|
|
m_errno = errno_;
|
|
return -1;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
NS_LOG_ERROR ("ERROR_NOROUTETOHOST");
|
|
m_errno = ERROR_NOROUTETOHOST;
|
|
return -1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
// XXX maximum message size for UDP broadcast is limited by MTU
|
|
// size of underlying link; we are not checking that now.
|
|
uint32_t
|
|
UdpSocketImpl::GetTxAvailable (void) const
|
|
{
|
|
NS_LOG_FUNCTION_NOARGS ();
|
|
// No finite send buffer is modelled, but we must respect
|
|
// the maximum size of an IP datagram (65535 bytes - headers).
|
|
return MAX_IPV4_UDP_DATAGRAM_SIZE;
|
|
}
|
|
|
|
int
|
|
UdpSocketImpl::SendTo (Ptr<Packet> p, uint32_t flags, const Address &address)
|
|
{
|
|
NS_LOG_FUNCTION (this << p << flags << address);
|
|
InetSocketAddress transport = InetSocketAddress::ConvertFrom (address);
|
|
Ipv4Address ipv4 = transport.GetIpv4 ();
|
|
uint16_t port = transport.GetPort ();
|
|
return DoSendTo (p, ipv4, port);
|
|
}
|
|
|
|
uint32_t
|
|
UdpSocketImpl::GetRxAvailable (void) const
|
|
{
|
|
NS_LOG_FUNCTION_NOARGS ();
|
|
// We separately maintain this state to avoid walking the queue
|
|
// every time this might be called
|
|
return m_rxAvailable;
|
|
}
|
|
|
|
Ptr<Packet>
|
|
UdpSocketImpl::Recv (uint32_t maxSize, uint32_t flags)
|
|
{
|
|
NS_LOG_FUNCTION (this << maxSize << flags);
|
|
if (m_deliveryQueue.empty() )
|
|
{
|
|
m_errno = ERROR_AGAIN;
|
|
return 0;
|
|
}
|
|
Ptr<Packet> p = m_deliveryQueue.front ();
|
|
if (p->GetSize () <= maxSize)
|
|
{
|
|
m_deliveryQueue.pop ();
|
|
m_rxAvailable -= p->GetSize ();
|
|
}
|
|
else
|
|
{
|
|
p = 0;
|
|
}
|
|
return p;
|
|
}
|
|
|
|
Ptr<Packet>
|
|
UdpSocketImpl::RecvFrom (uint32_t maxSize, uint32_t flags,
|
|
Address &fromAddress)
|
|
{
|
|
NS_LOG_FUNCTION (this << maxSize << flags);
|
|
Ptr<Packet> packet = Recv (maxSize, flags);
|
|
if (packet != 0)
|
|
{
|
|
SocketAddressTag tag;
|
|
bool found;
|
|
found = packet->PeekPacketTag (tag);
|
|
NS_ASSERT (found);
|
|
fromAddress = tag.GetAddress ();
|
|
}
|
|
return packet;
|
|
}
|
|
|
|
int
|
|
UdpSocketImpl::GetSockName (Address &address) const
|
|
{
|
|
NS_LOG_FUNCTION_NOARGS ();
|
|
if (m_endPoint != 0)
|
|
{
|
|
address = InetSocketAddress (m_endPoint->GetLocalAddress (), m_endPoint->GetLocalPort());
|
|
}
|
|
else
|
|
{
|
|
address = InetSocketAddress(Ipv4Address::GetZero(), 0);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
UdpSocketImpl::MulticastJoinGroup (uint32_t interface, const Address &groupAddress)
|
|
{
|
|
NS_LOG_FUNCTION (interface << groupAddress);
|
|
/*
|
|
1) sanity check interface
|
|
2) sanity check that it has not been called yet on this interface/group
|
|
3) determine address family of groupAddress
|
|
4) locally store a list of (interface, groupAddress)
|
|
5) call ipv4->MulticastJoinGroup () or Ipv6->MulticastJoinGroup ()
|
|
*/
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
UdpSocketImpl::MulticastLeaveGroup (uint32_t interface, const Address &groupAddress)
|
|
{
|
|
NS_LOG_FUNCTION (interface << groupAddress);
|
|
/*
|
|
1) sanity check interface
|
|
2) determine address family of groupAddress
|
|
3) delete from local list of (interface, groupAddress); raise a LOG_WARN
|
|
if not already present (but return 0)
|
|
5) call ipv4->MulticastLeaveGroup () or Ipv6->MulticastLeaveGroup ()
|
|
*/
|
|
return 0;
|
|
}
|
|
|
|
void
|
|
UdpSocketImpl::ForwardUp (Ptr<Packet> packet, Ipv4Address ipv4, uint16_t port)
|
|
{
|
|
NS_LOG_FUNCTION (this << packet << ipv4 << port);
|
|
|
|
if (m_shutdownRecv)
|
|
{
|
|
return;
|
|
}
|
|
if ((m_rxAvailable + packet->GetSize ()) <= m_rcvBufSize)
|
|
{
|
|
Address address = InetSocketAddress (ipv4, port);
|
|
SocketAddressTag tag;
|
|
tag.SetAddress (address);
|
|
packet->AddPacketTag (tag);
|
|
m_deliveryQueue.push (packet);
|
|
m_rxAvailable += packet->GetSize ();
|
|
NotifyDataRecv ();
|
|
}
|
|
else
|
|
{
|
|
// In general, this case should not occur unless the
|
|
// receiving application reads data from this socket slowly
|
|
// in comparison to the arrival rate
|
|
//
|
|
// drop and trace packet
|
|
NS_LOG_WARN ("No receive buffer space available. Drop.");
|
|
m_dropTrace (packet);
|
|
}
|
|
}
|
|
|
|
void
|
|
UdpSocketImpl::ForwardIcmp (Ipv4Address icmpSource, uint8_t icmpTtl,
|
|
uint8_t icmpType, uint8_t icmpCode,
|
|
uint32_t icmpInfo)
|
|
{
|
|
NS_LOG_FUNCTION (this << icmpSource << (uint32_t)icmpTtl << (uint32_t)icmpType <<
|
|
(uint32_t)icmpCode << icmpInfo);
|
|
if (!m_icmpCallback.IsNull ())
|
|
{
|
|
m_icmpCallback (icmpSource, icmpTtl, icmpType, icmpCode, icmpInfo);
|
|
}
|
|
}
|
|
|
|
|
|
void
|
|
UdpSocketImpl::SetRcvBufSize (uint32_t size)
|
|
{
|
|
m_rcvBufSize = size;
|
|
}
|
|
|
|
uint32_t
|
|
UdpSocketImpl::GetRcvBufSize (void) const
|
|
{
|
|
return m_rcvBufSize;
|
|
}
|
|
|
|
void
|
|
UdpSocketImpl::SetIpTtl (uint8_t ipTtl)
|
|
{
|
|
m_ipTtl = ipTtl;
|
|
}
|
|
|
|
uint8_t
|
|
UdpSocketImpl::GetIpTtl (void) const
|
|
{
|
|
return m_ipTtl;
|
|
}
|
|
|
|
void
|
|
UdpSocketImpl::SetIpMulticastTtl (uint8_t ipTtl)
|
|
{
|
|
m_ipMulticastTtl = ipTtl;
|
|
}
|
|
|
|
uint8_t
|
|
UdpSocketImpl::GetIpMulticastTtl (void) const
|
|
{
|
|
return m_ipMulticastTtl;
|
|
}
|
|
|
|
void
|
|
UdpSocketImpl::SetIpMulticastIf (int32_t ipIf)
|
|
{
|
|
m_ipMulticastIf = ipIf;
|
|
}
|
|
|
|
int32_t
|
|
UdpSocketImpl::GetIpMulticastIf (void) const
|
|
{
|
|
return m_ipMulticastIf;
|
|
}
|
|
|
|
void
|
|
UdpSocketImpl::SetIpMulticastLoop (bool loop)
|
|
{
|
|
m_ipMulticastLoop = loop;
|
|
}
|
|
|
|
bool
|
|
UdpSocketImpl::GetIpMulticastLoop (void) const
|
|
{
|
|
return m_ipMulticastLoop;
|
|
}
|
|
|
|
void
|
|
UdpSocketImpl::SetMtuDiscover (bool discover)
|
|
{
|
|
m_mtuDiscover = discover;
|
|
}
|
|
bool
|
|
UdpSocketImpl::GetMtuDiscover (void) const
|
|
{
|
|
return m_mtuDiscover;
|
|
}
|
|
|
|
|
|
} //namespace ns3
|