zeromq.*: make the size of the zmq_msg_t buffer vary depending on library version

This could fix the mac 32bit failure. It maybe happened because the
buffer was too small and data was overwritten.

diff --git a/extra/zeromq/ffi/ffi.factor b/extra/zeromq/ffi/ffi.factor
index e195e01fc71cddb1aabd31da1bfaa0f11a140b1d..8ff66536d91179d591b93d3c36d19b214a225c50 100644 (file)
--- a/extra/zeromq/ffi/ffi.factor
+++ b/extra/zeromq/ffi/ffi.factor
@@ -71,22 +71,19 @@ FUNCTION: int zmq_term ( void* context )
 ! 0MQ message definition.
 !
 
-STRUCT: zmq_msg_t
-    { data uchar[32] } ;
-
-FUNCTION: int zmq_msg_init ( zmq_msg_t* msg )
-FUNCTION: int zmq_msg_init_size ( zmq_msg_t* msg, size_t size )
-FUNCTION: int zmq_msg_init_data ( zmq_msg_t* msg, void* data, size_t size, void* ffn, void* hint )
-FUNCTION: int zmq_msg_send ( zmq_msg_t* msg, void* s, int flags )
-FUNCTION: int zmq_msg_recv ( zmq_msg_t* msg, void* s, int flags )
-FUNCTION: int zmq_msg_close ( zmq_msg_t* msg )
-FUNCTION: int zmq_msg_move ( zmq_msg_t* dest, zmq_msg_t* src )
-FUNCTION: int zmq_msg_copy ( zmq_msg_t* dest, zmq_msg_t* src )
-FUNCTION: void* zmq_msg_data ( zmq_msg_t* msg )
-FUNCTION: size_t zmq_msg_size ( zmq_msg_t* msg )
-FUNCTION: int zmq_msg_more ( zmq_msg_t* msg )
-FUNCTION: int zmq_msg_get ( zmq_msg_t* msg, int option )
-FUNCTION: int zmq_msg_set ( zmq_msg_t* msg, int option, int optval )
+FUNCTION: int zmq_msg_init ( void* msg )
+FUNCTION: int zmq_msg_init_size ( void* msg, size_t size )
+FUNCTION: int zmq_msg_init_data ( void* msg, void* data, size_t size, void* ffn, void* hint )
+FUNCTION: int zmq_msg_send ( void* msg, void* s, int flags )
+FUNCTION: int zmq_msg_recv ( void* msg, void* s, int flags )
+FUNCTION: int zmq_msg_close ( void* msg )
+FUNCTION: int zmq_msg_move ( void* dest, void* src )
+FUNCTION: int zmq_msg_copy ( void* dest, void* src )
+FUNCTION: void* zmq_msg_data ( void* msg )
+FUNCTION: size_t zmq_msg_size ( void* msg )
+FUNCTION: int zmq_msg_more ( void* msg )
+FUNCTION: int zmq_msg_get ( void* msg, int option )
+FUNCTION: int zmq_msg_set ( void* msg, int option, int optval )
 
 !
 ! 0MQ socket definition.
@@ -200,8 +197,8 @@ FUNCTION: int zmq_send ( void* s, void* buf, size_t len, int flags )
 FUNCTION: int zmq_recv ( void* s, void* buf, size_t len, int flags )
 FUNCTION: int zmq_socket_monitor ( void* s, c-string addr, int events )
 
-FUNCTION: int zmq_sendmsg ( void* s, zmq_msg_t* msg, int flags )
-FUNCTION: int zmq_recvmsg ( void* s, zmq_msg_t* msg, int flags )
+FUNCTION: int zmq_sendmsg ( void* s, void* msg, int flags )
+FUNCTION: int zmq_recvmsg ( void* s, void* msg, int flags )
 
 ! Experimental
 FUNCTION: int zmq_sendiov ( void* s, void* iov, size_t count, int flags )

diff --git a/extra/zeromq/zeromq-tests.factor b/extra/zeromq/zeromq-tests.factor
index 0fc97832cb695322e901dc68db77c79b2bebcbc6..0c7d4c9016d59645fac56b2d68621abf5e85d648 100644 (file)
--- a/extra/zeromq/zeromq-tests.factor
+++ b/extra/zeromq/zeromq-tests.factor
@@ -1,8 +1,13 @@
 ! Copyright (C) 2011-2013 Eungju PARK, John Benediktsson.
 ! See http://factorcode.org/license.txt for BSD license.
-USING: destructors tools.test zeromq ;
+USING: destructors sequences tools.test zeromq ;
 IN: zeromq.tests
 
+{ t } [
+    zmq-msg-size { 32 48 64 } member?
+] unit-test
+
+
 { B{ 0 1 10 33 244 255 } } [
     B{ 0 1 10 33 244 255 } byte-array>zmq-message
     [ zmq-message>byte-array ] with-disposal

diff --git a/extra/zeromq/zeromq.factor b/extra/zeromq/zeromq.factor
index b92e95f85adc6c1b7444eb2b660a635dd1a664d2..61e29c60c3493896040dd20979a881f226cc06fa 100644 (file)
--- a/extra/zeromq/zeromq.factor
+++ b/extra/zeromq/zeromq.factor
@@ -1,9 +1,8 @@
 ! Copyright (C) 2011-2013 Eungju PARK, John Benediktsson.
 ! See http://factorcode.org/license.txt for BSD license.
-
 USING: accessors alien.c-types alien.data arrays byte-arrays
-classes.struct combinators continuations destructors fry io
-kernel libc math namespaces sequences zeromq.ffi ;
+classes.struct combinators destructors fry kernel libc math math.order
+memoize sequences zeromq.ffi ;
 
 IN: zeromq
 
@@ -18,13 +17,30 @@ TUPLE: zmq-error n string ;
 : zmq-version ( -- version )
     { int int int } [ zmq_version ] with-out-parameters 3array ;
 
+: zmq-version-numeric ( -- n )
+    zmq-version first3 [ 100 * ] [ 10 * ] [ 1 * ] tri* + + ;
+
+! See
+! https://github.com/chuckremes/ffi-rzmq-core/blob/master/lib/ffi-rzmq-core/structures.rb
+MEMO: zmq-msg-size ( -- x )
+    zmq-version-numeric 410 <=> {
+        { +lt+ [ 32 ] }
+        { +eq+ [ 48 ] }
+        { +gt+ [ 64 ] }
+    } case ;
+
+! This word should be used to allocate the zmq_msg_t struct because
+! the size of it varies between versions.
+: <zmq_msg_t> ( -- byte-array )
+    zmq-msg-size (byte-array) ;
+
 GENERIC# zmq-setopt 2 ( obj name value -- )
 GENERIC# zmq-getopt 1 ( obj name -- value )
 
 TUPLE: zmq-message underlying ;
 
 : <zmq-message> ( -- msg )
-    zmq_msg_t <struct>
+    <zmq_msg_t>
     [ zmq_msg_init check-zmq-error ]
     [ zmq-message boa ] bi ;
 
@@ -32,7 +48,7 @@ M: zmq-message dispose
     underlying>> zmq_msg_close check-zmq-error ;
 
 : byte-array>zmq-message ( byte-array -- msg )
-    zmq_msg_t <struct>
+    <zmq_msg_t>
     [ over length zmq_msg_init_size check-zmq-error ]
     [ zmq_msg_data swap dup length memcpy ]
     [ zmq-message boa ] tri ;