src/ClientList.h

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