laag-libzmq 4.2.3.0

data/vendor/github.com/zeromq/libzmq/src/socks_connecter.hpp

@@ -0,0 +1,163 @@
+/*
+    Copyright (c) 2007-2016 Contributors as noted in the AUTHORS file
+
+    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/>.
+*/
+
+#ifndef __SOCKS_CONNECTER_HPP_INCLUDED__
+#define __SOCKS_CONNECTER_HPP_INCLUDED__
+
+#include "fd.hpp"
+#include "io_object.hpp"
+#include "own.hpp"
+#include "stdint.hpp"
+#include "socks.hpp"
+
+namespace zmq
+{
+
+    class io_thread_t;
+    class session_base_t;
+    struct address_t;
+
+    class socks_connecter_t : public own_t, public io_object_t
+    {
+    public:
+
+        //  If 'delayed_start' is true connecter first waits for a while,
+        //  then starts connection process.
+        socks_connecter_t (zmq::io_thread_t *io_thread_,
+            zmq::session_base_t *session_, const options_t &options_,
+            address_t *addr_, address_t *proxy_addr_,  bool delayed_start_);
+        ~socks_connecter_t ();
+
+    private:
+        enum {
+            unplugged,
+            waiting_for_reconnect_time,
+            waiting_for_proxy_connection,
+            sending_greeting,
+            waiting_for_choice,
+            sending_request,
+            waiting_for_response
+        };
+
+        //  ID of the timer used to delay the reconnection.
+        enum { reconnect_timer_id = 1 };
+
+        //  Method ID
+        enum { socks_no_auth_required = 0 };
+
+        //  Handlers for incoming commands.
+        virtual void process_plug ();
+        virtual void process_term (int linger_);
+
+        //  Handlers for I/O events.
+        virtual void in_event ();
+        virtual void out_event ();
+        virtual void timer_event (int id_);
+
+        //  Internal function to start the actual connection establishment.
+        void initiate_connect ();
+
+        int process_server_response (const socks_choice_t &response);
+        int process_server_response (const socks_response_t &response);
+
+        int parse_address (const std::string &address_,
+                std::string &hostname_, uint16_t &port_);
+
+        int connect_to_proxy ();
+
+        void error ();
+
+        //  Internal function to start reconnect timer
+        void start_timer ();
+
+        //  Internal function to return a reconnect backoff delay.
+        //  Will modify the current_reconnect_ivl used for next call
+        //  Returns the currently used interval
+        int get_new_reconnect_ivl ();
+
+        //  Open TCP connecting socket. Returns -1 in case of error,
+        //  0 if connect was successful immediately. Returns -1 with
+        //  EAGAIN errno if async connect was launched.
+        int open ();
+
+        //  Close the connecting socket.
+        void close ();
+
+        //  Get the file descriptor of newly created connection. Returns
+        //  retired_fd if the connection was unsuccessful.
+        zmq::fd_t check_proxy_connection ();
+
+        socks_greeting_encoder_t greeting_encoder;
+        socks_choice_decoder_t choice_decoder;
+        socks_request_encoder_t request_encoder;
+        socks_response_decoder_t response_decoder;
+
+        //  Address to connect to. Owned by session_base_t.
+        address_t *addr;
+
+        //  SOCKS address; owned by this connecter.
+        address_t *proxy_addr;
+
+        int status;
+
+        //  Underlying socket.
+        fd_t s;
+
+        //  Handle corresponding to the listening socket.
+        handle_t handle;
+
+        //  If true file descriptor is registered with the poller and 'handle'
+        //  contains valid value.
+        bool handle_valid;
+
+        //  If true, connecter is waiting a while before trying to connect.
+        const bool delayed_start;
+
+        //  True iff a timer has been started.
+        bool timer_started;
+
+        //  Reference to the session we belong to.
+        zmq::session_base_t *session;
+
+        //  Current reconnect ivl, updated for backoff strategy
+        int current_reconnect_ivl;
+
+        // String representation of endpoint to connect to
+        std::string endpoint;
+
+        // Socket
+        zmq::socket_base_t *socket;
+
+        socks_connecter_t (const socks_connecter_t&);
+        const socks_connecter_t &operator = (const socks_connecter_t&);
+    };
+
+}
+
+#endif

data/vendor/github.com/zeromq/libzmq/src/stdint.hpp

@@ -0,0 +1,77 @@
+/*
+    Copyright (c) 2007-2016 Contributors as noted in the AUTHORS file
+
+    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/>.
+*/
+
+#ifndef __ZMQ_STDINT_HPP_INCLUDED__
+#define __ZMQ_STDINT_HPP_INCLUDED__
+
+#if defined ZMQ_HAVE_SOLARIS || defined ZMQ_HAVE_OPENVMS
+
+#include <inttypes.h>
+
+#elif defined _MSC_VER && _MSC_VER < 1600
+
+#ifndef int8_t
+typedef __int8 int8_t;
+#endif
+#ifndef int16_t
+typedef __int16 int16_t;
+#endif
+#ifndef int32_t
+typedef __int32 int32_t;
+#endif
+#ifndef int64_t
+typedef __int64 int64_t;
+#endif
+#ifndef uint8_t
+typedef unsigned __int8 uint8_t;
+#endif
+#ifndef uint16_t
+typedef unsigned __int16 uint16_t;
+#endif
+#ifndef uint32_t
+typedef unsigned __int32 uint32_t;
+#endif
+#ifndef uint64_t
+typedef unsigned __int64 uint64_t;
+#endif
+#ifndef UINT32_MAX
+#define UINT32_MAX   _UI32_MAX
+#endif
+
+#else
+
+#include <stdint.h>
+
+#endif
+
+#ifndef UINT8_MAX
+#define UINT8_MAX 0xFF
+#endif
+
+#endif

data/vendor/github.com/zeromq/libzmq/src/stream.cpp

@@ -0,0 +1,321 @@
+/*
+    Copyright (c) 2007-2016 Contributors as noted in the AUTHORS file
+
+    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/>.
+*/
+
+#include "precompiled.hpp"
+#include "macros.hpp"
+#include "stream.hpp"
+#include "pipe.hpp"
+#include "wire.hpp"
+#include "random.hpp"
+#include "likely.hpp"
+#include "err.hpp"
+
+zmq::stream_t::stream_t (class ctx_t *parent_, uint32_t tid_, int sid_) :
+    socket_base_t (parent_, tid_, sid_),
+    prefetched (false),
+    routing_id_sent (false),
+    current_out (NULL),
+    more_out (false),
+    next_integral_routing_id (generate_random ())
+{
+    options.type = ZMQ_STREAM;
+    options.raw_socket = true;
+
+    prefetched_routing_id.init ();
+    prefetched_msg.init ();
+}
+
+zmq::stream_t::~stream_t ()
+{
+    zmq_assert (outpipes.empty ());
+    prefetched_routing_id.close ();
+    prefetched_msg.close ();
+}
+
+void zmq::stream_t::xattach_pipe (pipe_t *pipe_, bool subscribe_to_all_)
+{
+    LIBZMQ_UNUSED(subscribe_to_all_);
+
+    zmq_assert (pipe_);
+
+    identify_peer (pipe_);
+    fq.attach (pipe_);
+}
+
+void zmq::stream_t::xpipe_terminated (pipe_t *pipe_)
+{
+    outpipes_t::iterator it = outpipes.find (pipe_->get_routing_id ());
+    zmq_assert (it != outpipes.end ());
+    outpipes.erase (it);
+    fq.pipe_terminated (pipe_);
+    if (pipe_ == current_out)
+        current_out = NULL;
+}
+
+void zmq::stream_t::xread_activated (pipe_t *pipe_)
+{
+    fq.activated (pipe_);
+}
+
+void zmq::stream_t::xwrite_activated (pipe_t *pipe_)
+{
+    outpipes_t::iterator it;
+    for (it = outpipes.begin (); it != outpipes.end (); ++it)
+        if (it->second.pipe == pipe_)
+            break;
+
+    zmq_assert (it != outpipes.end ());
+    zmq_assert (!it->second.active);
+    it->second.active = true;
+}
+
+int zmq::stream_t::xsend (msg_t *msg_)
+{
+    //  If this is the first part of the message it's the ID of the
+    //  peer to send the message to.
+    if (!more_out) {
+        zmq_assert (!current_out);
+
+        //  If we have malformed message (prefix with no subsequent message)
+        //  then just silently ignore it.
+        //  TODO: The connections should be killed instead.
+        if (msg_->flags () & msg_t::more) {
+
+            //  Find the pipe associated with the routing id stored in the prefix.
+            //  If there's no such pipe return an error
+            blob_t routing_id ((unsigned char*) msg_->data (), msg_->size ());
+            outpipes_t::iterator it = outpipes.find (routing_id);
+
+            if (it != outpipes.end ()) {
+                current_out = it->second.pipe;
+                if (!current_out->check_write ()) {
+                    it->second.active = false;
+                    current_out = NULL;
+                    errno = EAGAIN;
+                    return -1;
+                }
+            }
+            else {
+                errno = EHOSTUNREACH;
+                return -1;
+            }
+        }
+
+        //  Expect one more message frame.
+        more_out = true;
+
+        int rc = msg_->close ();
+        errno_assert (rc == 0);
+        rc = msg_->init ();
+        errno_assert (rc == 0);
+        return 0;
+    }
+
+    //  Ignore the MORE flag
+    msg_->reset_flags (msg_t::more);
+
+    //  This is the last part of the message.
+    more_out = false;
+
+    //  Push the message into the pipe. If there's no out pipe, just drop it.
+    if (current_out) {
+
+        // Close the remote connection if user has asked to do so
+        // by sending zero length message.
+        // Pending messages in the pipe will be dropped (on receiving term- ack)
+        if (msg_->size () == 0) {
+            current_out->terminate (false);
+            int rc = msg_->close ();
+            errno_assert (rc == 0);
+            rc = msg_->init ();
+            errno_assert (rc == 0);
+            current_out = NULL;
+            return 0;
+        }
+        bool ok = current_out->write (msg_);
+        if (likely (ok))
+            current_out->flush ();
+        current_out = NULL;
+    }
+    else {
+        int rc = msg_->close ();
+        errno_assert (rc == 0);
+    }
+
+    //  Detach the message from the data buffer.
+    int rc = msg_->init ();
+    errno_assert (rc == 0);
+
+    return 0;
+}
+
+int zmq::stream_t::xsetsockopt (int option_, const void *optval_,
+    size_t optvallen_)
+{
+    bool is_int = (optvallen_ == sizeof (int));
+    int value = 0;
+    if (is_int) memcpy(&value, optval_, sizeof (int));
+
+    switch (option_) {
+        case ZMQ_CONNECT_ROUTING_ID:
+            if (optval_ && optvallen_) {
+                connect_routing_id.assign ((char*) optval_, optvallen_);
+                return 0;
+            }
+            break;
+
+        case ZMQ_STREAM_NOTIFY:
+            if (is_int && (value == 0 || value == 1)) {
+                options.raw_notify = (value != 0);
+                return 0;
+            }
+            break;
+
+        default:
+            break;
+    }
+    errno = EINVAL;
+    return -1;
+}
+
+int zmq::stream_t::xrecv (msg_t *msg_)
+{
+    if (prefetched) {
+        if (!routing_id_sent) {
+            int rc = msg_->move (prefetched_routing_id);
+            errno_assert (rc == 0);
+            routing_id_sent = true;
+        }
+        else {
+            int rc = msg_->move (prefetched_msg);
+            errno_assert (rc == 0);
+            prefetched = false;
+        }
+        return 0;
+    }
+
+    pipe_t *pipe = NULL;
+    int rc = fq.recvpipe (&prefetched_msg, &pipe);
+    if (rc != 0)
+        return -1;
+
+    zmq_assert (pipe != NULL);
+    zmq_assert ((prefetched_msg.flags () & msg_t::more) == 0);
+
+    //  We have received a frame with TCP data.
+    //  Rather than sending this frame, we keep it in prefetched
+    //  buffer and send a frame with peer's ID.
+    const blob_t &routing_id = pipe->get_routing_id ();
+    rc = msg_->close();
+    errno_assert (rc == 0);
+    rc = msg_->init_size (routing_id.size ());
+    errno_assert (rc == 0);
+
+    // forward metadata (if any)
+    metadata_t *metadata = prefetched_msg.metadata();
+    if (metadata)
+        msg_->set_metadata(metadata);
+
+    memcpy (msg_->data (), routing_id.data (), routing_id.size ());
+    msg_->set_flags (msg_t::more);
+
+    prefetched = true;
+    routing_id_sent = true;
+
+    return 0;
+}
+
+bool zmq::stream_t::xhas_in ()
+{
+    //  We may already have a message pre-fetched.
+    if (prefetched)
+        return true;
+
+    //  Try to read the next message.
+    //  The message, if read, is kept in the pre-fetch buffer.
+    pipe_t *pipe = NULL;
+    int rc = fq.recvpipe (&prefetched_msg, &pipe);
+    if (rc != 0)
+        return false;
+
+    zmq_assert (pipe != NULL);
+    zmq_assert ((prefetched_msg.flags () & msg_t::more) == 0);
+
+    const blob_t &routing_id = pipe->get_routing_id ();
+    rc = prefetched_routing_id.init_size (routing_id.size ());
+    errno_assert (rc == 0);
+
+    // forward metadata (if any)
+    metadata_t *metadata = prefetched_msg.metadata();
+    if (metadata)
+        prefetched_routing_id.set_metadata(metadata);
+
+    memcpy (prefetched_routing_id.data (), routing_id.data (), routing_id.size ());
+    prefetched_routing_id.set_flags (msg_t::more);
+
+    prefetched = true;
+    routing_id_sent = false;
+
+    return true;
+}
+
+bool zmq::stream_t::xhas_out ()
+{
+    //  In theory, STREAM socket is always ready for writing. Whether actual
+    //  attempt to write succeeds depends on which pipe the message is going
+    //  to be routed to.
+    return true;
+}
+
+void zmq::stream_t::identify_peer (pipe_t *pipe_)
+{
+    //  Always assign routing id for raw-socket
+    unsigned char buffer [5];
+    buffer [0] = 0;
+    blob_t routing_id;
+    if (connect_routing_id.length ()) {
+        routing_id.set ((unsigned char*) connect_routing_id.c_str(),
+            connect_routing_id.length ());
+        connect_routing_id.clear ();
+        outpipes_t::iterator it = outpipes.find (routing_id);
+        zmq_assert (it == outpipes.end ());
+    }
+    else {
+        put_uint32 (buffer + 1, next_integral_routing_id++);
+        routing_id.set (buffer, sizeof buffer);
+        memcpy (options.routing_id, routing_id.data (), routing_id.size ());
+        options.routing_id_size = (unsigned char) routing_id.size ();
+    }
+    pipe_->set_router_socket_routing_id (routing_id);
+    //  Add the record into output pipes lookup table
+    outpipe_t outpipe = {pipe_, true};
+    const bool ok = outpipes.ZMQ_MAP_INSERT_OR_EMPLACE (
+        ZMQ_MOVE(routing_id), outpipe).second;
+    zmq_assert (ok);
+}