src/ClientList.h

   1 //
   2 // This file is part of the aMule Project.
   3 //
   4 // Copyright (c) 2003-2008 aMule Team ( admin@amule.org / http://www.amule.org )
   5 // Copyright (c) 2002-2008 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 #ifndef CLIENTLIST_H
  27 #define CLIENTLIST_H
  28
  29 #include "DeadSourceList.h"     // Needed for CDeadSourceList
  30
  31 #include <deque>
  32 #include <set>
  33
  34 class CUpDownClient;
  35 class CClientTCPSocket;
  36 class CDeletedClient;
  37 class CMD4Hash;
  38 namespace Kademlia {
  39         class CContact;
  40         class CUInt128;
  41 }
  42
  43 enum buddyState
  44 {
  45         Disconnected,
  46         Connecting,
  47         Connected
  48 };
  49
  50
  51 #define BAN_CLEANUP_TIME        1200000 // 20 min
  52
  53
  54 /**
  55  * This class takes care of managing existing clients.
  56  *
  57  * This class tracks a number of attributes related to existing and deleted
  58  * clients. Among other things, it keeps track of existing, banned, dead and
  59  * dying clients, as well as offers support for matching new client-instances
  60  * against already exist clients to avoid duplicates.
  61  */
  62 class CClientList
  63 {
  64 public:
  65         /**
  66          * Constructor.
  67          */
  68         CClientList();
  69
  70         /**
  71          * Destructor.
  72          */
  73         ~CClientList();
  74
  75
  76         /**
  77          * Adds a client to the global list of clients.
  78          *
  79          * @param toadd The new client.
  80          */
  81         void    AddClient( CUpDownClient* toadd );
  82
  83         /**
  84          * Schedules a client for deletion.
  85          *
  86          * @param client The client to be deleted.
  87          *
  88          * Call this function whenever a client is to be deleted, rather than
  89          * directly deleting the client. If the client is on the global client-
  90          * list, then it will be scheduled for deletion, otherwise it will be
  91          * deleted immediatly. Please check CUpDownClient::Safe_Delete for the
  92          * proper way to do this.
  93          */
  94         void    AddToDeleteQueue( CUpDownClient* client );
  95
  96
  97         /**
  98          * Updates the recorded IP of the specified client.
  99          *
 100          * @param client The client to have its entry updated.
 101          * @param newIP The new IP adress of the client.
 102          *
 103          * This function is to be called before the client actually changes its
 104          * IP-address, and will update the old entry with the new value. There
 105          * will only be added an entry if the new IP isn't zero.
 106          */
 107         void    UpdateClientIP( CUpDownClient* client, uint32 newIP );
 108
 109         /**
 110          * Updates the recorded ID of the specified client.
 111          *
 112          * @param client The client to have its entry updated.
 113          * @param newID The new ID of the client.
 114          *
 115          * This function is to be called before the client actually changes its
 116          * ID, and will update the old entry with the new value. Unlike the other
 117          * two functions, this function will always ensure that there is an entry
 118          * for the client, regardless of the value of newID.
 119          */
 120         void    UpdateClientID( CUpDownClient* client, uint32 newID );
 121
 122         /**
 123          * Updates the recorded hash of the specified client.
 124          *
 125          * @param client The client to have its entry updated.
 126          * @param newHash The new user-hash.
 127          *
 128          * This function is to be called before the client actually changes its
 129          * user-hash, and will update the old entry with the new value. There will
 130          * only be added an entry if the new hash is valid.
 131          */
 132         void    UpdateClientHash( CUpDownClient* client, const CMD4Hash& newHash );
 133
 134
 135         /**
 136          * Returns the number of listed clients.
 137          */
 138         uint32  GetClientCount() const;
 139
 140
 141         /**
 142          * Deletes all tracked clients.
 143          */
 144         void    DeleteAll();
 145
 146
 147         /**
 148          * Replaces a new client-instance with the an already existing client, if one such exist.
 149          *
 150          * @param client A pointer to the pointer of the new instance.
 151          * @param sender The socket assosiated with the new instance.
 152          *
 153          * Call this function when a new client-instance has been created. This function will then
 154          * compare it against all existing clients and see if we already have an instance matching
 155          * the new one. If that is the case, it will delete the new instance and set the pointer to
 156          * the existing one.
 157          */
 158         bool    AttachToAlreadyKnown( CUpDownClient** client, CClientTCPSocket* sender );
 159
 160
 161         /**
 162          * Finds a client with the specified ip and port.
 163          *
 164          * @param clientip The IP of the client to find.
 165          * @param port The port used by the client.
 166          */
 167         CUpDownClient* FindClientByIP( uint32 clientip, uint16 port );
 168
 169
 170         //! The list-type used to store clients IPs and other information
 171         typedef std::map<uint32, uint32> ClientMap;
 172
 173
 174         /**
 175          * Adds a client to the list of tracked clients.
 176          *
 177          * @param toadd The client to track.
 178          *
 179          * This function is used to keep track of clients after they
 180          * have been deleted and makes it possible to spot port or hash
 181          * changes.
 182          */
 183         void    AddTrackClient(CUpDownClient* toadd);
 184
 185         /**
 186          * Returns the number of tracked client.
 187          *
 188          * @param dwIP The IP-adress which of the clients.
 189          * @return The number of clients tracked at the specifed IP.
 190          */
 191         uint16  GetClientsFromIP(uint32 dwIP);
 192
 193         /**
 194          * Checks if a client has changed its user-hash.
 195          *
 196          * @param dwIP The IP of the client.
 197          * @param nPort The port of the client.
 198          * @param pNewHash The userhash assosiated with the client.
 199          *
 200          */
 201         bool    ComparePriorUserhash( uint32 dwIP, uint16 nPort, void* pNewHash );
 202
 203
 204         /**
 205          * Bans an IP address for 2 hours.
 206          *
 207          * @param dwIP The IP from which all clients will be banned.
 208          */
 209         void    AddBannedClient(uint32 dwIP);
 210
 211         /**
 212          * Checks if a client has been banned.
 213          *
 214          * @param dwIP The IP to check.
 215          * @return True if the IP is banned, false otherwise.
 216          */
 217         bool    IsBannedClient(uint32 dwIP);
 218
 219         /**
 220          * Unbans an IP address, if it has been banned.
 221          *
 222          * @param dwIP The IP address to unban.
 223          */
 224         void    RemoveBannedClient(uint32 dwIP);
 225
 226
 227         /**
 228          * Main loop.
 229          *
 230          * This function takes care of cleaning the various lists and deleting
 231          * pending clients on the deletion-queue.
 232          */
 233         void    Process();
 234
 235
 236         /**
 237          * Deletes clients previously queued for deletion
 238          *
 239          * This function takes care of deleting pending clients on the
 240          * deletion-queue.
 241          */
 242         void    ProcessDeleteQueue();
 243
 244
 245         /**
 246          * This function removes all clients filtered by the current IPFilter.
 247          *
 248          * Call this function after changing the current IPFiler list, to ensure
 249          * that no client-connections to illegal IPs exist. These would otherwise
 250          * be allowed to exist, bypassing the IPFilter.
 251          */
 252         void    FilterQueues();
 253
 254
 255         //! The type of the list used to store client-pointers for a couple of tasks.
 256         typedef std::deque<CUpDownClient*> SourceList;
 257
 258
 259         /**
 260          * Returns a list of clients with the specified user-hash.
 261          *
 262          * @param hash The userhash to search for.
 263          *
 264          * This function will return a list of clients with the specified userhash,
 265          * provided that the hash is a valid non-empty userhash. Empty hashes will
 266          * simply result in nothing being found.
 267          */
 268         SourceList      GetClientsByHash( const CMD4Hash& hash );
 269
 270         /**
 271          * Returns a list of clients with the specified IP.
 272          *
 273          * @param ip The IP-address to search for.
 274          *
 275          * This function will return a list of clients with the specified IP,
 276          * provided that the IP is a non-zero value. A value of zero will not
 277          * result in any results.
 278          */
 279         SourceList      GetClientsByIP( unsigned long ip );
 280
 281
 282         //! The type of the lists used to store IPs and IDs.
 283         typedef std::multimap<uint32, CUpDownClient*> IDMap;
 284         //! The pairs of the IP/ID list.
 285         typedef std::pair<uint32, CUpDownClient*> IDMapPair;
 286
 287
 288         /**
 289          * Returns a list of all clients.
 290          *
 291          * @return The complete list of clients.
 292          */
 293         const IDMap& GetClientList();
 294
 295
 296         /**
 297          * Adds a source to the list of dead sources.
 298          *
 299          * @param client The source to be recorded as dead.
 300          */
 301         void            AddDeadSource(const CUpDownClient* client);
 302
 303         /**
 304          * Checks if a source is recorded as being dead.
 305          *
 306          * @param client The client to evaluate.
 307          * @return True if dead, false otherwise.
 308          *
 309          * Sources that are dead are not to be considered valid
 310          * sources and should not be added to partfiles.
 311          */
 312         bool            IsDeadSource(const CUpDownClient* client);
 313
 314         /**
 315          * Sends a message to a client, identified by a GUI_ID
 316          *
 317          * @return Success
 318          */
 319          bool   SendMessage(uint64 client_id, const wxString& message);
 320
 321         /**
 322          * Stops a chat session with a client.
 323          *
 324          */
 325          void   SetChatState(uint64 client_id, uint8 state);
 326
 327         uint8   GetBuddyStatus() const {return m_nBuddyStatus;}
 328         // This must be used on CreateKadSourceLink and if we ever add the columns
 329         // on shared files control.
 330         CUpDownClient* GetBuddy() const { return m_pBuddy; }
 331         bool RequestTCP(Kademlia::CContact* contact, uint8_t connectOptions);
 332         void RequestBuddy(Kademlia::CContact* contact, uint8_t connectOptions);
 333         bool IncomingBuddy(Kademlia::CContact* contact, Kademlia::CUInt128* buddyID);
 334         void RemoveFromKadList(CUpDownClient* torem);
 335         void AddToKadList(CUpDownClient* toadd);
 336         bool DoRequestFirewallCheckUDP(const Kademlia::CContact& contact);
 337
 338         void AddKadFirewallRequest(uint32 ip);
 339         bool IsKadFirewallCheckIP(uint32 ip) const;
 340
 341         // Direct Callback list
 342         void    AddDirectCallbackClient(CUpDownClient *toAdd);
 343         void    RemoveDirectCallback(CUpDownClient *toRemove) { m_currentDirectCallbacks.remove(toRemove); }
 344         void    AddTrackCallbackRequests(uint32_t ip);
 345         bool    AllowCallbackRequest(uint32_t ip) const;
 346
 347 protected:
 348         /*
 349          * Avoids unwanted clients to be forever in the client list
 350          */
 351         void    CleanUpClientList();
 352
 353         void    ProcessDirectCallbackList();
 354
 355 private:
 356         /**
 357          * Helperfunction which finds a client matching the specified client.
 358          *
 359          * @param client The client to search for.
 360          * @return The matching client or NULL.
 361          *
 362          * This functions searches through the list of clients and finds the first match
 363          * using the same checks as CUpDownClient::Compare, but without the overhead.
 364          */
 365         CUpDownClient* FindMatchingClient( CUpDownClient* client );
 366
 367
 368         /**
 369          * Check if we already know this IP.
 370          *
 371          * This function is used to determine if the given IP address
 372          * is already known.
 373          *
 374          * @param ip The IP address to check.
 375          */
 376         bool IsIPAlreadyKnown(uint32_t ip);
 377
 378
 379         /**
 380          * Helperfunction which removes the client from the IP-list.
 381          */
 382         void    RemoveIPFromList( CUpDownClient* client );
 383         /**
 384          * Helperfunction which removes the client from the ID-list.
 385          */
 386         bool    RemoveIDFromList( CUpDownClient* client );
 387         /**
 388          * Helperfunction which removes the client from the hash-list.
 389          */
 390         void    RemoveHashFromList( CUpDownClient* client );
 391
 392
 393         //! The type of the list used to store user-hashes.
 394         typedef std::multimap<CMD4Hash, CUpDownClient*> HashMap;
 395         //! The pairs of the Hash-list.
 396         typedef std::pair<CMD4Hash, CUpDownClient*> HashMapPair;
 397
 398
 399         //! The map of clients with valid hashes
 400         HashMap m_hashList;
 401
 402         //! The map of clients with valid IPs
 403         IDMap   m_ipList;
 404
 405         //! The full lists of clients
 406         IDMap   m_clientList;
 407
 408         //! This is the lists of clients that should be deleted
 409         SourceList m_delete_queue;
 410 #ifdef __WXDEBUG__
 411         bool m_delete_queue_closed;
 412 #endif
 413
 414         //! This is the map of banned clients.
 415         ClientMap m_bannedList;
 416         //! This variable is used to keep track of the last time the banned-list was pruned.
 417         uint32  m_dwLastBannCleanUp;
 418
 419         //! This is the map of tracked clients.
 420         std::map<uint32, CDeletedClient*> m_trackedClientsList;
 421         //! This keeps track of the last time the tracked-list was pruned.
 422         uint32  m_dwLastTrackedCleanUp;
 423
 424         //! This keeps track of the last time the client-list was pruned.
 425         uint32 m_dwLastClientCleanUp;
 426
 427         //! List of unusable sources.
 428         CDeadSourceList m_deadSources;
 429
 430         /* Kad Stuff */
 431         std::set<CUpDownClient*>        m_KadSources;
 432         CUpDownClient* m_pBuddy;
 433         uint8 m_nBuddyStatus;
 434
 435         typedef struct {
 436                 uint32 ip;
 437                 uint32 inserted;
 438         } IpAndTicks;
 439         typedef std::list<IpAndTicks>   IpAndTicksList;
 440         IpAndTicksList                  m_firewallCheckRequests;
 441
 442         typedef std::list<CUpDownClient *>      DirectCallbackList;
 443         DirectCallbackList              m_currentDirectCallbacks;
 444         IpAndTicksList                  m_directCallbackRequests;
 445 };
 446
 447 #endif
 448 // File_checked_for_headers