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

Update new version: 3.15.02

File:
1 edited

Legend:

Unmodified
Added
Removed
  • filezilla/trunk/fuentes/src/interface/netconfwizard.cpp

    r130 r3185  
    11#include <filezilla.h>
    22
    3 #include "event_loop.h"
     3#include <libfilezilla/event_loop.hpp>
     4#include <libfilezilla/iputils.hpp>
     5#include <libfilezilla/util.hpp>
    46#include "engine_context.h"
    57#include "netconfwizard.h"
     
    1517EVT_WIZARD_PAGE_CHANGING(wxID_ANY, CNetConfWizard::OnPageChanging)
    1618EVT_WIZARD_PAGE_CHANGED(wxID_ANY, CNetConfWizard::OnPageChanged)
    17 EVT_SOCKET(wxID_ANY, CNetConfWizard::OnSocketEvent)
    1819EVT_BUTTON(XRCID("ID_RESTART"), CNetConfWizard::OnRestart)
    1920EVT_WIZARD_FINISHED(wxID_ANY, CNetConfWizard::OnFinish)
     
    2930
    3031CNetConfWizard::CNetConfWizard(wxWindow* parent, COptions* pOptions, CFileZillaEngineContext & engine_context)
    31         : CEventHandler(engine_context.GetEventLoop())
     32        : fz::event_handler(engine_context.GetEventLoop())
    3233        , m_parent(parent), m_pOptions(pOptions), m_pSocketServer(0)
    3334{
    34         m_socket = 0;
    3535        m_pIPResolver = 0;
    3636        m_pSendBuffer = 0;
    37         m_pSocketServer = 0;
    38         m_pDataSocket = 0;
    3937
    4038        m_timer.SetOwner(this);
     
    4543CNetConfWizard::~CNetConfWizard()
    4644{
    47         RemoveHandler();
     45        remove_handler();
    4846
    4947        delete m_socket;
     
    146144void CNetConfWizard::OnPageChanging(wxWizardEvent& event)
    147145{
    148         if (event.GetPage() == m_pages[3])
    149         {
     146        if (event.GetPage() == m_pages[3]) {
    150147                int mode = XRCCTRL(*this, "ID_ACTIVEMODE1", wxRadioButton)->GetValue() ? 0 : (XRCCTRL(*this, "ID_ACTIVEMODE2", wxRadioButton)->GetValue() ? 1 : 2);
    151                 if (mode == 1)
    152                 {
     148                if (mode == 1) {
    153149                        wxTextCtrl* control = XRCCTRL(*this, "ID_ACTIVEIP", wxTextCtrl);
    154150                        wxString ip = control->GetValue();
    155                         if (ip.empty())
    156                         {
     151                        if (ip.empty()) {
    157152                                wxMessageBoxEx(_("Please enter your external IP address"));
    158153                                control->SetFocus();
     
    160155                                return;
    161156                        }
    162                         if (!IsIpAddress(ip))
    163                         {
    164                                 wxMessageBoxEx(_("You have to enter a valid IP address."));
     157                        if (fz::get_address_type(ip.ToStdWstring()) != fz::address_type::ipv4) {
     158                                wxMessageBoxEx(_("You have to enter a valid IPv4 address."));
    165159                                control->SetFocus();
    166160                                event.Veto();
     
    168162                        }
    169163                }
    170                 else if (mode == 2)
    171                 {
     164                else if (mode == 2) {
    172165                        wxTextCtrl* pResolver = XRCCTRL(*this, "ID_ACTIVERESOLVER", wxTextCtrl);
    173166                        wxString address = pResolver->GetValue();
    174                         if (address.empty())
    175                         {
     167                        if (address.empty()) {
    176168                                wxMessageBoxEx(_("Please enter an URL where to get your external address from"));
    177169                                pResolver->SetFocus();
     
    181173                }
    182174        }
    183         else if (event.GetPage() == m_pages[4])
    184         {
     175        else if (event.GetPage() == m_pages[4]) {
    185176                int mode = XRCCTRL(*this, "ID_ACTIVE_PORTMODE1", wxRadioButton)->GetValue() ? 0 : 1;
    186                 if (mode)
    187                 {
     177                if (mode) {
    188178                        wxTextCtrl* pPortMin = XRCCTRL(*this, "ID_ACTIVE_PORTMIN", wxTextCtrl);
    189179                        wxTextCtrl* pPortMax = XRCCTRL(*this, "ID_ACTIVE_PORTMAX", wxTextCtrl);
     
    202192                }
    203193        }
    204         else if (event.GetPage() == m_pages[5] && !event.GetDirection())
    205         {
     194        else if (event.GetPage() == m_pages[5] && !event.GetDirection()) {
    206195                wxButton* pNext = wxDynamicCast(FindWindow(wxID_FORWARD), wxButton);
    207196                pNext->SetLabel(m_nextLabelText);
    208197        }
    209         else if (event.GetPage() == m_pages[5] && event.GetDirection())
    210         {
     198        else if (event.GetPage() == m_pages[5] && event.GetDirection()) {
    211199                if (m_testDidRun)
    212200                        return;
     
    221209
    222210                PrintMessage(wxString::Format(_("Connecting to %s"), _T("probe.filezilla-project.org")), 0);
    223                 m_socket = new wxSocketClient(wxSOCKET_NOWAIT);
    224                 m_socket->SetEventHandler(*this, 0);
    225                 m_socket->SetNotify(wxSOCKET_INPUT_FLAG | wxSOCKET_OUTPUT_FLAG | wxSOCKET_CONNECTION_FLAG | wxSOCKET_LOST_FLAG);
    226                 m_socket->Notify(true);
     211                m_socket = new CSocket(this);
    227212                m_recvBufferPos = 0;
    228213
    229                 wxIPV4address addr;
    230                 addr.Hostname(_T("probe.filezilla-project.org"));
    231                 addr.Service(21);
    232 
    233                 m_socket->Connect(addr, false);
     214                int res = m_socket->Connect(_T("probe.filezilla-project.org"), 21);
     215                if (res && res != EINPROGRESS) {
     216                        PrintMessage(wxString::Format(_("Connect failed: %s"), CSocket::GetErrorDescription(res)), 1);
     217                        CloseSocket();
     218                }
    234219        }
    235220}
     
    237222void CNetConfWizard::OnPageChanged(wxWizardEvent& event)
    238223{
    239         if (event.GetPage() == m_pages[5])
    240         {
     224        if (event.GetPage() == m_pages[5]) {
    241225                wxButton* pNext = wxDynamicCast(FindWindow(wxID_FORWARD), wxButton);
    242226                m_nextLabelText = pNext->GetLabel();
    243227                pNext->SetLabel(_("&Test"));
    244228        }
    245         else if (event.GetPage() == m_pages[6])
    246         {
     229        else if (event.GetPage() == m_pages[6]) {
    247230                wxButton* pPrev = wxDynamicCast(FindWindow(wxID_BACKWARD), wxButton);
    248231                pPrev->Disable();
     
    252235}
    253236
    254 void CNetConfWizard::OnSocketEvent(wxSocketEvent& event)
    255 {
     237void CNetConfWizard::DoOnSocketEvent(CSocketEventSource* s, SocketEventType t, int error)
     238{
     239        if (s == m_socket) {
     240                if (error) {
     241                        OnClose();
     242                        return;
     243                }
     244                switch (t)
     245                {
     246                case SocketEventType::read:
     247                        OnReceive();
     248                        break;
     249                case SocketEventType::write:
     250                        OnSend();
     251                        break;
     252                case SocketEventType::close:
     253                        OnClose();
     254                        break;
     255                case SocketEventType::connection:
     256                        OnConnect();
     257                        break;
     258                default:
     259                        break;
     260                }
     261        }
     262        else if (s == m_pSocketServer) {
     263                if (error) {
     264                        PrintMessage(_("Listen socket closed"), 1);
     265                        CloseSocket();
     266                        return;
     267                }
     268                switch (t) {
     269                case SocketEventType::close:
     270                        PrintMessage(_("Listen socket closed"), 1);
     271                        CloseSocket();
     272                        break;
     273                case SocketEventType::connection:
     274                        OnAccept();
     275                        break;
     276                default:
     277                        break;
     278                }
     279        }
     280        else if (s == m_pDataSocket) {
     281                if (error) {
     282                        OnDataClose();
     283                        return;
     284                }
     285                switch (t)
     286                {
     287                case SocketEventType::close:
     288                        OnDataClose();
     289                        break;
     290                case SocketEventType::read:
     291                        OnDataReceive();
     292                        break;
     293                default:
     294                        break;
     295                }
     296        }
     297}
     298
     299
     300void CNetConfWizard::OnSend()
     301{
     302        if (!m_pSendBuffer)
     303                return;
     304
    256305        if (!m_socket)
    257306                return;
    258307
    259         if (event.GetSocket() == m_socket)
    260         {
    261                 switch (event.GetSocketEvent())
    262                 {
    263                 case wxSOCKET_INPUT:
    264                         OnReceive();
    265                         break;
    266                 case wxSOCKET_OUTPUT:
    267                         OnSend();
    268                         break;
    269                 case wxSOCKET_LOST:
    270                         OnClose();
    271                         break;
    272                 case wxSOCKET_CONNECTION:
    273                         OnConnect();
    274                         break;
    275                 }
    276         }
    277         else if (event.GetSocket() == m_pSocketServer)
    278         {
    279                 switch (event.GetSocketEvent())
    280                 {
    281                 case wxSOCKET_LOST:
    282                         PrintMessage(_("Listen socket closed"), 1);
    283                         CloseSocket();
    284                         break;
    285                 case wxSOCKET_CONNECTION:
    286                         OnAccept();
    287                         break;
    288                 default:
    289                         break;
    290                 }
    291         }
    292         else if (event.GetSocket() == m_pDataSocket)
    293         {
    294                 switch (event.GetSocketEvent())
    295                 {
    296                 case wxSOCKET_LOST:
    297                         OnDataClose();
    298                         break;
    299                 case wxSOCKET_INPUT:
    300                         OnDataReceive();
    301                         break;
    302                 default:
    303                         break;
    304                 }
    305         }
    306 }
    307 
    308 void CNetConfWizard::OnSend()
    309 {
    310         if (!m_pSendBuffer)
    311                 return;
    312 
    313         if (!m_socket)
    314                 return;
    315 
    316         int len = strlen(m_pSendBuffer);
    317         m_socket->Write(m_pSendBuffer, len);
    318         if (m_socket->Error())
    319         {
    320                 if (m_socket->LastError() != wxSOCKET_WOULDBLOCK)
    321                 {
     308        int error;
     309        int const len = strlen(m_pSendBuffer);
     310        int const written = m_socket->Write(m_pSendBuffer, len, error);
     311        if (written < 0) {
     312                if (error != EAGAIN) {
    322313                        PrintMessage(_("Failed to send command."), 1);
    323314                        CloseSocket();
     
    325316                return;
    326317        }
    327         int written = m_socket->LastCount();
    328         if (written == len)
    329         {
     318        if (written == len) {
    330319                delete [] m_pSendBuffer;
    331320                m_pSendBuffer = 0;
     
    342331void CNetConfWizard::OnConnect()
    343332{
     333        PrintMessage(_("Connection established, waiting for welcome message."), 0);
    344334        m_connectSuccessful = true;
    345335}
     
    347337void CNetConfWizard::OnReceive()
    348338{
    349         m_socket->Read(m_recvBuffer + m_recvBufferPos, NETCONFBUFFERSIZE - m_recvBufferPos);
    350         unsigned int len;
    351         if (m_socket->Error() || !(len = m_socket->LastCount()))
    352         {
    353                 PrintMessage(_("Connection lost"), 1);
    354                 CloseSocket();
    355                 return;
    356         }
    357 
    358         m_recvBufferPos += len;
    359 
    360         if (m_recvBufferPos < 3)
    361                 return;
    362 
    363         for (int i = 0; i < m_recvBufferPos - 1; i++)
    364         {
    365                 if (m_recvBuffer[i] == '\n')
    366                 {
     339        while (true) {
     340                int error;
     341                int const read = m_socket->Read(m_recvBuffer + m_recvBufferPos, NETCONFBUFFERSIZE - m_recvBufferPos, error);
     342                if (read < 0) {
     343                        if (error != EAGAIN) {
     344                                PrintMessage(_("Could not receive data from server."), 1);
     345                                CloseSocket();
     346                        }
     347                        return;
     348                }
     349                if (!read) {
     350                        PrintMessage(_("Connection lost"), 1);
     351                        CloseSocket();
     352                        return;
     353                }
     354
     355                m_recvBufferPos += read;
     356
     357                if (m_recvBufferPos < 3)
     358                        return;
     359
     360                for (int i = 0; i < m_recvBufferPos - 1; ++i) {
     361                        if (m_recvBuffer[i] == '\n') {
     362                                m_testResult = servererror;
     363                                PrintMessage(_("Invalid data received"), 1);
     364                                CloseSocket();
     365                                return;
     366                        }
     367                        if (m_recvBuffer[i] != '\r')
     368                                continue;
     369
     370                        if (m_recvBuffer[i + 1] != '\n') {
     371                                m_testResult = servererror;
     372                                PrintMessage(_("Invalid data received"), 1);
     373                                CloseSocket();
     374                                return;
     375                        }
     376                        m_recvBuffer[i] = 0;
     377
     378                        if (!*m_recvBuffer) {
     379                                m_testResult = servererror;
     380                                PrintMessage(_("Invalid data received"), 1);
     381                                CloseSocket();
     382                                return;
     383                        }
     384
     385                        ParseResponse(m_recvBuffer);
     386
     387                        if (!m_socket)
     388                                return;
     389
     390                        memmove(m_recvBuffer, m_recvBuffer + i + 2, m_recvBufferPos - i - 2);
     391                        m_recvBufferPos -= i + 2;
     392                        i = -1;
     393                }
     394
     395                if (m_recvBufferPos == 100) {
    367396                        m_testResult = servererror;
    368397                        PrintMessage(_("Invalid data received"), 1);
     
    370399                        return;
    371400                }
    372                 if (m_recvBuffer[i] != '\r')
    373                         continue;
    374 
    375                 if (m_recvBuffer[i + 1] != '\n')
    376                 {
    377                         m_testResult = servererror;
    378                         PrintMessage(_("Invalid data received"), 1);
    379                         CloseSocket();
    380                         return;
    381                 }
    382                 m_recvBuffer[i] = 0;
    383 
    384                 if (!*m_recvBuffer)
    385                 {
    386                         m_testResult = servererror;
    387                         PrintMessage(_("Invalid data received"), 1);
    388                         CloseSocket();
    389                         return;
    390                 }
    391 
    392                 ParseResponse(m_recvBuffer);
    393 
    394                 if (!m_socket)
    395                         return;
    396 
    397                 memmove(m_recvBuffer, m_recvBuffer + i + 2, m_recvBufferPos - i - 2);
    398                 m_recvBufferPos -= i + 2;
    399                 i = -1;
    400401        }
    401402}
     
    413414        PrintMessage(str, 3);
    414415
    415         if (len < 3)
    416         {
     416        if (len < 3) {
    417417                m_testResult = servererror;
    418418                PrintMessage(_("Server sent unexpected reply."), 1);
     
    420420                return;
    421421        }
    422         if (line[3] && line[3] != ' ')
    423         {
     422        if (line[3] && line[3] != ' ') {
    424423                m_testResult = servererror;
    425424                PrintMessage(_("Server sent unexpected reply."), 1);
     
    437436                        break;
    438437
    439                 if (line[1] == '0' && line[2] == '1')
    440                 {
     438                if (line[1] == '0' && line[2] == '1') {
    441439                        PrintMessage(_("Communication tainted by router or firewall"), 1);
    442440                        m_testResult = tainted;
     
    444442                        return;
    445443                }
    446                 else if (line[1] == '1' && line[2] == '0')
    447                 {
     444                else if (line[1] == '1' && line[2] == '0') {
    448445                        PrintMessage(_("Wrong external IP address"), 1);
    449446                        m_testResult = mismatch;
     
    451448                        return;
    452449                }
    453                 else if (line[1] == '1' && line[2] == '1')
    454                 {
     450                else if (line[1] == '1' && line[2] == '1') {
    455451                        PrintMessage(_("Wrong external IP address"), 1);
    456452                        PrintMessage(_("Communication tainted by router or firewall"), 1);
     
    459455                        return;
    460456                }
    461                 else
    462                 {
     457                else {
    463458                        m_testResult = servererror;
    464459                        PrintMessage(_("Server sent unexpected reply."), 1);
     
    498493
    499494
    500                 if (line[0] == '5' && line[1] == '0' && (line[2] == '1' || line[2] == '2'))
    501                 {
     495                if (line[0] == '5' && line[1] == '0' && (line[2] == '1' || line[2] == '2')) {
    502496                        m_testResult = tainted;
    503497                        PrintMessage(_("PORT command tainted by router or firewall."), 1);
     
    546540}
    547541
    548 void CNetConfWizard::PrintMessage(const wxString& msg, int type)
     542void CNetConfWizard::PrintMessage(const wxString& msg, int)
    549543{
    550544        XRCCTRL(*this, "ID_RESULTS", wxTextCtrl)->AppendText(msg + _T("\n"));
     
    699693        int mode = XRCCTRL(*this, "ID_ACTIVEMODE1", wxRadioButton)->GetValue() ? 0 : (XRCCTRL(*this, "ID_ACTIVEMODE2", wxRadioButton)->GetValue() ? 1 : 2);
    700694        if (!mode) {
    701                 wxIPV4address addr;
    702                 if (m_socket->GetLocal(addr)) {
    703                         ret = addr.IPAddress();
    704                 }
    705                 else {
     695                ret = m_socket->GetLocalIP();
     696                if (ret.empty()) {
    706697                        PrintMessage(_("Failed to retrieve local ip address. Aborting"), 1);
    707698                        CloseSocket();
     
    772763                        if (ip.empty())
    773764                                return;
    774                         if (!GetIPV6LongForm(ip).empty())
    775                         {
     765                        if (!fz::get_ipv6_long_form(ip.ToStdWstring()).empty()) {
    776766                                PrintMessage(_("You appear to be using an IPv6-only host. This wizard does not support this environment."), 1);
    777767                                CloseSocket();
     
    828818}
    829819
    830 void CNetConfWizard::OnRestart(wxCommandEvent& event)
     820void CNetConfWizard::OnRestart(wxCommandEvent&)
    831821{
    832822        ResetTest();
     
    851841}
    852842
    853 void CNetConfWizard::OnFinish(wxWizardEvent& event)
    854 {
    855         if (m_testResult != successful)
    856         {
     843void CNetConfWizard::OnFinish(wxWizardEvent&)
     844{
     845        if (m_testResult != successful) {
    857846                if (wxMessageBoxEx(_("The test did not succeed. Do you really want to save the settings?"), _("Save settings?"), wxYES_NO | wxICON_QUESTION) != wxYES)
    858847                        return;
     
    896885                XRCCTRL(*this, "ID_ACTIVE_PORTMAX", wxTextCtrl)->GetValue().ToLong(&high);
    897886
    898                 int mid = GetRandomNumber(low, high);
     887                int mid = fz::random_number(low, high);
    899888                wxASSERT(mid >= low && mid <= high);
    900889
     
    912901int CNetConfWizard::CreateListenSocket(unsigned int port)
    913902{
    914         wxIPV4address addr;
    915         if (!addr.AnyAddress())
    916                 return 0;
    917 
    918         if (!addr.Service(port))
    919                 return 0;
    920 
    921         m_pSocketServer = new wxSocketServer(addr, wxSOCKET_NOWAIT);
    922         if (!m_pSocketServer->Ok())
    923         {
     903        m_pSocketServer = new CSocket(this);
     904        int res = m_pSocketServer->Listen(CSocket::unspec, port);
     905
     906        if (res < 0) {
    924907                delete m_pSocketServer;
    925908                m_pSocketServer = 0;
     
    927910        }
    928911
    929         m_pSocketServer->SetEventHandler(*this);
    930         m_pSocketServer->SetFlags(wxSOCKET_NOWAIT);
    931         m_pSocketServer->SetNotify(wxSOCKET_CONNECTION_FLAG | wxSOCKET_LOST_FLAG);
    932         m_pSocketServer->Notify(true);
    933 
    934 
    935912        if (port)
    936913                return port;
    937914
    938915        // Get port number from socket
    939         if (!m_pSocketServer->GetLocal(addr))
    940         {
     916        int error;
     917        res = m_pSocketServer->GetLocalPort(error);
     918        if (res <= 0) {
    941919                delete m_pSocketServer;
    942920                m_pSocketServer = 0;
    943921                return 0;
    944922        }
    945         return addr.Service();
     923        return static_cast<unsigned int>(port);
    946924}
    947925
    948926void CNetConfWizard::OnAccept()
    949927{
     928        if (!m_socket || !m_pSocketServer) {
     929                return;
     930        }
    950931        if (m_pDataSocket)
    951932                return;
    952         m_pDataSocket = m_pSocketServer->Accept(false);
     933
     934        int error;
     935        m_pDataSocket = m_pSocketServer->Accept(error);
    953936        if (!m_pDataSocket)
    954937                return;
    955938
    956         wxIPV4address peerAddr, dataPeerAddr;
    957         if (!m_socket->GetPeer(peerAddr)) {
     939        wxString peerAddr = m_socket->GetPeerHost();
     940        wxString dataPeerAddr = m_pDataSocket->GetPeerHost();
     941        if (peerAddr.empty()) {
    958942                delete m_pDataSocket;
    959943                m_pDataSocket = 0;
     
    962946                return;
    963947        }
    964         if (!m_pDataSocket->GetPeer(dataPeerAddr)) {
     948        if (dataPeerAddr.empty()) {
    965949                delete m_pDataSocket;
    966950                m_pDataSocket = 0;
     
    969953                return;
    970954        }
    971         if (peerAddr.IPAddress() != dataPeerAddr.IPAddress()) {
     955        if (peerAddr != dataPeerAddr) {
    972956                delete m_pDataSocket;
    973957                m_pDataSocket = 0;
     
    977961        delete m_pSocketServer;
    978962        m_pSocketServer = 0;
    979 
    980         m_pDataSocket->SetEventHandler(*this);
    981         m_pDataSocket->SetFlags(wxSOCKET_NOWAIT);
    982         m_pDataSocket->SetNotify(wxSOCKET_INPUT_FLAG | wxSOCKET_LOST_FLAG);
    983         m_pDataSocket->Notify(true);
    984963}
    985964
     
    987966{
    988967        char buffer[100];
    989         m_pDataSocket->Read(buffer, 99);
    990         unsigned int len;
    991         if (m_pDataSocket->Error() || !(len = m_pDataSocket->LastCount()))
    992         {
     968        int error;
     969        int const read = m_pDataSocket->Read(buffer, 99, error);
     970        if (!read) {
    993971                PrintMessage(_("Data socket closed too early."), 1);
    994972                CloseSocket();
    995973                return;
    996974        }
    997         buffer[len] = 0;
     975        if (read < 0) {
     976                if (error != EAGAIN) {
     977                        PrintMessage(_("Could not read from data socket."), 1);
     978                        CloseSocket();
     979                }
     980                return;
     981        }
     982        buffer[read] = 0;
    998983
    999984        int data = 0;
    1000985        const char* p = buffer;
    1001         while (*p && *p != ' ')
    1002         {
    1003                 if (*p < '0' || *p > '9')
    1004                 {
     986        while (*p && *p != ' ') {
     987                if (*p < '0' || *p > '9') {
    1005988                        m_testResult = datatainted;
    1006989                        PrintMessage(_("Received data tainted"), 1);
     
    1010993                data = data * 10 + *p++ - '0';
    1011994        }
    1012         if (data != m_data)
    1013         {
     995        if (data != m_data) {
    1014996                m_testResult = datatainted;
    1015997                PrintMessage(_("Received data tainted"), 1);
     
    10181000        }
    10191001        p++;
    1020         if (p - buffer != (int)len - 4)
    1021         {
     1002        if (p - buffer != read - 4) {
    10221003                PrintMessage(_("Failed to receive data"), 1);
    10231004                CloseSocket();
     
    10261007
    10271008        wxUint32 ip = 0;
    1028         for (const wxChar* q = m_externalIP.c_str(); *q; q++)
    1029         {
     1009        for (const wxChar* q = m_externalIP.c_str(); *q; ++q) {
    10301010                if (*q == '.')
    10311011                        ip *= 256;
     
    10531033{
    10541034        OnDataReceive();
    1055         if (m_pDataSocket)
    1056         {
     1035        if (m_pDataSocket) {
    10571036                PrintMessage(_("Data socket closed too early."), 0);
    10581037                CloseSocket();
     
    10621041        m_pDataSocket = 0;
    10631042
    1064         if (gotListReply)
    1065         {
     1043        if (gotListReply) {
    10661044                m_state++;
    10671045                SendNextCommand();
     
    10781056}
    10791057
    1080 void CNetConfWizard::operator()(CEventBase const& ev)
    1081 {
    1082         if (Dispatch<CExternalIPResolveEvent>(ev, this, &CNetConfWizard::OnExternalIPAddress))
    1083                 return;
     1058void CNetConfWizard::operator()(fz::event_base const& ev)
     1059{
     1060        fz::dispatch<CSocketEvent, CExternalIPResolveEvent>(ev, this
     1061                , &CNetConfWizard::OnSocketEvent
     1062                , &CNetConfWizard::OnExternalIPAddress);
    10841063}
    10851064
     
    10881067        QueueEvent(new wxCommandEvent(fzEVT_ON_EXTERNAL_IP_ADDRESS));
    10891068}
     1069
     1070void CNetConfWizard::OnSocketEvent(CSocketEventSource* s, SocketEventType t, int error)
     1071{
     1072        if (!s) {
     1073                return;
     1074        }
     1075
     1076        CallAfter([=]{DoOnSocketEvent(s, t, error);});
     1077}
Note: See TracChangeset for help on using the changeset viewer.