Ignore:
Timestamp:
Jan 9, 2017, 11:09:38 AM (3 years ago)
Author:
jrpelegrina
Message:

Update new version: 3.15.02

File:
1 edited

Legend:

Unmodified
Added
Removed
  • filezilla/trunk/fuentes/src/engine/socket.cpp

    r130 r3185  
    11#include <wx/defs.h>
    2 #ifdef __WXMSW__
    3   #ifndef NOMINMAX
    4   #define NOMINMAX
    5   #endif
    6   // MinGW needs this for getaddrinfo
    7   #if defined(_WIN32_WINNT)
    8     #if _WIN32_WINNT < 0x0600
    9       #undef _WIN32_WINNT
    10       #define _WIN32_WINNT 0x0600
    11     #endif
    12   #else
    13     #define _WIN32_WINNT 0x0600
    14   #endif
     2#include <libfilezilla/libfilezilla.hpp>
     3#ifdef FZ_WINDOWS
     4  #include <libfilezilla/private/windows.hpp>
    155  #include <winsock2.h>
    166  #include <ws2tcpip.h>
    177#endif
    188#include <filezilla.h>
    19 #include "mutex.h"
     9#include <libfilezilla/mutex.hpp>
    2010#include "socket.h"
    21 #ifndef __WXMSW__
     11#ifndef FZ_WINDOWS
    2212  #define mutex mutex_override // Sadly on some platforms system headers include conflicting names
    2313  #include <sys/types.h>
     
    6151
    6252class CSocketThread;
     53
    6354namespace {
    6455static std::vector<CSocketThread*> waiting_socket_threads;
    65 static mutex waiting_socket_threads_mutex{false};
    66 };
    67 
    68 struct socket_event_type;
    69 typedef CEvent<socket_event_type> CInternalSocketEvent;
    70 
    71 void RemoveSocketEvents(CEventHandler * handler, CSocketEventSource const* const source)
    72 {
    73         auto socketEventFilter = [&](CEventLoop::Events::value_type const& ev) -> bool {
     56static fz::mutex waiting_socket_threads_mutex{ false };
     57}
     58
     59void RemoveSocketEvents(fz::event_handler * handler, CSocketEventSource const* const source)
     60{
     61        auto socketEventFilter = [&](fz::event_loop::Events::value_type const& ev) -> bool {
    7462                if (ev.first != handler) {
    7563                        return false;
     
    8472        };
    8573
    86         handler->event_loop_.FilterEvents(socketEventFilter);
    87 }
    88 
    89 void ChangeSocketEventHandler(CEventHandler * oldHandler, CEventHandler * newHandler, CSocketEventSource const* const source)
     74        handler->event_loop_.filter_events(socketEventFilter);
     75}
     76
     77void ChangeSocketEventHandler(fz::event_handler * oldHandler, fz::event_handler * newHandler, CSocketEventSource const* const source)
    9078{
    9179        if (!oldHandler)
     
    9987        }
    10088        else {
    101                 auto socketEventFilter = [&](CEventLoop::Events::value_type & ev) -> bool {
     89                auto socketEventFilter = [&](fz::event_loop::Events::value_type & ev) -> bool {
    10290                        if (ev.first == oldHandler) {
    10391                                if (ev.second->derived_type() == CSocketEvent::type()) {
     
    115103                };
    116104
    117                 oldHandler->event_loop_.FilterEvents(socketEventFilter);
     105                oldHandler->event_loop_.filter_events(socketEventFilter);
    118106        }
    119107}
    120108
    121109namespace {
    122 #ifdef __WXMSW__
     110#ifdef FZ_WINDOWS
    123111static int ConvertMSWErrorCode(int error)
    124112{
     
    188176                };
    189177                for (int i = 0; errors[i]; ++i) {
    190 #ifdef __WXMSW__
     178#ifdef FZ_WINDOWS
    191179                        int code = ConvertMSWErrorCode(errors[i]);
    192180#else
     
    202190}
    203191
    204 class CSocketThread final : protected wxThread
     192class CSocketThread final : protected fz::thread
    205193{
    206194        friend class CSocket;
    207195public:
    208196        CSocketThread()
    209                 : wxThread(wxTHREAD_JOINABLE), m_sync(false)
    210         {
    211 #ifdef __WXMSW__
     197                : m_sync(false)
     198        {
     199#ifdef FZ_WINDOWS
    212200                m_sync_event = WSA_INVALID_EVENT;
    213201#else
     
    222210        virtual ~CSocketThread()
    223211        {
    224 #ifdef __WXMSW__
     212                join();
     213#ifdef FZ_WINDOWS
    225214                if (m_sync_event != WSA_INVALID_EVENT)
    226215                        WSACloseEvent(m_sync_event);
     
    235224        void SetSocket(CSocket* pSocket)
    236225        {
    237                 scoped_lock l(m_sync);
     226                fz::scoped_lock l(m_sync);
    238227                SetSocket(pSocket, l);
    239228        }
    240229
    241         void SetSocket(CSocket* pSocket, scoped_lock const&)
     230        void SetSocket(CSocket* pSocket, fz::scoped_lock const&)
    242231        {
    243232                m_pSocket = pSocket;
     
    278267        {
    279268                if (m_started) {
    280                         scoped_lock l(m_sync);
     269                        fz::scoped_lock l(m_sync);
    281270                        wxASSERT(m_threadwait);
    282271                        m_waiting = 0;
     
    285274                }
    286275                m_started = true;
    287 #ifdef __WXMSW__
     276#ifdef FZ_WINDOWS
    288277                if (m_sync_event == WSA_INVALID_EVENT)
    289278                        m_sync_event = WSACreateEvent();
     
    297286#endif
    298287
    299                 int res = Create();
    300                 if (res != wxTHREAD_NO_ERROR)
     288                if (!run()) {
    301289                        return 1;
    302 
    303                 Run();
     290                }
    304291
    305292                return 0;
     
    309296        void WakeupThread()
    310297        {
    311                 scoped_lock l(m_sync);
     298                fz::scoped_lock l(m_sync);
    312299                WakeupThread(l);
    313300        }
    314301
    315         void WakeupThread(scoped_lock & l)
     302        void WakeupThread(fz::scoped_lock & l)
    316303        {
    317304                if (!m_started || m_finished) {
     
    325312                }
    326313
    327 #ifdef __WXMSW__
     314#ifdef FZ_WINDOWS
    328315                WSASetEvent(m_sync_event);
    329316#else
     
    341328        {
    342329                int fd;
    343 #if defined(SOCK_CLOEXEC) && !defined(__WXMSW__)
     330#if defined(SOCK_CLOEXEC) && !defined(FZ_WINDOWS)
    344331                fd = socket(addr.ai_family, addr.ai_socktype | SOCK_CLOEXEC, addr.ai_protocol);
    345332                if (fd == -1 && errno == EINVAL)
     
    364351        {
    365352                if (fd != -1) {
    366         #ifdef __WXMSW__
     353        #ifdef FZ_WINDOWS
    367354                        closesocket(fd);
    368355        #else
     
    373360        }
    374361
    375         int TryConnectHost(addrinfo & addr, sockaddr_u const& bindAddr, scoped_lock & l)
     362        int TryConnectHost(addrinfo & addr, sockaddr_u const& bindAddr, fz::scoped_lock & l)
    376363        {
    377364                if (m_pSocket->m_pEvtHandler) {
    378                         m_pSocket->m_pEvtHandler->SendEvent<CHostAddressEvent>(m_pSocket, CSocket::AddressToString(addr.ai_addr, addr.ai_addrlen));
     365                        m_pSocket->m_pEvtHandler->send_event<CHostAddressEvent>(m_pSocket, CSocket::AddressToString(addr.ai_addr, addr.ai_addrlen));
    379366                }
    380367
     
    382369                if (fd == -1) {
    383370                        if (m_pSocket->m_pEvtHandler) {
    384                                 m_pSocket->m_pEvtHandler->SendEvent<CSocketEvent>(m_pSocket, addr.ai_next ? SocketEventType::connection_next : SocketEventType::connection, GetLastSocketError());
     371                                m_pSocket->m_pEvtHandler->send_event<CSocketEvent>(m_pSocket, addr.ai_next ? SocketEventType::connection_next : SocketEventType::connection, GetLastSocketError());
    385372                        }
    386373
     
    397384                int res = connect(fd, addr.ai_addr, addr.ai_addrlen);
    398385                if (res == -1) {
    399 #ifdef __WXMSW__
     386#ifdef FZ_WINDOWS
    400387                        // Map to POSIX error codes
    401388                        int error = WSAGetLastError();
     
    403390                                res = EINPROGRESS;
    404391                        else
    405                                 res = ConvertMSWErrorCode(WSAGetLastError());
     392                                res = GetLastSocketError();
    406393#else
    407394                        res = errno;
     
    433420                if (res) {
    434421                        if (m_pSocket->m_pEvtHandler) {
    435                                 m_pSocket->m_pEvtHandler->SendEvent<CSocketEvent>(m_pSocket, addr.ai_next ? SocketEventType::connection_next : SocketEventType::connection, res);
     422                                m_pSocket->m_pEvtHandler->send_event<CSocketEvent>(m_pSocket, addr.ai_next ? SocketEventType::connection_next : SocketEventType::connection, res);
    436423                        }
    437424
     
    444431
    445432                        if (m_pSocket->m_pEvtHandler) {
    446                                 m_pSocket->m_pEvtHandler->SendEvent<CSocketEvent>(m_pSocket, SocketEventType::connection, 0);
     433                                m_pSocket->m_pEvtHandler->send_event<CSocketEvent>(m_pSocket, SocketEventType::connection, 0);
    447434                        }
    448435
     
    457444
    458445        // Only call while locked
    459         bool DoConnect(scoped_lock & l)
     446        bool DoConnect(fz::scoped_lock & l)
    460447        {
    461448                if (m_host.empty() || m_port.empty()) {
     
    520507
    521508                if (res) {
    522 #ifdef __WXMSW__
     509#ifdef FZ_WINDOWS
    523510                        res = ConvertMSWErrorCode(res);
    524511#endif
    525512
    526513                        if (m_pSocket->m_pEvtHandler) {
    527                                 m_pSocket->m_pEvtHandler->SendEvent<CSocketEvent>(m_pSocket, SocketEventType::connection, res);
     514                                m_pSocket->m_pEvtHandler->send_event<CSocketEvent>(m_pSocket, SocketEventType::connection, res);
    528515                        }
    529516                        m_pSocket->m_state = CSocket::closed;
     
    548535
    549536                if (m_pSocket->m_pEvtHandler) {
    550                         m_pSocket->m_pEvtHandler->SendEvent<CSocketEvent>(m_pSocket, SocketEventType::connection, ECONNABORTED);
     537                        m_pSocket->m_pEvtHandler->send_event<CSocketEvent>(m_pSocket, SocketEventType::connection, ECONNABORTED);
    551538                }
    552539                m_pSocket->m_state = CSocket::closed;
     
    561548
    562549        // Call only while locked
    563         bool DoWait(int wait, scoped_lock & l)
     550        bool DoWait(int wait, fz::scoped_lock & l)
    564551        {
    565552                m_waiting |= wait;
    566553
    567554                for (;;) {
    568 #ifdef __WXMSW__
     555#ifdef FZ_WINDOWS
    569556                        int wait_events = FD_CLOSE;
    570557                        if (m_waiting & WAIT_CONNECT)
     
    590577                        int res = WSAEnumNetworkEvents(m_pSocket->m_fd, m_sync_event, &events);
    591578                        if (res) {
    592                                 res = ConvertMSWErrorCode(WSAGetLastError());
     579                                res = GetLastSocketError();
    593580                                return false;
    594581                        }
     
    720707                        if (m_pSocket->m_synchronous_read_cb)
    721708                                m_pSocket->m_synchronous_read_cb->cb();
    722                         m_pSocket->m_pEvtHandler->SendEvent<CSocketEvent>(m_pSocket, SocketEventType::read, m_triggered_errors[1]);
     709                        m_pSocket->m_pEvtHandler->send_event<CSocketEvent>(m_pSocket, SocketEventType::read, m_triggered_errors[1]);
    723710                        m_triggered &= ~WAIT_READ;
    724711                }
    725712                if (m_triggered & WAIT_WRITE) {
    726                         m_pSocket->m_pEvtHandler->SendEvent<CSocketEvent>(m_pSocket, SocketEventType::write, m_triggered_errors[2]);
     713                        m_pSocket->m_pEvtHandler->send_event<CSocketEvent>(m_pSocket, SocketEventType::write, m_triggered_errors[2]);
    727714                        m_triggered &= ~WAIT_WRITE;
    728715                }
    729716                if (m_triggered & WAIT_ACCEPT) {
    730                         m_pSocket->m_pEvtHandler->SendEvent<CSocketEvent>(m_pSocket, SocketEventType::connection, m_triggered_errors[3]);
     717                        m_pSocket->m_pEvtHandler->send_event<CSocketEvent>(m_pSocket, SocketEventType::connection, m_triggered_errors[3]);
    731718                        m_triggered &= ~WAIT_ACCEPT;
    732719                }
     
    742729                }
    743730
    744 #ifdef __WXMSW__
     731#ifdef FZ_WINDOWS
    745732                // MSDN says this:
    746733                //   FD_CLOSE being posted after all data is read from a socket.
     
    753740                                return;
    754741                        }
    755                         m_pSocket->m_pEvtHandler->SendEvent<CSocketEvent>(m_pSocket, SocketEventType::read, 0);
     742                        m_pSocket->m_pEvtHandler->send_event<CSocketEvent>(m_pSocket, SocketEventType::read, 0);
    756743                }
    757744                else
    758745#endif
    759746                {
    760                         m_pSocket->m_pEvtHandler->SendEvent<CSocketEvent>(m_pSocket, SocketEventType::close, m_triggered_errors[4]);
     747                        m_pSocket->m_pEvtHandler->send_event<CSocketEvent>(m_pSocket, SocketEventType::close, m_triggered_errors[4]);
    761748                        m_triggered &= ~WAIT_CLOSE;
    762749                }
     
    764751
    765752        // Call only while locked
    766         bool IdleLoop(scoped_lock & l)
     753        bool IdleLoop(fz::scoped_lock & l)
    767754        {
    768755                if (m_quit)
     
    779766        }
    780767
    781         virtual ExitCode Entry()
    782         {
    783                 scoped_lock l(m_sync);
     768        virtual void entry()
     769        {
     770                fz::scoped_lock l(m_sync);
    784771                for (;;) {
    785772                        if (!IdleLoop(l)) {
    786773                                m_finished = true;
    787                                 return 0;
     774                                return;
    788775                        }
    789776
     
    805792                                }
    806793
    807 #ifdef __WXMSW__
     794#ifdef FZ_WINDOWS
    808795                                m_waiting |= WAIT_CLOSE;
    809796                                int wait_close = WAIT_CLOSE;
     
    818805                                        if (m_triggered & WAIT_CLOSE && m_pSocket) {
    819806                                                m_pSocket->m_state = CSocket::closing;
    820 #ifdef __WXMSW__
     807#ifdef FZ_WINDOWS
    821808                                                wait_close = 0;
    822809#endif
     
    827814
    828815                                        SendEvents();
    829 #ifdef __WXMSW__
     816#ifdef FZ_WINDOWS
    830817                                        m_waiting |= wait_close;
    831818#endif
     
    835822
    836823                m_finished = true;
    837                 return 0;
     824                return;
    838825        }
    839826
     
    844831        std::string m_bind;
    845832
    846 #ifdef __WXMSW__
     833#ifdef FZ_WINDOWS
    847834        // We wait on this using WSAWaitForMultipleEvents
    848835        WSAEVENT m_sync_event;
     
    852839#endif
    853840
    854         mutex m_sync;
    855         condition m_condition;
     841        fz::mutex m_sync;
     842        fz::condition m_condition;
    856843
    857844        bool m_started{};
     
    870857};
    871858
    872 CSocket::CSocket(CEventHandler* pEvtHandler)
     859CSocket::CSocket(fz::event_handler* pEvtHandler)
    873860        : m_pEvtHandler(pEvtHandler)
    874861{
     
    901888                return;
    902889
    903         scoped_lock l(m_pSocketThread->m_sync);
     890        fz::scoped_lock l(m_pSocketThread->m_sync);
    904891        m_pSocketThread->SetSocket(0, l);
    905892        if (m_pSocketThread->m_finished) {
    906893                m_pSocketThread->WakeupThread(l);
    907894                l.unlock();
    908                 m_pSocketThread->Wait();
    909895                delete m_pSocketThread;
    910896        }
     
    919905                        l.unlock();
    920906
    921                         scoped_lock wl(waiting_socket_threads_mutex);
     907                        fz::scoped_lock wl(waiting_socket_threads_mutex);
    922908                        waiting_socket_threads.push_back(m_pSocketThread);
    923909                }
     
    952938
    953939        if (m_pSocketThread && m_pSocketThread->m_started) {
    954                 scoped_lock l(m_pSocketThread->m_sync);
     940                fz::scoped_lock l(m_pSocketThread->m_sync);
    955941                if (!m_pSocketThread->m_threadwait) {
    956942                        m_pSocketThread->WakeupThread(l);
     
    987973}
    988974
    989 void CSocket::SetEventHandler(CEventHandler* pEvtHandler)
     975void CSocket::SetEventHandler(fz::event_handler* pEvtHandler)
    990976{
    991977        if (m_pSocketThread) {
    992                 scoped_lock l(m_pSocketThread->m_sync);
     978                fz::scoped_lock l(m_pSocketThread->m_sync);
    993979
    994980                if (m_pEvtHandler == pEvtHandler) {
     
    1001987
    1002988                if (pEvtHandler && m_state == connected) {
    1003 #ifdef __WXMSW__
     989#ifdef FZ_WINDOWS
    1004990                        // If a graceful shutdown is going on in background already,
    1005991                        // no further events are recorded. Send out events we're not
     
    1007993
    1008994                        if (!(m_pSocketThread->m_waiting & WAIT_WRITE)) {
    1009                                 pEvtHandler->SendEvent<CSocketEvent>(this, SocketEventType::write, 0);
    1010                         }
    1011 
    1012                         pEvtHandler->SendEvent<CSocketEvent>(this, SocketEventType::read, 0);
     995                                pEvtHandler->send_event<CSocketEvent>(this, SocketEventType::write, 0);
     996                        }
     997
     998                        pEvtHandler->send_event<CSocketEvent>(this, SocketEventType::read, 0);
    1013999                        if (m_pSocketThread->m_waiting & WAIT_READ) {
    10141000                                m_pSocketThread->m_waiting &= ~WAIT_READ;
     
    11051091
    11061092        // Codes that have no POSIX equivalence
    1107 #ifdef __WXMSW__
     1093#ifdef FZ_WINDOWS
    11081094        ERRORDECL(WSANOTINITIALISED, TRANSLATE_T("Not initialized, need to call WSAStartup"))
    11091095        ERRORDECL(WSAENETDOWN, TRANSLATE_T("System's network subsystem has failed"))
     
    11451131{
    11461132        if (m_pSocketThread) {
    1147                 scoped_lock l(m_pSocketThread->m_sync);
     1133                fz::scoped_lock l(m_pSocketThread->m_sync);
    11481134                int fd = m_fd;
    11491135                m_fd = -1;
     
    11961182void CSocket::Cleanup(bool force)
    11971183{
    1198         scoped_lock wl(waiting_socket_threads_mutex);
     1184        fz::scoped_lock wl(waiting_socket_threads_mutex);
    11991185        auto iter = waiting_socket_threads.begin();
    12001186        for (; iter != waiting_socket_threads.end(); ++iter) {
     
    12021188
    12031189                if (!force) {
    1204                         scoped_lock l(pThread->m_sync);
     1190                        fz::scoped_lock l(pThread->m_sync);
    12051191                        if (!pThread->m_finished) {
    12061192                                break;
     
    12081194                }
    12091195
    1210                 pThread->Wait(wxTHREAD_WAIT_BLOCK);
    12111196                delete pThread;
    12121197        }
     
    12221207                if (error == EAGAIN) {
    12231208                        if (m_pSocketThread) {
    1224                                 scoped_lock l(m_pSocketThread->m_sync);
     1209                                fz::scoped_lock l(m_pSocketThread->m_sync);
    12251210                                if (!(m_pSocketThread->m_waiting & WAIT_READ)) {
    12261211                                        m_pSocketThread->m_waiting |= WAIT_READ;
     
    12561241        const int flags = 0;
    12571242
    1258 #if !defined(SO_NOSIGPIPE) && !defined(__WXMSW__)
     1243#if !defined(SO_NOSIGPIPE) && !defined(FZ_WINDOWS)
    12591244        // Some systems have neither. Need to block signal
    12601245        struct sigaction old_action;
    1261         struct sigaction action = {0};
     1246        struct sigaction action = {};
    12621247        action.sa_handler = SIG_IGN;
    12631248        int signal_set = sigaction(SIGPIPE, &action, &old_action);
     
    12681253        int res = send(m_fd, (const char*)buffer, size, flags);
    12691254
    1270 #if !defined(MSG_NOSIGNAL) && !defined(SO_NOSIGPIPE) && !defined(__WXMSW__)
     1255#if !defined(MSG_NOSIGNAL) && !defined(SO_NOSIGPIPE) && !defined(FZ_WINDOWS)
    12711256        // Restore previous signal handler
    12721257        if (!signal_set)
     
    12781263                if (error == EAGAIN) {
    12791264                        if (m_pSocketThread) {
    1280                                 scoped_lock l (m_pSocketThread->m_sync);
     1265                                fz::scoped_lock l (m_pSocketThread->m_sync);
    12811266                                if (!(m_pSocketThread->m_waiting & WAIT_WRITE)) {
    12821267                                        m_pSocketThread->m_waiting |= WAIT_WRITE;
     
    14071392
    14081393        {
    1409                 struct addrinfo hints = {0};
     1394                struct addrinfo hints = {};
    14101395                hints.ai_family = m_family;
    14111396                hints.ai_socktype = SOCK_STREAM;
     
    14231408
    14241409                if (res) {
    1425 #ifdef __WXMSW__
     1410#ifdef FZ_WINDOWS
    14261411                        return ConvertMSWErrorCode(res);
    14271412#else
     
    14751460        error = getsockname(m_fd, &addr.sockaddr, &addr_len);
    14761461        if (error) {
    1477 #ifdef __WXMSW__
     1462#ifdef FZ_WINDOWS
    14781463                error = ConvertMSWErrorCode(error);
    14791464#endif
     
    14971482        if (error)
    14981483        {
    1499 #ifdef __WXMSW__
     1484#ifdef FZ_WINDOWS
    15001485                error = ConvertMSWErrorCode(error);
    15011486#endif
     
    15151500{
    15161501        if (m_pSocketThread) {
    1517                 scoped_lock l(m_pSocketThread->m_sync);
     1502                fz::scoped_lock l(m_pSocketThread->m_sync);
    15181503                m_pSocketThread->m_waiting |= WAIT_ACCEPT;
    15191504                m_pSocketThread->WakeupThread(l);
     
    15491534{
    15501535        // Set socket to non-blocking.
    1551 #ifdef __WXMSW__
     1536#ifdef FZ_WINDOWS
    15521537        unsigned long nonblock = 1;
    15531538        int res = ioctlsocket(fd, FIONBIO, &nonblock);
Note: See TracChangeset for help on using the changeset viewer.