libzmq 0.0.1

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

@@ -0,0 +1,72 @@
+/*
+    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_TCP_SOCKET_HPP_INCLUDED__
+#define __ZMQ_TCP_SOCKET_HPP_INCLUDED__
+
+#include "fd.hpp"
+#include "stdint.hpp"
+
+namespace zmq
+{
+
+    //  The class encapsulating simple TCP read/write socket.
+
+    class tcp_socket_t
+    {
+    public:
+
+        tcp_socket_t ();
+        ~tcp_socket_t ();
+
+        //  Associates a socket with a native socket descriptor.
+        int open (fd_t fd_, uint64_t sndbuf_, uint64_t rcvbuf_);
+         
+        //  Closes the underlying socket.
+        int close ();
+
+        //  Returns the underlying socket. Returns retired_fd when the socket
+        //  is in the closed state.
+        fd_t get_fd ();
+
+        //  Writes data to the socket. Returns the number of bytes actually
+        //  written (even zero is to be considered to be a success). In case
+        //  of error or orderly shutdown by the other peer -1 is returned.
+        int write (const void *data, int size);
+
+        //  Reads data from the socket (up to 'size' bytes). Returns the number
+        //  of bytes actually read (even zero is to be considered to be
+        //  a success). In case of error or orderly shutdown by the other
+        //  peer -1 is returned.
+        int read (void *data, int size);
+
+    private:
+
+        //  Underlying socket.
+        fd_t s;
+
+        //  Disable copy construction of tcp_socket.
+        tcp_socket_t (const tcp_socket_t&);
+        const tcp_socket_t &operator = (const tcp_socket_t&);
+    };
+
+}
+
+#endif

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

@@ -0,0 +1,97 @@
+/*
+    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 "thread.hpp"
+#include "err.hpp"
+#include "platform.hpp"
+
+#ifdef ZMQ_HAVE_WINDOWS
+
+extern "C"
+{
+    static unsigned int __stdcall thread_routine (void *arg_)
+    {
+        zmq::thread_t *self = (zmq::thread_t*) arg_;
+        self->tfn (self->arg);
+        return 0;
+    }
+}
+
+void zmq::thread_t::start (thread_fn *tfn_, void *arg_)
+{
+    tfn = tfn_;
+    arg =arg_;
+    descriptor = (HANDLE) _beginthreadex (NULL, 0,
+        &::thread_routine, this, 0 , NULL);
+    win_assert (descriptor != NULL);    
+}
+
+void zmq::thread_t::stop ()
+{
+    DWORD rc = WaitForSingleObject (descriptor, INFINITE);
+    win_assert (rc != WAIT_FAILED);
+    BOOL rc2 = CloseHandle (descriptor);
+    win_assert (rc2 != 0);
+}
+
+#else
+
+#include <signal.h>
+
+extern "C"
+{
+    static void *thread_routine (void *arg_)
+    {
+    #if !defined ZMQ_HAVE_OPENVMS
+        //  Following code will guarantee more predictable latecnies as it'll
+        //  disallow any signal handling in the I/O thread.
+        sigset_t signal_set;
+        int rc = sigfillset (&signal_set);
+        errno_assert (rc == 0);
+        rc = pthread_sigmask (SIG_BLOCK, &signal_set, NULL);
+        errno_assert (rc == 0);
+    #endif
+
+        zmq::thread_t *self = (zmq::thread_t*) arg_;   
+        self->tfn (self->arg);
+        return NULL;
+    }
+}
+
+void zmq::thread_t::start (thread_fn *tfn_, void *arg_)
+{
+    tfn = tfn_;
+    arg =arg_;
+    int rc = pthread_create (&descriptor, NULL, thread_routine, this);
+    errno_assert (rc == 0);
+}
+
+void zmq::thread_t::stop ()
+{
+    int rc = pthread_join (descriptor, NULL);
+    errno_assert (rc == 0);
+}
+
+#endif
+
+
+
+
+

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

@@ -0,0 +1,78 @@
+/*
+    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_THREAD_HPP_INCLUDED__
+#define __ZMQ_THREAD_HPP_INCLUDED__
+
+#include "platform.hpp"
+
+#ifdef ZMQ_HAVE_WINDOWS
+#include "windows.hpp"
+#else
+#include <pthread.h>
+#endif
+
+namespace zmq
+{
+
+    typedef void (thread_fn) (void*);
+
+    //  Class encapsulating OS thread. Thread initiation/termination is done
+    //  using special functions rather than in constructor/destructor so that
+    //  thread isn't created during object construction by accident, causing
+    //  newly created thread to access half-initialised object. Same applies
+    //  to the destruction process: Thread should be terminated before object
+    //  destruction begins, otherwise it can access half-destructed object.
+
+    class thread_t
+    {
+    public:
+
+        inline thread_t ()
+        {
+        }
+
+        //  Creates OS thread. 'tfn' is main thread function. It'll be passed
+        //  'arg' as an argument.
+        void start (thread_fn *tfn_, void *arg_);
+
+        //  Waits for thread termination.
+        void stop ();
+
+        //  These are internal members. They should be private, however then
+        //  they would not be accessible from the main C routine of the thread.
+        thread_fn *tfn;
+        void *arg;
+        
+    private:
+
+#ifdef ZMQ_HAVE_WINDOWS
+        HANDLE descriptor;
+#else
+        pthread_t descriptor;
+#endif
+
+        thread_t (const thread_t&);
+        const thread_t &operator = (const thread_t&);
+    };
+
+}
+
+#endif

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

@@ -0,0 +1,41 @@
+/*
+    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 "transient_session.hpp"
+
+zmq::transient_session_t::transient_session_t (class io_thread_t *io_thread_,
+      class socket_base_t *socket_, const options_t &options_) :
+    session_t (io_thread_, socket_, options_)
+{
+}
+
+zmq::transient_session_t::~transient_session_t ()
+{
+}
+
+void zmq::transient_session_t::attached (const blob_t &peer_identity_)
+{
+}
+
+void zmq::transient_session_t::detached ()
+{
+    //  There's no way to reestablish a transient session. Tear it down.
+    terminate ();
+}

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

@@ -0,0 +1,52 @@
+/*
+    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_TRANSIENT_SESSION_HPP_INCLUDED__
+#define __ZMQ_TRANSIENT_SESSION_HPP_INCLUDED__
+
+#include "session.hpp"
+
+namespace zmq
+{
+
+    //  Transient session is created by the listener when the connected peer
+    //  stays anonymous. Transient session is destroyed on disconnect.
+
+    class transient_session_t : public session_t
+    {
+    public:
+
+        transient_session_t (class io_thread_t *io_thread_,
+            class socket_base_t *socket_, const options_t &options_);
+        ~transient_session_t ();
+
+    private:
+
+        //  Handlers for events from session base class.
+        void attached (const blob_t &peer_identity_);
+        void detached ();
+
+        transient_session_t (const transient_session_t&);
+        const transient_session_t &operator = (const transient_session_t&);
+    };
+
+}
+
+#endif

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

@@ -0,0 +1,181 @@
+/*
+    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 <stdlib.h>
+
+#include <new>
+#include <algorithm>
+
+#include "platform.hpp"
+#if defined ZMQ_HAVE_WINDOWS
+#include "windows.hpp"
+#endif
+
+#include "err.hpp"
+#include "trie.hpp"
+
+zmq::trie_t::trie_t () :
+    refcnt (0),
+    min (0),
+    count (0)
+{
+}
+
+zmq::trie_t::~trie_t ()
+{
+    if (count == 1)
+        delete next.node;
+    else if (count > 1) {
+        for (unsigned short i = 0; i != count; ++i)
+            if (next.table [i])
+                delete next.table [i];
+        free (next.table);
+    }
+}
+
+void zmq::trie_t::add (unsigned char *prefix_, size_t size_)
+{
+    //  We are at the node corresponding to the prefix. We are done.
+    if (!size_) {
+        ++refcnt;
+        return;
+    }
+
+    unsigned char c = *prefix_;
+    if (c < min || c >= min + count) {
+
+        //  The character is out of range of currently handled
+        //  charcters. We have to extend the table.
+        if (!count) {
+            min = c;
+            count = 1;
+            next.node = NULL;
+        }
+        else if (count == 1) {
+            unsigned char oldc = min;
+            trie_t *oldp = next.node;
+            count = (min < c ? c - min : min - c) + 1;
+            next.table = (trie_t**)
+                malloc (sizeof (trie_t*) * count);
+            alloc_assert (next.table);
+            for (unsigned short i = 0; i != count; ++i)
+                next.table [i] = 0;
+            min = std::min (min, c);
+            next.table [oldc - min] = oldp;
+        }
+        else if (min < c) {
+
+            //  The new character is above the current character range.
+            unsigned short old_count = count;
+            count = c - min + 1;
+            next.table = (trie_t**) realloc ((void*) next.table,
+                sizeof (trie_t*) * count);
+            zmq_assert (next.table);
+            for (unsigned short i = old_count; i != count; i++)
+                next.table [i] = NULL;
+        }
+        else {
+
+            //  The new character is below the current character range.
+            unsigned short old_count = count;
+            count = (min + old_count) - c;
+            next.table = (trie_t**) realloc ((void*) next.table,
+                sizeof (trie_t*) * count);
+            zmq_assert (next.table);
+            memmove (next.table + min - c, next.table,
+                old_count * sizeof (trie_t*));
+            for (unsigned short i = 0; i != min - c; i++)
+                next.table [i] = NULL;
+            min = c;
+        }
+    }
+
+    //  If next node does not exist, create one.
+    if (count == 1) {
+        if (!next.node) {
+            next.node = new (std::nothrow) trie_t;
+            alloc_assert (next.node);
+        }
+        next.node->add (prefix_ + 1, size_ - 1);
+    }
+    else {
+        if (!next.table [c - min]) {
+            next.table [c - min] = new (std::nothrow) trie_t;
+            alloc_assert (next.table [c - min]);
+        }
+        next.table [c - min]->add (prefix_ + 1, size_ - 1);
+    }
+}
+
+bool zmq::trie_t::rm (unsigned char *prefix_, size_t size_)
+{
+     if (!size_) {
+         if (!refcnt)
+             return false;
+         refcnt--;
+         return true;
+     }
+
+     unsigned char c = *prefix_;
+     if (!count || c < min || c >= min + count)
+         return false;
+
+     trie_t *next_node =
+         count == 1 ? next.node : next.table [c - min];
+
+     if (!next_node)
+         return false;
+
+     return next_node->rm (prefix_ + 1, size_ - 1);
+}
+
+bool zmq::trie_t::check (unsigned char *data_, size_t size_)
+{
+    //  This function is on critical path. It deliberately doesn't use
+    //  recursion to get a bit better performance.
+    trie_t *current = this;
+    while (true) {
+
+        //  We've found a corresponding subscription!
+        if (current->refcnt)
+            return true;
+
+        //  We've checked all the data and haven't found matching subscription.
+        if (!size_)
+            return false;
+
+        //  If there's no corresponding slot for the first character
+        //  of the prefix, the message does not match.
+        unsigned char c = *data_;
+        if (c < current->min || c >= current->min + current->count)
+            return false;
+
+        //  Move to the next character.
+        if (current->count == 1)
+            current = current->next.node;
+        else {
+            current = current->next.table [c - current->min];
+            if (!current)
+                return false;
+        }
+        data_++;
+        size_--;
+    }
+}