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