libzmq 0.0.1

data/libzmq/zeromq-2.1.7/src/object.hpp

@@ -0,0 +1,127 @@
+/*
+    Copyright (c) 2007-2011 iMatix Corporation
+    Copyright (c) 2007-2011 Other contributors as noted in the AUTHORS file
+
+    This file is part of 0MQ.
+
+    0MQ is free software; you can redistribute it and/or modify it under
+    the terms of the GNU Lesser General Public License as published by
+    the Free Software Foundation; either version 3 of the License, or
+    (at your option) any later version.
+
+    0MQ 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_OBJECT_HPP_INCLUDED__
+#define __ZMQ_OBJECT_HPP_INCLUDED__
+
+#include "../include/zmq.h"
+
+#include "stdint.hpp"
+#include "blob.hpp"
+
+namespace zmq
+{
+    //  Base class for all objects that participate in inter-thread
+    //  communication.
+
+    class object_t
+    {
+    public:
+
+        object_t (class ctx_t *ctx_, uint32_t tid_);
+        object_t (object_t *parent_);
+        virtual ~object_t ();
+
+        uint32_t get_tid ();
+        ctx_t *get_ctx ();
+        void process_command (struct command_t &cmd_);
+
+    protected:
+
+        //  Using following function, socket is able to access global
+        //  repository of inproc endpoints.
+        int register_endpoint (const char *addr_, struct endpoint_t &endpoint_);
+        void unregister_endpoints (class socket_base_t *socket_);
+        struct endpoint_t find_endpoint (const char *addr_);
+        void destroy_socket (class socket_base_t *socket_);
+
+        //  Logs an message.
+        void log (const char *format_, ...);
+
+        //  Chooses least loaded I/O thread.
+        class io_thread_t *choose_io_thread (uint64_t affinity_);
+
+        //  Derived object can use these functions to send commands
+        //  to other objects.
+        void send_stop ();
+        void send_plug (class own_t *destination_,
+            bool inc_seqnum_ = true);
+        void send_own (class own_t *destination_,
+            class own_t *object_);
+        void send_attach (class session_t *destination_,
+             struct i_engine *engine_, const blob_t &peer_identity_,
+             bool inc_seqnum_ = true);
+        void send_bind (class own_t *destination_,
+             class reader_t *in_pipe_, class writer_t *out_pipe_,
+             const blob_t &peer_identity_, bool inc_seqnum_ = true);
+        void send_activate_reader (class reader_t *destination_);
+        void send_activate_writer (class writer_t *destination_,
+             uint64_t msgs_read_);
+        void send_pipe_term (class writer_t *destination_);
+        void send_pipe_term_ack (class reader_t *destination_);
+        void send_term_req (class own_t *destination_,
+            class own_t *object_);
+        void send_term (class own_t *destination_, int linger_);
+        void send_term_ack (class own_t *destination_);
+        void send_reap (class socket_base_t *socket_);
+        void send_reaped ();
+        void send_done ();
+
+        //  These handlers can be overloaded by the derived objects. They are
+        //  called when command arrives from another thread.
+        virtual void process_stop ();
+        virtual void process_plug ();
+        virtual void process_own (class own_t *object_);
+        virtual void process_attach (struct i_engine *engine_,
+            const blob_t &peer_identity_);
+        virtual void process_bind (class reader_t *in_pipe_,
+            class writer_t *out_pipe_, const blob_t &peer_identity_);
+        virtual void process_activate_reader ();
+        virtual void process_activate_writer (uint64_t msgs_read_);
+        virtual void process_pipe_term ();
+        virtual void process_pipe_term_ack ();
+        virtual void process_term_req (class own_t *object_);
+        virtual void process_term (int linger_);
+        virtual void process_term_ack ();
+        virtual void process_reap (class socket_base_t *socket_);
+        virtual void process_reaped ();
+
+        //  Special handler called after a command that requires a seqnum
+        //  was processed. The implementation should catch up with its counter
+        //  of processed commands here.
+        virtual void process_seqnum ();
+
+    private:
+
+        //  Context provides access to the global state.
+        class ctx_t *ctx;
+
+        //  Thread ID of the thread the object belongs to.
+        uint32_t tid;
+
+        void send_command (command_t &cmd_);
+
+        object_t (const object_t&);
+        const object_t &operator = (const object_t&);
+    };
+
+}
+
+#endif

data/libzmq/zeromq-2.1.7/src/options.cpp

@@ -0,0 +1,336 @@
+/*
+    Copyright (c) 2007-2011 iMatix Corporation
+    Copyright (c) 2007-2011 Other contributors as noted in the AUTHORS file
+
+    This file is part of 0MQ.
+
+    0MQ is free software; you can redistribute it and/or modify it under
+    the terms of the GNU Lesser General Public License as published by
+    the Free Software Foundation; either version 3 of the License, or
+    (at your option) any later version.
+
+    0MQ 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 <string.h>
+
+#include "../include/zmq.h"
+
+#include "options.hpp"
+#include "err.hpp"
+
+zmq::options_t::options_t () :
+    hwm (0),
+    swap (0),
+    affinity (0),
+    rate (40 * 1000),
+    recovery_ivl (10),
+    recovery_ivl_msec (-1),
+    use_multicast_loop (true),
+    sndbuf (0),
+    rcvbuf (0),
+    type (-1),
+    linger (-1),
+    reconnect_ivl (100),
+    reconnect_ivl_max (0),
+    backlog (100),
+    requires_in (false),
+    requires_out (false),
+    immediate_connect (true)
+{
+}
+
+int zmq::options_t::setsockopt (int option_, const void *optval_,
+    size_t optvallen_)
+{
+    switch (option_) {
+
+    case ZMQ_HWM:
+        if (optvallen_ != sizeof (uint64_t)) {
+            errno = EINVAL;
+            return -1;
+        }
+        hwm = *((uint64_t*) optval_);
+        return 0;
+
+    case ZMQ_SWAP:
+        if (optvallen_ != sizeof (int64_t) || *((int64_t*) optval_) < 0) {
+            errno = EINVAL;
+            return -1;
+        }
+        swap = *((int64_t*) optval_);
+        return 0;
+
+    case ZMQ_AFFINITY:
+        if (optvallen_ != sizeof (uint64_t)) {
+            errno = EINVAL;
+            return -1;
+        }
+        affinity = *((uint64_t*) optval_);
+        return 0;
+
+    case ZMQ_IDENTITY:
+
+        //  Empty identity is invalid as well as identity longer than
+        //  255 bytes. Identity starting with binary zero is invalid
+        //  as these are used for auto-generated identities.
+        if (optvallen_ < 1 || optvallen_ > 255 ||
+              *((const unsigned char*) optval_) == 0) {
+            errno = EINVAL;
+            return -1;
+        }
+        identity.assign ((const unsigned char*) optval_, optvallen_);
+        return 0;
+
+    case ZMQ_RATE:
+        if (optvallen_ != sizeof (int64_t) || *((int64_t*) optval_) < 0) {
+            errno = EINVAL;
+            return -1;
+        }
+        rate = (uint32_t) *((int64_t*) optval_);
+        return 0;
+        
+    case ZMQ_RECOVERY_IVL:
+        if (optvallen_ != sizeof (int64_t)  || *((int64_t*) optval_) < 0) {
+            errno = EINVAL;
+            return -1;
+        }
+        recovery_ivl = (uint32_t) *((int64_t*) optval_);
+        return 0;
+
+    case ZMQ_RECOVERY_IVL_MSEC:
+        if (optvallen_ != sizeof (int64_t)  || *((int64_t*) optval_) < 0) {
+            errno = EINVAL;
+            return -1;
+        }
+        recovery_ivl_msec = (int32_t) *((int64_t*) optval_);
+        return 0;
+
+    case ZMQ_MCAST_LOOP:
+        if (optvallen_ != sizeof (int64_t)) {
+            errno = EINVAL;
+            return -1;
+        }
+        if ((int64_t) *((int64_t*) optval_) == 0)
+            use_multicast_loop = false;
+        else if ((int64_t) *((int64_t*) optval_) == 1)
+            use_multicast_loop = true;
+        else {
+            errno = EINVAL;
+            return -1;
+        }
+        return 0;
+
+    case ZMQ_SNDBUF:
+        if (optvallen_ != sizeof (uint64_t)) {
+            errno = EINVAL;
+            return -1;
+        }
+        sndbuf = *((uint64_t*) optval_);
+        return 0;
+
+    case ZMQ_RCVBUF:
+        if (optvallen_ != sizeof (uint64_t)) {
+            errno = EINVAL;
+            return -1;
+        }
+        rcvbuf = *((uint64_t*) optval_);
+        return 0;
+
+    case ZMQ_LINGER:
+        if (optvallen_ != sizeof (int)) {
+            errno = EINVAL;
+            return -1;
+        }
+        linger = *((int*) optval_);
+        return 0;
+
+    case ZMQ_RECONNECT_IVL:
+        if (optvallen_ != sizeof (int)) {
+            errno = EINVAL;
+            return -1;
+        }
+        if (*((int*) optval_) < 0) {
+            errno = EINVAL;
+            return -1;
+        }
+        reconnect_ivl = *((int*) optval_);
+        return 0;
+
+    case ZMQ_RECONNECT_IVL_MAX:
+        if (optvallen_ != sizeof (int)) {
+            errno = EINVAL;
+            return -1;
+        }
+        if (*((int*) optval_) < 0) {
+            errno = EINVAL;
+            return -1;
+        }
+        reconnect_ivl_max = *((int*) optval_);
+        return 0;
+
+    case ZMQ_BACKLOG:
+        if (optvallen_ != sizeof (int)) {
+            errno = EINVAL;
+            return -1;
+        }
+        backlog = *((int*) optval_);
+        return 0;
+
+    }
+
+    errno = EINVAL;
+    return -1;
+}
+
+int zmq::options_t::getsockopt (int option_, void *optval_, size_t *optvallen_)
+{
+    switch (option_) {
+
+    case ZMQ_HWM:
+        if (*optvallen_ < sizeof (uint64_t)) {
+            errno = EINVAL;
+            return -1;
+        }
+        *((uint64_t*) optval_) = hwm;
+        *optvallen_ = sizeof (uint64_t);
+        return 0;
+
+    case ZMQ_SWAP:
+        if (*optvallen_ < sizeof (int64_t)) {
+            errno = EINVAL;
+            return -1;
+        }
+        *((int64_t*) optval_) = swap;
+        *optvallen_ = sizeof (int64_t);
+        return 0;
+
+    case ZMQ_AFFINITY:
+        if (*optvallen_ < sizeof (uint64_t)) {
+            errno = EINVAL;
+            return -1;
+        }
+        *((uint64_t*) optval_) = affinity;
+        *optvallen_ = sizeof (uint64_t);
+        return 0;
+
+    case ZMQ_IDENTITY:
+        if (*optvallen_ < identity.size ()) {
+            errno = EINVAL;
+            return -1;
+        }
+        memcpy (optval_, identity.data (), identity.size ());
+        *optvallen_ = identity.size ();
+        return 0;
+
+
+    case ZMQ_RATE:
+        if (*optvallen_ < sizeof (int64_t)) {
+            errno = EINVAL;
+            return -1;
+        }
+        *((int64_t*) optval_) = rate;
+        *optvallen_ = sizeof (int64_t);
+        return 0;
+        
+    case ZMQ_RECOVERY_IVL:
+        if (*optvallen_ < sizeof (int64_t)) {
+            errno = EINVAL;
+            return -1;
+        }
+        *((int64_t*) optval_) = recovery_ivl;
+        *optvallen_ = sizeof (int64_t);
+        return 0;
+
+    case ZMQ_RECOVERY_IVL_MSEC:
+        if (*optvallen_ < sizeof (int64_t)) {
+            errno = EINVAL;
+            return -1;
+        }
+        *((int64_t*) optval_) = recovery_ivl_msec;
+        *optvallen_ = sizeof (int64_t);
+        return 0;
+
+    case ZMQ_MCAST_LOOP:
+        if (*optvallen_ < sizeof (int64_t)) {
+            errno = EINVAL;
+            return -1;
+        }
+        *((int64_t*) optval_) = use_multicast_loop ? 1 : 0;
+        *optvallen_ = sizeof (int64_t);
+        return 0;
+
+    case ZMQ_SNDBUF:
+        if (*optvallen_ < sizeof (uint64_t)) {
+            errno = EINVAL;
+            return -1;
+        }
+        *((uint64_t*) optval_) = sndbuf;
+        *optvallen_ = sizeof (uint64_t);
+        return 0;
+
+    case ZMQ_RCVBUF:
+        if (*optvallen_ < sizeof (uint64_t)) {
+            errno = EINVAL;
+            return -1;
+        }
+        *((uint64_t*) optval_) = rcvbuf;
+        *optvallen_ = sizeof (uint64_t);
+        return 0;
+
+    case ZMQ_TYPE:
+        if (*optvallen_ < sizeof (int)) {
+            errno = EINVAL;
+            return -1;
+        }
+        *((int*) optval_) = type;
+        *optvallen_ = sizeof (int);
+        return 0;
+
+    case ZMQ_LINGER:
+        if (*optvallen_ < sizeof (int)) {
+            errno = EINVAL;
+            return -1;
+        }
+        *((int*) optval_) = linger;
+        *optvallen_ = sizeof (int);
+        return 0;
+
+    case ZMQ_RECONNECT_IVL:
+        if (*optvallen_ < sizeof (int)) {
+            errno = EINVAL;
+            return -1;
+        }
+        *((int*) optval_) = reconnect_ivl;
+        *optvallen_ = sizeof (int);
+        return 0;
+
+    case ZMQ_RECONNECT_IVL_MAX:
+        if (*optvallen_ < sizeof (int)) {
+            errno = EINVAL;
+            return -1;
+        }
+        *((int*) optval_) = reconnect_ivl_max;
+        *optvallen_ = sizeof (int);
+        return 0;
+
+    case ZMQ_BACKLOG:
+        if (*optvallen_ < sizeof (int)) {
+            errno = EINVAL;
+            return -1;
+        }
+        *((int*) optval_) = backlog;
+        *optvallen_ = sizeof (int);
+        return 0;
+
+    }
+
+    errno = EINVAL;
+    return -1;
+}