src/LibSocketAsio.cpp

   1 //
   2 // This file is part of the aMule Project.
   3 //
   4 // Copyright (c) 2011-2011 aMule Team ( admin@amule.org / http://www.amule.org )
   5 // Copyright (c) 2011-2011 Stu Redman ( admin@amule.org / http://www.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 "config.h"             // Needed for HAVE_BOOST_SOURCES
  27
  28
  29 #ifdef _MSC_VER
  30 #define _WIN32_WINNT 0x0501     // Boost complains otherwise
  31 #endif
  32
  33 // Windows requires that Boost headers are included before wx headers.
  34 // This works if precompiled headers are disabled for this file.
  35
  36 #define BOOST_ALL_NO_LIB
  37
  38 // Suppress warning caused by faulty boost/preprocessor/config/config.hpp in Boost 1.49
  39 #if defined __GNUC__ && ! defined __GXX_EXPERIMENTAL_CXX0X__ && __cplusplus < 201103L
  40         #define BOOST_PP_VARIADICS 0
  41 #endif
  42
  43 #include <algorithm>    // Needed for std::min - Boost up to 1.54 fails to compile with MSVC 2013 otherwise
  44
  45 #include <boost/asio.hpp>
  46 #include <boost/bind.hpp>
  47 #include <boost/version.hpp>
  48
  49 //
  50 // Do away with building Boost.System, adding lib paths...
  51 // Just include the single file and be done.
  52 //
  53 #ifdef HAVE_BOOST_SOURCES
  54 #       include <boost/../libs/system/src/error_code.cpp>
  55 #else
  56 #       include <boost/system/error_code.hpp>
  57 #endif
  58
  59 #include "LibSocket.h"
  60 #include <wx/thread.h>          // wxMutex
  61 #include <wx/intl.h>            // _()
  62 #include <common/Format.h>      // Needed for CFormat
  63 #include "Logger.h"
  64 #include "GuiEvents.h"
  65 #include "amuleIPV4Address.h"
  66 #include "MuleUDPSocket.h"
  67 #include "OtherFunctions.h"     // DeleteContents
  68 #include "ScopedPtr.h"
  69 #include <common/Macros.h>
  70
  71 using namespace boost::asio;
  72 using namespace boost::system;  // for error_code
  73 static io_service s_io_service;
  74
  75 // Number of threads in the Asio thread pool
  76 const int CAsioService::m_numberOfThreads = 4;
  77
  78 /**
  79  * ASIO Client TCP socket implementation
  80  */
  81
  82 class CamuleIPV4Endpoint : public ip::tcp::endpoint {
  83 public:
  84         CamuleIPV4Endpoint() {}
  85
  86         CamuleIPV4Endpoint(const CamuleIPV4Endpoint & impl) : ip::tcp::endpoint(impl) {}
  87         CamuleIPV4Endpoint(const ip::tcp::endpoint & ep) { * this = ep; }
  88         CamuleIPV4Endpoint(const ip::udp::endpoint & ep) { address(ep.address()); port(ep.port()); }
  89
  90         const CamuleIPV4Endpoint& operator = (const ip::tcp::endpoint & ep)
  91         {
  92                 * (ip::tcp::endpoint *) this = ep;
  93                 return *this;
  94         }
  95 };
  96
  97 class CAsioSocketImpl
  98 {
  99 public:
 100         // cppcheck-suppress uninitMemberVar m_readBufferPtr
 101         CAsioSocketImpl(CLibSocket * libSocket) :
 102                 m_libSocket(libSocket),
 103                 m_strand(s_io_service),
 104                 m_timer(s_io_service)
 105         {
 106                 m_OK = false;
 107                 m_blocksRead = false;
 108                 m_blocksWrite = false;
 109                 m_ErrorCode = 0;
 110                 m_readBuffer = NULL;
 111                 m_readBufferSize = 0;
 112                 m_readPending = false;
 113                 m_readBufferContent = 0;
 114                 m_eventPending = false;
 115                 m_port = 0;
 116                 m_sendBuffer = NULL;
 117                 m_connected = false;
 118                 m_closed = false;
 119                 m_isDestroying = false;
 120                 m_proxyState = false;
 121                 m_notify = true;
 122                 m_sync = false;
 123                 m_IP = wxT("?");
 124                 m_IPint = 0;
 125                 m_socket = new ip::tcp::socket(s_io_service);
 126
 127                 // Set socket to non blocking
 128                 m_socket->non_blocking();
 129         }
 130
 131         ~CAsioSocketImpl()
 132         {
 133                 delete[] m_readBuffer;
 134                 delete[] m_sendBuffer;
 135         }
 136
 137         void Notify(bool notify)
 138         {
 139                 m_notify = notify;
 140         }
 141
 142         bool Connect(const amuleIPV4Address& adr, bool wait)
 143         {
 144                 if (!m_proxyState) {
 145                         SetIp(adr);
 146                 }
 147                 m_port = adr.Service();
 148                 m_closed = false;
 149                 m_OK = false;
 150                 m_sync = !m_notify;             // set this once for the whole lifetime of the socket
 151                 AddDebugLogLineF(logAsio, CFormat(wxT("Connect %s %p")) % m_IP % this);
 152
 153                 if (wait || m_sync) {
 154                         error_code ec;
 155                         m_socket->connect(adr.GetEndpoint(), ec);
 156                         m_OK = !ec;
 157                         m_connected = m_OK;
 158                         return m_OK;
 159                 } else {
 160                         m_socket->async_connect(adr.GetEndpoint(),
 161                                 m_strand.wrap(boost::bind(& CAsioSocketImpl::HandleConnect, this, placeholders::error)));
 162                         // m_OK and return are false because we are not connected yet
 163                         return false;
 164                 }
 165         }
 166
 167         bool IsConnected() const
 168         {
 169                 return m_connected;
 170         }
 171
 172         // For wxSocketClient, Ok won't return true unless the client is connected to a server.
 173         bool IsOk() const
 174         {
 175                 return m_OK;
 176         }
 177
 178         bool IsDestroying() const
 179         {
 180                 return m_isDestroying;
 181         }
 182
 183         // Returns the actual error code
 184         int LastError() const
 185         {
 186                 return m_ErrorCode;
 187         }
 188
 189         // Is reading blocked?
 190         bool BlocksRead() const
 191         {
 192                 return m_blocksRead;
 193         }
 194
 195         // Is writing blocked?
 196         bool BlocksWrite() const
 197         {
 198                 return m_blocksWrite;
 199         }
 200
 201         // Problem: wx sends an event when data gets available, so first there is an event, then Read() is called
 202         // Asio can read async with callback, so you first read, then you get an event.
 203         // Strategy:
 204         // - Read some data in background into a buffer
 205         // - Callback posts event when something is there
 206         // - Read data from buffer
 207         // - If data is exhausted, start reading more in background
 208         // - If not, post another event (making sure events don't pile up though)
 209         uint32 Read(char * buf, uint32 bytesToRead)
 210         {
 211                 if (bytesToRead == 0) {                 // huh?
 212                         return 0;
 213                 }
 214
 215                 if (m_sync) {
 216                         return ReadSync(buf, bytesToRead);
 217                 }
 218
 219                 if (m_ErrorCode) {
 220                         AddDebugLogLineF(logAsio, CFormat(wxT("Read1 %s %d - Error")) % m_IP % bytesToRead);
 221                         return 0;
 222                 }
 223
 224                 if (m_readPending                                       // Background read hasn't completed.
 225                         || m_readBufferContent == 0) {  // shouldn't be if it's not pending
 226
 227                         m_blocksRead = true;
 228                         AddDebugLogLineF(logAsio, CFormat(wxT("Read1 %s %d - Block")) % m_IP % bytesToRead);
 229                         return 0;
 230                 }
 231
 232                 m_blocksRead = false;   // shouldn't be needed
 233
 234                 // Read from our buffer
 235                 uint32 readCache = std::min(m_readBufferContent, bytesToRead);
 236                 memcpy(buf, m_readBufferPtr, readCache);
 237                 m_readBufferContent     -= readCache;
 238                 m_readBufferPtr         += readCache;
 239
 240                 AddDebugLogLineF(logAsio, CFormat(wxT("Read2 %s %d - %d")) % m_IP % bytesToRead % readCache);
 241                 if (m_readBufferContent) {
 242                         // Data left, post another event
 243                         PostReadEvent(1);
 244                 } else {
 245                         // Nothing left, read more
 246                         StartBackgroundRead();
 247                 }
 248                 return readCache;
 249         }
 250
 251
 252         // Make a copy of the data and send it in background
 253         // - unless a background send is already going on
 254         uint32 Write(const void * buf, uint32 nbytes)
 255         {
 256                 if (m_sync) {
 257                         return WriteSync(buf, nbytes);
 258                 }
 259
 260                 if (m_sendBuffer) {
 261                         m_blocksWrite = true;
 262                         AddDebugLogLineF(logAsio, CFormat(wxT("Write blocks %d %p %s")) % nbytes % m_sendBuffer % m_IP);
 263                         return 0;
 264                 }
 265                 AddDebugLogLineF(logAsio, CFormat(wxT("Write %d %s")) % nbytes % m_IP);
 266                 m_sendBuffer = new char[nbytes];
 267                 memcpy(m_sendBuffer, buf, nbytes);
 268                 m_strand.dispatch(boost::bind(& CAsioSocketImpl::DispatchWrite, this, nbytes));
 269                 m_ErrorCode = 0;
 270                 return nbytes;
 271         }
 272
 273
 274         void Close()
 275         {
 276                 if (!m_closed) {
 277                         m_closed = true;
 278                         m_connected = false;
 279                         if (m_sync || s_io_service.stopped()) {
 280                                 DispatchClose();
 281                         } else {
 282                                 m_strand.dispatch(boost::bind(& CAsioSocketImpl::DispatchClose, this));
 283                         }
 284                 }
 285         }
 286
 287
 288         void Destroy()
 289         {
 290                 if (m_isDestroying) {
 291                         AddDebugLogLineC(logAsio, CFormat(wxT("Destroy() already dying socket %p %p %s")) % m_libSocket % this % m_IP);
 292                         return;
 293                 }
 294                 m_isDestroying = true;
 295                 AddDebugLogLineF(logAsio, CFormat(wxT("Destroy() %p %p %s")) % m_libSocket % this % m_IP);
 296                 Close();
 297                 if (m_sync || s_io_service.stopped()) {
 298                         HandleDestroy();
 299                 } else {
 300                         // Close prevents creation of any more callbacks, but does not clear any callbacks already
 301                         // sitting in Asio's event queue (I have seen such a crash).
 302                         // So create a delay timer so they can be called until core is notified.
 303                         m_timer.expires_from_now(boost::posix_time::seconds(1));
 304                         m_timer.async_wait(m_strand.wrap(boost::bind(& CAsioSocketImpl::HandleDestroy, this)));
 305                 }
 306         }
 307
 308
 309         wxString GetPeer()
 310         {
 311                 return m_IP;
 312         }
 313
 314         uint32 GetPeerInt()
 315         {
 316                 return m_IPint;
 317         }
 318
 319         //
 320         // Bind socket to local endpoint if user wants to choose the local address
 321         //
 322         void SetLocal(const amuleIPV4Address& local)
 323         {
 324                 error_code ec;
 325                 if (!m_socket->is_open()) {
 326                         // Socket is usually still closed when this is called
 327                         m_socket->open(boost::asio::ip::tcp::v4(), ec);
 328                         if (ec) {
 329                                 AddDebugLogLineC(logAsio, CFormat(wxT("Can't open socket : %s")) % ec.message());
 330                         }
 331                 }
 332                 //
 333                 // We are using random (OS-defined) local ports.
 334                 // To set a constant output port, first call
 335                 // m_socket->set_option(socket_base::reuse_address(true));
 336                 // and then set the endpoint's port to it.
 337                 //
 338                 CamuleIPV4Endpoint endpoint(local.GetEndpoint());
 339                 endpoint.port(0);
 340                 m_socket->bind(endpoint, ec);
 341                 if (ec) {
 342                         AddDebugLogLineC(logAsio, CFormat(wxT("Can't bind socket to local endpoint %s : %s"))
 343                                 % local.IPAddress() % ec.message());
 344                 } else {
 345                         AddDebugLogLineF(logAsio, CFormat(wxT("Bound socket to local endpoint %s")) % local.IPAddress());
 346                 }
 347         }
 348
 349
 350         void EventProcessed()
 351         {
 352                 m_eventPending = false;
 353         }
 354
 355         void SetWrapSocket(CLibSocket * socket)
 356         {
 357                 m_libSocket = socket;
 358                 // Also do some setting up
 359                 m_OK = true;
 360                 m_connected = true;
 361                 // Start reading
 362                 StartBackgroundRead();
 363         }
 364
 365         bool UpdateIP()
 366         {
 367                 error_code ec;
 368                 amuleIPV4Address addr = CamuleIPV4Endpoint(m_socket->remote_endpoint(ec));
 369                 if (SetError(ec)) {
 370                         AddDebugLogLineN(logAsio, CFormat(wxT("UpdateIP failed %p %s")) % this % ec.message());
 371                         return false;
 372                 }
 373                 SetIp(addr);
 374                 m_port = addr.Service();
 375                 AddDebugLogLineF(logAsio, CFormat(wxT("UpdateIP %s %d %p")) % m_IP % m_port % this);
 376                 return true;
 377         }
 378
 379         const wxChar * GetIP() const { return m_IP; }
 380         uint16 GetPort() const { return m_port; }
 381
 382         ip::tcp::socket & GetAsioSocket()
 383         {
 384                 return * m_socket;
 385         }
 386
 387         bool GetProxyState() const { return m_proxyState; }
 388
 389         void SetProxyState(bool state, const amuleIPV4Address * adr)
 390         {
 391                 m_proxyState = state;
 392                 if (state) {
 393                         // Start. Get the true IP for logging.
 394                         wxASSERT(adr);
 395                         SetIp(*adr);
 396                         AddDebugLogLineF(logAsio, CFormat(wxT("SetProxyState to proxy %s")) % m_IP);
 397                 } else {
 398                         // Transition from proxy to normal mode
 399                         AddDebugLogLineF(logAsio, CFormat(wxT("SetProxyState to normal %s")) % m_IP);
 400                         m_ErrorCode = 0;
 401                 }
 402         }
 403
 404 private:
 405         //
 406         // Dispatch handlers
 407         // Access to m_socket is all bundled in the thread running s_io_service to avoid
 408         // concurrent access to the socket from several threads.
 409         // So once things are running (after connect), all access goes through one of these handlers.
 410         //
 411         void DispatchClose()
 412         {
 413                 error_code ec;
 414                 m_socket->close(ec);
 415                 if (ec) {
 416                         AddDebugLogLineC(logAsio, CFormat(wxT("Close error %s %s")) % m_IP % ec.message());
 417                 } else {
 418                         AddDebugLogLineF(logAsio, CFormat(wxT("Closed %s")) % m_IP);
 419                 }
 420         }
 421
 422         void DispatchBackgroundRead()
 423         {
 424                 AddDebugLogLineF(logAsio, CFormat(wxT("DispatchBackgroundRead %s")) % m_IP);
 425                 m_socket->async_read_some(null_buffers(),
 426                         m_strand.wrap(boost::bind(& CAsioSocketImpl::HandleRead, this, placeholders::error)));
 427         }
 428
 429         void DispatchWrite(uint32 nbytes)
 430         {
 431                 async_write(*m_socket, buffer(m_sendBuffer, nbytes),
 432                         m_strand.wrap(boost::bind(& CAsioSocketImpl::HandleSend, this, placeholders::error, placeholders::bytes_transferred)));
 433         }
 434
 435         //
 436         // Completion handlers for async requests
 437         //
 438
 439         void HandleConnect(const error_code& err)
 440         {
 441                 m_OK = !err;
 442                 AddDebugLogLineF(logAsio, CFormat(wxT("HandleConnect %d %s")) % m_OK % m_IP);
 443                 if (m_isDestroying) {
 444                         AddDebugLogLineF(logAsio, CFormat(wxT("HandleConnect: socket pending for deletion %s")) % m_IP);
 445                 } else {
 446                         CoreNotify_LibSocketConnect(m_libSocket, err.value());
 447                         if (m_OK) {
 448                                 // After connect also send a OUTPUT event to show data is available
 449                                 CoreNotify_LibSocketSend(m_libSocket, 0);
 450                                 // Start reading
 451                                 StartBackgroundRead();
 452                                 m_connected = true;
 453                         }
 454                 }
 455         }
 456
 457         void HandleSend(const error_code& err, size_t DEBUG_ONLY(bytes_transferred) )
 458         {
 459                 delete[] m_sendBuffer;
 460                 m_sendBuffer = NULL;
 461
 462                 if (m_isDestroying) {
 463                         AddDebugLogLineF(logAsio, CFormat(wxT("HandleSend: socket pending for deletion %s")) % m_IP);
 464                 } else {
 465                         if (SetError(err)) {
 466                                 AddDebugLogLineN(logAsio, CFormat(wxT("HandleSend Error %d %s")) % bytes_transferred % m_IP);
 467                                 PostLostEvent();
 468                         } else {
 469                                 AddDebugLogLineF(logAsio, CFormat(wxT("HandleSend %d %s")) % bytes_transferred % m_IP);
 470                                 m_blocksWrite = false;
 471                                 CoreNotify_LibSocketSend(m_libSocket, m_ErrorCode);
 472                         }
 473                 }
 474         }
 475
 476         void HandleRead(const error_code & ec)
 477         {
 478                 if (m_isDestroying) {
 479                         AddDebugLogLineF(logAsio, CFormat(wxT("HandleRead: socket pending for deletion %s")) % m_IP);
 480                 }
 481
 482                 if (SetError(ec)) {
 483                         // This is what we get in Windows when a connection gets closed from remote.
 484                         AddDebugLogLineN(logAsio, CFormat(wxT("HandleReadError %s %s")) % m_IP % ec.message());
 485                         PostLostEvent();
 486                         return;
 487                 }
 488
 489                 error_code ec2;
 490                 uint32 avail = m_socket->available(ec2);
 491                 if (SetError(ec2)) {
 492                         AddDebugLogLineN(logAsio, CFormat(wxT("HandleReadError available %d %s %s")) % avail % m_IP % ec2.message());
 493                         PostLostEvent();
 494                         return;
 495                 }
 496                 if (avail == 0) {
 497                         // This is what we get in Linux when a connection gets closed from remote.
 498                         AddDebugLogLineF(logAsio, CFormat(wxT("HandleReadError nothing available %s")) % m_IP);
 499                         SetError();
 500                         PostLostEvent();
 501                         return;
 502                 }
 503                 AddDebugLogLineF(logAsio, CFormat(wxT("HandleRead %d %s")) % avail % m_IP);
 504
 505                 // adjust (or create) our read buffer
 506                 if (m_readBufferSize < avail) {
 507                         delete[] m_readBuffer;
 508                         m_readBuffer = new char[avail];
 509                         m_readBufferSize = avail;
 510                 }
 511                 m_readBufferPtr = m_readBuffer;
 512
 513                 // read available data
 514                 m_readBufferContent = m_socket->read_some(buffer(m_readBuffer, avail), ec2);
 515                 if (SetError(ec2) || m_readBufferContent == 0) {
 516                         AddDebugLogLineN(logAsio, CFormat(wxT("HandleReadError read %d %s %s")) % m_readBufferContent % m_IP % ec2.message());
 517                         PostLostEvent();
 518                         return;
 519                 }
 520
 521                 m_readPending = false;
 522                 m_blocksRead = false;
 523                 PostReadEvent(2);
 524         }
 525
 526         void HandleDestroy()
 527         {
 528                 AddDebugLogLineF(logAsio, CFormat(wxT("HandleDestroy() %p %p %s")) % m_libSocket % this % m_IP);
 529                 CoreNotify_LibSocketDestroy(m_libSocket);
 530         }
 531
 532
 533         //
 534         // Other functions
 535         //
 536
 537         void StartBackgroundRead()
 538         {
 539                 m_readPending = true;
 540                 m_readBufferContent = 0;
 541                 m_strand.dispatch(boost::bind(& CAsioSocketImpl::DispatchBackgroundRead, this));
 542         }
 543
 544         void PostReadEvent(int DEBUG_ONLY(from) )
 545         {
 546                 if (!m_eventPending) {
 547                         AddDebugLogLineF(logAsio, CFormat(wxT("Post read event %d %s")) % from % m_IP);
 548                         m_eventPending = true;
 549                         CoreNotify_LibSocketReceive(m_libSocket, m_ErrorCode);
 550                 }
 551         }
 552
 553         void PostLostEvent()
 554         {
 555                 if (!m_isDestroying && !m_closed) {
 556                         CoreNotify_LibSocketLost(m_libSocket);
 557                 }
 558         }
 559
 560         void SetError()
 561         {
 562                 m_ErrorCode = 2;
 563         }
 564
 565         bool SetError(const error_code & err)
 566         {
 567                 m_ErrorCode = err.value();
 568                 return m_ErrorCode != errc::success;
 569         }
 570
 571         //
 572         // Synchronous sockets (amulecmd)
 573         //
 574         uint32 ReadSync(char * buf, uint32 bytesToRead)
 575         {
 576                 error_code ec;
 577                 uint32 received = read(*m_socket, buffer(buf, bytesToRead), ec);
 578                 SetError(ec);
 579                 return received;
 580         }
 581
 582         uint32 WriteSync(const void * buf, uint32 nbytes)
 583         {
 584                 error_code ec;
 585                 uint32 sent = write(*m_socket, buffer(buf, nbytes), ec);
 586                 SetError(ec);
 587                 return sent;
 588         }
 589
 590         //
 591         // Access to even const & wxString is apparently not thread-safe.
 592         // Locks are set/removed in wx and reference counts can go astray.
 593         // So store our IP string in a wxString which is used nowhere.
 594         // Store a pointer to its string buffer as well and use THAT everywhere.
 595         //
 596         void SetIp(const amuleIPV4Address& adr)
 597         {
 598                 m_IPstring = adr.IPAddress();
 599                 m_IP = m_IPstring.c_str();
 600                 m_IPint = StringIPtoUint32(m_IPstring);
 601         }
 602
 603         CLibSocket      *       m_libSocket;
 604         ip::tcp::socket *       m_socket;
 605                                                                                 // remote IP
 606         wxString                m_IPstring;                     // as String (use nowhere because of threading!)
 607         const wxChar *  m_IP;                           // as char*  (use in debug logs)
 608         uint32                  m_IPint;                        // as int
 609         uint16                  m_port;                         // remote port
 610         bool                    m_OK;
 611         int                             m_ErrorCode;
 612         bool                    m_blocksRead;
 613         bool                    m_blocksWrite;
 614         char *                  m_readBuffer;
 615         uint32                  m_readBufferSize;
 616         char *                  m_readBufferPtr;
 617         bool                    m_readPending;
 618         uint32                  m_readBufferContent;
 619         bool                    m_eventPending;
 620         char *                  m_sendBuffer;
 621         io_service::strand      m_strand;               // handle synchronisation in io_service thread pool
 622         deadline_timer  m_timer;
 623         bool                    m_connected;
 624         bool                    m_closed;
 625         bool                    m_isDestroying;         // true if Destroy() was called
 626         bool                    m_proxyState;
 627         bool                    m_notify;                       // set by Notify()
 628         bool                    m_sync;                         // copied from !m_notify on Connect()
 629 };
 630
 631
 632 /**
 633  * Library socket wrapper
 634  */
 635
 636 CLibSocket::CLibSocket(int /* flags */)
 637 {
 638         m_aSocket = new CAsioSocketImpl(this);
 639 }
 640
 641
 642 CLibSocket::~CLibSocket()
 643 {
 644         AddDebugLogLineF(logAsio, CFormat(wxT("~CLibSocket() %p %p %s")) % this % m_aSocket % m_aSocket->GetIP());
 645         delete m_aSocket;
 646 }
 647
 648
 649 bool CLibSocket::Connect(const amuleIPV4Address& adr, bool wait)
 650 {
 651         return m_aSocket->Connect(adr, wait);
 652 }
 653
 654
 655 bool CLibSocket::IsConnected() const
 656 {
 657         return m_aSocket->IsConnected();
 658 }
 659
 660
 661 bool CLibSocket::IsOk() const
 662 {
 663         return m_aSocket->IsOk();
 664 }
 665
 666
 667 wxString CLibSocket::GetPeer()
 668 {
 669         return m_aSocket->GetPeer();
 670 }
 671
 672
 673 uint32 CLibSocket::GetPeerInt()
 674 {
 675         return m_aSocket->GetPeerInt();
 676 }
 677
 678
 679 void CLibSocket::Destroy()
 680 {
 681         m_aSocket->Destroy();
 682 }
 683
 684
 685 bool CLibSocket::IsDestroying() const
 686 {
 687         return m_aSocket->IsDestroying();
 688 }
 689
 690
 691 void CLibSocket::Notify(bool notify)
 692 {
 693         m_aSocket->Notify(notify);
 694 }
 695
 696
 697 uint32 CLibSocket::Read(void * buffer, uint32 nbytes)
 698 {
 699         return m_aSocket->Read((char *) buffer, nbytes);
 700 }
 701
 702
 703 uint32 CLibSocket::Write(const void * buffer, uint32 nbytes)
 704 {
 705         return m_aSocket->Write(buffer, nbytes);
 706 }
 707
 708
 709 void CLibSocket::Close()
 710 {
 711         m_aSocket->Close();
 712 }
 713
 714
 715 int CLibSocket::LastError() const
 716 {
 717         return m_aSocket->LastError();
 718 }
 719
 720
 721 void CLibSocket::SetLocal(const amuleIPV4Address& local)
 722 {
 723         m_aSocket->SetLocal(local);
 724 }
 725
 726
 727
 728 // new Stuff
 729
 730 bool CLibSocket::BlocksRead() const
 731 {
 732         return m_aSocket->BlocksRead();
 733 }
 734
 735
 736 bool CLibSocket::BlocksWrite() const
 737 {
 738         return m_aSocket->BlocksWrite();
 739 }
 740
 741
 742 void CLibSocket::EventProcessed()
 743 {
 744         m_aSocket->EventProcessed();
 745 }
 746
 747
 748 void CLibSocket::LinkSocketImpl(class CAsioSocketImpl * socket)
 749 {
 750         delete m_aSocket;
 751         m_aSocket = socket;
 752         m_aSocket->SetWrapSocket(this);
 753 }
 754
 755
 756 const wxChar * CLibSocket::GetIP() const
 757 {
 758         return m_aSocket->GetIP();
 759 }
 760
 761
 762 bool CLibSocket::GetProxyState() const
 763 {
 764         return m_aSocket->GetProxyState();
 765 }
 766
 767
 768 void CLibSocket::SetProxyState(bool state, const amuleIPV4Address * adr)
 769 {
 770         m_aSocket->SetProxyState(state, adr);
 771 }
 772
 773
 774 /**
 775  * ASIO TCP socket server
 776  */
 777
 778 class CAsioSocketServerImpl : public ip::tcp::acceptor
 779 {
 780 public:
 781         CAsioSocketServerImpl(const amuleIPV4Address & adr, CLibSocketServer * libSocketServer)
 782                 : ip::tcp::acceptor(s_io_service),
 783                   m_libSocketServer(libSocketServer),
 784                   m_currentSocket(NULL),
 785                   m_strand(s_io_service)
 786         {
 787                 m_ok = false;
 788                 m_socketAvailable = false;
 789
 790                 try {
 791                         open(adr.GetEndpoint().protocol());
 792                         set_option(ip::tcp::acceptor::reuse_address(true));
 793                         bind(adr.GetEndpoint());
 794                         listen();
 795                         StartAccept();
 796                         m_ok = true;
 797                         AddDebugLogLineN(logAsio, CFormat(wxT("CAsioSocketServerImpl bind to %s %d")) % adr.IPAddress() % adr.Service());
 798                 } catch (const system_error& err) {
 799                         AddDebugLogLineC(logAsio, CFormat(wxT("CAsioSocketServerImpl bind to %s %d failed - %s")) % adr.IPAddress() % adr.Service() % err.code().message());
 800                 }
 801         }
 802
 803         ~CAsioSocketServerImpl()
 804         {
 805         }
 806
 807         // For wxSocketServer, Ok will return true if the server could bind to the specified address and is already listening for new connections.
 808         bool IsOk() const { return m_ok; }
 809
 810         void Close() { close(); }
 811
 812         bool AcceptWith(CLibSocket & socket)
 813         {
 814                 if (!m_socketAvailable) {
 815                         AddDebugLogLineF(logAsio, wxT("AcceptWith: nothing there"));
 816                         return false;
 817                 }
 818
 819                 // return the socket we received
 820                 socket.LinkSocketImpl(m_currentSocket.release());
 821
 822                 // check if we have another socket ready for reception
 823                 m_currentSocket.reset(new CAsioSocketImpl(NULL));
 824                 error_code ec;
 825                 // async_accept does not work if server is non-blocking
 826                 // temporarily switch it to non-blocking
 827                 non_blocking(true);
 828                 // we are set to non-blocking, so this returns right away
 829                 accept(m_currentSocket->GetAsioSocket(), ec);
 830                 // back to blocking
 831                 non_blocking(false);
 832                 if (ec || !m_currentSocket->UpdateIP()) {
 833                         // nothing there
 834                         m_socketAvailable = false;
 835                         // start getting another one
 836                         StartAccept();
 837                         AddDebugLogLineF(logAsio, wxT("AcceptWith: ok, getting another socket in background"));
 838                 } else {
 839                         // we got another socket right away
 840                         m_socketAvailable = true;       // it is already true, but this improves readability
 841                         AddDebugLogLineF(logAsio, wxT("AcceptWith: ok, another socket is available"));
 842                         // aMule actually doesn't need a notification as it polls the listen socket.
 843                         // amuleweb does need it though
 844                         CoreNotify_ServerTCPAccept(m_libSocketServer);
 845                 }
 846
 847                 return true;
 848         }
 849
 850         bool SocketAvailable() const { return m_socketAvailable; }
 851
 852 private:
 853
 854         void StartAccept()
 855         {
 856                 m_currentSocket.reset(new CAsioSocketImpl(NULL));
 857                 async_accept(m_currentSocket->GetAsioSocket(),
 858                         m_strand.wrap(boost::bind(& CAsioSocketServerImpl::HandleAccept, this, placeholders::error)));
 859         }
 860
 861         void HandleAccept(const error_code& error)
 862         {
 863                 if (error) {
 864                         AddDebugLogLineC(logAsio, CFormat(wxT("Error in HandleAccept: %s")) % error.message());
 865                 } else {
 866                         if (m_currentSocket->UpdateIP()) {
 867                                 AddDebugLogLineN(logAsio, CFormat(wxT("HandleAccept received a connection from %s:%d"))
 868                                         % m_currentSocket->GetIP() % m_currentSocket->GetPort());
 869                                 m_socketAvailable = true;
 870                                 CoreNotify_ServerTCPAccept(m_libSocketServer);
 871                                 return;
 872                         } else {
 873                                 AddDebugLogLineN(logAsio, wxT("Error in HandleAccept: invalid socket"));
 874                         }
 875                 }
 876                 // We were not successful. Try again.
 877                 // Post the request to the event queue to make sure it doesn't get called immediately.
 878                 m_strand.post(boost::bind(& CAsioSocketServerImpl::StartAccept, this));
 879         }
 880
 881         // The wrapper object
 882         CLibSocketServer * m_libSocketServer;
 883         // Startup ok
 884         bool m_ok;
 885         // The last socket that connected to us
 886         CScopedPtr<CAsioSocketImpl> m_currentSocket;
 887         // Is there a socket available?
 888         bool m_socketAvailable;
 889         io_service::strand      m_strand;               // handle synchronisation in io_service thread pool
 890 };
 891
 892
 893 CLibSocketServer::CLibSocketServer(const amuleIPV4Address& adr, int /* flags */)
 894 {
 895         m_aServer = new CAsioSocketServerImpl(adr, this);
 896 }
 897
 898
 899 CLibSocketServer::~CLibSocketServer()
 900 {
 901         delete m_aServer;
 902 }
 903
 904
 905 // Accepts an incoming connection request, and creates a new CLibSocket object which represents the server-side of the connection.
 906 // Only used in CamuleApp::ListenSocketHandler() and we don't get there.
 907 CLibSocket * CLibSocketServer::Accept(bool /* wait */)
 908 {
 909         wxFAIL;
 910         return NULL;
 911 }
 912
 913
 914 // Accept an incoming connection using the specified socket object.
 915 bool CLibSocketServer::AcceptWith(CLibSocket & socket, bool WXUNUSED_UNLESS_DEBUG(wait) )
 916 {
 917         wxASSERT(!wait);
 918         return m_aServer->AcceptWith(socket);
 919 }
 920
 921
 922 bool CLibSocketServer::IsOk() const
 923 {
 924         return m_aServer->IsOk();
 925 }
 926
 927
 928 void CLibSocketServer::Close()
 929 {
 930         m_aServer->Close();
 931 }
 932
 933
 934 bool CLibSocketServer::SocketAvailable()
 935 {
 936         return m_aServer->SocketAvailable();
 937 }
 938
 939
 940 /**
 941  * ASIO UDP socket implementation
 942  */
 943
 944 class CAsioUDPSocketImpl
 945 {
 946 private:
 947         // UDP data block
 948         class CUDPData {
 949         public:
 950                 char * buffer;
 951                 uint32 size;
 952                 amuleIPV4Address ipadr;
 953
 954                 CUDPData(const void * src, uint32 _size, amuleIPV4Address adr) :
 955                         size(_size), ipadr(adr)
 956                 {
 957                         buffer = new char[size];
 958                         memcpy(buffer, src, size);
 959                 }
 960
 961                 ~CUDPData()
 962                 {
 963                         delete[] buffer;
 964                 }
 965         };
 966
 967 public:
 968         CAsioUDPSocketImpl(const amuleIPV4Address &address, int /* flags */, CLibUDPSocket * libSocket) :
 969                 m_libSocket(libSocket),
 970                 m_strand(s_io_service),
 971                 m_timer(s_io_service),
 972                 m_address(address)
 973         {
 974                 m_muleSocket = NULL;
 975                 m_socket = NULL;
 976                 m_readBuffer = new char[CMuleUDPSocket::UDP_BUFFER_SIZE];
 977                 m_OK = true;
 978                 CreateSocket();
 979         }
 980
 981         ~CAsioUDPSocketImpl()
 982         {
 983                 AddDebugLogLineF(logAsio, wxT("UDP ~CAsioUDPSocketImpl"));
 984                 delete m_socket;
 985                 delete[] m_readBuffer;
 986                 DeleteContents(m_receiveBuffers);
 987         }
 988
 989         void SetClientData(CMuleUDPSocket * muleSocket)
 990         {
 991                 AddDebugLogLineF(logAsio, wxT("UDP SetClientData"));
 992                 m_muleSocket = muleSocket;
 993         }
 994
 995         uint32 RecvFrom(amuleIPV4Address& addr, void* buf, uint32 nBytes)
 996         {
 997                 CUDPData * recdata;
 998                 {
 999                         wxMutexLocker lock(m_receiveBuffersLock);
1000                         if (m_receiveBuffers.empty()) {
1001                                 AddDebugLogLineN(logAsio, wxT("UDP RecvFromError no data"));
1002                                 return 0;
1003                         }
1004                         recdata = * m_receiveBuffers.begin();
1005                         m_receiveBuffers.pop_front();
1006                 }
1007                 uint32 read = recdata->size;
1008                 if (read > nBytes) {
1009                         // should not happen
1010                         AddDebugLogLineN(logAsio, CFormat(wxT("UDP RecvFromError too much data %d")) % read);
1011                         read = nBytes;
1012                 }
1013                 memcpy(buf, recdata->buffer, read);
1014                 addr = recdata->ipadr;
1015                 delete recdata;
1016                 return read;
1017         }
1018
1019         uint32 SendTo(const amuleIPV4Address& addr, const void* buf, uint32 nBytes)
1020         {
1021                 // Collect data, make a copy of the buffer's content
1022                 CUDPData * recdata = new CUDPData(buf, nBytes, addr);
1023                 AddDebugLogLineF(logAsio, CFormat(wxT("UDP SendTo %d to %s")) % nBytes % addr.IPAddress());
1024                 m_strand.dispatch(boost::bind(& CAsioUDPSocketImpl::DispatchSendTo, this, recdata));
1025                 return nBytes;
1026         }
1027
1028         bool IsOk() const
1029         {
1030                 return m_OK;
1031         }
1032
1033         void Close()
1034         {
1035                 if (s_io_service.stopped()) {
1036                         DispatchClose();
1037                 } else {
1038                         m_strand.dispatch(boost::bind(& CAsioUDPSocketImpl::DispatchClose, this));
1039                 }
1040         }
1041
1042         void Destroy()
1043         {
1044                 AddDebugLogLineF(logAsio, CFormat(wxT("Destroy() %p %p")) % m_libSocket % this);
1045                 Close();
1046                 if (s_io_service.stopped()) {
1047                         HandleDestroy();
1048                 } else {
1049                         // Close prevents creation of any more callbacks, but does not clear any callbacks already
1050                         // sitting in Asio's event queue (I have seen such a crash).
1051                         // So create a delay timer so they can be called until core is notified.
1052                         m_timer.expires_from_now(boost::posix_time::seconds(1));
1053                         m_timer.async_wait(m_strand.wrap(boost::bind(& CAsioUDPSocketImpl::HandleDestroy, this)));
1054                 }
1055         }
1056
1057
1058 private:
1059         //
1060         // Dispatch handlers
1061         // Access to m_socket is all bundled in the thread running s_io_service to avoid
1062         // concurrent access to the socket from several threads.
1063         // So once things are running (after connect), all access goes through one of these handlers.
1064         //
1065         void DispatchClose()
1066         {
1067                 error_code ec;
1068                 m_socket->close(ec);
1069                 if (ec) {
1070                         AddDebugLogLineC(logAsio, CFormat(wxT("UDP Close error %s")) % ec.message());
1071                 } else {
1072                         AddDebugLogLineF(logAsio, wxT("UDP Closed"));
1073                 }
1074         }
1075
1076         void DispatchSendTo(CUDPData * recdata)
1077         {
1078                 ip::udp::endpoint endpoint(recdata->ipadr.GetEndpoint().address(), recdata->ipadr.Service());
1079
1080                 AddDebugLogLineF(logAsio, CFormat(wxT("UDP DispatchSendTo %d to %s:%d")) % recdata->size
1081                         % endpoint.address().to_string() % endpoint.port());
1082                 m_socket->async_send_to(buffer(recdata->buffer, recdata->size), endpoint,
1083                         m_strand.wrap(boost::bind(& CAsioUDPSocketImpl::HandleSendTo, this, placeholders::error, placeholders::bytes_transferred, recdata)));
1084         }
1085
1086         //
1087         // Completion handlers for async requests
1088         //
1089
1090         void HandleRead(const error_code & ec, size_t received)
1091         {
1092                 if (ec) {
1093                         AddDebugLogLineN(logAsio, CFormat(wxT("UDP HandleReadError %s")) % ec.message());
1094                 } else if (received == 0) {
1095                         AddDebugLogLineF(logAsio, wxT("UDP HandleReadError nothing available"));
1096                 } else if (m_muleSocket == NULL) {
1097                         AddDebugLogLineN(logAsio, wxT("UDP HandleReadError no handler"));
1098                 } else {
1099
1100                         amuleIPV4Address ipadr = amuleIPV4Address(CamuleIPV4Endpoint(m_receiveEndpoint));
1101                         AddDebugLogLineF(logAsio, CFormat(wxT("UDP HandleRead %d %s:%d")) % received % ipadr.IPAddress() % ipadr.Service());
1102
1103                         // create our read buffer
1104                         CUDPData * recdata = new CUDPData(m_readBuffer, received, ipadr);
1105                         {
1106                                 wxMutexLocker lock(m_receiveBuffersLock);
1107                                 m_receiveBuffers.push_back(recdata);
1108                         }
1109                         CoreNotify_UDPSocketReceive(m_muleSocket);
1110                 }
1111                 StartBackgroundRead();
1112         }
1113
1114         void HandleSendTo(const error_code & ec, size_t sent, CUDPData * recdata)
1115         {
1116                 if (ec) {
1117                         AddDebugLogLineN(logAsio, CFormat(wxT("UDP HandleSendToError %s")) % ec.message());
1118                 } else if (sent != recdata->size) {
1119                         AddDebugLogLineN(logAsio, CFormat(wxT("UDP HandleSendToError tosend: %d sent %d")) % recdata->size % sent);
1120                 }
1121                 if (m_muleSocket == NULL) {
1122                         AddDebugLogLineN(logAsio, wxT("UDP HandleSendToError no handler"));
1123                 } else {
1124                         AddDebugLogLineF(logAsio, CFormat(wxT("UDP HandleSendTo %d to %s")) % sent % recdata->ipadr.IPAddress());
1125                         CoreNotify_UDPSocketSend(m_muleSocket);
1126                 }
1127                 delete recdata;
1128         }
1129
1130         void HandleDestroy()
1131         {
1132                 AddDebugLogLineF(logAsio, CFormat(wxT("HandleDestroy() %p %p")) % m_libSocket % this);
1133                 delete m_libSocket;
1134         }
1135
1136         //
1137         // Other functions
1138         //
1139
1140         void CreateSocket()
1141         {
1142                 try {
1143                         delete m_socket;
1144                         ip::udp::endpoint endpoint(m_address.GetEndpoint().address(), m_address.Service());
1145                         m_socket = new ip::udp::socket(s_io_service, endpoint);
1146                         AddDebugLogLineN(logAsio, CFormat(wxT("Created UDP socket %s %d")) % m_address.IPAddress() % m_address.Service());
1147                         StartBackgroundRead();
1148                 } catch (const system_error& err) {
1149                         AddLogLineC(CFormat(wxT("Error creating UDP socket %s %d : %s")) % m_address.IPAddress() % m_address.Service() % err.code().message());
1150                         m_socket = NULL;
1151                         m_OK = false;
1152                 }
1153         }
1154
1155         void StartBackgroundRead()
1156         {
1157                 m_socket->async_receive_from(buffer(m_readBuffer, CMuleUDPSocket::UDP_BUFFER_SIZE), m_receiveEndpoint,
1158                         m_strand.wrap(boost::bind(& CAsioUDPSocketImpl::HandleRead, this, placeholders::error, placeholders::bytes_transferred)));
1159         }
1160
1161         CLibUDPSocket *         m_libSocket;
1162         ip::udp::socket *       m_socket;
1163         CMuleUDPSocket *        m_muleSocket;
1164         bool                            m_OK;
1165         io_service::strand      m_strand;               // handle synchronisation in io_service thread pool
1166         deadline_timer          m_timer;
1167         amuleIPV4Address        m_address;
1168
1169         // One fix receive buffer
1170         char *                          m_readBuffer;
1171         // and a list of dynamic buffers. UDP data may be coming in faster
1172         // than the main loop can handle it.
1173         std::list<CUDPData *>   m_receiveBuffers;
1174         wxMutex                         m_receiveBuffersLock;
1175
1176         // Address of last reception
1177         ip::udp::endpoint       m_receiveEndpoint;
1178 };
1179
1180
1181 /**
1182  * Library UDP socket wrapper
1183  */
1184
1185 CLibUDPSocket::CLibUDPSocket(amuleIPV4Address &address, int flags)
1186 {
1187         m_aSocket = new CAsioUDPSocketImpl(address, flags, this);
1188 }
1189
1190
1191 CLibUDPSocket::~CLibUDPSocket()
1192 {
1193         AddDebugLogLineF(logAsio, CFormat(wxT("~CLibUDPSocket() %p %p")) % this % m_aSocket);
1194         delete m_aSocket;
1195 }
1196
1197
1198 bool CLibUDPSocket::IsOk() const
1199 {
1200         return m_aSocket->IsOk();
1201 }
1202
1203
1204 uint32 CLibUDPSocket::RecvFrom(amuleIPV4Address& addr, void* buf, uint32 nBytes)
1205 {
1206         return m_aSocket->RecvFrom(addr, buf, nBytes);
1207 }
1208
1209
1210 uint32 CLibUDPSocket::SendTo(const amuleIPV4Address& addr, const void* buf, uint32 nBytes)
1211 {
1212         return m_aSocket->SendTo(addr, buf, nBytes);
1213 }
1214
1215
1216 void CLibUDPSocket::SetClientData(CMuleUDPSocket * muleSocket)
1217 {
1218         m_aSocket->SetClientData(muleSocket);
1219 }
1220
1221
1222 int CLibUDPSocket::LastError() const
1223 {
1224         return !IsOk();
1225 }
1226
1227
1228 void CLibUDPSocket::Close()
1229 {
1230         m_aSocket->Close();
1231 }
1232
1233
1234 void CLibUDPSocket::Destroy()
1235 {
1236         m_aSocket->Destroy();
1237 }
1238
1239
1240 /**
1241  * CAsioService - ASIO event loop thread
1242  */
1243
1244 class CAsioServiceThread : public wxThread {
1245 public:
1246         CAsioServiceThread() : wxThread(wxTHREAD_JOINABLE)
1247         {
1248                 static int count = 0;
1249                 m_threadNumber = ++count;
1250                 Create();
1251                 Run();
1252         }
1253
1254         void * Entry()
1255         {
1256                 AddLogLineNS(CFormat(_("Asio thread %d started")) % m_threadNumber);
1257                 io_service::work worker(s_io_service);          // keep io_service running
1258                 s_io_service.run();
1259                 AddDebugLogLineN(logAsio, CFormat(wxT("Asio thread %d stopped")) % m_threadNumber);
1260
1261                 return NULL;
1262         }
1263
1264 private:
1265         int m_threadNumber;
1266 };
1267
1268 /**
1269  * The constructor starts the thread.
1270  */
1271 CAsioService::CAsioService()
1272 {
1273         m_threads = new CAsioServiceThread[m_numberOfThreads];
1274 }
1275
1276
1277 CAsioService::~CAsioService()
1278 {
1279 }
1280
1281
1282 void CAsioService::Stop()
1283 {
1284         if (!m_threads) {
1285                 return;
1286         }
1287         s_io_service.stop();
1288         // Wait for threads to exit
1289         for (int i = 0; i < m_numberOfThreads; i++) {
1290                 CAsioServiceThread * t = m_threads + i;
1291                 t->Wait();
1292         }
1293         delete[] m_threads;
1294         m_threads = 0;
1295 }
1296
1297
1298
1299
1300
1301 /**
1302  * amuleIPV4Address
1303  */
1304
1305 amuleIPV4Address::amuleIPV4Address()
1306 {
1307         m_endpoint = new CamuleIPV4Endpoint();
1308 }
1309
1310 amuleIPV4Address::amuleIPV4Address(const amuleIPV4Address &a)
1311 {
1312         *this = a;
1313 }
1314
1315 amuleIPV4Address::amuleIPV4Address(const CamuleIPV4Endpoint &ep)
1316 {
1317         *this = ep;
1318 }
1319
1320 amuleIPV4Address::~amuleIPV4Address()
1321 {
1322         delete m_endpoint;
1323 }
1324
1325 amuleIPV4Address& amuleIPV4Address::operator=(const amuleIPV4Address &a)
1326 {
1327         m_endpoint = new CamuleIPV4Endpoint(* a.m_endpoint);
1328         return *this;
1329 }
1330
1331 amuleIPV4Address& amuleIPV4Address::operator=(const CamuleIPV4Endpoint &ep)
1332 {
1333         m_endpoint = new CamuleIPV4Endpoint(ep);
1334         return *this;
1335 }
1336
1337 bool amuleIPV4Address::Hostname(const wxString& name)
1338 {
1339         if (name.IsEmpty()) {
1340                 return false;
1341         }
1342         // This is usually just an IP.
1343         std::string sname(unicode2char(name));
1344         error_code ec;
1345         ip::address_v4 adr = ip::address_v4::from_string(sname, ec);
1346         if (!ec) {
1347                 m_endpoint->address(adr);
1348                 return true;
1349         }
1350         AddDebugLogLineN(logAsio, CFormat(wxT("Hostname(\"%s\") failed, not an IP address %s")) % name % ec.message());
1351
1352         // Try to resolve (sync). Normally not required. Unless you type in your hostname as "local IP address" or something.
1353         error_code ec2;
1354         ip::tcp::resolver res(s_io_service);
1355         // We only want to get IPV4 addresses.
1356         ip::tcp::resolver::query query(ip::tcp::v4(), sname, "");
1357         ip::tcp::resolver::iterator endpoint_iterator = res.resolve(query, ec2);
1358         if (ec2) {
1359                 AddDebugLogLineN(logAsio, CFormat(wxT("Hostname(\"%s\") resolve failed: %s")) % name % ec2.message());
1360                 return false;
1361         }
1362         if (endpoint_iterator == ip::tcp::resolver::iterator()) {
1363                 AddDebugLogLineN(logAsio, CFormat(wxT("Hostname(\"%s\") resolve failed: no address found")) % name);
1364                 return false;
1365         }
1366         m_endpoint->address(endpoint_iterator->endpoint().address());
1367         AddDebugLogLineN(logAsio, CFormat(wxT("Hostname(\"%s\") resolved to %s")) % name % IPAddress());
1368         return true;
1369 }
1370
1371 bool amuleIPV4Address::Service(uint16 service)
1372 {
1373         if (service == 0) {
1374                 return false;
1375         }
1376         m_endpoint->port(service);
1377         return true;
1378 }
1379
1380 uint16 amuleIPV4Address::Service() const
1381 {
1382         return m_endpoint->port();
1383 }
1384
1385 bool amuleIPV4Address::IsLocalHost() const
1386 {
1387         return m_endpoint->address().is_loopback();
1388 }
1389
1390 wxString amuleIPV4Address::IPAddress() const
1391 {
1392         return CFormat(wxT("%s")) % m_endpoint->address().to_string();
1393 }
1394
1395 // "Set address to any of the addresses of the current machine."
1396 // This just sets the address to 0.0.0.0 .
1397 // wx does the same.
1398 bool amuleIPV4Address::AnyAddress()
1399 {
1400         m_endpoint->address(ip::address_v4::any());
1401         AddDebugLogLineN(logAsio, CFormat(wxT("AnyAddress: set to %s")) % IPAddress());
1402         return true;
1403 }
1404
1405 const CamuleIPV4Endpoint & amuleIPV4Address::GetEndpoint() const
1406 {
1407         return * m_endpoint;
1408 }
1409
1410 CamuleIPV4Endpoint & amuleIPV4Address::GetEndpoint()
1411 {
1412         return * m_endpoint;
1413 }
1414
1415
1416 //
1417 // Notification stuff
1418 //
1419 namespace MuleNotify
1420 {
1421
1422         void LibSocketConnect(CLibSocket * socket, int error)
1423         {
1424                 if (socket->IsDestroying()) {
1425                         AddDebugLogLineF(logAsio, CFormat(wxT("LibSocketConnect Destroying %s %d")) % socket->GetIP() % error);
1426                 } else if (socket->GetProxyState()) {
1427                         AddDebugLogLineF(logAsio, CFormat(wxT("LibSocketConnect Proxy %s %d")) % socket->GetIP() % error);
1428                         socket->OnProxyEvent(MULE_SOCKET_CONNECTION);
1429                 } else {
1430                         AddDebugLogLineF(logAsio, CFormat(wxT("LibSocketConnect %s %d")) %socket->GetIP() % error);
1431                         socket->OnConnect(error);
1432                 }
1433         }
1434
1435         void LibSocketSend(CLibSocket * socket, int error)
1436         {
1437                 if (socket->IsDestroying()) {
1438                         AddDebugLogLineF(logAsio, CFormat(wxT("LibSocketSend Destroying %s %d")) % socket->GetIP() % error);
1439                 } else if (socket->GetProxyState()) {
1440                         AddDebugLogLineF(logAsio, CFormat(wxT("LibSocketSend Proxy %s %d")) % socket->GetIP() % error);
1441                         socket->OnProxyEvent(MULE_SOCKET_OUTPUT);
1442                 } else {
1443                         AddDebugLogLineF(logAsio, CFormat(wxT("LibSocketSend %s %d")) % socket->GetIP() % error);
1444                         socket->OnSend(error);
1445                 }
1446         }
1447
1448         void LibSocketReceive(CLibSocket * socket, int error)
1449         {
1450                 socket->EventProcessed();
1451                 if (socket->IsDestroying()) {
1452                         AddDebugLogLineF(logAsio, CFormat(wxT("LibSocketReceive Destroying %s %d")) % socket->GetIP() % error);
1453                 } else if (socket->GetProxyState()) {
1454                         AddDebugLogLineF(logAsio, CFormat(wxT("LibSocketReceive Proxy %s %d")) % socket->GetIP() % error);
1455                         socket->OnProxyEvent(MULE_SOCKET_INPUT);
1456                 } else {
1457                         AddDebugLogLineF(logAsio, CFormat(wxT("LibSocketReceive %s %d")) % socket->GetIP() % error);
1458                         socket->OnReceive(error);
1459                 }
1460         }
1461
1462         void LibSocketLost(CLibSocket * socket)
1463         {
1464                 if (socket->IsDestroying()) {
1465                         AddDebugLogLineF(logAsio, CFormat(wxT("LibSocketLost Destroying %s")) % socket->GetIP());
1466                 } else if (socket->GetProxyState()) {
1467                         AddDebugLogLineF(logAsio, CFormat(wxT("LibSocketLost Proxy %s")) % socket->GetIP());
1468                         socket->OnProxyEvent(MULE_SOCKET_LOST);
1469                 } else {
1470                         AddDebugLogLineF(logAsio, CFormat(wxT("LibSocketLost %s")) % socket->GetIP());
1471                         socket->OnLost();
1472                 }
1473         }
1474
1475         void LibSocketDestroy(CLibSocket * socket)
1476         {
1477                 AddDebugLogLineF(logAsio, CFormat(wxT("LibSocket_Destroy %s")) % socket->GetIP());
1478                 delete socket;
1479         }
1480
1481         void ProxySocketEvent(CLibSocket * socket, int evt)
1482         {
1483                 AddDebugLogLineF(logAsio, CFormat(wxT("ProxySocketEvent %s %d")) % socket->GetIP() % evt);
1484                 socket->OnProxyEvent(evt);
1485         }
1486
1487         void ServerTCPAccept(CLibSocketServer * socketServer)
1488         {
1489                 AddDebugLogLineF(logAsio, wxT("ServerTCP_Accept"));
1490                 socketServer->OnAccept();
1491         }
1492
1493         void UDPSocketSend(CMuleUDPSocket * socket)
1494         {
1495                 AddDebugLogLineF(logAsio, wxT("UDPSocketSend"));
1496                 socket->OnSend(0);
1497         }
1498
1499         void UDPSocketReceive(CMuleUDPSocket * socket)
1500         {
1501                 AddDebugLogLineF(logAsio, wxT("UDPSocketReceive"));
1502                 socket->OnReceive(0);
1503         }
1504
1505
1506 } // namespace MuleNotify
1507
1508 //
1509 // Initialize MuleBoostVersion
1510 //
1511 wxString MuleBoostVersion = CFormat(wxT("%d.%d")) % (BOOST_VERSION / 100000) % (BOOST_VERSION / 100 % 1000);