rbczmq 1.6.2 → 1.6.4

data/ext/czmq/src/zstr.c

@@ -0,0 +1,297 @@
+/*  =========================================================================
+    zstr - sending and receiving strings
+
+    -------------------------------------------------------------------------
+    Copyright (c) 1991-2013 iMatix Corporation <www.imatix.com>
+    Copyright other contributors as noted in the AUTHORS file.
+
+    This file is part of CZMQ, the high-level C binding for 0MQ:
+    http://czmq.zeromq.org.
+
+    This 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.
+
+    This software is distributed in the hope that it will be useful, but
+    WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABIL-
+    ITY 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/>.
+    =========================================================================
+*/
+
+/*
+@header
+    The zstr class provides utility functions for sending and receiving C
+    strings across 0MQ sockets. It sends strings without a terminating null,
+    and appends a null byte on received strings. This class is for simple
+    message sending.
+@discuss
+@end
+*/
+
+#include "../include/czmq.h"
+
+static int
+s_send_string (void *zocket, bool more, char *string)
+{
+    assert (zocket);
+
+    int len = strlen (string);
+    zmq_msg_t message;
+    zmq_msg_init_size (&message, len);
+    memcpy (zmq_msg_data (&message), string, len);
+    int rc = zmq_sendmsg (zocket, &message, more? ZMQ_SNDMORE: 0);
+
+    return rc == -1? -1: 0;
+}
+
+
+//  --------------------------------------------------------------------------
+//  Receive C string from socket. Caller must free returned string. Returns
+//  NULL if the context is being terminated or the process was interrupted.
+
+char *
+zstr_recv (void *zocket)
+{
+    assert (zocket);
+    zmq_msg_t message;
+    zmq_msg_init (&message);
+    if (zmq_recvmsg (zocket, &message, 0) < 0)
+        return NULL;
+
+    size_t size = zmq_msg_size (&message);
+    char *string = (char *) malloc (size + 1);
+    memcpy (string, zmq_msg_data (&message), size);
+    zmq_msg_close (&message);
+    string [size] = 0;
+    return string;
+}
+
+
+//  --------------------------------------------------------------------------
+//  Receive C string from socket, if socket had input ready. Caller must
+//  free returned string. Returns NULL if there was no input waiting, or if
+//  the context was terminated. Use zctx_interrupted to exit any loop that
+//  relies on this method.
+
+char *
+zstr_recv_nowait (void *zocket)
+{
+    assert (zocket);
+    zmq_msg_t message;
+    zmq_msg_init (&message);
+    if (zmq_recvmsg (zocket, &message, ZMQ_DONTWAIT) < 0)
+        return NULL;
+
+    size_t size = zmq_msg_size (&message);
+    char *string = (char *) malloc (size + 1);
+    memcpy (string, zmq_msg_data (&message), size);
+    zmq_msg_close (&message);
+    string [size] = 0;
+    return string;
+}
+
+
+//  --------------------------------------------------------------------------
+//  Send C string to socket. Returns 0 if successful, -1 if there was an
+//  error.
+
+int
+zstr_send (void *zocket, const char *format, ...)
+{
+    assert (zocket);
+    assert (format);
+    //  Format string into buffer
+    int size = 255 + 1;
+    char stackbuffer[255+1];
+    char *string = stackbuffer;
+    va_list argptr;
+    va_start (argptr, format);
+    int required = vsnprintf (string, size, format, argptr);
+    va_end (argptr);
+#ifdef _MSC_VER
+    if (required < 0 || required >= size) {
+        va_start (argptr, format);
+        required = _vscprintf (format, argptr);
+        va_end (argptr);
+    }
+#endif
+    if (required >= size) {
+        size = required + 1;
+        string = (char *) malloc (size);
+        if (!string)
+            return -1;
+        va_start (argptr, format);
+        vsnprintf (string, size, format, argptr);
+        va_end (argptr);
+    }
+
+    int rc = s_send_string (zocket, false, string);
+    if (string!=stackbuffer)
+        free (string);
+    return rc;
+}
+
+//  Deprecated, does exactly the same
+int
+zstr_sendf (void *zocket, const char *format, ...)
+{
+    assert (zocket);
+    assert (format);
+    //  Format string into buffer
+    int size = 255 + 1;
+    char stackbuffer[255+1];
+    char *string = stackbuffer;
+    va_list argptr;
+    va_start (argptr, format);
+    int required = vsnprintf (string, size, format, argptr);
+    va_end (argptr);
+#ifdef _MSC_VER
+    if (required < 0 || required >= size) {
+        va_start (argptr, format);
+        required = _vscprintf (format, argptr);
+        va_end (argptr);
+    }
+#endif
+    if (required >= size) {
+        size = required + 1;
+        string = (char *) malloc (size);
+        if (!string)
+            return -1;
+        va_start (argptr, format);
+        vsnprintf (string, size, format, argptr);
+        va_end (argptr);
+    }
+
+    int rc = s_send_string (zocket, false, string);
+    if (string!=stackbuffer)
+        free (string);
+    return rc;
+}
+
+
+//  --------------------------------------------------------------------------
+//  Send a string to a socket in 0MQ string format, with MORE flag
+
+int
+zstr_sendm (void *zocket, const char *format, ...)
+{
+    assert (zocket);
+    assert (format);
+    //  Format string into buffer
+    int size = 255 + 1;
+    char stackbuffer[255+1];
+    char *string = stackbuffer;
+    va_list argptr;
+    va_start (argptr, format);
+    int required = vsnprintf (string, size, format, argptr);
+    va_end (argptr);
+#ifdef _MSC_VER
+    if (required < 0 || required >= size) {
+        va_start (argptr, format);
+        required = _vscprintf (format, argptr);
+        va_end (argptr);
+    }
+#endif
+    if (required >= size) {
+        size = required + 1;
+        string = (char *) malloc (size);
+        if (!string)
+            return -1;
+        va_start (argptr, format);
+        vsnprintf (string, size, format, argptr);
+        va_end (argptr);
+    }
+
+    int rc = s_send_string (zocket, true, string);
+    if (string!=stackbuffer)
+        free (string);
+    return rc;
+}
+
+//  Deprecated, does exactly the same
+int
+zstr_sendfm (void *zocket, const char *format, ...)
+{
+    assert (zocket);
+    assert (format);
+    //  Format string into buffer
+    int size = 255 + 1;
+    char stackbuffer[255+1];
+    char *string = stackbuffer;
+    va_list argptr;
+    va_start (argptr, format);
+    int required = vsnprintf (string, size, format, argptr);
+    va_end (argptr);
+#ifdef _MSC_VER
+    if (required < 0 || required >= size) {
+        va_start (argptr, format);
+        required = _vscprintf (format, argptr);
+        va_end (argptr);
+    }
+#endif
+    if (required >= size) {
+        size = required + 1;
+        string = (char *) malloc (size);
+        if (!string)
+            return -1;
+        va_start (argptr, format);
+        vsnprintf (string, size, format, argptr);
+        va_end (argptr);
+    }
+
+    int rc = s_send_string (zocket, true, string);
+    if (string!=stackbuffer)
+        free (string);
+    return rc;
+}
+
+//  --------------------------------------------------------------------------
+//  Selftest
+
+int
+zstr_test (bool verbose)
+{
+    printf (" * zstr: ");
+
+    //  @selftest
+    zctx_t *ctx = zctx_new ();
+    assert (ctx);
+
+    void *output = zsocket_new (ctx, ZMQ_PAIR);
+    assert (output);
+    zsocket_bind (output, "inproc://zstr.test");
+    void *input = zsocket_new (ctx, ZMQ_PAIR);
+    assert (input);
+    zsocket_connect (input, "inproc://zstr.test");
+
+    //  Send ten strings, five strings with MORE flag and then END
+    int string_nbr;
+    for (string_nbr = 0; string_nbr < 10; string_nbr++)
+        zstr_send (output, "this is string %d", string_nbr);
+    for (string_nbr = 0; string_nbr < 5; string_nbr++)
+        zstr_sendm (output, "this is string %d", string_nbr);
+    zstr_send (output, "END");
+
+    //  Read and count until we receive END
+    string_nbr = 0;
+    for (string_nbr = 0;; string_nbr++) {
+        char *string = zstr_recv (input);
+        if (streq (string, "END")) {
+            free (string);
+            break;
+        }
+        free (string);
+    }
+    assert (string_nbr == 15);
+
+    zctx_destroy (&ctx);
+    //  @end
+
+    printf ("OK\n");
+    return 0;
+}

data/ext/czmq/src/zsys.c

@@ -0,0 +1,136 @@
+/*  =========================================================================
+    zsys - system wrapper
+
+    -------------------------------------------------------------------------
+    Copyright (c) 1991-2013 iMatix Corporation <www.imatix.com>
+    Copyright other contributors as noted in the AUTHORS file.
+
+    This file is part of CZMQ, the high-level C binding for 0MQ:
+    http://czmq.zeromq.org.
+
+    This 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.
+
+    This software is distributed in the hope that it will be useful, but
+    WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABIL-
+    ITY 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/>.
+    =========================================================================
+*/
+
+/*
+@header
+    The zsys class provides a portable wrapper for miscellaneous functions
+    that we want to wrap but which don't fit into any of the existing
+    classes. Eventually all non-portable functionality might be moved here
+    but for now it covers only file systems.
+@discuss
+@end
+*/
+
+#include "../include/czmq.h"
+
+#if defined (__UNIX__)
+static bool s_first_time = true;
+static struct sigaction sigint_default;
+static struct sigaction sigterm_default;
+#endif
+
+//  --------------------------------------------------------------------------
+//  Set interrupt handler (NULL means external handler)
+//  Idempotent; safe to call multiple times
+
+void
+zsys_handler_set (zsys_handler_fn *handler_fn)
+{
+#if defined (__UNIX__)
+    //  Install signal handler for SIGINT and SIGTERM if not NULL
+    //  and if this is the first time we've been called
+    if (s_first_time) {
+        s_first_time = false;
+        if (handler_fn) {
+            struct sigaction action;
+            action.sa_handler = handler_fn;
+            action.sa_flags = 0;
+            sigemptyset (&action.sa_mask);
+            sigaction (SIGINT, &action, &sigint_default);
+            sigaction (SIGTERM, &action, &sigterm_default);
+        }
+        else {
+            //  Save default handlers if not already done
+            sigaction (SIGINT, NULL, &sigint_default);
+            sigaction (SIGTERM, NULL, &sigterm_default);
+        }
+    }
+#endif
+}
+
+
+//  --------------------------------------------------------------------------
+//  Reset interrupt handler, call this at exit if needed
+//  Idempotent; safe to call multiple times
+
+void
+zsys_handler_reset (void)
+{
+#if defined (__UNIX__)
+    //  Restore default handlers if not already done
+    if (sigint_default.sa_handler) {
+        sigaction (SIGINT, &sigint_default, NULL);
+        sigaction (SIGTERM, &sigterm_default, NULL);
+        sigint_default.sa_handler = NULL;
+        sigterm_default.sa_handler = NULL;
+        s_first_time = true;
+    }
+#endif
+}
+
+
+//  --------------------------------------------------------------------------
+//  Set network interface name to use for broadcasts
+//  Use this to force the interface for beacons
+//  This is experimental; may be merged into zbeacon class.
+
+//  NOT thread safe, not a good design; this is to test the feasibility
+//  of forcing a network interface name instead of writing code to find it.
+static char *s_interface = NULL;
+
+void
+zsys_set_interface (char *interface)
+{
+    free (s_interface);
+    s_interface = strdup (interface);
+}
+
+
+//  Return network interface name to use for broadcasts.
+//  Returns "" if no interface was set.
+//  This is experimental; may be merged into zbeacon class.
+
+char *
+zsys_interface (void)
+{
+    return (s_interface? s_interface: "");
+}
+
+
+//  --------------------------------------------------------------------------
+//  Selftest
+
+int
+zsys_test (bool verbose)
+{
+    printf (" * zsys: ");
+    zsys_handler_reset ();
+    zsys_handler_set (NULL);
+    zsys_handler_set (NULL);
+    zsys_handler_reset ();
+    zsys_handler_reset ();
+    printf ("OK\n");
+    return 0;
+}

data/ext/czmq/src/zthread.c

@@ -0,0 +1,269 @@
+/*  =========================================================================
+    zthread - working with system threads
+
+    -------------------------------------------------------------------------
+    Copyright (c) 1991-2013 iMatix Corporation <www.imatix.com>
+    Copyright other contributors as noted in the AUTHORS file.
+
+    This file is part of CZMQ, the high-level C binding for 0MQ:
+    http://czmq.zeromq.org.
+
+    This 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.
+
+    This software is distributed in the hope that it will be useful, but
+    WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABIL-
+    ITY 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/>.
+    =========================================================================
+*/
+
+/*
+@header
+    The zthread class wraps OS thread creation. It creates detached threads
+    that look like normal OS threads, or attached threads that share the
+    caller's 0MQ context, and get an inproc pipe to talk back to the parent
+    thread. Detached threads create their own 0MQ contexts as needed.
+@discuss
+    We have several use cases for multiple threads. One is to simulate many
+    processes, so we can test 0MQ designs and flows more easily. Another is
+    to create APIs that can send and receive 0MQ messages in the background.
+
+    zthread solves these two use cases separately, using the zthread_new
+    and zthead_fork methods respectively. These methods wrap the native
+    system calls needed to start threads, so your code can remain fully
+    portable.
+
+    Detached threads follow the POSIX pthreads API; they accept a void *
+    argument and return a void * result (always NULL in our case).
+
+    Attached thread receive a void * argument, a zctx_t context, and a pipe
+    socket. The pipe socket is a PAIR socket that is connected back to the
+    caller. When you call zthread_fork, it returns you a PAIR socket that
+    is the other end of this pipe. Thus attached threads can talk back to
+    their parent threads over the pipe. We use this very heavily when making
+    so-called "asynchronous" APIs, which you can see in the Guide examples
+    like 'clone'.
+
+    To recap some rules about threading: do not share sockets between
+    threads or your code will crash. You can migrate a socket from one
+    thread to a child thread, if you stop using it in the parent thread
+    immediately after creating the child thread. If you want to connect
+    sockets over inproc:// they must share the same 0MQ context, i.e. be
+    attached threads. You should always use zthread_fork to create an
+    attached thread; it is not sufficient to pass a zctx_t structure to
+    a detached thread (this will crash).
+
+    If you want to communicate over ipc:// or tcp:// you may be sharing
+    the same context, or use separate contexts. Thus, every detached thread
+    usually starts by creating its own zctx_t instance.    
+@end
+*/
+
+#include "../include/czmq.h"
+
+//  --------------------------------------------------------------------------
+//  Thread creation code, wrapping POSIX and Win32 thread APIs
+
+typedef struct {
+    //  Two thread handlers, one will be set, one NULL
+    zthread_attached_fn *attached;
+    zthread_detached_fn *detached;
+    void *args;                 //  Application arguments
+    zctx_t *ctx;                //  Context object if any
+    void *pipe;                 //  Pipe, if any, back to parent
+#if defined (__WINDOWS__)
+    HANDLE handle;              //  Win32 thread handle
+#endif
+} shim_t;
+
+#if defined (__UNIX__)
+//  Thread shim for UNIX calls the real thread and cleans up afterwards.
+void *
+s_thread_shim (void *args)
+{
+    assert (args);
+    shim_t *shim = (shim_t *) args;
+    if (shim->attached)
+        shim->attached (shim->args, shim->ctx, shim->pipe);
+    else
+        shim->detached (shim->args);
+
+    zctx_destroy (&shim->ctx);
+    free (shim);
+    return NULL;
+}
+
+#elif defined (__WINDOWS__)
+//  Thread shim for Windows that wraps a POSIX-style thread handler
+//  and does the _endthreadex for us automatically.
+unsigned __stdcall
+s_thread_shim (void *args)
+{
+    assert (args);
+    shim_t *shim = (shim_t *) args;
+    if (shim->attached)
+        shim->attached (shim->args, shim->ctx, shim->pipe);
+    else
+        shim->detached (shim->args);
+
+    zctx_destroy (&shim->ctx);  //  Close any dangling sockets
+    free (shim);
+    _endthreadex (0);           //  Terminates thread
+    return 0;
+}
+#endif
+
+static void
+s_thread_start (shim_t *shim)
+{
+#if defined (__UNIX__)
+    pthread_t thread;
+    pthread_create (&thread, NULL, s_thread_shim, shim);
+    pthread_detach (thread);
+
+#elif defined (__WINDOWS__)
+    shim->handle = (HANDLE)_beginthreadex(
+        NULL,                   //  Handle is private to this process
+        0,                      //  Use a default stack size for new thread
+        &s_thread_shim,         //  Start real thread function via this shim
+        shim,                   //  Which gets the current object as argument
+        CREATE_SUSPENDED,       //  Set thread priority before starting it
+        NULL);                  //  We don't use the thread ID
+
+    assert (shim->handle);
+    //  Set child thread priority to same as current
+    int priority = GetThreadPriority (GetCurrentThread ());
+    SetThreadPriority (shim->handle, priority);
+    //  Start thread
+    ResumeThread (shim->handle);
+    //  Release resources
+    CloseHandle (shim->handle);
+    shim->handle = 0;
+#endif
+}
+
+
+//  --------------------------------------------------------------------------
+//  Create a detached thread. A detached thread operates autonomously
+//  and is used to simulate a separate process. It gets no ctx, and no
+//  pipe. Returns 0 on success, -1 if insufficient memory.
+
+int
+zthread_new (zthread_detached_fn *thread_fn, void *args)
+{
+    //  Prepare argument shim for child thread
+    shim_t *shim = (shim_t *) zmalloc (sizeof (shim_t));
+    if (shim) {
+        shim->detached = thread_fn;
+        shim->args = args;
+        s_thread_start (shim);
+        return 0;
+    }
+    return -1;
+}
+
+
+//  --------------------------------------------------------------------------
+//  Create an attached thread. An attached thread gets a ctx and a PAIR
+//  pipe back to its parent. It must monitor its pipe, and exit if the
+//  pipe becomes unreadable. Returns pipe, or NULL if there was an error.
+
+void *
+zthread_fork (zctx_t *ctx, zthread_attached_fn *thread_fn, void *args)
+{
+    shim_t *shim = NULL;
+    //  Create our end of the pipe
+    void *pipe = zsocket_new (ctx, ZMQ_PAIR);
+    if (pipe)
+        zsocket_bind (pipe, "inproc://zctx-pipe-%p", pipe);
+    else
+        return NULL;
+    
+    //  Prepare argument shim for child thread
+    shim = (shim_t *) zmalloc (sizeof (shim_t));
+    if (shim) {
+        shim->attached = thread_fn;
+        shim->args = args;
+        shim->ctx = zctx_shadow (ctx);
+        if (!shim->ctx)
+            return NULL;
+    }
+    else
+        return NULL;
+    
+    //  Connect child pipe to our pipe
+    shim->pipe = zsocket_new (shim->ctx, ZMQ_PAIR);
+    if (!shim->pipe)
+        return NULL;
+    zsocket_connect (shim->pipe, "inproc://zctx-pipe-%p", pipe);
+    
+    s_thread_start (shim);
+    return pipe;
+}
+
+
+//  --------------------------------------------------------------------------
+//  Selftest
+
+//  @selftest
+static void *
+s_test_detached (void *args)
+{
+    //  Create a socket to check it'll be automatically deleted
+    zctx_t *ctx = zctx_new ();
+    assert (ctx);
+
+    void *push = zsocket_new (ctx, ZMQ_PUSH);
+    assert (push);
+    zctx_destroy (&ctx);
+    return NULL;
+}
+
+static void
+s_test_attached (void *args, zctx_t *ctx, void *pipe)
+{
+    //  Create a socket to check it'll be automatically deleted
+    zsocket_new (ctx, ZMQ_PUSH);
+    //  Wait for our parent to ping us, and pong back
+    free (zstr_recv (pipe));
+    zstr_send (pipe, "pong");
+}
+
+//  @end
+
+int
+zthread_test (bool verbose)
+{
+    printf (" * zthread: ");
+
+    //  @selftest
+    zctx_t *ctx = zctx_new ();
+    assert (ctx);
+    int rc = 0;
+
+    //  Create a detached thread, let it run
+    rc = zthread_new (s_test_detached, NULL);
+    assert (rc == 0);
+    zclock_sleep (100);
+
+    //  Create an attached thread, check it's safely alive
+    void *pipe = zthread_fork (ctx, s_test_attached, NULL);
+    assert (pipe);
+    zstr_send (pipe, "ping");
+    char *pong = zstr_recv (pipe);
+    assert (streq (pong, "pong"));
+    free (pong);
+
+    //  Everything should be cleanly closed now
+    zctx_destroy (&ctx);
+    //  @end
+
+    printf ("OK\n");
+    return 0;
+}