laag-libzmq 4.2.3.0

data/vendor/github.com/zeromq/libzmq/src/tweetnacl.h

@@ -0,0 +1,75 @@
+/*
+    Copyright (c) 2016-2017 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 TWEETNACL_H
+#define TWEETNACL_H
+
+#if defined (ZMQ_USE_TWEETNACL)
+
+#define crypto_box_SECRETKEYBYTES 32
+#define crypto_box_BOXZEROBYTES 16
+#define crypto_box_NONCEBYTES 24
+#define crypto_box_ZEROBYTES 32
+#define crypto_box_PUBLICKEYBYTES 32
+#define crypto_box_BEFORENMBYTES 32
+#define crypto_secretbox_KEYBYTES 32
+#define crypto_secretbox_NONCEBYTES 24
+#define crypto_secretbox_ZEROBYTES 32
+#define crypto_secretbox_BOXZEROBYTES 16
+typedef unsigned char u8;
+typedef unsigned long u32;
+typedef unsigned long long u64;
+typedef long long i64;
+typedef i64 gf[16];
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+void randombytes (unsigned char *, unsigned long long);
+//  Do not call manually! Use random_close from random.hpp
+int randombytes_close (void);
+//  Do not call manually! Use random_open from random.hpp
+int sodium_init (void);
+
+int crypto_box_keypair(u8 *y,u8 *x);
+int crypto_box_afternm(u8 *c,const u8 *m,u64 d,const u8 *n,const u8 *k);
+int crypto_box_open_afternm(u8 *m,const u8 *c,u64 d,const u8 *n,const u8 *k);
+int crypto_box(u8 *c,const u8 *m,u64 d,const u8 *n,const u8 *y,const u8 *x);
+int crypto_box_open(u8 *m,const u8 *c,u64 d,const u8 *n,const u8 *y,const u8 *x);
+int crypto_box_beforenm(u8 *k,const u8 *y,const u8 *x);
+int crypto_scalarmult_base(u8 *q,const u8 *n);
+int crypto_secretbox(u8 *c,const u8 *m,u64 d,const u8 *n,const u8 *k);
+int crypto_secretbox_open(u8 *m,const u8 *c,u64 d,const u8 *n,const u8 *k);
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+#endif

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

@@ -0,0 +1,172 @@
+/*
+    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 <string>
+#include <sstream>
+
+#include "macros.hpp"
+#include "udp_address.hpp"
+#include "stdint.hpp"
+#include "err.hpp"
+#include "ip.hpp"
+
+#ifndef ZMQ_HAVE_WINDOWS
+#include <sys/types.h>
+#include <arpa/inet.h>
+#include <netdb.h>
+#include <ctype.h>
+#endif
+
+zmq::udp_address_t::udp_address_t ()
+        : is_multicast(false)
+{
+    memset (&bind_address, 0, sizeof bind_address);
+    memset (&dest_address, 0, sizeof dest_address);
+}
+
+zmq::udp_address_t::~udp_address_t ()
+{
+}
+
+int zmq::udp_address_t::resolve (const char *name_, bool bind_)
+{
+    //  Find the ':' at end that separates address from the port number.
+    const char *delimiter = strrchr (name_, ':');
+    if (!delimiter) {
+        errno = EINVAL;
+        return -1;
+    }
+
+    //  Separate the address/port.
+    std::string addr_str (name_, delimiter - name_);
+    std::string port_str (delimiter + 1);
+
+    //  Parse the port number (0 is not a valid port).
+    uint16_t port = (uint16_t) atoi (port_str.c_str ());
+    if (port == 0) {
+        errno = EINVAL;
+        return -1;
+    }
+
+    dest_address.sin_family = AF_INET;
+    dest_address.sin_port = htons (port);
+
+    //  Only when the udp should bind we allow * as the address
+    if (addr_str == "*" && bind_)
+        dest_address.sin_addr.s_addr = htonl (INADDR_ANY);
+    else
+        dest_address.sin_addr.s_addr = inet_addr (addr_str.c_str ());
+
+    if (dest_address.sin_addr.s_addr == INADDR_NONE) {
+        errno = EINVAL;
+        return -1;
+    }
+
+    // we will check only first byte of IP
+    // and if it from 224 to 239, then it can
+    // represent multicast IP.
+    int i = dest_address.sin_addr.s_addr & 0xFF;
+    if(i >=  224 && i <= 239) {
+        multicast = dest_address.sin_addr;
+        is_multicast = true;
+    }
+    else
+        is_multicast = false;
+
+    iface.s_addr = htonl (INADDR_ANY);
+    if (iface.s_addr == INADDR_NONE) {
+        errno = EINVAL;
+        return -1;
+    }
+
+    //  If a should bind and not a multicast, the dest address
+    //  is actually the bind address
+    if (bind_ && !is_multicast)
+        bind_address = dest_address;
+    else {
+        bind_address.sin_family = AF_INET;
+        bind_address.sin_port = htons (port);
+        bind_address.sin_addr.s_addr = htonl (INADDR_ANY);
+    }
+
+    address = name_;
+
+    return 0;
+}
+
+int zmq::udp_address_t::to_string (std::string &addr_)
+{
+    addr_ = address;
+    return 0;
+}
+
+bool zmq::udp_address_t::is_mcast () const
+{
+    return is_multicast;
+}
+
+const sockaddr* zmq::udp_address_t::bind_addr () const
+{
+    return (sockaddr *) &bind_address;
+}
+
+socklen_t zmq::udp_address_t::bind_addrlen () const
+{
+    return sizeof (sockaddr_in);
+}
+
+const sockaddr* zmq::udp_address_t::dest_addr () const
+{
+    return (sockaddr *) &dest_address;
+}
+
+socklen_t zmq::udp_address_t::dest_addrlen () const
+{
+    return sizeof (sockaddr_in);
+}
+
+const in_addr zmq::udp_address_t::multicast_ip () const
+{
+    return multicast;
+}
+
+const in_addr zmq::udp_address_t::interface_ip () const
+{
+    return iface;
+}
+
+#if defined ZMQ_HAVE_WINDOWS
+unsigned short zmq::udp_address_t::family () const
+#else
+sa_family_t zmq::udp_address_t::family () const
+#endif
+{
+    return AF_INET;
+}

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

@@ -0,0 +1,78 @@
+/*
+    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_UDP_ADDRESS_HPP_INCLUDED__
+#define __ZMQ_UDP_ADDRESS_HPP_INCLUDED__
+
+#if !defined ZMQ_HAVE_WINDOWS
+#include <sys/socket.h>
+#include <netinet/in.h>
+#endif
+
+namespace zmq
+{
+    class udp_address_t
+    {
+    public:
+
+        udp_address_t ();
+        virtual ~udp_address_t ();
+
+        int resolve (const char *name_, bool receiver_);
+
+        //  The opposite to resolve()
+        virtual int to_string (std::string &addr_);
+
+#if defined ZMQ_HAVE_WINDOWS
+        unsigned short family () const;
+#else
+        sa_family_t family () const;
+#endif
+        const sockaddr *bind_addr () const;
+        socklen_t bind_addrlen () const;
+
+        const sockaddr *dest_addr () const;
+        socklen_t dest_addrlen () const;
+
+        bool is_mcast () const;
+
+        const in_addr multicast_ip () const;
+        const in_addr interface_ip () const;
+
+    private:
+        in_addr  multicast;
+        in_addr  iface;
+        sockaddr_in bind_address;
+        sockaddr_in dest_address;
+        bool is_multicast;
+        std::string address;
+    };
+}
+
+#endif

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

@@ -0,0 +1,394 @@
+/*
+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"
+
+#if !defined ZMQ_HAVE_WINDOWS
+#include <sys/types.h>
+#include <unistd.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#endif
+
+#include "udp_engine.hpp"
+#include "session_base.hpp"
+#include "v2_protocol.hpp"
+#include "err.hpp"
+#include "ip.hpp"
+
+zmq::udp_engine_t::udp_engine_t(const options_t &options_) :
+    plugged (false),
+    fd(-1),
+    session(NULL),
+    handle((handle_t)NULL),
+    address(NULL),
+    options(options_),
+    send_enabled(false),
+    recv_enabled(false)
+{
+}
+
+zmq::udp_engine_t::~udp_engine_t()
+{
+    zmq_assert (!plugged);
+
+    if (fd != retired_fd) {
+#ifdef ZMQ_HAVE_WINDOWS
+        int rc = closesocket (fd);
+        wsa_assert (rc != SOCKET_ERROR);
+#else
+        int rc = close (fd);
+        errno_assert (rc == 0);
+#endif
+        fd = retired_fd;
+    }
+}
+
+int zmq::udp_engine_t::init (address_t *address_, bool send_, bool recv_)
+{
+    zmq_assert (address_);
+    zmq_assert (send_ || recv_);
+    send_enabled = send_;
+    recv_enabled = recv_;
+    address = address_;
+
+    fd = open_socket (address->resolved.udp_addr->family (), SOCK_DGRAM, IPPROTO_UDP);
+    if (fd == retired_fd)
+        return -1;
+
+    unblock_socket (fd);
+
+    return 0;
+}
+
+void zmq::udp_engine_t::plug (io_thread_t* io_thread_, session_base_t *session_)
+{
+    zmq_assert (!plugged);
+    plugged = true;
+
+    zmq_assert (!session);
+    zmq_assert (session_);
+    session = session_;
+
+    //  Connect to I/O threads poller object.
+    io_object_t::plug (io_thread_);
+    handle = add_fd (fd);
+
+    // Bind the socket to a device if applicable
+    if (!options.bound_device.empty ())
+        bind_to_device (fd, options.bound_device);
+
+    if (send_enabled) {
+        if (!options.raw_socket) {
+            out_address = address->resolved.udp_addr->dest_addr ();
+            out_addrlen = address->resolved.udp_addr->dest_addrlen ();
+        }
+        else {
+            out_address = (sockaddr *) &raw_address;
+            out_addrlen = sizeof (sockaddr_in);
+        }
+
+        set_pollout (handle);
+    }
+
+    if (recv_enabled) {
+        int on = 1;
+        int rc = setsockopt (fd, SOL_SOCKET, SO_REUSEADDR, (char *) &on, sizeof (on));
+#ifdef ZMQ_HAVE_WINDOWS
+        wsa_assert (rc != SOCKET_ERROR);
+#else
+        errno_assert (rc == 0);
+#endif
+
+        rc = bind (fd, address->resolved.udp_addr->bind_addr (),
+                       address->resolved.udp_addr->bind_addrlen ());
+#ifdef ZMQ_HAVE_WINDOWS
+        wsa_assert (rc != SOCKET_ERROR);
+#else
+        errno_assert (rc == 0);
+#endif
+
+        if (address->resolved.udp_addr->is_mcast ()) {
+            struct ip_mreq mreq;
+            mreq.imr_multiaddr = address->resolved.udp_addr->multicast_ip ();
+            mreq.imr_interface = address->resolved.udp_addr->interface_ip ();
+            rc = setsockopt (fd, IPPROTO_IP, IP_ADD_MEMBERSHIP, (char*) &mreq, sizeof (mreq));
+#ifdef ZMQ_HAVE_WINDOWS
+            wsa_assert (rc != SOCKET_ERROR);
+#else
+            errno_assert (rc == 0);
+#endif
+        }
+        set_pollin (handle);
+
+        //  Call restart output to drop all join/leave commands
+        restart_output ();
+    }
+}
+
+void zmq::udp_engine_t::terminate()
+{
+    zmq_assert (plugged);
+    plugged = false;
+
+    rm_fd (handle);
+
+    //  Disconnect from I/O threads poller object.
+    io_object_t::unplug ();
+
+    delete this;
+}
+
+void zmq::udp_engine_t::sockaddr_to_msg (zmq::msg_t *msg, sockaddr_in* addr)
+{
+    char* name = inet_ntoa(addr->sin_addr);
+
+    char port[6];
+    sprintf (port, "%d", (int) ntohs (addr->sin_port));
+
+    int size = (int) strlen (name) + (int) strlen (port) + 1 + 1; //  Colon + NULL
+    int rc = msg->init_size (size);
+    errno_assert (rc == 0);
+    msg->set_flags (msg_t::more);
+    char *address = (char*)msg->data ();
+
+    strcpy (address, name);
+    strcat (address, ":");
+    strcat (address, port);
+}
+
+int zmq::udp_engine_t::resolve_raw_address (char *name_, size_t length_)
+{
+    memset (&raw_address, 0, sizeof raw_address);
+
+    const char *delimiter = NULL;
+
+    // Find delimiter, cannot use memrchr as it is not supported on windows
+    if (length_ != 0) {
+        int chars_left = (int) length_;
+        char *current_char = name_ + length_;
+        do {
+            if (*(--current_char) == ':') {
+                delimiter = current_char;
+                break;
+            }
+        } while (--chars_left != 0);
+    }
+
+    if (!delimiter) {
+        errno = EINVAL;
+        return -1;
+    }
+
+    std::string addr_str (name_, delimiter - name_);
+    std::string port_str (delimiter + 1, name_ + length_ - delimiter - 1);
+
+    //  Parse the port number (0 is not a valid port).
+    uint16_t port = (uint16_t) atoi (port_str.c_str ());
+    if (port == 0) {
+        errno = EINVAL;
+        return -1;
+    }
+
+    raw_address.sin_family = AF_INET;
+    raw_address.sin_port = htons (port);
+    raw_address.sin_addr.s_addr = inet_addr (addr_str.c_str ());
+
+    if (raw_address.sin_addr.s_addr == INADDR_NONE) {
+        errno = EINVAL;
+        return -1;
+    }
+
+    return 0;
+}
+
+void zmq::udp_engine_t::out_event()
+{
+    msg_t group_msg;
+    int rc = session->pull_msg (&group_msg);
+    errno_assert (rc == 0 || (rc == -1 && errno == EAGAIN));
+
+    if (rc == 0) {
+        msg_t body_msg;
+        rc = session->pull_msg (&body_msg);
+
+        size_t group_size = group_msg.size ();
+        size_t body_size = body_msg.size ();
+        size_t size;
+
+        if (options.raw_socket) {
+            rc = resolve_raw_address ((char*) group_msg.data(), group_size);
+
+            //  We discard the message if address is not valid
+            if (rc != 0) {
+                rc = group_msg.close ();
+                errno_assert (rc == 0);
+
+                body_msg.close ();
+                errno_assert (rc == 0);
+
+                return;
+            }
+
+            size = body_size;
+
+            memcpy (out_buffer, body_msg.data (), body_size);
+        }
+        else {
+            size = group_size + body_size + 1;
+
+            // TODO: check if larger than maximum size
+            out_buffer[0] = (unsigned char) group_size;
+            memcpy (out_buffer + 1, group_msg.data (), group_size);
+            memcpy (out_buffer + 1 + group_size, body_msg.data (), body_size);
+        }
+
+        rc = group_msg.close ();
+        errno_assert (rc == 0);
+
+        body_msg.close ();
+        errno_assert (rc == 0);
+
+#ifdef ZMQ_HAVE_WINDOWS
+        rc = sendto (fd, (const char *) out_buffer, (int) size, 0,
+            out_address, (int) out_addrlen);
+        wsa_assert (rc != SOCKET_ERROR);
+#else
+        rc = sendto (fd, out_buffer, size, 0, out_address, out_addrlen);
+        errno_assert (rc != -1);
+#endif
+    }
+    else
+       reset_pollout (handle);
+}
+
+const char *zmq::udp_engine_t::get_endpoint () const
+{
+    return "";
+}
+
+void zmq::udp_engine_t::restart_output()
+{
+    //  If we don't support send we just drop all messages
+    if (!send_enabled) {
+        msg_t msg;
+        while (session->pull_msg (&msg) == 0)
+            msg.close ();
+    }
+    else {
+        set_pollout(handle);
+        out_event ();
+    }
+}
+
+void zmq::udp_engine_t::in_event()
+{
+  struct sockaddr_in in_address;
+  socklen_t in_addrlen = sizeof(sockaddr_in);
+#ifdef ZMQ_HAVE_WINDOWS
+    int nbytes = recvfrom(fd, (char*) in_buffer, MAX_UDP_MSG, 0, (sockaddr*) &in_address, &in_addrlen);
+    const int last_error = WSAGetLastError();
+    if (nbytes == SOCKET_ERROR) {
+        wsa_assert(
+            last_error == WSAENETDOWN ||
+            last_error == WSAENETRESET ||
+            last_error == WSAEWOULDBLOCK);
+        return;
+    }
+#else
+    int nbytes = recvfrom(fd, in_buffer, MAX_UDP_MSG, 0, (sockaddr*) &in_address, &in_addrlen);
+    if (nbytes == -1) {
+        errno_assert(errno != EBADF
+            && errno != EFAULT
+            && errno != ENOMEM
+            && errno != ENOTSOCK);
+        return;
+    }
+#endif
+    int rc;
+    int body_size;
+    int body_offset;
+    msg_t msg;
+
+    if (options.raw_socket) {
+        sockaddr_to_msg (&msg, &in_address);
+
+        body_size = nbytes;
+        body_offset = 0;
+    }
+    else {
+        char* group_buffer = (char *)in_buffer + 1;
+        int group_size = in_buffer[0];
+
+        rc = msg.init_size (group_size);
+        errno_assert (rc == 0);
+        msg.set_flags (msg_t::more);
+        memcpy (msg.data (), group_buffer, group_size);
+
+        //  This doesn't fit, just ingore
+        if (nbytes - 1 < group_size)
+            return;
+
+        body_size = nbytes - 1 - group_size;
+        body_offset = 1 + group_size;
+    }
+
+    rc = session->push_msg (&msg);
+    errno_assert (rc == 0 || (rc == -1 && errno == EAGAIN));
+
+    //  Pipe is full
+    if (rc != 0) {
+        rc = msg.close ();
+        errno_assert (rc == 0);
+
+        reset_pollin (handle);
+        return;
+    }
+
+    rc = msg.close ();
+    errno_assert (rc == 0);
+    rc = msg.init_size (body_size);
+    errno_assert (rc == 0);
+    memcpy (msg.data (), in_buffer + body_offset, body_size);
+    rc = session->push_msg (&msg);
+    errno_assert (rc == 0);
+    rc = msg.close ();
+    errno_assert (rc == 0);
+    session->flush ();
+}
+
+void zmq::udp_engine_t::restart_input()
+{
+    if (!recv_enabled)
+        return;
+
+    set_pollin (handle);
+    in_event ();
+}