src/updownclient.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 UPDOWNCLIENT_H
  27 #define UPDOWNCLIENT_H
  28
  29 #include "GetTickCount.h"       // Needed for GetTickCount
  30 #include "MD4Hash.h"
  31 #include <common/StringFunctions.h>
  32 #include "NetworkFunctions.h"
  33 #include "OtherStructs.h"
  34
  35 #include <map>
  36
  37
  38 typedef std::vector<bool> BitVector;
  39
  40 class CPartFile;
  41 class CClientTCPSocket;
  42 class CClientCredits;
  43 class CPacket;
  44 class CFriend;
  45 class CKnownFile;
  46 class CMemFile;
  47 class CAICHHash;
  48
  49
  50 // uploadstate
  51 #define US_UPLOADING            0
  52 #define US_ONUPLOADQUEUE        1
  53 #define US_WAITCALLBACK         2
  54 #define US_CONNECTING           3
  55 #define US_PENDING              4
  56 #define US_LOWTOLOWIP           5
  57 #define US_BANNED               6
  58 #define US_ERROR                7
  59 #define US_NONE                 8
  60
  61 // downloadstate
  62 enum EDownloadState {
  63         DS_DOWNLOADING = 0,
  64         DS_ONQUEUE,
  65         DS_CONNECTED,
  66         DS_CONNECTING,
  67         DS_WAITCALLBACK,
  68         DS_WAITCALLBACKKAD,
  69         DS_REQHASHSET,
  70         DS_NONEEDEDPARTS,
  71         DS_TOOMANYCONNS,
  72         DS_TOOMANYCONNSKAD,
  73         DS_LOWTOLOWIP,
  74         DS_BANNED,
  75         DS_ERROR,
  76         DS_NONE,
  77         DS_REMOTEQUEUEFULL  // not used yet, except in statistics
  78 };
  79
  80 // m_byChatstate
  81 enum {
  82         MS_NONE = 0,
  83         MS_CHATTING,
  84         MS_CONNECTING,
  85         MS_UNABLETOCONNECT
  86 };
  87
  88 enum ESourceFrom {
  89         SF_NONE,
  90         SF_LOCAL_SERVER,
  91         SF_REMOTE_SERVER,
  92         SF_KADEMLIA,
  93         SF_SOURCE_EXCHANGE,
  94         SF_PASSIVE,
  95         SF_LINK,
  96         SF_SOURCE_SEEDS,
  97         SF_SEARCH_RESULT
  98 };
  99
 100 enum ESecureIdentState{
 101         IS_UNAVAILABLE          = 0,
 102         IS_ALLREQUESTSSEND      = 0,
 103         IS_SIGNATURENEEDED      = 1,
 104         IS_KEYANDSIGNEEDED      = 2
 105 };
 106
 107 enum EInfoPacketState{
 108         IP_NONE                 = 0,
 109         IP_EDONKEYPROTPACK      = 1,
 110         IP_EMULEPROTPACK        = 2,
 111         IP_BOTH                 = 3
 112 };
 113
 114 enum EKadState{
 115         KS_NONE,
 116         KS_QUEUED_FWCHECK,
 117         KS_CONNECTING_FWCHECK,
 118         KS_CONNECTED_FWCHECK,
 119         KS_QUEUED_BUDDY,
 120         KS_INCOMING_BUDDY,
 121         KS_CONNECTING_BUDDY,
 122         KS_CONNECTED_BUDDY,
 123         KS_QUEUED_FWCHECK_UDP,
 124         KS_FWCHECK_UDP,
 125         KS_CONNECTING_FWCHECK_UDP
 126 };
 127
 128 //! Used to keep track of the state of the client
 129 enum ClientState
 130 {
 131         //! New is for clients that have just been created.
 132         CS_NEW = 0,
 133         //! Listed is for clients that are on the clientlist
 134         CS_LISTED,
 135         //! Dying signifies clients that have been queued for deletion
 136         CS_DYING
 137 };
 138
 139 // This is fixed on ed2k v1, but can be any number on ED2Kv2
 140 #define STANDARD_BLOCKS_REQUEST 3
 141
 142 class CUpDownClient
 143 {
 144         friend class CClientList;
 145         friend class CUpDownClientListRem;
 146 private:
 147         /**
 148          * Please note that only the ClientList is allowed to delete the clients.
 149          * To schedule a client for deletion, call the CClientList::AddToDeleteQueue
 150          * funtion, which will safely remove dead clients once every second.
 151          */
 152         ~CUpDownClient();
 153
 154 public:
 155 #ifdef CLIENT_GUI
 156         CUpDownClient(class CEC_UpDownClient_Tag *);
 157 #else
 158         //base
 159         CUpDownClient(CClientTCPSocket* sender = 0);
 160         CUpDownClient(uint16 in_port, uint32 in_userid, uint32 in_serverup, uint16 in_serverport,CPartFile* in_reqfile, bool ed2kID, bool checkfriend);
 161 #endif
 162         /**
 163          * This function should be called when the client object is to be deleted.
 164          * It'll close the socket of the client and add it to the deletion queue
 165          * owned by the CClientList class. However, if the CUpDownClient isn't on
 166          * the normal clientlist, it will be deleted immediatly.
 167          *
 168          * The purpose of this is to avoid clients suddenly being removed due to
 169          * asyncronous events, such as socket errors, which can result in the
 170          * problems, as each CUpDownClient object is often kept in multiple lists,
 171          * and instantly removing the client poses the risk of invalidating
 172          * currently used iterators and/or creating dangling pointers.
 173          *
 174          * @see CClientList::AddToDeleteQueue
 175          * @see CClientList::Process
 176          */
 177         void            Safe_Delete();
 178
 179         /**
 180          * Specifies if the client has been queued for deletion.
 181          *
 182          * @return True if Safe_Delete has been called, false otherwise.
 183          */
 184         bool            HasBeenDeleted()                { return m_clientState == CS_DYING; }
 185
 186         ClientState     GetClientState()                { return m_clientState; }
 187
 188         bool            Disconnected(const wxString& strReason, bool bFromSocket = false);
 189         bool            TryToConnect(bool bIgnoreMaxCon = false);
 190         bool            Connect();
 191         void            ConnectionEstablished();
 192         const wxString& GetUserName() const             { return m_Username; }
 193         //Only use this when you know the real IP or when your clearing it.
 194         void            SetIP( uint32 val );
 195         uint32          GetIP() const                   { return m_dwUserIP; }
 196         bool            HasLowID() const                { return IsLowID(m_nUserIDHybrid); }
 197         wxString        GetFullIP() const               { return Uint32toStringIP(m_FullUserIP); }
 198         uint32          GetConnectIP() const            { return m_nConnectIP; }
 199         uint32          GetUserIDHybrid() const         { return m_nUserIDHybrid; }
 200         void            SetUserIDHybrid(uint32 val);
 201         uint16_t        GetUserPort() const             { return m_nUserPort; }
 202         void            SetUserPort(uint16_t port)      { m_nUserPort = port; }
 203         uint32          GetTransferredDown() const      { return m_nTransferredDown; }
 204         uint32          GetServerIP() const             { return m_dwServerIP; }
 205         void            SetServerIP(uint32 nIP)         { m_dwServerIP = nIP; }
 206         uint16          GetServerPort() const           { return m_nServerPort; }
 207         void            SetServerPort(uint16 nPort)     { m_nServerPort = nPort; }
 208         const CMD4Hash& GetUserHash() const             { return m_UserHash; }
 209         void            SetUserHash(const CMD4Hash& userhash);
 210         void            ValidateHash()                  { m_HasValidHash = !m_UserHash.IsEmpty(); }
 211         bool            HasValidHash() const            { return m_HasValidHash; }
 212         uint32          GetVersion() const              { return m_nClientVersion;}
 213         uint8           GetMuleVersion() const          { return m_byEmuleVersion;}
 214         bool            ExtProtocolAvailable() const    { return m_bEmuleProtocol;}
 215         bool            IsEmuleClient() const           { return (m_byEmuleVersion > 0);}
 216         bool            IsBanned() const;
 217         const wxString& GetClientFilename() const       { return m_clientFilename; }
 218         uint16          GetUDPPort() const              { return m_nUDPPort; }
 219         void            SetUDPPort(uint16 nPort)        { m_nUDPPort = nPort; }
 220         uint8           GetUDPVersion() const           { return m_byUDPVer; }
 221         uint8           GetExtendedRequestsVersion() const { return m_byExtendedRequestsVer; }
 222         bool            IsFriend() const                { return m_Friend != NULL; }
 223         bool            IsML() const                    { return m_bIsML; }
 224         bool            IsHybrid() const                { return m_bIsHybrid; }
 225         uint32          GetCompatibleClient() const     { return m_byCompatibleClient; }
 226
 227         void            ClearDownloadBlockRequests();
 228         void            RequestSharedFileList();
 229         void            ProcessSharedFileList(const byte* pachPacket, uint32 nSize, wxString& pszDirectory);
 230
 231         wxString        GetUploadFileInfo();
 232
 233         void            SetUserName(const wxString& NewName) { m_Username = NewName; }
 234
 235         uint8           GetClientSoft() const           { return m_clientSoft; }
 236         void            ReGetClientSoft();
 237         bool            ProcessHelloAnswer(const byte* pachPacket, uint32 nSize);
 238         bool            ProcessHelloPacket(const byte* pachPacket, uint32 nSize);
 239         void            SendHelloAnswer();
 240         bool            SendHelloPacket();
 241         void            SendMuleInfoPacket(bool bAnswer, bool OSInfo = false);
 242         bool            ProcessMuleInfoPacket(const byte* pachPacket, uint32 nSize);
 243         void            ProcessMuleCommentPacket(const byte* pachPacket, uint32 nSize);
 244         bool            Compare(const CUpDownClient* tocomp, bool bIgnoreUserhash = false) const;
 245         void            SetLastSrcReqTime()             { m_dwLastSourceRequest = ::GetTickCount(); }
 246         void            SetLastSrcAnswerTime()          { m_dwLastSourceAnswer = ::GetTickCount(); }
 247         void            SetLastAskedForSources()        { m_dwLastAskedForSources = ::GetTickCount(); }
 248         uint32          GetLastSrcReqTime() const       { return m_dwLastSourceRequest; }
 249         uint32          GetLastSrcAnswerTime() const    { return m_dwLastSourceAnswer; }
 250         uint32          GetLastAskedForSources() const  { return m_dwLastAskedForSources; }
 251         bool            GetFriendSlot() const           { return m_bFriendSlot; }
 252         void            SetFriendSlot(bool bNV)         { m_bFriendSlot = bNV; }
 253         void            SetCommentDirty(bool bDirty = true)     { m_bCommentDirty = bDirty; }
 254         uint8                   GetSourceExchange1Version() const                               { return m_bySourceExchange1Ver; }
 255         bool                    SupportsSourceExchange2() const                                 { return m_fSupportsSourceEx2; }
 256
 257         bool            SafeSendPacket(CPacket* packet);
 258
 259         void            ProcessRequestPartsPacket(const byte* pachPacket, uint32 nSize, bool largeblocks);
 260         void            ProcessRequestPartsPacketv2(const CMemFile& data);
 261
 262         void            SendPublicKeyPacket();
 263         void            SendSignaturePacket();
 264         void            ProcessPublicKeyPacket(const byte* pachPacket, uint32 nSize);
 265         void            ProcessSignaturePacket(const byte* pachPacket, uint32 nSize);
 266         uint8           GetSecureIdentState();
 267
 268         void            SendSecIdentStatePacket();
 269         void            ProcessSecIdentStatePacket(const byte* pachPacket, uint32 nSize);
 270
 271         uint8           GetInfoPacketsReceived() const  { return m_byInfopacketsReceived; }
 272         void            InfoPacketsReceived();
 273
 274         //upload
 275         uint8           GetUploadState() const          { return m_nUploadState; }
 276         void            SetUploadState(uint8 news);
 277         uint32          GetTransferredUp() const        { return m_nTransferredUp; }
 278         uint32          GetSessionUp() const            { return m_nTransferredUp - m_nCurSessionUp; }
 279         void            ResetSessionUp() {
 280                                                 m_nCurSessionUp = m_nTransferredUp;
 281                                                 m_addedPayloadQueueSession = 0;
 282                                                 m_nCurQueueSessionPayloadUp = 0;
 283                                         }
 284         uint32          GetUploadDatarate() const       { return m_nUpDatarate; }
 285
 286 #ifndef CLIENT_GUI
 287         uint32          GetWaitTime() const             { return m_dwUploadTime - GetWaitStartTime(); }
 288         uint32          GetUpStartTimeDelay() const     { return ::GetTickCount() - m_dwUploadTime; }
 289         uint32          GetWaitStartTime() const;
 290 #else
 291         uint32          m_WaitTime, m_UpStartTimeDelay, m_WaitStartTime;
 292         uint32          GetWaitTime() const             { return m_WaitTime; }
 293         uint32          GetUpStartTimeDelay() const     { return m_UpStartTimeDelay; }
 294         uint32          GetWaitStartTime() const        { return m_WaitStartTime; }
 295 #endif
 296
 297         bool            IsDownloading() const           { return (m_nUploadState == US_UPLOADING); }
 298
 299 #ifndef CLIENT_GUI
 300         uint32          GetScore(
 301                                 bool sysvalue,
 302                                 bool isdownloading = false,
 303                                 bool onlybasevalue = false) const;
 304 #else
 305         uint32          m_score;
 306         uint32          GetScore(
 307                                 bool WXUNUSED(sysvalue),
 308                                 bool WXUNUSED(isdownloading) = false,
 309                                 bool WXUNUSED(onlybasevalue) = false) const
 310         {
 311                 return m_score;
 312         }
 313         uint16          m_waitingPosition;
 314         uint16          GetWaitingPosition() const { return m_waitingPosition; }
 315 #endif
 316         double          GetRating() const
 317         {
 318                 return (double)GetScore(false, IsDownloading(), true);
 319         }
 320
 321         void            AddReqBlock(Requested_Block_Struct* reqblock);
 322         void            CreateNextBlockPackage();
 323         void            SetUpStartTime()                { m_dwUploadTime = ::GetTickCount(); }
 324         void            SetWaitStartTime();
 325         void            ClearWaitStartTime();
 326         void            SendHashsetPacket(const CMD4Hash& forfileid);
 327         bool            SupportMultiPacket() const      { return m_bMultiPacket; }
 328         bool            SupportExtMultiPacket() const   { return m_fExtMultiPacket; }
 329
 330         void            SetUploadFileID(CKnownFile *newreqfile);
 331
 332         /**
 333          *Gets the file actually on upload
 334          *
 335          */
 336         const CKnownFile* GetUploadFile() const         { return m_uploadingfile; }
 337
 338         void            SendOutOfPartReqsAndAddToWaitingQueue();
 339         void            ProcessExtendedInfo(const CMemFile *data, CKnownFile *tempreqfile);
 340         void            ProcessFileInfo(const CMemFile* data, const CPartFile* file);
 341         void            ProcessFileStatus(bool bUdpPacket, const CMemFile* data, const CPartFile* file);
 342
 343         const CMD4Hash& GetUploadFileID() const         { return m_requpfileid; }
 344         void            SetUploadFileID(const CMD4Hash& new_id);
 345         void            ClearUploadFileID()             { m_requpfileid.Clear(); m_uploadingfile = NULL;};
 346         uint32          SendBlockData();
 347         void            ClearUploadBlockRequests();
 348         void            SendRankingInfo();
 349         void            SendCommentInfo(CKnownFile *file);
 350         bool            IsDifferentPartBlock() const;
 351         void            UnBan();
 352         void            Ban();
 353         bool            m_bAddNextConnect;      // VQB Fix for LowID slots only on connection
 354         uint32          GetAskedCount() const           { return m_cAsked; }
 355         void            AddAskedCount()                 { m_cAsked++; }
 356         void            ClearAskedCount()               { m_cAsked = 1; }       // 1, because it's cleared *after* the first request...
 357         void            FlushSendBlocks();      // call this when you stop upload,
 358                                                 // or the socket might be not able to send
 359         void            SetLastUpRequest()              { m_dwLastUpRequest = ::GetTickCount(); }
 360         uint32          GetLastUpRequest() const        { return m_dwLastUpRequest; }
 361         size_t          GetUpPartCount() const          { return m_upPartStatus.size(); }
 362
 363
 364         //download
 365         void            SetRequestFile(CPartFile* reqfile);
 366         CPartFile*      GetRequestFile() const          { return m_reqfile; }
 367
 368         uint8           GetDownloadState() const        { return m_nDownloadState; }
 369         void            SetDownloadState(uint8 byNewState);
 370         uint32          GetLastAskedTime() const        { return m_dwLastAskedTime; }
 371
 372         bool            IsPartAvailable(uint16 iPart) const
 373                                         { return ( iPart < m_downPartStatus.size() ) ? m_downPartStatus[iPart] : 0; }
 374         bool            IsUpPartAvailable(uint16 iPart) const
 375                                         { return ( iPart < m_upPartStatus.size() ) ? m_upPartStatus[iPart] : 0;}
 376
 377         const BitVector& GetPartStatus() const          { return m_downPartStatus; }
 378         const BitVector& GetUpPartStatus() const        { return m_upPartStatus; }
 379         float           GetKBpsDown() const                             { return kBpsDown; }
 380         float           CalculateKBpsDown();
 381         uint16          GetRemoteQueueRank() const      { return m_nRemoteQueueRank; }
 382         uint16          GetOldRemoteQueueRank() const   { return m_nOldRemoteQueueRank; }
 383         void            SetRemoteQueueFull(bool flag)   { m_bRemoteQueueFull = flag; }
 384         bool            IsRemoteQueueFull() const       { return m_bRemoteQueueFull; }
 385         void            SetRemoteQueueRank(uint16 nr);
 386         bool            AskForDownload();
 387         void            SendStartupLoadReq();
 388         void            SendFileRequest();
 389         void            ProcessHashSet(const byte* packet, uint32 size);
 390         bool            AddRequestForAnotherFile(CPartFile* file);
 391         bool            DeleteFileRequest(CPartFile* file);
 392         void            DeleteAllFileRequests();
 393         void            SendBlockRequests();
 394         void            ProcessBlockPacket(const byte* packet, uint32 size, bool packed, bool largeblocks);
 395
 396 #ifndef CLIENT_GUI
 397         uint16          GetAvailablePartCount() const;
 398 #else
 399         uint16          m_AvailPartCount;
 400         uint16          GetAvailablePartCount() const   { return m_AvailPartCount; }
 401 #endif
 402
 403         bool            SwapToAnotherFile(bool bIgnoreNoNeeded, bool ignoreSuspensions, bool bRemoveCompletely, CPartFile* toFile = NULL);
 404         void            UDPReaskACK(uint16 nNewQR);
 405         void            UDPReaskFNF();
 406         void            UDPReaskForDownload();
 407         bool            IsSourceRequestAllowed();
 408         uint16          GetUpCompleteSourcesCount() const       { return m_nUpCompleteSourcesCount; }
 409         void            SetUpCompleteSourcesCount(uint16 n)     { m_nUpCompleteSourcesCount = n; }
 410
 411         //chat
 412         uint8           GetChatState()                  { return m_byChatstate; }
 413         void            SetChatState(uint8 nNewS)       { m_byChatstate = nNewS; }
 414
 415         //File Comment
 416         const wxString& GetFileComment() const          { return m_strComment; }
 417         uint8           GetFileRating() const           { return m_iRating; }
 418
 419         const wxString& GetSoftStr() const              { return m_clientSoftString; }
 420         const wxString& GetSoftVerStr() const           { return m_clientVerString; }
 421 #ifndef CLIENT_GUI
 422         const wxString GetServerName() const;
 423 #else
 424         wxString m_ServerName;
 425         const wxString& GetServerName() const { return m_ServerName; }
 426 #endif
 427
 428         uint16          GetKadPort() const              { return m_nKadPort; }
 429         void            SetKadPort(uint16 nPort)        { m_nKadPort = nPort; }
 430
 431         // Kry - AICH import
 432         void            SetReqFileAICHHash(CAICHHash* val);
 433         CAICHHash*      GetReqFileAICHHash() const      {return m_pReqFileAICHHash;}
 434         bool            IsSupportingAICH() const        {return m_fSupportsAICH & 0x01;}
 435         void            SendAICHRequest(CPartFile* pForFile, uint16 nPart);
 436         bool            IsAICHReqPending() const        {return m_fAICHRequested; }
 437         void            ProcessAICHAnswer(const byte* packet, uint32 size);
 438         void            ProcessAICHRequest(const byte* packet, uint32 size);
 439         void            ProcessAICHFileHash(CMemFile* data, const CPartFile* file);
 440
 441         EUtf8Str        GetUnicodeSupport() const;
 442
 443         // Barry - Process zip file as it arrives, don't need to wait until end of block
 444         int             unzip(Pending_Block_Struct *block, byte *zipped, uint32 lenZipped, byte **unzipped, uint32 *lenUnzipped, int iRecursion = 0);
 445         // Barry - Sets string to show parts downloading, eg NNNYNNNNYYNYN
 446         wxString        ShowDownloadingParts() const;
 447         void            UpdateDisplayedInfo(bool force = false);
 448         int             GetFileListRequested() const    { return m_iFileListRequested; }
 449         void            SetFileListRequested(int iFileListRequested) { m_iFileListRequested = iFileListRequested; }
 450
 451         void            ResetFileStatusInfo();
 452
 453         bool            CheckHandshakeFinished(uint32 protocol, uint32 opcode) const;
 454
 455         bool            GetSentCancelTransfer() const   { return m_fSentCancelTransfer; }
 456         void            SetSentCancelTransfer(bool bVal)        { m_fSentCancelTransfer = bVal; }
 457
 458         wxString        GetClientFullInfo();
 459
 460         const wxString& GetClientOSInfo() const         { return m_sClientOSInfo; }
 461
 462         void            ProcessPublicIPAnswer(const byte* pbyData, uint32 uSize);
 463         void            SendPublicIPRequest();
 464
 465         /**
 466          * Sets the current socket of the client.
 467          *
 468          * @param socket The pointer to the new socket, can be NULL.
 469          *
 470          * Please note that this function DOES NOT delete the old socket.
 471          */
 472         void            SetSocket(CClientTCPSocket* socket);
 473
 474         /**
 475          * Function for accessing the socket owned by a client.
 476          *
 477          * @return The pointer (can be NULL) to the socket used by this client.
 478          *
 479          * Please note that the socket object is quite volatile and can be removed
 480          * from one function call to the next, therefore, you should normally use
 481          * the safer functions below, which all check if the socket is valid before
 482          * deferring it.
 483          */
 484         CClientTCPSocket* GetSocket() const             { return m_socket; }
 485
 486         /**
 487          * Safe function for checking if the socket is connected.
 488          *
 489          * @return True if the socket exists and is connected, false otherwise.
 490          */
 491 #ifndef CLIENT_GUI
 492         bool            IsConnected() const;
 493 #else
 494         bool            m_IsConnected;
 495         bool            IsConnected() const             { return m_IsConnected; }
 496 #endif
 497
 498         /**
 499          * Safe function for sending packets.
 500          *
 501          * @return True if the socket exists and the packet was sent, false otherwise.
 502          */
 503         bool            SendPacket(CPacket* packet, bool delpacket = true, bool controlpacket = true);
 504
 505         /**
 506          * Safe function for setting the download limit of the socket.
 507          *
 508          * @return Current download speed of the client.
 509          */
 510         float           SetDownloadLimit(uint32 reducedownload);
 511
 512         /**
 513          * Sends a message to a client
 514          *
 515          * @return True if sent, false if connecting
 516          */
 517         bool    SendMessage(const wxString& message);
 518
 519         uint32          GetPayloadInBuffer() const      { return m_addedPayloadQueueSession - GetQueueSessionPayloadUp(); }
 520         uint32          GetQueueSessionPayloadUp() const        { return m_nCurQueueSessionPayloadUp; }
 521         bool            HasBlocks() const               { return !m_BlockRequests_queue.empty(); }
 522
 523         /* Source comes from? */
 524         ESourceFrom             GetSourceFrom() const   { return (ESourceFrom)m_nSourceFrom; }
 525         void                    SetSourceFrom(ESourceFrom val)  { m_nSourceFrom = val; }
 526
 527         /* Kad buddy support */
 528         // ID
 529         const byte*     GetBuddyID() const              { return m_achBuddyID; }
 530         void            SetBuddyID(const byte* m_achTempBuddyID);
 531         bool            HasValidBuddyID() const         { return m_bBuddyIDValid; }
 532         /* IP */
 533         void            SetBuddyIP( uint32 val )        { m_nBuddyIP = val; }
 534         uint32          GetBuddyIP() const              { return m_nBuddyIP; }
 535         /* Port */
 536         void            SetBuddyPort( uint16 val )      { m_nBuddyPort = val; }
 537         uint16          GetBuddyPort() const            { return m_nBuddyPort; }
 538
 539         //KadIPCheck
 540         bool            SendBuddyPingPong()             { return m_dwLastBuddyPingPongTime < ::GetTickCount(); }
 541         bool            AllowIncomeingBuddyPingPong()   { return m_dwLastBuddyPingPongTime < (::GetTickCount()-(3*60*1000)); }
 542         void            SetLastBuddyPingPongTime()      { m_dwLastBuddyPingPongTime = (::GetTickCount()+(10*60*1000)); }
 543         EKadState       GetKadState() const             { return m_nKadState; }
 544         void            SetKadState(EKadState nNewS)    { m_nKadState = nNewS; }
 545         uint8           GetKadVersion()                 { return m_byKadVersion; }
 546         void            ProcessFirewallCheckUDPRequest(CMemFile *data);
 547         // Kad added by me
 548         bool                    SendBuddyPing();
 549
 550         /* Returns the client hash type (SO_EMULE, mldonkey, etc) */
 551         int             GetHashType() const;
 552
 553         /**
 554          * Checks that a client isn't aggressively re-asking for files.
 555          *
 556          * Call this when a file is requested. If the time since the last request is
 557          * less than MIN_REQUESTTIME, 3 is added to the m_Aggressiveness variable.
 558          * If the time since the last request is >= MIN_REQUESTTIME, the variable is
 559          * decremented by 1. The client is banned if the variable reaches 10 or above.
 560          *
 561          * To check if a client is aggressive use the IsClientAggressive() function.
 562          *
 563          * Currently this function is called when the following packets are received:
 564          *  - OP_STARTUPLOADREQ
 565          *  - OP_REASKFILEPING
 566          */
 567         void            CheckForAggressive();
 568
 569         const wxString& GetClientModString() const      { return m_strModVersion; }
 570
 571         const wxString& GetClientVerString() const      { return m_fullClientVerString; }
 572
 573         const wxString& GetVersionString() const        { return m_clientVersionString; }
 574
 575         void            UpdateStats();
 576
 577         /* Returns a pointer to the credits, only for hash purposes */
 578         void*           GetCreditsHash() const { return (void*)credits; }
 579
 580         uint32          GetLastBlockOffset() const { return m_nLastBlockOffset; }
 581
 582         bool            GetOSInfoSupport() const { return m_fOsInfoSupport; }
 583
 584         bool            GetVBTTags() const { return m_fValueBasedTypeTags; }
 585
 586         uint16          GetLastPartAsked() const { return m_lastPartAsked; }
 587
 588         void            SetLastPartAsked(uint16 nPart) { m_lastPartAsked = nPart; }
 589
 590         CFriend*        GetFriend() const { return m_Friend; }
 591
 592         void            SetFriend(CFriend* newfriend) { m_Friend = newfriend; }
 593
 594         bool            IsIdentified() const;
 595
 596         bool            IsBadGuy() const;
 597
 598         bool            SUIFailed() const;
 599
 600         bool            SUINeeded() const;
 601
 602         bool            SUINotSupported() const;
 603
 604         uint64          GetDownloadedTotal() const;
 605
 606         uint64          GetUploadedTotal() const;
 607
 608         double          GetScoreRatio() const;
 609
 610         uint32          GetCreationTime() const { return m_nCreationTime; }
 611
 612         bool            SupportsLargeFiles() const { return m_fSupportsLargeFiles; }
 613
 614         #ifdef __DEBUG__
 615         /* Kry - Debug. See connection_reason definition comment below */
 616         void            SetConnectionReason(const wxString& reason) { connection_reason = reason; }
 617         #endif
 618
 619         // Encryption / Obfuscation / ConnectOptions
 620         bool            SupportsCryptLayer() const                      { return m_fSupportsCryptLayer; }
 621         bool            RequestsCryptLayer() const                      { return SupportsCryptLayer() && m_fRequestsCryptLayer; }
 622         bool            RequiresCryptLayer() const                      { return RequestsCryptLayer() && m_fRequiresCryptLayer; }
 623         bool            SupportsDirectUDPCallback() const               { return m_fDirectUDPCallback != 0 && HasValidHash() && GetKadPort() != 0; }
 624         uint32_t        GetDirectCallbackTimeout() const                { return m_dwDirectCallbackTimeout; }
 625         bool            HasObfuscatedConnectionBeenEstablished() const  { return m_hasbeenobfuscatinglately; }
 626
 627         void            SetCryptLayerSupport(bool bVal)                 { m_fSupportsCryptLayer = bVal ? 1 : 0; }
 628         void            SetCryptLayerRequest(bool bVal)                 { m_fRequestsCryptLayer = bVal ? 1 : 0; }
 629         void            SetCryptLayerRequires(bool bVal)                { m_fRequiresCryptLayer = bVal ? 1 : 0; }
 630         void            SetDirectUDPCallbackSupport(bool bVal)          { m_fDirectUDPCallback = bVal ? 1 : 0; }
 631         void            SetConnectOptions(uint8_t options, bool encryption = true, bool callback = true); // shortcut, sets crypt, callback, etc from the tagvalue we receive
 632         bool            ShouldReceiveCryptUDPPackets() const;
 633
 634         bool            HasDisabledSharedFiles() const { return m_fNoViewSharedFiles; }
 635
 636 private:
 637
 638         CClientCredits  *credits;
 639         CFriend         *m_Friend;
 640
 641         uint32          m_nTransferredUp;
 642         uint32          m_nCurQueueSessionPayloadUp;
 643         uint32          m_addedPayloadQueueSession;
 644
 645         struct TransferredData {
 646                 uint32  datalen;
 647                 uint32  timestamp;
 648         };
 649
 650         //////////////////////////////////////////////////////////
 651         // Upload data rate computation
 652         //
 653         uint32          m_nUpDatarate;
 654         uint32          m_nSumForAvgUpDataRate;
 655         std::list<TransferredData> m_AvarageUDR_list;
 656
 657
 658         /**
 659          * This struct is used to keep track of CPartFiles which this source shares.
 660          */
 661         struct A4AFStamp {
 662                 //! Signifies if this sources has needed parts for this file.
 663                 bool NeededParts;
 664                 //! This is set when we wish to avoid swapping to this file for a while.
 665                 uint32 timestamp;
 666         };
 667
 668         //! I typedef in the name of readability!
 669         typedef std::map<CPartFile*, A4AFStamp> A4AFList;
 670         //! This list contains all PartFiles which this client can be used as a source for.
 671         A4AFList m_A4AF_list;
 672
 673         /**
 674          * Helper function used by SwapToAnotherFile().
 675          *
 676          * @param it The iterator of the PartFile to be examined.
 677          * @param ignorenoneeded Do not check for the status NoNeededParts when checking the file.
 678          * @param ignoresuspended Do not check the timestamp when checking the file.
 679          * @return True if the file is a viable target, false otherwise.
 680          *
 681          * This function is used to perform checks to see if we should consider
 682          * this file a viable target for A4AF swapping. Unless ignoresuspended is
 683          * true, it will examine the timestamp of the file and reset it if needed.
 684          */
 685         bool            IsValidSwapTarget( A4AFList::iterator it, bool ignorenoneeded = false, bool ignoresuspended = false );
 686
 687         CPartFile*      m_reqfile;
 688
 689         // base
 690         void            Init();
 691         bool            ProcessHelloTypePacket(const CMemFile& data);
 692         void            SendHelloTypePacket(CMemFile* data);
 693         void            SendFirewallCheckUDPRequest();
 694         void            ClearHelloProperties(); // eMule 0.42
 695         uint32          m_dwUserIP;
 696         uint32          m_nConnectIP;           // holds the supposed IP or (after we had a connection) the real IP
 697         uint32          m_dwServerIP;
 698         uint32          m_nUserIDHybrid;
 699         uint16_t        m_nUserPort;
 700         int16           m_nServerPort;
 701         uint32          m_nClientVersion;
 702         uint32          m_cSendblock;
 703         uint8           m_byEmuleVersion;
 704         uint8           m_byDataCompVer;
 705         bool            m_bEmuleProtocol;
 706         wxString        m_Username;
 707         uint32          m_FullUserIP;
 708         CMD4Hash        m_UserHash;
 709         bool            m_HasValidHash;
 710         uint16          m_nUDPPort;
 711         uint8           m_byUDPVer;
 712         uint8           m_bySourceExchange1Ver;
 713         uint8           m_byAcceptCommentVer;
 714         uint8           m_byExtendedRequestsVer;
 715         uint8           m_clientSoft;
 716         uint32          m_dwLastSourceRequest;
 717         uint32          m_dwLastSourceAnswer;
 718         uint32          m_dwLastAskedForSources;
 719         int             m_iFileListRequested;
 720         bool            m_bFriendSlot;
 721         bool            m_bCommentDirty;
 722         bool            m_bIsHybrid;
 723         bool            m_bIsML;
 724         bool            m_bSupportsPreview;
 725         bool            m_bUnicodeSupport;
 726         uint16          m_nKadPort;
 727         bool            m_bMultiPacket;
 728         ClientState     m_clientState;
 729         CClientTCPSocket*       m_socket;
 730         bool            m_fNeedOurPublicIP; // we requested our IP from this client
 731
 732         // Kry - Secure User Ident import
 733         ESecureIdentState       m_SecureIdentState;
 734         uint8           m_byInfopacketsReceived;                // have we received the edonkeyprot and emuleprot packet already (see InfoPacketsReceived() )
 735         uint32          m_dwLastSignatureIP;
 736         uint8           m_bySupportSecIdent;
 737
 738         uint32          m_byCompatibleClient;
 739         std::list<CPacket*>     m_WaitingPackets_list;
 740         uint32          m_lastRefreshedDLDisplay;
 741
 742         //upload
 743         void CreateStandartPackets(const unsigned char* data,uint32 togo, Requested_Block_Struct* currentblock);
 744         void CreatePackedPackets(const unsigned char* data,uint32 togo, Requested_Block_Struct* currentblock);
 745
 746         uint8           m_nUploadState;
 747         uint32          m_dwUploadTime;
 748         uint32          m_cAsked;
 749         uint32          m_dwLastUpRequest;
 750         uint32          m_nCurSessionUp;
 751         uint16          m_nUpPartCount;
 752         CMD4Hash        m_requpfileid;
 753         uint16          m_nUpCompleteSourcesCount;
 754
 755         //! This vector contains the avilability of parts for the file that the user
 756         //! is requesting. When changing it, be sure to call CKnownFile::UpdatePartsFrequency
 757         //! so that the files know the actual availability of parts.
 758         BitVector       m_upPartStatus;
 759         uint16          m_lastPartAsked;
 760         wxString        m_strModVersion;
 761
 762         std::list<Requested_Block_Struct*>      m_BlockRequests_queue;
 763         std::list<Requested_Block_Struct*>      m_DoneBlocks_list;
 764
 765         //download
 766         bool            m_bRemoteQueueFull;
 767         uint8           m_nDownloadState;
 768         uint16          m_nPartCount;
 769         uint32          m_dwLastAskedTime;
 770         wxString        m_clientFilename;
 771         uint32          m_nTransferredDown;
 772         uint32          m_nLastBlockOffset;   // Patch for show parts that you download [Cax2]
 773         uint16          m_cShowDR;
 774         uint32          m_dwLastBlockReceived;
 775         uint16          m_nRemoteQueueRank;
 776         uint16          m_nOldRemoteQueueRank;
 777         bool            m_bCompleteSource;
 778         bool            m_bReaskPending;
 779         bool            m_bUDPPending;
 780         bool            m_bHashsetRequested;
 781
 782         std::list<Pending_Block_Struct*>        m_PendingBlocks_list;
 783         std::list<Requested_Block_Struct*>      m_DownloadBlocks_list;
 784
 785         // download speed calculation
 786         float           kBpsDown;
 787         uint32          msReceivedPrev;
 788         uint32          bytesReceivedCycle;
 789         // chat
 790         uint8           m_byChatstate;
 791         wxString        m_strComment;
 792         int8            m_iRating;
 793
 794         unsigned int
 795                 m_fHashsetRequesting : 1, // we have sent a hashset request to this client
 796                 m_fNoViewSharedFiles : 1, // client has disabled the 'View Shared Files' feature,
 797                                           // if this flag is not set, we just know that we don't know
 798                                           // for sure if it is enabled
 799                 m_fSupportsPreview   : 1,
 800                 m_fSentCancelTransfer: 1, // we have sent an OP_CANCELTRANSFER in the current connection
 801                 m_fSharedDirectories : 1, // client supports OP_ASKSHAREDIRS opcodes
 802                 m_fSupportsAICH      : 3,
 803                 m_fAICHRequested     : 1,
 804                 m_fSupportsLargeFiles: 1,
 805                 m_fSentOutOfPartReqs : 1,
 806                 m_fExtMultiPacket    : 1,
 807                 m_fRequestsCryptLayer: 1,
 808                 m_fSupportsCryptLayer: 1,
 809                 m_fRequiresCryptLayer: 1,
 810                 m_fSupportsSourceEx2 : 1,
 811                 m_fDirectUDPCallback : 1;
 812
 813         unsigned int
 814                 m_fOsInfoSupport : 1,
 815                 m_fValueBasedTypeTags : 1;
 816
 817         /* Razor 1a - Modif by MikaelB */
 818
 819         bool            m_bHelloAnswerPending;
 820
 821         //! This vector contains the avilability of parts for the file we requested
 822         //! from this user. When changing it, be sure to call CPartFile::UpdatePartsFrequency
 823         //! so that the files know the actual availability of parts.
 824         BitVector       m_downPartStatus;
 825
 826         CAICHHash*      m_pReqFileAICHHash;
 827
 828         ESourceFrom     m_nSourceFrom;
 829
 830         /* Kad Stuff */
 831         byte            m_achBuddyID[16];
 832         bool            m_bBuddyIDValid;
 833         uint32          m_nBuddyIP;
 834         uint16          m_nBuddyPort;
 835
 836         EKadState       m_nKadState;
 837
 838         uint8           m_byKadVersion;
 839         uint32          m_dwLastBuddyPingPongTime;
 840         uint32_t        m_dwDirectCallbackTimeout;
 841
 842         //! This keeps track of aggressive requests for files.
 843         uint16          m_Aggressiveness;
 844         //! This tracks the time of the last time since a file was requested
 845         uint32          m_LastFileRequest;
 846
 847         bool            m_OSInfo_sent;
 848
 849         wxString        m_clientSoftString;     /* software name */
 850         wxString        m_clientVerString;      /* version + optional mod name */
 851         wxString        m_clientVersionString;  /* version string */
 852         wxString        m_fullClientVerString;  /* full info string */
 853         wxString        m_sClientOSInfo;
 854         wxString        m_pendingMessage;
 855
 856         int             SecIdentSupRec;
 857
 858         CKnownFile*     m_uploadingfile;
 859
 860         uint8           m_MaxBlockRequests;
 861
 862         // needed for stats
 863         uint32          m_lastClientSoft;
 864         uint32          m_lastClientVersion;
 865         wxString        m_lastOSInfo;
 866
 867         /* For buddies timeout */
 868         uint32 m_nCreationTime;
 869
 870         /* Calculation of last average speed */
 871         uint32 m_lastaverage;
 872         uint32 m_last_block_start;
 873
 874         /* Save the encryption status for display when disconnected */
 875         bool m_hasbeenobfuscatinglately;
 876
 877         /* Kry - Debug thing. Clients created just to check their data
 878            have this string set to the reason we want to check them.
 879            Obviously, once checked, we disconect them. Take that, sucker.
 880            This debug code is just for me I'm afraid. */
 881           #ifdef __DEBUG__
 882           wxString connection_reason;
 883           #endif
 884 };
 885
 886
 887 #define MAKE_CLIENT_VERSION(mjr, min, upd) \
 888         ((uint32)(mjr)*100U*10U*100U + (uint32)(min)*100U*10U + (uint32)(upd)*100U)
 889
 890
 891 #endif // UPDOWNCLIENT_H
 892 // File_checked_for_headers