Attachment #610 for bug #424

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

(-)a/src/applications/packet-sink/packet-sink.cc (-3 / +24 lines)

Lines 62-67 PacketSink::PacketSink ()	Link Here

  NS_LOG_FUNCTION (this);

  NS_LOG_FUNCTION (this);

  m_socket = 0;

  m_socket = 0;

  m_totalRx = 0;

PacketSink::~PacketSink()

PacketSink::~PacketSink()

Lines 69-76 PacketSink::~PacketSink()	Link Here

  NS_LOG_FUNCTION (this);

  NS_LOG_FUNCTION (this);

void

uint32_t PacketSink::GetTotalRx() const

PacketSink::DoDispose (void)

  return m_totalRx;

void PacketSink::DoDispose (void)

  NS_LOG_FUNCTION (this);

  NS_LOG_FUNCTION (this);

  m_socket = 0;

  m_socket = 0;

Lines 109-114 void PacketSink::StartApplication() /	Link Here

109

  m_socket->SetAcceptCallback (

114

  m_socket->SetAcceptCallback (

110

            MakeNullCallback<bool, Ptr<Socket>, const Address &> (),

115

            MakeNullCallback<bool, Ptr<Socket>, const Address &> (),

111

            MakeCallback(&PacketSink::HandleAccept, this));

116

            MakeCallback(&PacketSink::HandleAccept, this));

117

  m_socket->SetCloseCallbacks (

118

            MakeCallback(&PacketSink::HandlePeerClose, this),

119

            MakeCallback(&PacketSink::HandlePeerError, this));

112

120

113

121

114

void PacketSink::StopApplication()     // Called at time specified by Stop

122

void PacketSink::StopApplication()     // Called at time specified by Stop

Lines 141-152 void PacketSink::HandleRead (Ptr<Socket>	Link Here

141

      if (InetSocketAddress::IsMatchingType (from))

149

      if (InetSocketAddress::IsMatchingType (from))

142

150

143

          InetSocketAddress address = InetSocketAddress::ConvertFrom (from);

151

          InetSocketAddress address = InetSocketAddress::ConvertFrom (from);

152

          m_totalRx += packet->GetSize();

144

          NS_LOG_INFO ("Received " << packet->GetSize() << " bytes from " <<

153

          NS_LOG_INFO ("Received " << packet->GetSize() << " bytes from " <<

145

            address.GetIpv4() << " [" << address << "]");

154

                       address.GetIpv4() << " [" << address << "]"

155

                       << " total Rx " << m_totalRx);

146

156

147

      m_rxTrace (packet, from);

157

      m_rxTrace (packet, from);

148

158

149

159

160

161

void PacketSink::HandlePeerClose (Ptr<Socket> socket)

162

163

  NS_LOG_INFO("PktSink, peerClose");

164

165

166

void PacketSink::HandlePeerError (Ptr<Socket> socket)

167

168

  NS_LOG_INFO("PktSink, peerError");

169

170

150

171

151

void PacketSink::HandleAccept (Ptr<Socket> s, const Address& from)

172

void PacketSink::HandleAccept (Ptr<Socket> s, const Address& from)

152

173

(-)a/src/applications/packet-sink/packet-sink.h (-2 / +8 lines)

Lines 73-78 public:	Link Here

  virtual ~PacketSink ();

  virtual ~PacketSink ();

  // Return the total bytes received in this sink app

  uint32_t GetTotalRx() const;

protected:

protected:

  virtual void DoDispose (void);

  virtual void DoDispose (void);

private:

private:

Lines 80-94 private:	Link Here

  virtual void StartApplication (void);    // Called at time specified by Start

  virtual void StartApplication (void);    // Called at time specified by Start

  virtual void StopApplication (void);     // Called at time specified by Stop

  virtual void StopApplication (void);     // Called at time specified by Stop

  void HandleRead (Ptr<Socket> socket);

  void HandleRead (Ptr<Socket>);

  void HandleAccept (Ptr<Socket>, const Address& from);

  void HandleAccept (Ptr<Socket>, const Address& from);

  void HandlePeerClose(Ptr<Socket>);

  void HandlePeerError(Ptr<Socket>);

  // In the case of TCP, each socket accept returns a new socket, so the

  // In the case of TCP, each socket accept returns a new socket, so the

  // listening socket is stored seperately from the accepted sockets

  // listening socket is stored seperately from the accepted sockets

  Ptr<Socket>     m_socket;       // Listening socket

  Ptr<Socket>     m_socket;       // Listening socket

  std::list<Ptr<Socket> > m_socketList; //the accepted sockets

  std::list<Ptr<Socket> > m_socketList; //the accepted sockets

  Address         m_local;        // Local address to bind to

  Address         m_local;        // Local address to bind to

  uint32_t        m_totalRx;      // Total bytes received

  TypeId          m_tid;          // Protocol TypeId

  TypeId          m_tid;          // Protocol TypeId

  TracedCallback<Ptr<const Packet>, const Address &> m_rxTrace;

  TracedCallback<Ptr<const Packet>, const Address &> m_rxTrace;

100




  m_tcp = 0;
  delete m_pendingData; //prevents leak
  m_pendingData = 0;
  CancelAllTimers();
}

void

TcpSocketImpl::Close (void)
{
  NS_LOG_FUNCTION_NOARGS ();
  // First we check to see if there is any unread rx data
  // Bug number 426 claims we should send reset in this case.
  if (!m_bufferedData.empty())
    {
      SendRST();
      return 0;
    }

  uint32_t remainingData = 0;
  if (m_pendingData)
    {
      remainingData = m_pendingData->SizeFromSeq (m_firstPendingSequence,
                                                  m_nextTxSequence);
    }
  
  if (remainingData != 0)
    { // App close with pending data must wait until all data transmitted
      m_closeOnEmpty = true;
      NS_LOG_LOGIC("Socket " << this << 
                   " deferring close, state " << m_state);
      return 0;
    }

  Actions_t action  = ProcessEvent (APP_CLOSE);
  ProcessAction (action);
  return 0;

      m_errno = ERROR_SHUTDOWN;
      return -1;
    }
  // Get the size before sending to tcp, as the sent callback cares
  // about payload sent, not with headers
  uint32_t sentSize = p->GetSize();
  m_tcp->Send (p, m_endPoint->GetLocalAddress (), ipv4,
                  m_endPoint->GetLocalPort (), port);
  NotifyDataSent (sentSize);
  return 0;
}


  TcpHeader tcpHeader;
  packet->RemoveHeader (tcpHeader);

  if (tcpHeader.GetFlags () & TcpHeader::RST)
    { // Got an RST, just shut everything down
      NotifyErrorClose();
      CancelAllTimers();
      m_endPoint->SetDestroyCallback(MakeNullCallback<void>());
      m_tcp->DeAllocate (m_endPoint);
      m_endPoint = 0;
      return;
    }
      
  if (tcpHeader.GetFlags () & TcpHeader::ACK)
    {
      Time m = m_rtt->AckSeq (tcpHeader.GetAckNumber () );

    {
      NS_LOG_LOGIC ("TcpSocketImpl " << this << " sending RST from state "
              << saveState << " event " << e);
      SendRST();
      return NO_ACT;
    }
  bool needCloseNotify = (stateAction.state == CLOSED && m_state != CLOSED 
    && e != TIMEOUT);

    // the handshaking
    {
      Simulator::ScheduleNow(&TcpSocketImpl::ConnectionSucceeded, this);
      //NotifyConnectionSucceeded ();
      m_connected = true;
      m_endPoint->SetPeer (m_remoteAddress, m_remotePort);
      NS_LOG_LOGIC ("TcpSocketImpl " << this << " Connected!");

      NS_LOG_LOGIC ("TcpSocketImpl " << this << " transition to CLOSED from " 
               << m_state << " event " << e << " closeNot " << m_closeNotified
               << " action " << stateAction.action);
      NotifyNormalClose();
      m_closeNotified = true;
      NS_LOG_LOGIC ("TcpSocketImpl " << this << " calling Closed from PE"
              << " origState " << saveState

      m_endPoint->SetDestroyCallback(MakeNullCallback<void>());
      m_tcp->DeAllocate (m_endPoint);
      m_endPoint = 0;
      CancelAllTimers();
    }
    
  return stateAction.action;

  }
}

// This function closes the endpoint completely
void TcpSocketImpl::SendRST()
{
  SendEmptyPacket(TcpHeader::RST);
  NotifyErrorClose();
  CancelAllTimers();
  m_endPoint->SetDestroyCallback(MakeNullCallback<void>());
  m_tcp->DeAllocate (m_endPoint);
  m_endPoint = 0;
}

  
bool TcpSocketImpl::ProcessAction (Actions_t a)
{ // These actions do not require a packet or any TCP Headers
  NS_LOG_FUNCTION (this << a);

      break;
    case PEER_CLOSE:
    {
      NS_LOG_LOGIC("Got Peer Close");
      // First we have to be sure the FIN packet was not received
      // out of sequence.  If so, note pending close and process
      // new sequence rx

        {
          NS_LOG_LOGIC ("TCP " << this 
              << " calling AppCloseRequest");
          NotifyNormalClose();
          m_closeRequestNotified = true;
        }
      NS_LOG_LOGIC ("TcpSocketImpl " << this 

                         m_endPoint->GetLocalAddress (),
                         m_remoteAddress);
      m_rtt->SentSeq(m_nextTxSequence, sz);       // notify the RTT
      // Notify the application of the data being sent
      Simulator::ScheduleNow(&TcpSocketImpl::NotifyDataSent, this, sz);
      nPacketsSent++;                             // Count sent this loop
      m_nextTxSequence += sz;                     // Advance next tx sequence
      // Note the high water mark

  // and MUST be called by any subclass, from the NewAck function
  // Always cancel any pending re-tx timer on new acknowledgement
  NS_LOG_FUNCTION (this << ack << skipTimer); 
  //DEBUG(1,(cout << "TCP " << this << "Cancelling retx timer " << endl));
  if (!skipTimer)
    {
      NS_LOG_LOGIC (this<<" Cancelled ReTxTimeout event which was set to expire at "

  SendPendingData (m_connected);
}

void TcpSocketImpl::CancelAllTimers()
{
  m_retxEvent.Cancel ();
  m_persistEvent.Cancel ();
  m_delAckEvent.Cancel();
  m_lastAckEvent.Cancel ();
}

Ptr<TcpSocketImpl> TcpSocketImpl::Copy ()
{
  return CopyObject<TcpSocketImpl> (this);

(-)a/src/internet-stack/tcp-socket-impl.h (-6 / +8 lines)

Lines 105-110 private:	Link Here

105

  int DoSendTo (Ptr<Packet> p, const Address &daddr);

105

  int DoSendTo (Ptr<Packet> p, const Address &daddr);

106

  int DoSendTo (Ptr<Packet> p, Ipv4Address daddr, uint16_t dport);

106

  int DoSendTo (Ptr<Packet> p, Ipv4Address daddr, uint16_t dport);

107

  void SendEmptyPacket(uint8_t flags);

107

  void SendEmptyPacket(uint8_t flags);

108

  void SendRST();

109

108

  //methods for state

110

  //methods for state

109

  bool ProcessAction (Actions_t a);

111

  bool ProcessAction (Actions_t a);

110

  bool ProcessAction (Actions_t a, const TcpHeader& tcpHeader,

112

  bool ProcessAction (Actions_t a, const TcpHeader& tcpHeader,

Lines 130-147 private:	Link Here

130

  // Manage data tx/rx

132

  // Manage data tx/rx

131

  void NewRx (Ptr<Packet>, const TcpHeader&, const Address&);

133

  void NewRx (Ptr<Packet>, const TcpHeader&, const Address&);

132

  void RxBufFinishInsert (SequenceNumber);

134

  void RxBufFinishInsert (SequenceNumber);

133

  // XXX This should be virtual and overridden

134

  Ptr<TcpSocketImpl> Copy ();

135

  Ptr<TcpSocketImpl> Copy ();

135

  void NewAck (SequenceNumber seq);

136

  virtual void NewAck (SequenceNumber seq);

136

  // XXX This should be virtual and overridden

137

  virtual void DupAck (const TcpHeader& t, uint32_t count);

137

  void DupAck (const TcpHeader& t, uint32_t count);

138

  virtual void ReTxTimeout ();

138

  void ReTxTimeout ();

139

  void DelAckTimeout ();

139

  void DelAckTimeout ();

140

  void LastAckTimeout ();

140

  void LastAckTimeout ();

141

  void PersistTimeout ();

141

  void PersistTimeout ();

142

  void Retransmit ();

142

  void Retransmit ();

143

  void CommonNewAck (SequenceNumber seq, bool skipTimer = false);

143

  void CommonNewAck (SequenceNumber seq, bool skipTimer = false);

144

  // All timers are cancelled when the endpoint is deleted, to insure

145

  // we don't have additional activity

146

  void CancelAllTimers();

145

  // attribute related

147

  // attribute related

146

  virtual void SetSndBufSize (uint32_t size);

148

  virtual void SetSndBufSize (uint32_t size);

147

  virtual uint32_t GetSndBufSize (void) const;

149

  virtual uint32_t GetSndBufSize (void) const;

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

Lines 62-67 Socket::SetConnectCallback (	Link Here

void

void

Socket::SetCloseCallbacks (

  Callback<void, Ptr<Socket> > normalClose,

  Callback<void, Ptr<Socket> > errorClose)

  NS_LOG_FUNCTION_NOARGS ();

  m_normalClose = normalClose;

  m_errorClose = errorClose;

void

Socket::SetAcceptCallback (

Socket::SetAcceptCallback (

  Callback<bool, Ptr<Socket>, const Address &> connectionRequest,

  Callback<bool, Ptr<Socket>, const Address &> connectionRequest,

  Callback<void, Ptr<Socket>, const Address&> newConnectionCreated)

  Callback<void, Ptr<Socket>, const Address&> newConnectionCreated)

Lines 191-196 Socket::NotifyConnectionFailed (void)	Link Here

191

  if (!m_connectionFailed.IsNull ())

201

  if (!m_connectionFailed.IsNull ())

192

202

193

      m_connectionFailed (this);

203

      m_connectionFailed (this);

204

205

206

207

void

208

Socket::NotifyNormalClose (void)

209

210

  NS_LOG_FUNCTION_NOARGS ();

211

  if (!m_normalClose.IsNull ())

212

213

      m_normalClose (this);

214

215

216

217

void

218

Socket::NotifyErrorClose (void)

219

220

  NS_LOG_FUNCTION_NOARGS ();

221

  if (!m_errorClose.IsNull ())

222

223

      m_errorClose (this);

194

224

195

225

196

226

(-)a/src/node/socket.h (-3 / +26 lines)

Lines 103-108 public:	Link Here

103

*/

103

*/

104

  virtual Ptr<Node> GetNode (void) const = 0;

104

  virtual Ptr<Node> GetNode (void) const = 0;

105

/**

105

/**

106

   * \brief Specify callbacks to allow the caller to determine if

107

   * the connection succeeds of fails.

106

   * \param connectionSucceeded this callback is invoked when the

108

   * \param connectionSucceeded this callback is invoked when the

107

   *        connection request initiated by the user is successfully

109

   *        connection request initiated by the user is successfully

108

   *        completed. The callback is passed  back a pointer to

110

   *        completed. The callback is passed  back a pointer to

Lines 114-119 public:	Link Here

114

*/

116

*/

115

  void SetConnectCallback (Callback<void, Ptr<Socket> > connectionSucceeded,

117

  void SetConnectCallback (Callback<void, Ptr<Socket> > connectionSucceeded,

116

                           Callback<void,  Ptr<Socket> > connectionFailed);

118

                           Callback<void,  Ptr<Socket> > connectionFailed);

119

/**

120

  * \brief Detect socket recv() events such as graceful shutdown or error.

121

122

  * For connection-oriented sockets, the first callback is used to signal

123

  * that the remote side has gracefully shut down the connection, and the

124

  * second callback denotes an error corresponding to cases in which

125

  * a traditional recv() socket call might return -1 (error), such

126

  * as a connection reset.  For datagram sockets, these callbacks may

127

  * never be invoked.

128

129

  * \param normalClose this callback is invoked when the

130

  *        peer closes the connection gracefully

131

  * \param errorClose this callback is invoked when the

132

  *        connection closes abnormally

133

*/

134

  void SetCloseCallbacks (Callback<void, Ptr<Socket> > normalClose,

135

                          Callback<void, Ptr<Socket> > errorClose);

117

/**

136

/**

118

   * \brief Accept connection requests from remote hosts

137

   * \brief Accept connection requests from remote hosts

119

   * \param connectionRequest Callback for connection request from peer.

138

   * \param connectionRequest Callback for connection request from peer.

Lines 496-501 protected:	Link Here

496

protected:

515

protected:

497

  void NotifyConnectionSucceeded (void);

516

  void NotifyConnectionSucceeded (void);

498

  void NotifyConnectionFailed (void);

517

  void NotifyConnectionFailed (void);

518

  void NotifyNormalClose(void);

519

  void NotifyErrorClose(void);

499

  bool NotifyConnectionRequest (const Address &from);

520

  bool NotifyConnectionRequest (const Address &from);

500

  void NotifyNewConnectionCreated (Ptr<Socket> socket, const Address &from);

521

  void NotifyNewConnectionCreated (Ptr<Socket> socket, const Address &from);

501

  void NotifyDataSent (uint32_t size);

522

  void NotifyDataSent (uint32_t size);

Lines 503-515 protected:	Link Here

503

  void NotifyDataRecv (void);

524

  void NotifyDataRecv (void);

504

  virtual void DoDispose (void);

525

  virtual void DoDispose (void);

505

private:

526

private:

506

  Callback<void, Ptr<Socket> >   m_connectionSucceeded;

527

  Callback<void, Ptr<Socket> >                   m_connectionSucceeded;

507

  Callback<void, Ptr<Socket> >   m_connectionFailed;

528

  Callback<void, Ptr<Socket> >                   m_connectionFailed;

529

  Callback<void, Ptr<Socket> >                   m_normalClose;

530

  Callback<void, Ptr<Socket> >                   m_errorClose;

508

  Callback<bool, Ptr<Socket>, const Address &>   m_connectionRequest;

531

  Callback<bool, Ptr<Socket>, const Address &>   m_connectionRequest;

509

  Callback<void, Ptr<Socket>, const Address&>    m_newConnectionCreated;

532

  Callback<void, Ptr<Socket>, const Address&>    m_newConnectionCreated;

510

  Callback<void, Ptr<Socket>, uint32_t>          m_dataSent;

533

  Callback<void, Ptr<Socket>, uint32_t>          m_dataSent;

511

  Callback<void, Ptr<Socket>, uint32_t >         m_sendCb;

534

  Callback<void, Ptr<Socket>, uint32_t >         m_sendCb;

512

  Callback<void, Ptr<Socket> > m_receivedData;

535

  Callback<void, Ptr<Socket> >                   m_receivedData;

513

536

514

};

537

};

515

538

Return to bug 424