Network.cpp

Go to the documentation of this file.

/*
        This file is part of cpp-ethereum.

        cpp-ethereum is free software: you can redistribute it and/or modify
        it under the terms of the GNU General Public License as published by
        the Free Software Foundation, either version 3 of the License, or
        (at your option) any later version.

        cpp-ethereum is distributed in the hope that it will be useful,
        but WITHOUT ANY WARRANTY; without even the implied warranty of
        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
        GNU General Public License for more details.

        You should have received a copy of the GNU General Public License
        along with cpp-ethereum.  If not, see <http://www.gnu.org/licenses/>.
*/
#include <sys/types.h>
#ifndef _WIN32
#include <ifaddrs.h>
#endif

#include <boost/algorithm/string.hpp>
#include <boost/algorithm/string/split.hpp>

#include <libdevcore/Common.h>
#include <libdevcore/Assertions.h>
#include <libdevcore/CommonIO.h>
#include <libdevcore/Exceptions.h>
#include "Common.h"
#include "UPnP.h"
#include "Network.h"

using namespace std;
using namespace dev;
using namespace dev::p2p;

static_assert(BOOST_VERSION == 106300, "Wrong boost headers version");

std::set<bi::address> Network::getInterfaceAddresses()
{
        std::set<bi::address> addresses;

#if defined(_WIN32)
        WSAData wsaData;
        if (WSAStartup(MAKEWORD(1, 1), &wsaData) != 0)
                BOOST_THROW_EXCEPTION(NoNetworking());

        char ac[80];
        if (gethostname(ac, sizeof(ac)) == SOCKET_ERROR)
        {
                clog(NetWarn) << "Error " << WSAGetLastError() << " when getting local host name.";
                WSACleanup();
                BOOST_THROW_EXCEPTION(NoNetworking());
        }

        struct hostent* phe = gethostbyname(ac);
        if (phe == 0)
        {
                clog(NetWarn) << "Bad host lookup.";
                WSACleanup();
                BOOST_THROW_EXCEPTION(NoNetworking());
        }

        for (int i = 0; phe->h_addr_list[i] != 0; ++i)
        {
                struct in_addr addr;
                memcpy(&addr, phe->h_addr_list[i], sizeof(struct in_addr));
                char *addrStr = inet_ntoa(addr);
                bi::address address(bi::address::from_string(addrStr));
                if (!isLocalHostAddress(address))
                        addresses.insert(address.to_v4());
        }

        WSACleanup();
#else
        ifaddrs* ifaddr;
        if (getifaddrs(&ifaddr) == -1)
                BOOST_THROW_EXCEPTION(NoNetworking());

        for (auto ifa = ifaddr; ifa != NULL; ifa = ifa->ifa_next)
        {
                if (!ifa->ifa_addr || string(ifa->ifa_name) == "lo0" || !(ifa->ifa_flags & IFF_UP))
                        continue;

                if (ifa->ifa_addr->sa_family == AF_INET)
                {
                        in_addr addr = ((struct sockaddr_in *)ifa->ifa_addr)->sin_addr;
                        boost::asio::ip::address_v4 address(boost::asio::detail::socket_ops::network_to_host_long(addr.s_addr));
                        if (!isLocalHostAddress(address))
                                addresses.insert(address);
                }
                else if (ifa->ifa_addr->sa_family == AF_INET6)
                {
                        sockaddr_in6* sockaddr = ((struct sockaddr_in6 *)ifa->ifa_addr);
                        in6_addr addr = sockaddr->sin6_addr;
                        boost::asio::ip::address_v6::bytes_type bytes;
                        memcpy(&bytes[0], addr.s6_addr, 16);
                        boost::asio::ip::address_v6 address(bytes, sockaddr->sin6_scope_id);
                        if (!isLocalHostAddress(address))
                                addresses.insert(address);
                }
        }

        if (ifaddr!=NULL)
                freeifaddrs(ifaddr);

#endif

        return addresses;
}

int Network::tcp4Listen(bi::tcp::acceptor& _acceptor, NetworkPreferences const& _netPrefs)
{
        // Due to the complexities of NAT and network environments (multiple NICs, tunnels, etc)
        // and security concerns automation is the enemy of network configuration.
        // If a preference cannot be accommodate the network must fail to start.
        //
        // Preferred IP: Attempt if set, else, try 0.0.0.0 (all interfaces)
        // Preferred Port: Attempt if set, else, try c_defaultListenPort or 0 (random)
        // TODO: throw instead of returning -1 and rename NetworkPreferences to NetworkConfig
        
        bi::address listenIP;
        try
        {
                listenIP = _netPrefs.listenIPAddress.empty() ? bi::address_v4() : bi::address::from_string(_netPrefs.listenIPAddress);
        }
        catch (...)
        {
                cwarn << "Couldn't start accepting connections on host. Failed to accept socket on " << listenIP << ":" << _netPrefs.listenPort << ".\n" << boost::current_exception_diagnostic_information();
                return -1;
        }
        bool requirePort = (bool)_netPrefs.listenPort;

        for (unsigned i = 0; i < 2; ++i)
        {
                bi::tcp::endpoint endpoint(listenIP, requirePort ? _netPrefs.listenPort : (i ? 0 : c_defaultListenPort));
                try
                {
#if defined(_WIN32)
                        bool reuse = false;
#else
                        bool reuse = true;
#endif
                        _acceptor.open(endpoint.protocol());
                        _acceptor.set_option(ba::socket_base::reuse_address(reuse));
                        _acceptor.bind(endpoint);
                        _acceptor.listen();
                        return _acceptor.local_endpoint().port();
                }
                catch (...)
                {
                        // bail if this is first attempt && port was specificed, or second attempt failed (random port)
                        if (i || requirePort)
                        {
                                // both attempts failed
                                cwarn << "Couldn't start accepting connections on host. Failed to accept socket on " << listenIP << ":" << _netPrefs.listenPort << ".\n" << boost::current_exception_diagnostic_information();
                                _acceptor.close();
                                return -1;
                        }
                        
                        _acceptor.close();
                        continue;
                }
        }

        return -1;
}

bi::tcp::endpoint Network::traverseNAT(std::set<bi::address> const& _ifAddresses, unsigned short _listenPort, bi::address& o_upnpInterfaceAddr)
{
        asserts(_listenPort != 0);

        unique_ptr<UPnP> upnp;
        try
        {
                upnp.reset(new UPnP);
        }
        // let m_upnp continue as null - we handle it properly.
        catch (...) {}

        bi::tcp::endpoint upnpEP;
        if (upnp && upnp->isValid())
        {
                bi::address pAddr;
                int extPort = 0;
                for (auto const& addr: _ifAddresses)
                        if (addr.is_v4() && isPrivateAddress(addr) && (extPort = upnp->addRedirect(addr.to_string().c_str(), _listenPort)))
                        {
                                pAddr = addr;
                                break;
                        }

                auto eIP = upnp->externalIP();
                bi::address eIPAddr(bi::address::from_string(eIP));
                if (extPort && eIP != string("0.0.0.0") && !isPrivateAddress(eIPAddr))
                {
                        clog(NetNote) << "Punched through NAT and mapped local port" << _listenPort << "onto external port" << extPort << ".";
                        clog(NetNote) << "External addr:" << eIP;
                        o_upnpInterfaceAddr = pAddr;
                        upnpEP = bi::tcp::endpoint(eIPAddr, (unsigned short)extPort);
                }
                else
                        clog(NetWarn) << "Couldn't punch through NAT (or no NAT in place).";
        }

        return upnpEP;
}

bi::tcp::endpoint Network::resolveHost(string const& _addr)
{
        static boost::asio::io_service s_resolverIoService;

        vector<string> split;
        boost::split(split, _addr, boost::is_any_of(":"));
        unsigned port = dev::p2p::c_defaultIPPort;

        try
        {
                if (split.size() > 1)
                        port = static_cast<unsigned>(stoi(split.at(1)));
        }
        catch(...) {}

        boost::system::error_code ec;
        bi::address address = bi::address::from_string(split[0], ec);
        bi::tcp::endpoint ep(bi::address(), port);
        if (!ec)
                ep.address(address);
        else
        {
                boost::system::error_code ec;
                // resolve returns an iterator (host can resolve to multiple addresses)
                bi::tcp::resolver r(s_resolverIoService);
                auto it = r.resolve({bi::tcp::v4(), split[0], toString(port)}, ec);
                if (ec)
                {
                        clog(NetWarn) << "Error resolving host address..." << LogTag::Url << _addr << ":" << LogTag::Error << ec.message();
                        return bi::tcp::endpoint();
                }
                else
                        ep = *it;
        }
        return ep;
}