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/proxy.cpp

    r130 r3185  
     1#include <wx/defs.h>
     2#include <libfilezilla/libfilezilla.hpp>
     3#ifdef FZ_WINDOWS
     4  #include <libfilezilla/private/windows.hpp>
     5  #include <winsock2.h>
     6  #include <ws2tcpip.h>
     7#else
     8  #include <sys/socket.h>
     9#endif
    110#include <filezilla.h>
    211#include "engineprivate.h"
    312#include "proxy.h"
    413#include "ControlSocket.h"
    5 #include <wx/sckaddr.h>
     14
     15#include <libfilezilla/iputils.hpp>
     16
     17#ifndef FZ_WINDOWS
     18#include <netdb.h>
     19#endif
    620
    721enum handshake_state
     
    1832};
    1933
    20 CProxySocket::CProxySocket(CEventHandler* pEvtHandler, CSocket* pSocket, CControlSocket* pOwner)
    21         : CEventHandler(pOwner->event_loop_)
     34CProxySocket::CProxySocket(fz::event_handler* pEvtHandler, CSocket* pSocket, CControlSocket* pOwner)
     35        : fz::event_handler(pOwner->event_loop_)
    2236        , CBackend(pEvtHandler)
    2337        , m_pSocket(pSocket)
     
    2943CProxySocket::~CProxySocket()
    3044{
    31         RemoveHandler();
     45        remove_handler();
    3246
    3347        if (m_pSocket)
     
    138152        else if (type == SOCKS4) {
    139153                wxString ip = m_host;
    140                 if (!GetIPV6LongForm(m_host).empty()) {
     154                if (!fz::get_ipv6_long_form(m_host.ToStdWstring()).empty()) {
    141155                        m_pOwner->LogMessage(MessageType::Error, _("IPv6 addresses are not supported with SOCKS4 proxy"));
    142156                        return EINVAL;
    143157                }
    144158
    145                 if (!IsIpAddress(m_host)) {
    146                         wxIPV4address address;
    147                         if (!address.Hostname(host)) {
     159                if (fz::get_address_type(m_host.ToStdWstring()) == fz::address_type::unknown) {
     160                        addrinfo hints{};
     161                        hints.ai_family = AF_INET;
     162                        hints.ai_socktype = SOCK_STREAM;
     163
     164                        addrinfo * result{};
     165                        int res = getaddrinfo(host.ToStdString().c_str(), 0, &hints, &result);
     166                        if (!res && result) {
     167                                if (result->ai_family == AF_INET) {
     168                                        ip = CSocket::AddressToString(result->ai_addr, result->ai_addrlen, false);
     169                                }
     170                                freeaddrinfo(result);
     171                        }
     172
     173                        if (ip.empty()) {
    148174                                m_pOwner->LogMessage(MessageType::Error, _("Cannot resolve hostname to IPv4 address for use with SOCKS4 proxy."));
    149175                                return EINVAL;
    150176                        }
    151                         ip = address.IPAddress();
    152177                }
    153178
     
    203228}
    204229
    205 void CProxySocket::operator()(CEventBase const& ev)
    206 {
    207         Dispatch<CSocketEvent, CHostAddressEvent>(ev, this,
     230void CProxySocket::operator()(fz::event_base const& ev)
     231{
     232        fz::dispatch<CSocketEvent, CHostAddressEvent>(ev, this,
    208233                &CProxySocket::OnSocketEvent,
    209234                &CProxySocket::OnHostAddress);
     
    221246                        if (m_proxyState == handshake)
    222247                                m_proxyState = noconn;
    223                         m_pEvtHandler->SendEvent<CSocketEvent>(this, SocketEventType::connection, error);
     248                        m_pEvtHandler->send_event<CSocketEvent>(this, SocketEventType::connection, error);
    224249                }
    225250                else {
     
    276301                                        if (error != EAGAIN) {
    277302                                                m_proxyState = noconn;
    278                                                 m_pEvtHandler->SendEvent<CSocketEvent>(this, SocketEventType::close, error);
     303                                                m_pEvtHandler->send_event<CSocketEvent>(this, SocketEventType::close, error);
    279304                                        }
    280305                                        else
     
    284309                                if (!read) {
    285310                                        m_proxyState = noconn;
    286                                         m_pEvtHandler->SendEvent<CSocketEvent>(this, SocketEventType::close, ECONNABORTED);
     311                                        m_pEvtHandler->send_event<CSocketEvent>(this, SocketEventType::close, ECONNABORTED);
    287312                                        return;
    288313                                }
     
    290315                                        m_proxyState = noconn;
    291316                                        m_pOwner->LogMessage(MessageType::Debug_Warning, _T("Incoming data before request fully sent"));
    292                                         m_pEvtHandler->SendEvent<CSocketEvent>(this, SocketEventType::close, ECONNABORTED);
     317                                        m_pEvtHandler->send_event<CSocketEvent>(this, SocketEventType::close, ECONNABORTED);
    293318                                        return;
    294319                                }
     
    302327                                                        m_proxyState = noconn;
    303328                                                        m_pOwner->LogMessage(MessageType::Debug_Warning, _T("Incoming header too large"));
    304                                                         m_pEvtHandler->SendEvent<CSocketEvent>(this, SocketEventType::close, ENOMEM);
     329                                                        m_pEvtHandler->send_event<CSocketEvent>(this, SocketEventType::close, ENOMEM);
    305330                                                        return;
    306331                                                }
     
    314339                                                m_proxyState = noconn;
    315340                                                m_pOwner->LogMessage(MessageType::Debug_Warning, _T("Could not read what got peeked"));
    316                                                 m_pEvtHandler->SendEvent<CSocketEvent>(this, SocketEventType::close, ECONNABORTED);
     341                                                m_pEvtHandler->send_event<CSocketEvent>(this, SocketEventType::close, ECONNABORTED);
    317342                                                return;
    318343                                        }
     
    331356                        if (reply.Left(10) != _T("HTTP/1.1 2") && reply.Left(10) != _T("HTTP/1.0 2")) {
    332357                                m_proxyState = noconn;
    333                                 m_pEvtHandler->SendEvent<CSocketEvent>(this, SocketEventType::close, ECONNRESET);
     358                                m_pEvtHandler->send_event<CSocketEvent>(this, SocketEventType::close, ECONNRESET);
    334359                                return;
    335360                        }
    336361
    337362                        m_proxyState = conn;
    338                         m_pEvtHandler->SendEvent<CSocketEvent>(this, SocketEventType::connection, 0);
     363                        m_pEvtHandler->send_event<CSocketEvent>(this, SocketEventType::connection, 0);
    339364                        return;
    340365                }
     
    346371                                if (read_error != EAGAIN) {
    347372                                        m_proxyState = noconn;
    348                                         m_pEvtHandler->SendEvent<CSocketEvent>(this, SocketEventType::close, read_error);
     373                                        m_pEvtHandler->send_event<CSocketEvent>(this, SocketEventType::close, read_error);
    349374                                }
    350375                                else
     
    355380                        if (!read) {
    356381                                m_proxyState = noconn;
    357                                 m_pEvtHandler->SendEvent<CSocketEvent>(this, SocketEventType::close, ECONNABORTED);
     382                                m_pEvtHandler->send_event<CSocketEvent>(this, SocketEventType::close, ECONNABORTED);
    358383                                return;
    359384                        }
     
    384409                                m_pOwner->LogMessage(MessageType::Error, _("Proxy request failed: %s"), error);
    385410                                m_proxyState = noconn;
    386                                 m_pEvtHandler->SendEvent<CSocketEvent>(this, SocketEventType::close, ECONNABORTED);
     411                                m_pEvtHandler->send_event<CSocketEvent>(this, SocketEventType::close, ECONNABORTED);
    387412                                return;
    388413                        }
    389414                        m_proxyState = conn;
    390                         m_pEvtHandler->SendEvent<CSocketEvent>(this, SocketEventType::connection, 0);
     415                        m_pEvtHandler->send_event<CSocketEvent>(this, SocketEventType::connection, 0);
    391416                }
    392417                return;
     
    404429                                if (error != EAGAIN) {
    405430                                        m_proxyState = noconn;
    406                                         m_pEvtHandler->SendEvent<CSocketEvent>(this, SocketEventType::close, error);
     431                                        m_pEvtHandler->send_event<CSocketEvent>(this, SocketEventType::close, error);
    407432                                }
    408433                                else
     
    412437                        if (!read) {
    413438                                m_proxyState = noconn;
    414                                 m_pEvtHandler->SendEvent<CSocketEvent>(this, SocketEventType::close, ECONNABORTED);
     439                                m_pEvtHandler->send_event<CSocketEvent>(this, SocketEventType::close, ECONNABORTED);
    415440                                return;
    416441                        }
     
    427452                        default:
    428453                                if (m_pRecvBuffer[0] != 5) {
    429                                         m_pOwner->LogMessage(MessageType::Debug_Warning, _("Unknown SOCKS protocol version: %d"), (int)m_pRecvBuffer[0]);
    430                                         m_proxyState = noconn;
    431                                         m_pEvtHandler->SendEvent<CSocketEvent>(this, SocketEventType::close, ECONNABORTED);
     454                                        m_pOwner->LogMessage(MessageType::Error, _("Unknown SOCKS protocol version: %d"), (int)m_pRecvBuffer[0]);
     455                                        m_proxyState = noconn;
     456                                        m_pEvtHandler->send_event<CSocketEvent>(this, SocketEventType::close, ECONNABORTED);
    432457                                        return;
    433458                                }
     
    435460                        case socks5_auth:
    436461                                if (m_pRecvBuffer[0] != 1) {
    437                                         m_pOwner->LogMessage(MessageType::Debug_Warning, _("Unknown protocol version of SOCKS Username/Password Authentication subnegotiation: %d"), (int)m_pRecvBuffer[0]);
    438                                         m_proxyState = noconn;
    439                                         m_pEvtHandler->SendEvent<CSocketEvent>(this, SocketEventType::close, ECONNABORTED);
     462                                        m_pOwner->LogMessage(MessageType::Error, _("Unknown protocol version of SOCKS Username/Password Authentication subnegotiation: %d"), (int)m_pRecvBuffer[0]);
     463                                        m_proxyState = noconn;
     464                                        m_pEvtHandler->send_event<CSocketEvent>(this, SocketEventType::close, ECONNABORTED);
    440465                                        return;
    441466                                }
     
    459484                                                break;
    460485                                        default:
    461                                                 m_pOwner->LogMessage(MessageType::Debug_Warning, _("No supported SOCKS5 auth method"));
     486                                                m_pOwner->LogMessage(MessageType::Error, _("No supported SOCKS5 auth method"));
    462487                                                m_proxyState = noconn;
    463                                                 m_pEvtHandler->SendEvent<CSocketEvent>(this, SocketEventType::close, ECONNABORTED);
     488                                                m_pEvtHandler->send_event<CSocketEvent>(this, SocketEventType::close, ECONNABORTED);
    464489                                                return;
    465490                                        }
     
    469494                                if (m_pRecvBuffer[1] != 0)
    470495                                {
    471                                         m_pOwner->LogMessage(MessageType::Debug_Warning, _("Proxy authentication failed"));
    472                                         m_proxyState = noconn;
    473                                         m_pEvtHandler->SendEvent<CSocketEvent>(this, SocketEventType::close, ECONNABORTED);
     496                                        m_pOwner->LogMessage(MessageType::Error, _("Proxy authentication failed"));
     497                                        m_proxyState = noconn;
     498                                        m_pEvtHandler->send_event<CSocketEvent>(this, SocketEventType::close, ECONNABORTED);
    474499                                        return;
    475500                                }
     
    510535                                        }
    511536
    512                                         m_pOwner->LogMessage(MessageType::Debug_Warning, _("Proxy request failed: %s"), errorMsg);
    513                                         m_proxyState = noconn;
    514                                         m_pEvtHandler->SendEvent<CSocketEvent>(this, SocketEventType::close, ECONNABORTED);
     537                                        m_pOwner->LogMessage(MessageType::Error, _("Proxy request failed. Reply from proxy: %s"), errorMsg);
     538                                        m_proxyState = noconn;
     539                                        m_pEvtHandler->send_event<CSocketEvent>(this, SocketEventType::close, ECONNABORTED);
    515540                                        return;
    516541                                }
     
    534559                                        break;
    535560                                default:
    536                                         m_pOwner->LogMessage(MessageType::Debug_Warning, _("Proxy request failed: Unknown address type in CONNECT reply"));
    537                                         m_proxyState = noconn;
    538                                         m_pEvtHandler->SendEvent<CSocketEvent>(this, SocketEventType::close, ECONNABORTED);
     561                                        m_pOwner->LogMessage(MessageType::Error, _("Proxy request failed: Unknown address type in CONNECT reply"));
     562                                        m_proxyState = noconn;
     563                                        m_pEvtHandler->send_event<CSocketEvent>(this, SocketEventType::close, ECONNABORTED);
    539564                                        return;
    540565                                }
     
    545570                                        // We're done
    546571                                        m_proxyState = conn;
    547                                         m_pEvtHandler->SendEvent<CSocketEvent>(this, SocketEventType::connection, 0);
     572                                        m_pEvtHandler->send_event<CSocketEvent>(this, SocketEventType::connection, 0);
    548573                                        return;
    549574                                }
     
    583608                                        m_pSendBuffer[2] = 0; // Reserved
    584609
    585                                         if (IsIpAddress(m_host)) {
    586                                                 // Quite ugly
    587                                                 wxString ipv6 = GetIPV6LongForm(m_host);
    588                                                 if (!ipv6.empty()) {
    589                                                         ipv6.Replace(_T(":"), _T(""));
    590                                                         addrlen = 16;
    591                                                         for (int i = 0; i < 16; i++)
    592                                                                 m_pSendBuffer[4 + i] = (DigitHexToDecNum(ipv6[i * 2]) << 4) + DigitHexToDecNum(ipv6[i * 2 + 1]);
    593 
    594                                                         m_pSendBuffer[3] = 4; // IPv6
     610                                        auto type = fz::get_address_type(m_host.ToStdWstring());
     611                                        if (type == fz::address_type::ipv6) {
     612                                                auto ipv6 = fz::get_ipv6_long_form(m_host.ToStdWstring());
     613                                                addrlen = 16;
     614                                                for (int i = 0; i < 16; ++i) {
     615                                                        m_pSendBuffer[4 + i] = (fz::hex_char_to_int(ipv6[i * 2 + i / 2]) << 4) + fz::hex_char_to_int(ipv6[i * 2 + 1 + i / 2]);
    595616                                                }
    596                                                 else {
    597                                                         unsigned char *buf = (unsigned char*)m_pSendBuffer + 4;
    598                                                         int i = 0;
    599                                                         memset(buf, 0, 4);
    600                                                         for (const wxChar* p = m_host.c_str(); *p && i < 4; p++)
     617
     618                                                m_pSendBuffer[3] = 4; // IPv6
     619                                        }
     620                                        else if (type == fz::address_type::ipv4) {
     621                                                unsigned char *buf = (unsigned char*)m_pSendBuffer + 4;
     622                                                int i = 0;
     623                                                memset(buf, 0, 4);
     624                                                for (const wxChar* p = m_host.c_str(); *p && i < 4; ++p) {
     625                                                        const wxChar& c = *p;
     626                                                        if (c == '.')
    601627                                                        {
    602                                                                 const wxChar& c = *p;
    603                                                                 if (c == '.')
    604                                                                 {
    605                                                                         i++;
    606                                                                         continue;
    607                                                                 }
    608                                                                 buf[i] *= 10;
    609                                                                 buf[i] += c - '0';
     628                                                                i++;
     629                                                                continue;
    610630                                                        }
    611 
    612                                                         addrlen = 4;
    613 
    614                                                         m_pSendBuffer[3] = 1; // IPv4
     631                                                        buf[i] *= 10;
     632                                                        buf[i] += c - '0';
    615633                                                }
     634
     635                                                addrlen = 4;
     636
     637                                                m_pSendBuffer[3] = 1; // IPv4
    616638                                        }
    617639                                        else {
     
    645667                m_proxyState = noconn;
    646668                m_pOwner->LogMessage(MessageType::Debug_Warning, _T("Unhandled handshake state %d"), m_handshakeState);
    647                 m_pEvtHandler->SendEvent<CSocketEvent>(this, SocketEventType::close, ECONNABORTED);
     669                m_pEvtHandler->send_event<CSocketEvent>(this, SocketEventType::close, ECONNABORTED);
    648670                return;
    649671        }
     
    662684                        if (error != EAGAIN) {
    663685                                m_proxyState = noconn;
    664                                 m_pEvtHandler->SendEvent<CSocketEvent>(this, SocketEventType::close, error);
     686                                m_pEvtHandler->send_event<CSocketEvent>(this, SocketEventType::close, error);
    665687                        }
    666688                        else
Note: See TracChangeset for help on using the changeset viewer.