Attachment #159 for bug #213

View | Details | Raw Unified | Return to bug 213
Collapse All | Expand All

(-)ns-3-dev/examples/tcp-large-transfer.cc (-1 / +1 lines)

Lines 204-210	Link Here

204

      char m = toascii (97 + i % 26);

204

      char m = toascii (97 + i % 26);

205

      data[i] = m;

205

      data[i] = m;

206

207

    uint32_t amountSent = localSocket->Send (data, curSize);

207

    uint32_t amountSent = localSocket->Send (data, curSize, 0);

208

    if(amountSent < curSize)

208

    if(amountSent < curSize)

209

210

        std::cout << "Socket blocking, returning" << std::endl;

210

        std::cout << "Socket blocking, returning" << std::endl;

(-)ns-3-dev/src/applications/packet-sink/packet-sink.cc (-1 / +1 lines)

Lines 105-111	Link Here

105

  Ptr<Packet> packet;

105

  Ptr<Packet> packet;

106

  while (packet = socket->Recv ())

106

  while (packet = socket->Recv ())

107

108

      SocketRxAddressTag tag;

108

      SocketAddressTag tag;

109

      bool found;

109

      bool found;

110

      found = packet->FindFirstMatchingTag (tag);

110

      found = packet->FindFirstMatchingTag (tag);

111

      NS_ASSERT (found);

111

      NS_ASSERT (found);

(-)ns-3-dev/src/applications/udp-echo/udp-echo-client.cc (-1 / +1 lines)

Lines 156-162	Link Here

156

  Ptr<Packet> packet;

156

  Ptr<Packet> packet;

157

  while (packet = socket->Recv ())

157

  while (packet = socket->Recv ())

158

159

      SocketRxAddressTag tag;

159

      SocketAddressTag tag;

160

      bool found;

160

      bool found;

161

      found  = packet->FindFirstMatchingTag (tag);

161

      found  = packet->FindFirstMatchingTag (tag);

162

      NS_ASSERT (found);

162

      NS_ASSERT (found);

(-)ns-3-dev/src/applications/udp-echo/udp-echo-server.cc (-2 / +2 lines)

Lines 97-103	Link Here

  Ptr<Packet> packet;

  Ptr<Packet> packet;

  while (packet = socket->Recv ())

  while (packet = socket->Recv ())

100

      SocketRxAddressTag tag;

100

      SocketAddressTag tag;

101

      bool found;

101

      bool found;

102

      found = packet->FindFirstMatchingTag (tag);

102

      found = packet->FindFirstMatchingTag (tag);

103

      NS_ASSERT (found);

103

      NS_ASSERT (found);

Lines 110-116	Link Here

110

            address.GetIpv4());

110

            address.GetIpv4());

111

112

          NS_LOG_LOGIC ("Echoing packet");

112

          NS_LOG_LOGIC ("Echoing packet");

113

          socket->SendTo (packet, from);

113

          socket->SendTo (packet, 0, from);

114

115

116

(-)ns-3-dev/src/internet-node/tcp-socket-impl.cc (-10 / +24 lines)

Lines 346-353	Link Here

346

347

  return -1;

347

  return -1;

348

349

350

//p here is just data, no headers

349

int

351

int

350

TcpSocketImpl::Send (const Ptr<Packet> p) //p here is just data, no headers

352

TcpSocketImpl::Send (Ptr<Packet> p, uint32_t flags)

351

353

352

  NS_LOG_FUNCTION (this << p);

354

  NS_LOG_FUNCTION (this << p);

353

  if (m_state == ESTABLISHED || m_state == SYN_SENT || m_state == CLOSE_WAIT)

355

  if (m_state == ESTABLISHED || m_state == SYN_SENT || m_state == CLOSE_WAIT)

Lines 382-392	Link Here

382

384

383

385

384

386

385

int TcpSocketImpl::Send (const uint8_t* buf, uint32_t size)

386

387

  return Send (Create<Packet> (buf, size));

388

389

390

int TcpSocketImpl::DoSendTo (Ptr<Packet> p, const Address &address)

387

int TcpSocketImpl::DoSendTo (Ptr<Packet> p, const Address &address)

391

388

392

  NS_LOG_FUNCTION (this << p << address);

389

  NS_LOG_FUNCTION (this << p << address);

Lines 420-426	Link Here

420

417

421

418

422

int

419

int

423

TcpSocketImpl::SendTo (Ptr<Packet> p, const Address &address)

420

TcpSocketImpl::SendTo (Ptr<Packet> p, uint32_t flags, const Address &address)

424

421

425

  NS_LOG_FUNCTION (this << address << p);

422

  NS_LOG_FUNCTION (this << address << p);

426

  if (!m_connected)

423

  if (!m_connected)

Lines 430-436	Link Here

430

427

431

  else

428

  else

432

429

433

      return Send (p); //drop the address according to BSD manpages

430

      return Send (p, flags); //drop the address according to BSD manpages

434

431

435

432

436

433

Lines 532-537	Link Here

532

  return m_rxAvailable;

529

  return m_rxAvailable;

533

530

534

531

532

Ptr<Packet>

533

TcpSocketImpl::RecvFrom (uint32_t maxSize, uint32_t flags,

534

  Address &fromAddress)

535

536

  NS_LOG_FUNCTION (this << maxSize << flags);

537

  Ptr<Packet> packet = Recv (maxSize, flags);

538

  if (packet != 0)

539

540

      SocketAddressTag tag;

541

      bool found;

542

      found = packet->FindFirstMatchingTag (tag);

543

      NS_ASSERT (found);

544

      fromAddress = tag.GetAddress ();

545

546

  return packet;

547

548

535

void

549

void

536

TcpSocketImpl::ForwardUp (Ptr<Packet> packet, Ipv4Address ipv4, uint16_t port)

550

TcpSocketImpl::ForwardUp (Ptr<Packet> packet, Ipv4Address ipv4, uint16_t port)

537

551

Lines 1048-1054	Link Here

1048

      m_nextRxSequence += s;           // Advance next expected sequence

1062

      m_nextRxSequence += s;           // Advance next expected sequence

1049

      //bytesReceived += s;       // Statistics

1063

      //bytesReceived += s;       // Statistics

1050

      NS_LOG_LOGIC("Case 1, advanced nrxs to " << m_nextRxSequence );

1064

      NS_LOG_LOGIC("Case 1, advanced nrxs to " << m_nextRxSequence );

1051

      SocketRxAddressTag tag;

1065

      SocketAddressTag tag;

1052

      tag.SetAddress (fromAddress);

1066

      tag.SetAddress (fromAddress);

1053

      p->AddTag (tag);

1067

      p->AddTag (tag);

1054

      //buffer this, it'll be read by call to Recv

1068

      //buffer this, it'll be read by call to Recv

Lines 1106-1112	Link Here

1106

          i->second = 0; // relase reference to already buffered

1120

          i->second = 0; // relase reference to already buffered

1107

1121

1108

      // Save for later delivery

1122

      // Save for later delivery

1109

      SocketRxAddressTag tag;

1123

      SocketAddressTag tag;

1110

      tag.SetAddress (fromAddress);

1124

      tag.SetAddress (fromAddress);

1111

      p->AddTag (tag);

1125

      p->AddTag (tag);

1112

      m_bufferedData[tcpHeader.GetSequenceNumber () ] = p;

1126

      m_bufferedData[tcpHeader.GetSequenceNumber () ] = p;




  virtual int ShutdownSend (void);
  virtual int ShutdownRecv (void);
  virtual int Connect(const Address &address);
  virtual int Send (Ptr<Packet> p);
  virtual int Send (const uint8_t* buf, uint32_t size);
  virtual int SendTo(Ptr<Packet> p, const Address &address);
  virtual uint32_t GetTxAvailable (void) const;
  virtual int Listen(uint32_t queueLimit);
  virtual uint32_t GetTxAvailable (void) const;
  virtual int Send (Ptr<Packet> p, uint32_t flags);
  virtual int SendTo(Ptr<Packet> p, uint32_t flags, const Address &toAddress);
  virtual uint32_t GetRxAvailable (void) const;
  virtual Ptr<Packet> Recv (uint32_t maxSize, uint32_t flags);
  virtual Ptr<Packet> RecvFrom (uint32_t maxSize, uint32_t flags,
    Address &fromAddress);

private:
  friend class Tcp;




}

int 
UdpSocketImpl::Send (Ptr<Packet> p, uint32_t flags)
{
  NS_LOG_FUNCTION (this << p << flags);

  if (!m_connected)
    {

int 
UdpSocketImpl::DoSend (Ptr<Packet> p)
{
  NS_LOG_FUNCTION (this << p);
  if (m_endPoint == 0)
    {
      if (Bind () == -1)

}

int 
UdpSocketImpl::SendTo (Ptr<Packet> p, uint32_t flags, const Address &address)
{
  NS_LOG_FUNCTION (this << p << flags << address);
  InetSocketAddress transport = InetSocketAddress::ConvertFrom (address);
  Ipv4Address ipv4 = transport.GetIpv4 ();
  uint16_t port = transport.GetPort ();
  return DoSendTo (p, ipv4, port);
}

uint32_t
UdpSocketImpl::GetRxAvailable (void) const
{
  NS_LOG_FUNCTION_NOARGS ();
  // We separately maintain this state to avoid walking the queue 
  // every time this might be called
  return m_rxAvailable;
}

Ptr<Packet>
UdpSocketImpl::Recv (uint32_t maxSize, uint32_t flags)
{
  NS_LOG_FUNCTION (this << maxSize << flags);
  if (m_deliveryQueue.empty() )
    {
      return 0;

  return p;
}

Ptr<Packet>
UdpSocketImpl::RecvFrom (uint32_t maxSize, uint32_t flags, 
  Address &fromAddress)
{
  NS_LOG_FUNCTION (this << maxSize << flags);
  Ptr<Packet> packet = Recv (maxSize, flags);
  if (packet != 0)
    {
      SocketAddressTag tag;
      bool found;
      found = packet->FindFirstMatchingTag (tag);
      NS_ASSERT (found);
      fromAddress = tag.GetAddress ();
    }
  return packet;
}

void 

  if ((m_rxAvailable + packet->GetSize ()) <= m_rcvBufSize)
    {
      Address address = InetSocketAddress (ipv4, port);
      SocketAddressTag tag;
      tag.SetAddress (address);
      packet->AddTag (tag);
      m_deliveryQueue.push (packet);

  // Unicast test
  m_receivedPacket = Create<Packet> ();
  m_receivedPacket2 = Create<Packet> ();
  NS_TEST_ASSERT_EQUAL (txSocket->SendTo ( Create<Packet> (123), 0, 
    InetSocketAddress (Ipv4Address("10.0.0.1"), 1234)), 123);
  Simulator::Run ();
  NS_TEST_ASSERT_EQUAL (m_receivedPacket->GetSize (), 123);


  m_receivedPacket = Create<Packet> ();
  m_receivedPacket2 = Create<Packet> ();
  NS_TEST_ASSERT_EQUAL (txSocket->SendTo ( Create<Packet> (123), 0, 
    InetSocketAddress (Ipv4Address("255.255.255.255"), 1234)), 123);
  Simulator::Run ();
  NS_TEST_ASSERT_EQUAL (m_receivedPacket->GetSize (), 123);


  m_receivedPacket = Create<Packet> ();
  m_receivedPacket2 = Create<Packet> ();
  NS_TEST_ASSERT_EQUAL (txSocket->SendTo (Create<Packet> (123), 0,
InetSocketAddress (Ipv4Address("255.255.255.255"), 1234)), 123);
  Simulator::Run ();
  NS_TEST_ASSERT_EQUAL (m_receivedPacket->GetSize (), 123);

(-)ns-3-dev/src/internet-node/udp-socket-impl.h (-4 / +5 lines)

Lines 58-69	Link Here

  virtual int ShutdownRecv (void);

  virtual int ShutdownRecv (void);

  virtual int Connect(const Address &address);

  virtual int Connect(const Address &address);

  virtual int Listen (uint32_t queueLimit);

  virtual int Listen (uint32_t queueLimit);

  virtual int Send (Ptr<Packet> p);

  virtual int SendTo (Ptr<Packet> p, const Address &address);

  virtual uint32_t GetTxAvailable (void) const;

  virtual uint32_t GetTxAvailable (void) const;

  virtual int Send (Ptr<Packet> p, uint32_t flags);

  virtual Ptr<Packet> Recv (uint32_t maxSize, uint32_t flags);

  virtual int SendTo (Ptr<Packet> p, uint32_t flags, const Address &address);

  virtual uint32_t GetRxAvailable (void) const;

  virtual uint32_t GetRxAvailable (void) const;

  virtual Ptr<Packet> Recv (uint32_t maxSize, uint32_t flags);

  virtual Ptr<Packet> RecvFrom (uint32_t maxSize, uint32_t flags,

    Address &fromAddress);

private:

private:

  // Attributes set through UdpSocket base class

  // Attributes set through UdpSocket base class




}

int
PacketSocket::Send (Ptr<Packet> p, uint32_t flags)
{
  NS_LOG_FUNCTION_NOARGS ();
  if (m_state == STATE_OPEN ||

      m_errno = ERROR_NOTCONN;
      return -1;
    }
  return SendTo (p, flags, m_destAddr);
}

uint32_t

}

int
PacketSocket::SendTo (Ptr<Packet> p, uint32_t flags, const Address &address)
{
  NS_LOG_FUNCTION_NOARGS ();
  PacketSocketAddress ad;


  if ((m_rxAvailable + packet->GetSize ()) <= m_rcvBufSize)
    {
      SocketAddressTag tag;
      tag.SetAddress (address);
      packet->AddTag (tag);
      m_deliveryQueue.push (packet);

    }
}

uint32_t
PacketSocket::GetRxAvailable (void) const
{
  NS_LOG_FUNCTION_NOARGS ();
  // We separately maintain this state to avoid walking the queue 
  // every time this might be called
  return m_rxAvailable;
}

Ptr<Packet> 
PacketSocket::Recv (uint32_t maxSize, uint32_t flags)
{

  return p;
}

Ptr<Packet>
PacketSocket::RecvFrom (uint32_t maxSize, uint32_t flags, Address &fromAddress)
{
  NS_LOG_FUNCTION_NOARGS ();
  Ptr<Packet> packet = Recv (maxSize, flags);
  if (packet != 0)
    {
      SocketAddressTag tag;
      bool found;
      found = packet->FindFirstMatchingTag (tag);
      NS_ASSERT (found);
      fromAddress = tag.GetAddress ();
    }
  return packet;
}

}//namespace ns3




  virtual int ShutdownRecv (void);
  virtual int Connect(const Address &address);
  virtual int Listen(uint32_t queueLimit);
  virtual int Send (Ptr<Packet> p);
  virtual uint32_t GetTxAvailable (void) const;
  virtual int Send (Ptr<Packet> p, uint32_t flags);
  virtual int SendTo(Ptr<Packet> p, uint32_t flags, const Address &toAddress);

  virtual Ptr<Packet> Recv (uint32_t maxSize, uint32_t flags);
  virtual uint32_t GetRxAvailable (void) const;
  virtual Ptr<Packet> Recv (uint32_t maxSize, uint32_t flags);
  virtual Ptr<Packet> RecvFrom (uint32_t maxSize, uint32_t flags,
    Address &fromAddress);

private:
  void ForwardUp (Ptr<NetDevice> device, Ptr<Packet> packet, 




  NS_LOG_FUNCTION_NOARGS ();
}

void
Socket::SetCloseUnblocksCallback (Callback<void,Ptr<Socket> > closeUnblocks)
{
  NS_LOG_FUNCTION_NOARGS ();
  m_closeUnblocks = closeUnblocks;
}

Ptr<Socket> 
Socket::CreateSocket (Ptr<Node> node, TypeId tid)
{

  m_receivedData = receivedData;
}

int 
Socket::Send (Ptr<Packet> p)
{
  NS_LOG_FUNCTION_NOARGS ();
  return Send (p, 0);
}

void
Socket::NotifyCloseUnblocks (void)
{

  return 0; //XXX the base class version does nothing
}

int 
Socket::Send (const uint8_t* buf, uint32_t size, uint32_t flags)
{
  NS_LOG_FUNCTION_NOARGS ();
  Ptr<Packet> p;

    {
      p = Create<Packet> (size);
    }
  return Send (p, flags);
}

int 
Socket::SendTo (const uint8_t* buf, uint32_t size, uint32_t flags,
                const Address &toAddress)
{
  NS_LOG_FUNCTION_NOARGS ();
  Ptr<Packet> p;
  if(buf)
    {
      p = Create<Packet> (buf, size);
    }
  else
    {
      p = Create<Packet> (size);
    }
  return SendTo (p, flags, toAddress);
}

Ptr<Packet>
Socket::Recv (void)
{
  NS_LOG_FUNCTION_NOARGS ();
  return Recv (std::numeric_limits<uint32_t>::max(), 0);
}

int 
Socket::Recv (uint8_t* buf, uint32_t size, uint32_t flags)
{
  NS_LOG_FUNCTION_NOARGS ();
  Ptr<Packet> p = Recv (size, flags); // read up to "size" bytes
  if (p == 0)
    {
      return 0;
    }
  memcpy (buf, p->PeekData (), p->GetSize());
  return p->GetSize ();
}

Ptr<Packet>
Socket::RecvFrom (Address &fromAddress)
{
  NS_LOG_FUNCTION_NOARGS ();
  return RecvFrom (std::numeric_limits<uint32_t>::max(), 0, fromAddress);
}

int 
Socket::RecvFrom (uint8_t* buf, uint32_t size, uint32_t flags,
                  Address &fromAddress)
{
  NS_LOG_FUNCTION_NOARGS ();
  Ptr<Packet> p = RecvFrom (size, flags, fromAddress); 
  if (p == 0)
    {
      return 0;
    }
  memcpy (buf, p->PeekData (), p->GetSize());
  return p->GetSize ();
}

void 

 *           Socket Tags
 ***************************************************************/

SocketAddressTag::SocketAddressTag ()  
{
}

void 
SocketAddressTag::SetAddress (Address addr)
{
  m_address = addr;
}

Address 
SocketAddressTag::GetAddress (void) const
{
  return m_address;
}


TypeId
SocketAddressTag::GetTypeId (void)
{
  static TypeId tid = TypeId ("ns3::SocketAddressTag")
    .SetParent<Tag> ()
    .AddConstructor<SocketAddressTag> ()
    ;
  return tid;
}
TypeId
SocketAddressTag::GetInstanceTypeId (void) const
{
  return GetTypeId ();
}
uint32_t
SocketAddressTag::GetSerializedSize (void) const
{
  return m_address.GetSerializedSize ();
}
void
SocketAddressTag::Serialize (TagBuffer i) const
{
  m_address.Serialize (i);
}
void
SocketAddressTag::Deserialize (TagBuffer i)
{
  m_address.Deserialize (i);
}
void
SocketAddressTag::Print (std::ostream &os) const
{
  os << "address=" << m_address;
}

  os << "Ttl=" << (uint32_t) m_ttl;
}


}//namespace ns3




   * \param tid The TypeId of the socket to create
   */
  static Ptr<Socket> CreateSocket (Ptr<Node> node, TypeId tid);

  /**
   * \return the errno associated to the last call which failed in this
   *         socket. Each socket's errno is initialized to zero
   *         when the socket is created.
   */
  virtual enum Socket::SocketErrno GetErrno (void) const = 0;

  /**
   * \returns the node this socket is associated with.
   */
  virtual Ptr<Node> GetNode (void) const = 0;

  void SetCloseUnblocksCallback (Callback<void, Ptr<Socket> > closeUnblocks);

  /**
   * \param closeCompleted Callback invoked when the close operation is
   *        completed.
   */
  void SetCloseCallback (Callback<void, Ptr<Socket> > closeCompleted);

  /**
   * \param connectionSucceeded this callback is invoked when the 
   *        connection request initiated by the user is successfully 

   *        user should check this return value to confirm that the
   *        callback is supported.
   */
  virtual bool SetDataSentCallback (Callback<void, Ptr<Socket>, 
                                    uint32_t> dataSent);
  /**
   * \brief Notify application when space in transmit buffer is added
   *

  virtual int Listen (uint32_t queueLimit) = 0;

  /**
   * \brief Returns the number of bytes which can be sent in a single call
   * to Send. 
   * 
   * For datagram sockets, this returns the number of bytes that
   * can be passed atomically through the underlying protocol.
   *
   * For stream sockets, this returns the available space in bytes
   * left in the transmit buffer.
   */
  virtual uint32_t GetTxAvailable (void) const = 0;
 
  /**
   * \brief Send data (or dummy data) to the remote host
   *
   * This function matches closely in semantics to the send() function
   * call in the standard C library (libc):
   *   ssize_t send (int s, const void *msg, size_t len, int flags);
   * except that the send I/O is asynchronous.  This is the
   * primary Send method at this low-level API and must be implemented 
   * by subclasses.
   * 
   * In a typical blocking sockets model, this call would block upon
   * lack of space to hold the message to be sent.  In ns-3 at this

   * split the Packet (based on information obtained from 
   * GetTxAvailable) and reattempt to send the data.
   *
   * The flags argument is formed by or'ing one or more of the values:     
   *        MSG_OOB        process out-of-band data 
   *        MSG_DONTROUTE  bypass routing, use direct interface 
   * These flags are _unsupported_ as of ns-3.1.  
   *
   * \param p ns3::Packet to send
   * \param flags Socket control flags
   * \returns the number of bytes accepted for transmission if no error
   *          occurs, and -1 otherwise.
   *
   * \see SetSendCallback
   */
  virtual int Send (Ptr<Packet> p, uint32_t flags) = 0;

  /**
   * \brief Send data to a specified peer.
   *
   * This method has similar semantics to Send () but subclasses may
   * want to provide checks on socket state, so the implementation is
   * pushed to subclasses.
   *
   * \param p packet to send
   * \param flags Socket control flags
   * \param toAddress IP Address of remote host
   * \returns -1 in case of error or the number of bytes copied in the 
   *          internal buffer and accepted for transmission.
   */
  virtual int SendTo (Ptr<Packet> p, uint32_t flags, 
    const Address &toAddress) = 0;

  /**
   * Return number of bytes which can be returned from one or 
   * multiple calls to Recv.
   * Must be possible to call this method from the Recv callback.
   */
  virtual uint32_t GetRxAvailable (void) const = 0;

  /**
   * \brief Read data from the socket
   *
   * This function matches closely in semantics to the recv() function
   * call in the standard C library (libc):
   *   ssize_t recv (int s, void *buf, size_t len, int flags);
   * except that the receive I/O is asynchronous.  This is the
   * primary Recv method at this low-level API and must be implemented 
   * by subclasses.
   * 
   * This method is normally used only on a connected socket.
   * In a typical blocking sockets model, this call would block until
   * at least one byte is returned or the connection closes.  
   * In ns-3 at this API, the call returns immediately in such a case
   * and returns 0 if nothing is available to be read.
   * However, an application can set a callback, ns3::SetRecvCallback,
   * to be notified of data being available to be read
   * (when it conceptually unblocks); this is an asynchronous
   * I/O model for recv().
   * 
   * This variant of Recv() uses class ns3::Packet to encapsulate
   * data, rather than providing a raw pointer and length field.  
   * This allows an ns-3 application to attach tags if desired (such
   * as a flow ID) and may allow the simulator to avoid some data
   * copies.  Despite the appearance of receiving Packets on a stream
   * socket, just think of it as a fancy byte buffer with streaming
   * semantics.    
   *
   * The semantics depend on the type of socket.  For a datagram socket,
   * each Recv() returns the data from at most one Send(), and order
   * is not necessarily preserved.  For a stream socket, the bytes
   * are delivered in order, and on-the-wire packet boundaries are
   * not preserved.  
   * 
   * The flags argument is formed by or'ing one or more of the values:     
   *        MSG_OOB        process out-of-band data
   *        MSG_PEEK       peek at incoming message
   * These flags are _unsupported_ as of ns-3.1.  
   *
   * Some variants of Recv() are supported as additional API,
   * including RecvFrom(), overloaded Recv() without arguments,
   * and variants that use raw character buffers.
   *
   * \param maxSize reader will accept packet up to maxSize
   * \param flags Socket control flags
   * \returns Ptr<Packet> of the next in-sequence packet.  Returns
   * 0 if the socket cannot return a next in-sequence packet conforming
   * to the maxSize and flags.
   *
   * \see SetRecvCallback
   */
  virtual Ptr<Packet> Recv (uint32_t maxSize, uint32_t flags) = 0;

  /**
   * \brief Read a single packet from the socket and retrieve the sender 
   * address.
   *
   * Calls Recv(maxSize, flags) with maxSize
   * implicitly set to maximum sized integer, and flags set to zero.
   *
   * This method has similar semantics to Recv () but subclasses may   
   * want to provide checks on socket state, so the implementation is   
   * pushed to subclasses.
   *
   * \param maxSize reader will accept packet up to maxSize
   * \param flags Socket control flags
   * \param fromAddress output parameter that will return the
   * address of the sender of the received packet, if any.  Remains
   * untouched if no packet is received.
   * \returns Ptr<Packet> of the next in-sequence packet.  Returns
   * 0 if the socket cannot return a next in-sequence packet.
   */
  virtual Ptr<Packet> RecvFrom (uint32_t maxSize, uint32_t flags,  
    Address &fromAddress) = 0;

  /////////////////////////////////////////////////////////////////////
  //   The remainder of these public methods are overloaded methods  //
  //   or variants of Send() and Recv(), and they are non-virtual    //
  /////////////////////////////////////////////////////////////////////
 
  /**
   * \brief Send data (or dummy data) to the remote host
   * \param buf A pointer to a raw byte buffer of some data to send.  If this 
   * is 0, we send dummy data whose size is specified by the second parameter
   * \param size the number of bytes to copy from the buffer
   * 
   * Overloaded version of Send(..., flags) with flags set to zero.
   *
   * \param p ns3::Packet to send
   * \returns the number of bytes accepted for transmission if no error
   *          occurs, and -1 otherwise.
   */
  int Send (Ptr<Packet> p);

  /**
   * \brief Send data (or dummy data) to the remote host
   * 
   * This method is provided so as to have an API which is closer in 
   * appearance to that of real network or BSD sockets.  
   *
   * \param buf A pointer to a raw byte buffer of some data to send.  If 
   * this buffer is 0, we send dummy data whose size is specified by the 
   * second parameter
   * \param size the number of bytes to copy from the buffer
   * \param flags Socket control flags
   */
  int Send (const uint8_t* buf, uint32_t size, uint32_t flags);
  

  /**
   * \brief Send data to a specified peer.
   *
   * This method is provided so as to have an API which is closer in 
   * appearance to that of real network or BSD sockets.  
   *
   * \param buf A pointer to a raw byte buffer of some data to send.  
   * If this is 0, we send dummy data whose size is specified by the 
   * third parameter
   * \param size the number of bytes to copy from the buffer
   * \param flags Socket control flags
   * \param address IP Address of remote host
   * \returns -1 in case of error or the number of bytes copied in the 
   *          internal buffer and accepted for transmission.
   *
   * This is provided so as to have an API which is closer in appearance 
   * to that of real network or BSD sockets.
   */
  int SendTo (const uint8_t* buf, uint32_t size, uint32_t flags, 
              const Address &address); 

  /**
   * \brief Read a single packet from the socket
   * \param maxSize reader will accept packet up to maxSize
   * \param flags Socket recv flags
   * \returns Ptr<Packet> of the next in-sequence packet.  Returns
   * 0 if the socket cannot return a next in-sequence packet conforming
   * to the maxSize and flags.
   */
  virtual Ptr<Packet> Recv (uint32_t maxSize, uint32_t flags) = 0;
  /**
   * \brief Read a single packet from the socket
   *
   * Overloaded version of Recv(maxSize, flags) with maxSize
   * implicitly set to maximum sized integer, and flags set to zero.
   *
   * \returns Ptr<Packet> of the next in-sequence packet.  Returns
   * 0 if the socket cannot return a next in-sequence packet.
   */
   Ptr<Packet> Recv (void);

  /**
   * \brief Recv data (or dummy data) from the remote host
   *
   * This method is provided so as to have an API which is closer in 
   * appearance to that of real network or BSD sockets.  
   * 
   * If the underlying packet was carring null (fake) data, this buffer
   * will be zeroed up to the length specified by the return value.
   *
   * \param buf A pointer to a raw byte buffer to write the data to. 
   * \param size Number of bytes (at most) to copy to buf
   * \param flags any flags to pass to the socket
   * \returns number of bytes copied into buf
   * 
   * This is provided so as to have an API which is closer in appearance 
   * to that of real network or BSD sockets.  
   */
  int Recv (uint8_t* buf, uint32_t size, uint32_t flags);

  /**
   * \brief Read a single packet from the socket and retrieve the sender 
   * address.
   *
   * Calls RecvFrom (maxSize, flags, fromAddress) with maxSize
   * implicitly set to maximum sized integer, and flags set to zero.
   *
   * \param maxSize reader will accept packet up to maxSize
   * \param flags Socket control flags
   * \param fromAddress output parameter that will return the
   * address of the sender of the received packet, if any.  Remains
   * untouched if no packet is received.
   * \returns Ptr<Packet> of the next in-sequence packet.  Returns
   * 0 if the socket cannot return a next in-sequence packet.
   */
  Ptr<Packet> RecvFrom (Address &fromAddress);

  /**
   * \brief Read a single packet from the socket and retrieve the sender
   * address.
   *
   * This method is provided so as to have an API which is closer in 
   * appearance to that of real network or BSD sockets.  
   * 
   * \param buf A pointer to a raw byte buffer to write the data to. 
   * If the underlying packet was carring null (fake) data, this buffer
   * will be zeroed up to the length specified by the return value.
   * \param size Number of bytes (at most) to copy to buf
   * \param flags any flags to pass to the socket
   * \param fromAddress output parameter that will return the
   * address of the sender of the received packet, if any.  Remains
   * untouched if no packet is received.
   * \returns number of bytes copied into buf
   */
  int RecvFrom (uint8_t* buf, uint32_t size, uint32_t flags,
                Address &fromAddress);
 
protected:
  void NotifyCloseUnblocks (void);

};

/**
 * \brief This class implements a tag that carries an address
 * of a packet across the socket interface.
 */
class SocketAddressTag : public Tag
{
public:
  SocketAddressTag ();
  void SetAddress (Address addr);
  Address GetAddress (void) const;


(-)ns-3-dev/src/node/tcp-socket.h (-3 / +7 lines)

Lines 58-68	Link Here

  virtual int ShutdownSend (void) = 0;

  virtual int ShutdownSend (void) = 0;

  virtual int ShutdownRecv (void) = 0;

  virtual int ShutdownRecv (void) = 0;

  virtual int Connect (const Address &address) = 0;

  virtual int Connect (const Address &address) = 0;

  virtual int Send (Ptr<Packet> p) = 0;

  virtual uint32_t GetTxAvailable (void) const = 0;

  virtual uint32_t GetTxAvailable (void) const = 0;

  virtual int SendTo (Ptr<Packet> p, const Address &address) = 0;

  virtual int Send (Ptr<Packet> p, uint32_t flags) = 0;

  virtual Ptr<Packet> Recv (uint32_t maxSize, uint32_t flags) = 0;

  virtual int SendTo (Ptr<Packet> p, uint32_t flags,

    const Address &toAddress) = 0;

  virtual uint32_t GetRxAvailable (void) const = 0;

  virtual uint32_t GetRxAvailable (void) const = 0;

  virtual Ptr<Packet> Recv (uint32_t maxSize, uint32_t flags) = 0;

  virtual Ptr<Packet> RecvFrom (uint32_t maxSize, uint32_t flags,

    Address &fromAddress) = 0;

private:

private:

  // Indirect the attribute setting and getting through private virtual methods

  // Indirect the attribute setting and getting through private virtual methods

(-)ns-3-dev/src/node/udp-socket.h (-3 / +6 lines)

Lines 57-67	Link Here

  virtual int ShutdownSend (void) = 0;

  virtual int ShutdownSend (void) = 0;

  virtual int ShutdownRecv (void) = 0;

  virtual int ShutdownRecv (void) = 0;

  virtual int Connect (const Address &address) = 0;

  virtual int Connect (const Address &address) = 0;

  virtual int Send (Ptr<Packet> p) = 0;

  virtual uint32_t GetTxAvailable (void) const = 0;

  virtual uint32_t GetTxAvailable (void) const = 0;

  virtual int SendTo (Ptr<Packet> p, const Address &address) = 0;

  virtual int Send (Ptr<Packet> p, uint32_t flags) = 0;

  virtual Ptr<Packet> Recv (uint32_t maxSize, uint32_t flags) = 0;

  virtual int SendTo (Ptr<Packet> p, uint32_t flags,

    const Address &toAddress) = 0;

  virtual uint32_t GetRxAvailable (void) const = 0;

  virtual uint32_t GetRxAvailable (void) const = 0;

  virtual Ptr<Packet> Recv (uint32_t maxSize, uint32_t flags) = 0;

  virtual Ptr<Packet> RecvFrom (uint32_t maxSize, uint32_t flags,

    Address &fromAddress) = 0;

private:

private:

  // Indirect the attribute setting and getting through private virtual methods

  // Indirect the attribute setting and getting through private virtual methods

(-)ns-3-dev/src/routing/olsr/olsr-agent-impl.cc (-1 / +1 lines)

Lines 305-311	Link Here

305

  Ptr<Packet> receivedPacket;

305

  Ptr<Packet> receivedPacket;

306

  receivedPacket = socket->Recv ();

306

  receivedPacket = socket->Recv ();

307

308

  SocketRxAddressTag tag;

308

  SocketAddressTag tag;

309

  bool found;

309

  bool found;

310

  found = receivedPacket->FindFirstMatchingTag (tag);

310

  found = receivedPacket->FindFirstMatchingTag (tag);

311

  NS_ASSERT (found);

311

  NS_ASSERT (found);

Return to bug 213