laag-libzmq 4.2.3.0

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

@@ -0,0 +1,70 @@
+/*
+    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 "mechanism_base.hpp"
+#include "session_base.hpp"
+
+zmq::mechanism_base_t::mechanism_base_t (session_base_t *const session_,
+                                         const options_t &options_) :
+    mechanism_t (options_),
+    session (session_)
+{
+
+}
+
+int zmq::mechanism_base_t::check_basic_command_structure (msg_t *msg_)
+{
+    if (msg_->size () <= 1 || msg_->size () <= ((uint8_t *) msg_->data ())[0]) {
+        session->get_socket ()->event_handshake_failed_protocol (
+          session->get_endpoint (),
+          ZMQ_PROTOCOL_ERROR_ZMTP_MALFORMED_COMMAND_UNSPECIFIED);
+        errno = EPROTO;
+        return -1;
+    }
+    return 0;
+}
+
+void zmq::mechanism_base_t::handle_error_reason (const char *error_reason,
+                                                 size_t error_reason_len)
+{
+    if (error_reason_len == 3 && error_reason[1] == '0'
+        && error_reason[2] == '0' && error_reason[0] >= '3'
+        && error_reason[0] <= '5') {
+        // it is a ZAP status code, so emit an authentication failure event
+        session->get_socket ()->event_handshake_failed_auth (
+          session->get_endpoint (), (error_reason[0] - '0') * 100);
+    }
+}
+
+bool zmq::mechanism_base_t::zap_required() const
+{
+    return !options.zap_domain.empty ();
+}

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

@@ -0,0 +1,53 @@
+/*
+    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_MECHANISM_BASE_HPP_INCLUDED__
+#define __ZMQ_MECHANISM_BASE_HPP_INCLUDED__
+
+#include "mechanism.hpp"
+
+namespace zmq
+{
+class mechanism_base_t : public mechanism_t
+{
+  protected:
+    mechanism_base_t (session_base_t *const session_,
+                      const options_t &options_);
+
+    session_base_t *const session;
+
+    int check_basic_command_structure (msg_t *msg_);
+
+    void handle_error_reason (const char *error_reason, size_t error_reason_len);
+
+    bool zap_required() const;
+};
+}
+
+#endif

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

@@ -0,0 +1,62 @@
+/*
+    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 "metadata.hpp"
+
+zmq::metadata_t::metadata_t (const dict_t &dict) :
+    ref_cnt (1),
+    dict (dict)
+{
+}
+
+const char *zmq::metadata_t::get (const std::string &property) const
+{
+    dict_t::const_iterator it = dict.find (property);
+    if (it == dict.end())
+    {
+        /** \todo remove this when support for the deprecated name "Identity" is dropped */
+        if (property == "Identity")
+            return get (ZMQ_MSG_PROPERTY_ROUTING_ID);
+
+        return NULL;
+    }
+    else
+        return it->second.c_str ();
+}
+
+void zmq::metadata_t::add_ref ()
+{
+    ref_cnt.add (1);
+}
+
+bool zmq::metadata_t::drop_ref ()
+{
+    return !ref_cnt.sub (1);
+}

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

@@ -0,0 +1,70 @@
+/*
+    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_METADATA_HPP_INCLUDED__
+#define __ZMQ_METADATA_HPP_INCLUDED__
+
+#include <map>
+#include <string>
+
+#include "atomic_counter.hpp"
+
+namespace zmq
+{
+    class metadata_t
+    {
+        public:
+            typedef std::map <std::string, std::string> dict_t;
+
+            metadata_t (const dict_t &dict);
+
+            //  Returns pointer to property value or NULL if
+            //  property is not found.
+            const char *get (const std::string &property) const;
+
+            void add_ref ();
+
+            //  Drop reference. Returns true iff the reference
+            //  counter drops to zero.
+            bool drop_ref ();
+
+        private:
+            metadata_t(const metadata_t&);
+            metadata_t & operator=(const metadata_t&);
+
+            //  Reference counter.
+            atomic_counter_t ref_cnt;
+
+            //  Dictionary holding metadata.
+            dict_t dict;
+    };
+
+}
+
+#endif

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

@@ -0,0 +1,578 @@
+/*
+    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 "msg.hpp"
+
+#include <string.h>
+#include <stdlib.h>
+#include <new>
+
+#include "stdint.hpp"
+#include "likely.hpp"
+#include "metadata.hpp"
+#include "err.hpp"
+
+//  Check whether the sizes of public representation of the message (zmq_msg_t)
+//  and private representation of the message (zmq::msg_t) match.
+
+typedef char zmq_msg_size_check
+    [2 * ((sizeof (zmq::msg_t) == sizeof (zmq_msg_t)) != 0) - 1];
+
+bool zmq::msg_t::check () const
+{
+     return u.base.type >= type_min && u.base.type <= type_max;
+}
+
+int zmq::msg_t::init (void* data_, size_t size_,
+                      msg_free_fn* ffn_, void* hint,
+                      content_t* content_)
+{
+    if (size_ < max_vsm_size) {
+        int const rc = init_size(size_);
+
+        if (rc != -1)
+        {
+            memcpy(data(), data_, size_);
+            return 0;
+        }
+        else
+        {
+            return -1;
+        }
+    }
+    else if(content_)
+    {
+        return init_external_storage(content_, data_, size_, ffn_, hint);
+    }
+    else
+    {
+        return init_data(data_, size_, ffn_, hint);
+    }
+}
+
+int zmq::msg_t::init ()
+{
+    u.vsm.metadata = NULL;
+    u.vsm.type = type_vsm;
+    u.vsm.flags = 0;
+    u.vsm.size = 0;
+    u.vsm.group[0] = '\0';
+    u.vsm.routing_id = 0;
+    return 0;
+}
+
+int zmq::msg_t::init_size (size_t size_)
+{
+    if (size_ <= max_vsm_size) {
+        u.vsm.metadata = NULL;
+        u.vsm.type = type_vsm;
+        u.vsm.flags = 0;
+        u.vsm.size = (unsigned char) size_;
+        u.vsm.group[0] = '\0';
+        u.vsm.routing_id = 0;
+    }
+    else {
+        u.lmsg.metadata = NULL;
+        u.lmsg.type = type_lmsg;
+        u.lmsg.flags = 0;
+        u.lmsg.group[0] = '\0';
+        u.lmsg.routing_id = 0;
+        u.lmsg.content = NULL;
+        if (sizeof (content_t) + size_ > size_)
+            u.lmsg.content = (content_t*) malloc (sizeof (content_t) + size_);
+        if (unlikely (!u.lmsg.content)) {
+            errno = ENOMEM;
+            return -1;
+        }
+
+        u.lmsg.content->data = u.lmsg.content + 1;
+        u.lmsg.content->size = size_;
+        u.lmsg.content->ffn = NULL;
+        u.lmsg.content->hint = NULL;
+        new (&u.lmsg.content->refcnt) zmq::atomic_counter_t ();
+    }
+    return 0;
+}
+
+int zmq::msg_t::init_external_storage(content_t* content_, void* data_, size_t size_,
+                                      msg_free_fn *ffn_, void* hint_)
+{
+    zmq_assert(NULL != data_);
+    zmq_assert(NULL != content_);
+
+    u.zclmsg.metadata = NULL;
+    u.zclmsg.type = type_zclmsg;
+    u.zclmsg.flags = 0;
+    u.zclmsg.group[0] = '\0';
+    u.zclmsg.routing_id = 0;
+
+    u.zclmsg.content = content_;
+    u.zclmsg.content->data = data_;
+    u.zclmsg.content->size = size_;
+    u.zclmsg.content->ffn = ffn_;
+    u.zclmsg.content->hint = hint_;
+    new (&u.zclmsg.content->refcnt) zmq::atomic_counter_t();
+
+    return 0;
+}
+
+int zmq::msg_t::init_data (void *data_, size_t size_,
+                           msg_free_fn *ffn_, void *hint_)
+{
+    //  If data is NULL and size is not 0, a segfault
+    //  would occur once the data is accessed
+    zmq_assert (data_ != NULL || size_ == 0);
+
+    //  Initialize constant message if there's no need to deallocate
+    if (ffn_ == NULL) {
+        u.cmsg.metadata = NULL;
+        u.cmsg.type = type_cmsg;
+        u.cmsg.flags = 0;
+        u.cmsg.data = data_;
+        u.cmsg.size = size_;
+        u.cmsg.group[0] = '\0';
+        u.cmsg.routing_id = 0;
+    }
+    else {
+        u.lmsg.metadata = NULL;
+        u.lmsg.type = type_lmsg;
+        u.lmsg.flags = 0;
+        u.lmsg.group[0] = '\0';
+        u.lmsg.routing_id = 0;
+        u.lmsg.content = (content_t*) malloc (sizeof (content_t));
+        if (!u.lmsg.content) {
+            errno = ENOMEM;
+            return -1;
+        }
+
+        u.lmsg.content->data = data_;
+        u.lmsg.content->size = size_;
+        u.lmsg.content->ffn = ffn_;
+        u.lmsg.content->hint = hint_;
+        new (&u.lmsg.content->refcnt) zmq::atomic_counter_t ();
+    }
+    return 0;
+
+}
+
+int zmq::msg_t::init_delimiter ()
+{
+    u.delimiter.metadata = NULL;
+    u.delimiter.type = type_delimiter;
+    u.delimiter.flags = 0;
+    u.delimiter.group[0] = '\0';
+    u.delimiter.routing_id = 0;
+    return 0;
+}
+
+int zmq::msg_t::init_join ()
+{
+    u.base.metadata = NULL;
+    u.base.type = type_join;
+    u.base.flags = 0;
+    u.base.group[0] = '\0';
+    u.base.routing_id = 0;
+    return 0;
+}
+
+int zmq::msg_t::init_leave ()
+{
+    u.base.metadata = NULL;
+    u.base.type = type_leave;
+    u.base.flags = 0;
+    u.base.group[0] = '\0';
+    u.base.routing_id = 0;
+    return 0;
+}
+
+int zmq::msg_t::close ()
+{
+    //  Check the validity of the message.
+    if (unlikely (!check ())) {
+        errno = EFAULT;
+        return -1;
+    }
+
+    if (u.base.type == type_lmsg) {
+
+        //  If the content is not shared, or if it is shared and the reference
+        //  count has dropped to zero, deallocate it.
+        if (!(u.lmsg.flags & msg_t::shared) ||
+              !u.lmsg.content->refcnt.sub (1)) {
+
+            //  We used "placement new" operator to initialize the reference
+            //  counter so we call the destructor explicitly now.
+            u.lmsg.content->refcnt.~atomic_counter_t ();
+
+            if (u.lmsg.content->ffn)
+                u.lmsg.content->ffn (u.lmsg.content->data,
+                    u.lmsg.content->hint);
+            free (u.lmsg.content);
+        }
+    }
+
+    if (is_zcmsg())
+    {
+        zmq_assert(u.zclmsg.content->ffn);
+
+        //  If the content is not shared, or if it is shared and the reference
+        //  count has dropped to zero, deallocate it.
+        if (!(u.zclmsg.flags & msg_t::shared) ||
+            !u.zclmsg.content->refcnt.sub (1)) {
+
+            //  We used "placement new" operator to initialize the reference
+            //  counter so we call the destructor explicitly now.
+            u.zclmsg.content->refcnt.~atomic_counter_t ();
+
+            u.zclmsg.content->ffn (u.zclmsg.content->data,
+                          u.zclmsg.content->hint);
+        }
+    }
+
+    if (u.base.metadata != NULL) {
+        if (u.base.metadata->drop_ref ()) {
+            LIBZMQ_DELETE(u.base.metadata);
+        }
+        u.base.metadata = NULL;
+    }
+
+    //  Make the message invalid.
+    u.base.type = 0;
+
+    return 0;
+}
+
+int zmq::msg_t::move (msg_t &src_)
+{
+    //  Check the validity of the source.
+    if (unlikely (!src_.check ())) {
+        errno = EFAULT;
+        return -1;
+    }
+
+    int rc = close ();
+    if (unlikely (rc < 0))
+        return rc;
+
+    *this = src_;
+
+    rc = src_.init ();
+    if (unlikely (rc < 0))
+        return rc;
+
+    return 0;
+}
+
+int zmq::msg_t::copy (msg_t &src_)
+{
+    //  Check the validity of the source.
+    if (unlikely (!src_.check ())) {
+        errno = EFAULT;
+        return -1;
+    }
+
+    int rc = close ();
+    if (unlikely (rc < 0))
+        return rc;
+
+    if (src_.u.base.type == type_lmsg  ) {
+
+        //  One reference is added to shared messages. Non-shared messages
+        //  are turned into shared messages and reference count is set to 2.
+        if (src_.u.lmsg.flags & msg_t::shared)
+            src_.u.lmsg.content->refcnt.add (1);
+        else {
+            src_.u.lmsg.flags |= msg_t::shared;
+            src_.u.lmsg.content->refcnt.set (2);
+        }
+    }
+
+    if (src_.is_zcmsg()) {
+
+        //  One reference is added to shared messages. Non-shared messages
+        //  are turned into shared messages and reference count is set to 2.
+        if (src_.u.zclmsg.flags & msg_t::shared)
+            src_.refcnt()->add (1);
+        else {
+            src_.u.zclmsg.flags |= msg_t::shared;
+            src_.refcnt()->set (2);
+        }
+    }
+    if (src_.u.base.metadata != NULL)
+        src_.u.base.metadata->add_ref ();
+
+    *this = src_;
+
+    return 0;
+
+}
+
+void *zmq::msg_t::data ()
+{
+    //  Check the validity of the message.
+    zmq_assert (check ());
+
+    switch (u.base.type) {
+    case type_vsm:
+        return u.vsm.data;
+    case type_lmsg:
+        return u.lmsg.content->data;
+    case type_cmsg:
+        return u.cmsg.data;
+    case type_zclmsg:
+        return u.zclmsg.content->data;
+    default:
+        zmq_assert (false);
+        return NULL;
+    }
+}
+
+size_t zmq::msg_t::size () const
+{
+    //  Check the validity of the message.
+    zmq_assert (check ());
+
+    switch (u.base.type) {
+    case type_vsm:
+        return u.vsm.size;
+    case type_lmsg:
+        return u.lmsg.content->size;
+    case type_zclmsg:
+        return u.zclmsg.content->size;
+    case type_cmsg:
+        return u.cmsg.size;
+    default:
+        zmq_assert (false);
+        return 0;
+    }
+}
+
+unsigned char zmq::msg_t::flags () const
+{
+    return u.base.flags;
+}
+
+void zmq::msg_t::set_flags (unsigned char flags_)
+{
+    u.base.flags |= flags_;
+}
+
+void zmq::msg_t::reset_flags (unsigned char flags_)
+{
+    u.base.flags &= ~flags_;
+}
+
+zmq::metadata_t *zmq::msg_t::metadata () const
+{
+    return u.base.metadata;
+}
+
+void zmq::msg_t::set_metadata (zmq::metadata_t *metadata_)
+{
+    assert (metadata_ != NULL);
+    assert (u.base.metadata == NULL);
+    metadata_->add_ref ();
+    u.base.metadata = metadata_;
+}
+
+void zmq::msg_t::reset_metadata ()
+{
+    if (u.base.metadata) {
+        if (u.base.metadata->drop_ref ()) {
+            LIBZMQ_DELETE(u.base.metadata);
+        }
+        u.base.metadata = NULL;
+    }
+}
+
+bool zmq::msg_t::is_routing_id () const
+{
+    return (u.base.flags & routing_id) == routing_id;
+}
+
+bool zmq::msg_t::is_credential () const
+{
+    return (u.base.flags & credential) == credential;
+}
+
+bool zmq::msg_t::is_delimiter () const
+{
+    return u.base.type == type_delimiter;
+}
+
+bool zmq::msg_t::is_vsm () const
+{
+    return u.base.type == type_vsm;
+}
+
+bool zmq::msg_t::is_cmsg () const
+{
+    return u.base.type == type_cmsg;
+}
+
+bool zmq::msg_t::is_zcmsg() const
+{
+    return u.base.type == type_zclmsg;
+}
+
+bool zmq::msg_t::is_join() const
+{
+    return u.base.type == type_join;
+}
+
+bool zmq::msg_t::is_leave() const
+{
+    return u.base.type == type_leave;
+}
+
+void zmq::msg_t::add_refs (int refs_)
+{
+    zmq_assert (refs_ >= 0);
+
+    //  Operation not supported for messages with metadata.
+    zmq_assert (u.base.metadata == NULL);
+
+    //  No copies required.
+    if (!refs_)
+        return;
+
+    //  VSMs, CMSGS and delimiters can be copied straight away. The only
+    //  message type that needs special care are long messages.
+    if (u.base.type == type_lmsg || is_zcmsg() ) {
+        if (u.base.flags & msg_t::shared)
+            refcnt()->add (refs_);
+        else {
+            refcnt()->set (refs_ + 1);
+            u.base.flags |= msg_t::shared;
+        }
+    }
+}
+
+bool zmq::msg_t::rm_refs (int refs_)
+{
+    zmq_assert (refs_ >= 0);
+
+    //  Operation not supported for messages with metadata.
+    zmq_assert (u.base.metadata == NULL);
+
+    //  No copies required.
+    if (!refs_)
+        return true;
+
+    //  If there's only one reference close the message.
+    if ( (u.base.type != type_zclmsg && u.base.type != type_lmsg) || !(u.base.flags & msg_t::shared)) {
+        close ();
+        return false;
+    }
+
+    //  The only message type that needs special care are long and zcopy messages.
+    if (u.base.type == type_lmsg && !u.lmsg.content->refcnt.sub(refs_)) {
+        //  We used "placement new" operator to initialize the reference
+        //  counter so we call the destructor explicitly now.
+        u.lmsg.content->refcnt.~atomic_counter_t ();
+
+        if (u.lmsg.content->ffn)
+            u.lmsg.content->ffn (u.lmsg.content->data, u.lmsg.content->hint);
+        free (u.lmsg.content);
+
+        return false;
+    }
+
+    if (is_zcmsg() && !u.zclmsg.content->refcnt.sub(refs_)) {
+        // storage for rfcnt is provided externally
+        if (u.zclmsg.content->ffn) {
+            u.zclmsg.content->ffn(u.zclmsg.content->data, u.zclmsg.content->hint);
+        }
+
+        return false;
+    }
+
+    return true;
+}
+
+uint32_t zmq::msg_t::get_routing_id ()
+{
+    return u.base.routing_id;
+}
+
+int zmq::msg_t::set_routing_id (uint32_t routing_id_)
+{
+    if (routing_id_) {
+        u.base.routing_id = routing_id_;
+        return 0;
+    }
+    errno = EINVAL;
+    return -1;
+}
+
+int zmq::msg_t::reset_routing_id ()
+{
+    u.base.routing_id = 0;
+    return 0;
+}
+
+const char * zmq::msg_t::group ()
+{
+    return u.base.group;
+}
+
+int zmq::msg_t::set_group (const char * group_)
+{
+    return set_group (group_, strlen (group_));
+}
+
+int zmq::msg_t::set_group (const char * group_, size_t length_)
+{
+    if (length_> ZMQ_GROUP_MAX_LENGTH)
+    {
+        errno = EINVAL;
+        return -1;
+    }
+
+    strncpy (u.base.group, group_, length_);
+    u.base.group[length_] = '\0';
+
+    return 0;
+}
+
+zmq::atomic_counter_t *zmq::msg_t::refcnt()
+{
+    switch(u.base.type)
+    {
+        case type_lmsg:
+            return &u.lmsg.content->refcnt;
+        case type_zclmsg:
+            return &u.zclmsg.content->refcnt;
+        default:
+            zmq_assert(false);
+            return NULL;
+    }
+}