00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023 #include "ns3/log.h"
00024 #include "ns3/packet.h"
00025 #include "node.h"
00026 #include "socket.h"
00027 #include "socket-factory.h"
00028 #include <limits>
00029
00030 NS_LOG_COMPONENT_DEFINE ("Socket");
00031
00032 namespace ns3 {
00033
00034 Socket::Socket (void)
00035 {
00036 NS_LOG_FUNCTION_NOARGS ();
00037 }
00038
00039 Socket::~Socket ()
00040 {
00041 NS_LOG_FUNCTION_NOARGS ();
00042 }
00043
00044 Ptr<Socket>
00045 Socket::CreateSocket (Ptr<Node> node, TypeId tid)
00046 {
00047 Ptr<Socket> s;
00048 Ptr<SocketFactory> socketFactory = node->GetObject<SocketFactory> (tid);
00049 s = socketFactory->CreateSocket ();
00050 NS_ASSERT (s != 0);
00051 return s;
00052 }
00053
00054 void
00055 Socket::SetConnectCallback (
00056 Callback<void, Ptr<Socket> > connectionSucceeded,
00057 Callback<void, Ptr<Socket> > connectionFailed)
00058 {
00059 NS_LOG_FUNCTION_NOARGS ();
00060 m_connectionSucceeded = connectionSucceeded;
00061 m_connectionFailed = connectionFailed;
00062 }
00063
00064 void
00065 Socket::SetAcceptCallback (
00066 Callback<bool, Ptr<Socket>, const Address &> connectionRequest,
00067 Callback<void, Ptr<Socket>, const Address&> newConnectionCreated)
00068 {
00069 NS_LOG_FUNCTION_NOARGS ();
00070 m_connectionRequest = connectionRequest;
00071 m_newConnectionCreated = newConnectionCreated;
00072 }
00073
00074 void
00075 Socket::SetDataSentCallback (Callback<void, Ptr<Socket>, uint32_t> dataSent)
00076 {
00077 NS_LOG_FUNCTION_NOARGS ();
00078 m_dataSent = dataSent;
00079 }
00080
00081 void
00082 Socket::SetSendCallback (Callback<void, Ptr<Socket>, uint32_t> sendCb)
00083 {
00084 NS_LOG_FUNCTION_NOARGS ();
00085 m_sendCb = sendCb;
00086 }
00087
00088 void
00089 Socket::SetRecvCallback (Callback<void, Ptr<Socket> > receivedData)
00090 {
00091 NS_LOG_FUNCTION_NOARGS ();
00092 m_receivedData = receivedData;
00093 }
00094
00095 int
00096 Socket::Send (Ptr<Packet> p)
00097 {
00098 NS_LOG_FUNCTION_NOARGS ();
00099 return Send (p, 0);
00100 }
00101
00102 int
00103 Socket::Send (const uint8_t* buf, uint32_t size, uint32_t flags)
00104 {
00105 NS_LOG_FUNCTION_NOARGS ();
00106 Ptr<Packet> p;
00107 if (buf)
00108 {
00109 p = Create<Packet> (buf, size);
00110 }
00111 else
00112 {
00113 p = Create<Packet> (size);
00114 }
00115 return Send (p, flags);
00116 }
00117
00118 int
00119 Socket::SendTo (const uint8_t* buf, uint32_t size, uint32_t flags,
00120 const Address &toAddress)
00121 {
00122 NS_LOG_FUNCTION_NOARGS ();
00123 Ptr<Packet> p;
00124 if(buf)
00125 {
00126 p = Create<Packet> (buf, size);
00127 }
00128 else
00129 {
00130 p = Create<Packet> (size);
00131 }
00132 return SendTo (p, flags, toAddress);
00133 }
00134
00135 Ptr<Packet>
00136 Socket::Recv (void)
00137 {
00138 NS_LOG_FUNCTION_NOARGS ();
00139 return Recv (std::numeric_limits<uint32_t>::max(), 0);
00140 }
00141
00142 int
00143 Socket::Recv (uint8_t* buf, uint32_t size, uint32_t flags)
00144 {
00145 NS_LOG_FUNCTION_NOARGS ();
00146 Ptr<Packet> p = Recv (size, flags);
00147 if (p == 0)
00148 {
00149 return 0;
00150 }
00151 memcpy (buf, p->PeekData (), p->GetSize());
00152 return p->GetSize ();
00153 }
00154
00155 Ptr<Packet>
00156 Socket::RecvFrom (Address &fromAddress)
00157 {
00158 NS_LOG_FUNCTION_NOARGS ();
00159 return RecvFrom (std::numeric_limits<uint32_t>::max(), 0, fromAddress);
00160 }
00161
00162 int
00163 Socket::RecvFrom (uint8_t* buf, uint32_t size, uint32_t flags,
00164 Address &fromAddress)
00165 {
00166 NS_LOG_FUNCTION_NOARGS ();
00167 Ptr<Packet> p = RecvFrom (size, flags, fromAddress);
00168 if (p == 0)
00169 {
00170 return 0;
00171 }
00172 memcpy (buf, p->PeekData (), p->GetSize());
00173 return p->GetSize ();
00174 }
00175
00176
00177 void
00178 Socket::NotifyConnectionSucceeded (void)
00179 {
00180 NS_LOG_FUNCTION_NOARGS ();
00181 if (!m_connectionSucceeded.IsNull ())
00182 {
00183 m_connectionSucceeded (this);
00184 }
00185 }
00186
00187 void
00188 Socket::NotifyConnectionFailed (void)
00189 {
00190 NS_LOG_FUNCTION_NOARGS ();
00191 if (!m_connectionFailed.IsNull ())
00192 {
00193 m_connectionFailed (this);
00194 }
00195 }
00196
00197 bool
00198 Socket::NotifyConnectionRequest (const Address &from)
00199 {
00200 NS_LOG_FUNCTION_NOARGS ();
00201 if (!m_connectionRequest.IsNull ())
00202 {
00203 return m_connectionRequest (this, from);
00204 }
00205 else
00206 {
00207
00208
00209
00210
00211 return true;
00212 }
00213 }
00214
00215 void
00216 Socket::NotifyNewConnectionCreated (Ptr<Socket> socket, const Address &from)
00217 {
00218 NS_LOG_FUNCTION_NOARGS ();
00219 if (!m_newConnectionCreated.IsNull ())
00220 {
00221 m_newConnectionCreated (socket, from);
00222 }
00223 }
00224
00225 void
00226 Socket::NotifyDataSent (uint32_t size)
00227 {
00228 NS_LOG_FUNCTION_NOARGS ();
00229 if (!m_dataSent.IsNull ())
00230 {
00231 m_dataSent (this, size);
00232 }
00233 }
00234
00235 void
00236 Socket::NotifySend (uint32_t spaceAvailable)
00237 {
00238 NS_LOG_FUNCTION_NOARGS ();
00239 if (!m_sendCb.IsNull ())
00240 {
00241 m_sendCb (this, spaceAvailable);
00242 }
00243 }
00244
00245 void
00246 Socket::NotifyDataRecv (void)
00247 {
00248 NS_LOG_FUNCTION_NOARGS ();
00249 if (!m_receivedData.IsNull ())
00250 {
00251 m_receivedData (this);
00252 }
00253 }
00254
00255
00256
00257
00258
00259 SocketAddressTag::SocketAddressTag ()
00260 {
00261 }
00262
00263 void
00264 SocketAddressTag::SetAddress (Address addr)
00265 {
00266 m_address = addr;
00267 }
00268
00269 Address
00270 SocketAddressTag::GetAddress (void) const
00271 {
00272 return m_address;
00273 }
00274
00275
00276 TypeId
00277 SocketAddressTag::GetTypeId (void)
00278 {
00279 static TypeId tid = TypeId ("ns3::SocketAddressTag")
00280 .SetParent<Tag> ()
00281 .AddConstructor<SocketAddressTag> ()
00282 ;
00283 return tid;
00284 }
00285 TypeId
00286 SocketAddressTag::GetInstanceTypeId (void) const
00287 {
00288 return GetTypeId ();
00289 }
00290 uint32_t
00291 SocketAddressTag::GetSerializedSize (void) const
00292 {
00293 return m_address.GetSerializedSize ();
00294 }
00295 void
00296 SocketAddressTag::Serialize (TagBuffer i) const
00297 {
00298 m_address.Serialize (i);
00299 }
00300 void
00301 SocketAddressTag::Deserialize (TagBuffer i)
00302 {
00303 m_address.Deserialize (i);
00304 }
00305 void
00306 SocketAddressTag::Print (std::ostream &os) const
00307 {
00308 os << "address=" << m_address;
00309 }
00310
00311 SocketIpTtlTag::SocketIpTtlTag ()
00312 {
00313 }
00314
00315 void
00316 SocketIpTtlTag::SetTtl (uint8_t ttl)
00317 {
00318 m_ttl = ttl;
00319 }
00320
00321 uint8_t
00322 SocketIpTtlTag::GetTtl (void) const
00323 {
00324 return m_ttl;
00325 }
00326
00327
00328 TypeId
00329 SocketIpTtlTag::GetTypeId (void)
00330 {
00331 static TypeId tid = TypeId ("ns3::SocketIpTtlTag")
00332 .SetParent<Tag> ()
00333 .AddConstructor<SocketIpTtlTag> ()
00334 ;
00335 return tid;
00336 }
00337 TypeId
00338 SocketIpTtlTag::GetInstanceTypeId (void) const
00339 {
00340 return GetTypeId ();
00341 }
00342
00343 uint32_t
00344 SocketIpTtlTag::GetSerializedSize (void) const
00345 {
00346 return 1;
00347 }
00348 void
00349 SocketIpTtlTag::Serialize (TagBuffer i) const
00350 {
00351 i.WriteU8 (m_ttl);
00352 }
00353 void
00354 SocketIpTtlTag::Deserialize (TagBuffer i)
00355 {
00356 m_ttl = i.ReadU8 ();
00357 }
00358 void
00359 SocketIpTtlTag::Print (std::ostream &os) const
00360 {
00361 os << "Ttl=" << (uint32_t) m_ttl;
00362 }
00363
00364
00365 SocketSetDontFragmentTag::SocketSetDontFragmentTag ()
00366 {}
00367 void
00368 SocketSetDontFragmentTag::Enable (void)
00369 {
00370 m_dontFragment = true;
00371 }
00372 void
00373 SocketSetDontFragmentTag::Disable (void)
00374 {
00375 m_dontFragment = false;
00376 }
00377 bool
00378 SocketSetDontFragmentTag::IsEnabled (void) const
00379 {
00380 return m_dontFragment;
00381 }
00382
00383 TypeId
00384 SocketSetDontFragmentTag::GetTypeId (void)
00385 {
00386 static TypeId tid = TypeId ("ns3::SocketSetDontFragmentTag")
00387 .SetParent<Tag> ()
00388 .AddConstructor<SocketSetDontFragmentTag> ()
00389 ;
00390 return tid;
00391 }
00392 TypeId
00393 SocketSetDontFragmentTag::GetInstanceTypeId (void) const
00394 {
00395 return GetTypeId ();
00396 }
00397 uint32_t
00398 SocketSetDontFragmentTag::GetSerializedSize (void) const
00399 {
00400 return 1;
00401 }
00402 void
00403 SocketSetDontFragmentTag::Serialize (TagBuffer i) const
00404 {
00405 i.WriteU8 (m_dontFragment?1:0);
00406 }
00407 void
00408 SocketSetDontFragmentTag::Deserialize (TagBuffer i)
00409 {
00410 m_dontFragment = (i.ReadU8 () == 1)?true:false;
00411 }
00412 void
00413 SocketSetDontFragmentTag::Print (std::ostream &os) const
00414 {
00415 os << (m_dontFragment?"true":"false");
00416 }
00417
00418 }