laag-libzmq 4.2.3.0

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

@@ -0,0 +1,206 @@
+/*
+    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 "epoll.hpp"
+#if defined ZMQ_USE_EPOLL
+
+#include <sys/epoll.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <algorithm>
+#include <new>
+
+#include "macros.hpp"
+#include "epoll.hpp"
+#include "err.hpp"
+#include "config.hpp"
+#include "i_poll_events.hpp"
+
+zmq::epoll_t::epoll_t (const zmq::ctx_t &ctx_) :
+    ctx(ctx_),
+    stopping (false)
+{
+#ifdef ZMQ_USE_EPOLL_CLOEXEC
+    //  Setting this option result in sane behaviour when exec() functions
+    //  are used. Old sockets are closed and don't block TCP ports, avoid
+    //  leaks, etc.
+    epoll_fd = epoll_create1 (EPOLL_CLOEXEC);
+#else
+    epoll_fd = epoll_create (1);
+#endif
+    errno_assert (epoll_fd != -1);
+}
+
+zmq::epoll_t::~epoll_t ()
+{
+    //  Wait till the worker thread exits.
+    worker.stop ();
+
+    close (epoll_fd);
+    for (retired_t::iterator it = retired.begin (); it != retired.end (); ++it) {
+        LIBZMQ_DELETE(*it);
+    }
+}
+
+zmq::epoll_t::handle_t zmq::epoll_t::add_fd (fd_t fd_, i_poll_events *events_)
+{
+    poll_entry_t *pe = new (std::nothrow) poll_entry_t;
+    alloc_assert (pe);
+
+    //  The memset is not actually needed. It's here to prevent debugging
+    //  tools to complain about using uninitialised memory.
+    memset (pe, 0, sizeof (poll_entry_t));
+
+    pe->fd = fd_;
+    pe->ev.events = 0;
+    pe->ev.data.ptr = pe;
+    pe->events = events_;
+
+    int rc = epoll_ctl (epoll_fd, EPOLL_CTL_ADD, fd_, &pe->ev);
+    errno_assert (rc != -1);
+
+    //  Increase the load metric of the thread.
+    adjust_load (1);
+
+    return pe;
+}
+
+void zmq::epoll_t::rm_fd (handle_t handle_)
+{
+    poll_entry_t *pe = (poll_entry_t*) handle_;
+    int rc = epoll_ctl (epoll_fd, EPOLL_CTL_DEL, pe->fd, &pe->ev);
+    errno_assert (rc != -1);
+    pe->fd = retired_fd;
+    retired_sync.lock ();
+    retired.push_back (pe);
+    retired_sync.unlock ();
+
+    //  Decrease the load metric of the thread.
+    adjust_load (-1);
+}
+
+void zmq::epoll_t::set_pollin (handle_t handle_)
+{
+    poll_entry_t *pe = (poll_entry_t*) handle_;
+    pe->ev.events |= EPOLLIN;
+    int rc = epoll_ctl (epoll_fd, EPOLL_CTL_MOD, pe->fd, &pe->ev);
+    errno_assert (rc != -1);
+}
+
+void zmq::epoll_t::reset_pollin (handle_t handle_)
+{
+    poll_entry_t *pe = (poll_entry_t*) handle_;
+    pe->ev.events &= ~((short) EPOLLIN);
+    int rc = epoll_ctl (epoll_fd, EPOLL_CTL_MOD, pe->fd, &pe->ev);
+    errno_assert (rc != -1);
+}
+
+void zmq::epoll_t::set_pollout (handle_t handle_)
+{
+    poll_entry_t *pe = (poll_entry_t*) handle_;
+    pe->ev.events |= EPOLLOUT;
+    int rc = epoll_ctl (epoll_fd, EPOLL_CTL_MOD, pe->fd, &pe->ev);
+    errno_assert (rc != -1);
+}
+
+void zmq::epoll_t::reset_pollout (handle_t handle_)
+{
+    poll_entry_t *pe = (poll_entry_t*) handle_;
+    pe->ev.events &= ~((short) EPOLLOUT);
+    int rc = epoll_ctl (epoll_fd, EPOLL_CTL_MOD, pe->fd, &pe->ev);
+    errno_assert (rc != -1);
+}
+
+void zmq::epoll_t::start ()
+{
+    ctx.start_thread (worker, worker_routine, this);
+}
+
+void zmq::epoll_t::stop ()
+{
+    stopping = true;
+}
+
+int zmq::epoll_t::max_fds ()
+{
+    return -1;
+}
+
+void zmq::epoll_t::loop ()
+{
+    epoll_event ev_buf [max_io_events];
+
+    while (!stopping) {
+
+        //  Execute any due timers.
+        int timeout = (int) execute_timers ();
+
+        //  Wait for events.
+        int n = epoll_wait (epoll_fd, &ev_buf [0], max_io_events,
+            timeout ? timeout : -1);
+        if (n == -1) {
+            errno_assert (errno == EINTR);
+            continue;
+        }
+
+        for (int i = 0; i < n; i ++) {
+            poll_entry_t *pe = ((poll_entry_t*) ev_buf [i].data.ptr);
+
+            if (pe->fd == retired_fd)
+                continue;
+            if (ev_buf [i].events & (EPOLLERR | EPOLLHUP))
+                pe->events->in_event ();
+            if (pe->fd == retired_fd)
+               continue;
+            if (ev_buf [i].events & EPOLLOUT)
+                pe->events->out_event ();
+            if (pe->fd == retired_fd)
+                continue;
+            if (ev_buf [i].events & EPOLLIN)
+                pe->events->in_event ();
+        }
+
+        //  Destroy retired event sources.
+        retired_sync.lock ();
+        for (retired_t::iterator it = retired.begin (); it != retired.end (); ++it) {
+            LIBZMQ_DELETE(*it);
+        }
+        retired.clear ();
+        retired_sync.unlock ();
+    }
+}
+
+void zmq::epoll_t::worker_routine (void *arg_)
+{
+    ((epoll_t*) arg_)->loop ();
+}
+
+#endif

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

@@ -0,0 +1,119 @@
+/*
+    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_EPOLL_HPP_INCLUDED__
+#define __ZMQ_EPOLL_HPP_INCLUDED__
+
+//  poller.hpp decides which polling mechanism to use.
+#include "poller.hpp"
+#if defined ZMQ_USE_EPOLL
+
+#include <vector>
+#include <sys/epoll.h>
+
+#include "ctx.hpp"
+#include "fd.hpp"
+#include "thread.hpp"
+#include "poller_base.hpp"
+#include "mutex.hpp"
+
+namespace zmq
+{
+
+    struct i_poll_events;
+
+    //  This class implements socket polling mechanism using the Linux-specific
+    //  epoll mechanism.
+
+    class epoll_t : public poller_base_t
+    {
+    public:
+
+        typedef void* handle_t;
+
+        epoll_t (const ctx_t &ctx_);
+        ~epoll_t ();
+
+        //  "poller" concept.
+        handle_t add_fd (fd_t fd_, zmq::i_poll_events *events_);
+        void rm_fd (handle_t handle_);
+        void set_pollin (handle_t handle_);
+        void reset_pollin (handle_t handle_);
+        void set_pollout (handle_t handle_);
+        void reset_pollout (handle_t handle_);
+        void start ();
+        void stop ();
+
+        static int max_fds ();
+
+    private:
+
+        //  Main worker thread routine.
+        static void worker_routine (void *arg_);
+
+        //  Main event loop.
+        void loop ();
+
+        // Reference to ZMQ context.
+        const ctx_t &ctx;
+
+        //  Main epoll file descriptor
+        fd_t epoll_fd;
+
+        struct poll_entry_t
+        {
+            fd_t fd;
+            epoll_event ev;
+            zmq::i_poll_events *events;
+        };
+
+        //  List of retired event sources.
+        typedef std::vector <poll_entry_t*> retired_t;
+        retired_t retired;
+
+        //  If true, thread is in the process of shutting down.
+        bool stopping;
+
+        //  Handle of the physical thread doing the I/O work.
+        thread_t worker;
+
+        //  Synchronisation of retired event sources
+        mutex_t retired_sync;
+
+        epoll_t (const epoll_t&);
+        const epoll_t &operator = (const epoll_t&);
+    };
+
+    typedef epoll_t poller_t;
+
+}
+
+#endif
+
+#endif

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

@@ -0,0 +1,447 @@
+/*
+    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 "err.hpp"
+
+const char *zmq::errno_to_string (int errno_)
+{
+    switch (errno_) {
+#if defined ZMQ_HAVE_WINDOWS
+    case ENOTSUP:
+        return "Not supported";
+    case EPROTONOSUPPORT:
+        return "Protocol not supported";
+    case ENOBUFS:
+        return "No buffer space available";
+    case ENETDOWN:
+        return "Network is down";
+    case EADDRINUSE:
+        return "Address in use";
+    case EADDRNOTAVAIL:
+        return "Address not available";
+    case ECONNREFUSED:
+        return "Connection refused";
+    case EINPROGRESS:
+        return "Operation in progress";
+#endif
+    case EFSM:
+        return "Operation cannot be accomplished in current state";
+    case ENOCOMPATPROTO:
+        return "The protocol is not compatible with the socket type";
+    case ETERM:
+        return "Context was terminated";
+    case EMTHREAD:
+        return "No thread available";
+    case EHOSTUNREACH:
+        return "Host unreachable";
+    default:
+#if defined _MSC_VER
+#pragma warning (push)
+#pragma warning (disable:4996)
+#endif
+        return strerror (errno_);
+#if defined _MSC_VER
+#pragma warning (pop)
+#endif
+    }
+}
+
+void zmq::zmq_abort(const char *errmsg_)
+{
+#if defined ZMQ_HAVE_WINDOWS
+
+    //  Raise STATUS_FATAL_APP_EXIT.
+    ULONG_PTR extra_info [1];
+    extra_info [0] = (ULONG_PTR) errmsg_;
+    RaiseException (0x40000015, EXCEPTION_NONCONTINUABLE, 1, extra_info);
+#else
+    (void)errmsg_;
+    print_backtrace();
+    abort ();
+#endif
+}
+
+#ifdef ZMQ_HAVE_WINDOWS
+
+const char *zmq::wsa_error()
+{
+    return wsa_error_no (WSAGetLastError(), NULL);
+}
+
+const char *zmq::wsa_error_no (int no_, const char * wsae_wouldblock_string)
+{
+    //  TODO:  It seems that list of Windows socket errors is longer than this.
+    //         Investigate whether there's a way to convert it into the string
+    //         automatically (wsaError->HRESULT->string?).
+    return
+        (no_ == WSABASEERR) ?
+            "No Error" :
+        (no_ == WSAEINTR) ?
+            "Interrupted system call" :
+        (no_ == WSAEBADF) ?
+            "Bad file number" :
+        (no_ == WSAEACCES) ?
+            "Permission denied" :
+        (no_ == WSAEFAULT) ?
+            "Bad address" :
+        (no_ == WSAEINVAL) ?
+            "Invalid argument" :
+        (no_ == WSAEMFILE) ?
+            "Too many open files" :
+        (no_ == WSAEWOULDBLOCK) ?
+            wsae_wouldblock_string :
+        (no_ == WSAEINPROGRESS) ?
+            "Operation now in progress" :
+        (no_ == WSAEALREADY) ?
+            "Operation already in progress" :
+        (no_ == WSAENOTSOCK) ?
+            "Socket operation on non-socket" :
+        (no_ == WSAEDESTADDRREQ) ?
+            "Destination address required" :
+        (no_ == WSAEMSGSIZE) ?
+            "Message too long" :
+        (no_ == WSAEPROTOTYPE) ?
+            "Protocol wrong type for socket" :
+        (no_ == WSAENOPROTOOPT) ?
+            "Bad protocol option" :
+        (no_ == WSAEPROTONOSUPPORT) ?
+            "Protocol not supported" :
+        (no_ == WSAESOCKTNOSUPPORT) ?
+            "Socket type not supported" :
+        (no_ == WSAEOPNOTSUPP) ?
+            "Operation not supported on socket" :
+        (no_ == WSAEPFNOSUPPORT) ?
+            "Protocol family not supported" :
+        (no_ == WSAEAFNOSUPPORT) ?
+            "Address family not supported by protocol family" :
+        (no_ == WSAEADDRINUSE) ?
+            "Address already in use" :
+        (no_ == WSAEADDRNOTAVAIL) ?
+            "Can't assign requested address" :
+        (no_ == WSAENETDOWN) ?
+            "Network is down" :
+        (no_ == WSAENETUNREACH) ?
+            "Network is unreachable" :
+        (no_ == WSAENETRESET) ?
+            "Net dropped connection or reset" :
+        (no_ == WSAECONNABORTED) ?
+            "Software caused connection abort" :
+        (no_ == WSAECONNRESET) ?
+            "Connection reset by peer" :
+        (no_ == WSAENOBUFS) ?
+            "No buffer space available" :
+        (no_ == WSAEISCONN) ?
+            "Socket is already connected" :
+        (no_ == WSAENOTCONN) ?
+            "Socket is not connected" :
+        (no_ == WSAESHUTDOWN) ?
+            "Can't send after socket shutdown" :
+        (no_ == WSAETOOMANYREFS) ?
+            "Too many references can't splice" :
+        (no_ == WSAETIMEDOUT) ?
+            "Connection timed out" :
+        (no_ == WSAECONNREFUSED) ?
+            "Connection refused" :
+        (no_ == WSAELOOP) ?
+            "Too many levels of symbolic links" :
+        (no_ == WSAENAMETOOLONG) ?
+            "File name too long" :
+        (no_ == WSAEHOSTDOWN) ?
+            "Host is down" :
+        (no_ == WSAEHOSTUNREACH) ?
+            "No Route to Host" :
+        (no_ == WSAENOTEMPTY) ?
+            "Directory not empty" :
+        (no_ == WSAEPROCLIM) ?
+            "Too many processes" :
+        (no_ == WSAEUSERS) ?
+            "Too many users" :
+        (no_ == WSAEDQUOT) ?
+            "Disc Quota Exceeded" :
+        (no_ == WSAESTALE) ?
+            "Stale NFS file handle" :
+        (no_ == WSAEREMOTE) ?
+            "Too many levels of remote in path" :
+        (no_ == WSASYSNOTREADY) ?
+            "Network SubSystem is unavailable" :
+        (no_ == WSAVERNOTSUPPORTED) ?
+            "WINSOCK DLL Version out of range" :
+        (no_ == WSANOTINITIALISED) ?
+            "Successful WSASTARTUP not yet performed" :
+        (no_ == WSAHOST_NOT_FOUND) ?
+            "Host not found" :
+        (no_ == WSATRY_AGAIN) ?
+            "Non-Authoritative Host not found" :
+        (no_ == WSANO_RECOVERY) ?
+            "Non-Recoverable errors: FORMERR REFUSED NOTIMP" :
+        (no_ == WSANO_DATA) ?
+            "Valid name no data record of requested" :
+        "error not defined";
+}
+
+void zmq::win_error (char *buffer_, size_t buffer_size_)
+{
+    DWORD errcode = GetLastError ();
+#if defined _WIN32_WCE
+    DWORD rc = FormatMessageW (FORMAT_MESSAGE_FROM_SYSTEM |
+        FORMAT_MESSAGE_IGNORE_INSERTS, NULL, errcode, MAKELANGID(LANG_NEUTRAL,
+        SUBLANG_DEFAULT), (LPWSTR)buffer_, buffer_size_ / sizeof(wchar_t), NULL);
+#else
+    DWORD rc = FormatMessageA (FORMAT_MESSAGE_FROM_SYSTEM |
+        FORMAT_MESSAGE_IGNORE_INSERTS, NULL, errcode, MAKELANGID(LANG_NEUTRAL,
+        SUBLANG_DEFAULT), buffer_, (DWORD) buffer_size_, NULL);
+#endif
+    zmq_assert (rc);
+}
+
+int zmq::wsa_error_to_errno (int errcode)
+{
+    switch (errcode) {
+//  10004 - Interrupted system call.
+    case WSAEINTR:
+        return EINTR;
+//  10009 - File handle is not valid.
+    case WSAEBADF:
+        return EBADF;
+//  10013 - Permission denied.
+    case WSAEACCES:
+        return EACCES;
+//  10014 - Bad address.
+    case WSAEFAULT:
+        return EFAULT;
+//  10022 - Invalid argument.
+    case WSAEINVAL:
+        return EINVAL;
+//  10024 - Too many open files.
+    case WSAEMFILE:
+        return EMFILE;
+//  10035 - Operation would block.
+    case WSAEWOULDBLOCK:
+        return EBUSY;
+//  10036 - Operation now in progress.
+    case WSAEINPROGRESS:
+        return EAGAIN;
+//  10037 - Operation already in progress.
+    case WSAEALREADY:
+        return EAGAIN;
+//  10038 - Socket operation on non-socket.
+    case WSAENOTSOCK:
+        return ENOTSOCK;
+//  10039 - Destination address required.
+    case WSAEDESTADDRREQ:
+        return EFAULT;
+//  10040 - Message too long.
+    case WSAEMSGSIZE:
+        return EMSGSIZE;
+//  10041 - Protocol wrong type for socket.
+    case WSAEPROTOTYPE:
+        return EFAULT;
+//  10042 - Bad protocol option.
+    case WSAENOPROTOOPT:
+        return EINVAL;
+//  10043 - Protocol not supported.
+    case WSAEPROTONOSUPPORT:
+        return EPROTONOSUPPORT;
+//  10044 - Socket type not supported.
+    case WSAESOCKTNOSUPPORT:
+        return EFAULT;
+//  10045 - Operation not supported on socket.
+    case WSAEOPNOTSUPP:
+        return EFAULT;
+//  10046 - Protocol family not supported.
+    case WSAEPFNOSUPPORT:
+        return EPROTONOSUPPORT;
+//  10047 - Address family not supported by protocol family.
+    case WSAEAFNOSUPPORT:
+        return EAFNOSUPPORT;
+//  10048 - Address already in use.
+    case WSAEADDRINUSE:
+        return EADDRINUSE;
+//  10049 - Cannot assign requested address.
+    case WSAEADDRNOTAVAIL:
+        return EADDRNOTAVAIL;
+//  10050 - Network is down.
+    case WSAENETDOWN:
+        return ENETDOWN;
+//  10051 - Network is unreachable.
+    case WSAENETUNREACH:
+        return ENETUNREACH;
+//  10052 - Network dropped connection on reset.
+    case WSAENETRESET:
+        return ENETRESET;
+//  10053 - Software caused connection abort.
+    case WSAECONNABORTED:
+        return ECONNABORTED;
+//  10054 - Connection reset by peer.
+    case WSAECONNRESET:
+        return ECONNRESET;
+//  10055 - No buffer space available.
+    case WSAENOBUFS:
+        return ENOBUFS;
+//  10056 - Socket is already connected.
+    case WSAEISCONN:
+        return EFAULT;
+//  10057 - Socket is not connected.
+    case WSAENOTCONN:
+        return ENOTCONN;
+//  10058 - Can't send after socket shutdown.
+    case WSAESHUTDOWN:
+        return EFAULT;
+//  10059 - Too many references can't splice.
+    case WSAETOOMANYREFS:
+        return EFAULT;
+//  10060 - Connection timed out.
+    case WSAETIMEDOUT:
+        return ETIMEDOUT;
+//  10061 - Connection refused.
+    case WSAECONNREFUSED:
+        return ECONNREFUSED;
+//  10062 - Too many levels of symbolic links.
+    case WSAELOOP:
+        return EFAULT;
+//  10063 - File name too long.
+    case WSAENAMETOOLONG:
+        return EFAULT;
+//  10064 - Host is down.
+    case WSAEHOSTDOWN:
+        return EAGAIN;
+//  10065 - No route to host.
+    case WSAEHOSTUNREACH:
+        return EHOSTUNREACH;
+//  10066 - Directory not empty.
+    case WSAENOTEMPTY:
+        return EFAULT;
+//  10067 - Too many processes.
+    case WSAEPROCLIM:
+        return EFAULT;
+//  10068 - Too many users.
+    case WSAEUSERS:
+        return EFAULT;
+//  10069 - Disc Quota Exceeded.
+    case WSAEDQUOT:
+        return EFAULT;
+//  10070 - Stale NFS file handle.
+    case WSAESTALE:
+        return EFAULT;
+//  10071 - Too many levels of remote in path.
+    case WSAEREMOTE:
+        return EFAULT;
+//  10091 - Network SubSystem is unavailable.
+    case WSASYSNOTREADY:
+        return EFAULT;
+//  10092 - WINSOCK DLL Version out of range.
+    case WSAVERNOTSUPPORTED:
+        return EFAULT;
+//  10093 - Successful WSASTARTUP not yet performed.
+    case WSANOTINITIALISED:
+        return EFAULT;
+//  11001 - Host not found.
+    case WSAHOST_NOT_FOUND:
+        return EFAULT;
+//  11002 - Non-Authoritative Host not found.
+    case WSATRY_AGAIN:
+        return EFAULT;
+//  11003 - Non-Recoverable errors: FORMERR REFUSED NOTIMP.
+    case WSANO_RECOVERY:
+        return EFAULT;
+//  11004 - Valid name no data record of requested.
+    case WSANO_DATA:
+        return EFAULT;
+    default:
+        wsa_assert (false);
+    }
+    //  Not reachable
+    return 0;
+}
+
+#endif
+
+#ifdef HAVE_LIBUNWIND
+
+#define UNW_LOCAL_ONLY
+#include <libunwind.h>
+#include <dlfcn.h>
+#include <cxxabi.h>
+#include "mutex.hpp"
+
+void zmq::print_backtrace (void)
+{
+    static zmq::mutex_t mtx;
+    mtx.lock ();
+    Dl_info dl_info;
+    unw_cursor_t cursor;
+    unw_context_t ctx;
+    unsigned frame_n = 0;
+
+    unw_getcontext (&ctx);
+    unw_init_local (&cursor, &ctx);
+
+    while (unw_step (&cursor) > 0) {
+        unw_word_t offset;
+        unw_proc_info_t p_info;
+        const char *file_name;
+        char *demangled_name;
+        char func_name[256] = "";
+        void *addr;
+        int rc;
+
+        if (unw_get_proc_info (&cursor, &p_info))
+            break;
+
+        rc = unw_get_proc_name (&cursor, func_name, 256, &offset);
+        if (rc == -UNW_ENOINFO)
+            strcpy(func_name, "?");
+
+        addr = (void *)(p_info.start_ip + offset);
+
+        if (dladdr (addr, &dl_info) && dl_info.dli_fname)
+            file_name = dl_info.dli_fname;
+        else
+            file_name = "?";
+
+        demangled_name = abi::__cxa_demangle (func_name, NULL, NULL, &rc);
+
+        printf ("#%u  %p in %s (%s+0x%lx)\n", frame_n++, addr, file_name,
+                rc ? func_name : demangled_name, (unsigned long) offset);
+        free (demangled_name);
+    }
+    puts ("");
+    
+    fflush (stdout);
+    mtx.unlock ();
+}
+
+#else
+
+void zmq::print_backtrace (void)
+{
+}
+
+#endif