Revert "add proxy_chain, a multi proxies chaining in the same thread feature"

This reverts commit bc7441f5.

doc/zmq_proxy_chain.txt

-zmq_proxy_chain(3)
-==================
-
-NAME
-----
-zmq_proxy_chain - start built-in 0MQ a proxy chain in the same thread
-control flow
-
-
-SYNOPSIS
---------
-*int zmq_proxy_chain (const void '**frontends', const void '**backends', 
-     const void '*capture', const void **hooks_, const void '*control');*
-
-
-DESCRIPTION
------------
-The _zmq_proxy_chain()_ function starts the built-in 0MQ proxy in the 
-current application thread, as _zmq_proxy()_, _zmq_proxy_steerable()_, or 
-_zmq_proxy_hook()_ do. Please, refer to these functions for their general 
-description and usage. We describe here only the additional proxy chaining 
-capability.
-
-Note that compared to the other proxy functions, the arguments _frontends_, 
-_backends_ and _hooks_ receive arrays instead of single values. Say one need 
-to implement the following architecture:
-
-*Process      client              proxy1                  proxy2              worker*
-               |             |-----------|             |----------|            |
-*socket*         cl           f1          b1            f2          b2           wk
-*endpoint*       |c----e1-----b|           |c----e2-----b|          |c----e3----b|
-
-Note: "c" is for connect, "b" for bind.
-
-With the other proxy functions, one needs typically one thread for each proxy:
-----
-thread 1: zmq_proxy(f1, b1);
-thread 2: zmq_proxy(f2, b2);
-----
-
-With _zmq_proxy_chain_, it can be performed with only one thread:
-----
-void** f = {f1, f2, NULL);
-void** b = {b1, b2, NULL);
-single thread: zmq_proxy_chain(f, b, NULL, NULL, NULL);
-----
-
-Note: the three NULL arguments are for capture, hooks, and control, since 
-_zmq_proxy_chain_ is built on top of _zmq_proxy_hook_, itself built on top 
-of _zmq_proxy_steerable_, itself built on top of _zmq_proxy_. Of course, hook and  
-steering features can be used along with chaining.
-
-We have limited the number of sockets that can be chained in a single command to 10, what 
-should be largely sufficient. The reason is to avoid dynamic memory allocation.
-
-Arguments frontends and backends shall be arrays of sockets of type void*, terminated 
-by NULL. Both arrays shall terminate by NULL at the same indice, otherwise, an error is 
-returned. Argument hooks shall be NULL or of the same length than the socket arrays. No 
-NULL is required at the end of hooks. Any number of elements may be NULL where no hook 
-is implemented in some proxies.
-
-
-Refer to linkzmq:zmq_socket[3] for a description of the available socket types.
-Refer to linkzmq:zmq_proxy[3] for a description of the zmq_proxy.
-Refer to linkzmq:zmq_proxy_steerable[3] for a description of the zmq_steerable.
-Refer to linkzmq:zmq_proxy_hook[3] for a description of the zmq_hook.
-
-EXAMPLE USAGE
--------------
-_zmq_proxy_chain_ aims at building protocol layers by easing the chaining of some 
-proxies typically by chaining:
-DEALER | ROUTER <---> STREAM <---> DEALER
-in the same thread. Any kind of protocol feature can be added via hooks.
-
-cf also zmq_proxy, zmq_proxy_steerable, zmq_proxy_hook.
-
-RETURN VALUE
-------------
-The _zmq_proxy_chain()_ function returns 0 if TERMINATE is sent to its
-control socket. Otherwise, it returns `-1` and 'errno' set to *ETERM* (the
-0MQ 'context' associated with either of the specified sockets was terminated).
-
-
-EXAMPLE
--------
-cf test_proxy_chain.cpp
-An example capable of proxying CURVE will be added soon.
-
-SEE ALSO
---------
-linkzmq:zmq_proxy[3]
-linkzmq:zmq_proxy_steerable[3]
-linkzmq:zmq_proxy_hook[3]
-linkzmq:zmq_bind[3]
-linkzmq:zmq_connect[3]
-linkzmq:zmq_socket[3]
-linkzmq:zmq[7]
-
-
-AUTHORS
--------
-This page was written by the 0MQ community. To make a change please
-read the 0MQ Contribution Policy at <http://www.zeromq.org/docs:contributing>.

include/zmq.h

@@ -398,11 +398,9 @@ ZMQ_EXPORT int zmq_poll (zmq_pollitem_t *items, int nitems, long timeout);
 
 /*  Built-in message proxy (3-way) */
 
-#define ZMQ_PROXY_CHAIN_MAX_LENGTH 10
 ZMQ_EXPORT int zmq_proxy (void *frontend, void *backend, void *capture);
 ZMQ_EXPORT int zmq_proxy_steerable (void *frontend, void *backend, void *capture, void *control);
 ZMQ_EXPORT int zmq_proxy_hook (void *frontend, void *backend, void *capture, void *hook, void *control);
-ZMQ_EXPORT int zmq_proxy_chain (void **frontends_, void **backends_, void *capture_, void **hooks_, void *control_);
 
 typedef int (*zmq_hook_f)(void *frontend, void *backend, void *capture, zmq_msg_t* msg_, size_t n_, void *data_);
 typedef struct zmq_proxy_hook_t {

src/proxy.cpp

@@ -119,12 +119,14 @@ forward(
 
 int
 zmq::proxy (
-        class socket_base_t **frontend_,
-        class socket_base_t **backend_,
-        class socket_base_t *capture_,
-        class socket_base_t *control_,
-        zmq::proxy_hook_t **hook_)
+    class socket_base_t *frontend_,
+    class socket_base_t *backend_,
+    class socket_base_t *capture_,
+    class socket_base_t *control_,
+    zmq::proxy_hook_t *hook_)
 {
+    static zmq::proxy_hook_t dummy_hook = {NULL, NULL, NULL};
+
     msg_t msg;
     int rc = msg.init ();
     if (rc != 0)
@@ -135,41 +137,12 @@ zmq::proxy (
 
     int more;
     size_t moresz;
-    size_t n = 0; // number of pair of sockets: the array ends with NULL
-    for (;; n++) { // counts the number of pair of sockets
-        if (!frontend_[n] && !backend_[n])
-            break;
-        if (!frontend_[n] || !backend_[n]) {
-            errno = EFAULT;
-            return -1;
-        }
-    }
-    if (!n) {
-        errno = EFAULT;
-        return -1;
-    }
-    // avoid dynamic allocation as we have no guarranty to reach the deallocator => limit the chain length
-    zmq_assert(n <= ZMQ_PROXY_CHAIN_MAX_LENGTH);
-    zmq_pollitem_t items [2 * ZMQ_PROXY_CHAIN_MAX_LENGTH + 1]; // +1 for the control socket
-    static zmq_pollitem_t null_item = { NULL, 0, ZMQ_POLLIN, 0 };
-    static zmq::proxy_hook_t dummy_hook = {NULL, NULL, NULL};
-    static zmq::proxy_hook_t* no_hooks[ZMQ_PROXY_CHAIN_MAX_LENGTH];
-    if (!hook_)
-        hook_ = no_hooks;
-    else
-        for (size_t i = 0; i < n; i++)
-            if (!hook_[i]) // Check if a hook is used
-                hook_[i] = &dummy_hook;
-    for (size_t i = 0; i < n; i++) {
-        memcpy(&items[2 * i], &null_item, sizeof(null_item));
-        items[2 * i].socket =     frontend_[i];
-        memcpy(&items[2 * i + 1], &null_item, sizeof(null_item));
-        items[2 * i + 1].socket = backend_[i];
-        no_hooks[i] = &dummy_hook;
-    }
-    memcpy(&items[2 * n], &null_item, sizeof(null_item));
-    items[2 * n].socket =     control_;
-    int qt_poll_items = (control_ ? 2 * n + 1 : 2 * n);
+    zmq_pollitem_t items [] = {
+        { frontend_, 0, ZMQ_POLLIN, 0 },
+        { backend_, 0, ZMQ_POLLIN, 0 },
+        { control_, 0, ZMQ_POLLIN, 0 }
+    };
+    int qt_poll_items = (control_ ? 3 : 2);
 
     //  Proxy can be in these three states
     enum {
@@ -185,7 +158,7 @@ zmq::proxy (
             return -1;
 
         //  Process a control command if any
-        if (control_ && items [2 * n].revents & ZMQ_POLLIN) {
+        if (control_ && items [2].revents & ZMQ_POLLIN) {
             rc = control_->recv (&msg, 0);
             if (unlikely (rc < 0))
                 return -1;
@@ -214,23 +187,22 @@ zmq::proxy (
                 zmq_assert (false);
             }
         }
-
-        // process each pair of sockets
-        for (size_t i = 0; i < n; i++) {
-            //  Process a request
-            if (state == active
-            &&  items [2 * i].revents & ZMQ_POLLIN) {
-                rc = forward(frontend_[i], backend_[i], capture_, msg, hook_[i]->front2back_hook, hook_[i]->data);
-                if (unlikely (rc < 0))
-                    return -1;
-            }
-            //  Process a reply
-            if (state == active
-            &&  items [2 * i + 1].revents & ZMQ_POLLIN) {
-                rc = forward(backend_[i], frontend_[i], capture_, msg, hook_[i]->back2front_hook, hook_[i]->data);
-                if (unlikely (rc < 0))
-                    return -1;
-            }
+        // Check if a hook is used
+        if (!hook_)
+            hook_ = &dummy_hook;
+        //  Process a request
+        if (state == active
+        &&  items [0].revents & ZMQ_POLLIN) {
+            rc = forward(frontend_, backend_, capture_, msg, hook_->front2back_hook, hook_->data);
+            if (unlikely (rc < 0))
+                return -1;
+        }
+        //  Process a reply
+        if (state == active
+        &&  items [1].revents & ZMQ_POLLIN) {
+            rc = forward(backend_, frontend_, capture_, msg, hook_->back2front_hook, hook_->data);
+            if (unlikely (rc < 0))
+                return -1;
         }
     }
     return 0;

src/proxy.hpp

@@ -32,11 +32,11 @@ namespace zmq
     };
 
     int proxy (
-            class socket_base_t **frontend_,
-            class socket_base_t **backend_,
-            class socket_base_t *capture_ = NULL,
-            class socket_base_t *control_ = NULL, // backward compatibility without this argument
-            proxy_hook_t **hook_ = NULL // backward compatibility without this argument
+        class socket_base_t *frontend_,
+        class socket_base_t *backend_,
+        class socket_base_t *capture_ = NULL,
+        class socket_base_t *control_ = NULL, // backward compatibility without this argument
+        proxy_hook_t *hook_ = NULL // backward compatibility without this argument
         );
 }
 

src/zmq.cpp

@@ -1025,55 +1025,48 @@ typedef char check_proxy_hook_t_size
 
 int zmq_proxy (void *frontend_, void *backend_, void *capture_)
 {
-    zmq::socket_base_t* frontends_[] = {(zmq::socket_base_t*) frontend_, NULL};
-    zmq::socket_base_t* backends_[] = {(zmq::socket_base_t*) backend_, NULL};
+    if (!frontend_ || !backend_) {
+        errno = EFAULT;
+        return -1;
+    }
     return zmq::proxy (
-        (zmq::socket_base_t**) frontends_,
-        (zmq::socket_base_t**) backends_,
+        (zmq::socket_base_t*) frontend_,
+        (zmq::socket_base_t*) backend_,
         (zmq::socket_base_t*) capture_);
 }
 
 int zmq_proxy_steerable (void *frontend_, void *backend_, void *capture_, void *control_)
 {
-    zmq::socket_base_t* frontends_[] = {(zmq::socket_base_t*) frontend_, NULL};
-    zmq::socket_base_t* backends_[] = {(zmq::socket_base_t*) backend_, NULL};
+    if (!frontend_ || !backend_) {
+        errno = EFAULT;
+        return -1;
+    }
     return zmq::proxy (
-        (zmq::socket_base_t**) frontends_,
-        (zmq::socket_base_t**) backends_,
+        (zmq::socket_base_t*) frontend_,
+        (zmq::socket_base_t*) backend_,
         (zmq::socket_base_t*) capture_,
         (zmq::socket_base_t*) control_);
 }
 
 int zmq_proxy_hook (void *frontend_, void *backend_, void *capture_, void *hook_, void *control_)
 {
-    zmq::socket_base_t* frontends_[] = {(zmq::socket_base_t*) frontend_, NULL};
-    zmq::socket_base_t* backends_[] = {(zmq::socket_base_t*) backend_, NULL};
-    zmq::proxy_hook_t* hooks_[] = {(zmq::proxy_hook_t*) hook_};
-    return zmq::proxy (
-        (zmq::socket_base_t**) frontends_,
-        (zmq::socket_base_t**) backends_,
-        (zmq::socket_base_t*) capture_,
-        (zmq::socket_base_t*) control_,
-        (zmq::proxy_hook_t**)  hooks_);
-}
-
-int zmq_proxy_chain (void **frontends_, void **backends_, void *capture_, void **hooks_, void *control_)
-{
+    if (!frontend_ || !backend_) {
+        errno = EFAULT;
+        return -1;
+    }
     return zmq::proxy (
-        (zmq::socket_base_t**) frontends_,
-        (zmq::socket_base_t**) backends_,
+        (zmq::socket_base_t*) frontend_,
+        (zmq::socket_base_t*) backend_,
         (zmq::socket_base_t*) capture_,
         (zmq::socket_base_t*) control_,
-        (zmq::proxy_hook_t**)  hooks_);
+        (zmq::proxy_hook_t*)  hook_);
 }
 
 //  The deprecated device functionality
 
 int zmq_device (int /* type */, void *frontend_, void *backend_)
 {
-    zmq::socket_base_t* frontends_[] = {(zmq::socket_base_t*) frontend_, NULL};
-    zmq::socket_base_t* backends_[] = {(zmq::socket_base_t*) backend_, NULL};
     return zmq::proxy (
-        (zmq::socket_base_t**) frontends_,
-        (zmq::socket_base_t**) backends_);
+        (zmq::socket_base_t*) frontend_,
+        (zmq::socket_base_t*) backend_);
 }

tests/Makefile.am

@@ -44,7 +44,6 @@ noinst_PROGRAMS = test_system \
                   test_inproc_connect \
                   test_issue_566 \
                   test_proxy \
-                  test_proxy_chain \
                   test_abstract_ipc \
                   test_many_sockets \
                   test_ipc_wildcard \
@@ -111,7 +110,6 @@ test_conflate_SOURCES = test_conflate.cpp
 test_inproc_connect_SOURCES = test_inproc_connect.cpp
 test_issue_566_SOURCES = test_issue_566.cpp
 test_proxy_SOURCES = test_proxy.cpp
-test_proxy_chain_SOURCES = test_proxy_chain.cpp
 test_abstract_ipc_SOURCES = test_abstract_ipc.cpp
 test_many_sockets_SOURCES = test_many_sockets.cpp
 test_ipc_wildcard_SOURCES = test_ipc_wildcard.cpp