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),
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 
260  if (InetSocketAddress::IsMatchingType (address))
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  }
295  else if (Inet6SocketAddress::IsMatchingType (address))
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);
399  if (InetSocketAddress::IsMatchingType(address) == true)
400  {
402  m_defaultAddress = Address(transport.GetIpv4 ());
403  m_defaultPort = transport.GetPort ();
404  SetIpTos (transport.GetTos ());
405  m_connected = true;
407  }
408  else if (Inet6SocketAddress::IsMatchingType(address) == true)
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  // If dest is set to the limited broadcast address (all ones),
573  // convert it to send a copy of the packet out of every
574  // interface as a subnet-directed broadcast.
575  // Exception: if the interface has a /32 address, there is no
576  // valid subnet-directed broadcast, so send it as limited broadcast
577  // Note also that some systems will only send limited broadcast packets
578  // out of the "default" interface; here we send it out all interfaces
579  //
580  if (dest.IsBroadcast ())
581  {
582  if (!m_allowBroadcast)
583  {
585  return -1;
586  }
587  NS_LOG_LOGIC ("Limited broadcast start.");
588  for (uint32_t i = 0; i < ipv4->GetNInterfaces (); i++ )
589  {
590  // Get the primary address
591  Ipv4InterfaceAddress iaddr = ipv4->GetAddress (i, 0);
592  Ipv4Address addri = iaddr.GetLocal ();
593  if (addri == Ipv4Address ("127.0.0.1"))
594  continue;
595  // Check if interface-bound socket
596  if (m_boundnetdevice)
597  {
598  if (ipv4->GetNetDevice (i) != m_boundnetdevice)
599  continue;
600  }
601  NS_LOG_LOGIC ("Sending one copy from " << addri << " to " << dest);
602  m_udp->Send (p->Copy (), addri, dest,
604  NotifyDataSent (p->GetSize ());
606  }
607  NS_LOG_LOGIC ("Limited broadcast end.");
608  return p->GetSize ();
609  }
611  {
612  m_udp->Send (p->Copy (), m_endPoint->GetLocalAddress (), dest,
613  m_endPoint->GetLocalPort (), port, 0);
614  NotifyDataSent (p->GetSize ());
616  return p->GetSize ();
617  }
618  else if (ipv4->GetRoutingProtocol () != 0)
619  {
620  Ipv4Header header;
621  header.SetDestination (dest);
623  Socket::SocketErrno errno_;
624  Ptr<Ipv4Route> route;
625  Ptr<NetDevice> oif = m_boundnetdevice; //specify non-zero if bound to a specific device
626  // TBD-- we could cache the route and just check its validity
627  route = ipv4->GetRoutingProtocol ()->RouteOutput (p, header, oif, errno_);
628  if (route != 0)
629  {
630  NS_LOG_LOGIC ("Route exists");
631  if (!m_allowBroadcast)
632  {
633  uint32_t outputIfIndex = ipv4->GetInterfaceForDevice (route->GetOutputDevice ());
634  uint32_t ifNAddr = ipv4->GetNAddresses (outputIfIndex);
635  for (uint32_t addrI = 0; addrI < ifNAddr; ++addrI)
636  {
637  Ipv4InterfaceAddress ifAddr = ipv4->GetAddress (outputIfIndex, addrI);
638  if (dest == ifAddr.GetBroadcast ())
639  {
641  return -1;
642  }
643  }
644  }
645 
646  header.SetSource (route->GetSource ());
647  m_udp->Send (p->Copy (), header.GetSource (), header.GetDestination (),
648  m_endPoint->GetLocalPort (), port, route);
649  NotifyDataSent (p->GetSize ());
650  return p->GetSize ();
651  }
652  else
653  {
654  NS_LOG_LOGIC ("No route to destination");
655  NS_LOG_ERROR (errno_);
656  m_errno = errno_;
657  return -1;
658  }
659  }
660  else
661  {
662  NS_LOG_ERROR ("ERROR_NOROUTETOHOST");
664  return -1;
665  }
666 
667  return 0;
668 }
669 
670 int
672 {
673  NS_LOG_FUNCTION (this << p << dest << port);
674 
675  if (dest.IsIpv4MappedAddress ())
676  {
677  return (DoSendTo(p, dest.GetIpv4MappedAddress (), port, 0));
678  }
679  if (m_boundnetdevice)
680  {
681  NS_LOG_LOGIC ("Bound interface number " << m_boundnetdevice->GetIfIndex ());
682  }
683  if (m_endPoint6 == 0)
684  {
685  if (Bind6 () == -1)
686  {
687  NS_ASSERT (m_endPoint6 == 0);
688  return -1;
689  }
690  NS_ASSERT (m_endPoint6 != 0);
691  }
692  if (m_shutdownSend)
693  {
695  return -1;
696  }
697 
698  if (p->GetSize () > GetTxAvailable () )
699  {
701  return -1;
702  }
703 
704  if (IsManualIpv6Tclass ())
705  {
706  SocketIpv6TclassTag ipTclassTag;
707  ipTclassTag.SetTclass (GetIpv6Tclass ());
708  p->AddPacketTag (ipTclassTag);
709  }
710 
711  uint8_t priority = GetPriority ();
712  if (priority)
713  {
714  SocketPriorityTag priorityTag;
715  priorityTag.SetPriority (priority);
716  p->ReplacePacketTag (priorityTag);
717  }
718 
719  Ptr<Ipv6> ipv6 = m_node->GetObject<Ipv6> ();
720 
721  // Locally override the IP TTL for this socket
722  // We cannot directly modify the TTL at this stage, so we set a Packet tag
723  // The destination can be either multicast, unicast/anycast, or
724  // either all-hosts broadcast or limited (subnet-directed) broadcast.
725  // For the latter two broadcast types, the TTL will later be set to one
726  // irrespective of what is set in these socket options. So, this tagging
727  // may end up setting the TTL of a limited broadcast packet to be
728  // the same as a unicast, but it will be fixed further down the stack
729  if (m_ipMulticastTtl != 0 && dest.IsMulticast ())
730  {
733  p->AddPacketTag (tag);
734  }
735  else if (IsManualIpv6HopLimit () && GetIpv6HopLimit () != 0 && !dest.IsMulticast ())
736  {
738  tag.SetHopLimit (GetIpv6HopLimit ());
739  p->AddPacketTag (tag);
740  }
741  // There is no analgous to an IPv4 broadcast address in IPv6.
742  // Instead, we use a set of link-local, site-local, and global
743  // multicast addresses. The Ipv6 routing layers should all
744  // provide an interface-specific route to these addresses such
745  // that we can treat these multicast addresses as "not broadcast"
746 
748  {
749  m_udp->Send (p->Copy (), m_endPoint6->GetLocalAddress (), dest,
750  m_endPoint6->GetLocalPort (), port, 0);
751  NotifyDataSent (p->GetSize ());
753  return p->GetSize ();
754  }
755  else if (ipv6->GetRoutingProtocol () != 0)
756  {
757  Ipv6Header header;
758  header.SetDestinationAddress (dest);
760  Socket::SocketErrno errno_;
761  Ptr<Ipv6Route> route;
762  Ptr<NetDevice> oif = m_boundnetdevice; //specify non-zero if bound to a specific device
763  // TBD-- we could cache the route and just check its validity
764  route = ipv6->GetRoutingProtocol ()->RouteOutput (p, header, oif, errno_);
765  if (route != 0)
766  {
767  NS_LOG_LOGIC ("Route exists");
768  header.SetSourceAddress (route->GetSource ());
769  m_udp->Send (p->Copy (), header.GetSourceAddress (), header.GetDestinationAddress (),
770  m_endPoint6->GetLocalPort (), port, route);
771  NotifyDataSent (p->GetSize ());
772  return p->GetSize ();
773  }
774  else
775  {
776  NS_LOG_LOGIC ("No route to destination");
777  NS_LOG_ERROR (errno_);
778  m_errno = errno_;
779  return -1;
780  }
781  }
782  else
783  {
784  NS_LOG_ERROR ("ERROR_NOROUTETOHOST");
786  return -1;
787  }
788 
789  return 0;
790 }
791 
792 
793 // maximum message size for UDP broadcast is limited by MTU
794 // size of underlying link; we are not checking that now.
795 // \todo Check MTU size of underlying link
796 uint32_t
798 {
800  // No finite send buffer is modelled, but we must respect
801  // the maximum size of an IP datagram (65535 bytes - headers).
803 }
804 
805 int
807 {
808  NS_LOG_FUNCTION (this << p << flags << address);
809  if (InetSocketAddress::IsMatchingType (address))
810  {
812  Ipv4Address ipv4 = transport.GetIpv4 ();
813  uint16_t port = transport.GetPort ();
814  uint8_t tos = transport.GetTos ();
815  return DoSendTo (p, ipv4, port, tos);
816  }
817  else if (Inet6SocketAddress::IsMatchingType (address))
818  {
820  Ipv6Address ipv6 = transport.GetIpv6 ();
821  uint16_t port = transport.GetPort ();
822  return DoSendTo (p, ipv6, port);
823  }
824  return -1;
825 }
826 
827 uint32_t
829 {
831  // We separately maintain this state to avoid walking the queue
832  // every time this might be called
833  return m_rxAvailable;
834 }
835 
837 UdpSocketImpl::Recv (uint32_t maxSize, uint32_t flags)
838 {
839  NS_LOG_FUNCTION (this << maxSize << flags);
840 
841  Address fromAddress;
842  Ptr<Packet> packet = RecvFrom (maxSize, flags, fromAddress);
843  return packet;
844 }
845 
847 UdpSocketImpl::RecvFrom (uint32_t maxSize, uint32_t flags,
848  Address &fromAddress)
849 {
850  NS_LOG_FUNCTION (this << maxSize << flags);
851 
852  if (m_deliveryQueue.empty () )
853  {
855  return 0;
856  }
857  Ptr<Packet> p = m_deliveryQueue.front ().first;
858  fromAddress = m_deliveryQueue.front ().second;
859 
860  if (p->GetSize () <= maxSize)
861  {
862  m_deliveryQueue.pop ();
863  m_rxAvailable -= p->GetSize ();
864  }
865  else
866  {
867  p = 0;
868  }
869  return p;
870 }
871 
872 int
874 {
876  if (m_endPoint != 0)
877  {
879  }
880  else if (m_endPoint6 != 0)
881  {
883  }
884  else
885  { // It is possible to call this method on a socket without a name
886  // in which case, behavior is unspecified
887  // Should this return an InetSocketAddress or an Inet6SocketAddress?
888  address = InetSocketAddress (Ipv4Address::GetZero (), 0);
889  }
890  return 0;
891 }
892 
893 int
895 {
896  NS_LOG_FUNCTION (this << address);
897 
898  if (!m_connected)
899  {
901  return -1;
902  }
903 
905  {
907  InetSocketAddress inet (addr, m_defaultPort);
908  inet.SetTos (GetIpTos ());
909  address = inet;
910  }
912  {
914  address = Inet6SocketAddress (addr, m_defaultPort);
915  }
916  else
917  {
918  NS_ASSERT_MSG (false, "unexpected address type");
919  }
920 
921  return 0;
922 }
923 
924 int
925 UdpSocketImpl::MulticastJoinGroup (uint32_t interface, const Address &groupAddress)
926 {
927  NS_LOG_FUNCTION (interface << groupAddress);
928  /*
929  1) sanity check interface
930  2) sanity check that it has not been called yet on this interface/group
931  3) determine address family of groupAddress
932  4) locally store a list of (interface, groupAddress)
933  5) call ipv4->MulticastJoinGroup () or Ipv6->MulticastJoinGroup ()
934  */
935  return 0;
936 }
937 
938 int
939 UdpSocketImpl::MulticastLeaveGroup (uint32_t interface, const Address &groupAddress)
940 {
941  NS_LOG_FUNCTION (interface << groupAddress);
942  /*
943  1) sanity check interface
944  2) determine address family of groupAddress
945  3) delete from local list of (interface, groupAddress); raise a LOG_WARN
946  if not already present (but return 0)
947  5) call ipv4->MulticastLeaveGroup () or Ipv6->MulticastLeaveGroup ()
948  */
949  return 0;
950 }
951 
952 void
954 {
955  NS_LOG_FUNCTION (netdevice);
956 
957  Ptr<NetDevice> oldBoundNetDevice = m_boundnetdevice;
958 
959  Socket::BindToNetDevice (netdevice); // Includes sanity check
960  if (m_endPoint != 0)
961  {
962  m_endPoint->BindToNetDevice (netdevice);
963  }
964 
965  if (m_endPoint6 != 0)
966  {
967  m_endPoint6->BindToNetDevice (netdevice);
968 
969  // The following is to fix the multicast distribution inside the node
970  // and to upgrade it to the actual bound NetDevice.
972  {
974  if (ipv6l3)
975  {
976  // Cleanup old one
977  if (oldBoundNetDevice)
978  {
979  uint32_t index = ipv6l3->GetInterfaceForDevice (oldBoundNetDevice);
980  ipv6l3->RemoveMulticastAddress (m_endPoint6->GetLocalAddress (), index);
981  }
982  else
983  {
984  ipv6l3->RemoveMulticastAddress (m_endPoint6->GetLocalAddress ());
985  }
986  // add new one
987  if (netdevice)
988  {
989  uint32_t index = ipv6l3->GetInterfaceForDevice (netdevice);
990  ipv6l3->AddMulticastAddress (m_endPoint6->GetLocalAddress (), index);
991  }
992  else
993  {
994  ipv6l3->AddMulticastAddress (m_endPoint6->GetLocalAddress ());
995  }
996  }
997  }
998  }
999 
1000  return;
1001 }
1002 
1003 void
1005  Ptr<Ipv4Interface> incomingInterface)
1006 {
1007  NS_LOG_FUNCTION (this << packet << header << port);
1008 
1009  if (m_shutdownRecv)
1010  {
1011  return;
1012  }
1013 
1014  // Should check via getsockopt ()..
1015  if (IsRecvPktInfo ())
1016  {
1017  Ipv4PacketInfoTag tag;
1018  packet->RemovePacketTag (tag);
1019  tag.SetRecvIf (incomingInterface->GetDevice ()->GetIfIndex ());
1020  packet->AddPacketTag (tag);
1021  }
1022 
1023  //Check only version 4 options
1024  if (IsIpRecvTos ())
1025  {
1026  SocketIpTosTag ipTosTag;
1027  ipTosTag.SetTos (header.GetTos ());
1028  packet->AddPacketTag (ipTosTag);
1029  }
1030 
1031  if (IsIpRecvTtl ())
1032  {
1033  SocketIpTtlTag ipTtlTag;
1034  ipTtlTag.SetTtl (header.GetTtl ());
1035  packet->AddPacketTag (ipTtlTag);
1036  }
1037 
1038  // in case the packet still has a priority tag attached, remove it
1039  SocketPriorityTag priorityTag;
1040  packet->RemovePacketTag (priorityTag);
1041 
1042  if ((m_rxAvailable + packet->GetSize ()) <= m_rcvBufSize)
1043  {
1045  m_deliveryQueue.push (std::make_pair (packet, address));
1046  m_rxAvailable += packet->GetSize ();
1047  NotifyDataRecv ();
1048  }
1049  else
1050  {
1051  // In general, this case should not occur unless the
1052  // receiving application reads data from this socket slowly
1053  // in comparison to the arrival rate
1054  //
1055  // drop and trace packet
1056  NS_LOG_WARN ("No receive buffer space available. Drop.");
1057  m_dropTrace (packet);
1058  }
1059 }
1060 
1061 void
1062 UdpSocketImpl::ForwardUp6 (Ptr<Packet> packet, Ipv6Header header, uint16_t port, Ptr<Ipv6Interface> incomingInterface)
1063 {
1064  NS_LOG_FUNCTION (this << packet << header.GetSourceAddress () << port);
1065 
1066  if (m_shutdownRecv)
1067  {
1068  return;
1069  }
1070 
1071  // Should check via getsockopt ().
1072  if (IsRecvPktInfo ())
1073  {
1074  Ipv6PacketInfoTag tag;
1075  packet->RemovePacketTag (tag);
1076  tag.SetRecvIf (incomingInterface->GetDevice ()->GetIfIndex ());
1077  packet->AddPacketTag (tag);
1078  }
1079 
1080  // Check only version 6 options
1081  if (IsIpv6RecvTclass ())
1082  {
1083  SocketIpv6TclassTag ipTclassTag;
1084  ipTclassTag.SetTclass (header.GetTrafficClass ());
1085  packet->AddPacketTag (ipTclassTag);
1086  }
1087 
1088  if (IsIpv6RecvHopLimit ())
1089  {
1090  SocketIpv6HopLimitTag ipHopLimitTag;
1091  ipHopLimitTag.SetHopLimit (header.GetHopLimit ());
1092  packet->AddPacketTag (ipHopLimitTag);
1093  }
1094 
1095  // in case the packet still has a priority tag attached, remove it
1096  SocketPriorityTag priorityTag;
1097  packet->RemovePacketTag (priorityTag);
1098 
1099  if ((m_rxAvailable + packet->GetSize ()) <= m_rcvBufSize)
1100  {
1102  m_deliveryQueue.push (std::make_pair (packet, address));
1103  m_rxAvailable += packet->GetSize ();
1104  NotifyDataRecv ();
1105  }
1106  else
1107  {
1108  // In general, this case should not occur unless the
1109  // receiving application reads data from this socket slowly
1110  // in comparison to the arrival rate
1111  //
1112  // drop and trace packet
1113  NS_LOG_WARN ("No receive buffer space available. Drop.");
1114  m_dropTrace (packet);
1115  }
1116 }
1117 
1118 void
1119 UdpSocketImpl::ForwardIcmp (Ipv4Address icmpSource, uint8_t icmpTtl,
1120  uint8_t icmpType, uint8_t icmpCode,
1121  uint32_t icmpInfo)
1122 {
1123  NS_LOG_FUNCTION (this << icmpSource << (uint32_t)icmpTtl << (uint32_t)icmpType <<
1124  (uint32_t)icmpCode << icmpInfo);
1125  if (!m_icmpCallback.IsNull ())
1126  {
1127  m_icmpCallback (icmpSource, icmpTtl, icmpType, icmpCode, icmpInfo);
1128  }
1129 }
1130 
1131 void
1132 UdpSocketImpl::ForwardIcmp6 (Ipv6Address icmpSource, uint8_t icmpTtl,
1133  uint8_t icmpType, uint8_t icmpCode,
1134  uint32_t icmpInfo)
1135 {
1136  NS_LOG_FUNCTION (this << icmpSource << (uint32_t)icmpTtl << (uint32_t)icmpType <<
1137  (uint32_t)icmpCode << icmpInfo);
1138  if (!m_icmpCallback6.IsNull ())
1139  {
1140  m_icmpCallback6 (icmpSource, icmpTtl, icmpType, icmpCode, icmpInfo);
1141  }
1142 }
1143 
1144 void
1146 {
1147  m_rcvBufSize = size;
1148 }
1149 
1150 uint32_t
1152 {
1153  return m_rcvBufSize;
1154 }
1155 
1156 void
1158 {
1159  m_ipMulticastTtl = ipTtl;
1160 }
1161 
1162 uint8_t
1164 {
1165  return m_ipMulticastTtl;
1166 }
1167 
1168 void
1170 {
1171  m_ipMulticastIf = ipIf;
1172 }
1173 
1174 int32_t
1176 {
1177  return m_ipMulticastIf;
1178 }
1179 
1180 void
1182 {
1183  m_ipMulticastLoop = loop;
1184 }
1185 
1186 bool
1188 {
1189  return m_ipMulticastLoop;
1190 }
1191 
1192 void
1194 {
1195  m_mtuDiscover = discover;
1196 }
1197 bool
1199 {
1200  return m_mtuDiscover;
1201 }
1202 
1203 bool
1205 {
1206  m_allowBroadcast = allowBroadcast;
1207  return true;
1208 }
1209 
1210 bool
1212 {
1213  return m_allowBroadcast;
1214 }
1215 
1216 void
1217 UdpSocketImpl::Ipv6JoinGroup (Ipv6Address address, Socket::Ipv6MulticastFilterMode filterMode, std::vector<Ipv6Address> sourceAddresses)
1218 {
1219  NS_LOG_FUNCTION (this << address << &filterMode << &sourceAddresses);
1220 
1221  // We can join only one multicast group (or change its params)
1222  NS_ASSERT_MSG ((m_ipv6MulticastGroupAddress == address || m_ipv6MulticastGroupAddress.IsAny ()), "Can join only one IPv6 multicast group.");
1223 
1225 
1227  if (ipv6l3)
1228  {
1229  if (filterMode == INCLUDE && sourceAddresses.empty ())
1230  {
1231  // it is a leave
1232  if (m_boundnetdevice)
1233  {
1234  int32_t index = ipv6l3->GetInterfaceForDevice (m_boundnetdevice);
1235  NS_ASSERT_MSG (index >= 0, "Interface without a valid index");
1236  ipv6l3->RemoveMulticastAddress (address, index);
1237  }
1238  else
1239  {
1240  ipv6l3->RemoveMulticastAddress (address);
1241  }
1242  }
1243  else
1244  {
1245  // it is a join or a modification
1246  if (m_boundnetdevice)
1247  {
1248  int32_t index = ipv6l3->GetInterfaceForDevice (m_boundnetdevice);
1249  NS_ASSERT_MSG (index >= 0, "Interface without a valid index");
1250  ipv6l3->AddMulticastAddress (address, index);
1251  }
1252  else
1253  {
1254  ipv6l3->AddMulticastAddress (address);
1255  }
1256  }
1257  }
1258 }
1259 
1260 } // namespace ns3
static bool IsMatchingType(const Address &address)
If the Address matches the type.
bool IsAny() const
If the IPv6 address is the "Any" address.
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
uint8_t GetTrafficClass(void) const
Get the "Traffic class" field.
Definition: ipv6-header.cc:50
bool m_shutdownSend
Send no longer allowed.
void SetTclass(uint8_t tclass)
Set the tag&#39;s Tclass.
Definition: socket.cc:906
static const uint32_t MAX_IPV4_UDP_DATAGRAM_SIZE
Maximum UDP datagram size.
Ipv6Address GetIpv6(void) const
Get the IPv6 address.
virtual bool GetAllowBroadcast() const
Query whether broadcast datagram transmissions are allowed.
bool IsManualIpTtl(void) const
Checks if the socket has a specific IPv4 TTL set.
Definition: socket.cc:377
Packet header for IPv6.
Definition: ipv6-header.h:34
an Inet address class
Ipv4Address GetIpv4(void) const
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 "...
void Destroy(void)
Kill this socket by zeroing its attributes (IPv4)
bool IsIpv6RecvHopLimit(void) const
Ask if the socket is currently passing information about IPv6 Hop Limit up the stack.
Definition: socket.cc:563
Ptr< UdpL4Protocol > m_udp
the associated UDP L4 protocol
virtual bool GetIpMulticastLoop(void) const
Get the IP multicast loop capability.
virtual uint8_t GetIpTtl(void) const
Query the value of IP Time to Live field of this socket.
Definition: socket.cc:526
Ipv4EndPoint * m_endPoint
the IPv4 endpoint
uint8_t GetIpTos(void) const
Query the value of IP Type of Service of this socket.
Definition: socket.cc:459
This class implements a tag that carries the socket-specific HOPLIMIT of a packet to the IPv6 layer...
Definition: socket.h:1159
#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 void SetIpMulticastIf(int32_t ipIf)
Set the IP multicast interface.
Ipv4Address GetLocal(void) const
Get the local address.
Ptr< T > GetObject(void) const
Get a pointer to the requested aggregated Object.
Definition: object.h:459
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.
void AddPacketTag(const Tag &tag) const
Add a packet tag.
Definition: packet.cc:852
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 GetDestination(void) const
Definition: ipv4-header.cc:304
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.
virtual uint8_t GetIpMulticastTtl(void) const
Get the IP multicast TTL.
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Definition: log.h:202
uint32_t GetSize(void) const
Returns the the size in bytes of the packet (including the zero-filled initial payload).
Definition: packet.h:831
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.
bool IsMulticast(void) const
void BindToNetDevice(Ptr< NetDevice > netdevice)
Bind a socket to specific device.
virtual uint8_t GetIpv6HopLimit(void) const
Query the value of IP Hop Limit field of this socket.
Definition: socket.cc:551
Ipv4Address GetSource(void) const
Definition: ipv4-header.cc:291
#define NS_LOG_FUNCTION_NOARGS()
Output the name of the function.
void SetProtocol(uint8_t num)
Definition: ipv4-header.cc:278
void SetTos(uint8_t tos)
Set the tag&#39;s TOS.
Definition: socket.cc:791
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:408
This class implements a tag that carries the socket-specific TTL of a packet to the IP layer...
Definition: socket.h:1111
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:1074
virtual void Ipv6JoinGroup(Ipv6Address address, Socket::Ipv6MulticastFilterMode filterMode, std::vector< Ipv6Address > sourceAddresses)
Joins a IPv6 multicast group.
bool IsRecvPktInfo() const
Get status indicating whether enable/disable packet information to socket.
Definition: socket.cc:364
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 enum SocketErrno GetErrno(void) const
Get last error number.
Ptr< NetDevice > GetOutputDevice(void) const
Definition: ipv4-route.cc:84
bool IsIpRecvTos(void) const
Ask if the socket is currently passing information about IP Type of Service up the stack...
Definition: socket.cc:471
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)
virtual int GetSockName(Address &address) const
Get socket address.
void BindToNetDevice(Ptr< NetDevice > netdevice)
Bind a socket to specific device.
NS_ASSERT_MSG(false,"Ipv4AddressGenerator::MaskToIndex(): Impossible")
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:610
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 uint32_t GetRcvBufSize(void) const
Get the receiving buffer size.
virtual uint32_t GetRxAvailable(void) const
Return number of bytes which can be returned from one or multiple calls to Recv.
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:866
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
Ipv4Address GetLocalAddress(void)
Get the local address.
bool IsBroadcast(void) const
uint8_t m_ipMulticastTtl
Multicast TTL.
indicates whether the socket has a priority set.
Definition: socket.h:1303
Address m_defaultAddress
Default address.
virtual enum SocketType GetSocketType(void) const
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
virtual int32_t GetIpMulticastIf(void) const
Get the IP multicast interface.
bool IsManualIpv6Tclass(void) const
Checks if the socket has a specific IPv6 Tclass set.
Definition: socket.cc:371
void NotifyDataSent(uint32_t size)
Notify through the callback (if set) that some data have been sent.
Definition: socket.cc:285
virtual Ptr< NetDevice > GetDevice() const
Get the NetDevice.
Ipv4Address GetSource(void) const
Definition: ipv4-route.cc:56
void Destroy6(void)
Kill this socket by zeroing its attributes (IPv6)
uint8_t GetTos(void) const
static bool IsMatchingType(const Address &address)
int FinishBind(void)
Finish the binding process.
void SetHopLimit(uint8_t hopLimit)
Set the tag&#39;s Hop Limit.
Definition: socket.cc:671
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< Packet > Copy(void) const
performs a COW copy of the packet.
Definition: packet.cc:121
bool IsManualIpv6HopLimit(void) const
Checks if the socket has a specific IPv6 Hop Limit set.
Definition: socket.cc:383
virtual void SetIpMulticastLoop(bool loop)
Set the IP multicast loop capability.
uint8_t GetHopLimit(void) const
Get the "Hop limit" field (TTL).
Definition: ipv6-header.cc:90
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.
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< Node > m_node
the associated node
void SetIcmpCallback(Callback< void, Ipv6Address, uint8_t, uint8_t, uint8_t, uint32_t > callback)
Set the ICMP callback.
indicates whether the socket has IPV6_TCLASS set.
Definition: socket.h:1350
uint8_t GetIpv6Tclass(void) const
Query the value of IPv6 Traffic Class field of this socket.
Definition: socket.cc:501
bool IsMulticast() const
If the IPv6 address is multicast (ff00::/8).
virtual void Ipv6LeaveGroup(void)
Leaves IPv6 multicast group this socket is joined to.
Definition: socket.cc:586
static Ipv4Address GetZero(void)
bool IsIpv6RecvTclass(void) const
Ask if the socket is currently passing information about IPv6 Traffic Class up the stack...
Definition: socket.cc:513
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 int ShutdownSend(void)
void SetSourceAddress(Ipv6Address src)
Set the "Source address" field.
Definition: ipv6-header.cc:95
bool IsIpRecvTtl(void) const
Ask if the socket is currently passing information about IP_TTL up the stack.
Definition: socket.cc:538
void Disable(void)
Disables the DF (Don&#39;t Fragment) flag.
Definition: socket.cc:732
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 uint32_t GetTxAvailable(void) const
Returns the number of bytes which can be sent in a single call to Send.
Ipv4Address GetBroadcast(void) const
Get the broadcast address.
Ptr< NetDevice > m_boundnetdevice
the device this socket is bound to (might be null).
Definition: socket.h:1072
virtual bool SetAllowBroadcast(bool allowBroadcast)
Configure whether broadcast datagram transmissions are allowed.
a class to store IPv4 address information on an interface
virtual int GetPeerName(Address &address) const
Get the peer address of a connected socket.
uint32_t m_rcvBufSize
Receive buffer size.
uint16_t GetLocalPort(void)
Get the local port.
#define NS_LOG_WARN(msg)
Use NS_LOG to output a message of level LOG_WARN.
Definition: log.h:262
Ptr< NetDevice > GetDevice(void) const
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:859
Ipv6Address GetSourceAddress(void) const
Get the "Source address" field.
Definition: ipv6-header.cc:100
indicates whether packets should be sent out with the DF (Don&#39;t Fragment) flag set.
Definition: socket.h:1207
static Inet6SocketAddress ConvertFrom(const Address &addr)
Convert the address to a InetSocketAddress.
uint16_t m_defaultPort
Default port.
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:726
uint16_t GetPort(void) const
Get the port.
void DeallocateEndPoint(void)
Deallocate m_endPoint and m_endPoint6.
Ipv4Address GetIpv4MappedAddress() const
Return the Ipv4 address.
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.
#define NS_LOG_ERROR(msg)
Use NS_LOG to output a message of level LOG_ERROR.
Definition: log.h:254
uint16_t GetPort(void) const
uint8_t GetTtl(void) const
Definition: ipv4-header.cc:265
uint8_t GetTos(void) const
Definition: ipv4-header.cc:194
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.
TracedCallback< Ptr< const Packet > > m_dropTrace
Trace for dropped packets.
void SetPriority(uint8_t priority)
Set the tag&#39;s priority.
Definition: socket.cc:848
uint8_t GetPriority(void) const
Query the priority value of this socket.
Definition: socket.cc:402
indicates whether the socket has IP_TOS set.
Definition: socket.h:1257
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:443
bool IsIpv4MappedAddress() const
If the address is an IPv4-mapped address.
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)
Callback< void, Ipv4Address, uint8_t, uint8_t, uint8_t, uint32_t > m_icmpCallback
ICMP callback.
Ipv6Address GetDestinationAddress(void) const
Get the "Destination address" field.
Definition: ipv6-header.cc:110
static Ipv6Address ConvertFrom(const Address &address)
Convert the Address object into an Ipv6Address ones.
virtual bool GetMtuDiscover(void) const
Get the MTU discover capability.
virtual void SetIpMulticastTtl(uint8_t ipTtl)
Set the IP multicast TTL.
virtual Ptr< Node > GetNode(void) const
Return the node this socket is associated with.
void SetRecvIf(uint32_t ifindex)
Set the tag&#39;s receiving interface.