如何在NS3中实现一个L4（传输层）协议
本文将以UDP协议为例，讲述该协议在NS3中的实现。
UDP的源代码位于src/internet目录下，主要包含以下几个文件：
| 文件名称 | 作用 |
|---|---|
| udp-header.h | UDP协议的头部信息。 |
| udp-header.cc | 同上。 |
| udp-l4-protocol.h | UDP传输层协议，继承自IpL4Protocol类。 |
| udp-l4-protocol.cc | 同上。 |
| udp-socket-factory-impl.h | 继承自UdpSocketFactory类，进一步实现了UDP中的机制。 |
| udp-socket-factory-impl.cc | 同上。 |
| udp-socket-factory.h | 继承自SocketFactory类，是具有UDP特色的SocketFactory。 |
| udp-socket-factory.cc | 同上。 |
| udp-socket-impl.h | 继承自UdpSocket类，用来进一步实现UDP中的机制。 |
| udp-socket-impl.cc | 同上。 |
| udp-socket.h | 继承自Socket类，用来实现一些UDP相关的函数。 |
| udp-socket.cc | 同上。 |
由于udp-socket文件中的内容很少很简单，此处不再展开，所以从udp-socket-impl文件开始。
这个的实现依赖于一些地址类，关于这些地址类的讲解可以参考另一篇文章NS3中的网络地址 « 云中君。
UdpSocketImpl
先看这个类中的私有变量：
// Connections to other layers of TCP/IP
Ipv4EndPoint* m_endPoint; //!< the IPv4 endpoint
Ipv6EndPoint* m_endPoint6; //!< the IPv6 endpoint
Ptr<Node> m_node; //!< the associated node
Ptr<UdpL4Protocol> m_udp; //!< the associated UDP L4 protocol
Callback<void, Ipv4Address,uint8_t,uint8_t,uint8_t,uint32_t> m_icmpCallback; //!< ICMP callback
Callback<void, Ipv6Address,uint8_t,uint8_t,uint8_t,uint32_t> m_icmpCallback6; //!< ICMPv6 callback
Address m_defaultAddress; //!< Default address
uint16_t m_defaultPort; //!< Default port
TracedCallback<Ptr<const Packet> > m_dropTrace; //!< Trace for dropped packets
mutable enum SocketErrno m_errno; //!< Socket error code
bool m_shutdownSend; //!< Send no longer allowed
bool m_shutdownRecv; //!< Receive no longer allowed
bool m_connected; //!< Connection established
bool m_allowBroadcast; //!< Allow send broadcast packets
std::queue<std::pair<Ptr<Packet>, Address> > m_deliveryQueue; //!< Queue for incoming packets
uint32_t m_rxAvailable; //!< Number of available bytes to be received
// Socket attributes
uint32_t m_rcvBufSize; //!< Receive buffer size
uint8_t m_ipMulticastTtl; //!< Multicast TTL
int32_t m_ipMulticastIf; //!< Multicast Interface
bool m_ipMulticastLoop; //!< Allow multicast loop
bool m_mtuDiscover; //!< Allow MTU discovery
我们看到，其中包含了一些关键的信息，比如：
- 当前的连接四元组；
- 当前主机；
- 当前的UDP协议；
- 当前绑定的设备（由于继承了
Socket，其包含在Socket当中）。
接下来看这个类中的一些函数的实现：
namespace ns3 {
NS_LOG_COMPONENT_DEFINE ("UdpSocketImpl");
NS_OBJECT_ENSURE_REGISTERED (UdpSocketImpl);
// The correct maximum UDP message size is 65507, as determined by the following formula:
// 0xffff - (sizeof(IP Header) + sizeof(UDP Header)) = 65535-(20+8) = 65507
// \todo MAX_IPV4_UDP_DATAGRAM_SIZE is correct only for IPv4
static const uint32_t MAX_IPV4_UDP_DATAGRAM_SIZE = 65507; //!< Maximum UDP datagram size
// Add attributes generic to all UdpSockets to base class UdpSocket
TypeId
UdpSocketImpl::GetTypeId (void)
{
static TypeId tid = TypeId ("ns3::UdpSocketImpl")
.SetParent<UdpSocket> ()
.SetGroupName ("Internet")
.AddConstructor<UdpSocketImpl> ()
.AddTraceSource ("Drop",
"Drop UDP packet due to receive buffer overflow",
MakeTraceSourceAccessor (&UdpSocketImpl::m_dropTrace),
"ns3::Packet::TracedCallback")
.AddAttribute ("IcmpCallback", "Callback invoked whenever an icmp error is received on this socket.",
CallbackValue (),
MakeCallbackAccessor (&UdpSocketImpl::m_icmpCallback),
MakeCallbackChecker ())
.AddAttribute ("IcmpCallback6", "Callback invoked whenever an icmpv6 error is received on this socket.",
CallbackValue (),
MakeCallbackAccessor (&UdpSocketImpl::m_icmpCallback6),
MakeCallbackChecker ())
;
return tid;
}
// 构造函数对一些变量和状态进行初始化
UdpSocketImpl::UdpSocketImpl ()
: m_endPoint (0),
m_endPoint6 (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 ();
m_allowBroadcast = false;
}
UdpSocketImpl::~UdpSocketImpl ()
{
NS_LOG_FUNCTION_NOARGS ();
/// \todo leave any multicast groups that have been joined
m_node = 0;
/**
* Note: actually this function is called AFTER
* UdpSocketImpl::Destroy or UdpSocketImpl::Destroy6
* so the code below is unnecessary in normal operations
*/
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 UdpSocketImpl::Destroy below
* will will zero the m_endPoint field.
*/
NS_ASSERT (m_endPoint != 0);
m_udp->DeAllocate (m_endPoint);
NS_ASSERT (m_endPoint == 0);
}
if (m_endPoint6 != 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 UdpSocketImpl::Destroy below
* will will zero the m_endPoint field.
*/
NS_ASSERT (m_endPoint6 != 0);
m_udp->DeAllocate (m_endPoint6);
NS_ASSERT (m_endPoint6 == 0);
}
m_udp = 0;
}
// 设置节点，也就是设置这个UDP socket所需要绑定的主机
void
UdpSocketImpl::SetNode (Ptr<Node> node)
{
NS_LOG_FUNCTION_NOARGS ();
m_node = node;
}
// 设置这个socket所绑定的UDP协议对象
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;
}
// 得到socket类型
enum Socket::SocketType
UdpSocketImpl::GetSocketType (void) const
{
return NS3_SOCK_DGRAM;
}
// 得到绑定的主机
Ptr<Node>
UdpSocketImpl::GetNode (void) const
{
NS_LOG_FUNCTION_NOARGS ();
return m_node;
}
// 将当前的m_endPoint设置为0
void
UdpSocketImpl::Destroy (void)
{
NS_LOG_FUNCTION_NOARGS ();
m_endPoint = 0;
}
void
UdpSocketImpl::Destroy6 (void)
{
NS_LOG_FUNCTION_NOARGS ();
m_endPoint6 = 0;
}
/* Deallocate the end point and cancel all the timers */
void
UdpSocketImpl::DeallocateEndPoint (void)
{
if (m_endPoint != 0)
{
m_endPoint->SetDestroyCallback (MakeNullCallback<void> ());
/**
* 注意这里与下一条语句的区别是，第一条语句根据这个m_endPoint释放UdpL4Protocol中相关的资源，
* 由于作为协议，m_udp保有一系列的地址以及端口四元组，因为一个协议栈应当能够同时保有多个连接。当
* 当前连接要失效时，我们除了应当将当前连接的m_endPoint设置为0以外，也需要将协议中保有的关于这个
* 连接的信息删除（m_udp中有一个类型为Ipv4EndPointDemux的成员变量，其中存储了所有的endPoint）
*/
m_udp->DeAllocate (m_endPoint);
m_endPoint = 0;
}
if (m_endPoint6 != 0)
{
m_endPoint6->SetDestroyCallback (MakeNullCallback<void> ());
// 此处同上，为上面的IPv6版本
m_udp->DeAllocate (m_endPoint6);
m_endPoint6 = 0;
}
}
// 在Bind完成的最后时刻，我们需要通过调用这个函数来处理一些绑定的事情，也就是说这个函数是被Bind函数所调用
int
UdpSocketImpl::FinishBind (void)
{
NS_LOG_FUNCTION_NOARGS ();
bool done = false;
if (m_endPoint != 0)
{
/**
* 设置当接收到数据后的回调，这个回调函数无返回值。
* 由于MakeCallback函数的一个参数为成员函数，第二个参数为调用的对象，我们可以看到这里的成员函数
* 是UdpSocketImpl类中的ForwardUp函数，调用者为自己，但由于NS3系统中实现了自己的智能指针，所
* 以需要通过Ptr<UdpSocketImpl>进行包装后再传入。
* ForwardUp函数把接收到的包发送给上层，这条语句的意思是设置一个回调，当收到包之后将包转发给上层
*/
m_endPoint->SetRxCallback (MakeCallback (&UdpSocketImpl::ForwardUp, Ptr<UdpSocketImpl> (this)));
// 同样，当接收到ICMP包之后，将包转发给上层
m_endPoint->SetIcmpCallback (MakeCallback (&UdpSocketImpl::ForwardIcmp, Ptr<UdpSocketImpl> (this)));
m_endPoint->SetDestroyCallback (MakeCallback (&UdpSocketImpl::Destroy, Ptr<UdpSocketImpl> (this)));
done = true;
}
if (m_endPoint6 != 0)
{
m_endPoint6->SetRxCallback (MakeCallback (&UdpSocketImpl::ForwardUp6, Ptr<UdpSocketImpl> (this)));
m_endPoint6->SetIcmpCallback (MakeCallback (&UdpSocketImpl::ForwardIcmp6, Ptr<UdpSocketImpl> (this)));
m_endPoint6->SetDestroyCallback (MakeCallback (&UdpSocketImpl::Destroy6, Ptr<UdpSocketImpl> (this)));
done = true;
}
if (done)
{
return 0;
}
return -1;
}
int
UdpSocketImpl::Bind (void)
{
NS_LOG_FUNCTION_NOARGS ();
// 没有指定地址，那么就自动分配地址
m_endPoint = m_udp->Allocate ();
// 如果指定了网卡，那么将其绑定到网卡上；如果还未绑定网卡，那就先不指明绑定到哪一个网卡上
if (m_boundnetdevice)
{
m_endPoint->BindToNetDevice (m_boundnetdevice);
}
return FinishBind ();
}
// 这个函数和上一个作用相同，只是换成了IPv6的版本
int
UdpSocketImpl::Bind6 (void)
{
NS_LOG_FUNCTION_NOARGS ();
m_endPoint6 = m_udp->Allocate6 ();
if (m_boundnetdevice)
{
m_endPoint6->BindToNetDevice (m_boundnetdevice);
}
return FinishBind ();
}
// 这是指明了绑定地址的版本
int
UdpSocketImpl::Bind (const Address &address)
{
NS_LOG_FUNCTION (this << address);
// 如果address中存的是一个IPv4的地址
if (InetSocketAddress::IsMatchingType (address))
{
NS_ASSERT_MSG (m_endPoint == 0, "Endpoint already allocated.");
InetSocketAddress transport = InetSocketAddress::ConvertFrom (address);
Ipv4Address ipv4 = transport.GetIpv4 ();
uint16_t port = transport.GetPort ();
SetIpTos (transport.GetTos ());
/*
* 地址是0.0.0.0在socket bind中表示所有可用的interface，比如一个程序选择监听在0.0.0.0，则表示 * 要监听在所有的自己可用的IP地址（所有的网卡）上，所以不需要指定网卡。如果一个主机有两个IP地址， * 192.168.1.1 和 10.1.2.1，并且该主机上的一个服务监听的地址是0.0.0.0,那么通过两个ip地址都能 * 够访问该服务，端口是随机分配的。
*/
if (ipv4 == Ipv4Address::GetAny () && port == 0)
{
m_endPoint = m_udp->Allocate ();
}
// 指定端口后，需要根据当前设备来设置端口（因为一个网卡设备有一套端口系统）。
else if (ipv4 == Ipv4Address::GetAny () && port != 0)
{
m_endPoint = m_udp->Allocate (GetBoundNetDevice (), 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 (GetBoundNetDevice (), ipv4, port);
}
// 未设置成功，根据端口来判断错误类型，端口不是0时说明地址在使用，而端口是0时，说明地址不可用
if (0 == m_endPoint)
{
m_errno = port ? ERROR_ADDRINUSE : ERROR_ADDRNOTAVAIL;
return -1;
}
// 将这个连接绑定到设备上
if (m_boundnetdevice)
{
m_endPoint->BindToNetDevice (m_boundnetdevice);
}
}
// IPv6版本
else if (Inet6SocketAddress::IsMatchingType (address))
{
NS_ASSERT_MSG (m_endPoint == 0, "Endpoint already allocated.");
Inet6SocketAddress transport = Inet6SocketAddress::ConvertFrom (address);
Ipv6Address ipv6 = transport.GetIpv6 ();
uint16_t port = transport.GetPort ();
if (ipv6 == Ipv6Address::GetAny () && port == 0)
{
m_endPoint6 = m_udp->Allocate6 ();
}
else if (ipv6 == Ipv6Address::GetAny () && port != 0)
{
m_endPoint6 = m_udp->Allocate6 (GetBoundNetDevice (), port);
}
else if (ipv6 != Ipv6Address::GetAny () && port == 0)
{
m_endPoint6 = m_udp->Allocate6 (ipv6);
}
else if (ipv6 != Ipv6Address::GetAny () && port != 0)
{
m_endPoint6 = m_udp->Allocate6 (GetBoundNetDevice (), ipv6, port);
}
if (0 == m_endPoint6)
{
m_errno = port ? ERROR_ADDRINUSE : ERROR_ADDRNOTAVAIL;
return -1;
}
if (m_boundnetdevice)
{
m_endPoint6->BindToNetDevice (m_boundnetdevice);
}
if (ipv6.IsMulticast ())
{
Ptr<Ipv6L3Protocol> ipv6l3 = m_node->GetObject <Ipv6L3Protocol> ();
if (ipv6l3)
{
if (m_boundnetdevice == 0)
{
ipv6l3->AddMulticastAddress (ipv6);
}
else
{
uint32_t index = ipv6l3->GetInterfaceForDevice (m_boundnetdevice);
ipv6l3->AddMulticastAddress (m_endPoint6->GetLocalAddress (), index);
}
}
}
}
else
{
NS_LOG_ERROR ("Not IsMatchingType");
m_errno = ERROR_INVAL;
return -1;
}
// 完成回调的设置
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;
if (m_endPoint)
{
m_endPoint->SetRxEnabled (false);
}
if (m_endPoint6)
{
m_endPoint6->SetRxEnabled (false);
}
return 0;
}
int
UdpSocketImpl::Close (void)
{
NS_LOG_FUNCTION_NOARGS ();
if (m_shutdownRecv == true && m_shutdownSend == true)
{
m_errno = Socket::ERROR_BADF;
return -1;
}
Ipv6LeaveGroup ();
m_shutdownRecv = true;
m_shutdownSend = true;
DeallocateEndPoint ();
return 0;
}
// UDP是无连接的，所以这里的connect并不会向对端发送任何信息，而只是设置一些本地的变量
int
UdpSocketImpl::Connect (const Address & 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 ();
SetIpTos (transport.GetTos ());
m_connected = true;
// 这里需要执行回调函数
NotifyConnectionSucceeded ();
}
else if (Inet6SocketAddress::IsMatchingType(address) == true)
{
Inet6SocketAddress transport = Inet6SocketAddress::ConvertFrom (address);
m_defaultAddress = Address(transport.GetIpv6 ());
m_defaultPort = transport.GetPort ();
m_connected = true;
NotifyConnectionSucceeded ();
}
else
{
NotifyConnectionFailed ();
return -1;
}
return 0;
}
// UDP不需要LISTEN原语，所以错误为动作类型不支持
int
UdpSocketImpl::Listen (void)
{
m_errno = Socket::ERROR_OPNOTSUPP;
return -1;
}
// Send函数通过DoSend函数来发送包
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) && (Ipv4Address::IsMatchingType(m_defaultAddress) == true))
{
if (Bind () == -1)
{
NS_ASSERT (m_endPoint == 0);
return -1;
}
NS_ASSERT (m_endPoint != 0);
}
else if ((m_endPoint6 == 0) && (Ipv6Address::IsMatchingType(m_defaultAddress) == true))
{
if (Bind6 () == -1)
{
NS_ASSERT (m_endPoint6 == 0);
return -1;
}
NS_ASSERT (m_endPoint6 != 0);
}
// 关闭发送时不可发送
if (m_shutdownSend)
{
m_errno = ERROR_SHUTDOWN;
return -1;
}
// 主要流程：调用DoSendTo函数发送包
if (Ipv4Address::IsMatchingType (m_defaultAddress))
{
return DoSendTo (p, Ipv4Address::ConvertFrom (m_defaultAddress), m_defaultPort, GetIpTos ());
}
else if (Ipv6Address::IsMatchingType (m_defaultAddress))
{
return DoSendTo (p, Ipv6Address::ConvertFrom (m_defaultAddress), m_defaultPort);
}
m_errno = ERROR_AFNOSUPPORT;
return(-1);
}
int
UdpSocketImpl::DoSendTo (Ptr<Packet> p, Ipv4Address dest, uint16_t port, uint8_t tos)
{
NS_LOG_FUNCTION (this << p << dest << port << (uint16_t) tos);
if (m_boundnetdevice)
{
NS_LOG_LOGIC ("Bound interface number " << m_boundnetdevice->GetIfIndex ());
}
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;
}
// 如果指定了TOS，那么根据TOS对包进行设置
uint8_t priority = GetPriority ();
if (tos)
{
SocketIpTosTag ipTosTag;
ipTosTag.SetTos (tos);
// This packet may already have a SocketIpTosTag (see BUG 2440)
p->ReplacePacketTag (ipTosTag);
priority = IpTos2Priority (tos);
}
// 如果指定了优先级，则根据优先级进行设置
if (priority)
{
SocketPriorityTag priorityTag;
priorityTag.SetPriority (priority);
p->ReplacePacketTag (priorityTag);
}
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 (IsManualIpTtl () && GetIpTtl () != 0 && !dest.IsMulticast () && !dest.IsBroadcast ())
{
SocketIpTtlTag tag;
tag.SetTtl (GetIpTtl ());
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 ())
{
if (!m_allowBroadcast)
{
m_errno = ERROR_OPNOTSUPP;
return -1;
}
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 ();
if (addri == Ipv4Address ("127.0.0.1"))
continue;
// Check if interface-bound socket
if (m_boundnetdevice)
{
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 ());
}
NS_LOG_LOGIC ("Limited broadcast end.");
return p->GetSize ();
}
else if (m_endPoint->GetLocalAddress () != Ipv4Address::GetAny ())
{
m_udp->Send (p->Copy (), m_endPoint->GetLocalAddress (), dest,
m_endPoint->GetLocalPort (), port, 0);
NotifyDataSent (p->GetSize ());
NotifySend (GetTxAvailable ());
return p->GetSize ();
}
else if (ipv4->GetRoutingProtocol () != 0)
{
Ipv4Header header;
header.SetDestination (dest);
header.SetProtocol (UdpL4Protocol::PROT_NUMBER);
Socket::SocketErrno errno_;
Ptr<Ipv4Route> route;
Ptr<NetDevice> oif = m_boundnetdevice; //specify non-zero if bound to a specific device
// 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");
if (!m_allowBroadcast)
{
uint32_t outputIfIndex = ipv4->GetInterfaceForDevice (route->GetOutputDevice ());
uint32_t ifNAddr = ipv4->GetNAddresses (outputIfIndex);
for (uint32_t addrI = 0; addrI < ifNAddr; ++addrI)
{
Ipv4InterfaceAddress ifAddr = ipv4->GetAddress (outputIfIndex, addrI);
if (dest == ifAddr.GetBroadcast ())
{
m_errno = ERROR_OPNOTSUPP;
return -1;
}
}
}
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;
}
int
UdpSocketImpl::DoSendTo (Ptr<Packet> p, Ipv6Address dest, uint16_t port)
{
NS_LOG_FUNCTION (this << p << dest << port);
if (dest.IsIpv4MappedAddress ())
{
return (DoSendTo(p, dest.GetIpv4MappedAddress (), port, 0));
}
if (m_boundnetdevice)
{
NS_LOG_LOGIC ("Bound interface number " << m_boundnetdevice->GetIfIndex ());
}
if (m_endPoint6 == 0)
{
if (Bind6 () == -1)
{
NS_ASSERT (m_endPoint6 == 0);
return -1;
}
NS_ASSERT (m_endPoint6 != 0);
}
if (m_shutdownSend)
{
m_errno = ERROR_SHUTDOWN;
return -1;
}
if (p->GetSize () > GetTxAvailable () )
{
m_errno = ERROR_MSGSIZE;
return -1;
}
if (IsManualIpv6Tclass ())
{
SocketIpv6TclassTag ipTclassTag;
ipTclassTag.SetTclass (GetIpv6Tclass ());
p->AddPacketTag (ipTclassTag);
}
uint8_t priority = GetPriority ();
if (priority)
{
SocketPriorityTag priorityTag;
priorityTag.SetPriority (priority);
p->ReplacePacketTag (priorityTag);
}
Ptr<Ipv6> ipv6 = m_node->GetObject<Ipv6> ();
// 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 ())
{
SocketIpv6HopLimitTag tag;
tag.SetHopLimit (m_ipMulticastTtl);
p->AddPacketTag (tag);
}
else if (IsManualIpv6HopLimit () && GetIpv6HopLimit () != 0 && !dest.IsMulticast ())
{
SocketIpv6HopLimitTag tag;
tag.SetHopLimit (GetIpv6HopLimit ());
p->AddPacketTag (tag);
}
// There is no analgous to an IPv4 broadcast address in IPv6.
// Instead, we use a set of link-local, site-local, and global
// multicast addresses. The Ipv6 routing layers should all
// provide an interface-specific route to these addresses such
// that we can treat these multicast addresses as "not broadcast"
if (m_endPoint6->GetLocalAddress () != Ipv6Address::GetAny ())
{
m_udp->Send (p->Copy (), m_endPoint6->GetLocalAddress (), dest,
m_endPoint6->GetLocalPort (), port, 0);
NotifyDataSent (p->GetSize ());
NotifySend (GetTxAvailable ());
return p->GetSize ();
}
else if (ipv6->GetRoutingProtocol () != 0)
{
Ipv6Header header;
header.SetDestinationAddress (dest);
header.SetNextHeader (UdpL4Protocol::PROT_NUMBER);
Socket::SocketErrno errno_;
Ptr<Ipv6Route> route;
Ptr<NetDevice> oif = m_boundnetdevice; //specify non-zero if bound to a specific device
// TBD-- we could cache the route and just check its validity
route = ipv6->GetRoutingProtocol ()->RouteOutput (p, header, oif, errno_);
if (route != 0)
{
NS_LOG_LOGIC ("Route exists");
header.SetSourceAddress (route->GetSource ());
m_udp->Send (p->Copy (), header.GetSourceAddress (), header.GetDestinationAddress (),
m_endPoint6->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;
}
// maximum message size for UDP broadcast is limited by MTU
// size of underlying link; we are not checking that now.
// \todo Check MTU size of underlying link
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);
if (InetSocketAddress::IsMatchingType (address))
{
InetSocketAddress transport = InetSocketAddress::ConvertFrom (address);
Ipv4Address ipv4 = transport.GetIpv4 ();
uint16_t port = transport.GetPort ();
uint8_t tos = transport.GetTos ();
return DoSendTo (p, ipv4, port, tos);
}
else if (Inet6SocketAddress::IsMatchingType (address))
{
Inet6SocketAddress transport = Inet6SocketAddress::ConvertFrom (address);
Ipv6Address ipv6 = transport.GetIpv6 ();
uint16_t port = transport.GetPort ();
return DoSendTo (p, ipv6, port);
}
return -1;
}
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);
Address fromAddress;
Ptr<Packet> packet = RecvFrom (maxSize, flags, fromAddress);
return packet;
}
Ptr<Packet>
UdpSocketImpl::RecvFrom (uint32_t maxSize, uint32_t flags,
Address &fromAddress)
{
NS_LOG_FUNCTION (this << maxSize << flags);
if (m_deliveryQueue.empty () )
{
m_errno = ERROR_AGAIN;
return 0;
}
Ptr<Packet> p = m_deliveryQueue.front ().first;
fromAddress = m_deliveryQueue.front ().second;
if (p->GetSize () <= maxSize)
{
m_deliveryQueue.pop ();
m_rxAvailable -= p->GetSize ();
}
else
{
p = 0;
}
return p;
}
int
UdpSocketImpl::GetSockName (Address &address) const
{
NS_LOG_FUNCTION_NOARGS ();
if (m_endPoint != 0)
{
address = InetSocketAddress (m_endPoint->GetLocalAddress (), m_endPoint->GetLocalPort ());
}
else if (m_endPoint6 != 0)
{
address = Inet6SocketAddress (m_endPoint6->GetLocalAddress (), m_endPoint6->GetLocalPort ());
}
else
{ // It is possible to call this method on a socket without a name
// in which case, behavior is unspecified
// Should this return an InetSocketAddress or an Inet6SocketAddress?
address = InetSocketAddress (Ipv4Address::GetZero (), 0);
}
return 0;
}
int
UdpSocketImpl::GetPeerName (Address &address) const
{
NS_LOG_FUNCTION (this << address);
if (!m_connected)
{
m_errno = ERROR_NOTCONN;
return -1;
}
if (Ipv4Address::IsMatchingType (m_defaultAddress))
{
Ipv4Address addr = Ipv4Address::ConvertFrom (m_defaultAddress);
InetSocketAddress inet (addr, m_defaultPort);
inet.SetTos (GetIpTos ());
address = inet;
}
else if (Ipv6Address::IsMatchingType (m_defaultAddress))
{
Ipv6Address addr = Ipv6Address::ConvertFrom (m_defaultAddress);
address = Inet6SocketAddress (addr, m_defaultPort);
}
else
{
NS_ASSERT_MSG (false, "unexpected address type");
}
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::BindToNetDevice (Ptr<NetDevice> netdevice)
{
NS_LOG_FUNCTION (netdevice);
Ptr<NetDevice> oldBoundNetDevice = m_boundnetdevice;
Socket::BindToNetDevice (netdevice); // Includes sanity check
if (m_endPoint != 0)
{
m_endPoint->BindToNetDevice (netdevice);
}
if (m_endPoint6 != 0)
{
m_endPoint6->BindToNetDevice (netdevice);
// The following is to fix the multicast distribution inside the node
// and to upgrade it to the actual bound NetDevice.
if (m_endPoint6->GetLocalAddress ().IsMulticast ())
{
Ptr<Ipv6L3Protocol> ipv6l3 = m_node->GetObject <Ipv6L3Protocol> ();
if (ipv6l3)
{
// Cleanup old one
if (oldBoundNetDevice)
{
uint32_t index = ipv6l3->GetInterfaceForDevice (oldBoundNetDevice);
ipv6l3->RemoveMulticastAddress (m_endPoint6->GetLocalAddress (), index);
}
else
{
ipv6l3->RemoveMulticastAddress (m_endPoint6->GetLocalAddress ());
}
// add new one
if (netdevice)
{
uint32_t index = ipv6l3->GetInterfaceForDevice (netdevice);
ipv6l3->AddMulticastAddress (m_endPoint6->GetLocalAddress (), index);
}
else
{
ipv6l3->AddMulticastAddress (m_endPoint6->GetLocalAddress ());
}
}
}
}
return;
}
void
UdpSocketImpl::ForwardUp (Ptr<Packet> packet, Ipv4Header header, uint16_t port,
Ptr<Ipv4Interface> incomingInterface)
{
NS_LOG_FUNCTION (this << packet << header << port);
if (m_shutdownRecv)
{
return;
}
// Should check via getsockopt ()..
if (IsRecvPktInfo ())
{
Ipv4PacketInfoTag tag;
packet->RemovePacketTag (tag);
tag.SetRecvIf (incomingInterface->GetDevice ()->GetIfIndex ());
packet->AddPacketTag (tag);
}
//Check only version 4 options
if (IsIpRecvTos ())
{
SocketIpTosTag ipTosTag;
ipTosTag.SetTos (header.GetTos ());
packet->AddPacketTag (ipTosTag);
}
if (IsIpRecvTtl ())
{
SocketIpTtlTag ipTtlTag;
ipTtlTag.SetTtl (header.GetTtl ());
packet->AddPacketTag (ipTtlTag);
}
// in case the packet still has a priority tag attached, remove it
SocketPriorityTag priorityTag;
packet->RemovePacketTag (priorityTag);
if ((m_rxAvailable + packet->GetSize ()) <= m_rcvBufSize)
{
Address address = InetSocketAddress (header.GetSource (), port);
m_deliveryQueue.push (std::make_pair (packet, address));
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::ForwardUp6 (Ptr<Packet> packet, Ipv6Header header, uint16_t port, Ptr<Ipv6Interface> incomingInterface)
{
NS_LOG_FUNCTION (this << packet << header.GetSourceAddress () << port);
if (m_shutdownRecv)
{
return;
}
// Should check via getsockopt ().
if (IsRecvPktInfo ())
{
Ipv6PacketInfoTag tag;
packet->RemovePacketTag (tag);
tag.SetRecvIf (incomingInterface->GetDevice ()->GetIfIndex ());
packet->AddPacketTag (tag);
}
// Check only version 6 options
if (IsIpv6RecvTclass ())
{
SocketIpv6TclassTag ipTclassTag;
ipTclassTag.SetTclass (header.GetTrafficClass ());
packet->AddPacketTag (ipTclassTag);
}
if (IsIpv6RecvHopLimit ())
{
SocketIpv6HopLimitTag ipHopLimitTag;
ipHopLimitTag.SetHopLimit (header.GetHopLimit ());
packet->AddPacketTag (ipHopLimitTag);
}
// in case the packet still has a priority tag attached, remove it
SocketPriorityTag priorityTag;
packet->RemovePacketTag (priorityTag);
if ((m_rxAvailable + packet->GetSize ()) <= m_rcvBufSize)
{
Address address = Inet6SocketAddress (header.GetSourceAddress (), port);
m_deliveryQueue.push (std::make_pair (packet, address));
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::ForwardIcmp6 (Ipv6Address 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_icmpCallback6.IsNull ())
{
m_icmpCallback6 (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::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;
}
bool
UdpSocketImpl::SetAllowBroadcast (bool allowBroadcast)
{
m_allowBroadcast = allowBroadcast;
return true;
}
bool
UdpSocketImpl::GetAllowBroadcast () const
{
return m_allowBroadcast;
}
void
UdpSocketImpl::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);
}
}
}
}
} // namespace ns3
Leinux
求物之妙，如系风捕景，能使是物了然于心者，千万人而不一遇也。
🗞️ Recent Posts