Attachment #112 for bug #131

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

(-)a/src/internet-node/tcp-socket.cc (+9 lines)

Lines 305-310 int TcpSocket::Send (const uint8_t* buf,	Link Here

305

      //PendingData::Add always copies the data buffer, never modifies

305

      //PendingData::Add always copies the data buffer, never modifies

306

      m_pendingData->Add (size,buf);

306

      m_pendingData->Add (size,buf);

307

      Actions_t action = ProcessEvent (APP_SEND);

307

      Actions_t action = ProcessEvent (APP_SEND);

308

      // We do not model any limit to the buffer, so report that the

309

      // maximum is available

310

      NotifySend (std::numeric_limits<uint32_t>::max ());

308

      if (!ProcessAction (action))

311

      if (!ProcessAction (action))

309

312

310

          return -1; // Failed, return zero

313

          return -1; // Failed, return zero

Lines 591-596 bool TcpSocket::ProcessPacketAction (Act	Link Here

591

      if (tcpHeader.GetAckNumber () > m_highestRxAck)

594

      if (tcpHeader.GetAckNumber () > m_highestRxAck)

592

595

593

        m_highestRxAck = tcpHeader.GetAckNumber ();

596

        m_highestRxAck = tcpHeader.GetAckNumber ();

597

        // We do not model any limit to the buffer, so report that the

598

        // maximum is available

599

        NotifySend (std::numeric_limits<uint32_t>::max ());

594

600

595

      SendPendingData ();

601

      SendPendingData ();

596

      break;

602

      break;

Lines 932-937 void TcpSocket::CommonNewAck (SequenceNu	Link Here

932

  NS_LOG_LOGIC ("TCP " << this << " NewAck " << ack

938

  NS_LOG_LOGIC ("TCP " << this << " NewAck " << ack

933

           << " numberAck " << (ack - m_highestRxAck)); // Number bytes ack'ed

939

           << " numberAck " << (ack - m_highestRxAck)); // Number bytes ack'ed

934

  m_highestRxAck = ack;         // Note the highest recieved Ack

940

  m_highestRxAck = ack;         // Note the highest recieved Ack

941

  // We do not model any limit to the buffer, so report that the

942

  // maximum is available

943

  NotifySend (std::numeric_limits<uint32_t>::max ());

935

  if (ack > m_nextTxSequence)

944

  if (ack > m_nextTxSequence)

936

945

937

      m_nextTxSequence = ack; // If advanced

946

      m_nextTxSequence = ack; // If advanced

(-)a/src/node/socket.cc (-2 / +20 lines)

Lines 64-74 Socket::SetAcceptCallback (	Link Here

  m_closeRequested = closeRequested;

  m_closeRequested = closeRequested;

void

bool

Socket::SetSendCallback (Callback<void, Ptr<Socket>, uint32_t> dataSent)

Socket::SetDataSentCallback (Callback<void, Ptr<Socket>, uint32_t> dataSent)

  NS_LOG_FUNCTION;

  NS_LOG_FUNCTION;

  m_dataSent = dataSent;

  m_dataSent = dataSent;

  return true;

void

Socket::SetSendCallback (Callback<void, Ptr<Socket>, uint32_t> sendCb)

  NS_LOG_FUNCTION;

  m_sendCb = sendCb;

void

void

Lines 200-205 Socket::NotifyDataSent (uint32_t size)	Link Here

200

208

201

209

202

void

210

void

211

Socket::NotifySend (uint32_t spaceAvailable)

212

213

  NS_LOG_FUNCTION;

214

  if (!m_sendCb.IsNull ())

215

216

      m_sendCb (this, spaceAvailable);

217

218

219

220

void

203

Socket::NotifyDataReceived (Ptr<Packet> p, const Address &from)

221

Socket::NotifyDataReceived (Ptr<Packet> p, const Address &from)

204

222

205

  NS_LOG_FUNCTION;

223

  NS_LOG_FUNCTION;




                          Callback<void, Ptr<Socket>, 
                            const Address&> newConnectionCreated,
                          Callback<void, Ptr<Socket> > closeRequested);
  /**
   * \brief Notify application when a packet has been sent from transport 
   *        protocol (non-standard socket call)
   * \param dataSent Callback for the event that data is sent from the
   *        underlying transport protocol.  This callback is passed a
   *        pointer to the socket, and the number of bytes sent.
   * \returns whether or not this socket supports this callback.  Note 
   *        that this is a non-standard socket call.  Some socket 
   *        implementations in ns-3 may not support this call, so the
   *        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
   *
   *        This callback is intended to notify a 
   *        socket that would have been blocked in a blocking socket model
   *        that some data has been acked and removed from the transmit
   *        buffer, and that it can call send again.  The semantics for
   *        reliable stream sockets are that when data is acked and removed
   *        from the transmit buffer, this callback is invoked.
   *
   * \param sendCb Callback for the event that the socket transmit buffer
   *        fill level has decreased.  This callback is passed a pointer to
   *        the socket, and the number of bytes available for writing
   *        into the buffer (an absolute value).  If there is no transmit
   *        buffer limit, a maximum-sized integer is always returned.
   */
  void SetSendCallback (Callback<void, Ptr<Socket>, uint32_t> sendCb);
  /**
   * \brief Receive data
   * \param receivedData Invoked whenever new data is received.

  void NotifyNewConnectionCreated (Ptr<Socket> socket, const Address &from);
  void NotifyCloseRequested (void);
  void NotifyDataSent (uint32_t size);
  void NotifySend (uint32_t spaceAvailable);
  void NotifyDataReceived (Ptr<Packet> p, const Address &from);

  Callback<void,Ptr<Socket> >    m_closeCompleted;

  Callback<bool, Ptr<Socket>, const Address &>   m_connectionRequest;
  Callback<void, Ptr<Socket>, const Address&>    m_newConnectionCreated;
  Callback<void, Ptr<Socket>, uint32_t>          m_dataSent;
  Callback<void, Ptr<Socket>, uint32_t >         m_sendCb;
  Callback<void, Ptr<Socket>, Ptr<Packet>,const Address&> m_receivedData;
};


Return to bug 131