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         /**
 171          * Finds a client with the specified ip.
 172          *
 173          * @param clientip The IP of the client to find.
 174          *
 175          * Returns the first client found if there are several with same ip.
 176          */
 177         CUpDownClient* FindClientByIP( uint32 clientip );
 178
 179
 180         //! The list-type used to store clients IPs and other information
 181         typedef std::map<uint32, uint32> ClientMap;
 182
 183
 184         /**
 185          * Adds a client to the list of tracked clients.
 186          *
 187          * @param toadd The client to track.
 188          *
 189          * This function is used to keep track of clients after they
 190          * have been deleted and makes it possible to spot port or hash
 191          * changes.
 192          */
 193         void    AddTrackClient(CUpDownClient* toadd);
 194
 195         /**
 196          * Returns the number of tracked client.
 197          *
 198          * @param dwIP The IP-adress which of the clients.
 199          * @return The number of clients tracked at the specifed IP.
 200          */
 201         uint16  GetClientsFromIP(uint32 dwIP);
 202
 203         /**
 204          * Checks if a client has changed its user-hash.
 205          *
 206          * @param dwIP The IP of the client.
 207          * @param nPort The port of the client.
 208          * @param pNewHash The userhash assosiated with the client.
 209          *
 210          */
 211         bool    ComparePriorUserhash( uint32 dwIP, uint16 nPort, void* pNewHash );
 212
 213
 214         /**
 215          * Bans an IP address for 2 hours.
 216          *
 217          * @param dwIP The IP from which all clients will be banned.
 218          */
 219         void    AddBannedClient(uint32 dwIP);
 220
 221         /**
 222          * Checks if a client has been banned.
 223          *
 224          * @param dwIP The IP to check.
 225          * @return True if the IP is banned, false otherwise.
 226          */
 227         bool    IsBannedClient(uint32 dwIP);
 228
 229         /**
 230          * Unbans an IP address, if it has been banned.
 231          *
 232          * @param dwIP The IP address to unban.
 233          */
 234         void    RemoveBannedClient(uint32 dwIP);
 235
 236
 237         /**
 238          * Main loop.
 239          *
 240          * This function takes care of cleaning the various lists and deleting
 241          * pending clients on the deletion-queue.
 242          */
 243         void    Process();
 244
 245
 246         /**
 247          * Deletes clients previously queued for deletion
 248          *
 249          * This function takes care of deleting pending clients on the
 250          * deletion-queue.
 251          */
 252         void    ProcessDeleteQueue();
 253
 254
 255         /**
 256          * This function removes all clients filtered by the current IPFilter.
 257          *
 258          * Call this function after changing the current IPFiler list, to ensure
 259          * that no client-connections to illegal IPs exist. These would otherwise
 260          * be allowed to exist, bypassing the IPFilter.
 261          */
 262         void    FilterQueues();
 263
 264
 265         //! The type of the list used to store client-pointers for a couple of tasks.
 266         typedef std::deque<CUpDownClient*> SourceList;
 267
 268
 269         /**
 270          * Returns a list of clients with the specified user-hash.
 271          *
 272          * @param hash The userhash to search for.
 273          *
 274          * This function will return a list of clients with the specified userhash,
 275          * provided that the hash is a valid non-empty userhash. Empty hashes will
 276          * simply result in nothing being found.
 277          */
 278         SourceList      GetClientsByHash( const CMD4Hash& hash );
 279
 280         /**
 281          * Returns a list of clients with the specified IP.
 282          *
 283          * @param ip The IP-address to search for.
 284          *
 285          * This function will return a list of clients with the specified IP,
 286          * provided that the IP is a non-zero value. A value of zero will not
 287          * result in any results.
 288          */
 289         SourceList      GetClientsByIP( unsigned long ip );
 290
 291
 292         //! The type of the lists used to store IPs and IDs.
 293         typedef std::multimap<uint32, CUpDownClient*> IDMap;
 294         //! The pairs of the IP/ID list.
 295         typedef std::pair<uint32, CUpDownClient*> IDMapPair;
 296
 297
 298         /**
 299          * Returns a list of all clients.
 300          *
 301          * @return The complete list of clients.
 302          */
 303         const IDMap& GetClientList();
 304
 305
 306         /**
 307          * Adds a source to the list of dead sources.
 308          *
 309          * @param client The source to be recorded as dead.
 310          */
 311         void            AddDeadSource(const CUpDownClient* client);
 312
 313         /**
 314          * Checks if a source is recorded as being dead.
 315          *
 316          * @param client The client to evaluate.
 317          * @return True if dead, false otherwise.
 318          *
 319          * Sources that are dead are not to be considered valid
 320          * sources and should not be added to partfiles.
 321          */
 322         bool            IsDeadSource(const CUpDownClient* client);
 323
 324         /**
 325          * Sends a message to a client, identified by a GUI_ID
 326          *
 327          * @return Success
 328          */
 329          bool   SendChatMessage(uint64 client_id, const wxString& message);
 330
 331         /**
 332          * Stops a chat session with a client.
 333          *
 334          */
 335          void   SetChatState(uint64 client_id, uint8 state);
 336
 337         uint8   GetBuddyStatus() const {return m_nBuddyStatus;}
 338         // This must be used on CreateKadSourceLink and if we ever add the columns
 339         // on shared files control.
 340         CUpDownClient* GetBuddy() const { return m_pBuddy; }
 341         bool RequestTCP(Kademlia::CContact* contact, uint8_t connectOptions);
 342         void RequestBuddy(Kademlia::CContact* contact, uint8_t connectOptions);
 343         bool IncomingBuddy(Kademlia::CContact* contact, Kademlia::CUInt128* buddyID);
 344         void RemoveFromKadList(CUpDownClient* torem);
 345         void AddToKadList(CUpDownClient* toadd);
 346         bool DoRequestFirewallCheckUDP(const Kademlia::CContact& contact);
 347
 348         void AddKadFirewallRequest(uint32 ip);
 349         bool IsKadFirewallCheckIP(uint32 ip) const;
 350
 351         // Direct Callback list
 352         void    AddDirectCallbackClient(CUpDownClient *toAdd);
 353         void    RemoveDirectCallback(CUpDownClient *toRemove) { m_currentDirectCallbacks.remove(toRemove); }
 354         void    AddTrackCallbackRequests(uint32_t ip);
 355         bool    AllowCallbackRequest(uint32_t ip) const;
 356
 357 protected:
 358         /*
 359          * Avoids unwanted clients to be forever in the client list
 360          */
 361         void    CleanUpClientList();
 362
 363         void    ProcessDirectCallbackList();
 364
 365 private:
 366         /**
 367          * Helperfunction which finds a client matching the specified client.
 368          *
 369          * @param client The client to search for.
 370          * @return The matching client or NULL.
 371          *
 372          * This functions searches through the list of clients and finds the first match
 373          * using the same checks as CUpDownClient::Compare, but without the overhead.
 374          */
 375         CUpDownClient* FindMatchingClient( CUpDownClient* client );
 376
 377
 378         /**
 379          * Check if we already know this IP.
 380          *
 381          * This function is used to determine if the given IP address
 382          * is already known.
 383          *
 384          * @param ip The IP address to check.
 385          */
 386         bool IsIPAlreadyKnown(uint32_t ip);
 387
 388
 389         /**
 390          * Helperfunction which removes the client from the IP-list.
 391          */
 392         void    RemoveIPFromList( CUpDownClient* client );
 393         /**
 394          * Helperfunction which removes the client from the ID-list.
 395          */
 396         bool    RemoveIDFromList( CUpDownClient* client );
 397         /**
 398          * Helperfunction which removes the client from the hash-list.
 399          */
 400         void    RemoveHashFromList( CUpDownClient* client );
 401
 402
 403         //! The type of the list used to store user-hashes.
 404         typedef std::multimap<CMD4Hash, CUpDownClient*> HashMap;
 405         //! The pairs of the Hash-list.
 406         typedef std::pair<CMD4Hash, CUpDownClient*> HashMapPair;
 407
 408
 409         //! The map of clients with valid hashes
 410         HashMap m_hashList;
 411
 412         //! The map of clients with valid IPs
 413         IDMap   m_ipList;
 414
 415         //! The full lists of clients
 416         IDMap   m_clientList;
 417
 418         //! This is the lists of clients that should be deleted
 419         SourceList m_delete_queue;
 420 #ifdef __WXDEBUG__
 421         bool m_delete_queue_closed;
 422 #endif
 423
 424         //! This is the map of banned clients.
 425         ClientMap m_bannedList;
 426         //! This variable is used to keep track of the last time the banned-list was pruned.
 427         uint32  m_dwLastBannCleanUp;
 428
 429         //! This is the map of tracked clients.
 430         std::map<uint32, CDeletedClient*> m_trackedClientsList;
 431         //! This keeps track of the last time the tracked-list was pruned.
 432         uint32  m_dwLastTrackedCleanUp;
 433
 434         //! This keeps track of the last time the client-list was pruned.
 435         uint32 m_dwLastClientCleanUp;
 436
 437         //! List of unusable sources.
 438         CDeadSourceList m_deadSources;
 439
 440         /* Kad Stuff */
 441         std::set<CUpDownClient*>        m_KadSources;
 442         CUpDownClient* m_pBuddy;
 443         uint8 m_nBuddyStatus;
 444
 445         typedef struct {
 446                 uint32 ip;
 447                 uint32 inserted;
 448         } IpAndTicks;
 449         typedef std::list<IpAndTicks>   IpAndTicksList;
 450         IpAndTicksList                  m_firewallCheckRequests;
 451
 452         typedef std::list<CUpDownClient *>      DirectCallbackList;
 453         DirectCallbackList              m_currentDirectCallbacks;
 454         IpAndTicksList                  m_directCallbackRequests;
 455 };
 456
 457 #endif
 458 // File_checked_for_headers