src/MuleUDPSocket.cpp

   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 #include <wx/wx.h>
  26 #include <algorithm>
  27
  28 #include "MuleUDPSocket.h"              // Interface declarations
  29
  30 #include <protocol/ed2k/Constants.h>
  31
  32 #include "Logger.h"                     // Needed for AddDebugLogLineM
  33 #include "amule.h"                      // Needed for theApp
  34 #include "GetTickCount.h"               // Needed for GetTickCount()
  35 #include "Packet.h"                     // Needed for CPacket
  36 #include <common/StringFunctions.h>     // Needed for unicode2char
  37 #include "Proxy.h"                      // Needed for CDatagramSocketProxy
  38 #include "Logger.h"                     // Needed for AddDebugLogLineM
  39 #include "UploadBandwidthThrottler.h"
  40 #include "EncryptedDatagramSocket.h"
  41 #include "OtherFunctions.h"
  42 #include "kademlia/kademlia/Prefs.h"
  43 #include "ClientList.h"
  44
  45
  46 CMuleUDPSocket::CMuleUDPSocket(const wxString& name, int id, const amuleIPV4Address& address, const CProxyData* ProxyData)
  47 :
  48 m_busy(false),
  49 m_name(name),
  50 m_id(id),
  51 m_addr(address),
  52 m_proxy(ProxyData),
  53 m_socket(NULL)
  54 {
  55 }
  56
  57
  58 CMuleUDPSocket::~CMuleUDPSocket()
  59 {
  60         theApp->uploadBandwidthThrottler->RemoveFromAllQueues(this);
  61
  62         wxMutexLocker lock(m_mutex);
  63         DestroySocket();
  64 }
  65
  66
  67 void CMuleUDPSocket::CreateSocket()
  68 {
  69         wxCHECK_RET(!m_socket, wxT("Socket already opened."));
  70
  71         m_socket = new CEncryptedDatagramSocket(m_addr, wxSOCKET_NOWAIT, m_proxy);
  72         m_socket->SetClientData(this);
  73         m_socket->SetEventHandler(*theApp, m_id);
  74         m_socket->SetNotify(wxSOCKET_INPUT_FLAG | wxSOCKET_OUTPUT_FLAG | wxSOCKET_LOST_FLAG);
  75         m_socket->Notify(true);
  76
  77         if (!m_socket->Ok()) {
  78                 AddDebugLogLineM(true, logMuleUDP, wxT("Failed to create valid ") + m_name);
  79                 DestroySocket();
  80         } else {
  81                 AddLogLineM(false, wxString(wxT("Created ")) << m_name << wxT(" at port ") << m_addr.Service());
  82         }
  83 }
  84
  85
  86 void CMuleUDPSocket::DestroySocket()
  87 {
  88         if (m_socket) {
  89                 AddDebugLogLineM(false, logMuleUDP, wxT("Shutting down ") + m_name);
  90                 m_socket->SetNotify(0);
  91                 m_socket->Notify(false);
  92                 m_socket->Close();
  93                 m_socket->Destroy();
  94                 m_socket = NULL;
  95         }
  96 }
  97
  98
  99 void CMuleUDPSocket::Open()
 100 {
 101         wxMutexLocker lock(m_mutex);
 102
 103         CreateSocket();
 104 }
 105
 106
 107 void CMuleUDPSocket::Close()
 108 {
 109         wxMutexLocker lock(m_mutex);
 110
 111         DestroySocket();
 112 }
 113
 114
 115 void CMuleUDPSocket::OnSend(int errorCode)
 116 {
 117         if (errorCode) {
 118                 return;
 119         }
 120
 121         {
 122                 wxMutexLocker lock(m_mutex);
 123                 m_busy = false;
 124                 if (m_queue.empty()) {
 125                         return;
 126                 }
 127         }
 128
 129         theApp->uploadBandwidthThrottler->QueueForSendingControlPacket(this);
 130 }
 131
 132
 133 const unsigned UDP_BUFFER_SIZE = 16384;
 134
 135
 136 void CMuleUDPSocket::OnReceive(int errorCode)
 137 {
 138         AddDebugLogLineM(false, logMuleUDP, wxString::Format(
 139                 wxT("Got UDP callback for read: Error %i Socket state %i"),
 140                 errorCode, Ok() ? 1 : 0));
 141
 142         char buffer[UDP_BUFFER_SIZE];
 143         wxIPV4address addr;
 144         unsigned length = 0;
 145         bool error = false;
 146         int lastError = 0;
 147
 148         {
 149                 wxMutexLocker lock(m_mutex);
 150
 151                 if (errorCode || (m_socket == NULL) || !m_socket->Ok()) {
 152                         DestroySocket();
 153                         CreateSocket();
 154
 155                         return;
 156                 }
 157
 158
 159                 length = m_socket->RecvFrom(addr, buffer, UDP_BUFFER_SIZE).LastCount();
 160                 error = m_socket->Error();
 161                 lastError = m_socket->LastError();
 162         }
 163
 164         const uint32 ip = StringIPtoUint32(addr.IPAddress());
 165         const uint16 port = addr.Service();
 166         if (error) {
 167                 OnReceiveError(lastError, ip, port);
 168         } else if (length < 2) {
 169                 // 2 bytes (protocol and opcode) is the smallets possible packet.
 170                 AddDebugLogLineM(false, logMuleUDP, m_name + wxT(": Invalid Packet received"));
 171         } else if (!ip) {
 172                 // wxASSERT(0);
 173                 printf("Unknown ip receiving on UDP packet! Ignoring: '%s'\n",
 174                         (const char*)unicode2char(addr.IPAddress()));
 175         } else if (!port) {
 176                 // wxASSERT(0);
 177                 printf("Unknown port receiving an UDP packet! Ignoring\n");
 178         } else if (theApp->clientlist->IsBannedClient(ip)) {
 179                 AddDebugLogLineM(false, logMuleUDP, m_name + wxT(": Dropped packet from banned IP ") + addr.IPAddress());
 180         } else {
 181                 AddDebugLogLineM(false, logMuleUDP, (m_name + wxT(": Packet received ("))
 182                         << addr.IPAddress() << wxT(":") << port << wxT("): ")
 183                         << length << wxT("b"));
 184                 OnPacketReceived(ip, port, (byte*)buffer, length);
 185         }
 186 }
 187
 188
 189 void CMuleUDPSocket::OnReceiveError(int errorCode, uint32 WXUNUSED(ip), uint16 WXUNUSED(port))
 190 {
 191         AddDebugLogLineM(false, logMuleUDP, (m_name + wxT(": Error while reading: ")) << errorCode);
 192 }
 193
 194
 195 void CMuleUDPSocket::OnDisconnected(int WXUNUSED(errorCode))
 196 {
 197         /* Due to bugs in wxWidgets, UDP sockets will sometimes
 198          * be closed. This is caused by the fact that wx treats
 199          * zero-length datagrams as EOF, which is only the case
 200          * when dealing with streaming sockets.
 201          *
 202          * This has been reported as patch #1885472:
 203          * http://sourceforge.net/tracker/index.php?func=detail&aid=1885472&group_id=9863&atid=309863
 204          */
 205         AddDebugLogLineM(true, logMuleUDP, m_name + wxT("Socket died, recreating."));
 206         DestroySocket();
 207         CreateSocket();
 208 }
 209
 210
 211 void CMuleUDPSocket::SendPacket(CPacket* packet, uint32 IP, uint16 port, bool bEncrypt, const uint8* pachTargetClientHashORKadID, bool bKad, uint32 nReceiverVerifyKey)
 212 {
 213         wxCHECK_RET(packet, wxT("Invalid packet."));
 214         /*wxCHECK_RET(port, wxT("Invalid port."));
 215         wxCHECK_RET(IP, wxT("Invalid IP."));
 216         */
 217
 218         if (!port || !IP) {
 219                 return;
 220         }
 221
 222         if (!Ok()) {
 223                 AddDebugLogLineM(false, logMuleUDP, (m_name + wxT(": Packet discarded (socket not Ok): "))
 224                         << Uint32toStringIP(IP) << wxT(":") << port << wxT(" ") << packet->GetPacketSize()
 225                         << wxT("b"));
 226                 delete packet;
 227
 228                 return;
 229         }
 230
 231         AddDebugLogLineM(false, logMuleUDP, (m_name + wxT(": Packet queued: "))
 232                 << Uint32toStringIP(IP) << wxT(":") << port << wxT(" ")
 233                 << packet->GetPacketSize() << wxT("b"));
 234
 235         UDPPack newpending;
 236         newpending.IP = IP;
 237         newpending.port = port;
 238         newpending.packet = packet;
 239         newpending.time = GetTickCount();
 240         newpending.bEncrypt = bEncrypt && (pachTargetClientHashORKadID != NULL || (bKad && nReceiverVerifyKey != 0));
 241         newpending.bKad = bKad;
 242         newpending.nReceiverVerifyKey = nReceiverVerifyKey;
 243         if (newpending.bEncrypt && pachTargetClientHashORKadID != NULL) {
 244                 md4cpy(newpending.pachTargetClientHashORKadID, pachTargetClientHashORKadID);
 245         } else {
 246                 md4clr(newpending.pachTargetClientHashORKadID);
 247         }
 248
 249         {
 250                 wxMutexLocker lock(m_mutex);
 251                 m_queue.push_back(newpending);
 252         }
 253
 254         theApp->uploadBandwidthThrottler->QueueForSendingControlPacket(this);
 255 }
 256
 257
 258 bool CMuleUDPSocket::Ok()
 259 {
 260         wxMutexLocker lock(m_mutex);
 261
 262         return m_socket && m_socket->Ok();
 263 }
 264
 265
 266 SocketSentBytes CMuleUDPSocket::SendControlData(uint32 maxNumberOfBytesToSend, uint32 WXUNUSED(minFragSize))
 267 {
 268         wxMutexLocker lock(m_mutex);
 269         uint32 sentBytes = 0;
 270         while (!m_queue.empty() && !m_busy && (sentBytes < maxNumberOfBytesToSend)) {
 271                 UDPPack item = m_queue.front();
 272                 CPacket* packet = item.packet;
 273                 if (GetTickCount() - item.time < UDPMAXQUEUETIME) {
 274                         uint32_t len = packet->GetPacketSize() + 2;
 275                         uint8_t *sendbuffer = new uint8_t [len];
 276                         memcpy(sendbuffer, packet->GetUDPHeader(), 2);
 277                         memcpy(sendbuffer + 2, packet->GetDataBuffer(), packet->GetPacketSize());
 278
 279                         if (item.bEncrypt && (theApp->GetPublicIP() > 0 || item.bKad)) {
 280                                 len = CEncryptedDatagramSocket::EncryptSendClient(&sendbuffer, len, item.pachTargetClientHashORKadID, item.bKad, item.nReceiverVerifyKey, (item.bKad ? Kademlia::CPrefs::GetUDPVerifyKey(item.IP) : 0));
 281                         }
 282
 283                         if (SendTo(sendbuffer, len, item.IP, item.port)) {
 284                                 sentBytes += len;
 285                                 m_queue.pop_front();
 286                                 delete packet;
 287                                 delete [] sendbuffer;
 288                         } else {
 289                                 // TODO: Needs better error handling, see SentTo
 290                                 delete [] sendbuffer;
 291                                 break;
 292                         }
 293                 } else {
 294                         m_queue.pop_front();
 295                         delete packet;
 296                 }
 297         }
 298         if (!m_busy && !m_queue.empty()) {
 299                 theApp->uploadBandwidthThrottler->QueueForSendingControlPacket(this);
 300         }
 301         SocketSentBytes returnVal = { true, 0, sentBytes };
 302
 303         return returnVal;
 304 }
 305
 306
 307 bool CMuleUDPSocket::SendTo(uint8_t *buffer, uint32_t length, uint32_t ip, uint16_t port)
 308 {
 309         // Just pretend that we sent the packet in order to avoid infinite loops.
 310         if (!(m_socket && m_socket->Ok())) {
 311                 return true;
 312         }
 313
 314         amuleIPV4Address addr;
 315         addr.Hostname(ip);
 316         addr.Service(port);
 317
 318         // We better clear this flag here, status might have been changed
 319         // between the U.B.T. addition and the real sending happening later
 320         m_busy = false;
 321         bool sent = false;
 322         m_socket->SendTo(addr, buffer, length);
 323         if (m_socket->Error()) {
 324                 wxSocketError error = m_socket->LastError();
 325
 326                 if (error == wxSOCKET_WOULDBLOCK) {
 327                         // Socket is busy and can't send this data right now,
 328                         // so we just return not sent and set the wouldblock
 329                         // flag so it gets resent when socket is ready.
 330                         m_busy = true;
 331                 } else {
 332                         // An error which we can't handle happended, so we drop
 333                         // the packet rather than risk entering an infinite loop.
 334                         printf("WARNING! %s discarded packet due to errors (%i) while sending.\n",
 335                                 (const char*)unicode2char(m_name), error);
 336                         sent = true;
 337                 }
 338         } else {
 339                 AddDebugLogLineM(false, logMuleUDP, (m_name + wxT(": Packet sent to "))
 340                         << ip << wxT(":") << port << wxT(": ")
 341                         << length << wxT("b"));
 342                 sent = true;
 343         }
 344
 345         return sent;
 346 }
 347
 348 // File_checked_for_headers