Files
ns-3-dev/src/internet-stack/raw-socket-impl.cc
T

389 lines
11 KiB
C++

#include "raw-socket-impl.h"
#include "ipv4-l3-protocol.h"
#include "icmpv4.h"
#include "ns3/inet-socket-address.h"
#include "ns3/node.h"
#include "ns3/packet.h"
#include "ns3/uinteger.h"
#include "ns3/log.h"
#include "ipv4-interface.h"
#include "udp-header.h"
NS_LOG_COMPONENT_DEFINE ("RawSocketImpl");
namespace ns3
{
NS_OBJECT_ENSURE_REGISTERED (RawSocketImpl);
TypeId
RawSocketImpl::GetTypeId (void)
{
static TypeId tid = TypeId ("ns3::RawSocketImpl") .SetParent<Socket> () .AddAttribute ("Protocol", "Protocol number to match.", UintegerValue (0),
MakeUintegerAccessor (&RawSocketImpl::m_protocol), MakeUintegerChecker<uint16_t> ()) .AddAttribute ("IcmpFilter",
"Any icmp header whose type field matches a bit in this filter is dropped.", UintegerValue (0), MakeUintegerAccessor (
&RawSocketImpl::m_icmpFilter), MakeUintegerChecker<uint32_t> ());
return tid;
}
RawSocketImpl::RawSocketImpl ()
{
NS_LOG_FUNCTION (this);
m_err = Socket::ERROR_NOTERROR;
m_node = 0;
m_src = Ipv4Address::GetAny ();
m_dst = Ipv4Address::GetAny ();
m_protocol = 0;
m_shutdownSend = false;
m_shutdownRecv = false;
}
void
RawSocketImpl::SetNode (Ptr<Node> node)
{
m_node = node;
m_ipv4 = m_node->GetObject<Ipv4L3Protocol> ();
NS_ASSERT(m_ipv4 != 0);
for(uint32_t i = 0; i < m_ipv4->GetNInterfaces(); ++i)
{
m_interfaces.push_back (m_ipv4->GetInterface(i));
}
}
void
RawSocketImpl::DoDispose (void)
{
NS_LOG_FUNCTION (this);
m_node = 0;
Socket::DoDispose ();
}
enum Socket::SocketErrno
RawSocketImpl::GetErrno (void) const
{
NS_LOG_FUNCTION (this);
return m_err;
}
Ptr<Node>
RawSocketImpl::GetNode (void) const
{
NS_LOG_FUNCTION (this);
return m_node;
}
int
RawSocketImpl::Bind (const Address &address)
{
NS_LOG_FUNCTION (this << address);
if (!InetSocketAddress::IsMatchingType (address))
{
m_err = Socket::ERROR_INVAL;
return -1;
}
InetSocketAddress ad = InetSocketAddress::ConvertFrom (address);
m_src = ad.GetIpv4 ();
m_sport = ad.GetPort();
return 0;
}
int
RawSocketImpl::Bind (void)
{
NS_LOG_FUNCTION (this);
m_src = Ipv4Address::GetAny ();
m_sport = 0;
return 0;
}
int
RawSocketImpl::GetSockName (Address &address) const
{
address = InetSocketAddress (m_src, 0);
return 0;
}
int
RawSocketImpl::Close (void)
{
NS_LOG_FUNCTION (this);
Ptr<Ipv4L3Protocol> ipv4 = m_node->GetObject<Ipv4L3Protocol> ();
if (ipv4 != 0)
{
ipv4->DeleteRawSocket (this);
}
return 0;
}
int
RawSocketImpl::ShutdownSend (void)
{
NS_LOG_FUNCTION (this);
m_shutdownSend = true;
return 0;
}
int
RawSocketImpl::ShutdownRecv (void)
{
NS_LOG_FUNCTION (this);
m_shutdownRecv = true;
return 0;
}
int
RawSocketImpl::Connect (const Address &address)
{
NS_LOG_FUNCTION (this << address);
if (!InetSocketAddress::IsMatchingType (address))
{
m_err = Socket::ERROR_INVAL;
return -1;
}
InetSocketAddress ad = InetSocketAddress::ConvertFrom (address);
m_dst = ad.GetIpv4 ();
return 0;
}
int
RawSocketImpl::Listen (void)
{
NS_LOG_FUNCTION (this);
m_err = Socket::ERROR_OPNOTSUPP;
return -1;
}
uint32_t
RawSocketImpl::GetTxAvailable (void) const
{
NS_LOG_FUNCTION (this);
return 0xffffffff;
}
int
RawSocketImpl::Send (Ptr<Packet> p, uint32_t flags)
{
NS_LOG_FUNCTION (this << " packet " << p << flags);
InetSocketAddress to = InetSocketAddress (m_dst, m_protocol);
return SendTo (p, flags, to);
}
int
RawSocketImpl::SendTo (Ptr<Packet> packet, uint32_t flags, const Address &toAddress)
{
if (!InetSocketAddress::IsMatchingType (toAddress))
{
m_err = Socket::ERROR_INVAL;
return -1;
}
if (m_shutdownSend)
{
return 0;
}
if (m_ipv4->GetRoutingProtocol ())
{
Ipv4Header header;
Ptr<Packet> copy = packet->Copy();
copy->RemoveHeader (header);
NS_LOG_LOGIC ("RawSocketImpl::SendTo packet uid " << packet->GetUid() << " address " << header.GetDestination());
SocketErrno errno_ = ERROR_NOTERROR;//do not use errno as it is the standard C last error number
Ptr<Ipv4Route> route;
uint32_t oif = 0; //specify non-zero if bound to a source address
route = m_ipv4->GetRoutingProtocol ()->RouteOutput (copy, header, oif, errno_);
if (route != 0)
{
NS_LOG_LOGIC ("Route exists");
SendByInterface(packet, route);
}
else
{
NS_LOG_LOGIC ("dropped because no outgoing route.");
}
}
return 0;
}
void
RawSocketImpl::SendByInterface (Ptr<Packet> p, Ptr<const Ipv4Route> route)
{
NS_ASSERT(m_node != 0);
Ipv4Header ipv4Header;
Ptr<Packet> packet = p->Copy();
packet->RemoveHeader(ipv4Header);
Ipv4Address source = ipv4Header.GetSource ();
Ipv4Address destination = ipv4Header.GetDestination ();
NS_LOG_LOGIC ("RawSocketImpl::SendByInterface to " << destination << " from " << source);
// Handle a few cases:
// 1) packet is destined to limited broadcast address
// 2) packet is destined to a subnet-directed broadcast address
// 3) packet is not broadcast, and is passed in with a route entry
const Ipv4Address loopback ("127.0.0.1");
// 1) packet is destined to limited broadcast address
if (destination.IsBroadcast ())
{
NS_LOG_LOGIC ("RawSocketImpl::Send case 1: limited broadcast");
for (std::list< Ptr<Ipv4Interface> >::iterator ifaceIter = m_interfaces.begin (); ifaceIter != m_interfaces.end (); ifaceIter++)
{
Ptr<Ipv4Interface> outInterface = *ifaceIter;
Ptr<Packet> packetCopy = p->Copy ();
NS_ASSERT (packet->GetSize () <= outInterface->GetDevice()->GetMtu ());
outInterface->Send (packetCopy, destination);
}
return;
}
// 2) check: packet is destined to a subnet-directed broadcast address
bool result = false;
uint32_t ifaceIndex = 0;
NS_LOG_LOGIC("number of interfaces " << m_interfaces.size ());
for (std::list< Ptr<Ipv4Interface> >::iterator ifaceIter = m_interfaces.begin (); ifaceIter != m_interfaces.end (); ifaceIter++, ifaceIndex++)
{
Ptr<Ipv4Interface> outInterface = *ifaceIter;
for (uint32_t j = 0; j < m_ipv4->GetNAddresses (ifaceIndex); j++)
{
Ipv4InterfaceAddress ifAddr = m_ipv4->GetAddress (ifaceIndex, j);
NS_LOG_LOGIC ("Testing address " << ifAddr.GetLocal () << " with mask " << ifAddr.GetMask ());
if (destination.IsSubnetDirectedBroadcast (ifAddr.GetMask ()) &&
(destination.CombineMask (ifAddr.GetMask ()) == ifAddr.GetLocal ().CombineMask (ifAddr.GetMask ())) )
//if (ifAddr.GetLocal() == source)
{
NS_LOG_LOGIC ("Send case 2: subnet directed bcast to " << ifAddr.GetLocal ());
Ptr<Packet> packetCopy = p->Copy ();
outInterface->Send (packetCopy, destination);
result = true;
}
}
}
if(result) return;
// 3) packet is not broadcast, and is passed in with a route entry
// with a valid Ipv4Address as the gateway
if (route && route->GetGateway () != Ipv4Address ())
{
NS_LOG_UNCOND ("RawSocketImpl::Send case 3: passed in with route");
Ptr<NetDevice> outDev = route->GetOutputDevice ();
int32_t interface = m_ipv4->GetInterfaceForDevice (outDev);
NS_ASSERT (interface >= 0);
Ptr<Ipv4Interface> outInterface = m_ipv4->GetInterface (interface);
NS_LOG_UNCOND ("Send via NetDevice ifIndex " << outDev->GetIfIndex () << " ipv4InterfaceIndex " << interface);
NS_ASSERT (p->GetSize () <= outInterface->GetDevice ()->GetMtu ());
if (!route->GetGateway ().IsEqual (Ipv4Address ("0.0.0.0")))
{
if (outInterface->IsUp ())
{
NS_LOG_UNCOND ("Send to gateway " << route->GetGateway ());
Ptr<Packet> packetCopy = p->Copy ();
outInterface->Send (packetCopy, route->GetGateway ());
}
else
{
NS_LOG_UNCOND ("Dropping-- outgoing interface is down: " << route->GetGateway ());
}
}
else
{
if (outInterface->IsUp ())
{
Ptr<Packet> packetCopy = p->Copy ();
NS_LOG_UNCOND ("Send to destination " << destination);
outInterface->Send (packetCopy, destination);
}
else
{
NS_LOG_UNCOND ("Dropping-- outgoing interface is down: " << destination);
}
} return;
}
}
uint32_t
RawSocketImpl::GetRxAvailable (void) const
{
NS_LOG_FUNCTION (this);
uint32_t rx = 0;
for (std::list<Data>::const_iterator i = m_recv.begin (); i != m_recv.end (); ++i)
{
rx += (i->packet)->GetSize ();
}
return rx;
}
Ptr<Packet>
RawSocketImpl::Recv (uint32_t maxSize, uint32_t flags)
{
NS_LOG_UNCOND ("RawSocketImpl::Recv" << maxSize << flags);
Address tmp;
return RecvFrom (maxSize, flags, tmp);
}
Ptr<Packet>
RawSocketImpl::RecvFrom (uint32_t maxSize, uint32_t flags, Address &fromAddress)
{
NS_LOG_UNCOND ("RawSocketImpl::RecvFrom" << " maxSize " << maxSize << " flags " << flags << " address " <<fromAddress);
if (m_recv.empty ())
{
return 0;
}
struct Data data = m_recv.front ();
m_recv.pop_front ();
if (data.packet->GetSize () > maxSize)
{
Ptr<Packet> first = data.packet->CreateFragment (0, maxSize);
data.packet->RemoveAtStart (maxSize);
m_recv.push_front (data);
return first;
}
InetSocketAddress inet = InetSocketAddress (data.fromIp, data.fromProtocol);
fromAddress = inet;
return data.packet;
}
void
RawSocketImpl::SetProtocol (uint16_t protocol)
{
NS_LOG_FUNCTION (this << protocol);
m_protocol = protocol;
}
bool
RawSocketImpl::ForwardUp (Ptr<const Packet> p, Ptr<NetDevice> device)
{
if (m_shutdownRecv)
{
return false;
}
Ptr<Packet> copy = p->Copy ();
Ipv4Header ipHeader;
copy->RemoveHeader(ipHeader);
for (std::list< Ptr<Ipv4Interface> >::const_iterator ifaceIter = m_interfaces.begin (); ifaceIter != m_interfaces.end (); ifaceIter++)
{
for (uint32_t i = 0; i < (*ifaceIter)->GetNAddresses(); ++i)
{
if ((*ifaceIter)->GetAddress(i).GetLocal() == ipHeader.GetSource())
return true;
}
}
UdpHeader udpHeader;
copy->RemoveHeader(udpHeader);
NS_LOG_LOGIC ("src = " << m_src << " dst = " << m_dst);
if ( m_sport == udpHeader.GetDestinationPort () && ipHeader.GetProtocol () == m_protocol)
{
if (m_protocol == 1)
{
Icmpv4Header icmpHeader;
copy->PeekHeader (icmpHeader);
uint8_t type = icmpHeader.GetType ();
if (type < 32 && ((1 << type) & m_icmpFilter))
{
// filter out icmp packet.
return false;
}
}
Ptr<Packet> packet = p->Copy();
struct Data data;
data.packet = packet;
data.fromIp = ipHeader.GetSource ();
data.fromProtocol = ipHeader.GetProtocol ();
m_recv.push_back (data);
NotifyDataRecv ();
return true;
}
return false;
}
} // namespace ns3