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