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         const wxString& GetFullIP() const               { return 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           CalculateKBpsDown();
 380         uint16          GetRemoteQueueRank() const      { return m_nRemoteQueueRank; }
 381         uint16          GetOldRemoteQueueRank() const   { return m_nOldRemoteQueueRank; }
 382         void            SetRemoteQueueFull(bool flag)   { m_bRemoteQueueFull = flag; }
 383         bool            IsRemoteQueueFull() const       { return m_bRemoteQueueFull; }
 384         void            SetRemoteQueueRank(uint16 nr);
 385         bool            AskForDownload();
 386         void            SendStartupLoadReq();
 387         void            SendFileRequest();
 388         void            ProcessHashSet(const byte* packet, uint32 size);
 389         bool            AddRequestForAnotherFile(CPartFile* file);
 390         bool            DeleteFileRequest(CPartFile* file);
 391         void            DeleteAllFileRequests();
 392         void            SendBlockRequests();
 393         void            ProcessBlockPacket(const byte* packet, uint32 size, bool packed, bool largeblocks);
 394
 395 #ifndef CLIENT_GUI
 396         uint16          GetAvailablePartCount() const;
 397         float           GetKBpsDown() const;
 398 #else
 399         uint16          m_AvailPartCount;
 400         uint16          GetAvailablePartCount() const   { return m_AvailPartCount; }
 401         float           GetKBpsDown() const                             { return kBpsDown; }
 402 #endif
 403
 404         bool            SwapToAnotherFile(bool bIgnoreNoNeeded, bool ignoreSuspensions, bool bRemoveCompletely, CPartFile* toFile = NULL);
 405         void            UDPReaskACK(uint16 nNewQR);
 406         void            UDPReaskFNF();
 407         void            UDPReaskForDownload();
 408         bool            IsSourceRequestAllowed();
 409         uint16          GetUpCompleteSourcesCount() const       { return m_nUpCompleteSourcesCount; }
 410         void            SetUpCompleteSourcesCount(uint16 n)     { m_nUpCompleteSourcesCount = n; }
 411
 412         //chat
 413         uint8           GetChatState()                  { return m_byChatstate; }
 414         void            SetChatState(uint8 nNewS)       { m_byChatstate = nNewS; }
 415
 416         //File Comment
 417         const wxString& GetFileComment() const          { return m_strComment; }
 418         uint8           GetFileRating() const           { return m_iRating; }
 419
 420         const wxString& GetSoftStr() const              { return m_clientSoftString; }
 421         const wxString& GetSoftVerStr() const           { return m_clientVerString; }
 422 #ifndef CLIENT_GUI
 423         const wxString GetServerName() const;
 424 #else
 425         wxString m_ServerName;
 426         const wxString& GetServerName() const { return m_ServerName; }
 427 #endif
 428
 429         uint16          GetKadPort() const              { return m_nKadPort; }
 430         void            SetKadPort(uint16 nPort)        { m_nKadPort = nPort; }
 431
 432         // Kry - AICH import
 433         void            SetReqFileAICHHash(CAICHHash* val);
 434         CAICHHash*      GetReqFileAICHHash() const      {return m_pReqFileAICHHash;}
 435         bool            IsSupportingAICH() const        {return m_fSupportsAICH & 0x01;}
 436         void            SendAICHRequest(CPartFile* pForFile, uint16 nPart);
 437         bool            IsAICHReqPending() const        {return m_fAICHRequested; }
 438         void            ProcessAICHAnswer(const byte* packet, uint32 size);
 439         void            ProcessAICHRequest(const byte* packet, uint32 size);
 440         void            ProcessAICHFileHash(CMemFile* data, const CPartFile* file);
 441
 442         EUtf8Str        GetUnicodeSupport() const;
 443
 444         // Barry - Process zip file as it arrives, don't need to wait until end of block
 445         int             unzip(Pending_Block_Struct *block, byte *zipped, uint32 lenZipped, byte **unzipped, uint32 *lenUnzipped, int iRecursion = 0);
 446         // Barry - Sets string to show parts downloading, eg NNNYNNNNYYNYN
 447         wxString        ShowDownloadingParts() const;
 448         void            UpdateDisplayedInfo(bool force = false);
 449         int             GetFileListRequested() const    { return m_iFileListRequested; }
 450         void            SetFileListRequested(int iFileListRequested) { m_iFileListRequested = iFileListRequested; }
 451
 452         void            ResetFileStatusInfo();
 453
 454         bool            CheckHandshakeFinished(uint32 protocol, uint32 opcode) const;
 455
 456         bool            GetSentCancelTransfer() const   { return m_fSentCancelTransfer; }
 457         void            SetSentCancelTransfer(bool bVal)        { m_fSentCancelTransfer = bVal; }
 458
 459         wxString        GetClientFullInfo();
 460
 461         const wxString& GetClientOSInfo() const         { return m_sClientOSInfo; }
 462
 463         void            ProcessPublicIPAnswer(const byte* pbyData, uint32 uSize);
 464         void            SendPublicIPRequest();
 465
 466         /**
 467          * Sets the current socket of the client.
 468          *
 469          * @param socket The pointer to the new socket, can be NULL.
 470          *
 471          * Please note that this function DOES NOT delete the old socket.
 472          */
 473         void            SetSocket(CClientTCPSocket* socket);
 474
 475         /**
 476          * Function for accessing the socket owned by a client.
 477          *
 478          * @return The pointer (can be NULL) to the socket used by this client.
 479          *
 480          * Please note that the socket object is quite volatile and can be removed
 481          * from one function call to the next, therefore, you should normally use
 482          * the safer functions below, which all check if the socket is valid before
 483          * deferring it.
 484          */
 485         CClientTCPSocket* GetSocket() const             { return m_socket; }
 486
 487         /**
 488          * Safe function for checking if the socket is connected.
 489          *
 490          * @return True if the socket exists and is connected, false otherwise.
 491          */
 492 #ifndef CLIENT_GUI
 493         bool            IsConnected() const;
 494 #else
 495         bool            m_IsConnected;
 496         bool            IsConnected() const             { return m_IsConnected; }
 497 #endif
 498
 499         /**
 500          * Safe function for sending packets.
 501          *
 502          * @return True if the socket exists and the packet was sent, false otherwise.
 503          */
 504         bool            SendPacket(CPacket* packet, bool delpacket = true, bool controlpacket = true);
 505
 506         /**
 507          * Safe function for setting the download limit of the socket.
 508          *
 509          * @return Current download speed of the client.
 510          */
 511         float           SetDownloadLimit(uint32 reducedownload);
 512
 513         /**
 514          * Sends a message to a client
 515          *
 516          * @return True if sent, false if connecting
 517          */
 518         bool    SendMessage(const wxString& message);
 519
 520         uint32          GetPayloadInBuffer() const      { return m_addedPayloadQueueSession - GetQueueSessionPayloadUp(); }
 521         uint32          GetQueueSessionPayloadUp() const        { return m_nCurQueueSessionPayloadUp; }
 522         bool            HasBlocks() const               { return !m_BlockRequests_queue.empty(); }
 523
 524         /* Source comes from? */
 525         ESourceFrom             GetSourceFrom() const   { return (ESourceFrom)m_nSourceFrom; }
 526         void                    SetSourceFrom(ESourceFrom val)  { m_nSourceFrom = val; }
 527
 528         /* Kad buddy support */
 529         // ID
 530         const byte*     GetBuddyID() const              { return m_achBuddyID; }
 531         void            SetBuddyID(const byte* m_achTempBuddyID);
 532         bool            HasValidBuddyID() const         { return m_bBuddyIDValid; }
 533         /* IP */
 534         void            SetBuddyIP( uint32 val )        { m_nBuddyIP = val; }
 535         uint32          GetBuddyIP() const              { return m_nBuddyIP; }
 536         /* Port */
 537         void            SetBuddyPort( uint16 val )      { m_nBuddyPort = val; }
 538         uint16          GetBuddyPort() const            { return m_nBuddyPort; }
 539
 540         //KadIPCheck
 541         bool            SendBuddyPingPong()             { return m_dwLastBuddyPingPongTime < ::GetTickCount(); }
 542         bool            AllowIncomeingBuddyPingPong()   { return m_dwLastBuddyPingPongTime < (::GetTickCount()-(3*60*1000)); }
 543         void            SetLastBuddyPingPongTime()      { m_dwLastBuddyPingPongTime = (::GetTickCount()+(10*60*1000)); }
 544         EKadState       GetKadState() const             { return m_nKadState; }
 545         void            SetKadState(EKadState nNewS)    { m_nKadState = nNewS; }
 546         uint8           GetKadVersion()                 { return m_byKadVersion; }
 547         void            ProcessFirewallCheckUDPRequest(CMemFile *data);
 548         // Kad added by me
 549         bool                    SendBuddyPing();
 550
 551         /* Returns the client hash type (SO_EMULE, mldonkey, etc) */
 552         int             GetHashType() const;
 553
 554         /**
 555          * Checks that a client isn't aggressively re-asking for files.
 556          *
 557          * Call this when a file is requested. If the time since the last request is
 558          * less than MIN_REQUESTTIME, 3 is added to the m_Aggressiveness variable.
 559          * If the time since the last request is >= MIN_REQUESTTIME, the variable is
 560          * decremented by 1. The client is banned if the variable reaches 10 or above.
 561          *
 562          * To check if a client is aggressive use the IsClientAggressive() function.
 563          *
 564          * Currently this function is called when the following packets are received:
 565          *  - OP_STARTUPLOADREQ
 566          *  - OP_REASKFILEPING
 567          */
 568         void            CheckForAggressive();
 569
 570         const wxString& GetClientModString() const      { return m_strModVersion; }
 571
 572         const wxString& GetClientVerString() const      { return m_fullClientVerString; }
 573
 574         const wxString& GetVersionString() const        { return m_clientVersionString; }
 575
 576         void            UpdateStats();
 577
 578         /* Returns a pointer to the credits, only for hash purposes */
 579         void*           GetCreditsHash() const { return (void*)credits; }
 580
 581         uint32          GetLastBlockOffset() const { return m_nLastBlockOffset; }
 582
 583         bool            GetOSInfoSupport() const { return m_fOsInfoSupport; }
 584
 585         bool            GetVBTTags() const { return m_fValueBasedTypeTags; }
 586
 587         uint16          GetLastPartAsked() const { return m_lastPartAsked; }
 588
 589         void            SetLastPartAsked(uint16 nPart) { m_lastPartAsked = nPart; }
 590
 591         CFriend*        GetFriend() const { return m_Friend; }
 592
 593         void            SetFriend(CFriend* newfriend) { m_Friend = newfriend; }
 594
 595         bool            IsIdentified() const;
 596
 597         bool            IsBadGuy() const;
 598
 599         bool            SUIFailed() const;
 600
 601         bool            SUINeeded() const;
 602
 603         bool            SUINotSupported() const;
 604
 605         uint64          GetDownloadedTotal() const;
 606
 607         uint64          GetUploadedTotal() const;
 608
 609         double          GetScoreRatio() const;
 610
 611         uint32          GetCreationTime() const { return m_nCreationTime; }
 612
 613         bool            SupportsLargeFiles() const { return m_fSupportsLargeFiles; }
 614
 615         #ifdef __DEBUG__
 616         /* Kry - Debug. See connection_reason definition comment below */
 617         void            SetConnectionReason(const wxString& reason) { connection_reason = reason; }
 618         #endif
 619
 620         // Encryption / Obfuscation / ConnectOptions
 621         bool            SupportsCryptLayer() const                      { return m_fSupportsCryptLayer; }
 622         bool            RequestsCryptLayer() const                      { return SupportsCryptLayer() && m_fRequestsCryptLayer; }
 623         bool            RequiresCryptLayer() const                      { return RequestsCryptLayer() && m_fRequiresCryptLayer; }
 624         bool            SupportsDirectUDPCallback() const               { return m_fDirectUDPCallback != 0 && HasValidHash() && GetKadPort() != 0; }
 625         uint32_t        GetDirectCallbackTimeout() const                { return m_dwDirectCallbackTimeout; }
 626         bool            HasObfuscatedConnectionBeenEstablished() const  { return m_hasbeenobfuscatinglately; }
 627
 628         void            SetCryptLayerSupport(bool bVal)                 { m_fSupportsCryptLayer = bVal ? 1 : 0; }
 629         void            SetCryptLayerRequest(bool bVal)                 { m_fRequestsCryptLayer = bVal ? 1 : 0; }
 630         void            SetCryptLayerRequires(bool bVal)                { m_fRequiresCryptLayer = bVal ? 1 : 0; }
 631         void            SetDirectUDPCallbackSupport(bool bVal)          { m_fDirectUDPCallback = bVal ? 1 : 0; }
 632         void            SetConnectOptions(uint8_t options, bool encryption = true, bool callback = true); // shortcut, sets crypt, callback, etc from the tagvalue we receive
 633         bool            ShouldReceiveCryptUDPPackets() const;
 634
 635         bool            HasDisabledSharedFiles() const { return m_fNoViewSharedFiles; }
 636
 637 private:
 638
 639         CClientCredits  *credits;
 640         CFriend         *m_Friend;
 641
 642         uint32          m_nTransferredUp;
 643         uint32          m_nCurQueueSessionPayloadUp;
 644         uint32          m_addedPayloadQueueSession;
 645
 646         struct TransferredData {
 647                 uint32  datalen;
 648                 uint32  timestamp;
 649         };
 650
 651         //////////////////////////////////////////////////////////
 652         // Upload data rate computation
 653         //
 654         uint32          m_nUpDatarate;
 655         uint32          m_nSumForAvgUpDataRate;
 656         std::list<TransferredData> m_AvarageUDR_list;
 657
 658
 659         /**
 660          * This struct is used to keep track of CPartFiles which this source shares.
 661          */
 662         struct A4AFStamp {
 663                 //! Signifies if this sources has needed parts for this file.
 664                 bool NeededParts;
 665                 //! This is set when we wish to avoid swapping to this file for a while.
 666                 uint32 timestamp;
 667         };
 668
 669         //! I typedef in the name of readability!
 670         typedef std::map<CPartFile*, A4AFStamp> A4AFList;
 671         //! This list contains all PartFiles which this client can be used as a source for.
 672         A4AFList m_A4AF_list;
 673
 674         /**
 675          * Helper function used by SwapToAnotherFile().
 676          *
 677          * @param it The iterator of the PartFile to be examined.
 678          * @param ignorenoneeded Do not check for the status NoNeededParts when checking the file.
 679          * @param ignoresuspended Do not check the timestamp when checking the file.
 680          * @return True if the file is a viable target, false otherwise.
 681          *
 682          * This function is used to perform checks to see if we should consider
 683          * this file a viable target for A4AF swapping. Unless ignoresuspended is
 684          * true, it will examine the timestamp of the file and reset it if needed.
 685          */
 686         bool            IsValidSwapTarget( A4AFList::iterator it, bool ignorenoneeded = false, bool ignoresuspended = false );
 687
 688         CPartFile*      m_reqfile;
 689
 690         // base
 691         void            Init();
 692         bool            ProcessHelloTypePacket(const CMemFile& data);
 693         void            SendHelloTypePacket(CMemFile* data);
 694         void            SendFirewallCheckUDPRequest();
 695         void            ClearHelloProperties(); // eMule 0.42
 696         uint32          m_dwUserIP;
 697         uint32          m_nConnectIP;           // holds the supposed IP or (after we had a connection) the real IP
 698         uint32          m_dwServerIP;
 699         uint32          m_nUserIDHybrid;
 700         uint16_t        m_nUserPort;
 701         int16           m_nServerPort;
 702         uint32          m_nClientVersion;
 703         uint32          m_cSendblock;
 704         uint8           m_byEmuleVersion;
 705         uint8           m_byDataCompVer;
 706         bool            m_bEmuleProtocol;
 707         wxString        m_Username;
 708         wxString        m_FullUserIP;
 709         CMD4Hash        m_UserHash;
 710         bool            m_HasValidHash;
 711         uint16          m_nUDPPort;
 712         uint8           m_byUDPVer;
 713         uint8           m_bySourceExchange1Ver;
 714         uint8           m_byAcceptCommentVer;
 715         uint8           m_byExtendedRequestsVer;
 716         uint8           m_clientSoft;
 717         uint32          m_dwLastSourceRequest;
 718         uint32          m_dwLastSourceAnswer;
 719         uint32          m_dwLastAskedForSources;
 720         int             m_iFileListRequested;
 721         bool            m_bFriendSlot;
 722         bool            m_bCommentDirty;
 723         bool            m_bIsHybrid;
 724         bool            m_bIsML;
 725         bool            m_bSupportsPreview;
 726         bool            m_bUnicodeSupport;
 727         uint16          m_nKadPort;
 728         bool            m_bMultiPacket;
 729         ClientState     m_clientState;
 730         CClientTCPSocket*       m_socket;
 731         bool            m_fNeedOurPublicIP; // we requested our IP from this client
 732
 733         // Kry - Secure User Ident import
 734         ESecureIdentState       m_SecureIdentState;
 735         uint8           m_byInfopacketsReceived;                // have we received the edonkeyprot and emuleprot packet already (see InfoPacketsReceived() )
 736         uint32          m_dwLastSignatureIP;
 737         uint8           m_bySupportSecIdent;
 738
 739         uint32          m_byCompatibleClient;
 740         std::list<CPacket*>     m_WaitingPackets_list;
 741         uint32          m_lastRefreshedDLDisplay;
 742
 743         //upload
 744         void CreateStandartPackets(const unsigned char* data,uint32 togo, Requested_Block_Struct* currentblock);
 745         void CreatePackedPackets(const unsigned char* data,uint32 togo, Requested_Block_Struct* currentblock);
 746
 747         uint8           m_nUploadState;
 748         uint32          m_dwUploadTime;
 749         uint32          m_cAsked;
 750         uint32          m_dwLastUpRequest;
 751         uint32          m_nCurSessionUp;
 752         uint16          m_nUpPartCount;
 753         CMD4Hash        m_requpfileid;
 754         uint16          m_nUpCompleteSourcesCount;
 755
 756         //! This vector contains the avilability of parts for the file that the user
 757         //! is requesting. When changing it, be sure to call CKnownFile::UpdatePartsFrequency
 758         //! so that the files know the actual availability of parts.
 759         BitVector       m_upPartStatus;
 760         uint16          m_lastPartAsked;
 761         wxString        m_strModVersion;
 762
 763         std::list<Requested_Block_Struct*>      m_BlockRequests_queue;
 764         std::list<Requested_Block_Struct*>      m_DoneBlocks_list;
 765
 766         //download
 767         bool            m_bRemoteQueueFull;
 768         uint8           m_nDownloadState;
 769         uint16          m_nPartCount;
 770         uint32          m_dwLastAskedTime;
 771         wxString        m_clientFilename;
 772         uint32          m_nTransferredDown;
 773         uint32          m_nLastBlockOffset;   // Patch for show parts that you download [Cax2]
 774         uint16          m_cShowDR;
 775         uint32          m_dwLastBlockReceived;
 776         uint16          m_nRemoteQueueRank;
 777         uint16          m_nOldRemoteQueueRank;
 778         bool            m_bCompleteSource;
 779         bool            m_bReaskPending;
 780         bool            m_bUDPPending;
 781         bool            m_bHashsetRequested;
 782
 783         std::list<Pending_Block_Struct*>        m_PendingBlocks_list;
 784         std::list<Requested_Block_Struct*>      m_DownloadBlocks_list;
 785
 786         // download speed calculation
 787         float           kBpsDown;
 788         uint32          msReceivedPrev;
 789         uint32          bytesReceivedCycle;
 790         // chat
 791         uint8           m_byChatstate;
 792         wxString        m_strComment;
 793         int8            m_iRating;
 794
 795         unsigned int
 796                 m_fHashsetRequesting : 1, // we have sent a hashset request to this client
 797                 m_fNoViewSharedFiles : 1, // client has disabled the 'View Shared Files' feature,
 798                                           // if this flag is not set, we just know that we don't know
 799                                           // for sure if it is enabled
 800                 m_fSupportsPreview   : 1,
 801                 m_fSentCancelTransfer: 1, // we have sent an OP_CANCELTRANSFER in the current connection
 802                 m_fSharedDirectories : 1, // client supports OP_ASKSHAREDIRS opcodes
 803                 m_fSupportsAICH      : 3,
 804                 m_fAICHRequested     : 1,
 805                 m_fSupportsLargeFiles: 1,
 806                 m_fSentOutOfPartReqs : 1,
 807                 m_fExtMultiPacket    : 1,
 808                 m_fRequestsCryptLayer: 1,
 809                 m_fSupportsCryptLayer: 1,
 810                 m_fRequiresCryptLayer: 1,
 811                 m_fSupportsSourceEx2 : 1,
 812                 m_fDirectUDPCallback : 1;
 813
 814         unsigned int
 815                 m_fOsInfoSupport : 1,
 816                 m_fValueBasedTypeTags : 1;
 817
 818         /* Razor 1a - Modif by MikaelB */
 819
 820         bool            m_bHelloAnswerPending;
 821
 822         //! This vector contains the avilability of parts for the file we requested
 823         //! from this user. When changing it, be sure to call CPartFile::UpdatePartsFrequency
 824         //! so that the files know the actual availability of parts.
 825         BitVector       m_downPartStatus;
 826
 827         CAICHHash*      m_pReqFileAICHHash;
 828
 829         ESourceFrom     m_nSourceFrom;
 830
 831         /* Kad Stuff */
 832         byte            m_achBuddyID[16];
 833         bool            m_bBuddyIDValid;
 834         uint32          m_nBuddyIP;
 835         uint16          m_nBuddyPort;
 836
 837         EKadState       m_nKadState;
 838
 839         uint8           m_byKadVersion;
 840         uint32          m_dwLastBuddyPingPongTime;
 841         uint32_t        m_dwDirectCallbackTimeout;
 842
 843         //! This keeps track of aggressive requests for files.
 844         uint16          m_Aggressiveness;
 845         //! This tracks the time of the last time since a file was requested
 846         uint32          m_LastFileRequest;
 847
 848         bool            m_OSInfo_sent;
 849
 850         wxString        m_clientSoftString;     /* software name */
 851         wxString        m_clientVerString;      /* version + optional mod name */
 852         wxString        m_clientVersionString;  /* version string */
 853         wxString        m_fullClientVerString;  /* full info string */
 854         wxString        m_sClientOSInfo;
 855         wxString        m_pendingMessage;
 856
 857         int             SecIdentSupRec;
 858
 859         CKnownFile*     m_uploadingfile;
 860
 861         uint8           m_MaxBlockRequests;
 862
 863         // needed for stats
 864         uint32          m_lastClientSoft;
 865         uint32          m_lastClientVersion;
 866         wxString        m_lastOSInfo;
 867
 868         /* For buddies timeout */
 869         uint32 m_nCreationTime;
 870
 871         /* Calculation of last average speed */
 872         uint32 m_lastaverage;
 873         uint32 m_last_block_start;
 874
 875         /* Save the encryption status for display when disconnected */
 876         bool m_hasbeenobfuscatinglately;
 877
 878         /* Kry - Debug thing. Clients created just to check their data
 879            have this string set to the reason we want to check them.
 880            Obviously, once checked, we disconect them. Take that, sucker.
 881            This debug code is just for me I'm afraid. */
 882           #ifdef __DEBUG__
 883           wxString connection_reason;
 884           #endif
 885 };
 886
 887
 888 #define MAKE_CLIENT_VERSION(mjr, min, upd) \
 889         ((uint32)(mjr)*100U*10U*100U + (uint32)(min)*100U*10U + (uint32)(upd)*100U)
 890
 891
 892 #endif // UPDOWNCLIENT_H
 893 // File_checked_for_headers