A Discrete-Event Network Simulator
API
udp-l4-protocol.cc
Go to the documentation of this file.
1 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
2 /*
3  * Copyright (c) 2005 INRIA
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License version 2 as
7  * published by the Free Software Foundation;
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software
16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17  *
18  * Author: Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
19  */
20 
21 #include "ns3/log.h"
22 #include "ns3/assert.h"
23 #include "ns3/packet.h"
24 #include "ns3/node.h"
25 #include "ns3/boolean.h"
26 #include "ns3/object-vector.h"
27 #include "ns3/ipv6.h"
28 #include "ns3/ipv4-route.h"
29 #include "ns3/ipv6-route.h"
30 #include "ns3/ipv6-header.h"
31 
32 #include "udp-l4-protocol.h"
33 #include "udp-header.h"
35 #include "ipv4-end-point-demux.h"
36 #include "ipv4-end-point.h"
37 #include "ipv6-end-point-demux.h"
38 #include "ipv6-end-point.h"
39 #include "ipv4-l3-protocol.h"
40 #include "ipv6-l3-protocol.h"
41 #include "udp-socket-impl.h"
42 
43 namespace ns3 {
44 
45 NS_LOG_COMPONENT_DEFINE ("UdpL4Protocol");
46 
47 NS_OBJECT_ENSURE_REGISTERED (UdpL4Protocol);
48 
49 /* see http://www.iana.org/assignments/protocol-numbers */
50 const uint8_t UdpL4Protocol::PROT_NUMBER = 17;
51 
52 TypeId
54 {
55  static TypeId tid = TypeId ("ns3::UdpL4Protocol")
57  .SetGroupName ("Internet")
58  .AddConstructor<UdpL4Protocol> ()
59  .AddAttribute ("SocketList", "The list of sockets associated to this protocol.",
62  MakeObjectVectorChecker<UdpSocketImpl> ())
63  ;
64  return tid;
65 }
66 
68  : m_endPoints (new Ipv4EndPointDemux ()), m_endPoints6 (new Ipv6EndPointDemux ())
69 {
71 }
72 
74 {
76 }
77 
78 void
80 {
81  m_node = node;
82 }
83 
84 /*
85  * This method is called by AggregateObject and completes the aggregation
86  * by setting the node in the udp stack and link it to the ipv4 object
87  * present in the node along with the socket factory
88  */
89 void
91 {
92  NS_LOG_FUNCTION (this);
93  Ptr<Node> node = this->GetObject<Node> ();
94  Ptr<Ipv4> ipv4 = this->GetObject<Ipv4> ();
95  Ptr<Ipv6> ipv6 = node->GetObject<Ipv6> ();
96 
97  if (m_node == 0)
98  {
99  if ((node != 0) && (ipv4 != 0 || ipv6 != 0))
100  {
101  this->SetNode (node);
102  Ptr<UdpSocketFactoryImpl> udpFactory = CreateObject<UdpSocketFactoryImpl> ();
103  udpFactory->SetUdp (this);
104  node->AggregateObject (udpFactory);
105  }
106  }
107 
108  // We set at least one of our 2 down targets to the IPv4/IPv6 send
109  // functions. Since these functions have different prototypes, we
110  // need to keep track of whether we are connected to an IPv4 or
111  // IPv6 lower layer and call the appropriate one.
112 
113  if (ipv4 != 0 && m_downTarget.IsNull())
114  {
115  ipv4->Insert (this);
116  this->SetDownTarget (MakeCallback (&Ipv4::Send, ipv4));
117  }
118  if (ipv6 != 0 && m_downTarget6.IsNull())
119  {
120  ipv6->Insert (this);
121  this->SetDownTarget6 (MakeCallback (&Ipv6::Send, ipv6));
122  }
124 }
125 
126 int
128 {
129  return PROT_NUMBER;
130 }
131 
132 
133 void
135 {
137  for (std::vector<Ptr<UdpSocketImpl> >::iterator i = m_sockets.begin (); i != m_sockets.end (); i++)
138  {
139  *i = 0;
140  }
141  m_sockets.clear ();
142 
143  if (m_endPoints != 0)
144  {
145  delete m_endPoints;
146  m_endPoints = 0;
147  }
148  if (m_endPoints6 != 0)
149  {
150  delete m_endPoints6;
151  m_endPoints6 = 0;
152  }
153  m_node = 0;
156 /*
157  = MakeNullCallback<void,Ptr<Packet>, Ipv4Address, Ipv4Address, uint8_t, Ptr<Ipv4Route> > ();
158 */
160 }
161 
164 {
166  Ptr<UdpSocketImpl> socket = CreateObject<UdpSocketImpl> ();
167  socket->SetNode (m_node);
168  socket->SetUdp (this);
169  m_sockets.push_back (socket);
170  return socket;
171 }
172 
173 Ipv4EndPoint *
175 {
176  NS_LOG_FUNCTION (this);
177  return m_endPoints->Allocate ();
178 }
179 
180 Ipv4EndPoint *
182 {
183  NS_LOG_FUNCTION (this << address);
184  return m_endPoints->Allocate (address);
185 }
186 
187 Ipv4EndPoint *
188 UdpL4Protocol::Allocate (Ptr<NetDevice> boundNetDevice, uint16_t port)
189 {
190  NS_LOG_FUNCTION (this << boundNetDevice << port);
191  return m_endPoints->Allocate (boundNetDevice, port);
192 }
193 
194 Ipv4EndPoint *
196 {
197  NS_LOG_FUNCTION (this << boundNetDevice << address << port);
198  return m_endPoints->Allocate (boundNetDevice, address, port);
199 }
200 Ipv4EndPoint *
202  Ipv4Address localAddress, uint16_t localPort,
203  Ipv4Address peerAddress, uint16_t peerPort)
204 {
205  NS_LOG_FUNCTION (this << boundNetDevice << localAddress << localPort << peerAddress << peerPort);
206  return m_endPoints->Allocate (boundNetDevice,
207  localAddress, localPort,
208  peerAddress, peerPort);
209 }
210 
211 void
213 {
214  NS_LOG_FUNCTION (this << endPoint);
215  m_endPoints->DeAllocate (endPoint);
216 }
217 
218 Ipv6EndPoint *
220 {
221  NS_LOG_FUNCTION (this);
222  return m_endPoints6->Allocate ();
223 }
224 
225 Ipv6EndPoint *
227 {
228  NS_LOG_FUNCTION (this << address);
229  return m_endPoints6->Allocate (address);
230 }
231 
232 Ipv6EndPoint *
233 UdpL4Protocol::Allocate6 (Ptr<NetDevice> boundNetDevice, uint16_t port)
234 {
235  NS_LOG_FUNCTION (this << boundNetDevice << port);
236  return m_endPoints6->Allocate (boundNetDevice, port);
237 }
238 
239 Ipv6EndPoint *
241 {
242  NS_LOG_FUNCTION (this << boundNetDevice << address << port);
243  return m_endPoints6->Allocate (boundNetDevice, address, port);
244 }
245 Ipv6EndPoint *
247  Ipv6Address localAddress, uint16_t localPort,
248  Ipv6Address peerAddress, uint16_t peerPort)
249 {
250  NS_LOG_FUNCTION (this << boundNetDevice << localAddress << localPort << peerAddress << peerPort);
251  return m_endPoints6->Allocate (boundNetDevice,
252  localAddress, localPort,
253  peerAddress, peerPort);
254 }
255 
256 void
258 {
259  NS_LOG_FUNCTION (this << endPoint);
260  m_endPoints6->DeAllocate (endPoint);
261 }
262 
263 void
264 UdpL4Protocol::ReceiveIcmp (Ipv4Address icmpSource, uint8_t icmpTtl,
265  uint8_t icmpType, uint8_t icmpCode, uint32_t icmpInfo,
266  Ipv4Address payloadSource,Ipv4Address payloadDestination,
267  const uint8_t payload[8])
268 {
269  NS_LOG_FUNCTION (this << icmpSource << icmpTtl << icmpType << icmpCode << icmpInfo
270  << payloadSource << payloadDestination);
271  uint16_t src, dst;
272  src = payload[0] << 8;
273  src |= payload[1];
274  dst = payload[2] << 8;
275  dst |= payload[3];
276 
277  Ipv4EndPoint *endPoint = m_endPoints->SimpleLookup (payloadSource, src, payloadDestination, dst);
278  if (endPoint != 0)
279  {
280  endPoint->ForwardIcmp (icmpSource, icmpTtl, icmpType, icmpCode, icmpInfo);
281  }
282  else
283  {
284  NS_LOG_DEBUG ("no endpoint found source=" << payloadSource <<
285  ", destination="<<payloadDestination<<
286  ", src=" << src << ", dst=" << dst);
287  }
288 }
289 
290 void
291 UdpL4Protocol::ReceiveIcmp (Ipv6Address icmpSource, uint8_t icmpTtl,
292  uint8_t icmpType, uint8_t icmpCode, uint32_t icmpInfo,
293  Ipv6Address payloadSource,Ipv6Address payloadDestination,
294  const uint8_t payload[8])
295 {
296  NS_LOG_FUNCTION (this << icmpSource << icmpTtl << icmpType << icmpCode << icmpInfo
297  << payloadSource << payloadDestination);
298  uint16_t src, dst;
299  src = payload[0] << 8;
300  src |= payload[1];
301  dst = payload[2] << 8;
302  dst |= payload[3];
303 
304  Ipv6EndPoint *endPoint = m_endPoints6->SimpleLookup (payloadSource, src, payloadDestination, dst);
305  if (endPoint != 0)
306  {
307  endPoint->ForwardIcmp (icmpSource, icmpTtl, icmpType, icmpCode, icmpInfo);
308  }
309  else
310  {
311  NS_LOG_DEBUG ("no endpoint found source=" << payloadSource <<
312  ", destination="<<payloadDestination<<
313  ", src=" << src << ", dst=" << dst);
314  }
315 }
316 
319  Ipv4Header const &header,
320  Ptr<Ipv4Interface> interface)
321 {
322  NS_LOG_FUNCTION (this << packet << header);
323  UdpHeader udpHeader;
324  if(Node::ChecksumEnabled ())
325  {
326  udpHeader.EnableChecksums ();
327  }
328 
329  udpHeader.InitializeChecksum (header.GetSource (), header.GetDestination (), PROT_NUMBER);
330 
331  // We only peek at the header for now (instead of removing it) so that it will be intact
332  // if we have to pass it to a IPv6 endpoint via:
333  //
334  // UdpL4Protocol::Receive (Ptr<Packet> packet, Ipv6Address &src, Ipv6Address &dst, ...)
335 
336  packet->PeekHeader (udpHeader);
337 
338  if(!udpHeader.IsChecksumOk ())
339  {
340  NS_LOG_INFO ("Bad checksum : dropping packet!");
342  }
343 
344  NS_LOG_DEBUG ("Looking up dst " << header.GetDestination () << " port " << udpHeader.GetDestinationPort ());
345  Ipv4EndPointDemux::EndPoints endPoints =
346  m_endPoints->Lookup (header.GetDestination (), udpHeader.GetDestinationPort (),
347  header.GetSource (), udpHeader.GetSourcePort (), interface);
348  if (endPoints.empty ())
349  {
350  if (this->GetObject<Ipv6L3Protocol> () != 0)
351  {
352  NS_LOG_LOGIC (" No Ipv4 endpoints matched on UdpL4Protocol, trying Ipv6 "<<this);
353  Ptr<Ipv6Interface> fakeInterface;
354  Ipv6Header ipv6Header;
357  ipv6Header.SetSourceAddress (src);
358  ipv6Header.SetDestinationAddress (dst);
359  return (this->Receive (packet, ipv6Header, fakeInterface));
360  }
361 
362  NS_LOG_LOGIC ("RX_ENDPOINT_UNREACH");
364  }
365 
366  packet->RemoveHeader(udpHeader);
367  for (Ipv4EndPointDemux::EndPointsI endPoint = endPoints.begin ();
368  endPoint != endPoints.end (); endPoint++)
369  {
370  (*endPoint)->ForwardUp (packet->Copy (), header, udpHeader.GetSourcePort (),
371  interface);
372  }
373  return IpL4Protocol::RX_OK;
374 }
375 
378  Ipv6Header const &header,
379  Ptr<Ipv6Interface> interface)
380 {
381  NS_LOG_FUNCTION (this << packet << header.GetSourceAddress () << header.GetDestinationAddress ());
382  UdpHeader udpHeader;
383  if(Node::ChecksumEnabled ())
384  {
385  udpHeader.EnableChecksums ();
386  }
387 
388  udpHeader.InitializeChecksum (header.GetSourceAddress (), header.GetDestinationAddress (), PROT_NUMBER);
389 
390  packet->RemoveHeader (udpHeader);
391 
392  if(!udpHeader.IsChecksumOk () && !header.GetSourceAddress ().IsIpv4MappedAddress ())
393  {
394  NS_LOG_INFO ("Bad checksum : dropping packet!");
396  }
397 
398  NS_LOG_DEBUG ("Looking up dst " << header.GetDestinationAddress () << " port " << udpHeader.GetDestinationPort ());
399  Ipv6EndPointDemux::EndPoints endPoints =
400  m_endPoints6->Lookup (header.GetDestinationAddress (), udpHeader.GetDestinationPort (),
401  header.GetSourceAddress (), udpHeader.GetSourcePort (), interface);
402  if (endPoints.empty ())
403  {
404  NS_LOG_LOGIC ("RX_ENDPOINT_UNREACH");
406  }
407  for (Ipv6EndPointDemux::EndPointsI endPoint = endPoints.begin ();
408  endPoint != endPoints.end (); endPoint++)
409  {
410  (*endPoint)->ForwardUp (packet->Copy (), header, udpHeader.GetSourcePort (), interface);
411  }
412  return IpL4Protocol::RX_OK;
413 }
414 
415 void
417  Ipv4Address saddr, Ipv4Address daddr,
418  uint16_t sport, uint16_t dport)
419 {
420  NS_LOG_FUNCTION (this << packet << saddr << daddr << sport << dport);
421 
422  UdpHeader udpHeader;
423  if(Node::ChecksumEnabled ())
424  {
425  udpHeader.EnableChecksums ();
426  udpHeader.InitializeChecksum (saddr,
427  daddr,
428  PROT_NUMBER);
429  }
430  udpHeader.SetDestinationPort (dport);
431  udpHeader.SetSourcePort (sport);
432 
433  packet->AddHeader (udpHeader);
434 
435  m_downTarget (packet, saddr, daddr, PROT_NUMBER, 0);
436 }
437 
438 void
440  Ipv4Address saddr, Ipv4Address daddr,
441  uint16_t sport, uint16_t dport, Ptr<Ipv4Route> route)
442 {
443  NS_LOG_FUNCTION (this << packet << saddr << daddr << sport << dport << route);
444 
445  UdpHeader udpHeader;
446  if(Node::ChecksumEnabled ())
447  {
448  udpHeader.EnableChecksums ();
449  udpHeader.InitializeChecksum (saddr,
450  daddr,
451  PROT_NUMBER);
452  }
453  udpHeader.SetDestinationPort (dport);
454  udpHeader.SetSourcePort (sport);
455 
456  packet->AddHeader (udpHeader);
457 
458  m_downTarget (packet, saddr, daddr, PROT_NUMBER, route);
459 }
460 
461 void
463  Ipv6Address saddr, Ipv6Address daddr,
464  uint16_t sport, uint16_t dport)
465 {
466  NS_LOG_FUNCTION (this << packet << saddr << daddr << sport << dport);
467 
468  UdpHeader udpHeader;
469  if(Node::ChecksumEnabled ())
470  {
471  udpHeader.EnableChecksums ();
472  udpHeader.InitializeChecksum (saddr,
473  daddr,
474  PROT_NUMBER);
475  }
476  udpHeader.SetDestinationPort (dport);
477  udpHeader.SetSourcePort (sport);
478 
479  packet->AddHeader (udpHeader);
480 
481  m_downTarget6 (packet, saddr, daddr, PROT_NUMBER, 0);
482 }
483 
484 void
486  Ipv6Address saddr, Ipv6Address daddr,
487  uint16_t sport, uint16_t dport, Ptr<Ipv6Route> route)
488 {
489  NS_LOG_FUNCTION (this << packet << saddr << daddr << sport << dport << route);
490 
491  UdpHeader udpHeader;
492  if(Node::ChecksumEnabled ())
493  {
494  udpHeader.EnableChecksums ();
495  udpHeader.InitializeChecksum (saddr,
496  daddr,
497  PROT_NUMBER);
498  }
499  udpHeader.SetDestinationPort (dport);
500  udpHeader.SetSourcePort (sport);
501 
502  packet->AddHeader (udpHeader);
503 
504  m_downTarget6 (packet, saddr, daddr, PROT_NUMBER, route);
505 }
506 
507 void
509 {
510  NS_LOG_FUNCTION (this);
511  m_downTarget = callback;
512 }
513 
516 {
517  return m_downTarget;
518 }
519 
520 void
522 {
523  NS_LOG_FUNCTION (this);
524  m_downTarget6 = callback;
525 }
526 
529 {
530  return m_downTarget6;
531 }
532 
533 } // namespace ns3
534 
uint32_t RemoveHeader(Header &header)
Deserialize and remove the header from the internal buffer.
Definition: packet.cc:280
Packet header for IPv6.
Definition: ipv6-header.h:34
Ptr< Socket > CreateSocket(void)
#define NS_LOG_FUNCTION(parameters)
If log level LOG_FUNCTION is enabled, this macro will output all input parameters separated by "...
void InitializeChecksum(Address source, Address destination, uint8_t protocol)
Definition: udp-header.cc:75
virtual void DoDispose(void)
Destructor implementation.
bool IsIpv4MappedAddress() const
If the address is an IPv4-mapped address.
#define NS_OBJECT_ENSURE_REGISTERED(type)
Register an Object subclass with the TypeId system.
Definition: object-base.h:45
std::list< Ipv6EndPoint * > EndPoints
Container of the IPv6 endpoints.
Access to the IPv6 forwarding table, interfaces, and configuration.
Definition: ipv6.h:81
EndPoints Lookup(Ipv6Address dst, uint16_t dport, Ipv6Address src, uint16_t sport, Ptr< Ipv6Interface > incomingInterface)
lookup for a match with all the parameters.
virtual void SetDownTarget(IpL4Protocol::DownTargetCallback cb)
This method allows a caller to set the current down target callback set for this L4 protocol (IPv4 ca...
static bool ChecksumEnabled(void)
Definition: node.cc:276
void AggregateObject(Ptr< Object > other)
Aggregate two Objects together.
Definition: object.cc:252
void SetDestinationPort(uint16_t port)
Definition: udp-header.cc:55
Ipv4Address GetSource(void) const
Definition: ipv4-header.cc:291
Ptr< const AttributeAccessor > MakeObjectVectorAccessor(U T::*memberVariable)
MakeAccessorHelper implementation for ObjectVector.
Definition: object-vector.h:81
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Definition: log.h:205
void SetSourcePort(uint16_t port)
Definition: udp-header.cc:60
#define NS_LOG_INFO(msg)
Use NS_LOG to output a message of level LOG_INFO.
Definition: log.h:281
virtual void DoDispose(void)
Destructor implementation.
Definition: object.cc:346
#define NS_LOG_FUNCTION_NOARGS()
Output the name of the function.
virtual IpL4Protocol::DownTargetCallback GetDownTarget(void) const
This method allows a caller to get the current down target callback set for this L4 protocol (IPv4 ca...
std::list< Ipv6EndPoint * >::iterator EndPointsI
Iterator to the container of the IPv6 endpoints.
Ptr< Node > m_node
the node this stack is associated with
virtual void SetDownTarget6(IpL4Protocol::DownTargetCallback6 cb)
This method allows a caller to set the current down target callback set for this L4 protocol (IPv6 ca...
void SetNode(Ptr< Node > node)
Set node associated with this stack.
uint16_t port
Definition: dsdv-manet.cc:45
Demultiplexes packets to various transport layer endpoints.
Packet header for IPv4.
Definition: ipv4-header.h:33
virtual void Send(Ptr< Packet > packet, Ipv6Address source, Ipv6Address destination, uint8_t protocol, Ptr< Ipv6Route > route)=0
Higher-level layers call this method to send a packet down the stack to the MAC and PHY layers...
virtual enum IpL4Protocol::RxStatus Receive(Ptr< Packet > p, Ipv4Header const &header, Ptr< Ipv4Interface > interface)
Called from lower-level layers to send the packet up in the stack.
void EnableChecksums(void)
Enable checksum calculation for UDP.
Definition: udp-header.cc:49
uint16_t GetDestinationPort(void) const
Definition: udp-header.cc:70
Ipv4EndPoint * Allocate(void)
Allocate an IPv4 Endpoint.
Ipv6EndPoint * Allocate(void)
Allocate a Ipv6EndPoint.
uint32_t PeekHeader(Header &header) const
Deserialize but does not remove the header from the internal buffer.
Definition: packet.cc:290
Callback< R > MakeCallback(R(T::*memPtr)(void), OBJ objPtr)
Definition: callback.h:1610
Ipv6Address GetSourceAddress(void) const
Get the "Source address" field.
Definition: ipv6-header.cc:100
static TypeId GetTypeId(void)
Get the type ID.
virtual int GetProtocolNumber(void) const
Returns the protocol number of this protocol.
void DeAllocate(Ipv6EndPoint *endPoint)
Remove a end point.
Ptr< T > GetObject(void) const
Get a pointer to the requested aggregated Object.
Definition: object.h:461
Every class exported by the ns3 library is enclosed in the ns3 namespace.
virtual void ReceiveIcmp(Ipv4Address icmpSource, uint8_t icmpTtl, uint8_t icmpType, uint8_t icmpCode, uint32_t icmpInfo, Ipv4Address payloadSource, Ipv4Address payloadDestination, const uint8_t payload[8])
Called from lower-level layers to send the ICMP packet up in the stack.
address
Definition: first.py:44
Ipv6EndPointDemux * m_endPoints6
A list of IPv6 end points.
void ForwardIcmp(Ipv4Address icmpSource, uint8_t icmpTtl, uint8_t icmpType, uint8_t icmpCode, uint32_t icmpInfo)
Forward the ICMP packet to the upper level.
Ipv6EndPoint * SimpleLookup(Ipv6Address dst, uint16_t dport, Ipv6Address src, uint16_t sport)
Simple lookup for a four-tuple match.
Ptr< Packet > Copy(void) const
performs a COW copy of the packet.
Definition: packet.cc:121
Packet header for UDP packets.
Definition: udp-header.h:39
virtual void Send(Ptr< Packet > packet, Ipv4Address source, Ipv4Address destination, uint8_t protocol, Ptr< Ipv4Route > route)=0
Ipv4EndPoint * SimpleLookup(Ipv4Address daddr, uint16_t dport, Ipv4Address saddr, uint16_t sport)
simple lookup for a match with all the parameters.
L4 Protocol abstract base class.
void DeAllocate(Ipv4EndPoint *endPoint)
Remove an IPv4 Endpoint.
NS_LOG_LOGIC("Net device "<< nd<< " is not bridged")
IpL4Protocol::DownTargetCallback6 m_downTarget6
Callback to send packets over IPv6.
EndPoints Lookup(Ipv4Address daddr, uint16_t dport, Ipv4Address saddr, uint16_t sport, Ptr< Ipv4Interface > incomingInterface)
lookup for a match with all the parameters.
virtual IpL4Protocol::DownTargetCallback6 GetDownTarget6(void) const
This method allows a caller to get the current down target callback set for this L4 protocol (IPv6 ca...
Ipv4Address GetDestination(void) const
Definition: ipv4-header.cc:304
void SetSourceAddress(Ipv6Address src)
Set the "Source address" field.
Definition: ipv6-header.cc:95
Describes an IPv6 address.
Definition: ipv6-address.h:49
Ipv4 addresses are stored in host order in this class.
Definition: ipv4-address.h:41
std::list< Ipv4EndPoint * > EndPoints
Container of the IPv4 endpoints.
IpL4Protocol::DownTargetCallback m_downTarget
Callback to send packets over IPv4.
virtual void NotifyNewAggregate()
Notify all Objects aggregated to this one of a new Object being aggregated.
Implementation of the UDP protocol.
Demultiplexer for end points.
#define NS_LOG_DEBUG(msg)
Use NS_LOG to output a message of level LOG_DEBUG.
Definition: log.h:273
std::vector< Ptr< UdpSocketImpl > > m_sockets
list of sockets
A representation of an IPv6 endpoint/connection.
Ipv4EndPointDemux * m_endPoints
A list of IPv4 end points.
void Send(Ptr< Packet > packet, Ipv4Address saddr, Ipv4Address daddr, uint16_t sport, uint16_t dport)
Send a packet via UDP (IPv4)
void Nullify(void)
Discard the implementation, set it to null.
Definition: callback.h:1377
Ipv6EndPoint * Allocate6(void)
Allocate an IPv6 Endpoint.
void ForwardIcmp(Ipv6Address src, uint8_t ttl, uint8_t type, uint8_t code, uint32_t info)
Forward the ICMP packet to the upper level.
std::list< Ipv4EndPoint * >::iterator EndPointsI
Iterator to the container of the IPv4 endpoints.
RxStatus
Rx status codes.
uint16_t GetSourcePort(void) const
Definition: udp-header.cc:65
virtual void NotifyNewAggregate(void)
Notify all Objects aggregated to this one of a new Object being aggregated.
Definition: object.cc:325
Container for a set of ns3::Object pointers.
void DeAllocate(Ipv4EndPoint *endPoint)
Remove a end point.
bool IsNull(void) const
Check for null implementation.
Definition: callback.h:1372
Ipv6Address GetDestinationAddress(void) const
Get the "Destination address" field.
Definition: ipv6-header.cc:110
static Ipv6Address MakeIpv4MappedAddress(Ipv4Address addr)
Make the Ipv4-mapped IPv6 address.
a unique identifier for an interface.
Definition: type-id.h:58
static const uint8_t PROT_NUMBER
protocol number (0x11)
void SetDestinationAddress(Ipv6Address dst)
Set the "Destination address" field.
Definition: ipv6-header.cc:105
TypeId SetParent(TypeId tid)
Set the parent TypeId.
Definition: type-id.cc:922
void AddHeader(const Header &header)
Add header to this packet.
Definition: packet.cc:256
A representation of an internet endpoint/connection.
bool IsChecksumOk(void) const
Is the UDP checksum correct ?
Definition: udp-header.cc:136
Ipv4EndPoint * Allocate(void)
Allocate a Ipv4EndPoint.