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 #ifdef HAVE_CONFIG_H
  27 #       include "config.h"              // Needed for HAVE_BOOST_SOURCES
  28 #endif
  29
  30 #ifdef _MSC_VER
  31 #define _WIN32_WINNT 0x0501             // Boost complains otherwise
  32 #endif
  33
  34 // Windows requires that Boost headers are included before wx headers.
  35 // This works if precompiled headers are disabled for this file.
  36
  37 #define BOOST_ALL_NO_LIB
  38
  39 // Suppress warning caused by faulty boost/preprocessor/config/config.hpp in Boost 1.49
  40 #if defined __GNUC__ && ! defined __GXX_EXPERIMENTAL_CXX0X__ && __cplusplus < 201103L
  41         #define BOOST_PP_VARIADICS 0
  42 #endif
  43
  44 #include <algorithm>    // Needed for std::min - Boost up to 1.54 fails to compile with MSVC 2013 otherwise
  45
  46 #include <boost/asio.hpp>
  47 #include <boost/bind.hpp>
  48 #include <boost/version.hpp>
  49
  50 //
  51 // Do away with building Boost.System, adding lib paths...
  52 // Just include the single file and be done.
  53 //
  54 #ifdef HAVE_BOOST_SOURCES
  55 #       include <boost/../libs/system/src/error_code.cpp>
  56 #else
  57 #       include <boost/system/error_code.hpp>
  58 #endif
  59
  60 #include "LibSocket.h"
  61 #include <wx/thread.h>          // wxMutex
  62 #include <wx/intl.h>            // _()
  63 #include <common/Format.h>      // Needed for CFormat
  64 #include "Logger.h"
  65 #include "GuiEvents.h"
  66 #include "amuleIPV4Address.h"
  67 #include "MuleUDPSocket.h"
  68 #include "OtherFunctions.h"     // DeleteContents, MuleBoostVersion
  69 #include "ScopedPtr.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 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 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                 if (err) {
 568                         SetError();
 569                 } else {
 570                         m_ErrorCode = 0;
 571                 }
 572                 return m_ErrorCode != 0;
 573         }
 574
 575         //
 576         // Synchronous sockets (amulecmd)
 577         //
 578         uint32 ReadSync(char * buf, uint32 bytesToRead)
 579         {
 580                 error_code ec;
 581                 uint32 received = read(*m_socket, buffer(buf, bytesToRead), ec);
 582                 SetError(ec);
 583                 return received;
 584         }
 585
 586         uint32 WriteSync(const void * buf, uint32 nbytes)
 587         {
 588                 error_code ec;
 589                 uint32 sent = write(*m_socket, buffer(buf, nbytes), ec);
 590                 SetError(ec);
 591                 return sent;
 592         }
 593
 594         //
 595         // Access to even const & wxString is apparently not thread-safe.
 596         // Locks are set/removed in wx and reference counts can go astray.
 597         // So store our IP string in a wxString which is used nowhere.
 598         // Store a pointer to its string buffer as well and use THAT everywhere.
 599         //
 600         void SetIp(const amuleIPV4Address& adr)
 601         {
 602                 m_IPstring = adr.IPAddress();
 603                 m_IP = m_IPstring.c_str();
 604                 m_IPint = StringIPtoUint32(m_IPstring);
 605         }
 606
 607         CLibSocket      *       m_libSocket;
 608         ip::tcp::socket *       m_socket;
 609                                                                                 // remote IP
 610         wxString                m_IPstring;                     // as String (use nowhere because of threading!)
 611         const wxChar *  m_IP;                           // as char*  (use in debug logs)
 612         uint32                  m_IPint;                        // as int
 613         uint16                  m_port;                         // remote port
 614         bool                    m_OK;
 615         int                             m_ErrorCode;
 616         bool                    m_blocksRead;
 617         bool                    m_blocksWrite;
 618         char *                  m_readBuffer;
 619         uint32                  m_readBufferSize;
 620         char *                  m_readBufferPtr;
 621         bool                    m_readPending;
 622         uint32                  m_readBufferContent;
 623         bool                    m_eventPending;
 624         char *                  m_sendBuffer;
 625         io_service::strand      m_strand;               // handle synchronisation in io_service thread pool
 626         deadline_timer  m_timer;
 627         bool                    m_connected;
 628         bool                    m_closed;
 629         bool                    m_isDestroying;         // true if Destroy() was called
 630         bool                    m_proxyState;
 631         bool                    m_notify;                       // set by Notify()
 632         bool                    m_sync;                         // copied from !m_notify on Connect()
 633 };
 634
 635
 636 /**
 637  * Library socket wrapper
 638  */
 639
 640 CLibSocket::CLibSocket(int /* flags */)
 641 {
 642         m_aSocket = new CAsioSocketImpl(this);
 643 }
 644
 645
 646 CLibSocket::~CLibSocket()
 647 {
 648         AddDebugLogLineF(logAsio, CFormat(wxT("~CLibSocket() %p %p %s")) % this % m_aSocket % m_aSocket->GetIP());
 649         delete m_aSocket;
 650 }
 651
 652
 653 bool CLibSocket::Connect(const amuleIPV4Address& adr, bool wait)
 654 {
 655         return m_aSocket->Connect(adr, wait);
 656 }
 657
 658
 659 bool CLibSocket::IsConnected() const
 660 {
 661         return m_aSocket->IsConnected();
 662 }
 663
 664
 665 bool CLibSocket::IsOk() const
 666 {
 667         return m_aSocket->IsOk();
 668 }
 669
 670
 671 wxString CLibSocket::GetPeer()
 672 {
 673         return m_aSocket->GetPeer();
 674 }
 675
 676
 677 uint32 CLibSocket::GetPeerInt()
 678 {
 679         return m_aSocket->GetPeerInt();
 680 }
 681
 682
 683 void CLibSocket::Destroy()
 684 {
 685         m_aSocket->Destroy();
 686 }
 687
 688
 689 bool CLibSocket::IsDestroying() const
 690 {
 691         return m_aSocket->IsDestroying();
 692 }
 693
 694
 695 void CLibSocket::Notify(bool notify)
 696 {
 697         m_aSocket->Notify(notify);
 698 }
 699
 700
 701 uint32 CLibSocket::Read(void * buffer, uint32 nbytes)
 702 {
 703         return m_aSocket->Read((char *) buffer, nbytes);
 704 }
 705
 706
 707 uint32 CLibSocket::Write(const void * buffer, uint32 nbytes)
 708 {
 709         return m_aSocket->Write(buffer, nbytes);
 710 }
 711
 712
 713 void CLibSocket::Close()
 714 {
 715         m_aSocket->Close();
 716 }
 717
 718
 719 int CLibSocket::LastError() const
 720 {
 721         return m_aSocket->LastError();
 722 }
 723
 724
 725 void CLibSocket::SetLocal(const amuleIPV4Address& local)
 726 {
 727         m_aSocket->SetLocal(local);
 728 }
 729
 730
 731
 732 // new Stuff
 733
 734 bool CLibSocket::BlocksRead() const
 735 {
 736         return m_aSocket->BlocksRead();
 737 }
 738
 739
 740 bool CLibSocket::BlocksWrite() const
 741 {
 742         return m_aSocket->BlocksWrite();
 743 }
 744
 745
 746 void CLibSocket::EventProcessed()
 747 {
 748         m_aSocket->EventProcessed();
 749 }
 750
 751
 752 void CLibSocket::LinkSocketImpl(class CAsioSocketImpl * socket)
 753 {
 754         delete m_aSocket;
 755         m_aSocket = socket;
 756         m_aSocket->SetWrapSocket(this);
 757 }
 758
 759
 760 const wxChar * CLibSocket::GetIP() const
 761 {
 762         return m_aSocket->GetIP();
 763 }
 764
 765
 766 bool CLibSocket::GetProxyState() const
 767 {
 768         return m_aSocket->GetProxyState();
 769 }
 770
 771
 772 void CLibSocket::SetProxyState(bool state, const amuleIPV4Address * adr)
 773 {
 774         m_aSocket->SetProxyState(state, adr);
 775 }
 776
 777
 778 /**
 779  * ASIO TCP socket server
 780  */
 781
 782 class CAsioSocketServerImpl : public ip::tcp::acceptor
 783 {
 784 public:
 785         CAsioSocketServerImpl(const amuleIPV4Address & adr, CLibSocketServer * libSocketServer)
 786                 : ip::tcp::acceptor(s_io_service),
 787                   m_libSocketServer(libSocketServer),
 788                   m_currentSocket(NULL),
 789                   m_strand(s_io_service)
 790         {
 791                 m_ok = false;
 792                 m_socketAvailable = false;
 793
 794                 try {
 795                         open(adr.GetEndpoint().protocol());
 796                         set_option(ip::tcp::acceptor::reuse_address(true));
 797                         bind(adr.GetEndpoint());
 798                         listen();
 799                         StartAccept();
 800                         m_ok = true;
 801                         AddDebugLogLineN(logAsio, CFormat(wxT("CAsioSocketServerImpl bind to %s %d")) % adr.IPAddress() % adr.Service());
 802                 } catch (const system_error& err) {
 803                         AddDebugLogLineC(logAsio, CFormat(wxT("CAsioSocketServerImpl bind to %s %d failed - %s")) % adr.IPAddress() % adr.Service() % err.code().message());
 804                 }
 805         }
 806
 807         ~CAsioSocketServerImpl()
 808         {
 809         }
 810
 811         // For wxSocketServer, Ok will return true if the server could bind to the specified address and is already listening for new connections.
 812         bool IsOk() const { return m_ok; }
 813
 814         void Close() { close(); }
 815
 816         bool AcceptWith(CLibSocket & socket)
 817         {
 818                 if (!m_socketAvailable) {
 819                         AddDebugLogLineF(logAsio, wxT("AcceptWith: nothing there"));
 820                         return false;
 821                 }
 822
 823                 // return the socket we received
 824                 socket.LinkSocketImpl(m_currentSocket.release());
 825
 826                 // check if we have another socket ready for reception
 827                 m_currentSocket.reset(new CAsioSocketImpl(NULL));
 828                 error_code ec;
 829                 // async_accept does not work if server is non-blocking
 830                 // temporarily switch it to non-blocking
 831                 non_blocking(true);
 832                 // we are set to non-blocking, so this returns right away
 833                 accept(m_currentSocket->GetAsioSocket(), ec);
 834                 // back to blocking
 835                 non_blocking(false);
 836                 if (ec || !m_currentSocket->UpdateIP()) {
 837                         // nothing there
 838                         m_socketAvailable = false;
 839                         // start getting another one
 840                         StartAccept();
 841                         AddDebugLogLineF(logAsio, wxT("AcceptWith: ok, getting another socket in background"));
 842                 } else {
 843                         // we got another socket right away
 844                         m_socketAvailable = true;       // it is already true, but this improves readability
 845                         AddDebugLogLineF(logAsio, wxT("AcceptWith: ok, another socket is available"));
 846                         // aMule actually doesn't need a notification as it polls the listen socket.
 847                         // amuleweb does need it though
 848                         CoreNotify_ServerTCPAccept(m_libSocketServer);
 849                 }
 850
 851                 return true;
 852         }
 853
 854         bool SocketAvailable() const { return m_socketAvailable; }
 855
 856 private:
 857
 858         void StartAccept()
 859         {
 860                 m_currentSocket.reset(new CAsioSocketImpl(NULL));
 861                 async_accept(m_currentSocket->GetAsioSocket(),
 862                         m_strand.wrap(boost::bind(& CAsioSocketServerImpl::HandleAccept, this, placeholders::error)));
 863         }
 864
 865         void HandleAccept(const error_code& error)
 866         {
 867                 if (error) {
 868                         AddDebugLogLineC(logAsio, CFormat(wxT("Error in HandleAccept: %s")) % error.message());
 869                 } else {
 870                         if (m_currentSocket->UpdateIP()) {
 871                                 AddDebugLogLineN(logAsio, CFormat(wxT("HandleAccept received a connection from %s:%d"))
 872                                         % m_currentSocket->GetIP() % m_currentSocket->GetPort());
 873                                 m_socketAvailable = true;
 874                                 CoreNotify_ServerTCPAccept(m_libSocketServer);
 875                                 return;
 876                         } else {
 877                                 AddDebugLogLineN(logAsio, wxT("Error in HandleAccept: invalid socket"));
 878                         }
 879                 }
 880                 // We were not successful. Try again.
 881                 // Post the request to the event queue to make sure it doesn't get called immediately.
 882                 m_strand.post(boost::bind(& CAsioSocketServerImpl::StartAccept, this));
 883         }
 884
 885         // The wrapper object
 886         CLibSocketServer * m_libSocketServer;
 887         // Startup ok
 888         bool m_ok;
 889         // The last socket that connected to us
 890         CScopedPtr<CAsioSocketImpl> m_currentSocket;
 891         // Is there a socket available?
 892         bool m_socketAvailable;
 893         io_service::strand      m_strand;               // handle synchronisation in io_service thread pool
 894 };
 895
 896
 897 CLibSocketServer::CLibSocketServer(const amuleIPV4Address& adr, int /* flags */)
 898 {
 899         m_aServer = new CAsioSocketServerImpl(adr, this);
 900 }
 901
 902
 903 CLibSocketServer::~CLibSocketServer()
 904 {
 905         delete m_aServer;
 906 }
 907
 908
 909 // Accepts an incoming connection request, and creates a new CLibSocket object which represents the server-side of the connection.
 910 // Only used in CamuleApp::ListenSocketHandler() and we don't get there.
 911 CLibSocket * CLibSocketServer::Accept(bool /* wait */)
 912 {
 913         wxFAIL;
 914         return NULL;
 915 }
 916
 917
 918 // Accept an incoming connection using the specified socket object.
 919 bool CLibSocketServer::AcceptWith(CLibSocket & socket, bool wait)
 920 {
 921         wxASSERT(!wait);
 922         return m_aServer->AcceptWith(socket);
 923 }
 924
 925
 926 bool CLibSocketServer::IsOk() const
 927 {
 928         return m_aServer->IsOk();
 929 }
 930
 931
 932 void CLibSocketServer::Close()
 933 {
 934         m_aServer->Close();
 935 }
 936
 937
 938 bool CLibSocketServer::SocketAvailable()
 939 {
 940         return m_aServer->SocketAvailable();
 941 }
 942
 943
 944 /**
 945  * ASIO UDP socket implementation
 946  */
 947
 948 class CAsioUDPSocketImpl
 949 {
 950 private:
 951         // UDP data block
 952         class CUDPData {
 953         public:
 954                 char * buffer;
 955                 uint32 size;
 956                 amuleIPV4Address ipadr;
 957
 958                 CUDPData(const void * src, uint32 _size, amuleIPV4Address adr) :
 959                         size(_size), ipadr(adr)
 960                 {
 961                         buffer = new char[size];
 962                         memcpy(buffer, src, size);
 963                 }
 964
 965                 ~CUDPData()
 966                 {
 967                         delete[] buffer;
 968                 }
 969         };
 970
 971 public:
 972         CAsioUDPSocketImpl(const amuleIPV4Address &address, int /* flags */, CLibUDPSocket * libSocket) :
 973                 m_libSocket(libSocket),
 974                 m_strand(s_io_service),
 975                 m_timer(s_io_service),
 976                 m_address(address)
 977         {
 978                 m_muleSocket = NULL;
 979                 m_socket = NULL;
 980                 m_readBuffer = new char[CMuleUDPSocket::UDP_BUFFER_SIZE];
 981                 m_OK = true;
 982                 CreateSocket();
 983         }
 984
 985         ~CAsioUDPSocketImpl()
 986         {
 987                 AddDebugLogLineF(logAsio, wxT("UDP ~CAsioUDPSocketImpl"));
 988                 delete m_socket;
 989                 delete[] m_readBuffer;
 990                 DeleteContents(m_receiveBuffers);
 991         }
 992
 993         void SetClientData(CMuleUDPSocket * muleSocket)
 994         {
 995                 AddDebugLogLineF(logAsio, wxT("UDP SetClientData"));
 996                 m_muleSocket = muleSocket;
 997         }
 998
 999         uint32 RecvFrom(amuleIPV4Address& addr, void* buf, uint32 nBytes)
1000         {
1001                 CUDPData * recdata;
1002                 {
1003                         wxMutexLocker lock(m_receiveBuffersLock);
1004                         if (m_receiveBuffers.empty()) {
1005                                 AddDebugLogLineN(logAsio, wxT("UDP RecvFromError no data"));
1006                                 return 0;
1007                         }
1008                         recdata = * m_receiveBuffers.begin();
1009                         m_receiveBuffers.pop_front();
1010                 }
1011                 uint32 read = recdata->size;
1012                 if (read > nBytes) {
1013                         // should not happen
1014                         AddDebugLogLineN(logAsio, CFormat(wxT("UDP RecvFromError too much data %d")) % read);
1015                         read = nBytes;
1016                 }
1017                 memcpy(buf, recdata->buffer, read);
1018                 addr = recdata->ipadr;
1019                 delete recdata;
1020                 return read;
1021         }
1022
1023         uint32 SendTo(const amuleIPV4Address& addr, const void* buf, uint32 nBytes)
1024         {
1025                 // Collect data, make a copy of the buffer's content
1026                 CUDPData * recdata = new CUDPData(buf, nBytes, addr);
1027                 AddDebugLogLineF(logAsio, CFormat(wxT("UDP SendTo %d to %s")) % nBytes % addr.IPAddress());
1028                 m_strand.dispatch(boost::bind(& CAsioUDPSocketImpl::DispatchSendTo, this, recdata));
1029                 return nBytes;
1030         }
1031
1032         bool IsOk() const
1033         {
1034                 return m_OK;
1035         }
1036
1037         void Close()
1038         {
1039                 if (s_io_service.stopped()) {
1040                         DispatchClose();
1041                 } else {
1042                         m_strand.dispatch(boost::bind(& CAsioUDPSocketImpl::DispatchClose, this));
1043                 }
1044         }
1045
1046         void Destroy()
1047         {
1048                 AddDebugLogLineF(logAsio, CFormat(wxT("Destroy() %p %p")) % m_libSocket % this);
1049                 Close();
1050                 if (s_io_service.stopped()) {
1051                         HandleDestroy();
1052                 } else {
1053                         // Close prevents creation of any more callbacks, but does not clear any callbacks already
1054                         // sitting in Asio's event queue (I have seen such a crash).
1055                         // So create a delay timer so they can be called until core is notified.
1056                         m_timer.expires_from_now(boost::posix_time::seconds(1));
1057                         m_timer.async_wait(m_strand.wrap(boost::bind(& CAsioUDPSocketImpl::HandleDestroy, this)));
1058                 }
1059         }
1060
1061
1062 private:
1063         //
1064         // Dispatch handlers
1065         // Access to m_socket is all bundled in the thread running s_io_service to avoid
1066         // concurrent access to the socket from several threads.
1067         // So once things are running (after connect), all access goes through one of these handlers.
1068         //
1069         void DispatchClose()
1070         {
1071                 error_code ec;
1072                 m_socket->close(ec);
1073                 if (ec) {
1074                         AddDebugLogLineC(logAsio, CFormat(wxT("UDP Close error %s")) % ec.message());
1075                 } else {
1076                         AddDebugLogLineF(logAsio, wxT("UDP Closed"));
1077                 }
1078         }
1079
1080         void DispatchSendTo(CUDPData * recdata)
1081         {
1082                 ip::udp::endpoint endpoint(recdata->ipadr.GetEndpoint().address(), recdata->ipadr.Service());
1083
1084                 AddDebugLogLineF(logAsio, CFormat(wxT("UDP DispatchSendTo %d to %s:%d")) % recdata->size
1085                         % endpoint.address().to_string() % endpoint.port());
1086                 m_socket->async_send_to(buffer(recdata->buffer, recdata->size), endpoint,
1087                         m_strand.wrap(boost::bind(& CAsioUDPSocketImpl::HandleSendTo, this, placeholders::error, placeholders::bytes_transferred, recdata)));
1088         }
1089
1090         //
1091         // Completion handlers for async requests
1092         //
1093
1094         void HandleRead(const error_code & ec, size_t received)
1095         {
1096                 if (ec) {
1097                         AddDebugLogLineN(logAsio, CFormat(wxT("UDP HandleReadError %s")) % ec.message());
1098                 } else if (received == 0) {
1099                         AddDebugLogLineF(logAsio, wxT("UDP HandleReadError nothing available"));
1100                 } else if (m_muleSocket == NULL) {
1101                         AddDebugLogLineN(logAsio, wxT("UDP HandleReadError no handler"));
1102                 } else {
1103
1104                         amuleIPV4Address ipadr = amuleIPV4Address(CamuleIPV4Endpoint(m_receiveEndpoint));
1105                         AddDebugLogLineF(logAsio, CFormat(wxT("UDP HandleRead %d %s:%d")) % received % ipadr.IPAddress() % ipadr.Service());
1106
1107                         // create our read buffer
1108                         CUDPData * recdata = new CUDPData(m_readBuffer, received, ipadr);
1109                         {
1110                                 wxMutexLocker lock(m_receiveBuffersLock);
1111                                 m_receiveBuffers.push_back(recdata);
1112                         }
1113                         CoreNotify_UDPSocketReceive(m_muleSocket);
1114                 }
1115                 StartBackgroundRead();
1116         }
1117
1118         void HandleSendTo(const error_code & ec, size_t sent, CUDPData * recdata)
1119         {
1120                 if (ec) {
1121                         AddDebugLogLineN(logAsio, CFormat(wxT("UDP HandleSendToError %s")) % ec.message());
1122                 } else if (sent != recdata->size) {
1123                         AddDebugLogLineN(logAsio, CFormat(wxT("UDP HandleSendToError tosend: %d sent %d")) % recdata->size % sent);
1124                 }
1125                 if (m_muleSocket == NULL) {
1126                         AddDebugLogLineN(logAsio, wxT("UDP HandleSendToError no handler"));
1127                 } else {
1128                         AddDebugLogLineF(logAsio, CFormat(wxT("UDP HandleSendTo %d to %s")) % sent % recdata->ipadr.IPAddress());
1129                         CoreNotify_UDPSocketSend(m_muleSocket);
1130                 }
1131                 delete recdata;
1132         }
1133
1134         void HandleDestroy()
1135         {
1136                 AddDebugLogLineF(logAsio, CFormat(wxT("HandleDestroy() %p %p")) % m_libSocket % this);
1137                 delete m_libSocket;
1138         }
1139
1140         //
1141         // Other functions
1142         //
1143
1144         void CreateSocket()
1145         {
1146                 try {
1147                         delete m_socket;
1148                         ip::udp::endpoint endpoint(m_address.GetEndpoint().address(), m_address.Service());
1149                         m_socket = new ip::udp::socket(s_io_service, endpoint);
1150                         AddDebugLogLineN(logAsio, CFormat(wxT("Created UDP socket %s %d")) % m_address.IPAddress() % m_address.Service());
1151                         StartBackgroundRead();
1152                 } catch (const system_error& err) {
1153                         AddLogLineC(CFormat(wxT("Error creating UDP socket %s %d : %s")) % m_address.IPAddress() % m_address.Service() % err.code().message());
1154                         m_socket = NULL;
1155                         m_OK = false;
1156                 }
1157         }
1158
1159         void StartBackgroundRead()
1160         {
1161                 m_socket->async_receive_from(buffer(m_readBuffer, CMuleUDPSocket::UDP_BUFFER_SIZE), m_receiveEndpoint,
1162                         m_strand.wrap(boost::bind(& CAsioUDPSocketImpl::HandleRead, this, placeholders::error, placeholders::bytes_transferred)));
1163         }
1164
1165         CLibUDPSocket *         m_libSocket;
1166         ip::udp::socket *       m_socket;
1167         CMuleUDPSocket *        m_muleSocket;
1168         bool                            m_OK;
1169         io_service::strand      m_strand;               // handle synchronisation in io_service thread pool
1170         deadline_timer          m_timer;
1171         amuleIPV4Address        m_address;
1172
1173         // One fix receive buffer
1174         char *                          m_readBuffer;
1175         // and a list of dynamic buffers. UDP data may be coming in faster
1176         // than the main loop can handle it.
1177         std::list<CUDPData *>   m_receiveBuffers;
1178         wxMutex                         m_receiveBuffersLock;
1179
1180         // Address of last reception
1181         ip::udp::endpoint       m_receiveEndpoint;
1182 };
1183
1184
1185 /**
1186  * Library UDP socket wrapper
1187  */
1188
1189 CLibUDPSocket::CLibUDPSocket(amuleIPV4Address &address, int flags)
1190 {
1191         m_aSocket = new CAsioUDPSocketImpl(address, flags, this);
1192 }
1193
1194
1195 CLibUDPSocket::~CLibUDPSocket()
1196 {
1197         AddDebugLogLineF(logAsio, CFormat(wxT("~CLibUDPSocket() %p %p")) % this % m_aSocket);
1198         delete m_aSocket;
1199 }
1200
1201
1202 bool CLibUDPSocket::IsOk() const
1203 {
1204         return m_aSocket->IsOk();
1205 }
1206
1207
1208 uint32 CLibUDPSocket::RecvFrom(amuleIPV4Address& addr, void* buf, uint32 nBytes)
1209 {
1210         return m_aSocket->RecvFrom(addr, buf, nBytes);
1211 }
1212
1213
1214 uint32 CLibUDPSocket::SendTo(const amuleIPV4Address& addr, const void* buf, uint32 nBytes)
1215 {
1216         return m_aSocket->SendTo(addr, buf, nBytes);
1217 }
1218
1219
1220 void CLibUDPSocket::SetClientData(CMuleUDPSocket * muleSocket)
1221 {
1222         m_aSocket->SetClientData(muleSocket);
1223 }
1224
1225
1226 int CLibUDPSocket::LastError() const
1227 {
1228         return !IsOk();
1229 }
1230
1231
1232 void CLibUDPSocket::Close()
1233 {
1234         m_aSocket->Close();
1235 }
1236
1237
1238 void CLibUDPSocket::Destroy()
1239 {
1240         m_aSocket->Destroy();
1241 }
1242
1243
1244 /**
1245  * CAsioService - ASIO event loop thread
1246  */
1247
1248 class CAsioServiceThread : public wxThread {
1249 public:
1250         CAsioServiceThread() : wxThread(wxTHREAD_JOINABLE)
1251         {
1252                 static int count = 0;
1253                 m_threadNumber = ++count;
1254                 Create();
1255                 Run();
1256         }
1257
1258         void * Entry()
1259         {
1260                 AddLogLineNS(CFormat(_("Asio thread %d started")) % m_threadNumber);
1261                 io_service::work worker(s_io_service);          // keep io_service running
1262                 s_io_service.run();
1263                 AddDebugLogLineN(logAsio, CFormat(wxT("Asio thread %d stopped")) % m_threadNumber);
1264
1265                 return NULL;
1266         }
1267
1268 private:
1269         int m_threadNumber;
1270 };
1271
1272 /**
1273  * The constructor starts the thread.
1274  */
1275 CAsioService::CAsioService()
1276 {
1277         m_threads = new CAsioServiceThread[m_numberOfThreads];
1278 }
1279
1280
1281 CAsioService::~CAsioService()
1282 {
1283 }
1284
1285
1286 void CAsioService::Stop()
1287 {
1288         if (!m_threads) {
1289                 return;
1290         }
1291         s_io_service.stop();
1292         // Wait for threads to exit
1293         for (int i = 0; i < m_numberOfThreads; i++) {
1294                 CAsioServiceThread * t = m_threads + i;
1295                 t->Wait();
1296         }
1297         delete[] m_threads;
1298         m_threads = 0;
1299 }
1300
1301
1302
1303
1304
1305 /**
1306  * amuleIPV4Address
1307  */
1308
1309 amuleIPV4Address::amuleIPV4Address()
1310 {
1311         m_endpoint = new CamuleIPV4Endpoint();
1312 }
1313
1314 amuleIPV4Address::amuleIPV4Address(const amuleIPV4Address &a)
1315 {
1316         *this = a;
1317 }
1318
1319 amuleIPV4Address::amuleIPV4Address(const CamuleIPV4Endpoint &ep)
1320 {
1321         *this = ep;
1322 }
1323
1324 amuleIPV4Address::~amuleIPV4Address()
1325 {
1326         delete m_endpoint;
1327 }
1328
1329 amuleIPV4Address& amuleIPV4Address::operator=(const amuleIPV4Address &a)
1330 {
1331         m_endpoint = new CamuleIPV4Endpoint(* a.m_endpoint);
1332         return *this;
1333 }
1334
1335 amuleIPV4Address& amuleIPV4Address::operator=(const CamuleIPV4Endpoint &ep)
1336 {
1337         m_endpoint = new CamuleIPV4Endpoint(ep);
1338         return *this;
1339 }
1340
1341 bool amuleIPV4Address::Hostname(const wxString& name)
1342 {
1343         if (name.IsEmpty()) {
1344                 return false;
1345         }
1346         // This is usually just an IP.
1347         std::string sname(unicode2char(name));
1348         error_code ec;
1349         ip::address_v4 adr = ip::address_v4::from_string(sname, ec);
1350         if (!ec) {
1351                 m_endpoint->address(adr);
1352                 return true;
1353         }
1354         AddDebugLogLineN(logAsio, CFormat(wxT("Hostname(\"%s\") failed, not an IP address %s")) % name % ec.message());
1355
1356         // Try to resolve (sync). Normally not required. Unless you type in your hostname as "local IP address" or something.
1357         error_code ec2;
1358         ip::tcp::resolver res(s_io_service);
1359         // We only want to get IPV4 addresses.
1360         ip::tcp::resolver::query query(ip::tcp::v4(), sname, "");
1361         ip::tcp::resolver::iterator endpoint_iterator = res.resolve(query, ec2);
1362         if (ec2) {
1363                 AddDebugLogLineN(logAsio, CFormat(wxT("Hostname(\"%s\") resolve failed: %s")) % name % ec2.message());
1364                 return false;
1365         }
1366         if (endpoint_iterator == ip::tcp::resolver::iterator()) {
1367                 AddDebugLogLineN(logAsio, CFormat(wxT("Hostname(\"%s\") resolve failed: no address found")) % name);
1368                 return false;
1369         }
1370         m_endpoint->address(endpoint_iterator->endpoint().address());
1371         AddDebugLogLineN(logAsio, CFormat(wxT("Hostname(\"%s\") resolved to %s")) % name % IPAddress());
1372         return true;
1373 }
1374
1375 bool amuleIPV4Address::Service(uint16 service)
1376 {
1377         if (service == 0) {
1378                 return false;
1379         }
1380         m_endpoint->port(service);
1381         return true;
1382 }
1383
1384 uint16 amuleIPV4Address::Service() const
1385 {
1386         return m_endpoint->port();
1387 }
1388
1389 bool amuleIPV4Address::IsLocalHost() const
1390 {
1391         return m_endpoint->address().is_loopback();
1392 }
1393
1394 wxString amuleIPV4Address::IPAddress() const
1395 {
1396         return CFormat(wxT("%s")) % m_endpoint->address().to_string();
1397 }
1398
1399 // "Set address to any of the addresses of the current machine."
1400 // This just sets the address to 0.0.0.0 .
1401 // wx does the same.
1402 bool amuleIPV4Address::AnyAddress()
1403 {
1404         m_endpoint->address(ip::address_v4::any());
1405         AddDebugLogLineN(logAsio, CFormat(wxT("AnyAddress: set to %s")) % IPAddress());
1406         return true;
1407 }
1408
1409 const CamuleIPV4Endpoint & amuleIPV4Address::GetEndpoint() const
1410 {
1411         return * m_endpoint;
1412 }
1413
1414 CamuleIPV4Endpoint & amuleIPV4Address::GetEndpoint()
1415 {
1416         return * m_endpoint;
1417 }
1418
1419
1420 //
1421 // Notification stuff
1422 //
1423 namespace MuleNotify
1424 {
1425
1426         void LibSocketConnect(CLibSocket * socket, int error)
1427         {
1428                 if (socket->IsDestroying()) {
1429                         AddDebugLogLineF(logAsio, CFormat(wxT("LibSocketConnect Destroying %s %d")) % socket->GetIP() % error);
1430                 } else if (socket->GetProxyState()) {
1431                         AddDebugLogLineF(logAsio, CFormat(wxT("LibSocketConnect Proxy %s %d")) % socket->GetIP() % error);
1432                         socket->OnProxyEvent(wxSOCKET_CONNECTION);
1433                 } else {
1434                         AddDebugLogLineF(logAsio, CFormat(wxT("LibSocketConnect %s %d")) %socket->GetIP() % error);
1435                         socket->OnConnect(error);
1436                 }
1437         }
1438
1439         void LibSocketSend(CLibSocket * socket, int error)
1440         {
1441                 if (socket->IsDestroying()) {
1442                         AddDebugLogLineF(logAsio, CFormat(wxT("LibSocketSend Destroying %s %d")) % socket->GetIP() % error);
1443                 } else if (socket->GetProxyState()) {
1444                         AddDebugLogLineF(logAsio, CFormat(wxT("LibSocketSend Proxy %s %d")) % socket->GetIP() % error);
1445                         socket->OnProxyEvent(wxSOCKET_OUTPUT);
1446                 } else {
1447                         AddDebugLogLineF(logAsio, CFormat(wxT("LibSocketSend %s %d")) % socket->GetIP() % error);
1448                         socket->OnSend(error);
1449                 }
1450         }
1451
1452         void LibSocketReceive(CLibSocket * socket, int error)
1453         {
1454                 socket->EventProcessed();
1455                 if (socket->IsDestroying()) {
1456                         AddDebugLogLineF(logAsio, CFormat(wxT("LibSocketReceive Destroying %s %d")) % socket->GetIP() % error);
1457                 } else if (socket->GetProxyState()) {
1458                         AddDebugLogLineF(logAsio, CFormat(wxT("LibSocketReceive Proxy %s %d")) % socket->GetIP() % error);
1459                         socket->OnProxyEvent(wxSOCKET_INPUT);
1460                 } else {
1461                         AddDebugLogLineF(logAsio, CFormat(wxT("LibSocketReceive %s %d")) % socket->GetIP() % error);
1462                         socket->OnReceive(error);
1463                 }
1464         }
1465
1466         void LibSocketLost(CLibSocket * socket)
1467         {
1468                 if (socket->IsDestroying()) {
1469                         AddDebugLogLineF(logAsio, CFormat(wxT("LibSocketLost Destroying %s")) % socket->GetIP());
1470                 } else if (socket->GetProxyState()) {
1471                         AddDebugLogLineF(logAsio, CFormat(wxT("LibSocketLost Proxy %s")) % socket->GetIP());
1472                         socket->OnProxyEvent(wxSOCKET_LOST);
1473                 } else {
1474                         AddDebugLogLineF(logAsio, CFormat(wxT("LibSocketLost %s")) % socket->GetIP());
1475                         socket->OnLost();
1476                 }
1477         }
1478
1479         void LibSocketDestroy(CLibSocket * socket)
1480         {
1481                 AddDebugLogLineF(logAsio, CFormat(wxT("LibSocket_Destroy %s")) % socket->GetIP());
1482                 delete socket;
1483         }
1484
1485         void ProxySocketEvent(CLibSocket * socket, int evt)
1486         {
1487                 AddDebugLogLineF(logAsio, CFormat(wxT("ProxySocketEvent %s %d")) % socket->GetIP() % evt);
1488                 socket->OnProxyEvent(evt);
1489         }
1490
1491         void ServerTCPAccept(CLibSocketServer * socketServer)
1492         {
1493                 AddDebugLogLineF(logAsio, wxT("ServerTCP_Accept"));
1494                 socketServer->OnAccept();
1495         }
1496
1497 } // namespace MuleNotify
1498
1499 //
1500 // Initialize MuleBoostVersion
1501 //
1502 wxString MuleBoostVersion = CFormat(wxT("%d.%d")) % (BOOST_VERSION / 100000) % (BOOST_VERSION / 100 % 1000);