laag-libzmq 4.2.3.0

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

@@ -0,0 +1,73 @@
+
+#ifndef __ZMQ_UDP_ENGINE_HPP_INCLUDED__
+#define __ZMQ_UDP_ENGINE_HPP_INCLUDED__
+
+#include "io_object.hpp"
+#include "i_engine.hpp"
+#include "address.hpp"
+#include "udp_address.hpp"
+#include "msg.hpp"
+
+#define MAX_UDP_MSG 8192
+
+namespace zmq
+{
+    class io_thread_t;
+    class session_base_t;
+
+    class udp_engine_t : public io_object_t, public i_engine
+    {
+        public:
+            udp_engine_t (const options_t &options_);
+            ~udp_engine_t ();
+
+            int init (address_t *address_, bool send_, bool recv_);
+
+            //  i_engine interface implementation.
+            //  Plug the engine to the session.
+            void plug (zmq::io_thread_t *io_thread_, class session_base_t *session_);
+
+            //  Terminate and deallocate the engine. Note that 'detached'
+            //  events are not fired on termination.
+            void terminate ();
+
+            //  This method is called by the session to signalise that more
+            //  messages can be written to the pipe.
+            void restart_input ();
+
+            //  This method is called by the session to signalise that there
+            //  are messages to send available.
+            void restart_output ();
+
+            void zap_msg_available () {};
+
+            void in_event ();
+            void out_event ();
+
+            const char *get_endpoint () const;
+
+        private:
+            int resolve_raw_address (char *addr_, size_t length_);
+            void sockaddr_to_msg (zmq::msg_t *msg, sockaddr_in* addr);
+
+            bool plugged;
+
+            fd_t fd;
+            session_base_t* session;
+            handle_t handle;
+            address_t *address;
+
+            options_t options;
+
+            sockaddr_in raw_address;
+            const struct sockaddr* out_address;
+            socklen_t out_addrlen;
+
+            unsigned char out_buffer[MAX_UDP_MSG];
+            unsigned char in_buffer[MAX_UDP_MSG];
+            bool send_enabled;
+            bool recv_enabled;
+    };
+}
+
+#endif

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

@@ -0,0 +1,153 @@
+/*
+    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 <stdlib.h>
+#include <string.h>
+#include <limits>
+
+#include "decoder.hpp"
+#include "v1_decoder.hpp"
+#include "likely.hpp"
+#include "wire.hpp"
+#include "err.hpp"
+
+zmq::v1_decoder_t::v1_decoder_t (size_t bufsize_, int64_t maxmsgsize_) :
+    c_single_allocator(bufsize_),
+    decoder_base_t <v1_decoder_t> (this),
+    maxmsgsize (maxmsgsize_)
+{
+    int rc = in_progress.init ();
+    errno_assert (rc == 0);
+
+    //  At the beginning, read one byte and go to one_byte_size_ready state.
+    next_step (tmpbuf, 1, &v1_decoder_t::one_byte_size_ready);
+}
+
+zmq::v1_decoder_t::~v1_decoder_t ()
+{
+    int rc = in_progress.close ();
+    errno_assert (rc == 0);
+}
+
+int zmq::v1_decoder_t::one_byte_size_ready (unsigned char const*)
+{
+    //  First byte of size is read. If it is 0xff read 8-byte size.
+    //  Otherwise allocate the buffer for message data and read the
+    //  message data into it.
+    if (*tmpbuf == 0xff)
+        next_step (tmpbuf, 8, &v1_decoder_t::eight_byte_size_ready);
+    else {
+
+        //  There has to be at least one byte (the flags) in the message).
+        if (!*tmpbuf) {
+            errno = EPROTO;
+            return -1;
+        }
+
+        if (maxmsgsize >= 0 && (int64_t) (*tmpbuf - 1) > maxmsgsize) {
+            errno = EMSGSIZE;
+            return -1;
+        }
+
+        int rc = in_progress.close();
+        assert(rc == 0);
+        rc = in_progress.init_size (*tmpbuf - 1);
+        if (rc != 0) {
+            errno_assert (errno == ENOMEM);
+            rc = in_progress.init ();
+            errno_assert (rc == 0);
+            errno = ENOMEM;
+            return -1;
+        }
+
+        next_step (tmpbuf, 1, &v1_decoder_t::flags_ready);
+    }
+    return 0;
+}
+
+int zmq::v1_decoder_t::eight_byte_size_ready (unsigned char const*)
+{
+    //  8-byte payload length is read. Allocate the buffer
+    //  for message body and read the message data into it.
+    const uint64_t payload_length = get_uint64 (tmpbuf);
+
+    //  There has to be at least one byte (the flags) in the message).
+    if (payload_length == 0) {
+        errno = EPROTO;
+        return -1;
+    }
+
+    //  Message size must not exceed the maximum allowed size.
+    if (maxmsgsize >= 0 && payload_length - 1 > (uint64_t) maxmsgsize) {
+        errno = EMSGSIZE;
+        return -1;
+    }
+
+    //  Message size must fit within range of size_t data type.
+    if (payload_length - 1 > std::numeric_limits <size_t>::max ()) {
+        errno = EMSGSIZE;
+        return -1;
+    }
+
+    const size_t msg_size = static_cast <size_t> (payload_length - 1);
+
+    int rc = in_progress.close();
+    assert(rc == 0);
+    rc = in_progress.init_size (msg_size);
+    if (rc != 0) {
+        errno_assert (errno == ENOMEM);
+        rc = in_progress.init ();
+        errno_assert (rc == 0);
+        errno = ENOMEM;
+        return -1;
+    }
+
+    next_step (tmpbuf, 1, &v1_decoder_t::flags_ready);
+    return 0;
+}
+
+int zmq::v1_decoder_t::flags_ready (unsigned char const*)
+{
+    //  Store the flags from the wire into the message structure.
+    in_progress.set_flags (tmpbuf [0] & msg_t::more);
+
+    next_step (in_progress.data (), in_progress.size (),
+        &v1_decoder_t::message_ready);
+
+    return 0;
+}
+
+int zmq::v1_decoder_t::message_ready (unsigned char const*)
+{
+    //  Message is completely read. Push it further and start reading
+    //  new message. (in_progress is a 0-byte message after this point.)
+    next_step (tmpbuf, 1, &v1_decoder_t::one_byte_size_ready);
+    return 1;
+}

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

@@ -0,0 +1,69 @@
+/*
+    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_V1_DECODER_HPP_INCLUDED__
+#define __ZMQ_V1_DECODER_HPP_INCLUDED__
+
+#include "decoder.hpp"
+
+namespace zmq
+{
+    //  Decoder for ZMTP/1.0 protocol. Converts data batches into messages.
+
+    class v1_decoder_t :
+            public zmq::c_single_allocator,
+            public decoder_base_t <v1_decoder_t>
+    {
+    public:
+
+        v1_decoder_t (size_t bufsize_, int64_t maxmsgsize_);
+        ~v1_decoder_t ();
+
+        virtual msg_t *msg () { return &in_progress; }
+
+    private:
+
+        int one_byte_size_ready (unsigned char const*);
+        int eight_byte_size_ready (unsigned char const*);
+        int flags_ready (unsigned char const*);
+        int message_ready (unsigned char const*);
+
+        unsigned char tmpbuf [8];
+        msg_t in_progress;
+
+        int64_t maxmsgsize;
+
+        v1_decoder_t (const v1_decoder_t&);
+        void operator = (const v1_decoder_t&);
+    };
+
+}
+
+#endif
+

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

@@ -0,0 +1,76 @@
+/*
+    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 "encoder.hpp"
+#include "v1_encoder.hpp"
+#include "likely.hpp"
+#include "wire.hpp"
+
+zmq::v1_encoder_t::v1_encoder_t (size_t bufsize_) :
+    encoder_base_t <v1_encoder_t> (bufsize_)
+{
+    //  Write 0 bytes to the batch and go to message_ready state.
+    next_step (NULL, 0, &v1_encoder_t::message_ready, true);
+}
+
+zmq::v1_encoder_t::~v1_encoder_t ()
+{
+}
+
+void zmq::v1_encoder_t::size_ready ()
+{
+    //  Write message body into the buffer.
+    next_step (in_progress->data (), in_progress->size (),
+        &v1_encoder_t::message_ready, true);
+}
+
+void zmq::v1_encoder_t::message_ready ()
+{
+    //  Get the message size.
+    size_t size = in_progress->size ();
+
+    //  Account for the 'flags' byte.
+    size++;
+
+    //  For messages less than 255 bytes long, write one byte of message size.
+    //  For longer messages write 0xff escape character followed by 8-byte
+    //  message size. In both cases 'flags' field follows.
+    if (size < 255) {
+        tmpbuf [0] = (unsigned char) size;
+        tmpbuf [1] = (in_progress->flags () & msg_t::more);
+        next_step (tmpbuf, 2, &v1_encoder_t::size_ready, false);
+    }
+    else {
+        tmpbuf [0] = 0xff;
+        put_uint64 (tmpbuf + 1, size);
+        tmpbuf [9] = (in_progress->flags () & msg_t::more);
+        next_step (tmpbuf, 10, &v1_encoder_t::size_ready, false);
+    }
+}

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

@@ -0,0 +1,59 @@
+/*
+    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_V1_ENCODER_HPP_INCLUDED__
+#define __ZMQ_V1_ENCODER_HPP_INCLUDED__
+
+#include "encoder.hpp"
+
+namespace zmq
+{
+    //  Encoder for ZMTP/1.0 protocol. Converts messages into data batches.
+
+    class v1_encoder_t : public encoder_base_t <v1_encoder_t>
+    {
+    public:
+
+        v1_encoder_t (size_t bufsize_);
+        ~v1_encoder_t ();
+
+    private:
+
+        void size_ready ();
+        void message_ready ();
+
+        unsigned char tmpbuf [10];
+
+        v1_encoder_t (const v1_encoder_t&);
+        const v1_encoder_t &operator = (const v1_encoder_t&);
+    };
+}
+
+#endif
+

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

@@ -0,0 +1,161 @@
+/*
+    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 <stdlib.h>
+#include <string.h>
+#include <cmath>
+
+#include "v2_protocol.hpp"
+#include "v2_decoder.hpp"
+#include "likely.hpp"
+#include "wire.hpp"
+#include "err.hpp"
+
+zmq::v2_decoder_t::v2_decoder_t (size_t bufsize_, int64_t maxmsgsize_) :
+    shared_message_memory_allocator( bufsize_),
+    decoder_base_t <v2_decoder_t, shared_message_memory_allocator> (this),
+    msg_flags (0),
+    maxmsgsize (maxmsgsize_)
+{
+    int rc = in_progress.init ();
+    errno_assert (rc == 0);
+
+    //  At the beginning, read one byte and go to flags_ready state.
+    next_step (tmpbuf, 1, &v2_decoder_t::flags_ready);
+}
+
+zmq::v2_decoder_t::~v2_decoder_t ()
+{
+    int rc = in_progress.close ();
+    errno_assert (rc == 0);
+}
+
+int zmq::v2_decoder_t::flags_ready (unsigned char const*)
+{
+    msg_flags = 0;
+    if (tmpbuf [0] & v2_protocol_t::more_flag)
+        msg_flags |= msg_t::more;
+    if (tmpbuf [0] & v2_protocol_t::command_flag)
+        msg_flags |= msg_t::command;
+
+    //  The payload length is either one or eight bytes,
+    //  depending on whether the 'large' bit is set.
+    if (tmpbuf [0] & v2_protocol_t::large_flag)
+        next_step (tmpbuf, 8, &v2_decoder_t::eight_byte_size_ready);
+    else
+        next_step (tmpbuf, 1, &v2_decoder_t::one_byte_size_ready);
+
+    return 0;
+}
+
+int zmq::v2_decoder_t::one_byte_size_ready (unsigned char const* read_from)
+{
+    return size_ready(tmpbuf[0], read_from);
+}
+
+int zmq::v2_decoder_t::eight_byte_size_ready (unsigned char const* read_from) {
+    //  The payload size is encoded as 64-bit unsigned integer.
+    //  The most significant byte comes first.
+    const uint64_t msg_size = get_uint64(tmpbuf);
+
+    return size_ready(msg_size, read_from);
+}
+
+int zmq::v2_decoder_t::size_ready(uint64_t msg_size, unsigned char const* read_pos) {
+    //  Message size must not exceed the maximum allowed size.
+    if (maxmsgsize >= 0)
+        if (unlikely (msg_size > static_cast <uint64_t> (maxmsgsize))) {
+            errno = EMSGSIZE;
+            return -1;
+        }
+
+    //  Message size must fit into size_t data type.
+    if (unlikely (msg_size != static_cast <size_t> (msg_size))) {
+        errno = EMSGSIZE;
+        return -1;
+    }
+
+    int rc = in_progress.close();
+    assert(rc == 0);
+
+    // the current message can exceed the current buffer. We have to copy the buffer
+    // data into a new message and complete it in the next receive.
+
+    if (unlikely ((unsigned char*)read_pos + msg_size > (data() + size())))
+    {
+        // a new message has started, but the size would exceed the pre-allocated arena
+        // this happens every time when a message does not fit completely into the buffer
+        rc = in_progress.init_size (static_cast <size_t> (msg_size));
+    }
+    else
+    {
+        // construct message using n bytes from the buffer as storage
+        // increase buffer ref count
+        // if the message will be a large message, pass a valid refcnt memory location as well
+        rc = in_progress.init ((unsigned char *) read_pos, static_cast <size_t> (msg_size),
+                                shared_message_memory_allocator::call_dec_ref, buffer(),
+                                provide_content ());
+
+        // For small messages, data has been copied and refcount does not have to be increased
+        if (in_progress.is_zcmsg())
+        {
+            advance_content();
+            inc_ref();
+        }
+    }
+
+    if (unlikely (rc)) {
+        errno_assert (errno == ENOMEM);
+        rc = in_progress.init ();
+        errno_assert (rc == 0);
+        errno = ENOMEM;
+        return -1;
+    }
+
+    in_progress.set_flags (msg_flags);
+    // this sets read_pos to
+    // the message data address if the data needs to be copied
+    // for small message / messages exceeding the current buffer
+    // or
+    // to the current start address in the buffer because the message
+    // was constructed to use n bytes from the address passed as argument
+    next_step (in_progress.data (), in_progress.size (),
+        &v2_decoder_t::message_ready);
+
+    return 0;
+}
+
+int zmq::v2_decoder_t::message_ready (unsigned char const*)
+{
+    //  Message is completely read. Signal this to the caller
+    //  and prepare to decode next message.
+    next_step (tmpbuf, 1, &v2_decoder_t::flags_ready);
+    return 1;
+}