src/libs/ec/cpp/RemoteConnect.cpp

   1 //
   2 // This file is part of the aMule Project.
   3 //
   4 // Copyright (c) 2004-2008 aMule Team ( admin@amule.org / http://www.amule.org )
   5 // Copyright (c) 2004-2008 Angel Vidal ( kry@amule.org )
   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 #include "RemoteConnect.h"
  27
  28 #include <common/MD5Sum.h>
  29 #include <common/Format.h>
  30
  31 #include <wx/intl.h>
  32
  33 using std::auto_ptr;
  34
  35 DEFINE_LOCAL_EVENT_TYPE(wxEVT_EC_CONNECTION)
  36
  37 CECLoginPacket::CECLoginPacket(const wxString& client, const wxString& version)
  38 :
  39 CECPacket(EC_OP_AUTH_REQ)
  40 {
  41         AddTag(CECTag(EC_TAG_CLIENT_NAME, client));
  42         AddTag(CECTag(EC_TAG_CLIENT_VERSION, version));
  43         AddTag(CECTag(EC_TAG_PROTOCOL_VERSION, (uint64)EC_CURRENT_PROTOCOL_VERSION));
  44
  45         #ifdef EC_VERSION_ID
  46         CMD4Hash versionhash;
  47         wxCHECK2(versionhash.Decode(wxT(EC_VERSION_ID)), /* Do nothing. */);
  48         AddTag(CECTag(EC_TAG_VERSION_ID, versionhash));
  49         #endif
  50
  51 }
  52
  53 CECAuthPacket::CECAuthPacket(const wxString& pass)
  54 :
  55 CECPacket(EC_OP_AUTH_PASSWD)
  56 {
  57         CMD4Hash passhash;
  58         wxCHECK2(passhash.Decode(pass), /* Do nothing. */);
  59         AddTag(CECTag(EC_TAG_PASSWD_HASH, passhash));
  60 }
  61
  62 /*!
  63  * Connection to remote core
  64  *
  65  */
  66
  67 CRemoteConnect::CRemoteConnect(wxEvtHandler* evt_handler)
  68 :
  69 CECMuleSocket(evt_handler != 0),
  70 m_ec_state(EC_INIT),
  71 m_req_fifo(),
  72 // Give application some indication about how fast requests are served
  73 // When request fifo contain more that certain number of entries, it may
  74 // indicate that either core or network is slowing us down
  75 m_req_count(0),
  76 // This is not mean to be absolute limit, because we can't drop requests
  77 // out of calling context; it is just signal to application to slow down
  78 m_req_fifo_thr(20),
  79 m_notifier(evt_handler)
  80 {
  81 }
  82
  83 bool CRemoteConnect::ConnectToCore(const wxString &host, int port,
  84         const wxString &WXUNUSED(login), const wxString &pass,
  85         const wxString& client, const wxString& version)
  86 {
  87         m_connectionPassword = pass;
  88
  89         m_client = client;
  90         m_version = version;
  91
  92         // don't even try to connect without a valid password
  93         if (m_connectionPassword.IsEmpty() || m_connectionPassword == wxT("d41d8cd98f00b204e9800998ecf8427e")) {
  94                 m_server_reply = _("You must specify a non-empty password.");
  95                 return false;
  96         } else {
  97                 CMD4Hash hash;
  98                 if (!hash.Decode(m_connectionPassword)) {
  99                         m_server_reply = _("Invalid password, not a MD5 hash!");
 100                         return false;
 101                 } else if (hash.IsEmpty()) {
 102                         m_server_reply = _("You must specify a non-empty password.");
 103                         return false;
 104                 }
 105         }
 106
 107         wxIPV4address addr;
 108
 109         addr.Hostname(host);
 110         addr.Service(port);
 111
 112         if (ConnectSocket(addr)) {
 113                 CECLoginPacket login_req(m_client, m_version);
 114
 115                 std::auto_ptr<const CECPacket> getSalt(SendRecvPacket(&login_req));
 116                 m_ec_state = EC_REQ_SENT;
 117
 118                 ProcessAuthPacket(getSalt.get());
 119
 120                 CECAuthPacket passwdPacket(m_connectionPassword);
 121
 122                 std::auto_ptr<const CECPacket> reply(SendRecvPacket(&passwdPacket));
 123                 m_ec_state = EC_PASSWD_SENT;
 124
 125                 return ProcessAuthPacket(reply.get());
 126         } else if (m_notifier) {
 127                 m_ec_state = EC_CONNECT_SENT;
 128         } else {
 129                 return false;
 130         }
 131
 132         return true;
 133 }
 134
 135 bool CRemoteConnect::IsConnectedToLocalHost()
 136 {
 137         wxIPV4address addr;
 138         return GetPeer(addr) ? addr.IsLocalHost() : false;
 139 }
 140
 141 void CRemoteConnect::WriteDoneAndQueueEmpty()
 142 {
 143 }
 144
 145 void CRemoteConnect::OnConnect() {
 146         if (m_notifier) {
 147                 wxASSERT(m_ec_state == EC_CONNECT_SENT);
 148                 CECLoginPacket login_req(m_client, m_version);
 149                 CECSocket::SendPacket(&login_req);
 150
 151                 m_ec_state = EC_REQ_SENT;
 152         } else {
 153                 // do nothing, calling code will take from here
 154         }
 155 }
 156
 157 void CRemoteConnect::OnLost() {
 158         if (m_notifier) {
 159                 // Notify app of failure
 160                 wxECSocketEvent event(wxEVT_EC_CONNECTION,false,_("Connection failure"));
 161                 m_notifier->AddPendingEvent(event);
 162         }
 163 }
 164
 165 const CECPacket *CRemoteConnect::OnPacketReceived(const CECPacket *packet, uint32 trueSize)
 166 {
 167         CECPacket *next_packet = 0;
 168         m_req_count--;
 169         packet->DebugPrint(true, trueSize);
 170         switch(m_ec_state) {
 171                 case EC_REQ_SENT:
 172                         if (ProcessAuthPacket(packet)) {
 173                                 CECAuthPacket passwdPacket(m_connectionPassword);
 174                                 CECSocket::SendPacket(&passwdPacket);
 175                                 m_ec_state = EC_PASSWD_SENT;
 176                         }
 177                         break;
 178                 case EC_PASSWD_SENT:
 179                         ProcessAuthPacket(packet);
 180                         break;
 181                 case EC_OK:
 182                         if ( !m_req_fifo.empty() ) {
 183                                 CECPacketHandlerBase *handler = m_req_fifo.front();
 184                                 m_req_fifo.pop_front();
 185                                 if ( handler ) {
 186                                         handler->HandlePacket(packet);
 187                                 }
 188                         } else {
 189                                 printf("EC error - packet received, but request fifo is empty\n");
 190                         }
 191                         break;
 192                 default:
 193                         break;
 194         }
 195
 196         // no reply by default
 197         return next_packet;
 198 }
 199
 200 /*
 201  * Our requests are served by core in FCFS order. And core always replies. So, even
 202  * if we're not interested in reply, we preserve place in request fifo.
 203  */
 204 void CRemoteConnect::SendRequest(CECPacketHandlerBase *handler, CECPacket *request)
 205 {
 206         m_req_count++;
 207         m_req_fifo.push_back(handler);
 208         CECSocket::SendPacket(request);
 209 }
 210
 211 void CRemoteConnect::SendPacket(CECPacket *request)
 212 {
 213         SendRequest(0, request);
 214 }
 215
 216 bool CRemoteConnect::ProcessAuthPacket(const CECPacket *reply) {
 217         bool result = false;
 218
 219         if (!reply) {
 220                 m_server_reply = _("EC connection failed. Empty reply.");
 221                 CloseSocket();
 222         } else {
 223                 if ((m_ec_state == EC_REQ_SENT) && (reply->GetOpCode() == EC_OP_AUTH_SALT)) {
 224                                 const CECTag *passwordSalt = reply->GetTagByName(EC_TAG_PASSWD_SALT);
 225                                 if ( NULL != passwordSalt) {
 226                                         wxString saltHash = MD5Sum(CFormat(wxT("%lX")) % passwordSalt->GetInt()).GetHash();
 227                                         m_connectionPassword = MD5Sum(m_connectionPassword.Lower() + saltHash).GetHash();
 228                                         m_ec_state = EC_SALT_RECEIVED;
 229                                         return true;
 230                                 } else {
 231                                         m_server_reply = _("External Connection: Bad reply, handshake failed. Connection closed.");
 232                                         m_ec_state = EC_FAIL;
 233                                         CloseSocket();
 234                                 }
 235                 } else if ((m_ec_state == EC_PASSWD_SENT) && (reply->GetOpCode() == EC_OP_AUTH_OK)) {
 236                         m_ec_state = EC_OK;
 237                         result = true;
 238                         if (reply->GetTagByName(EC_TAG_SERVER_VERSION)) {
 239                                 m_server_reply = _("Succeeded! Connection established to aMule ") +
 240                                         reply->GetTagByName(EC_TAG_SERVER_VERSION)->GetStringData();
 241                         } else {
 242                                 m_server_reply = _("Succeeded! Connection established.");
 243                         }
 244                 }else {
 245                         m_ec_state = EC_FAIL;
 246                         const CECTag *reason = reply->GetTagByName(EC_TAG_STRING);
 247                         if (reason != NULL) {
 248                                 m_server_reply = wxString(_("External Connection: Access denied because: ")) +
 249                                         wxGetTranslation(reason->GetStringData());
 250                         } else {
 251                                 m_server_reply = _("External Connection: Handshake failed.");
 252                         }
 253                         CloseSocket();
 254                 }
 255         }
 256         if ( m_notifier ) {
 257                 wxECSocketEvent event(wxEVT_EC_CONNECTION, result, m_server_reply);
 258                 m_notifier->AddPendingEvent(event);
 259         }
 260         return result;
 261 }
 262
 263 /******************** EC API ***********************/
 264
 265 void CRemoteConnect::StartKad() {
 266         CECPacket req(EC_OP_KAD_START);
 267         SendPacket(&req);
 268 }
 269
 270 void CRemoteConnect::StopKad() {
 271         CECPacket req(EC_OP_KAD_STOP);
 272         SendPacket(&req);
 273 }
 274
 275 void CRemoteConnect::ConnectED2K(uint32 ip, uint16 port) {
 276         CECPacket req(EC_OP_SERVER_CONNECT);
 277         if (ip && port) {
 278                 req.AddTag(CECTag(EC_TAG_SERVER, EC_IPv4_t(ip, port)));
 279         }
 280         SendPacket(&req);
 281 }
 282
 283 void CRemoteConnect::DisconnectED2K() {
 284         CECPacket req(EC_OP_SERVER_DISCONNECT);
 285         SendPacket(&req);
 286 }
 287
 288 void CRemoteConnect::RemoveServer(uint32 ip, uint16 port) {
 289         CECPacket req(EC_OP_SERVER_REMOVE);
 290         if (ip && port) {
 291                 req.AddTag(CECTag(EC_TAG_SERVER, EC_IPv4_t(ip, port)));
 292         }
 293         SendPacket(&req);
 294 }
 295 // File_checked_for_headers