vmci_connecter.cpp 8.68 KB
Newer Older
Ilya Kulakov's avatar
Ilya Kulakov committed
1
/*
2
    Copyright (c) 2007-2016 Contributors as noted in the AUTHORS file
Ilya Kulakov's avatar
Ilya Kulakov committed
3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29

    This file is part of libzmq, the ZeroMQ core engine in C++.

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

    As a special exception, the Contributors give you permission to link
    this library with independent modules to produce an executable,
    regardless of the license terms of these independent modules, and to
    copy and distribute the resulting executable under terms of your choice,
    provided that you also meet, for each linked independent module, the
    terms and conditions of the license of that module. An independent
    module is a module which is not derived from or based on this library.
    If you modify this library, you must extend this exception to your
    version of the library.

    libzmq 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 Lesser General Public
    License for more details.

    You should have received a copy of the GNU Lesser General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

30 31
#include "precompiled.hpp"

Ilya Kulakov's avatar
Ilya Kulakov committed
32 33 34 35 36 37 38 39 40 41 42 43 44 45
#include "vmci_connecter.hpp"

#if defined ZMQ_HAVE_VMCI

#include <new>

#include "stream_engine.hpp"
#include "io_thread.hpp"
#include "platform.hpp"
#include "random.hpp"
#include "err.hpp"
#include "ip.hpp"
#include "address.hpp"
#include "session_base.hpp"
46
#include "vmci_address.hpp"
Ilya Kulakov's avatar
Ilya Kulakov committed
47 48 49
#include "vmci.hpp"

zmq::vmci_connecter_t::vmci_connecter_t (class io_thread_t *io_thread_,
50 51 52 53
                                         class session_base_t *session_,
                                         const options_t &options_,
                                         const address_t *addr_,
                                         bool delayed_start_) :
Ilya Kulakov's avatar
Ilya Kulakov committed
54 55 56 57 58 59 60 61
    own_t (io_thread_, options_),
    io_object_t (io_thread_),
    addr (addr_),
    s (retired_fd),
    handle_valid (false),
    delayed_start (delayed_start_),
    timer_started (false),
    session (session_),
62
    current_reconnect_ivl (options.reconnect_ivl)
Ilya Kulakov's avatar
Ilya Kulakov committed
63 64 65 66
{
    zmq_assert (addr);
    zmq_assert (addr->protocol == "vmci");
    addr->to_string (endpoint);
67
    socket = session->get_socket ();
Ilya Kulakov's avatar
Ilya Kulakov committed
68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119
}

zmq::vmci_connecter_t::~vmci_connecter_t ()
{
    zmq_assert (!timer_started);
    zmq_assert (!handle_valid);
    zmq_assert (s == retired_fd);
}

void zmq::vmci_connecter_t::process_plug ()
{
    if (delayed_start)
        add_reconnect_timer ();
    else
        start_connecting ();
}

void zmq::vmci_connecter_t::process_term (int linger_)
{
    if (timer_started) {
        cancel_timer (reconnect_timer_id);
        timer_started = false;
    }

    if (handle_valid) {
        rm_fd (handle);
        handle_valid = false;
    }

    if (s != retired_fd)
        close ();

    own_t::process_term (linger_);
}

void zmq::vmci_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::vmci_connecter_t::out_event ()
{
    fd_t fd = connect ();
    rm_fd (handle);
    handle_valid = false;

    //  Handle the error condition by attempt to reconnect.
    if (fd == retired_fd) {
        close ();
120
        add_reconnect_timer ();
Ilya Kulakov's avatar
Ilya Kulakov committed
121 122 123
        return;
    }

124
    tune_vmci_buffer_size (this->get_ctx (), fd, options.vmci_buffer_size,
125 126
                           options.vmci_buffer_min_size,
                           options.vmci_buffer_max_size);
Ilya Kulakov's avatar
Ilya Kulakov committed
127

128
    if (options.vmci_connect_timeout > 0) {
Ilya Kulakov's avatar
Ilya Kulakov committed
129
#if defined ZMQ_HAVE_WINDOWS
130 131
        tune_vmci_connect_timeout (this->get_ctx (), fd,
                                   options.vmci_connect_timeout);
Ilya Kulakov's avatar
Ilya Kulakov committed
132 133 134 135 136 137 138
#else
        struct timeval timeout = {0, options.vmci_connect_timeout * 1000};
        tune_vmci_connect_timeout (this->get_ctx (), fd, timeout);
#endif
    }

    //  Create the engine object for this connection.
139 140
    stream_engine_t *engine = new (std::nothrow) stream_engine_t (
      fd, options, make_unconnected_bind_endpoint_pair (endpoint));
Ilya Kulakov's avatar
Ilya Kulakov committed
141 142 143 144 145 146 147 148
    alloc_assert (engine);

    //  Attach the engine to the corresponding session object.
    send_attach (session, engine);

    //  Shut the connecter down.
    terminate ();

149 150
    socket->event_connected (make_unconnected_bind_endpoint_pair (endpoint),
                             fd);
Ilya Kulakov's avatar
Ilya Kulakov committed
151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179
}

void zmq::vmci_connecter_t::timer_event (int id_)
{
    zmq_assert (id_ == reconnect_timer_id);
    timer_started = false;
    start_connecting ();
}

void zmq::vmci_connecter_t::start_connecting ()
{
    //  Open the connecting socket.
    int rc = open ();

    //  Connect may succeed in synchronous manner.
    if (rc == 0) {
        handle = add_fd (s);
        handle_valid = true;
        out_event ();
    }

    //  Handle any other error condition by eventual reconnect.
    else {
        if (s != retired_fd)
            close ();
        add_reconnect_timer ();
    }
}

180
void zmq::vmci_connecter_t::add_reconnect_timer ()
Ilya Kulakov's avatar
Ilya Kulakov committed
181
{
182 183 184
    if (options.reconnect_ivl != -1) {
        int rc_ivl = get_new_reconnect_ivl ();
        add_timer (rc_ivl, reconnect_timer_id);
185 186
        socket->event_connect_retried (
          make_unconnected_bind_endpoint_pair (endpoint), rc_ivl);
187 188
        timer_started = true;
    }
Ilya Kulakov's avatar
Ilya Kulakov committed
189 190 191 192 193
}

int zmq::vmci_connecter_t::get_new_reconnect_ivl ()
{
    //  The new interval is the current interval + random value.
194 195
    int this_interval =
      current_reconnect_ivl + (generate_random () % options.reconnect_ivl);
Ilya Kulakov's avatar
Ilya Kulakov committed
196 197 198

    //  Only change the current reconnect interval  if the maximum reconnect
    //  interval was set and if it's larger than the reconnect interval.
199 200
    if (options.reconnect_ivl_max > 0
        && options.reconnect_ivl_max > options.reconnect_ivl) {
Ilya Kulakov's avatar
Ilya Kulakov committed
201 202
        //  Calculate the next interval
        current_reconnect_ivl = current_reconnect_ivl * 2;
203
        if (current_reconnect_ivl >= options.reconnect_ivl_max) {
Ilya Kulakov's avatar
Ilya Kulakov committed
204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219
            current_reconnect_ivl = options.reconnect_ivl_max;
        }
    }
    return this_interval;
}

int zmq::vmci_connecter_t::open ()
{
    zmq_assert (s == retired_fd);

    int family = this->get_ctx ()->get_vmci_socket_family ();
    if (family == -1)
        return -1;

    //  Create the socket.
    s = open_socket (family, SOCK_STREAM, 0);
220 221
#ifdef ZMQ_HAVE_WINDOWS
    if (s == INVALID_SOCKET) {
222
        errno = wsa_error_to_errno (WSAGetLastError ());
223 224 225
        return -1;
    }
#else
Ilya Kulakov's avatar
Ilya Kulakov committed
226 227
    if (s == -1)
        return -1;
228
#endif
Ilya Kulakov's avatar
Ilya Kulakov committed
229 230

    //  Connect to the remote peer.
231 232
    int rc = ::connect (s, addr->resolved.vmci_addr->addr (),
                        addr->resolved.vmci_addr->addrlen ());
Ilya Kulakov's avatar
Ilya Kulakov committed
233 234 235 236 237 238 239 240 241

    //  Connect was successful immediately.
    if (rc == 0)
        return 0;

    //  Forward the error.
    return -1;
}

242
void zmq::vmci_connecter_t::close ()
Ilya Kulakov's avatar
Ilya Kulakov committed
243 244
{
    zmq_assert (s != retired_fd);
245 246 247 248 249
#ifdef ZMQ_HAVE_WINDOWS
    const int rc = closesocket (s);
    wsa_assert (rc != SOCKET_ERROR);
#else
    const int rc = ::close (s);
Ilya Kulakov's avatar
Ilya Kulakov committed
250
    errno_assert (rc == 0);
251
#endif
252
    socket->event_closed (make_unconnected_bind_endpoint_pair (endpoint), s);
Ilya Kulakov's avatar
Ilya Kulakov committed
253 254 255 256 257 258 259 260 261 262 263 264 265
    s = retired_fd;
}

zmq::fd_t zmq::vmci_connecter_t::connect ()
{
    //  Following code should handle both Berkeley-derived socket
    //  implementations and Solaris.
    int err = 0;
#if defined ZMQ_HAVE_HPUX
    int len = sizeof (err);
#else
    socklen_t len = sizeof (err);
#endif
266
    int rc = getsockopt (s, SOL_SOCKET, SO_ERROR, (char *) &err, &len);
267 268 269 270

    //  Assert if the error was caused by 0MQ bug.
    //  Networking problems are OK. No need to assert.
#ifdef ZMQ_HAVE_WINDOWS
271
    zmq_assert (rc == 0);
272
    if (err != 0) {
273 274 275 276 277 278
        if (err != WSAECONNREFUSED && err != WSAETIMEDOUT
            && err != WSAECONNABORTED && err != WSAEHOSTUNREACH
            && err != WSAENETUNREACH && err != WSAENETDOWN && err != WSAEACCES
            && err != WSAEINVAL && err != WSAEADDRINUSE
            && err != WSAECONNRESET) {
            wsa_assert_no (err);
279 280 281 282 283 284
        }
        return retired_fd;
    }
#else
    //  Following code should handle both Berkeley-derived socket
    //  implementations and Solaris.
Ilya Kulakov's avatar
Ilya Kulakov committed
285 286 287 288
    if (rc == -1)
        err = errno;
    if (err != 0) {
        errno = err;
289 290 291 292
        errno_assert (errno == ECONNREFUSED || errno == ECONNRESET
                      || errno == ETIMEDOUT || errno == EHOSTUNREACH
                      || errno == ENETUNREACH || errno == ENETDOWN
                      || errno == EINVAL);
Ilya Kulakov's avatar
Ilya Kulakov committed
293 294
        return retired_fd;
    }
295
#endif
Ilya Kulakov's avatar
Ilya Kulakov committed
296 297 298 299 300 301 302

    fd_t result = s;
    s = retired_fd;
    return result;
}

#endif