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