src/ListenSocket.cpp

   1 //
   2 // This file is part of the aMule Project.
   3 //
   4 // Copyright (c) 2003-2011 aMule Team ( admin@amule.org / http://www.amule.org )
   5 // Copyright (c) 2002-2011 Merkur ( devs@emule-project.net / http://www.emule-project.net )
   6 //
   7 // Any parts of this program derived from the xMule, lMule or eMule project,
   8 // or contributed by third-party developers are copyrighted by their
   9 // respective authors.
  10 //
  11 // This program is free software; you can redistribute it and/or modify
  12 // it under the terms of the GNU General Public License as published by
  13 // the Free Software Foundation; either version 2 of the License, or
  14 // (at your option) any later version.
  15 //
  16 // This program is distributed in the hope that it will be useful,
  17 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  18 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19 // GNU General Public License for more details.
  20 //
  21 // You should have received a copy of the GNU General Public License
  22 // along with this program; if not, write to the Free Software
  23 // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301, USA
  24 //
  25
  26 #include "ListenSocket.h"       // Interface declarations
  27
  28 #include <common/EventIDs.h>
  29
  30 #include "ClientTCPSocket.h"    // Needed for CClientRequestSocket
  31 #include "Logger.h"                     // Needed for AddLogLineM
  32 #include "Statistics.h"         // Needed for theStats
  33 #include "Preferences.h"        // Needed for CPreferences
  34 #include "amule.h"              // Needed for theApp
  35 #include "ServerConnect.h"      // Needed for CServerConnect
  36
  37 //-----------------------------------------------------------------------------
  38 // CListenSocket
  39 //-----------------------------------------------------------------------------
  40 //
  41 // This is the socket that listens to incoming connections in aMule's TCP port
  42 // As soon as a connection is detected, it creates a new socket of type
  43 // CClientTCPSocket to handle (accept) the connection.
  44 //
  45
  46 CListenSocket::CListenSocket(amuleIPV4Address &addr, const CProxyData *ProxyData)
  47 :
  48 // wxSOCKET_NOWAIT    - means non-blocking i/o
  49 // wxSOCKET_REUSEADDR - means we can reuse the socket immediately (wx-2.5.3)
  50 CSocketServerProxy(addr, MULE_SOCKET_NOWAIT|MULE_SOCKET_REUSEADDR, ProxyData)
  51 {
  52         // 0.42e - vars not used by us
  53         m_pending = false;
  54         shutdown = false;
  55         m_OpenSocketsInterval = 0;
  56         totalconnectionchecks = 0;
  57         averageconnections = 0.0;
  58         memset(m_ConnectionStates, 0, 3 * sizeof(m_ConnectionStates[0]));
  59         // Set the listen socket event handler -- The handler is written in amule.cpp
  60         if (IsOk()) {
  61                 SetEventHandler(*theApp, ID_LISTENSOCKET_EVENT);
  62                 SetNotify(wxSOCKET_CONNECTION_FLAG);
  63                 Notify(true);
  64
  65                 AddLogLineNS(_("ListenSocket: Ok."));
  66         } else {
  67                 AddLogLineCS(_("ERROR: Could not listen to TCP port.") );
  68         }
  69 }
  70
  71
  72 CListenSocket::~CListenSocket()
  73 {
  74         shutdown = true;
  75         Discard();
  76         Close();
  77
  78 #ifdef __DEBUG__
  79         // No new sockets should have been opened by now
  80         for (SocketSet::iterator it = socket_list.begin(); it != socket_list.end(); ++it) {
  81                 wxASSERT((*it)->IsDestroying());
  82         }
  83 #endif
  84
  85         KillAllSockets();
  86 }
  87
  88
  89 void CListenSocket::OnAccept()
  90 {
  91         m_pending = theApp->IsRunning();        // just do nothing if we are shutting down
  92         // If the client is still at maxconnections,
  93         // this will allow it to go above it ...
  94         // But if you don't, you will get a lowID on all servers.
  95         while (m_pending && (theApp->serverconnect->IsConnecting() || !TooManySockets())) {
  96                 if (!SocketAvailable()) {
  97                         m_pending = false;
  98                 } else {
  99                         // Create a new socket to deal with the connection
 100                         CClientTCPSocket* newclient = new CClientTCPSocket();
 101                         // Accept the connection and give it to the newly created socket
 102                         if (!AcceptWith(*newclient, false)) {
 103                                 newclient->Safe_Delete();
 104                                 m_pending = false;
 105                         } else {
 106                                 if (!newclient->InitNetworkData()) {
 107                                         // IP or port were not returned correctly
 108                                         // from the accepted address, or filtered.
 109                                         newclient->Safe_Delete();
 110                                 }
 111                         }
 112                 }
 113         }
 114         if (m_pending) {
 115                 theStats::AddMaxConnectionLimitReached();
 116         }
 117 }
 118
 119 void CListenSocket::AddConnection()
 120 {
 121         m_OpenSocketsInterval++;
 122 }
 123
 124 void CListenSocket::Process()
 125 {
 126         // 042e + Kry changes for Destroy
 127         m_OpenSocketsInterval = 0;
 128         SocketSet::iterator it = socket_list.begin();
 129         while ( it != socket_list.end() ) {
 130                 CClientTCPSocket* cur_socket = *it++;
 131                 if (!cur_socket->IsDestroying()) {
 132                         cur_socket->CheckTimeOut();
 133                 }
 134         }
 135
 136         if (m_pending) {
 137                 OnAccept();
 138         }
 139 }
 140
 141 void CListenSocket::RecalculateStats()
 142 {
 143         // 0.42e
 144         memset(m_ConnectionStates, 0, 3 * sizeof(m_ConnectionStates[0]));
 145         for (SocketSet::iterator it = socket_list.begin(); it != socket_list.end(); ) {
 146                 CClientTCPSocket* cur_socket = *it++;
 147                 switch (cur_socket->GetConState()) {
 148                         case ES_DISCONNECTED:
 149                                 m_ConnectionStates[0]++;
 150                                 break;
 151                         case ES_NOTCONNECTED:
 152                                 m_ConnectionStates[1]++;
 153                                 break;
 154                         case ES_CONNECTED:
 155                                 m_ConnectionStates[2]++;
 156                                 break;
 157                 }
 158         }
 159 }
 160
 161 void CListenSocket::AddSocket(CClientTCPSocket* toadd)
 162 {
 163         wxASSERT(toadd);
 164         socket_list.insert(toadd);
 165         theStats::AddActiveConnection();
 166 }
 167
 168 void CListenSocket::RemoveSocket(CClientTCPSocket* todel)
 169 {
 170         wxASSERT(todel);
 171         socket_list.erase(todel);
 172         theStats::RemoveActiveConnection();
 173 }
 174
 175 void CListenSocket::KillAllSockets()
 176 {
 177         // 0.42e reviewed - they use delete, but our safer is Destroy...
 178         // But I bet it would be better to call Safe_Delete on the socket.
 179         // Update: no... Safe_Delete MARKS for deletion. We need to delete it.
 180         for (SocketSet::iterator it = socket_list.begin(); it != socket_list.end(); ) {
 181                 CClientTCPSocket* cur_socket = *it++;
 182                 if (cur_socket->GetClient()) {
 183                         cur_socket->Safe_Delete_Client();
 184                 } else {
 185                         cur_socket->Safe_Delete();
 186                         cur_socket->Destroy();
 187                 }
 188         }
 189 }
 190
 191 bool CListenSocket::TooManySockets(bool bIgnoreInterval)
 192 {
 193         if (GetOpenSockets() > thePrefs::GetMaxConnections()
 194                 || (!bIgnoreInterval && m_OpenSocketsInterval > (thePrefs::GetMaxConperFive() * GetMaxConperFiveModifier()))) {
 195                 return true;
 196         } else {
 197                 return false;
 198         }
 199 }
 200
 201 bool CListenSocket::IsValidSocket(CClientTCPSocket* totest)
 202 {
 203         // 0.42e
 204         return socket_list.find(totest) != socket_list.end();
 205 }
 206
 207
 208 void CListenSocket::UpdateConnectionsStatus()
 209 {
 210         // 0.42e xcept for the khaos stats
 211         if( theApp->IsConnected() ) {
 212                 totalconnectionchecks++;
 213                 float percent;
 214                 percent = (float)(totalconnectionchecks-1)/(float)totalconnectionchecks;
 215                 if( percent > .99f ) {
 216                         percent = .99f;
 217                 }
 218                 averageconnections = (averageconnections*percent) + (float)GetOpenSockets()*(1.0f-percent);
 219         }
 220 }
 221
 222
 223 float CListenSocket::GetMaxConperFiveModifier()
 224 {
 225         float SpikeSize = GetOpenSockets() - averageconnections;
 226         if ( SpikeSize < 1 ) {
 227                 return 1;
 228         }
 229
 230         float SpikeTolerance = 2.5f * thePrefs::GetMaxConperFive();
 231         if ( SpikeSize > SpikeTolerance ) {
 232                 return 0;
 233         }
 234
 235         return 1.0f - (SpikeSize/SpikeTolerance);
 236 }
 237 // File_checked_for_headers