ipc_connecter.cpp

Go to the documentation of this file.

/* SPDX-License-Identifier: MPL-2.0 */
 
#include "precompiled.hpp"
#include "ipc_connecter.hpp"
 
#if defined ZMQ_HAVE_IPC
 
#include <new>
#include <string>
 
#include "io_thread.hpp"
#include "random.hpp"
#include "err.hpp"
#include "ip.hpp"
#include "address.hpp"
#include "ipc_address.hpp"
#include "session_base.hpp"
 
#if defined ZMQ_HAVE_WINDOWS
#include <afunix.h>
#else
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/un.h>
#endif
 
zmq::ipc_connecter_t::ipc_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_)
{
    zmq_assert (_addr->protocol == protocol_name::ipc);
}
 
void zmq::ipc_connecter_t::out_event ()
{
    const fd_t fd = connect ();
    rm_handle ();
 
    //  Handle the error condition by attempt to reconnect.
    if (fd == retired_fd) {
        close ();
        add_reconnect_timer ();
        return;
    }
 
    create_engine (fd, get_socket_name<ipc_address_t> (fd, socket_end_local));
}
 
void zmq::ipc_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 ());
 
        // TODO, tcp_connecter_t adds a connect timer in this case; maybe this
        // should be done here as well (and then this could be pulled up to
        // stream_connecter_base_t).
    }
    //stop connecting after called zmq_disconnect
    else if (rc == -1
             && (options.reconnect_stop & ZMQ_RECONNECT_STOP_AFTER_DISCONNECT)
             && errno == ECONNREFUSED && _socket->is_disconnected ()) {
        if (_s != retired_fd)
            close ();
    }
 
    //  Handle any other error condition by eventual reconnect.
    else {
        if (_s != retired_fd)
            close ();
        add_reconnect_timer ();
    }
}
 
int zmq::ipc_connecter_t::open ()
{
    zmq_assert (_s == retired_fd);
 
    //  Create the socket.
    _s = open_socket (AF_UNIX, SOCK_STREAM, 0);
    if (_s == retired_fd)
        return -1;
 
    //  Set the non-blocking flag.
    unblock_socket (_s);
 
    //  Connect to the remote peer.
    const int rc = ::connect (_s, _addr->resolved.ipc_addr->addr (),
                              _addr->resolved.ipc_addr->addrlen ());
 
    //  Connect was successful immediately.
    if (rc == 0)
        return 0;
 
        //  Translate other error codes indicating asynchronous connect has been
        //  launched to a uniform EINPROGRESS.
#ifdef ZMQ_HAVE_WINDOWS
    const int last_error = WSAGetLastError ();
    if (last_error == WSAEINPROGRESS || last_error == WSAEWOULDBLOCK)
        errno = EINPROGRESS;
    else
        errno = wsa_error_to_errno (last_error);
#else
    if (rc == -1 && errno == EINTR) {
        errno = EINPROGRESS;
    }
#endif
 
    //  Forward the error.
    return -1;
}
 
zmq::fd_t zmq::ipc_connecter_t::connect ()
{
    //  Following code should handle both Berkeley-derived socket
    //  implementations and Solaris.
    int err = 0;
    zmq_socklen_t len = static_cast<zmq_socklen_t> (sizeof (err));
    const int rc = getsockopt (_s, SOL_SOCKET, SO_ERROR,
                               reinterpret_cast<char *> (&err), &len);
    if (rc == -1) {
        if (errno == ENOPROTOOPT)
            errno = 0;
        err = errno;
    }
    if (err != 0) {
        //  Assert if the error was caused by 0MQ bug.
        //  Networking problems are OK. No need to assert.
        errno = err;
        errno_assert (errno == ECONNREFUSED || errno == ECONNRESET
                      || errno == ETIMEDOUT || errno == EHOSTUNREACH
                      || errno == ENETUNREACH || errno == ENETDOWN);
 
        return retired_fd;
    }
 
    const fd_t result = _s;
    _s = retired_fd;
    return result;
}
 
#endif