501        default: {
502            LogError("Error: malformed proxy response\n");
503            return false;
504        }
505        }
506        if (recvr != IntrRecvError::OK) {
507            LogError("Error reading from proxy\n");
508            return false;
509        }
510        if (InterruptibleRecv(pchRet3, 2, g_socks5_recv_timeout, sock) != IntrRecvError::OK) {
511            LogError("Error reading from proxy\n");
512            return false;
513        }
514        LogDebug(BCLog::NET, "SOCKS5 connected %s\n", strDest);
515        return true;
516    } catch (const std::runtime_error& e) {
517        LogError("Error during SOCKS5 proxy handshake: %s\n", e.what());
518        return false;
519    }
520}
521
522std::unique_ptr<Sock> CreateSockOS(int domain, int type, int protocol)
523{
524    // Not IPv4, IPv6 or UNIX
525    if (domain == AF_UNSPEC) return nullptr;
526
527    // Create a socket in the specified address family.
528    SOCKET hSocket = socket(domain, type, protocol);
529    if (hSocket == INVALID_SOCKET) {
530        return nullptr;
531    }
532
533    auto sock = std::make_unique<Sock>(hSocket);
534
535    if (domain != AF_INET && domain != AF_INET6 && domain != AF_UNIX) {
536        return sock;
537    }
538
539    // Ensure that waiting for I/O on this socket won't result in undefined
540    // behavior.
541    if (!sock->IsSelectable()) {
542        LogInfo("Cannot create connection: non-selectable socket created (fd >= FD_SETSIZE ?)\n");
543        return nullptr;
544    }
545
546#ifdef SO_NOSIGPIPE
547    int set = 1;
548    // Set the no-sigpipe option on the socket for BSD systems, other UNIXes
549    // should use the MSG_NOSIGNAL flag for every send.
550    if (sock->SetSockOpt(SOL_SOCKET, SO_NOSIGPIPE, &set, sizeof(int)) == SOCKET_ERROR) {
551        LogInfo("Error setting SO_NOSIGPIPE on socket: %s, continuing anyway\n",
552                  NetworkErrorString(WSAGetLastError()));
553    }
554#endif
555
556    // Set the non-blocking option on the socket.
557    if (!sock->SetNonBlocking()) {
558        LogInfo("Error setting socket to non-blocking: %s\n", NetworkErrorString(WSAGetLastError()));
559        return nullptr;
560    }
561
562#ifdef HAVE_SOCKADDR_UN
563    if (domain == AF_UNIX) return sock;
564#endif
565
566    if (protocol == IPPROTO_TCP) {
567        // Set the no-delay option (disable Nagle's algorithm) on the TCP socket.
568        const int on{1};
569        if (sock->SetSockOpt(IPPROTO_TCP, TCP_NODELAY, &on, sizeof(on)) == SOCKET_ERROR) {
570            LogDebug(BCLog::NET, "Unable to set TCP_NODELAY on a newly created socket, continuing anyway\n");
571        }
572    }
573
574    return sock;
575}
576
577std::function<std::unique_ptr<Sock>(int, int, int)> CreateSock = CreateSockOS;
578
579template<typename... Args>
580static void LogConnectFailure(bool manual_connection, util::ConstevalFormatString<sizeof...(Args)> fmt, const Args&... args)
581{
582    std::string error_message = tfm::format(fmt, args...);
583    if (manual_connection) {
584        LogInfo("%s\n", error_message);
585    } else {
586        LogDebug(BCLog::NET, "%s\n", error_message);
587    }
588}
589
590static bool ConnectToSocket(const Sock& sock,
591                            struct sockaddr* sockaddr,
592                            socklen_t len,
593                            const std::string& dest_str,
594                            bool manual_connection,
595                            std::chrono::milliseconds timeout)
596{
597    // Connect to `sockaddr` using `sock`.
598    if (sock.Connect(sockaddr, len) == SOCKET_ERROR) {
599        int nErr = WSAGetLastError();
600        // WSAEINVAL is here because some legacy version of winsock uses it
601        if (nErr == WSAEINPROGRESS || nErr == WSAEWOULDBLOCK || nErr == WSAEINVAL)
602        {
603            // Connection didn't actually fail, but is being established
604            // asynchronously. Thus, use async I/O api (select/poll)
605            // synchronously to check for successful connection with a timeout.
606            const Sock::Event requested = Sock::RecvEvent | Sock::SendEvent;
607            Sock::Event occurred;
608            if (!sock.Wait(timeout, requested, &occurred)) {
609                LogInfo("wait for connect to %s failed: %s\n",
610                          dest_str,
611                          NetworkErrorString(WSAGetLastError()));
612                return false;
613            } else if (occurred == 0) {
614                LogDebug(BCLog::NET, "connection attempt to %s timed out\n", dest_str);
615                return false;
616            }
617
618            // Even if the wait was successful, the connect might not
619            // have been successful. The reason for this failure is hidden away
620            // in the SO_ERROR for the socket in modern systems. We read it into
621            // sockerr here.
622            int sockerr;
623            socklen_t sockerr_len = sizeof(sockerr);
624            if (sock.GetSockOpt(SOL_SOCKET, SO_ERROR, &sockerr, &sockerr_len) ==
625                SOCKET_ERROR) {
626                LogInfo("getsockopt() for %s failed: %s\n", dest_str, NetworkErrorString(WSAGetLastError()));
627                return false;
628            }
629            if (sockerr != 0) {
630                LogConnectFailure(manual_connection,
631                                  "connect() to %s failed after wait: %s",
632                                  dest_str,
633                                  NetworkErrorString(sockerr));
634                return false;
635            }
636        }
637#ifdef WIN32
638        else if (WSAGetLastError() != WSAEISCONN)
639#else
640        else
641#endif
642        {
643            LogConnectFailure(manual_connection, "connect() to %s failed: %s", dest_str, NetworkErrorString(WSAGetLastError()));
644            return false;
645        }
646    }
647    return true;
648}
649
650std::unique_ptr<Sock> ConnectDirectly(const CService& dest, bool manual_connection)
651{
652    return ConnectDirectly(dest, manual_connection, std::chrono::milliseconds{nConnectTimeout});
653}
654
655std::unique_ptr<Sock> ConnectDirectly(const CService& dest,
656                                      bool manual_connection,
657                                      std::chrono::milliseconds timeout)
658{
659    auto sock = CreateSock(dest.GetSAFamily(), SOCK_STREAM, IPPROTO_TCP);
660    if (!sock) {
661        LogError("Cannot create a socket for connecting to %s\n", dest.ToStringAddrPort());
662        return {};
663    }
664
665    // Create a sockaddr from the specified service.
666    struct sockaddr_storage sockaddr;
667    socklen_t len = sizeof(sockaddr);
668    if (!dest.GetSockAddr((struct sockaddr*)&sockaddr, &len)) {
669        LogInfo("Cannot get sockaddr for %s: unsupported network\n", dest.ToStringAddrPort());
670        return {};
671    }
672
673    if (!ConnectToSocket(*sock, (struct sockaddr*)&sockaddr, len, dest.ToStringAddrPort(), manual_connection, timeout)) {
674        return {};
675    }
676
677    return sock;
678}
679
680std::unique_ptr<Sock> Proxy::Connect() const
681{
682    if (!IsValid()) return {};
683
684    if (!m_is_unix_socket) return ConnectDirectly(proxy, /*manual_connection=*/true);
685
686#ifdef HAVE_SOCKADDR_UN
687    auto sock = CreateSock(AF_UNIX, SOCK_STREAM, 0);
688    if (!sock) {
689        LogError("Cannot create a socket for connecting to %s\n", m_unix_socket_path);
690        return {};
691    }
692
693    const std::string path{m_unix_socket_path.substr(ADDR_PREFIX_UNIX.length())};
694
695    struct sockaddr_un addrun;
696    memset(&addrun, 0, sizeof(addrun));
697    addrun.sun_family = AF_UNIX;
698    // leave the last char in addrun.sun_path[] to be always '\0'
699    memcpy(addrun.sun_path, path.c_str(), std::min(sizeof(addrun.sun_path) - 1, path.length()));
700    socklen_t len = sizeof(addrun);
701
702    if (!ConnectToSocket(*sock,
703                         (struct sockaddr*)&addrun,
704                         len,
705                         path,
706                         /*manual_connection=*/true,
707                         std::chrono::milliseconds{nConnectTimeout})) {
708        return {};
709    }
710
711    return sock;
712#else
713    return {};
714#endif
715}
716
717bool SetProxy(enum Network net, const Proxy &addrProxy) {
718    assert(net >= 0 && net < NET_MAX);
719    if (!addrProxy.IsValid())
720        return false;
721    LOCK(g_proxyinfo_mutex);
722    proxyInfo[net] = addrProxy;
723    return true;
724}
725
726std::optional<Proxy> GetProxy(enum Network net)
727{
728    assert(net >= 0 && net < NET_MAX);
729    LOCK(g_proxyinfo_mutex);
730    if (!proxyInfo[net].IsValid()) {
731        return std::nullopt;
732    }
733    return proxyInfo[net];
734}
735
736bool SetNameProxy(const Proxy &addrProxy) {
737    if (!addrProxy.IsValid())
738        return false;
739    LOCK(g_proxyinfo_mutex);
740    nameProxy = addrProxy;
741    return true;
742}
743
744std::optional<Proxy> GetNameProxy()
745{
746    LOCK(g_proxyinfo_mutex);
747    if (!nameProxy.IsValid()) {
748        return std::nullopt;
749    }
750    return nameProxy;