/* SPDX-License-Identifier: MPL-2.0 */
 
#include "precompiled.hpp"
 
#include "vsock_connecter.hpp"
#include "vsock_address.hpp"
 
#if defined ZMQ_HAVE_VSOCK
 
#include <new>
 
#include "io_thread.hpp"
#include "platform.hpp"
#include "random.hpp"
#include "err.hpp"
#include "ip.hpp"
#include "address.hpp"
#include "session_base.hpp"
#include "sys/socket.h"
#include "linux/vm_sockets.h"
 
zmq::vsock_connecter_t::vsock_connecter_t (class io_thread_t *io_thread_,
                                           class session_base_t *session_,
                                           const options_t &options_,
                                           address_t *addr_,
                                           bool delayed_start_) :
    stream_connecter_base_t (
      io_thread_, session_, options_, addr_, delayed_start_),
    _connect_timer_started (false)
{
    zmq_assert (_addr->protocol == protocol_name::vsock);
}
 
zmq::vsock_connecter_t::~vsock_connecter_t ()
{
    zmq_assert (!_connect_timer_started);
}
 
void zmq::vsock_connecter_t::process_term (int linger_)
{
    if (_connect_timer_started) {
        cancel_timer (connect_timer_id);
        _connect_timer_started = false;
    }
 
    stream_connecter_base_t::process_term (linger_);
}
 
void zmq::vsock_connecter_t::in_event ()
{
    //  We are not polling for incoming data, so we are actually called
    //  because of error here. However, we can get error on out event as well
    //  on some platforms, so we'll simply handle both events in the same way.
    out_event ();
}
 
void zmq::vsock_connecter_t::out_event ()
{
    if (_connect_timer_started) {
        cancel_timer (connect_timer_id);
        _connect_timer_started = false;
    }
 
    //  TODO this is still very similar to (t)ipc_connecter_t, maybe the
    //  differences can be factored out
 
    rm_handle ();
 
    const fd_t fd = connect ();
 
    if (fd == retired_fd
        && ((options.reconnect_stop & ZMQ_RECONNECT_STOP_CONN_REFUSED)
            && errno == ECONNREFUSED)) {
        send_conn_failed (_session);
        close ();
        terminate ();
        return;
    }
 
    //  Handle the error condition by attempt to reconnect.
    if (fd == retired_fd) {
        close ();
        add_reconnect_timer ();
        return;
    }
 
    create_engine (
      fd, zmq::vsock_connecter_t::get_socket_name (fd, socket_end_local));
}
 
std::string
zmq::vsock_connecter_t::get_socket_name (zmq::fd_t fd_,
                                         socket_end_t socket_end_) const
{
    struct sockaddr_storage ss;
    const zmq_socklen_t sl = get_socket_address (fd_, socket_end_, &ss);
    if (sl == 0) {
        return std::string ();
    }
 
    const vsock_address_t addr (reinterpret_cast<struct sockaddr *> (&ss), sl,
                                this->get_ctx ());
    std::string address_string;
    addr.to_string (address_string);
    return address_string;
}
 
void zmq::vsock_connecter_t::timer_event (int id_)
{
    if (id_ == connect_timer_id) {
        _connect_timer_started = false;
        rm_handle ();
        close ();
        add_reconnect_timer ();
    } else
        stream_connecter_base_t::timer_event (id_);
}
 
void zmq::vsock_connecter_t::start_connecting ()
{
    //  Open the connecting socket.
    const int rc = open ();
 
    //  Connect may succeed in synchronous manner.
    if (rc == 0) {
        _handle = add_fd (_s);
        out_event ();
    }
 
    //  Connection establishment may be delayed. Poll for its completion.
    else if (rc == -1 && errno == EINPROGRESS) {
        _handle = add_fd (_s);
        set_pollout (_handle);
        _socket->event_connect_delayed (
          make_unconnected_connect_endpoint_pair (_endpoint), zmq_errno ());
 
        //  add userspace connect timeout
        add_connect_timer ();
    }
 
    //  Handle any other error condition by eventual reconnect.
    else {
        if (_s != retired_fd)
            close ();
        add_reconnect_timer ();
    }
}
 
void zmq::vsock_connecter_t::add_connect_timer ()
{
    if (options.connect_timeout > 0) {
        add_timer (options.connect_timeout, connect_timer_id);
        _connect_timer_started = true;
    }
}
 
int zmq::vsock_connecter_t::open ()
{
    zmq_assert (_s == retired_fd);
 
    //  Resolve the address
    if (_addr->resolved.vsock_addr != NULL) {
        LIBZMQ_DELETE (_addr->resolved.vsock_addr);
    }
 
    _addr->resolved.vsock_addr =
      new (std::nothrow) vsock_address_t (this->get_ctx ());
    alloc_assert (_addr->resolved.vsock_addr);
 
    //  Convert the textual address into address structure.
    _addr->resolved.vsock_addr->resolve (_addr->address.c_str ());
 
    //  Create the socket.
    _s = open_socket (AF_VSOCK, SOCK_STREAM, 0);
 
    if (_s == retired_fd) {
        //  TODO we should emit some event in this case!
 
        LIBZMQ_DELETE (_addr->resolved.vsock_addr);
        return -1;
    }
 
    zmq_assert (_addr->resolved.vsock_addr != NULL);
 
    // Set the socket to non-blocking mode so that we get async connect().
    unblock_socket (_s);
 
    const vsock_address_t *const vsock_addr = _addr->resolved.vsock_addr;
 
    //  Connect to the remote peer.
    int rc = ::connect (_s, vsock_addr->addr (), vsock_addr->addrlen ());
    //  Connect was successful immediately.
    if (rc == 0) {
        return 0;
    }
 
    if (errno == EINTR)
        errno = EINPROGRESS;
 
    return -1;
}
 
zmq::fd_t zmq::vsock_connecter_t::connect ()
{
    //  Async connect has finished. Check whether an error occurred
    int err = 0;
    socklen_t len = sizeof err;
 
    const int rc = getsockopt (_s, SOL_SOCKET, SO_ERROR,
                               reinterpret_cast<char *> (&err), &len);
 
    //  Assert if the error was caused by 0MQ bug.
    //  Networking problems are OK. No need to assert.
    //  Following code should handle both Berkeley-derived socket
    //  implementations and Solaris.
    if (rc == -1)
        err = errno;
    if (err != 0) {
        errno = err;
        errno_assert (errno != ENOPROTOOPT && errno != ENOTSOCK
                      && errno != ENOBUFS);
        return retired_fd;
    }
 
    //  Return the newly connected socket.
    const fd_t result = _s;
    _s = retired_fd;
    return result;
}
 
#endif