Mercurial Mercurial > ns-3.24 / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
src/node/packet-socket.cc
changeset 4502 07d34c0d8d18
parent 3778 78c4c41557f3
child 4698 60cd412fa3dd
equal deleted inserted replaced
4488:1faf35545dfd 4502:07d34c0d8d18 
    50   return tid;
 
    50   return tid;
 
    51 }
 
    51 }
 
    52 
    52 
    53 PacketSocket::PacketSocket () : m_rxAvailable (0)
 
    53 PacketSocket::PacketSocket () : m_rxAvailable (0)
 
    54 {
 
    54 {
 
    55   NS_LOG_FUNCTION_NOARGS ();
 
    55   NS_LOG_FUNCTION (this);
 
    56   m_state = STATE_OPEN;
 
    56   m_state = STATE_OPEN;
 
    57   m_shutdownSend = false;
 
    57   m_shutdownSend = false;
 
    58   m_shutdownRecv = false;
 
    58   m_shutdownRecv = false;
 
    59   m_errno = ERROR_NOTERROR;
 
    59   m_errno = ERROR_NOTERROR;
 
    60   m_isSingleDevice = false;
 
    60   m_isSingleDevice = false;
 
    62 }
 
    62 }
 
    63 
    63 
    64 void 
    64 void 
    65 PacketSocket::SetNode (Ptr<Node> node)
 
    65 PacketSocket::SetNode (Ptr<Node> node)
 
    66 {
 
    66 {
 
    67   NS_LOG_FUNCTION_NOARGS ();
 
    67   NS_LOG_FUNCTION (this << node);
 
    68   m_node = node;
 
    68   m_node = node;
 
    69 }
 
    69 }
 
    70 
    70 
    71 PacketSocket::~PacketSocket ()
 
    71 PacketSocket::~PacketSocket ()
 
    72 {
 
    72 {
 
    73   NS_LOG_FUNCTION_NOARGS ();
 
    73   NS_LOG_FUNCTION (this);
 
    74 }
 
    74 }
 
    75 
    75 
    76 void 
    76 void 
    77 PacketSocket::DoDispose (void)
 
    77 PacketSocket::DoDispose (void)
 
    78 {
 
    78 {
 
    79   NS_LOG_FUNCTION_NOARGS ();
 
    79   NS_LOG_FUNCTION (this);
 
    80   m_device = 0;
 
    80   m_device = 0;
 
    81 }
 
    81 }
 
    82 
    82 
    83 enum Socket::SocketErrno
 
    83 enum Socket::SocketErrno
 
    84 PacketSocket::GetErrno (void) const
 
    84 PacketSocket::GetErrno (void) const
 
    85 {
 
    85 {
 
    86   NS_LOG_FUNCTION_NOARGS ();
 
    86   NS_LOG_FUNCTION (this);
 
    87   return m_errno;
 
    87   return m_errno;
 
    88 }
 
    88 }
 
    89 
    89 
    90 Ptr<Node>
 
    90 Ptr<Node>
 
    91 PacketSocket::GetNode (void) const
 
    91 PacketSocket::GetNode (void) const
 
    92 {
 
    92 {
 
    93   NS_LOG_FUNCTION_NOARGS ();
 
    93   NS_LOG_FUNCTION (this);
 
    94   return m_node;
 
    94   return m_node;
 
    95 }
 
    95 }
 
    96 
    96 
    97 int
 
    97 int
 
    98 PacketSocket::Bind (void)
 
    98 PacketSocket::Bind (void)
 
    99 {
 
    99 {
 
   100   NS_LOG_FUNCTION_NOARGS ();
 
   100   NS_LOG_FUNCTION (this);
 
   101   PacketSocketAddress address;
 
   101   PacketSocketAddress address;
 
   102   address.SetProtocol (0);
 
   102   address.SetProtocol (0);
 
   103   address.SetAllDevices ();
 
   103   address.SetAllDevices ();
 
   104   return DoBind (address);
 
   104   return DoBind (address);
 
   105 }
 
   105 }
 
   106 
   106 
   107 int
 
   107 int
 
   108 PacketSocket::Bind (const Address &address)
 
   108 PacketSocket::Bind (const Address &address)
 
   109 { 
   109 { 
   110   NS_LOG_FUNCTION_NOARGS ();
 
   110   NS_LOG_FUNCTION (this << address);
 
   111   if (!PacketSocketAddress::IsMatchingType (address))
 
   111   if (!PacketSocketAddress::IsMatchingType (address))
 
   112     {
 
   112     {
 
   113       m_errno = ERROR_INVAL;
 
   113       m_errno = ERROR_INVAL;
 
   114       return -1;
 
   114       return -1;
 
   115     }
 
   115     }
 
   118 }
 
   118 }
 
   119 
   119 
   120 int
 
   120 int
 
   121 PacketSocket::DoBind (const PacketSocketAddress &address)
 
   121 PacketSocket::DoBind (const PacketSocketAddress &address)
 
   122 {
 
   122 {
 
   123   NS_LOG_FUNCTION_NOARGS ();
 
   123   NS_LOG_FUNCTION (this << address);
 
   124   if (m_state == STATE_BOUND ||
 
   124   if (m_state == STATE_BOUND ||
 
   125       m_state == STATE_CONNECTED)
 
   125       m_state == STATE_CONNECTED)
 
   126     {
 
   126     {
 
   127       m_errno = ERROR_INVAL;
 
   127       m_errno = ERROR_INVAL;
 
   128       return -1;
 
   128       return -1;
 
   151 }
 
   151 }
 
   152 
   152 
   153 int
 
   153 int
 
   154 PacketSocket::ShutdownSend (void)
 
   154 PacketSocket::ShutdownSend (void)
 
   155 {
 
   155 {
 
   156   NS_LOG_FUNCTION_NOARGS ();
 
   156   NS_LOG_FUNCTION (this);
 
   157   if (m_state == STATE_CLOSED)
 
   157   if (m_state == STATE_CLOSED)
 
   158     {
 
   158     {
 
   159       m_errno = ERROR_BADF;
 
   159       m_errno = ERROR_BADF;
 
   160       return -1;
 
   160       return -1;
 
   161     }
 
   161     }
 
   164 }
 
   164 }
 
   165 
   165 
   166 int
 
   166 int
 
   167 PacketSocket::ShutdownRecv (void)
 
   167 PacketSocket::ShutdownRecv (void)
 
   168 {
 
   168 {
 
   169   NS_LOG_FUNCTION_NOARGS ();
 
   169   NS_LOG_FUNCTION (this);
 
   170   if (m_state == STATE_CLOSED)
 
   170   if (m_state == STATE_CLOSED)
 
   171     {
 
   171     {
 
   172       m_errno = ERROR_BADF;
 
   172       m_errno = ERROR_BADF;
 
   173       return -1;
 
   173       return -1;
 
   174     }
 
   174     }
 
   177 }
 
   177 }
 
   178 
   178 
   179 int
 
   179 int
 
   180 PacketSocket::Close(void)
 
   180 PacketSocket::Close(void)
 
   181 {
 
   181 {
 
   182   NS_LOG_FUNCTION_NOARGS ();
 
   182   NS_LOG_FUNCTION (this);
 
   183   if (m_state == STATE_CLOSED)
 
   183   if (m_state == STATE_CLOSED)
 
   184     {
 
   184     {
 
   185       m_errno = ERROR_BADF;
 
   185       m_errno = ERROR_BADF;
 
   186       return -1;
 
   186       return -1;
 
   187     }
 
   187     }
 
   190 }
 
   190 }
 
   191 
   191 
   192 int
 
   192 int
 
   193 PacketSocket::Connect(const Address &ad)
 
   193 PacketSocket::Connect(const Address &ad)
 
   194 {
 
   194 {
 
   195   NS_LOG_FUNCTION_NOARGS ();
 
   195   NS_LOG_FUNCTION (this << ad);
 
   196   PacketSocketAddress address;
 
   196   PacketSocketAddress address;
 
   197   if (m_state == STATE_CLOSED)
 
   197   if (m_state == STATE_CLOSED)
 
   198     {
 
   198     {
 
   199       m_errno = ERROR_BADF;
 
   199       m_errno = ERROR_BADF;
 
   200       goto error;
 
   200       goto error;
 
   231 }
 
   231 }
 
   232 
   232 
   233 int
 
   233 int
 
   234 PacketSocket::Send (Ptr<Packet> p, uint32_t flags)
 
   234 PacketSocket::Send (Ptr<Packet> p, uint32_t flags)
 
   235 {
 
   235 {
 
   236   NS_LOG_FUNCTION_NOARGS ();
 
   236   NS_LOG_FUNCTION (this << p << flags);
 
   237   if (m_state == STATE_OPEN ||
 
   237   if (m_state == STATE_OPEN ||
 
   238       m_state == STATE_BOUND)
 
   238       m_state == STATE_BOUND)
 
   239     {
 
   239     {
 
   240       m_errno = ERROR_NOTCONN;
 
   240       m_errno = ERROR_NOTCONN;
 
   241       return -1;
 
   241       return -1;
 
   276 }
 
   276 }
 
   277 
   277 
   278 int
 
   278 int
 
   279 PacketSocket::SendTo (Ptr<Packet> p, uint32_t flags, const Address &address)
 
   279 PacketSocket::SendTo (Ptr<Packet> p, uint32_t flags, const Address &address)
 
   280 {
 
   280 {
 
   281   NS_LOG_FUNCTION_NOARGS ();
 
   281   NS_LOG_FUNCTION (this << p << flags << address);
 
   282   PacketSocketAddress ad;
 
   282   PacketSocketAddress ad;
 
   283   if (m_state == STATE_CLOSED)
 
   283   if (m_state == STATE_CLOSED)
 
   284     {
 
   284     {
 
   285       NS_LOG_LOGIC ("ERROR_BADF");
 
   285       NS_LOG_LOGIC ("ERROR_BADF");
 
   286       m_errno = ERROR_BADF;
 
   286       m_errno = ERROR_BADF;
 
   349 void 
   349 void 
   350 PacketSocket::ForwardUp (Ptr<NetDevice> device, Ptr<const Packet> packet, 
   350 PacketSocket::ForwardUp (Ptr<NetDevice> device, Ptr<const Packet> packet, 
   351                          uint16_t protocol, const Address &from,
 
   351                          uint16_t protocol, const Address &from,
 
   352                          const Address &to, NetDevice::PacketType packetType)
 
   352                          const Address &to, NetDevice::PacketType packetType)
 
   353 {
 
   353 {
 
   354   NS_LOG_FUNCTION_NOARGS ();
 
   354   NS_LOG_FUNCTION (this << device << packet << protocol << from << to << packetType);
 
   355   if (m_shutdownRecv)
 
   355   if (m_shutdownRecv)
 
   356     {
 
   356     {
 
   357       return;
 
   357       return;
 
   358     }
 
   358     }
 
   359 
   359 
   363   address.SetSingleDevice (device->GetIfIndex ());
 
   363   address.SetSingleDevice (device->GetIfIndex ());
 
   364   address.SetProtocol (protocol);
 
   364   address.SetProtocol (protocol);
 
   365 
   365 
   366   if ((m_rxAvailable + packet->GetSize ()) <= m_rcvBufSize)
 
   366   if ((m_rxAvailable + packet->GetSize ()) <= m_rcvBufSize)
 
   367     {
 
   367     {
 
       
   368       Ptr<Packet> copy = packet->Copy ();
 
   368       SocketAddressTag tag;
 
   369       SocketAddressTag tag;
 
   369       tag.SetAddress (address);
 
   370       tag.SetAddress (address);
 
   370       packet->AddTag (tag);
 
   371       copy->AddPacketTag (tag);
 
   371       m_deliveryQueue.push (packet->Copy ());
 
   372       m_deliveryQueue.push (copy);
 
   372       m_rxAvailable += packet->GetSize ();
 
   373       m_rxAvailable += packet->GetSize ();
 
   373       NS_LOG_LOGIC ("UID is " << packet->GetUid() << " PacketSocket " << this);
 
   374       NS_LOG_LOGIC ("UID is " << packet->GetUid() << " PacketSocket " << this);
 
   374       NotifyDataRecv ();
 
   375       NotifyDataRecv ();
 
   375     }
 
   376     }
 
   376   else
 
   377   else
 
   386 }
 
   387 }
 
   387 
   388 
   388 uint32_t
 
   389 uint32_t
 
   389 PacketSocket::GetRxAvailable (void) const
 
   390 PacketSocket::GetRxAvailable (void) const
 
   390 {
 
   391 {
 
   391   NS_LOG_FUNCTION_NOARGS ();
 
   392   NS_LOG_FUNCTION (this);
 
   392   // We separately maintain this state to avoid walking the queue 
   393   // We separately maintain this state to avoid walking the queue 
   393   // every time this might be called
 
   394   // every time this might be called
 
   394   return m_rxAvailable;
 
   395   return m_rxAvailable;
 
   395 }
 
   396 }
 
   396 
   397 
   397 Ptr<Packet> 
   398 Ptr<Packet> 
   398 PacketSocket::Recv (uint32_t maxSize, uint32_t flags)
 
   399 PacketSocket::Recv (uint32_t maxSize, uint32_t flags)
 
   399 {
 
   400 {
 
   400   NS_LOG_FUNCTION_NOARGS ();
 
   401   NS_LOG_FUNCTION (this << maxSize << flags);
 
   401   if (m_deliveryQueue.empty() )
 
   402   if (m_deliveryQueue.empty() )
 
   402     {
 
   403     {
 
   403       return 0;
 
   404       return 0;
 
   404     }
 
   405     }
 
   405   Ptr<Packet> p = m_deliveryQueue.front ();
 
   406   Ptr<Packet> p = m_deliveryQueue.front ();
 
   416 }
 
   417 }
 
   417 
   418 
   418 Ptr<Packet>
 
   419 Ptr<Packet>
 
   419 PacketSocket::RecvFrom (uint32_t maxSize, uint32_t flags, Address &fromAddress)
 
   420 PacketSocket::RecvFrom (uint32_t maxSize, uint32_t flags, Address &fromAddress)
 
   420 {
 
   421 {
 
   421   NS_LOG_FUNCTION_NOARGS ();
 
   422   NS_LOG_FUNCTION (this << maxSize << flags << fromAddress);
 
   422   Ptr<Packet> packet = Recv (maxSize, flags);
 
   423   Ptr<Packet> packet = Recv (maxSize, flags);
 
   423   if (packet != 0)
 
   424   if (packet != 0)
 
   424     {
 
   425     {
 
   425       SocketAddressTag tag;
 
   426       SocketAddressTag tag;
 
   426       bool found;
 
   427       bool found;
 
   427       found = packet->FindFirstMatchingTag (tag);
 
   428       found = packet->PeekPacketTag (tag);
 
   428       NS_ASSERT (found);
 
   429       NS_ASSERT (found);
 
   429       fromAddress = tag.GetAddress ();
 
   430       fromAddress = tag.GetAddress ();
 
   430     }
 
   431     }
 
   431   return packet;
 
   432   return packet;
 
   432 }
 
   433 }
 
   433 
   434 
   434 int
 
   435 int
 
   435 PacketSocket::GetSockName (Address &address) const
 
   436 PacketSocket::GetSockName (Address &address) const
 
   436 {
 
   437 {
 
   437   NS_LOG_FUNCTION_NOARGS ();
 
   438   NS_LOG_FUNCTION (this << address);
 
   438   PacketSocketAddress ad = PacketSocketAddress::ConvertFrom(address);
 
   439   PacketSocketAddress ad = PacketSocketAddress::ConvertFrom(address);
 
   439   
   440   
   440   ad.SetProtocol (m_protocol);
 
   441   ad.SetProtocol (m_protocol);
 
   441   if (m_isSingleDevice)
 
   442   if (m_isSingleDevice)
 
   442     {
 
   443     {
ns-3.24