src/MuleUDPSocket.h

   1 //
   2 // This file is part of the aMule Project.
   3 //
   4 // Copyright (C) 2005-2008 aMule Team ( admin@amule.org / http://www.amule.org )
   5 //
   6 // Any parts of this program derived from the xMule, lMule or eMule project,
   7 // or contributed by third-party developers are copyrighted by their
   8 // respective authors.
   9 //
  10 // This program is free software; you can redistribute it and/or modify
  11 // it under the terms of the GNU General Public License as published by
  12 // the Free Software Foundation; either version 2 of the License, or
  13 // (at your option) any later version.
  14 //
  15 // This program is distributed in the hope that it will be useful,
  16 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  17 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18 // GNU General Public License for more details.
  19 //
  20 // You should have received a copy of the GNU General Public License
  21 // along with this program; if not, write to the Free Software
  22 // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301, USA
  23 //
  24
  25 #ifndef MULEUDPSOCKET_H
  26 #define MULEUDPSOCKET_H
  27
  28
  29 #include "Types.h"                              // Needed for uint16 and uint32
  30 #include "ThrottledSocket.h"    // Needed for ThrottledControlSocket
  31 #include "amuleIPV4Address.h"   // Needed for amuleIPV4Address
  32
  33 class CEncryptedDatagramSocket;
  34 class CProxyData;
  35 class CPacket;
  36
  37 /***
  38  * This class provides a UBT governed UDP-socket.
  39  *
  40  * The CMuleUDPSocket are created with the NOWAIT option and
  41  * handle both INPUT and OUTPUT events.
  42  *
  43  * The following additional features are provided compared to CDatagramSocketProxy:
  44  *  - Goverened by the UBT.
  45  *  - Automatic sending/receiving of packets.
  46  *  - Fallover recovery for when a socket becomes invalid (error 4).
  47  *
  48  * @see ThrottledControlSocket
  49  * @see CEncryptedDatagramSocket
  50  */
  51 class CMuleUDPSocket : public ThrottledControlSocket
  52 {
  53
  54 public:
  55         /**
  56          * Opens a UDP socket at the specified address.
  57          *
  58          * @param name Name used when logging events.
  59          * @param id The ID used for events.
  60          * @param address The address where the socket will listen.
  61          * @param ProxyData ProxyData assosiated with the socket.
  62          */
  63         CMuleUDPSocket(const wxString& name, int id, const amuleIPV4Address& address, const CProxyData* ProxyData = NULL);
  64
  65         /**
  66          * Destructor, safely closes the socket if opened.
  67          */
  68         virtual ~CMuleUDPSocket();
  69
  70
  71         /**
  72          * Opens the socket.
  73          *
  74          * The socket is bound to the address specified in
  75          * the constructor.
  76          */
  77         void Open();
  78
  79         /**
  80          * Closes the socket.
  81          *
  82          * The socket can be reopened by calling Open. Closing a
  83          * already closed socket is an illegal operation.
  84          */
  85         void Close();
  86
  87
  88         /** This function is called by aMule when the socket may send. */
  89         virtual void OnSend(int errorCode);
  90         /** This function is called by aMule when there are data to be received. */
  91         virtual void OnReceive(int errorCode);
  92         /** This function is called by aMule when there is an error while receiving. */
  93         virtual void OnReceiveError(int errorCode, uint32 ip, uint16 port);
  94         /** This function is called when the socket is lost (see comments in func.) */
  95         virtual void OnDisconnected(int errorCode);
  96
  97         /**
  98          * Queues a packet for sending.
  99          *
 100          * @param packet The packet to send.
 101          * @param IP The target IP address.
 102          * @param port The target port.
 103          * @param bEncrypt If the packet must be encrypted
 104          * @param port The target port.
 105          * @param pachTargetClientHashORKadID The client hash or Kad ID
 106          * @param bKad
 107          * @param nReceiverVerifyKey
 108          *
 109          * Note that CMuleUDPSocket takes ownership of the packet.
 110          */
 111         void    SendPacket(CPacket* packet, uint32 IP, uint16 port, bool bEncrypt, const uint8* pachTargetClientHashORKadID, bool bKad, uint16 nReceiverVerifyKey);
 112
 113
 114         /**
 115          * Returns true if the socket is Ok, false otherwise.
 116          *
 117          * @see wxSocketBase::Ok
 118          */
 119         bool    Ok();
 120
 121 protected:
 122         /**
 123          * This function is called when a packet has been received.
 124          *
 125          * @param addr The address from where data was received.
 126          * @param buffer The data that has been received.
 127          * @param length The length of the data buffer.
 128          */
 129         virtual void OnPacketReceived(uint32 ip, uint16 port, byte* buffer, size_t length) = 0;
 130
 131
 132         /** See ThrottledControlSocket::SendControlData */
 133         SocketSentBytes  SendControlData(uint32 maxNumberOfBytesToSend, uint32 minFragSize);
 134
 135 private:
 136         /**
 137          * Sends a packet to the specified address.
 138          *
 139          * @param The data to be sent.
 140          * @param length the length of the data buffer.
 141          * @param ip The target ip address.
 142          * @param port The target port.
 143          */
 144         bool    SendTo(char* buffer, uint32 length, uint32 ip, uint16 port);
 145
 146
 147         /**
 148          * Creates a new socket.
 149          *
 150          * Calling this function when a socket already exists
 151          * is an illegal operation.
 152          */
 153         void    CreateSocket();
 154
 155         /**
 156          * Destroys the current socket, if any.
 157          */
 158         void    DestroySocket();
 159
 160
 161         //! Specifies if the last write attempt would cause the socket to block.
 162         bool                                    m_busy;
 163         //! The name of the socket, used for debugging messages.
 164         wxString                                m_name;
 165         //! The socket-ID, used for event-handling.
 166         int                                             m_id;
 167         //! The address at which the socket is currently bound.
 168         amuleIPV4Address                m_addr;
 169         //! Proxy settings used by the socket ...
 170         const CProxyData*               m_proxy;
 171         //! Mutex needed due to the use of the UBT.
 172         wxMutex                                 m_mutex;
 173         //! The currently opened socket, if any.
 174         CEncryptedDatagramSocket*       m_socket;
 175
 176         //! Storage struct used for queueing packets.
 177         struct UDPPack
 178         {
 179                 //! The packet, which at this point is owned by CMuleUDPSocket.
 180                 CPacket*        packet;
 181                 //! The timestamp of when the packet was queued.
 182                 uint32          time;
 183                 //! Target IP address.
 184                 uint32          IP;
 185                 //! Target port.
 186                 uint16          port;
 187                 //! If the packet is encrypted.
 188                 bool    bEncrypt;
 189                 //! Is it a kad packet?
 190                 bool    bKad;
 191                 // The verification key for RC4 encryption.
 192                 uint16 nReceiverVerifyKey;
 193                 // Client hash or kad ID.
 194                 uint8 pachTargetClientHashORKadID[16];
 195         } ;
 196
 197         //! The queue of packets waiting to be sent.
 198         std::list<UDPPack> m_queue;
 199 };
 200
 201 #endif // CLIENTUDPSOCKET_H
 202 // File_checked_for_headers