A Discrete-Event Network Simulator
API
socket.cc
Go to the documentation of this file.
1/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
2/*
3 * Copyright (c) 2006 Georgia Tech Research Corporation
4 * 2007 INRIA
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2 as
8 * published by the Free Software Foundation;
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18 *
19 * Authors: George F. Riley<riley@ece.gatech.edu>
20 * Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
21 */
22
23#include "ns3/log.h"
24#include "ns3/packet.h"
25#include "node.h"
26#include "socket.h"
27#include "socket-factory.h"
28#include <limits>
29
30namespace ns3 {
31
33
35
36TypeId
38{
39 static TypeId tid = TypeId ("ns3::Socket")
40 .SetParent<Object> ()
41 .SetGroupName("Network");
42 return tid;
43}
44
46 : m_manualIpTtl (false),
47 m_ipRecvTos (false),
48 m_ipRecvTtl (false),
49 m_manualIpv6Tclass (false),
50 m_manualIpv6HopLimit (false),
51 m_ipv6RecvTclass (false),
52 m_ipv6RecvHopLimit (false)
53{
56 m_recvPktInfo = false;
57
58 m_priority = 0;
59 m_ipTos = 0;
60 m_ipTtl = 0;
61 m_ipv6Tclass = 0;
63}
64
66{
67 NS_LOG_FUNCTION (this);
68}
69
72{
73 NS_LOG_FUNCTION (node << tid);
75 NS_ASSERT (node);
76 Ptr<SocketFactory> socketFactory = node->GetObject<SocketFactory> (tid);
77 NS_ASSERT (socketFactory);
78 s = socketFactory->CreateSocket ();
79 NS_ASSERT (s);
80 return s;
81}
82
83void
85 Callback<void, Ptr<Socket> > connectionSucceeded,
86 Callback<void, Ptr<Socket> > connectionFailed)
87{
88 NS_LOG_FUNCTION (this << &connectionSucceeded << &connectionFailed);
89 m_connectionSucceeded = connectionSucceeded;
90 m_connectionFailed = connectionFailed;
91}
92
93void
95 Callback<void, Ptr<Socket> > normalClose,
96 Callback<void, Ptr<Socket> > errorClose)
97{
98 NS_LOG_FUNCTION (this << &normalClose << &errorClose);
99 m_normalClose = normalClose;
100 m_errorClose = errorClose;
101}
102
103void
105 Callback<bool, Ptr<Socket>, const Address &> connectionRequest,
106 Callback<void, Ptr<Socket>, const Address&> newConnectionCreated)
107{
108 NS_LOG_FUNCTION (this << &connectionRequest << &newConnectionCreated);
109 m_connectionRequest = connectionRequest;
110 m_newConnectionCreated = newConnectionCreated;
111}
112
113void
115{
116 NS_LOG_FUNCTION (this << &dataSent);
117 m_dataSent = dataSent;
118}
119
120void
122{
123 NS_LOG_FUNCTION (this << &sendCb);
124 m_sendCb = sendCb;
125}
126
127void
129{
130 NS_LOG_FUNCTION (this << &receivedData);
131 m_receivedData = receivedData;
132}
133
134int
136{
137 NS_LOG_FUNCTION (this << p);
138 return Send (p, 0);
139}
140
141int
142Socket::Send (const uint8_t* buf, uint32_t size, uint32_t flags)
143{
144 NS_LOG_FUNCTION (this << &buf << size << flags);
145 Ptr<Packet> p;
146 if (buf)
147 {
148 p = Create<Packet> (buf, size);
149 }
150 else
151 {
152 p = Create<Packet> (size);
153 }
154 return Send (p, flags);
155}
156
157int
158Socket::SendTo (const uint8_t* buf, uint32_t size, uint32_t flags,
159 const Address &toAddress)
160{
161 NS_LOG_FUNCTION (this << &buf << size << flags << &toAddress);
162 Ptr<Packet> p;
163 if(buf)
164 {
165 p = Create<Packet> (buf, size);
166 }
167 else
168 {
169 p = Create<Packet> (size);
170 }
171 return SendTo (p, flags, toAddress);
172}
173
176{
177 NS_LOG_FUNCTION (this);
179}
180
181int
182Socket::Recv (uint8_t* buf, uint32_t size, uint32_t flags)
183{
184 NS_LOG_FUNCTION (this << &buf << size << flags);
185 Ptr<Packet> p = Recv (size, flags); // read up to "size" bytes
186 if (!p)
187 {
188 return 0;
189 }
190 p->CopyData (buf, p->GetSize ());
191 return p->GetSize ();
192}
193
196{
197 NS_LOG_FUNCTION (this << &fromAddress);
198 return RecvFrom (std::numeric_limits<uint32_t>::max (), 0, fromAddress);
199}
200
201int
202Socket::RecvFrom (uint8_t* buf, uint32_t size, uint32_t flags,
203 Address &fromAddress)
204{
205 NS_LOG_FUNCTION (this << &buf << size << flags << &fromAddress);
206 Ptr<Packet> p = RecvFrom (size, flags, fromAddress);
207 if (!p)
208 {
209 return 0;
210 }
211 p->CopyData (buf, p->GetSize ());
212 return p->GetSize ();
213}
214
215
216void
218{
219 NS_LOG_FUNCTION (this);
220 if (!m_connectionSucceeded.IsNull ())
221 {
223 }
224}
225
226void
228{
229 NS_LOG_FUNCTION (this);
230 if (!m_connectionFailed.IsNull ())
231 {
232 m_connectionFailed (this);
233 }
234}
235
236void
238{
239 NS_LOG_FUNCTION (this);
240 if (!m_normalClose.IsNull ())
241 {
242 m_normalClose (this);
243 }
244}
245
246void
248{
249 NS_LOG_FUNCTION (this);
250 if (!m_errorClose.IsNull ())
251 {
252 m_errorClose (this);
253 }
254}
255
256bool
258{
259 NS_LOG_FUNCTION (this << &from);
260 if (!m_connectionRequest.IsNull ())
261 {
262 return m_connectionRequest (this, from);
263 }
264 else
265 {
266 // accept all incoming connections by default.
267 // this way people writing code don't have to do anything
268 // special like register a callback that returns true
269 // just to get incoming connections
270 return true;
271 }
272}
273
274void
276{
277 NS_LOG_FUNCTION (this << socket << from);
278 if (!m_newConnectionCreated.IsNull ())
279 {
280 m_newConnectionCreated (socket, from);
281 }
282}
283
284void
286{
287 NS_LOG_FUNCTION (this << size);
288 if (!m_dataSent.IsNull ())
289 {
290 m_dataSent (this, size);
291 }
292}
293
294void
296{
297 NS_LOG_FUNCTION (this << spaceAvailable);
298 if (!m_sendCb.IsNull ())
299 {
300 m_sendCb (this, spaceAvailable);
301 }
302}
303
304void
306{
307 NS_LOG_FUNCTION (this);
308 if (!m_receivedData.IsNull ())
309 {
310 m_receivedData (this);
311 }
312}
313
314void
316{
317 NS_LOG_FUNCTION (this);
318 m_connectionSucceeded = MakeNullCallback<void,Ptr<Socket> > ();
319 m_connectionFailed = MakeNullCallback<void,Ptr<Socket> > ();
320 m_normalClose = MakeNullCallback<void,Ptr<Socket> > ();
321 m_errorClose = MakeNullCallback<void,Ptr<Socket> > ();
322 m_connectionRequest = MakeNullCallback<bool,Ptr<Socket>, const Address &> ();
323 m_newConnectionCreated = MakeNullCallback<void,Ptr<Socket>, const Address &> ();
324 m_dataSent = MakeNullCallback<void,Ptr<Socket>, uint32_t> ();
325 m_sendCb = MakeNullCallback<void,Ptr<Socket>, uint32_t> ();
326 m_receivedData = MakeNullCallback<void,Ptr<Socket> > ();
327}
328
329void
331{
332 NS_LOG_FUNCTION (this << netdevice);
333 if (netdevice)
334 {
335 bool found = false;
336 for (uint32_t i = 0; i < GetNode ()->GetNDevices (); i++)
337 {
338 if (GetNode ()->GetDevice (i) == netdevice)
339 {
340 found = true;
341 break;
342 }
343 }
344 NS_ASSERT_MSG (found, "Socket cannot be bound to a NetDevice not existing on the Node");
345 }
346 m_boundnetdevice = netdevice;
347}
348
351{
352 NS_LOG_FUNCTION (this);
353 return m_boundnetdevice;
354}
355
356void
358{
359 NS_LOG_FUNCTION (this << flag);
360 m_recvPktInfo = flag;
361}
362
364{
365 NS_LOG_FUNCTION (this);
366 return m_recvPktInfo;
367}
368
369bool
371{
372 return m_manualIpv6Tclass;
373}
374
375bool
377{
378 return m_manualIpTtl;
379}
380
381bool
383{
385}
386
387void
388Socket::SetPriority (uint8_t priority)
389{
390 NS_LOG_FUNCTION (this << priority);
391 m_priority = priority;
392}
393
394uint8_t
396{
397 return m_priority;
398}
399
400uint8_t
402{
403 uint8_t prio = NS3_PRIO_BESTEFFORT;
404 ipTos &= 0x1e;
405 switch (ipTos >> 1)
406 {
407 case 0:
408 case 1:
409 case 2:
410 case 3:
411 prio = NS3_PRIO_BESTEFFORT;
412 break;
413 case 4:
414 case 5:
415 case 6:
416 case 7:
417 prio = NS3_PRIO_BULK;
418 break;
419 case 8:
420 case 9:
421 case 10:
422 case 11:
424 break;
425 case 12:
426 case 13:
427 case 14:
428 case 15:
430 break;
431 }
432 return prio;
433}
434
435void
436Socket::SetIpTos (uint8_t tos)
437{
441 {
442 // preserve the least two significant bits of the current TOS
443 // value, which are used for ECN
444 tos &= 0xfc;
445 tos |= m_ipTos & 0x3;
446 }
447 m_ipTos = tos;
449}
450
451uint8_t
453{
454 return m_ipTos;
455}
456
457void
458Socket::SetIpRecvTos (bool ipv4RecvTos)
459{
460 m_ipRecvTos = ipv4RecvTos;
461}
462
463bool
465{
466 return m_ipRecvTos;
467}
468
469void
471{
474
475 //If -1 or invalid values, use default
476 if (tclass == -1 || tclass < -1 || tclass > 0xff)
477 {
478 //Print a warning
479 if (tclass < -1 || tclass > 0xff)
480 {
481 NS_LOG_WARN ("Invalid IPV6_TCLASS value. Using default.");
482 }
483 m_manualIpv6Tclass = false;
484 m_ipv6Tclass = 0;
485 }
486 else
487 {
488 m_manualIpv6Tclass = true;
489 m_ipv6Tclass = tclass;
490 }
491}
492
493uint8_t
495{
496 return m_ipv6Tclass;
497}
498
499void
500Socket::SetIpv6RecvTclass (bool ipv6RecvTclass)
501{
502 m_ipv6RecvTclass = ipv6RecvTclass;
503}
504
505bool
507{
508 return m_ipv6RecvTclass;
509}
510
511void
512Socket::SetIpTtl (uint8_t ttl)
513{
514 m_manualIpTtl = true;
515 m_ipTtl = ttl;
516}
517
518uint8_t
520{
521 return m_ipTtl;
522}
523
524void
525Socket::SetIpRecvTtl (bool ipv4RecvTtl)
526{
527 m_ipRecvTtl = ipv4RecvTtl;
528}
529
530bool
532{
533 return m_ipRecvTtl;
534}
535
536void
537Socket::SetIpv6HopLimit (uint8_t ipHopLimit)
538{
540 m_ipv6HopLimit = ipHopLimit;
541}
542
543uint8_t
545{
546 return m_ipv6HopLimit;
547}
548
549void
550Socket::SetIpv6RecvHopLimit (bool ipv6RecvHopLimit)
551{
552 m_ipv6RecvHopLimit = ipv6RecvHopLimit;
553}
554
555bool
557{
558 return m_ipv6RecvHopLimit;
559}
560
561void
562Socket::Ipv6JoinGroup (Ipv6Address address, Ipv6MulticastFilterMode filterMode, std::vector<Ipv6Address> sourceAddresses)
563{
564 NS_LOG_FUNCTION (this<<address<<&filterMode<<&sourceAddresses);
565 NS_ASSERT_MSG (false,"Ipv6JoinGroup not implemented on this socket");
566}
567
568void
570{
571 NS_LOG_FUNCTION (this<<address);
572
573 // Join Group. Note that joining a group with no sources means joining without source restrictions.
574 std::vector<Ipv6Address> sourceAddresses;
575 Ipv6JoinGroup (address, EXCLUDE, sourceAddresses);
576}
577
578void
580{
581 NS_LOG_FUNCTION (this);
583 {
584 NS_LOG_INFO (" The socket was not bound to any group.");
585 return;
586 }
587 // Leave Group. Note that joining a group with no sources means leaving it.
588 std::vector<Ipv6Address> sourceAddresses;
591}
592
593/***************************************************************
594 * Socket Tags
595 ***************************************************************/
596
598{
599 NS_LOG_FUNCTION (this);
600}
601
602void
604{
605 NS_LOG_FUNCTION (this << static_cast<uint32_t> (ttl));
606 m_ttl = ttl;
607}
608
609uint8_t
611{
612 NS_LOG_FUNCTION (this);
613 return m_ttl;
614}
615
617
618TypeId
620{
621 static TypeId tid = TypeId ("ns3::SocketIpTtlTag")
622 .SetParent<Tag> ()
623 .SetGroupName("Network")
624 .AddConstructor<SocketIpTtlTag> ()
625 ;
626 return tid;
627}
628TypeId
630{
631 return GetTypeId ();
632}
633
636{
637 NS_LOG_FUNCTION (this);
638 return 1;
639}
640void
642{
643 NS_LOG_FUNCTION (this << &i);
644 i.WriteU8 (m_ttl);
645}
646void
648{
649 NS_LOG_FUNCTION (this << &i);
650 m_ttl = i.ReadU8 ();
651}
652void
653SocketIpTtlTag::Print (std::ostream &os) const
654{
655 NS_LOG_FUNCTION (this << &os);
656 os << "Ttl=" << (uint32_t) m_ttl;
657}
658
660{
661}
662
663void
665{
666 m_hopLimit = hopLimit;
667}
668
669uint8_t
671{
672 return m_hopLimit;
673}
674
676
677TypeId
679{
680 static TypeId tid = TypeId ("ns3::SocketIpv6HopLimitTag")
681 .SetParent<Tag> ()
682 .SetGroupName("Network")
683 .AddConstructor<SocketIpv6HopLimitTag> ()
684 ;
685 return tid;
686}
687TypeId
689{
690 return GetTypeId ();
691}
692
695{
696 return 1;
697}
698void
700{
702}
703void
705{
706 m_hopLimit = i.ReadU8 ();
707}
708void
709SocketIpv6HopLimitTag::Print (std::ostream &os) const
710{
711 os << "HopLimit=" << (uint32_t) m_hopLimit;
712}
713
715{
716 NS_LOG_FUNCTION (this);
717}
718void
720{
721 NS_LOG_FUNCTION (this);
722 m_dontFragment = true;
723}
724void
726{
727 NS_LOG_FUNCTION (this);
728 m_dontFragment = false;
729}
730bool
732{
733 NS_LOG_FUNCTION (this);
734 return m_dontFragment;
735}
736
738
739TypeId
741{
742 static TypeId tid = TypeId ("ns3::SocketSetDontFragmentTag")
743 .SetParent<Tag> ()
744 .SetGroupName("Network")
745 .AddConstructor<SocketSetDontFragmentTag> ();
746 return tid;
747}
748TypeId
750{
751 return GetTypeId ();
752}
755{
756 NS_LOG_FUNCTION (this);
757 return 1;
758}
759void
761{
762 NS_LOG_FUNCTION (this << &i);
763 i.WriteU8 (m_dontFragment ? 1 : 0);
764}
765void
767{
768 NS_LOG_FUNCTION (this << &i);
769 m_dontFragment = (i.ReadU8 () == 1);
770}
771void
772SocketSetDontFragmentTag::Print (std::ostream &os) const
773{
774 NS_LOG_FUNCTION (this << &os);
775 os << (m_dontFragment ? "true" : "false");
776}
777
778
780{
781}
782
783void
785{
786 m_ipTos = ipTos;
787}
788
789uint8_t
791{
792 return m_ipTos;
793}
794
795TypeId
797{
798 static TypeId tid = TypeId ("ns3::SocketIpTosTag")
799 .SetParent<Tag> ()
800 .SetGroupName("Network")
801 .AddConstructor<SocketIpTosTag> ()
802 ;
803 return tid;
804}
805
806TypeId
808{
809 return GetTypeId ();
810}
811
814{
815 return sizeof (uint8_t);
816}
817
818void
820{
821 i.WriteU8 (m_ipTos);
822}
823
824void
826{
827 m_ipTos = i.ReadU8();
828}
829void
830SocketIpTosTag::Print (std::ostream &os) const
831{
832 os << "IP_TOS = " << m_ipTos;
833}
834
835
837{
838}
839
840void
842{
843 m_priority = priority;
844}
845
846uint8_t
848{
849 return m_priority;
850}
851
852TypeId
854{
855 static TypeId tid = TypeId ("ns3::SocketPriorityTag")
856 .SetParent<Tag> ()
857 .SetGroupName("Network")
858 .AddConstructor<SocketPriorityTag> ()
859 ;
860 return tid;
861}
862
863TypeId
865{
866 return GetTypeId ();
867}
868
871{
872 return sizeof (uint8_t);
873}
874
875void
877{
879}
880
881void
883{
884 m_priority = i.ReadU8();
885}
886
887void
888SocketPriorityTag::Print (std::ostream &os) const
889{
890 os << "SO_PRIORITY = " << m_priority;
891}
892
893
895{
896}
897
898void
900{
901 m_ipv6Tclass = tclass;
902}
903
904uint8_t
906{
907 return m_ipv6Tclass;
908}
909
910TypeId
912{
913 static TypeId tid = TypeId ("ns3::SocketIpv6TclassTag")
914 .SetParent<Tag> ()
915 .SetGroupName("Network")
916 .AddConstructor<SocketIpv6TclassTag> ()
917 ;
918 return tid;
919}
920
921TypeId
923{
924 return GetTypeId ();
925}
926
929{
930 return sizeof (uint8_t);
931}
932
933void
935{
937}
938
939void
941{
942 m_ipv6Tclass = i.ReadU8();
943}
944void
945SocketIpv6TclassTag::Print (std::ostream &os) const
946{
947 os << "IPV6_TCLASS = " << m_ipv6Tclass;
948}
949
950} // namespace ns3
#define max(a, b)
Definition: 80211b.c:43
a polymophic address class
Definition: address.h:91
Callback template class.
Definition: callback.h:422
Describes an IPv6 address.
Definition: ipv6-address.h:50
static Ipv6Address GetAny()
Get the "any" (::) Ipv6Address.
bool IsAny() const
If the IPv6 address is the "Any" address.
uint32_t GetNDevices(void) const
Definition: node.cc:152
Ptr< NetDevice > GetDevice(uint32_t index) const
Retrieve the index-th NetDevice associated to this node.
Definition: node.cc:144
A base class which provides memory management and object aggregation.
Definition: object.h:88
Ptr< T > GetObject(void) const
Get a pointer to the requested aggregated Object.
Definition: object.h:470
uint32_t CopyData(uint8_t *buffer, uint32_t size) const
Copy the packet contents to a byte buffer.
Definition: packet.cc:378
uint32_t GetSize(void) const
Returns the the size in bytes of the packet (including the zero-filled initial payload).
Definition: packet.h:856
Object to create transport layer instances that provide a socket API to applications.
virtual int Send(Ptr< Packet > p, uint32_t flags)=0
Send data (or dummy data) to the remote host.
Ptr< NetDevice > GetBoundNetDevice()
Returns socket's bound NetDevice, if any.
Definition: socket.cc:350
virtual void SetIpTtl(uint8_t ipTtl)
Manually set IP Time to Live field.
Definition: socket.cc:512
bool IsManualIpv6HopLimit(void) const
Checks if the socket has a specific IPv6 Hop Limit set.
Definition: socket.cc:382
Callback< void, Ptr< Socket > > m_normalClose
connection closed callback
Definition: socket.h:1084
uint8_t GetIpv6Tclass(void) const
Query the value of IPv6 Traffic Class field of this socket.
Definition: socket.cc:494
uint8_t GetPriority(void) const
Query the priority value of this socket.
Definition: socket.cc:395
bool m_ipv6RecvHopLimit
socket forwards IPv6 Hop Limit tag to L4
Definition: socket.h:1106
uint8_t m_ipTos
the socket IPv4 TOS
Definition: socket.h:1099
void SetConnectCallback(Callback< void, Ptr< Socket > > connectionSucceeded, Callback< void, Ptr< Socket > > connectionFailed)
Specify callbacks to allow the caller to determine if the connection succeeds of fails.
Definition: socket.cc:84
bool IsIpRecvTtl(void) const
Ask if the socket is currently passing information about IP_TTL up the stack.
Definition: socket.cc:531
uint8_t m_priority
the socket priority
Definition: socket.h:1092
Socket(void)
Definition: socket.cc:45
void SetIpTos(uint8_t ipTos)
Manually set IP Type of Service field.
Definition: socket.cc:436
virtual Ptr< Packet > RecvFrom(uint32_t maxSize, uint32_t flags, Address &fromAddress)=0
Read a single packet from the socket and retrieve the sender address.
bool m_manualIpv6HopLimit
socket has IPv6 Hop Limit set
Definition: socket.h:1104
void NotifyConnectionSucceeded(void)
Notify through the callback (if set) that the connection has been established.
Definition: socket.cc:217
void SetRecvPktInfo(bool flag)
Enable/Disable receive packet information to socket.
Definition: socket.cc:357
void NotifySend(uint32_t spaceAvailable)
Notify through the callback (if set) that some data have been sent.
Definition: socket.cc:295
void NotifyConnectionFailed(void)
Notify through the callback (if set) that the connection has not been established due to an error.
Definition: socket.cc:227
void NotifyNewConnectionCreated(Ptr< Socket > socket, const Address &from)
Notify through the callback (if set) that a new connection has been created.
Definition: socket.cc:275
Callback< void, Ptr< Socket > > m_connectionFailed
connection failed callback
Definition: socket.h:1083
void SetAcceptCallback(Callback< bool, Ptr< Socket >, const Address & > connectionRequest, Callback< void, Ptr< Socket >, const Address & > newConnectionCreated)
Accept connection requests from remote hosts.
Definition: socket.cc:104
bool IsRecvPktInfo() const
Get status indicating whether enable/disable packet information to socket.
Definition: socket.cc:363
bool NotifyConnectionRequest(const Address &from)
Notify through the callback (if set) that an incoming connection is being requested by a remote host.
Definition: socket.cc:257
uint8_t m_ipTtl
the socket IPv4 TTL
Definition: socket.h:1100
uint8_t m_ipv6HopLimit
the socket IPv6 Hop Limit
Definition: socket.h:1109
virtual void DoDispose(void)
Destructor implementation.
Definition: socket.cc:315
void SetIpRecvTos(bool ipv4RecvTos)
Tells a socket to pass information about IP Type of Service up the stack.
Definition: socket.cc:458
bool IsIpv6RecvHopLimit(void) const
Ask if the socket is currently passing information about IPv6 Hop Limit up the stack.
Definition: socket.cc:556
Ipv6Address m_ipv6MulticastGroupAddress
IPv6 multicast group address.
Definition: socket.h:1079
bool m_ipRecvTos
socket forwards IPv4 TOS tag to L4
Definition: socket.h:1096
bool IsIpv6RecvTclass(void) const
Ask if the socket is currently passing information about IPv6 Traffic Class up the stack.
Definition: socket.cc:506
static TypeId GetTypeId(void)
Get the type ID.
Definition: socket.cc:37
@ NS3_SOCK_STREAM
Definition: socket.h:105
void NotifyNormalClose(void)
Notify through the callback (if set) that the connection has been closed.
Definition: socket.cc:237
virtual void SetIpv6HopLimit(uint8_t ipHopLimit)
Manually set IPv6 Hop Limit.
Definition: socket.cc:537
uint8_t m_ipv6Tclass
the socket IPv6 Tclass
Definition: socket.h:1108
bool m_recvPktInfo
if the socket should add packet info tags to the packet forwarded to L4.
Definition: socket.h:1078
Callback< void, Ptr< Socket > > m_connectionSucceeded
connection succeeded callback
Definition: socket.h:1082
void SetDataSentCallback(Callback< void, Ptr< Socket >, uint32_t > dataSent)
Notify application when a packet has been sent from transport protocol (non-standard socket call)
Definition: socket.cc:114
static uint8_t IpTos2Priority(uint8_t ipTos)
Return the priority corresponding to a given TOS value.
Definition: socket.cc:401
virtual ~Socket(void)
Definition: socket.cc:65
void SetSendCallback(Callback< void, Ptr< Socket >, uint32_t > sendCb)
Notify application when space in transmit buffer is added.
Definition: socket.cc:121
virtual Ptr< Node > GetNode(void) const =0
Return the node this socket is associated with.
bool IsManualIpTtl(void) const
Checks if the socket has a specific IPv4 TTL set.
Definition: socket.cc:376
void SetPriority(uint8_t priority)
Manually set the socket priority.
Definition: socket.cc:388
bool m_ipv6RecvTclass
socket forwards IPv6 Tclass tag to L4
Definition: socket.h:1105
bool IsIpRecvTos(void) const
Ask if the socket is currently passing information about IP Type of Service up the stack.
Definition: socket.cc:464
void NotifyDataRecv(void)
Notify through the callback (if set) that some data have been received.
Definition: socket.cc:305
Ipv6MulticastFilterMode
Enumeration of the possible filter of a socket.
Definition: socket.h:139
Ptr< NetDevice > m_boundnetdevice
the device this socket is bound to (might be null).
Definition: socket.h:1077
virtual void BindToNetDevice(Ptr< NetDevice > netdevice)
Bind a socket to specific device.
Definition: socket.cc:330
@ NS3_PRIO_BULK
Definition: socket.h:121
@ NS3_PRIO_BESTEFFORT
Definition: socket.h:119
@ NS3_PRIO_INTERACTIVE
Definition: socket.h:123
@ NS3_PRIO_INTERACTIVE_BULK
Definition: socket.h:122
void NotifyErrorClose(void)
Notify through the callback (if set) that the connection has been closed due to an error.
Definition: socket.cc:247
virtual uint8_t GetIpTtl(void) const
Query the value of IP Time to Live field of this socket.
Definition: socket.cc:519
bool m_ipRecvTtl
socket forwards IPv4 TTL tag to L4
Definition: socket.h:1097
virtual int GetSockName(Address &address) const =0
Get socket address.
virtual void Ipv6JoinGroup(Ipv6Address address, Ipv6MulticastFilterMode filterMode, std::vector< Ipv6Address > sourceAddresses)
Joins a IPv6 multicast group.
Definition: socket.cc:562
Callback< void, Ptr< Socket > > m_receivedData
data received callback
Definition: socket.h:1090
virtual uint8_t GetIpv6HopLimit(void) const
Query the value of IP Hop Limit field of this socket.
Definition: socket.cc:544
void SetCloseCallbacks(Callback< void, Ptr< Socket > > normalClose, Callback< void, Ptr< Socket > > errorClose)
Detect socket recv() events such as graceful shutdown or error.
Definition: socket.cc:94
Callback< void, Ptr< Socket >, uint32_t > m_sendCb
packet sent callback
Definition: socket.h:1089
bool m_manualIpv6Tclass
socket has IPv6 Tclass set
Definition: socket.h:1103
Callback< void, Ptr< Socket >, const Address & > m_newConnectionCreated
connection created callback
Definition: socket.h:1087
bool m_manualIpTtl
socket has IPv4 TTL set
Definition: socket.h:1095
void SetRecvCallback(Callback< void, Ptr< Socket > > receivedData)
Notify application when new data is available to be read.
Definition: socket.cc:128
bool IsManualIpv6Tclass(void) const
Checks if the socket has a specific IPv6 Tclass set.
Definition: socket.cc:370
static Ptr< Socket > CreateSocket(Ptr< Node > node, TypeId tid)
This method wraps the creation of sockets that is performed on a given node by a SocketFactory specif...
Definition: socket.cc:71
Callback< void, Ptr< Socket >, uint32_t > m_dataSent
data sent callback
Definition: socket.h:1088
void SetIpv6RecvHopLimit(bool ipv6RecvHopLimit)
Tells a socket to pass information about IPv6 Hop Limit up the stack.
Definition: socket.cc:550
void SetIpv6Tclass(int ipTclass)
Manually set IPv6 Traffic Class field.
Definition: socket.cc:470
void NotifyDataSent(uint32_t size)
Notify through the callback (if set) that some data have been sent.
Definition: socket.cc:285
void SetIpRecvTtl(bool ipv4RecvTtl)
Tells a socket to pass information about IP_TTL up the stack.
Definition: socket.cc:525
void SetIpv6RecvTclass(bool ipv6RecvTclass)
Tells a socket to pass information about IPv6 Traffic Class up the stack.
Definition: socket.cc:500
uint8_t GetIpTos(void) const
Query the value of IP Type of Service of this socket.
Definition: socket.cc:452
virtual void Ipv6LeaveGroup(void)
Leaves IPv6 multicast group this socket is joined to.
Definition: socket.cc:579
virtual int SendTo(Ptr< Packet > p, uint32_t flags, const Address &toAddress)=0
Send data to a specified peer.
virtual enum Socket::SocketType GetSocketType(void) const =0
Callback< bool, Ptr< Socket >, const Address & > m_connectionRequest
connection request callback
Definition: socket.h:1086
Ptr< Packet > Recv(void)
Read a single packet from the socket.
Definition: socket.cc:175
Callback< void, Ptr< Socket > > m_errorClose
connection closed due to errors callback
Definition: socket.h:1085
indicates whether the socket has IP_TOS set.
Definition: socket.h:1263
uint8_t m_ipTos
the TOS carried by the tag
Definition: socket.h:1302
virtual uint32_t GetSerializedSize(void) const
Definition: socket.cc:813
virtual void Serialize(TagBuffer i) const
Definition: socket.cc:819
void SetTos(uint8_t tos)
Set the tag's TOS.
Definition: socket.cc:784
static TypeId GetTypeId(void)
Get the type ID.
Definition: socket.cc:796
virtual void Deserialize(TagBuffer i)
Definition: socket.cc:825
uint8_t GetTos(void) const
Get the tag's TOS.
Definition: socket.cc:790
virtual void Print(std::ostream &os) const
Definition: socket.cc:830
virtual TypeId GetInstanceTypeId(void) const
Get the most derived TypeId for this Object.
Definition: socket.cc:807
This class implements a tag that carries the socket-specific TTL of a packet to the IP layer.
Definition: socket.h:1117
static TypeId GetTypeId(void)
Get the type ID.
Definition: socket.cc:619
virtual void Deserialize(TagBuffer i)
Definition: socket.cc:647
uint8_t GetTtl(void) const
Get the tag's TTL.
Definition: socket.cc:610
void SetTtl(uint8_t ttl)
Set the tag's TTL.
Definition: socket.cc:603
virtual void Print(std::ostream &os) const
Definition: socket.cc:653
virtual uint32_t GetSerializedSize(void) const
Definition: socket.cc:635
uint8_t m_ttl
the ttl carried by the tag
Definition: socket.h:1157
virtual void Serialize(TagBuffer i) const
Definition: socket.cc:641
virtual TypeId GetInstanceTypeId(void) const
Get the most derived TypeId for this Object.
Definition: socket.cc:629
This class implements a tag that carries the socket-specific HOPLIMIT of a packet to the IPv6 layer.
Definition: socket.h:1165
virtual void Deserialize(TagBuffer i)
Definition: socket.cc:704
static TypeId GetTypeId(void)
Get the type ID.
Definition: socket.cc:678
virtual void Serialize(TagBuffer i) const
Definition: socket.cc:699
virtual void Print(std::ostream &os) const
Definition: socket.cc:709
void SetHopLimit(uint8_t hopLimit)
Set the tag's Hop Limit.
Definition: socket.cc:664
uint8_t GetHopLimit(void) const
Get the tag's Hop Limit.
Definition: socket.cc:670
virtual uint32_t GetSerializedSize(void) const
Definition: socket.cc:694
uint8_t m_hopLimit
the Hop Limit carried by the tag
Definition: socket.h:1205
virtual TypeId GetInstanceTypeId(void) const
Get the most derived TypeId for this Object.
Definition: socket.cc:688
indicates whether the socket has IPV6_TCLASS set.
Definition: socket.h:1356
uint8_t GetTclass(void) const
Get the tag's Tclass.
Definition: socket.cc:905
virtual TypeId GetInstanceTypeId(void) const
Get the most derived TypeId for this Object.
Definition: socket.cc:922
virtual uint32_t GetSerializedSize(void) const
Definition: socket.cc:928
virtual void Deserialize(TagBuffer i)
Definition: socket.cc:940
static TypeId GetTypeId(void)
Get the type ID.
Definition: socket.cc:911
uint8_t m_ipv6Tclass
the Tclass carried by the tag
Definition: socket.h:1395
virtual void Serialize(TagBuffer i) const
Definition: socket.cc:934
virtual void Print(std::ostream &os) const
Definition: socket.cc:945
void SetTclass(uint8_t tclass)
Set the tag's Tclass.
Definition: socket.cc:899
indicates whether the socket has a priority set.
Definition: socket.h:1309
uint8_t m_priority
the priority carried by the tag
Definition: socket.h:1348
uint8_t GetPriority(void) const
Get the tag's priority.
Definition: socket.cc:847
virtual void Serialize(TagBuffer i) const
Definition: socket.cc:876
virtual void Deserialize(TagBuffer i)
Definition: socket.cc:882
virtual uint32_t GetSerializedSize(void) const
Definition: socket.cc:870
static TypeId GetTypeId(void)
Get the type ID.
Definition: socket.cc:853
virtual void Print(std::ostream &os) const
Definition: socket.cc:888
void SetPriority(uint8_t priority)
Set the tag's priority.
Definition: socket.cc:841
virtual TypeId GetInstanceTypeId(void) const
Get the most derived TypeId for this Object.
Definition: socket.cc:864
indicates whether packets should be sent out with the DF (Don't Fragment) flag set.
Definition: socket.h:1213
bool IsEnabled(void) const
Checks if the DF (Don't Fragment) flag is set.
Definition: socket.cc:731
virtual void Serialize(TagBuffer i) const
Definition: socket.cc:760
virtual TypeId GetInstanceTypeId(void) const
Get the most derived TypeId for this Object.
Definition: socket.cc:749
void Disable(void)
Disables the DF (Don't Fragment) flag.
Definition: socket.cc:725
virtual void Print(std::ostream &os) const
Definition: socket.cc:772
static TypeId GetTypeId(void)
Get the type ID.
Definition: socket.cc:740
virtual void Deserialize(TagBuffer i)
Definition: socket.cc:766
bool m_dontFragment
DF bit value for outgoing packets.
Definition: socket.h:1255
void Enable(void)
Enables the DF (Don't Fragment) flag.
Definition: socket.cc:719
virtual uint32_t GetSerializedSize(void) const
Definition: socket.cc:754
read and write tag data
Definition: tag-buffer.h:52
TAG_BUFFER_INLINE void WriteU8(uint8_t v)
Definition: tag-buffer.h:172
TAG_BUFFER_INLINE uint8_t ReadU8(void)
Definition: tag-buffer.h:195
tag a set of bytes in a packet
Definition: tag.h:37
a unique identifier for an interface.
Definition: type-id.h:59
TypeId SetParent(TypeId tid)
Set the parent TypeId.
Definition: type-id.cc:922
#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
#define NS_ASSERT_MSG(condition, message)
At runtime, in debugging builds, if this condition is not true, the program prints the message to out...
Definition: assert.h:88
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Definition: log.h:206
#define NS_LOG_FUNCTION_NOARGS()
Output the name of the function.
#define NS_LOG_FUNCTION(parameters)
If log level LOG_FUNCTION is enabled, this macro will output all input parameters separated by ",...
#define NS_LOG_WARN(msg)
Use NS_LOG to output a message of level LOG_WARN.
Definition: log.h:266
#define NS_LOG_INFO(msg)
Use NS_LOG to output a message of level LOG_INFO.
Definition: log.h:282
#define NS_OBJECT_ENSURE_REGISTERED(type)
Register an Object subclass with the TypeId system.
Definition: object-base.h:45
address
Definition: first.py:40
Every class exported by the ns3 library is enclosed in the ns3 namespace.