A Discrete-Event Network Simulator
API
udp-socket-impl.cc
Go to the documentation of this file.
1 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
2 /*
3  * Copyright (c) 2007 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/node.h"
23 #include "ns3/inet-socket-address.h"
24 #include "ns3/inet6-socket-address.h"
25 #include "ns3/ipv4-route.h"
26 #include "ns3/ipv6-route.h"
27 #include "ns3/ipv4.h"
28 #include "ns3/ipv6.h"
29 #include "ns3/ipv6-l3-protocol.h"
30 #include "ns3/ipv4-header.h"
31 #include "ns3/ipv4-routing-protocol.h"
32 #include "ns3/ipv6-routing-protocol.h"
33 #include "ns3/udp-socket-factory.h"
34 #include "ns3/trace-source-accessor.h"
35 #include "ns3/ipv4-packet-info-tag.h"
36 #include "ns3/ipv6-packet-info-tag.h"
37 #include "udp-socket-impl.h"
38 #include "udp-l4-protocol.h"
39 #include "ipv4-end-point.h"
40 #include "ipv6-end-point.h"
41 #include <limits>
42 
43 namespace ns3 {
44 
45 NS_LOG_COMPONENT_DEFINE ("UdpSocketImpl");
46 
47 NS_OBJECT_ENSURE_REGISTERED (UdpSocketImpl);
48 
49 // The correct maximum UDP message size is 65507, as determined by the following formula:
50 // 0xffff - (sizeof(IP Header) + sizeof(UDP Header)) = 65535-(20+8) = 65507
51 // \todo MAX_IPV4_UDP_DATAGRAM_SIZE is correct only for IPv4
52 static const uint32_t MAX_IPV4_UDP_DATAGRAM_SIZE = 65507;
53 
54 // Add attributes generic to all UdpSockets to base class UdpSocket
55 TypeId
57 {
58  static TypeId tid = TypeId ("ns3::UdpSocketImpl")
59  .SetParent<UdpSocket> ()
60  .SetGroupName ("Internet")
61  .AddConstructor<UdpSocketImpl> ()
62  .AddTraceSource ("Drop",
63  "Drop UDP packet due to receive buffer overflow",
65  "ns3::Packet::TracedCallback")
66  .AddAttribute ("IcmpCallback", "Callback invoked whenever an icmp error is received on this socket.",
67  CallbackValue (),
70  .AddAttribute ("IcmpCallback6", "Callback invoked whenever an icmpv6 error is received on this socket.",
71  CallbackValue (),
74  ;
75  return tid;
76 }
77 
79  : m_endPoint (0),
80  m_endPoint6 (0),
81  m_node (0),
82  m_udp (0),
83  m_errno (ERROR_NOTERROR),
84  m_shutdownSend (false),
85  m_shutdownRecv (false),
86  m_connected (false),
87  m_rxAvailable (0)
88 {
90  m_allowBroadcast = false;
91 }
92 
94 {
96 
98  m_node = 0;
104  if (m_endPoint != 0)
105  {
106  NS_ASSERT (m_udp != 0);
115  NS_ASSERT (m_endPoint != 0);
116  m_udp->DeAllocate (m_endPoint);
117  NS_ASSERT (m_endPoint == 0);
118  }
119  if (m_endPoint6 != 0)
120  {
121  NS_ASSERT (m_udp != 0);
130  NS_ASSERT (m_endPoint6 != 0);
131  m_udp->DeAllocate (m_endPoint6);
132  NS_ASSERT (m_endPoint6 == 0);
133  }
134  m_udp = 0;
135 }
136 
137 void
139 {
141  m_node = node;
142 
143 }
144 void
146 {
148  m_udp = udp;
149 }
150 
151 
154 {
156  return m_errno;
157 }
158 
161 {
162  return NS3_SOCK_DGRAM;
163 }
164 
165 Ptr<Node>
167 {
169  return m_node;
170 }
171 
172 void
174 {
176  m_endPoint = 0;
177 }
178 
179 void
181 {
183  m_endPoint6 = 0;
184 }
185 
186 /* Deallocate the end point and cancel all the timers */
187 void
189 {
190  if (m_endPoint != 0)
191  {
192  m_endPoint->SetDestroyCallback (MakeNullCallback<void> ());
193  m_udp->DeAllocate (m_endPoint);
194  m_endPoint = 0;
195  }
196  if (m_endPoint6 != 0)
197  {
198  m_endPoint6->SetDestroyCallback (MakeNullCallback<void> ());
199  m_udp->DeAllocate (m_endPoint6);
200  m_endPoint6 = 0;
201  }
202 }
203 
204 
205 int
207 {
209  bool done = false;
210  if (m_endPoint != 0)
211  {
215  done = true;
216  }
217  if (m_endPoint6 != 0)
218  {
222  done = true;
223  }
224  if (done)
225  {
226  return 0;
227  }
228  return -1;
229 }
230 
231 int
233 {
235  m_endPoint = m_udp->Allocate ();
236  if (m_boundnetdevice)
237  {
239  }
240  return FinishBind ();
241 }
242 
243 int
245 {
247  m_endPoint6 = m_udp->Allocate6 ();
248  if (m_boundnetdevice)
249  {
251  }
252  return FinishBind ();
253 }
254 
255 int
257 {
258  NS_LOG_FUNCTION (this << address);
259 
261  {
262  NS_ASSERT_MSG (m_endPoint == 0, "Endpoint already allocated.");
263 
265  Ipv4Address ipv4 = transport.GetIpv4 ();
266  uint16_t port = transport.GetPort ();
267  SetIpTos (transport.GetTos ());
268  if (ipv4 == Ipv4Address::GetAny () && port == 0)
269  {
270  m_endPoint = m_udp->Allocate ();
271  }
272  else if (ipv4 == Ipv4Address::GetAny () && port != 0)
273  {
274  m_endPoint = m_udp->Allocate (GetBoundNetDevice (), port);
275  }
276  else if (ipv4 != Ipv4Address::GetAny () && port == 0)
277  {
278  m_endPoint = m_udp->Allocate (ipv4);
279  }
280  else if (ipv4 != Ipv4Address::GetAny () && port != 0)
281  {
282  m_endPoint = m_udp->Allocate (GetBoundNetDevice (), ipv4, port);
283  }
284  if (0 == m_endPoint)
285  {
287  return -1;
288  }
289  if (m_boundnetdevice)
290  {
292  }
293 
294  }
296  {
297  NS_ASSERT_MSG (m_endPoint == 0, "Endpoint already allocated.");
298 
300  Ipv6Address ipv6 = transport.GetIpv6 ();
301  uint16_t port = transport.GetPort ();
302  if (ipv6 == Ipv6Address::GetAny () && port == 0)
303  {
304  m_endPoint6 = m_udp->Allocate6 ();
305  }
306  else if (ipv6 == Ipv6Address::GetAny () && port != 0)
307  {
308  m_endPoint6 = m_udp->Allocate6 (GetBoundNetDevice (), port);
309  }
310  else if (ipv6 != Ipv6Address::GetAny () && port == 0)
311  {
312  m_endPoint6 = m_udp->Allocate6 (ipv6);
313  }
314  else if (ipv6 != Ipv6Address::GetAny () && port != 0)
315  {
316  m_endPoint6 = m_udp->Allocate6 (GetBoundNetDevice (), ipv6, port);
317  }
318  if (0 == m_endPoint6)
319  {
321  return -1;
322  }
323  if (m_boundnetdevice)
324  {
326  }
327 
328  if (ipv6.IsMulticast ())
329  {
331  if (ipv6l3)
332  {
333  if (m_boundnetdevice == 0)
334  {
335  ipv6l3->AddMulticastAddress (ipv6);
336  }
337  else
338  {
339  uint32_t index = ipv6l3->GetInterfaceForDevice (m_boundnetdevice);
340  ipv6l3->AddMulticastAddress (m_endPoint6->GetLocalAddress (), index);
341  }
342  }
343  }
344  }
345  else
346  {
347  NS_LOG_ERROR ("Not IsMatchingType");
349  return -1;
350  }
351 
352  return FinishBind ();
353 }
354 
355 int
357 {
359  m_shutdownSend = true;
360  return 0;
361 }
362 
363 int
365 {
367  m_shutdownRecv = true;
368  if (m_endPoint)
369  {
370  m_endPoint->SetRxEnabled (false);
371  }
372  if (m_endPoint6)
373  {
374  m_endPoint6->SetRxEnabled (false);
375  }
376  return 0;
377 }
378 
379 int
381 {
383  if (m_shutdownRecv == true && m_shutdownSend == true)
384  {
386  return -1;
387  }
388  Ipv6LeaveGroup ();
389  m_shutdownRecv = true;
390  m_shutdownSend = true;
392  return 0;
393 }
394 
395 int
397 {
398  NS_LOG_FUNCTION (this << address);
400  {
402  m_defaultAddress = Address(transport.GetIpv4 ());
403  m_defaultPort = transport.GetPort ();
404  SetIpTos (transport.GetTos ());
405  m_connected = true;
407  }
409  {
411  m_defaultAddress = Address(transport.GetIpv6 ());
412  m_defaultPort = transport.GetPort ();
413  m_connected = true;
415  }
416  else
417  {
419  return -1;
420  }
421 
422  return 0;
423 }
424 
425 int
427 {
429  return -1;
430 }
431 
432 int
433 UdpSocketImpl::Send (Ptr<Packet> p, uint32_t flags)
434 {
435  NS_LOG_FUNCTION (this << p << flags);
436 
437  if (!m_connected)
438  {
440  return -1;
441  }
442 
443  return DoSend (p);
444 }
445 
446 int
448 {
449  NS_LOG_FUNCTION (this << p);
451  {
452  if (Bind () == -1)
453  {
454  NS_ASSERT (m_endPoint == 0);
455  return -1;
456  }
457  NS_ASSERT (m_endPoint != 0);
458  }
459  else if ((m_endPoint6 == 0) && (Ipv6Address::IsMatchingType(m_defaultAddress) == true))
460  {
461  if (Bind6 () == -1)
462  {
463  NS_ASSERT (m_endPoint6 == 0);
464  return -1;
465  }
466  NS_ASSERT (m_endPoint6 != 0);
467  }
468  if (m_shutdownSend)
469  {
471  return -1;
472  }
473 
475  {
477  }
479  {
481  }
482 
484  return(-1);
485 }
486 
487 int
488 UdpSocketImpl::DoSendTo (Ptr<Packet> p, Ipv4Address dest, uint16_t port, uint8_t tos)
489 {
490  NS_LOG_FUNCTION (this << p << dest << port << (uint16_t) tos);
491  if (m_boundnetdevice)
492  {
493  NS_LOG_LOGIC ("Bound interface number " << m_boundnetdevice->GetIfIndex ());
494  }
495  if (m_endPoint == 0)
496  {
497  if (Bind () == -1)
498  {
499  NS_ASSERT (m_endPoint == 0);
500  return -1;
501  }
502  NS_ASSERT (m_endPoint != 0);
503  }
504  if (m_shutdownSend)
505  {
507  return -1;
508  }
509 
510  if (p->GetSize () > GetTxAvailable () )
511  {
513  return -1;
514  }
515 
516  uint8_t priority = GetPriority ();
517  if (tos)
518  {
519  SocketIpTosTag ipTosTag;
520  ipTosTag.SetTos (tos);
521  // This packet may already have a SocketIpTosTag (see BUG 2440)
522  p->ReplacePacketTag (ipTosTag);
523  priority = IpTos2Priority (tos);
524  }
525 
526  if (priority)
527  {
528  SocketPriorityTag priorityTag;
529  priorityTag.SetPriority (priority);
530  p->ReplacePacketTag (priorityTag);
531  }
532 
533  Ptr<Ipv4> ipv4 = m_node->GetObject<Ipv4> ();
534 
535  // Locally override the IP TTL for this socket
536  // We cannot directly modify the TTL at this stage, so we set a Packet tag
537  // The destination can be either multicast, unicast/anycast, or
538  // either all-hosts broadcast or limited (subnet-directed) broadcast.
539  // For the latter two broadcast types, the TTL will later be set to one
540  // irrespective of what is set in these socket options. So, this tagging
541  // may end up setting the TTL of a limited broadcast packet to be
542  // the same as a unicast, but it will be fixed further down the stack
543  if (m_ipMulticastTtl != 0 && dest.IsMulticast ())
544  {
545  SocketIpTtlTag tag;
546  tag.SetTtl (m_ipMulticastTtl);
547  p->AddPacketTag (tag);
548  }
549  else if (IsManualIpTtl () && GetIpTtl () != 0 && !dest.IsMulticast () && !dest.IsBroadcast ())
550  {
551  SocketIpTtlTag tag;
552  tag.SetTtl (GetIpTtl ());
553  p->AddPacketTag (tag);
554  }
555  {
557  bool found = p->RemovePacketTag (tag);
558  if (!found)
559  {
560  if (m_mtuDiscover)
561  {
562  tag.Enable ();
563  }
564  else
565  {
566  tag.Disable ();
567  }
568  p->AddPacketTag (tag);
569  }
570  }
571 
572  // Note that some systems will only send limited broadcast packets
573  // out of the "default" interface; here we send it out all interfaces
574  if (dest.IsBroadcast ())
575  {
576  if (!m_allowBroadcast)
577  {
579  return -1;
580  }
581  NS_LOG_LOGIC ("Limited broadcast start.");
582  for (uint32_t i = 0; i < ipv4->GetNInterfaces (); i++ )
583  {
584  // Get the primary address
585  Ipv4InterfaceAddress iaddr = ipv4->GetAddress (i, 0);
586  Ipv4Address addri = iaddr.GetLocal ();
587  if (addri == Ipv4Address ("127.0.0.1"))
588  continue;
589  // Check if interface-bound socket
590  if (m_boundnetdevice)
591  {
592  if (ipv4->GetNetDevice (i) != m_boundnetdevice)
593  continue;
594  }
595  NS_LOG_LOGIC ("Sending one copy from " << addri << " to " << dest);
596  m_udp->Send (p->Copy (), addri, dest,
598  NotifyDataSent (p->GetSize ());
600  }
601  NS_LOG_LOGIC ("Limited broadcast end.");
602  return p->GetSize ();
603  }
605  {
606  m_udp->Send (p->Copy (), m_endPoint->GetLocalAddress (), dest,
607  m_endPoint->GetLocalPort (), port, 0);
608  NotifyDataSent (p->GetSize ());
610  return p->GetSize ();
611  }
612  else if (ipv4->GetRoutingProtocol () != 0)
613  {
614  Ipv4Header header;
615  header.SetDestination (dest);
617  Socket::SocketErrno errno_;
618  Ptr<Ipv4Route> route;
619  Ptr<NetDevice> oif = m_boundnetdevice; //specify non-zero if bound to a specific device
620  // TBD-- we could cache the route and just check its validity
621  route = ipv4->GetRoutingProtocol ()->RouteOutput (p, header, oif, errno_);
622  if (route != 0)
623  {
624  NS_LOG_LOGIC ("Route exists");
625  if (!m_allowBroadcast)
626  {
627  // Here we try to route subnet-directed broadcasts
628  uint32_t outputIfIndex = ipv4->GetInterfaceForDevice (route->GetOutputDevice ());
629  uint32_t ifNAddr = ipv4->GetNAddresses (outputIfIndex);
630  for (uint32_t addrI = 0; addrI < ifNAddr; ++addrI)
631  {
632  Ipv4InterfaceAddress ifAddr = ipv4->GetAddress (outputIfIndex, addrI);
633  if (dest == ifAddr.GetBroadcast ())
634  {
636  return -1;
637  }
638  }
639  }
640 
641  header.SetSource (route->GetSource ());
642  m_udp->Send (p->Copy (), header.GetSource (), header.GetDestination (),
643  m_endPoint->GetLocalPort (), port, route);
644  NotifyDataSent (p->GetSize ());
645  return p->GetSize ();
646  }
647  else
648  {
649  NS_LOG_LOGIC ("No route to destination");
650  NS_LOG_ERROR (errno_);
651  m_errno = errno_;
652  return -1;
653  }
654  }
655  else
656  {
657  NS_LOG_ERROR ("ERROR_NOROUTETOHOST");
659  return -1;
660  }
661 
662  return 0;
663 }
664 
665 int
667 {
668  NS_LOG_FUNCTION (this << p << dest << port);
669 
670  if (dest.IsIpv4MappedAddress ())
671  {
672  return (DoSendTo(p, dest.GetIpv4MappedAddress (), port, 0));
673  }
674  if (m_boundnetdevice)
675  {
676  NS_LOG_LOGIC ("Bound interface number " << m_boundnetdevice->GetIfIndex ());
677  }
678  if (m_endPoint6 == 0)
679  {
680  if (Bind6 () == -1)
681  {
682  NS_ASSERT (m_endPoint6 == 0);
683  return -1;
684  }
685  NS_ASSERT (m_endPoint6 != 0);
686  }
687  if (m_shutdownSend)
688  {
690  return -1;
691  }
692 
693  if (p->GetSize () > GetTxAvailable () )
694  {
696  return -1;
697  }
698 
699  if (IsManualIpv6Tclass ())
700  {
701  SocketIpv6TclassTag ipTclassTag;
702  ipTclassTag.SetTclass (GetIpv6Tclass ());
703  p->AddPacketTag (ipTclassTag);
704  }
705 
706  uint8_t priority = GetPriority ();
707  if (priority)
708  {
709  SocketPriorityTag priorityTag;
710  priorityTag.SetPriority (priority);
711  p->ReplacePacketTag (priorityTag);
712  }
713 
714  Ptr<Ipv6> ipv6 = m_node->GetObject<Ipv6> ();
715 
716  // Locally override the IP TTL for this socket
717  // We cannot directly modify the TTL at this stage, so we set a Packet tag
718  // The destination can be either multicast, unicast/anycast, or
719  // either all-hosts broadcast or limited (subnet-directed) broadcast.
720  // For the latter two broadcast types, the TTL will later be set to one
721  // irrespective of what is set in these socket options. So, this tagging
722  // may end up setting the TTL of a limited broadcast packet to be
723  // the same as a unicast, but it will be fixed further down the stack
724  if (m_ipMulticastTtl != 0 && dest.IsMulticast ())
725  {
728  p->AddPacketTag (tag);
729  }
730  else if (IsManualIpv6HopLimit () && GetIpv6HopLimit () != 0 && !dest.IsMulticast ())
731  {
733  tag.SetHopLimit (GetIpv6HopLimit ());
734  p->AddPacketTag (tag);
735  }
736  // There is no analgous to an IPv4 broadcast address in IPv6.
737  // Instead, we use a set of link-local, site-local, and global
738  // multicast addresses. The Ipv6 routing layers should all
739  // provide an interface-specific route to these addresses such
740  // that we can treat these multicast addresses as "not broadcast"
741 
743  {
744  m_udp->Send (p->Copy (), m_endPoint6->GetLocalAddress (), dest,
745  m_endPoint6->GetLocalPort (), port, 0);
746  NotifyDataSent (p->GetSize ());
748  return p->GetSize ();
749  }
750  else if (ipv6->GetRoutingProtocol () != 0)
751  {
752  Ipv6Header header;
753  header.SetDestinationAddress (dest);
755  Socket::SocketErrno errno_;
756  Ptr<Ipv6Route> route;
757  Ptr<NetDevice> oif = m_boundnetdevice; //specify non-zero if bound to a specific device
758  // TBD-- we could cache the route and just check its validity
759  route = ipv6->GetRoutingProtocol ()->RouteOutput (p, header, oif, errno_);
760  if (route != 0)
761  {
762  NS_LOG_LOGIC ("Route exists");
763  header.SetSourceAddress (route->GetSource ());
764  m_udp->Send (p->Copy (), header.GetSourceAddress (), header.GetDestinationAddress (),
765  m_endPoint6->GetLocalPort (), port, route);
766  NotifyDataSent (p->GetSize ());
767  return p->GetSize ();
768  }
769  else
770  {
771  NS_LOG_LOGIC ("No route to destination");
772  NS_LOG_ERROR (errno_);
773  m_errno = errno_;
774  return -1;
775  }
776  }
777  else
778  {
779  NS_LOG_ERROR ("ERROR_NOROUTETOHOST");
781  return -1;
782  }
783 
784  return 0;
785 }
786 
787 
788 // maximum message size for UDP broadcast is limited by MTU
789 // size of underlying link; we are not checking that now.
790 // \todo Check MTU size of underlying link
791 uint32_t
793 {
795  // No finite send buffer is modelled, but we must respect
796  // the maximum size of an IP datagram (65535 bytes - headers).
798 }
799 
800 int
802 {
803  NS_LOG_FUNCTION (this << p << flags << address);
805  {
807  Ipv4Address ipv4 = transport.GetIpv4 ();
808  uint16_t port = transport.GetPort ();
809  uint8_t tos = transport.GetTos ();
810  return DoSendTo (p, ipv4, port, tos);
811  }
813  {
815  Ipv6Address ipv6 = transport.GetIpv6 ();
816  uint16_t port = transport.GetPort ();
817  return DoSendTo (p, ipv6, port);
818  }
819  return -1;
820 }
821 
822 uint32_t
824 {
826  // We separately maintain this state to avoid walking the queue
827  // every time this might be called
828  return m_rxAvailable;
829 }
830 
832 UdpSocketImpl::Recv (uint32_t maxSize, uint32_t flags)
833 {
834  NS_LOG_FUNCTION (this << maxSize << flags);
835 
836  Address fromAddress;
837  Ptr<Packet> packet = RecvFrom (maxSize, flags, fromAddress);
838  return packet;
839 }
840 
842 UdpSocketImpl::RecvFrom (uint32_t maxSize, uint32_t flags,
843  Address &fromAddress)
844 {
845  NS_LOG_FUNCTION (this << maxSize << flags);
846 
847  if (m_deliveryQueue.empty () )
848  {
850  return 0;
851  }
852  Ptr<Packet> p = m_deliveryQueue.front ().first;
853  fromAddress = m_deliveryQueue.front ().second;
854 
855  if (p->GetSize () <= maxSize)
856  {
857  m_deliveryQueue.pop ();
858  m_rxAvailable -= p->GetSize ();
859  }
860  else
861  {
862  p = 0;
863  }
864  return p;
865 }
866 
867 int
869 {
871  if (m_endPoint != 0)
872  {
874  }
875  else if (m_endPoint6 != 0)
876  {
878  }
879  else
880  { // It is possible to call this method on a socket without a name
881  // in which case, behavior is unspecified
882  // Should this return an InetSocketAddress or an Inet6SocketAddress?
884  }
885  return 0;
886 }
887 
888 int
890 {
891  NS_LOG_FUNCTION (this << address);
892 
893  if (!m_connected)
894  {
896  return -1;
897  }
898 
900  {
902  InetSocketAddress inet (addr, m_defaultPort);
903  inet.SetTos (GetIpTos ());
904  address = inet;
905  }
907  {
910  }
911  else
912  {
913  NS_ASSERT_MSG (false, "unexpected address type");
914  }
915 
916  return 0;
917 }
918 
919 int
920 UdpSocketImpl::MulticastJoinGroup (uint32_t interface, const Address &groupAddress)
921 {
922  NS_LOG_FUNCTION (interface << groupAddress);
923  /*
924  1) sanity check interface
925  2) sanity check that it has not been called yet on this interface/group
926  3) determine address family of groupAddress
927  4) locally store a list of (interface, groupAddress)
928  5) call ipv4->MulticastJoinGroup () or Ipv6->MulticastJoinGroup ()
929  */
930  return 0;
931 }
932 
933 int
934 UdpSocketImpl::MulticastLeaveGroup (uint32_t interface, const Address &groupAddress)
935 {
936  NS_LOG_FUNCTION (interface << groupAddress);
937  /*
938  1) sanity check interface
939  2) determine address family of groupAddress
940  3) delete from local list of (interface, groupAddress); raise a LOG_WARN
941  if not already present (but return 0)
942  5) call ipv4->MulticastLeaveGroup () or Ipv6->MulticastLeaveGroup ()
943  */
944  return 0;
945 }
946 
947 void
949 {
950  NS_LOG_FUNCTION (netdevice);
951 
952  Ptr<NetDevice> oldBoundNetDevice = m_boundnetdevice;
953 
954  Socket::BindToNetDevice (netdevice); // Includes sanity check
955  if (m_endPoint != 0)
956  {
957  m_endPoint->BindToNetDevice (netdevice);
958  }
959 
960  if (m_endPoint6 != 0)
961  {
962  m_endPoint6->BindToNetDevice (netdevice);
963 
964  // The following is to fix the multicast distribution inside the node
965  // and to upgrade it to the actual bound NetDevice.
967  {
969  if (ipv6l3)
970  {
971  // Cleanup old one
972  if (oldBoundNetDevice)
973  {
974  uint32_t index = ipv6l3->GetInterfaceForDevice (oldBoundNetDevice);
975  ipv6l3->RemoveMulticastAddress (m_endPoint6->GetLocalAddress (), index);
976  }
977  else
978  {
979  ipv6l3->RemoveMulticastAddress (m_endPoint6->GetLocalAddress ());
980  }
981  // add new one
982  if (netdevice)
983  {
984  uint32_t index = ipv6l3->GetInterfaceForDevice (netdevice);
985  ipv6l3->AddMulticastAddress (m_endPoint6->GetLocalAddress (), index);
986  }
987  else
988  {
989  ipv6l3->AddMulticastAddress (m_endPoint6->GetLocalAddress ());
990  }
991  }
992  }
993  }
994 
995  return;
996 }
997 
998 void
1000  Ptr<Ipv4Interface> incomingInterface)
1001 {
1002  NS_LOG_FUNCTION (this << packet << header << port);
1003 
1004  if (m_shutdownRecv)
1005  {
1006  return;
1007  }
1008 
1009  // Should check via getsockopt ()..
1010  if (IsRecvPktInfo ())
1011  {
1012  Ipv4PacketInfoTag tag;
1013  packet->RemovePacketTag (tag);
1014  tag.SetRecvIf (incomingInterface->GetDevice ()->GetIfIndex ());
1015  packet->AddPacketTag (tag);
1016  }
1017 
1018  //Check only version 4 options
1019  if (IsIpRecvTos ())
1020  {
1021  SocketIpTosTag ipTosTag;
1022  ipTosTag.SetTos (header.GetTos ());
1023  packet->AddPacketTag (ipTosTag);
1024  }
1025 
1026  if (IsIpRecvTtl ())
1027  {
1028  SocketIpTtlTag ipTtlTag;
1029  ipTtlTag.SetTtl (header.GetTtl ());
1030  packet->AddPacketTag (ipTtlTag);
1031  }
1032 
1033  // in case the packet still has a priority tag attached, remove it
1034  SocketPriorityTag priorityTag;
1035  packet->RemovePacketTag (priorityTag);
1036 
1037  if ((m_rxAvailable + packet->GetSize ()) <= m_rcvBufSize)
1038  {
1040  m_deliveryQueue.push (std::make_pair (packet, address));
1041  m_rxAvailable += packet->GetSize ();
1042  NotifyDataRecv ();
1043  }
1044  else
1045  {
1046  // In general, this case should not occur unless the
1047  // receiving application reads data from this socket slowly
1048  // in comparison to the arrival rate
1049  //
1050  // drop and trace packet
1051  NS_LOG_WARN ("No receive buffer space available. Drop.");
1052  m_dropTrace (packet);
1053  }
1054 }
1055 
1056 void
1057 UdpSocketImpl::ForwardUp6 (Ptr<Packet> packet, Ipv6Header header, uint16_t port, Ptr<Ipv6Interface> incomingInterface)
1058 {
1059  NS_LOG_FUNCTION (this << packet << header.GetSourceAddress () << port);
1060 
1061  if (m_shutdownRecv)
1062  {
1063  return;
1064  }
1065 
1066  // Should check via getsockopt ().
1067  if (IsRecvPktInfo ())
1068  {
1069  Ipv6PacketInfoTag tag;
1070  packet->RemovePacketTag (tag);
1071  tag.SetRecvIf (incomingInterface->GetDevice ()->GetIfIndex ());
1072  packet->AddPacketTag (tag);
1073  }
1074 
1075  // Check only version 6 options
1076  if (IsIpv6RecvTclass ())
1077  {
1078  SocketIpv6TclassTag ipTclassTag;
1079  ipTclassTag.SetTclass (header.GetTrafficClass ());
1080  packet->AddPacketTag (ipTclassTag);
1081  }
1082 
1083  if (IsIpv6RecvHopLimit ())
1084  {
1085  SocketIpv6HopLimitTag ipHopLimitTag;
1086  ipHopLimitTag.SetHopLimit (header.GetHopLimit ());
1087  packet->AddPacketTag (ipHopLimitTag);
1088  }
1089 
1090  // in case the packet still has a priority tag attached, remove it
1091  SocketPriorityTag priorityTag;
1092  packet->RemovePacketTag (priorityTag);
1093 
1094  if ((m_rxAvailable + packet->GetSize ()) <= m_rcvBufSize)
1095  {
1097  m_deliveryQueue.push (std::make_pair (packet, address));
1098  m_rxAvailable += packet->GetSize ();
1099  NotifyDataRecv ();
1100  }
1101  else
1102  {
1103  // In general, this case should not occur unless the
1104  // receiving application reads data from this socket slowly
1105  // in comparison to the arrival rate
1106  //
1107  // drop and trace packet
1108  NS_LOG_WARN ("No receive buffer space available. Drop.");
1109  m_dropTrace (packet);
1110  }
1111 }
1112 
1113 void
1114 UdpSocketImpl::ForwardIcmp (Ipv4Address icmpSource, uint8_t icmpTtl,
1115  uint8_t icmpType, uint8_t icmpCode,
1116  uint32_t icmpInfo)
1117 {
1118  NS_LOG_FUNCTION (this << icmpSource << (uint32_t)icmpTtl << (uint32_t)icmpType <<
1119  (uint32_t)icmpCode << icmpInfo);
1120  if (!m_icmpCallback.IsNull ())
1121  {
1122  m_icmpCallback (icmpSource, icmpTtl, icmpType, icmpCode, icmpInfo);
1123  }
1124 }
1125 
1126 void
1127 UdpSocketImpl::ForwardIcmp6 (Ipv6Address icmpSource, uint8_t icmpTtl,
1128  uint8_t icmpType, uint8_t icmpCode,
1129  uint32_t icmpInfo)
1130 {
1131  NS_LOG_FUNCTION (this << icmpSource << (uint32_t)icmpTtl << (uint32_t)icmpType <<
1132  (uint32_t)icmpCode << icmpInfo);
1133  if (!m_icmpCallback6.IsNull ())
1134  {
1135  m_icmpCallback6 (icmpSource, icmpTtl, icmpType, icmpCode, icmpInfo);
1136  }
1137 }
1138 
1139 void
1141 {
1142  m_rcvBufSize = size;
1143 }
1144 
1145 uint32_t
1147 {
1148  return m_rcvBufSize;
1149 }
1150 
1151 void
1153 {
1154  m_ipMulticastTtl = ipTtl;
1155 }
1156 
1157 uint8_t
1159 {
1160  return m_ipMulticastTtl;
1161 }
1162 
1163 void
1165 {
1166  m_ipMulticastIf = ipIf;
1167 }
1168 
1169 int32_t
1171 {
1172  return m_ipMulticastIf;
1173 }
1174 
1175 void
1177 {
1178  m_ipMulticastLoop = loop;
1179 }
1180 
1181 bool
1183 {
1184  return m_ipMulticastLoop;
1185 }
1186 
1187 void
1189 {
1190  m_mtuDiscover = discover;
1191 }
1192 bool
1194 {
1195  return m_mtuDiscover;
1196 }
1197 
1198 bool
1200 {
1201  m_allowBroadcast = allowBroadcast;
1202  return true;
1203 }
1204 
1205 bool
1207 {
1208  return m_allowBroadcast;
1209 }
1210 
1211 void
1212 UdpSocketImpl::Ipv6JoinGroup (Ipv6Address address, Socket::Ipv6MulticastFilterMode filterMode, std::vector<Ipv6Address> sourceAddresses)
1213 {
1214  NS_LOG_FUNCTION (this << address << &filterMode << &sourceAddresses);
1215 
1216  // We can join only one multicast group (or change its params)
1217  NS_ASSERT_MSG ((m_ipv6MulticastGroupAddress == address || m_ipv6MulticastGroupAddress.IsAny ()), "Can join only one IPv6 multicast group.");
1218 
1220 
1222  if (ipv6l3)
1223  {
1224  if (filterMode == INCLUDE && sourceAddresses.empty ())
1225  {
1226  // it is a leave
1227  if (m_boundnetdevice)
1228  {
1229  int32_t index = ipv6l3->GetInterfaceForDevice (m_boundnetdevice);
1230  NS_ASSERT_MSG (index >= 0, "Interface without a valid index");
1231  ipv6l3->RemoveMulticastAddress (address, index);
1232  }
1233  else
1234  {
1235  ipv6l3->RemoveMulticastAddress (address);
1236  }
1237  }
1238  else
1239  {
1240  // it is a join or a modification
1241  if (m_boundnetdevice)
1242  {
1243  int32_t index = ipv6l3->GetInterfaceForDevice (m_boundnetdevice);
1244  NS_ASSERT_MSG (index >= 0, "Interface without a valid index");
1245  ipv6l3->AddMulticastAddress (address, index);
1246  }
1247  else
1248  {
1249  ipv6l3->AddMulticastAddress (address);
1250  }
1251  }
1252  }
1253 }
1254 
1255 } // namespace ns3
static bool IsMatchingType(const Address &address)
If the Address matches the type.
void SetSource(Ipv4Address source)
Definition: ipv4-header.cc:285
Ipv6Address GetLocalAddress()
Get the local address.
(abstract) base class of all UdpSockets
Definition: udp-socket.h:47
bool m_shutdownSend
Send no longer allowed.
void SetTclass(uint8_t tclass)
Set the tag&#39;s Tclass.
Definition: socket.cc:900
static const uint32_t MAX_IPV4_UDP_DATAGRAM_SIZE
Maximum UDP datagram size.
Packet header for IPv6.
Definition: ipv6-header.h:34
an Inet address class
void SetDestination(Ipv4Address destination)
Definition: ipv4-header.cc:298
static Ipv4Address GetAny(void)
#define NS_LOG_FUNCTION(parameters)
If log level LOG_FUNCTION is enabled, this macro will output all input parameters separated by "...
Ipv4Address GetIpv4MappedAddress() const
Return the Ipv4 address.
void Destroy(void)
Kill this socket by zeroing its attributes (IPv4)
Ptr< UdpL4Protocol > m_udp
the associated UDP L4 protocol
Ipv4EndPoint * m_endPoint
the IPv4 endpoint
bool IsIpv4MappedAddress() const
If the address is an IPv4-mapped address.
bool IsBroadcast(void) const
This class implements a tag that carries the socket-specific HOPLIMIT of a packet to the IPv6 layer...
Definition: socket.h:1163
#define NS_OBJECT_ENSURE_REGISTERED(type)
Register an Object subclass with the TypeId system.
Definition: object-base.h:45
enum SocketErrno m_errno
Socket error code.
virtual int GetSockName(Address &address) const
Get socket address.
uint32_t GetSize(void) const
Returns the the size in bytes of the packet (including the zero-filled initial payload).
Definition: packet.h:852
Ipv6Address GetIpv6(void) const
Get the IPv6 address.
virtual void SetIpMulticastIf(int32_t ipIf)
Set the IP multicast interface.
bool IsIpRecvTos(void) const
Ask if the socket is currently passing information about IP Type of Service up the stack...
Definition: socket.cc:465
NS_ASSERT_MSG(false, "Ipv4AddressGenerator::MaskToIndex(): Impossible")
Access to the IPv6 forwarding table, interfaces, and configuration.
Definition: ipv6.h:81
bool m_allowBroadcast
Allow send broadcast packets.
void NotifyDataRecv(void)
Notify through the callback (if set) that some data have been received.
Definition: socket.cc:305
void SetRxCallback(Callback< void, Ptr< Packet >, Ipv4Header, uint16_t, Ptr< Ipv4Interface > > callback)
Set the reception callback.
Ptr< Packet > Recv(void)
Read a single packet from the socket.
Definition: socket.cc:175
IPv6 layer implementation.
void SetDestroyCallback(Callback< void > callback)
Set the default destroy callback.
uint8_t GetTos(void) const
void NotifyConnectionFailed(void)
Notify through the callback (if set) that the connection has not been established due to an error...
Definition: socket.cc:227
Ipv4Address GetSource(void) const
Definition: ipv4-header.cc:291
virtual bool GetAllowBroadcast() const
Query whether broadcast datagram transmissions are allowed.
uint8_t GetTos(void) const
Definition: ipv4-header.cc:194
virtual int Close(void)
Close a socket.
#define NS_ASSERT(condition)
At runtime, in debugging builds, if this condition is not true, the program prints the source file...
Definition: assert.h:67
static Ipv6Address GetAny()
Get the "any" (::) Ipv6Address.
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Definition: log.h:204
bool IsIpRecvTtl(void) const
Ask if the socket is currently passing information about IP_TTL up the stack.
Definition: socket.cc:532
void SetNextHeader(uint8_t next)
Set the "Next header" field.
Definition: ipv6-header.cc:75
uint32_t m_rxAvailable
Number of available bytes to be received.
virtual uint8_t GetIpMulticastTtl(void) const
Get the IP multicast TTL.
virtual enum SocketType GetSocketType(void) const
void BindToNetDevice(Ptr< NetDevice > netdevice)
Bind a socket to specific device.
virtual Ptr< NetDevice > GetDevice() const
Get the NetDevice.
#define NS_LOG_FUNCTION_NOARGS()
Output the name of the function.
virtual uint32_t GetTxAvailable(void) const
Returns the number of bytes which can be sent in a single call to Send.
void SetProtocol(uint8_t num)
Definition: ipv4-header.cc:278
void SetTos(uint8_t tos)
Set the tag&#39;s TOS.
Definition: socket.cc:785
virtual void BindToNetDevice(Ptr< NetDevice > netdevice)
Bind a socket to specific device.
static uint8_t IpTos2Priority(uint8_t ipTos)
Return the priority corresponding to a given TOS value.
Definition: socket.cc:402
This class implements a tag that carries the socket-specific TTL of a packet to the IP layer...
Definition: socket.h:1115
SocketErrno
Enumeration of the possible errors returned by a socket.
Definition: socket.h:82
virtual void SetRcvBufSize(uint32_t size)
Set the receiving buffer size.
Ipv6Address m_ipv6MulticastGroupAddress
IPv6 multicast group address.
Definition: socket.h:1078
virtual void Ipv6JoinGroup(Ipv6Address address, Socket::Ipv6MulticastFilterMode filterMode, std::vector< Ipv6Address > sourceAddresses)
Joins a IPv6 multicast group.
A sockets interface to UDP.
bool m_connected
Connection established.
void ForwardIcmp6(Ipv6Address icmpSource, uint8_t icmpTtl, uint8_t icmpType, uint8_t icmpCode, uint32_t icmpInfo)
Called by the L3 protocol when it received an ICMPv6 packet to pass on to TCP.
uint16_t port
Definition: dsdv-manet.cc:45
a polymophic address class
Definition: address.h:90
virtual int Bind(void)
Allocate a local IPv4 endpoint for this socket.
void SetDestroyCallback(Callback< void > callback)
Set the default destroy callback.
AttributeValue implementation for Callback.
Definition: callback.h:1880
void ForwardUp(Ptr< Packet > packet, Ipv4Header header, uint16_t port, Ptr< Ipv4Interface > incomingInterface)
Called by the L3 protocol when it received a packet to pass on to TCP.
Ptr< const TraceSourceAccessor > MakeTraceSourceAccessor(T a)
Create a TraceSourceAccessor which will control access to the underlying trace source.
virtual uint8_t GetIpTtl(void) const
Query the value of IP Time to Live field of this socket.
Definition: socket.cc:520
Ptr< NetDevice > GetBoundNetDevice()
Returns socket&#39;s bound NetDevice, if any.
Definition: socket.cc:351
Packet header for IPv4.
Definition: ipv4-header.h:33
virtual int ShutdownRecv(void)
bool IsMulticast(void) const
void BindToNetDevice(Ptr< NetDevice > netdevice)
Bind a socket to specific device.
virtual int MulticastLeaveGroup(uint32_t interfaceIndex, const Address &groupAddress)
Corresponds to socket option MCAST_LEAVE_GROUP.
Ipv6MulticastFilterMode
Enumeration of the possible filter of a socket.
Definition: socket.h:138
void ForwardIcmp(Ipv4Address icmpSource, uint8_t icmpTtl, uint8_t icmpType, uint8_t icmpCode, uint32_t icmpInfo)
Called by the L3 protocol when it received an ICMP packet to pass on to TCP.
Callback< void, Ipv6Address, uint8_t, uint8_t, uint8_t, uint32_t > m_icmpCallback6
ICMPv6 callback.
void SetTtl(uint8_t ttl)
Set the tag&#39;s TTL.
Definition: socket.cc:604
virtual Ptr< Node > GetNode(void) const
Return the node this socket is associated with.
int DoSend(Ptr< Packet > p)
Send a packet.
uint16_t GetLocalPort()
Get the local port.
void SetNode(Ptr< Node > node)
Set the associated node.
virtual int Bind6(void)
Allocate a local IPv6 endpoint for this socket.
UdpSocketImpl()
Create an unbound udp socket.
virtual int Connect(const Address &address)
Initiate a connection to a remote host.
virtual int MulticastJoinGroup(uint32_t interfaceIndex, const Address &groupAddress)
Corresponds to socket option MCAST_JOIN_GROUP.
bool ReplacePacketTag(Tag &tag)
Replace the value of a packet tag.
Definition: packet.cc:877
Ptr< const AttributeAccessor > MakeCallbackAccessor(T1 a1)
Create an AttributeAccessor for a class data member, or a lone class get functor or set method...
Definition: callback.h:1922
bool IsIpv6RecvTclass(void) const
Ask if the socket is currently passing information about IPv6 Traffic Class up the stack...
Definition: socket.cc:507
Ipv4Address GetLocalAddress(void)
Get the local address.
uint8_t m_ipMulticastTtl
Multicast TTL.
indicates whether the socket has a priority set.
Definition: socket.h:1307
Address m_defaultAddress
Default address.
An Inet6 address class.
virtual void SetMtuDiscover(bool discover)
Set the MTU discover capability.
Callback< R > MakeCallback(R(T::*memPtr)(void), OBJ objPtr)
Definition: callback.h:1489
void NotifyDataSent(uint32_t size)
Notify through the callback (if set) that some data have been sent.
Definition: socket.cc:285
Ipv4Address GetBroadcast(void) const
Get the broadcast address.
void Destroy6(void)
Kill this socket by zeroing its attributes (IPv6)
static bool IsMatchingType(const Address &address)
Ipv6Address GetSourceAddress(void) const
Get the "Source address" field.
Definition: ipv6-header.cc:100
int FinishBind(void)
Finish the binding process.
void SetHopLimit(uint8_t hopLimit)
Set the tag&#39;s Hop Limit.
Definition: socket.cc:665
virtual int GetPeerName(Address &address) const
Get the peer address of a connected socket.
static TypeId GetTypeId(void)
Get the type ID.
void NotifyConnectionSucceeded(void)
Notify through the callback (if set) that the connection has been established.
Definition: socket.cc:217
Access to the IPv4 forwarding table, interfaces, and configuration.
Definition: ipv4.h:76
Ptr< T > GetObject(void) const
Get a pointer to the requested aggregated Object.
Definition: object.h:459
virtual void SetIpMulticastLoop(bool loop)
Set the IP multicast loop capability.
virtual int Send(Ptr< Packet > p, uint32_t flags)
Send data (or dummy data) to the remote host.
bool m_shutdownRecv
Receive no longer allowed.
Ptr< NetDevice > GetOutputDevice(void) const
Definition: ipv4-route.cc:84
bool IsMulticast() const
If the IPv6 address is multicast (ff00::/8).
Every class exported by the ns3 library is enclosed in the ns3 namespace.
static InetSocketAddress ConvertFrom(const Address &address)
Returns an InetSocketAddress which corresponds to the input Address.
address
Definition: first.py:37
Ptr< NetDevice > GetDevice(void) const
bool IsManualIpv6Tclass(void) const
Checks if the socket has a specific IPv6 Tclass set.
Definition: socket.cc:371
Ptr< Node > m_node
the associated node
uint16_t GetPort(void) const
void SetIcmpCallback(Callback< void, Ipv6Address, uint8_t, uint8_t, uint8_t, uint32_t > callback)
Set the ICMP callback.
Ptr< Packet > Copy(void) const
performs a COW copy of the packet.
Definition: packet.cc:121
indicates whether the socket has IPV6_TCLASS set.
Definition: socket.h:1354
virtual void Ipv6LeaveGroup(void)
Leaves IPv6 multicast group this socket is joined to.
Definition: socket.cc:580
static Ipv4Address GetZero(void)
Ptr< const AttributeChecker > MakeCallbackChecker(void)
Definition: callback.cc:75
NS_LOG_LOGIC("Net device "<< nd<< " is not bridged")
virtual void BindToNetDevice(Ptr< NetDevice > netdevice)
Bind a socket to specific device.
Definition: socket.cc:330
This class implements Linux struct pktinfo in order to deliver ancillary information to the socket in...
virtual int32_t GetIpMulticastIf(void) const
Get the IP multicast interface.
uint8_t GetIpv6Tclass(void) const
Query the value of IPv6 Traffic Class field of this socket.
Definition: socket.cc:495
uint8_t GetTtl(void) const
Definition: ipv4-header.cc:265
virtual int ShutdownSend(void)
Ipv4Address GetDestination(void) const
Definition: ipv4-header.cc:304
void SetSourceAddress(Ipv6Address src)
Set the "Source address" field.
Definition: ipv6-header.cc:95
bool IsManualIpv6HopLimit(void) const
Checks if the socket has a specific IPv6 Hop Limit set.
Definition: socket.cc:383
void Disable(void)
Disables the DF (Don&#39;t Fragment) flag.
Definition: socket.cc:726
Describes an IPv6 address.
Definition: ipv6-address.h:49
void ForwardUp6(Ptr< Packet > packet, Ipv6Header header, uint16_t port, Ptr< Ipv6Interface > incomingInterface)
Called by the L3 protocol when it received a packet to pass on to TCP.
Ipv4 addresses are stored in host order in this class.
Definition: ipv4-address.h:40
virtual bool GetMtuDiscover(void) const
Get the MTU discover capability.
Ptr< NetDevice > m_boundnetdevice
the device this socket is bound to (might be null).
Definition: socket.h:1076
virtual bool SetAllowBroadcast(bool allowBroadcast)
Configure whether broadcast datagram transmissions are allowed.
uint8_t GetTrafficClass(void) const
Get the "Traffic class" field.
Definition: ipv6-header.cc:50
a class to store IPv4 address information on an interface
virtual bool GetIpMulticastLoop(void) const
Get the IP multicast loop capability.
void AddPacketTag(const Tag &tag) const
Add a packet tag.
Definition: packet.cc:863
uint32_t m_rcvBufSize
Receive buffer size.
uint16_t GetLocalPort(void)
Get the local port.
virtual uint8_t GetIpv6HopLimit(void) const
Query the value of IP Hop Limit field of this socket.
Definition: socket.cc:545
#define NS_LOG_WARN(msg)
Use NS_LOG to output a message of level LOG_WARN.
Definition: log.h:264
virtual uint32_t GetRcvBufSize(void) const
Get the receiving buffer size.
virtual enum SocketErrno GetErrno(void) const
Get last error number.
void SetRxEnabled(bool enabled)
Enable or Disable the endpoint Rx capability.
void SetUdp(Ptr< UdpL4Protocol > udp)
Set the associated UDP L4 protocol.
bool m_ipMulticastLoop
Allow multicast loop.
virtual int Listen(void)
Listen for incoming connections.
bool RemovePacketTag(Tag &tag)
Remove a packet tag.
Definition: packet.cc:870
indicates whether packets should be sent out with the DF (Don&#39;t Fragment) flag set.
Definition: socket.h:1211
static Inet6SocketAddress ConvertFrom(const Address &addr)
Convert the address to a InetSocketAddress.
uint16_t m_defaultPort
Default port.
bool IsIpv6RecvHopLimit(void) const
Ask if the socket is currently passing information about IPv6 Hop Limit up the stack.
Definition: socket.cc:557
virtual int SendTo(Ptr< Packet > p, uint32_t flags, const Address &address)
Send data to a specified peer.
Ipv6EndPoint * m_endPoint6
the IPv6 endpoint
void SetRxCallback(Callback< void, Ptr< Packet >, Ipv6Header, uint16_t, Ptr< Ipv6Interface > > callback)
Set the reception callback.
static bool IsMatchingType(const Address &addr)
If the address match.
void Enable(void)
Enables the DF (Don&#39;t Fragment) flag.
Definition: socket.cc:720
Ipv4Address GetLocal(void) const
Get the local address.
void DeallocateEndPoint(void)
Deallocate m_endPoint and m_endPoint6.
int32_t m_ipMulticastIf
Multicast Interface.
virtual Ptr< Packet > RecvFrom(uint32_t maxSize, uint32_t flags, Address &fromAddress)
Read a single packet from the socket and retrieve the sender address.
bool IsRecvPktInfo() const
Get status indicating whether enable/disable packet information to socket.
Definition: socket.cc:364
#define NS_LOG_ERROR(msg)
Use NS_LOG to output a message of level LOG_ERROR.
Definition: log.h:256
This class implements a tag that carries socket ancillary data to the socket interface.
static Ipv4Address ConvertFrom(const Address &address)
void SetRxEnabled(bool enabled)
Enable or Disable the endpoint Rx capability.
std::queue< std::pair< Ptr< Packet >, Address > > m_deliveryQueue
Queue for incoming packets.
uint8_t GetHopLimit(void) const
Get the "Hop limit" field (TTL).
Definition: ipv6-header.cc:90
uint16_t GetPort(void) const
Get the port.
TracedCallback< Ptr< const Packet > > m_dropTrace
Trace for dropped packets.
Ipv4Address GetSource(void) const
Definition: ipv4-route.cc:56
Ipv6Address GetDestinationAddress(void) const
Get the "Destination address" field.
Definition: ipv6-header.cc:110
void SetPriority(uint8_t priority)
Set the tag&#39;s priority.
Definition: socket.cc:842
indicates whether the socket has IP_TOS set.
Definition: socket.h:1261
bool IsManualIpTtl(void) const
Checks if the socket has a specific IPv4 TTL set.
Definition: socket.cc:377
uint8_t GetIpTos(void) const
Query the value of IP Type of Service of this socket.
Definition: socket.cc:453
void SetIcmpCallback(Callback< void, Ipv4Address, uint8_t, uint8_t, uint8_t, uint32_t > callback)
Set the ICMP callback.
SocketType
Enumeration of the possible socket types.
Definition: socket.h:104
void SetIpTos(uint8_t ipTos)
Manually set IP Type of Service field.
Definition: socket.cc:437
a unique identifier for an interface.
Definition: type-id.h:58
static const uint8_t PROT_NUMBER
protocol number (0x11)
bool m_mtuDiscover
Allow MTU discovery.
void SetDestinationAddress(Ipv6Address dst)
Set the "Destination address" field.
Definition: ipv6-header.cc:105
void NotifySend(uint32_t spaceAvailable)
Notify through the callback (if set) that some data have been sent.
Definition: socket.cc:295
TypeId SetParent(TypeId tid)
Set the parent TypeId.
Definition: type-id.cc:915
void SetRecvIf(uint32_t ifindex)
Set the tag&#39;s receiving interface.
static bool IsMatchingType(const Address &address)
int DoSendTo(Ptr< Packet > p, Ipv4Address daddr, uint16_t dport, uint8_t tos)
Send a packet to a specific destination and port (IPv4)
virtual uint32_t GetRxAvailable(void) const
Return number of bytes which can be returned from one or multiple calls to Recv.
Callback< void, Ipv4Address, uint8_t, uint8_t, uint8_t, uint32_t > m_icmpCallback
ICMP callback.
uint8_t GetPriority(void) const
Query the priority value of this socket.
Definition: socket.cc:396
bool IsAny() const
If the IPv6 address is the "Any" address.
Ipv4Address GetIpv4(void) const
static Ipv6Address ConvertFrom(const Address &address)
Convert the Address object into an Ipv6Address ones.
virtual void SetIpMulticastTtl(uint8_t ipTtl)
Set the IP multicast TTL.
void SetRecvIf(uint32_t ifindex)
Set the tag&#39;s receiving interface.