00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022 #include "packet-socket.h"
00023 #include "packet-socket-address.h"
00024 #include "ns3/log.h"
00025 #include "ns3/node.h"
00026 #include "ns3/packet.h"
00027 #include "ns3/uinteger.h"
00028 #include "ns3/trace-source-accessor.h"
00029
00030 #include <algorithm>
00031
00032 NS_LOG_COMPONENT_DEFINE ("PacketSocket");
00033
00034 namespace ns3 {
00035
00036 TypeId
00037 PacketSocket::GetTypeId (void)
00038 {
00039 static TypeId tid = TypeId ("ns3::PacketSocket")
00040 .SetParent<Socket> ()
00041 .AddConstructor<PacketSocket> ()
00042 .AddTraceSource ("Drop", "Drop packet due to receive buffer overflow",
00043 MakeTraceSourceAccessor (&PacketSocket::m_dropTrace))
00044 .AddAttribute ("RcvBufSize",
00045 "PacketSocket maximum receive buffer size (bytes)",
00046 UintegerValue (0xffffffffl),
00047 MakeUintegerAccessor (&PacketSocket::m_rcvBufSize),
00048 MakeUintegerChecker<uint32_t> ())
00049 ;
00050 return tid;
00051 }
00052
00053 PacketSocket::PacketSocket () : m_rxAvailable (0)
00054 {
00055 NS_LOG_FUNCTION_NOARGS ();
00056 m_state = STATE_OPEN;
00057 m_shutdownSend = false;
00058 m_shutdownRecv = false;
00059 m_errno = ERROR_NOTERROR;
00060 m_isSingleDevice = false;
00061 m_device = 0;
00062 }
00063
00064 void
00065 PacketSocket::SetNode (Ptr<Node> node)
00066 {
00067 NS_LOG_FUNCTION_NOARGS ();
00068 m_node = node;
00069 }
00070
00071 PacketSocket::~PacketSocket ()
00072 {
00073 NS_LOG_FUNCTION_NOARGS ();
00074 }
00075
00076 void
00077 PacketSocket::DoDispose (void)
00078 {
00079 NS_LOG_FUNCTION_NOARGS ();
00080 m_device = 0;
00081 }
00082
00083 enum Socket::SocketErrno
00084 PacketSocket::GetErrno (void) const
00085 {
00086 NS_LOG_FUNCTION_NOARGS ();
00087 return m_errno;
00088 }
00089
00090 Ptr<Node>
00091 PacketSocket::GetNode (void) const
00092 {
00093 NS_LOG_FUNCTION_NOARGS ();
00094 return m_node;
00095 }
00096
00097 int
00098 PacketSocket::Bind (void)
00099 {
00100 NS_LOG_FUNCTION_NOARGS ();
00101 PacketSocketAddress address;
00102 address.SetProtocol (0);
00103 address.SetAllDevices ();
00104 return DoBind (address);
00105 }
00106
00107 int
00108 PacketSocket::Bind (const Address &address)
00109 {
00110 NS_LOG_FUNCTION_NOARGS ();
00111 if (!PacketSocketAddress::IsMatchingType (address))
00112 {
00113 m_errno = ERROR_INVAL;
00114 return -1;
00115 }
00116 PacketSocketAddress ad = PacketSocketAddress::ConvertFrom (address);
00117 return DoBind (ad);
00118 }
00119
00120 int
00121 PacketSocket::DoBind (const PacketSocketAddress &address)
00122 {
00123 NS_LOG_FUNCTION_NOARGS ();
00124 if (m_state == STATE_BOUND ||
00125 m_state == STATE_CONNECTED)
00126 {
00127 m_errno = ERROR_INVAL;
00128 return -1;
00129 }
00130 if (m_state == STATE_CLOSED)
00131 {
00132 m_errno = ERROR_BADF;
00133 return -1;
00134 }
00135 Ptr<NetDevice> dev ;
00136 if (address.IsSingleDevice ())
00137 {
00138 dev = m_node->GetDevice (address.GetSingleDevice ());
00139 }
00140 else
00141 {
00142 dev = 0;
00143 }
00144 m_node->RegisterProtocolHandler (MakeCallback (&PacketSocket::ForwardUp, this),
00145 address.GetProtocol (), dev);
00146 m_state = STATE_BOUND;
00147 m_protocol = address.GetProtocol ();
00148 m_isSingleDevice = address.IsSingleDevice ();
00149 m_device = address.GetSingleDevice ();
00150 return 0;
00151 }
00152
00153 int
00154 PacketSocket::ShutdownSend (void)
00155 {
00156 NS_LOG_FUNCTION_NOARGS ();
00157 if (m_state == STATE_CLOSED)
00158 {
00159 m_errno = ERROR_BADF;
00160 return -1;
00161 }
00162 m_shutdownSend = true;
00163 return 0;
00164 }
00165
00166 int
00167 PacketSocket::ShutdownRecv (void)
00168 {
00169 NS_LOG_FUNCTION_NOARGS ();
00170 if (m_state == STATE_CLOSED)
00171 {
00172 m_errno = ERROR_BADF;
00173 return -1;
00174 }
00175 m_shutdownRecv = false;
00176 return 0;
00177 }
00178
00179 int
00180 PacketSocket::Close(void)
00181 {
00182 NS_LOG_FUNCTION_NOARGS ();
00183 if (m_state == STATE_CLOSED)
00184 {
00185 m_errno = ERROR_BADF;
00186 return -1;
00187 }
00188 m_state = STATE_CLOSED;
00189 return 0;
00190 }
00191
00192 int
00193 PacketSocket::Connect(const Address &ad)
00194 {
00195 NS_LOG_FUNCTION_NOARGS ();
00196 PacketSocketAddress address;
00197 if (m_state == STATE_CLOSED)
00198 {
00199 m_errno = ERROR_BADF;
00200 goto error;
00201 }
00202 if (m_state == STATE_OPEN)
00203 {
00204
00205 m_errno = ERROR_INVAL;
00206 goto error;
00207 }
00208 if (m_state == STATE_CONNECTED)
00209 {
00210 m_errno = ERROR_ISCONN;
00211 goto error;
00212 }
00213 if (!PacketSocketAddress::IsMatchingType (ad))
00214 {
00215 m_errno = ERROR_AFNOSUPPORT;
00216 goto error;
00217 }
00218 m_destAddr = ad;
00219 m_state = STATE_CONNECTED;
00220 NotifyConnectionSucceeded ();
00221 return 0;
00222 error:
00223 NotifyConnectionFailed ();
00224 return -1;
00225 }
00226 int
00227 PacketSocket::Listen(void)
00228 {
00229 m_errno = Socket::ERROR_OPNOTSUPP;
00230 return -1;
00231 }
00232
00233 int
00234 PacketSocket::Send (Ptr<Packet> p, uint32_t flags)
00235 {
00236 NS_LOG_FUNCTION_NOARGS ();
00237 if (m_state == STATE_OPEN ||
00238 m_state == STATE_BOUND)
00239 {
00240 m_errno = ERROR_NOTCONN;
00241 return -1;
00242 }
00243 return SendTo (p, flags, m_destAddr);
00244 }
00245
00246 uint32_t
00247 PacketSocket::GetMinMtu (PacketSocketAddress ad) const
00248 {
00249 if (ad.IsSingleDevice ())
00250 {
00251 Ptr<NetDevice> device = m_node->GetDevice (ad.GetSingleDevice ());
00252 return device->GetMtu ();
00253 }
00254 else
00255 {
00256 uint32_t minMtu = 0xffff;
00257 for (uint32_t i = 0; i < m_node->GetNDevices (); i++)
00258 {
00259 Ptr<NetDevice> device = m_node->GetDevice (i);
00260 minMtu = std::min (minMtu, (uint32_t)device->GetMtu ());
00261 }
00262 return minMtu;
00263 }
00264 }
00265
00266 uint32_t
00267 PacketSocket::GetTxAvailable (void) const
00268 {
00269 if (m_state == STATE_CONNECTED)
00270 {
00271 PacketSocketAddress ad = PacketSocketAddress::ConvertFrom (m_destAddr);
00272 return GetMinMtu (ad);
00273 }
00274
00275 return 0xffff;
00276 }
00277
00278 int
00279 PacketSocket::SendTo (Ptr<Packet> p, uint32_t flags, const Address &address)
00280 {
00281 NS_LOG_FUNCTION_NOARGS ();
00282 PacketSocketAddress ad;
00283 if (m_state == STATE_CLOSED)
00284 {
00285 NS_LOG_LOGIC ("ERROR_BADF");
00286 m_errno = ERROR_BADF;
00287 return -1;
00288 }
00289 if (m_shutdownSend)
00290 {
00291 NS_LOG_LOGIC ("ERROR_SHUTDOWN");
00292 m_errno = ERROR_SHUTDOWN;
00293 return -1;
00294 }
00295 if (!PacketSocketAddress::IsMatchingType (address))
00296 {
00297 NS_LOG_LOGIC ("ERROR_AFNOSUPPORT");
00298 m_errno = ERROR_AFNOSUPPORT;
00299 return -1;
00300 }
00301 ad = PacketSocketAddress::ConvertFrom (address);
00302 if (p->GetSize () > GetMinMtu (ad))
00303 {
00304 m_errno = ERROR_MSGSIZE;
00305 return -1;
00306 }
00307
00308 bool error = false;
00309 Address dest = ad.GetPhysicalAddress ();
00310 if (ad.IsSingleDevice ())
00311 {
00312 Ptr<NetDevice> device = m_node->GetDevice (ad.GetSingleDevice ());
00313 if (!device->Send (p, dest, ad.GetProtocol ()))
00314 {
00315 NS_LOG_LOGIC ("error: NetDevice::Send error");
00316 error = true;
00317 }
00318 }
00319 else
00320 {
00321 for (uint32_t i = 0; i < m_node->GetNDevices (); i++)
00322 {
00323 Ptr<NetDevice> device = m_node->GetDevice (i);
00324 if (!device->Send (p, dest, ad.GetProtocol ()))
00325 {
00326 NS_LOG_LOGIC ("error: NetDevice::Send error");
00327 error = true;
00328 }
00329 }
00330 }
00331 if (!error)
00332 {
00333 NotifyDataSent (p->GetSize ());
00334 NotifySend (GetTxAvailable ());
00335 }
00336
00337 if (error)
00338 {
00339 NS_LOG_LOGIC ("ERROR_INVAL 2");
00340 m_errno = ERROR_INVAL;
00341 return -1;
00342 }
00343 else
00344 {
00345 return 0;
00346 }
00347 }
00348
00349 void
00350 PacketSocket::ForwardUp (Ptr<NetDevice> device, Ptr<const Packet> packet,
00351 uint16_t protocol, const Address &from,
00352 const Address &to, NetDevice::PacketType packetType)
00353 {
00354 NS_LOG_FUNCTION_NOARGS ();
00355 if (m_shutdownRecv)
00356 {
00357 return;
00358 }
00359
00360
00361 PacketSocketAddress address;
00362 address.SetPhysicalAddress (from);
00363 address.SetSingleDevice (device->GetIfIndex ());
00364 address.SetProtocol (protocol);
00365
00366 if ((m_rxAvailable + packet->GetSize ()) <= m_rcvBufSize)
00367 {
00368 SocketAddressTag tag;
00369 tag.SetAddress (address);
00370 packet->AddTag (tag);
00371 m_deliveryQueue.push (packet->Copy ());
00372 m_rxAvailable += packet->GetSize ();
00373 NS_LOG_LOGIC ("UID is " << packet->GetUid() << " PacketSocket " << this);
00374 NotifyDataRecv ();
00375 }
00376 else
00377 {
00378
00379
00380
00381
00382
00383 NS_LOG_WARN ("No receive buffer space available. Drop.");
00384 m_dropTrace (packet);
00385 }
00386 }
00387
00388 uint32_t
00389 PacketSocket::GetRxAvailable (void) const
00390 {
00391 NS_LOG_FUNCTION_NOARGS ();
00392
00393
00394 return m_rxAvailable;
00395 }
00396
00397 Ptr<Packet>
00398 PacketSocket::Recv (uint32_t maxSize, uint32_t flags)
00399 {
00400 NS_LOG_FUNCTION_NOARGS ();
00401 if (m_deliveryQueue.empty() )
00402 {
00403 return 0;
00404 }
00405 Ptr<Packet> p = m_deliveryQueue.front ();
00406 if (p->GetSize () <= maxSize)
00407 {
00408 m_deliveryQueue.pop ();
00409 m_rxAvailable -= p->GetSize ();
00410 }
00411 else
00412 {
00413 p = 0;
00414 }
00415 return p;
00416 }
00417
00418 Ptr<Packet>
00419 PacketSocket::RecvFrom (uint32_t maxSize, uint32_t flags, Address &fromAddress)
00420 {
00421 NS_LOG_FUNCTION_NOARGS ();
00422 Ptr<Packet> packet = Recv (maxSize, flags);
00423 if (packet != 0)
00424 {
00425 SocketAddressTag tag;
00426 bool found;
00427 found = packet->FindFirstMatchingTag (tag);
00428 NS_ASSERT (found);
00429 fromAddress = tag.GetAddress ();
00430 }
00431 return packet;
00432 }
00433
00434 int
00435 PacketSocket::GetSockName (Address &address) const
00436 {
00437 NS_LOG_FUNCTION_NOARGS ();
00438 PacketSocketAddress ad = PacketSocketAddress::ConvertFrom(address);
00439
00440 ad.SetProtocol (m_protocol);
00441 if (m_isSingleDevice)
00442 {
00443 Ptr<NetDevice> device = m_node->GetDevice (ad.GetSingleDevice ());
00444 ad.SetPhysicalAddress(device->GetAddress());
00445 ad.SetSingleDevice (m_device);
00446 }
00447 else
00448 {
00449 ad.SetPhysicalAddress(Address());
00450 ad.SetAllDevices ();
00451 }
00452 address = ad;
00453
00454 return 0;
00455 }
00456
00457 }