NET_SocketListener.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * NAME:        NET_SocketListener.h
 *
 * COMMENTS:
 *
 */

#ifndef __NET_SOCKETLISTENER_H__
#define __NET_SOCKETLISTENER_H__

#include "NET_API.h"

#include "NET_ConnectionHandler.h"
#include "NET_Error.h"
#include "NET_InfoCallback.h"
#include "NET_SocketGroup.h"

#include <UT/UT_BoostAsio.h>
#include <UT/UT_Debug.h>
#include <UT/UT_IntrusivePtr.h>
#include <UT/UT_UniquePtr.h>
#include <UT/UT_UniversalLogFileSink.h>

#include <SYS/SYS_Compiler.h>

#include <type_traits>

class NET_WebServer;

class NET_API NET_ISocketListener
    : public UTenable_shared_from_this<NET_ISocketListener>
{
public:
    virtual ~NET_ISocketListener() = default;

    virtual void close(bool force) = 0;
    virtual bool isOpen() const = 0;

protected:
    NET_ISocketListener(ASIO_IOContext& context)
        : myIOContext(context), mySocketGroup(nullptr)
    {
    }

    /// Called when something failed with the socket listener.
    void fail(const hboost::system::error_code& ec, const char* what);

    NET_ISocketGroup* mySocketGroup;
    ASIO_IOContext& myIOContext;
    NET_ConnectionManager myConnectionManager;
};

template <typename EndpointT, typename Enabled = void>
struct endpoint_has_port : std::false_type
{
};

template <typename EndpointT>
struct endpoint_has_port<EndpointT, decltype(std::declval<EndpointT>().port(0))>
    : std::true_type
{
};

template <typename SocketT>
struct socket_info
{
    using endpoint_type = typename SocketT::endpoint_type;
    static constexpr bool uses_port
            = endpoint_has_port<endpoint_type>::value;
};

template <
        typename AcceptorT,
        typename SocketT
        = hboost::asio::basic_stream_socket<typename AcceptorT::protocol_type>>
class NET_SocketListener : public NET_ISocketListener
{
public:
    using acceptor_type = AcceptorT;
    using socket_type = SocketT;
    using endpoint_type = typename AcceptorT::endpoint_type;

    template <
            typename S = SocketT,
            typename = typename std::enable_if_t<socket_info<S>::uses_port>>
    void start(
            int initial_port,
            int max_port_range = -1,
            bool use_system_port = false,
            const ASIO_IPAddress& address = ASIO_IPAddressV4())
    {
        myPortInfo.myPort = initial_port;
        myPortInfo.myMaxPort = max_port_range;
        myPortInfo.myUseSystemPort = use_system_port;
        myPortInfo.myBindAddress = address;

        start();
    }
    template <
            typename S = SocketT,
            typename = typename std::enable_if_t<socket_info<S>::uses_port>>
    void start();
    void start(const ASIO_TCPEndpoint& ep)
    {
        if (isOpen())
        {
            return;
        }

        try
        {
            myAcceptor.open(ep.protocol());
            myAcceptor.set_option(typename AcceptorT::reuse_address(true));
            myAcceptor.bind(ep);
            myAcceptor.listen();
        }
        catch (std::exception& e)
        {
            NETaddFatal(NET_ERR_NET_MGR, "Server start error: {}", e.what());
            myAcceptor.close();
            return;
        }

        if (isOpen())
        {
            init_();
            startAccept_();
        }
    }
    void close(bool force) override
    {
        ASIO_HANDLER_LOCATION;

        hboost::asio::dispatch(
                myAcceptor.get_executor(),
                [this, self = shared_from_this(), force]()
                {
                    // Regardless of the closure type always try to close the
                    // acceptor so that no new connections come in.
                    if (myAcceptor.is_open())
                    {
                        hboost::system::error_code ec;
                        myAcceptor.close(ec);
                        if (ec)
                            fail(ec, "acceptor close");
                    }

                    // Let the individual handlers define what a forced closure
                    // means to that handler.
                    myConnectionManager.stopAll(force);
                });
    }
    /// Returns the port the socket listener is bound to. It does not return
    /// the port that was requested to bind to.
    template <
            typename S = SocketT,
            typename = typename std::enable_if_t<socket_info<S>::uses_port>>
    int port() const
    {
        return myAcceptor.local_endpoint().port();
    }
    template <
            typename S = SocketT,
            typename = typename std::enable_if_t<socket_info<S>::uses_port>>
    void setPort(int port)
    {
        myPortInfo.myPort = port;
    }
    template <
            typename S = SocketT,
            typename = typename std::enable_if_t<socket_info<S>::uses_port>>
    void setMaxPort(int port)
    {
        myPortInfo.myMaxPort = port;
    }
    template <
            typename S = SocketT,
            typename = typename std::enable_if_t<socket_info<S>::uses_port>>
    void setUseSystemPort(bool use_sys)
    {
        myPortInfo.myUseSystemPort = use_sys;
    }
    template <
            typename S = SocketT,
            typename = typename std::enable_if_t<socket_info<S>::uses_port>>
    void setUseIPv6(bool use_v6)
    {
        myPortInfo.myUseIPv6 = use_v6;
    }
    template <
            typename S = SocketT,
            typename = typename std::enable_if_t<socket_info<S>::uses_port>>
    bool useIPv6() const
    {
        return myPortInfo.myUseIPv6;
    }
    template <
            typename S = SocketT,
            typename = typename std::enable_if_t<socket_info<S>::uses_port>>
    void setBindAddress(const ASIO_IPAddress& bind_address)
    {
        myPortInfo.myBindAddress = bind_address;
    }
    template <
            typename S = SocketT,
            typename = typename std::enable_if_t<socket_info<S>::uses_port>>
    const ASIO_IPAddress& bindAddress() const
    {
        return myPortInfo.myBindAddress;
    }

    endpoint_type endpoint() const { return myAcceptor.local_endpoint(); }

    bool isOpen() const override { return myAcceptor.is_open(); }

protected:
    NET_SocketListener(ASIO_IOContext& context)
        : NET_ISocketListener(context)
        , myAcceptor(hboost::asio::make_strand(context))
    {
    }

    /// Do any initialization after the socket listener has been setup but
    /// before we actually start accepting requests.
    virtual void init_() {}
    /// Called each time a new socket is accepted. Make sure to add the
    /// connection handler to the connection manager so that we can easily
    /// stop all requests that came from this listening socket when shutting
    /// down.
    virtual void onAccept_(
            const hboost::system::error_code& ec,
            socket_type socket)
            = 0;

    /// Start an async accept. If the accept was a success onAccept_ is called.
    void startAccept_();

    AcceptorT myAcceptor;

    struct Empty {};

    struct PortInfo
    {
        ASIO_IPAddress myBindAddress;
        int myPort = -1;
        int myMaxPort = -1;
        bool myUseSystemPort = false;
        bool myUseIPv6 = false;
    };

    std::conditional_t<socket_info<socket_type>::uses_port, PortInfo, Empty>
            myPortInfo;
};

template <typename AcceptorT, typename SocketT>
template <typename S, typename Detected>
void
NET_SocketListener<AcceptorT, SocketT>::start()
{
    if (isOpen())
    {
        UT_ASSERT(!"Trying to start the same connection twice.");
        return;
    }
    endpoint_type ep(myPortInfo.myBindAddress, myPortInfo.myPort);

    start(ep);
    if (!isOpen() && myPortInfo.myPort != 0)
    {
        // First try the port range if possible.
        if (myPortInfo.myMaxPort > 0 && myPortInfo.myMaxPort > myPortInfo.myPort)
        {
            for (int port = myPortInfo.myPort + 1;
                 port <= myPortInfo.myMaxPort && !isOpen(); port++)
            {
                ep.port(port);
                start(ep);
            }
        }

        // Second let the OS pick a port.
        if (!isOpen() && myPortInfo.myUseSystemPort)
        {
            ep.port(0);
            start(ep);
        }
    }
}

template <typename AcceptorT, typename SocketT>
void
NET_SocketListener<AcceptorT, SocketT>::startAccept_()
{
    ASIO_HANDLER_LOCATION;

    myAcceptor.async_accept(
            hboost::asio::make_strand(myIOContext),
            [this, self = shared_from_this()](
                    hboost::system::error_code ec, socket_type socket) {
                ASIO_HANDLER_LOCATION;
                if (!myAcceptor.is_open())
                    return;

                if (!ec)
                {
                    if (socket.is_open())
                    {
                        onAccept_(ec, std::move(socket));
                    }
                }
                else
                {
                    // If the operation was cancelled it does not need to be
                    // logged and the operation is finished so there is no
                    // need to re-add an accept task.
                    if (ec == hboost::asio::error::operation_aborted)
                        return;
                    fail(ec, "accept");
                }

                startAccept_();
            });
}

#endif // __NET_SOCKETLISTENER_H__