rbczmq 0.1

data/ext/rbczmq/pollitem.h

@@ -0,0 +1,25 @@
+#ifndef RBCZMQ_POLLITEM_H
+#define RBCZMQ_POLLITEM_H
+
+typedef struct {
+    VALUE socket;
+    VALUE io;
+    VALUE events;
+    VALUE handler;
+    zmq_pollitem_t *item;
+} zmq_pollitem_wrapper;
+
+#define ZmqAssertPollitem(obj) ZmqAssertType(obj, rb_cZmqPollitem, "ZMQ::Pollitem")
+#define ZmqGetPollitem(obj) \
+    zmq_pollitem_wrapper *pollitem = NULL; \
+    ZmqAssertPollitem(obj); \
+    Data_Get_Struct(obj, zmq_pollitem_wrapper, pollitem); \
+    if (!pollitem) rb_raise(rb_eTypeError, "uninitialized ZMQ pollitem!");
+
+VALUE rb_czmq_pollitem_coerce(VALUE pollable);
+VALUE rb_czmq_pollitem_pollable(VALUE obj);
+VALUE rb_czmq_pollitem_events(VALUE obj);
+
+void _init_rb_czmq_pollitem();
+
+#endif

data/ext/rbczmq/rbczmq_ext.c

@@ -0,0 +1,198 @@
+#include <rbczmq_ext.h>
+
+VALUE rb_mZmq;
+VALUE rb_eZmqError;
+VALUE rb_cZmqContext;
+
+VALUE rb_cZmqSocket;
+VALUE rb_cZmqPubSocket;
+VALUE rb_cZmqSubSocket;
+VALUE rb_cZmqPushSocket;
+VALUE rb_cZmqPullSocket;
+VALUE rb_cZmqRouterSocket;
+VALUE rb_cZmqDealerSocket;
+VALUE rb_cZmqRepSocket;
+VALUE rb_cZmqReqSocket;
+VALUE rb_cZmqPairSocket;
+
+VALUE rb_cZmqFrame;
+VALUE rb_cZmqMessage;
+VALUE rb_cZmqLoop;
+VALUE rb_cZmqTimer;
+VALUE rb_cZmqPoller;
+VALUE rb_cZmqPollitem;
+
+st_table *frames_map = NULL;
+
+#ifdef HAVE_RUBY_ENCODING_H
+rb_encoding *binary_encoding;
+#endif
+
+/*
+ *  call-seq:
+ *     ZMQ.interrupted?    =>  boolean
+ *
+ *  Returns true if the process was interrupted by signal.
+ *
+ * === Examples
+ *     ZMQ.interrupted?    =>  boolean
+ *
+*/
+
+static VALUE rb_czmq_m_interrupted_p(ZMQ_UNUSED VALUE obj)
+{
+    return (zctx_interrupted == TRUE) ? Qtrue : Qfalse;
+}
+
+/*
+ *  call-seq:
+ *     ZMQ.version    =>  Array
+ *
+ *  Returns the libzmq version linked against.
+ *
+ * === Examples
+ *     ZMQ.version    =>  [2,1,11]
+ *
+*/
+
+static VALUE rb_czmq_m_version(ZMQ_UNUSED VALUE obj)
+{
+    int major, minor, patch;
+    zmq_version(&major, &minor, &patch);
+    return rb_ary_new3(3, INT2NUM(major), INT2NUM(minor), INT2NUM(patch));
+}
+
+/*
+ *  call-seq:
+ *     ZMQ.now    =>  Fixnum
+ *
+ *  Returns a current timestamp as a Fixnum
+ *
+ * === Examples
+ *     ZMQ.now    =>  1323206405148
+ *
+*/
+
+static VALUE rb_czmq_m_now(ZMQ_UNUSED VALUE obj)
+{
+    return INT2NUM(zclock_time());
+}
+
+/*
+ *  call-seq:
+ *     ZMQ.log("msg")    =>  nil
+ *
+ *  Logs a timestamped message to stdout.
+ *
+ * === Examples
+ *     ZMQ.log("msg")    =>  nil # 11-12-06 21:20:55 msg
+ *
+*/
+
+static VALUE rb_czmq_m_log(ZMQ_UNUSED VALUE obj, VALUE msg)
+{
+    Check_Type(msg, T_STRING);
+    zclock_log(StringValueCStr(msg));
+    return Qnil;
+}
+
+/*
+ *  call-seq:
+ *     ZMQ.error    =>  ZMQ::Error
+ *
+ *  Returns the last known ZMQ error (if any) as a ZMQ::Error instance.
+ *
+ * === Examples
+ *     ZMQ.error    =>  ZMQ::Error or nil
+ *
+*/
+
+static VALUE rb_czmq_m_error(ZMQ_UNUSED VALUE obj)
+{
+    int err;
+    err = zmq_errno();
+    if (err == 0) return Qnil;
+    return rb_exc_new2(rb_eZmqError, zmq_strerror(zmq_errno()));
+}
+
+/*
+ *  call-seq:
+ *     ZMQ.errno    =>  Fixnum
+ *
+ *  Returns the last known ZMQ errno (if any) as a Fixnum.
+ *
+ * === Examples
+ *     ZMQ.errno    =>  0
+ *
+*/
+
+static VALUE rb_czmq_m_errno(ZMQ_UNUSED VALUE obj)
+{
+    return INT2NUM(zmq_errno());
+}
+
+/*
+ *  call-seq:
+ *     ZMQ.interrupted!    =>  nil
+ *
+ *  Callback for Ruby signal handlers for terminating blocking functions and the reactor loop in libczmq.
+ *
+ * === Examples
+ *     ZMQ.interrupted!    =>  nil
+ *
+*/
+
+static VALUE rb_czmq_m_interrupted_bang(ZMQ_UNUSED VALUE obj)
+{
+    zctx_interrupted = 1;
+    return Qnil;
+}
+
+void Init_rbczmq_ext()
+{
+    frames_map = st_init_numtable();
+
+#ifdef HAVE_RUBY_ENCODING_H
+    binary_encoding = rb_enc_find("binary");
+#endif
+
+    rb_mZmq = rb_define_module("ZMQ");
+
+    rb_eZmqError = rb_define_class_under(rb_mZmq, "Error", rb_eStandardError);
+
+    rb_define_module_function(rb_mZmq, "interrupted?", rb_czmq_m_interrupted_p, 0);
+    rb_define_module_function(rb_mZmq, "version", rb_czmq_m_version, 0);
+    rb_define_module_function(rb_mZmq, "now", rb_czmq_m_now, 0);
+    rb_define_module_function(rb_mZmq, "log", rb_czmq_m_log, 1);
+    rb_define_module_function(rb_mZmq, "error", rb_czmq_m_error, 0);
+    rb_define_module_function(rb_mZmq, "errno", rb_czmq_m_errno, 0);
+    rb_define_module_function(rb_mZmq, "interrupted!", rb_czmq_m_interrupted_bang, 0);
+
+    rb_define_const(rb_mZmq, "POLLIN", INT2NUM(ZMQ_POLLIN));
+    rb_define_const(rb_mZmq, "POLLOUT", INT2NUM(ZMQ_POLLOUT));
+    rb_define_const(rb_mZmq, "POLLERR", INT2NUM(ZMQ_POLLERR));
+
+    rb_define_const(rb_mZmq, "PAIR", INT2NUM(ZMQ_PAIR));
+    rb_define_const(rb_mZmq, "SUB", INT2NUM(ZMQ_SUB));
+    rb_define_const(rb_mZmq, "PUB", INT2NUM(ZMQ_PUB));
+    rb_define_const(rb_mZmq, "REQ", INT2NUM(ZMQ_REQ));
+    rb_define_const(rb_mZmq, "REP", INT2NUM(ZMQ_REP));
+    rb_define_const(rb_mZmq, "DEALER", INT2NUM(ZMQ_DEALER));
+    rb_define_const(rb_mZmq, "ROUTER", INT2NUM(ZMQ_ROUTER));
+    rb_define_const(rb_mZmq, "PUSH", INT2NUM(ZMQ_PUSH));
+    rb_define_const(rb_mZmq, "PULL", INT2NUM(ZMQ_PULL));
+
+    rb_define_const(rb_mZmq, "EFSM", INT2NUM(EFSM));
+    rb_define_const(rb_mZmq, "ENOCOMPATPROTO", INT2NUM(ENOCOMPATPROTO));
+    rb_define_const(rb_mZmq, "ETERM", INT2NUM(ETERM));
+    rb_define_const(rb_mZmq, "EMTHREAD", INT2NUM(EMTHREAD));
+
+    _init_rb_czmq_context();
+    _init_rb_czmq_socket();
+    _init_rb_czmq_frame();
+    _init_rb_czmq_message();
+    _init_rb_czmq_timer();
+    _init_rb_czmq_loop();
+    _init_rb_czmq_poller();
+    _init_rb_czmq_pollitem();
+}

data/ext/rbczmq/rbczmq_ext.h

@@ -0,0 +1,94 @@
+#ifndef RBCZMQ_EXT_H
+#define RBCZMQ_EXT_H
+
+#include <czmq.h>
+#include "ruby.h"
+
+/* Compiler specific */
+
+#if defined(__GNUC__) && (__GNUC__ >= 3)
+#define ZMQ_UNUSED __attribute__ ((unused))
+#define ZMQ_NOINLINE __attribute__ ((noinline))
+#else
+#define ZMQ_UNUSED
+#define ZMQ_NOINLINE
+#endif
+
+#include <rbczmq_prelude.h>
+
+#define ZmqRaiseSysError() { \
+        printf("Sys error location: %s:%d\n", __FILE__,__LINE__); \
+        rb_sys_fail(zmq_strerror(zmq_errno())); \
+    }
+#define ZmqAssertSysError() if (zmq_errno() != 0 && zmq_errno() != EAGAIN) ZmqRaiseSysError();
+#define ZmqAssert(rc) \
+    if (rc == -1) { \
+        ZmqAssertSysError(); \
+        if (rc == ENOMEM) rb_memerror(); \
+        return Qfalse; \
+    }
+#define ZmqAssertObjOnAlloc(obj, wrapper) \
+    if (obj == NULL) { \
+        xfree(wrapper); \
+        ZmqAssertSysError(); \
+        rb_memerror(); \
+    }
+#define ZmqAssertType(obj, type, desc) \
+    if (!rb_obj_is_kind_of(obj,type)) \
+        rb_raise(rb_eTypeError, "wrong argument type %s (expected %s): %s", rb_obj_classname(obj), desc, RSTRING_PTR(rb_obj_as_string(obj)));
+
+extern VALUE rb_mZmq;
+extern VALUE rb_eZmqError;
+extern VALUE rb_cZmqContext;
+
+extern VALUE rb_cZmqSocket;
+extern VALUE rb_cZmqPubSocket;
+extern VALUE rb_cZmqSubSocket;
+extern VALUE rb_cZmqPushSocket;
+extern VALUE rb_cZmqPullSocket;
+extern VALUE rb_cZmqRouterSocket;
+extern VALUE rb_cZmqDealerSocket;
+extern VALUE rb_cZmqRepSocket;
+extern VALUE rb_cZmqReqSocket;
+extern VALUE rb_cZmqPairSocket;
+
+extern VALUE rb_cZmqFrame;
+extern VALUE rb_cZmqMessage;
+extern VALUE rb_cZmqLoop;
+extern VALUE rb_cZmqTimer;
+extern VALUE rb_cZmqPoller;
+extern VALUE rb_cZmqPollitem;
+
+extern st_table *frames_map;
+
+#include <context.h>
+#include <socket.h>
+#include <frame.h>
+#include <message.h>
+#include <loop.h>
+#include <timer.h>
+#include <poller.h>
+#include <pollitem.h>
+
+static inline char *rb_czmq_formatted_current_time()
+{
+    time_t curtime = time (NULL);
+    struct tm *loctime = localtime(&curtime);
+    char *formatted;
+    formatted = (char*)xmalloc(20);
+    strftime(formatted, 20, "%y-%m-%d %H:%M:%S ", loctime);
+    return formatted;
+}
+
+struct nogvl_device_args {
+    int type;
+#ifndef HAVE_RB_THREAD_BLOCKING_REGION
+    zctx_t *ctx;
+#endif
+    zmq_sock_wrapper *in;
+    zmq_sock_wrapper *out;
+    int rc;
+};
+typedef struct nogvl_device_args nogvl_device_args_t;
+
+#endif

data/ext/rbczmq/rbczmq_prelude.h

@@ -0,0 +1,22 @@
+#ifndef RBCZMQ_PRELUDE_H
+#define RBCZMQ_PRELUDE_H
+
+#ifndef RFLOAT_VALUE
+#define RFLOAT_VALUE(v) (RFLOAT(v)->value)
+#endif
+
+#ifdef RUBINIUS
+#include <rubinius.h>
+#else
+#ifdef JRUBY
+#include <jruby.h>
+#else
+#ifdef HAVE_RB_THREAD_BLOCKING_REGION
+#include <ruby19.h>
+#else
+#include <ruby18.h>
+#endif
+#endif
+#endif
+
+#endif

data/ext/rbczmq/rubinius.h

@@ -0,0 +1,24 @@
+#ifndef RBCZMQ_RUBINIUS_H
+#define RBCZMQ_RUBINIUS_H
+
+#define RSTRING_NOT_MODIFIED
+
+#ifdef HAVE_RUBY_ENCODING_H
+#include <ruby/st.h>
+#include <ruby/encoding.h>
+#include <ruby/io.h>
+extern rb_encoding *binary_encoding;
+#define ZmqEncode(str) rb_enc_associate(str, binary_encoding)
+#else
+#include "st.h"
+#define ZmqEncode(str) str
+#endif
+
+#define TRAP_BEG
+#define TRAP_END
+
+#define ZMQ_DEFAULT_SOCKET_TIMEOUT Qnil
+
+#define THREAD_PASS rb_thread_schedule();
+
+#endif

data/ext/rbczmq/ruby18.h

@@ -0,0 +1,43 @@
+#ifndef RBCZMQ_RUBY18_H
+#define RBCZMQ_RUBY18_H
+
+#define THREAD_PASS rb_thread_schedule();
+#define ZmqEncode(str) str
+#include "rubyio.h"
+#include "rubysig.h"
+#include "st.h"
+
+#ifndef RSTRING_PTR
+#define RSTRING_PTR(str) RSTRING(str)->ptr
+#endif
+#ifndef RSTRING_LEN
+#define RSTRING_LEN(s) (RSTRING(s)->len)
+#endif
+
+/*
+ * partial emulation of the 1.9 rb_thread_blocking_region under 1.8,
+ * this is enough for dealing with blocking I/O functions in the
+ * presence of threads.
+ */
+
+#define RUBY_UBF_IO ((rb_unblock_function_t *)-1)
+typedef void rb_unblock_function_t(void *);
+typedef VALUE rb_blocking_function_t(void *);
+static VALUE
+rb_thread_blocking_region(
+  rb_blocking_function_t *func, void *data1,
+  ZMQ_UNUSED rb_unblock_function_t *ubf,
+  ZMQ_UNUSED void *data2)
+{
+  VALUE rv;
+  TRAP_BEG;
+  rv = func(data1);
+  TRAP_END;
+  return rv;
+}
+
+struct timeval rb_time_interval _((VALUE));
+
+#define rb_errinfo() ruby_errinfo
+
+#endif

data/ext/rbczmq/ruby19.h

@@ -0,0 +1,15 @@
+#ifndef RBCZMQ_RUBY19_H
+#define RBCZMQ_RUBY19_H
+
+#include <ruby/encoding.h>
+#include <ruby/io.h>
+extern rb_encoding *binary_encoding;
+#define ZmqEncode(str) rb_enc_associate(str, binary_encoding)
+#ifndef THREAD_PASS
+#define THREAD_PASS rb_thread_schedule();
+#endif
+
+#define TRAP_BEG
+#define TRAP_END
+
+#endif

data/ext/rbczmq/socket.c

@@ -0,0 +1,1570 @@
+#include <rbczmq_ext.h>
+
+/*
+ * :nodoc:
+ *  Destroy the socket while the GIL is released - may block depending on socket linger value.
+ *
+*/
+static VALUE rb_czmq_nogvl_zsocket_destroy(void *ptr)
+{
+    zmq_sock_wrapper *sock = ptr;
+    errno = 0;
+    zsocket_destroy(sock->ctx, sock->socket);
+    return Qnil;
+}
+
+/*
+ * :nodoc:
+ *  Free all resources for a socket - invoked by the lower level ZMQ::Socket#destroy as well as the GC callback (some
+ *  regressions here still though).
+ *
+*/
+void rb_czmq_free_sock(zmq_sock_wrapper *sock)
+{
+    if (sock->ctx) {
+        rb_thread_blocking_region(rb_czmq_nogvl_zsocket_destroy, sock, RUBY_UBF_IO, 0);
+        if (zmq_errno() == ENOTSOCK) ZmqRaiseSysError();
+        sock->socket = NULL;
+        sock->flags |= ZMQ_SOCKET_DESTROYED;
+    }
+}
+
+/*
+ * :nodoc:
+ *  GC mark callback
+ *
+*/
+void rb_czmq_mark_sock(void *ptr)
+{
+    zmq_sock_wrapper *sock = (zmq_sock_wrapper *)ptr;
+    if (sock){
+        if (sock->verbose)
+            zclock_log ("I: %s socket %p, context %p: GC mark", zsocket_type_str(sock->socket), sock, sock->ctx);
+        rb_gc_mark(sock->endpoint);
+        rb_gc_mark(sock->thread);
+        rb_gc_mark(sock->recv_timeout);
+        rb_gc_mark(sock->send_timeout);
+    }
+}
+
+/*
+ * :nodoc:
+ *  GC free callback
+ *
+*/
+void rb_czmq_free_sock_gc(void *ptr)
+{
+    zmq_sock_wrapper *sock = (zmq_sock_wrapper *)ptr;
+    if (sock){
+        if (sock->verbose)
+            zclock_log ("I: %s socket %p, context %p: GC free", zsocket_type_str(sock->socket), sock, sock->ctx);
+/*
+        XXX: cyclic dependency
+        #4  0x0000000100712524 in zsockopt_set_linger (linger=1, socket=<value temporarily unavailable, due to optimizations>) at zsockopt.c:288
+        if (sock->socket != NULL && !(sock->flags & ZMQ_SOCKET_DESTROYED)) rb_czmq_free_sock(sock);
+*/
+#ifndef HAVE_RB_THREAD_BLOCKING_REGION
+        zlist_destroy(&(sock->str_buffer));
+        zlist_destroy(&(sock->frame_buffer));
+        zlist_destroy(&(sock->msg_buffer));
+#endif
+        xfree(sock);
+    }
+}
+
+/*
+ *  call-seq:
+ *     sock.close   =>  nil
+ *
+ *  Closes a socket. The GC will take the same action if a socket object is not reachable anymore on the next GC cycle.
+ *  This is a lower level API.
+ *
+ * === Examples
+ *     sock.close    =>  nil
+ *
+*/
+
+static VALUE rb_czmq_socket_close(VALUE obj)
+{
+    zmq_sock_wrapper *sock = NULL;
+    GetZmqSocket(obj);
+    ZmqSockGuardCrossThread(sock);
+    /* This is useless for production / real use cases as we can't query the state again OR assume
+    anything about the underlying connection. Merely doing the right thing. */
+    sock->state = ZMQ_SOCKET_PENDING;
+    rb_czmq_free_sock(sock);
+    return Qnil;
+}
+
+/*
+ *  call-seq:
+ *     sock.endpoint   =>  String or nil
+ *
+ *  Returns the endpoint this socket is currently connected to, if any.
+ *
+ * === Examples
+ *     ctx = ZMQ::Context.new
+ *     sock = ctx.socket(:PUSH)
+ *     sock.endpoint    =>   nil
+ *     sock.bind("inproc://test")
+ *     sock.endpoint    =>  "inproc://test"
+ *
+*/
+
+static VALUE rb_czmq_socket_endpoint(VALUE obj)
+{
+    zmq_sock_wrapper *sock = NULL;
+    GetZmqSocket(obj);
+    return sock->endpoint;
+}
+
+/*
+ *  call-seq:
+ *     sock.state   =>  String
+ *
+ *  Returns the current socket state, one of ZMQ::Socket::PENDING, ZMQ::Socket::BOUND or ZMQ::Socket::CONNECTED
+ *
+ * === Examples
+ *     ctx = ZMQ::Context.new
+ *     sock = ctx.socket(:PUSH)
+ *     sock.state       =>   ZMQ::Socket::PENDING
+ *     sock.bind("inproc://test")
+ *     sock.state       =>   ZMQ::Socket::BOUND
+ *
+*/
+
+static VALUE rb_czmq_socket_state(VALUE obj)
+{
+    zmq_sock_wrapper *sock = NULL;
+    GetZmqSocket(obj);
+    return INT2NUM(sock->state);
+}
+
+/*
+ *  call-seq:
+ *     sock.fd   =>  Fixnum
+ *
+ *  Returns a file descriptor reference for integrating this socket with an externel event loop or multiplexor.
+ *  Edge-triggered notification of I/O state changes.
+ *
+ * === Examples
+ *     ctx = ZMQ::Context.new
+ *     sock = ctx.socket(:PUSH)
+ *     sock.fd       =>   -1
+ *     sock.bind("inproc://test")
+ *     sock.fd       =>   4
+ *
+*/
+
+static VALUE rb_czmq_socket_fd(VALUE obj)
+{
+    zmq_sock_wrapper *sock = NULL;
+    GetZmqSocket(obj);
+    if (sock->state == ZMQ_SOCKET_PENDING) return INT2NUM(-1);
+    return INT2NUM(zsockopt_fd(sock->socket));
+}
+
+/*
+ * :nodoc:
+ *  Binds to an endpoint while the GIL is released.
+ *
+*/
+VALUE rb_czmq_nogvl_socket_bind(void *ptr)
+{
+    int rc;
+    struct nogvl_conn_args *args = ptr;
+    errno = 0;
+    zmq_sock_wrapper *socket = args->socket;
+#ifdef HAVE_RB_THREAD_BLOCKING_REGION
+    rc = zsocket_bind(socket->socket, args->endpoint);
+#else
+    rc = zsocket_bind(socket->socket, args->endpoint);
+#endif
+    return (VALUE)rc;
+}
+
+/*
+ * :nodoc:
+ *  Connects to an endpoint while the GIL is released.
+ *
+*/
+VALUE rb_czmq_nogvl_socket_connect(void *ptr)
+{
+    int rc;
+    struct nogvl_conn_args *args = ptr;
+    errno = 0;
+    zmq_sock_wrapper *socket = args->socket;
+#ifdef HAVE_RB_THREAD_BLOCKING_REGION
+    rc = zsocket_connect(socket->socket, args->endpoint);
+#else
+    rc = zsocket_connect(socket->socket, args->endpoint);
+#endif
+    return (VALUE)rc;
+}
+
+/*
+ *  call-seq:
+ *     sock.bind("inproc://test")   =>  Fixnum
+ *
+ *  Binds to a given endpoint. When the port number is '*', attempts to bind to a free port. Always returns the port
+ *  number on success.
+ *
+ * === Examples
+ *     ctx = ZMQ::Context.new
+ *     sock = ctx.socket(:PUSH)
+ *     sock.bind("tcp://localhost:*")    =>  5432
+ *
+*/
+
+static VALUE rb_czmq_socket_bind(VALUE obj, VALUE endpoint)
+{
+    struct nogvl_conn_args args;
+    int rc;
+    zmq_sock_wrapper *sock = NULL;
+    GetZmqSocket(obj);
+    ZmqSockGuardCrossThread(sock);
+    Check_Type(endpoint, T_STRING);
+    args.socket = sock;
+    args.endpoint = StringValueCStr(endpoint);
+    rc = (int)rb_thread_blocking_region(rb_czmq_nogvl_socket_bind, (void *)&args, RUBY_UBF_IO, 0);
+    if (rc == -1) ZmqRaiseSysError();
+    if (sock->verbose)
+        zclock_log ("I: %s socket %p: bound \"%s\"", zsocket_type_str(sock->socket), obj, StringValueCStr(endpoint));
+    sock->state = ZMQ_SOCKET_BOUND;
+    sock->endpoint = rb_str_new4(endpoint);
+    return INT2NUM(rc);
+}
+
+/*
+ *  call-seq:
+ *     sock.connect("tcp://localhost:3456")   =>  boolean
+ *
+ *  Attempts to connect to a given endpoint.
+ *
+ * === Examples
+ *     ctx = ZMQ::Context.new
+ *     rep = ctx.socket(:REP)
+ *     port = rep.bind("tcp://localhost:*")    =>  5432
+ *     req = ctx.socket(:REQ)
+ *     req.connect("tcp://localhost:#{port}")   => true
+ *
+*/
+
+static VALUE rb_czmq_socket_connect(VALUE obj, VALUE endpoint)
+{
+    struct nogvl_conn_args args;
+    int rc;
+    zmq_sock_wrapper *sock = NULL;
+    GetZmqSocket(obj);
+    ZmqSockGuardCrossThread(sock);
+    Check_Type(endpoint, T_STRING);
+    args.socket = sock;
+    args.endpoint = StringValueCStr(endpoint);
+    rc = (int)rb_thread_blocking_region(rb_czmq_nogvl_socket_connect, (void *)&args, RUBY_UBF_IO, 0);
+    ZmqAssert(rc);
+    if (sock->verbose)
+        zclock_log ("I: %s socket %p: connected \"%s\"", zsocket_type_str(sock->socket), obj, StringValueCStr(endpoint));
+    sock->state = ZMQ_SOCKET_CONNECTED;
+    sock->endpoint = rb_str_new4(endpoint);
+    return Qtrue;
+}
+
+/*
+ *  call-seq:
+ *     sock.verbose = true   =>  nil
+ *
+ *  Let this socket be verbose - dumps a lot of data to stdout for debugging.
+ *
+ * === Examples
+ *     ctx = ZMQ::Context.new
+ *     sock = ctx.socket(:REP)
+ *     sock.verbose = true    =>  nil
+ *
+*/
+
+static VALUE rb_czmq_socket_set_verbose(VALUE obj, VALUE level)
+{
+    Bool vlevel;
+    zmq_sock_wrapper *sock = NULL;
+    GetZmqSocket(obj);
+    vlevel = (level == Qtrue) ? TRUE : FALSE;
+    sock->verbose = vlevel;
+    return Qnil;
+}
+
+/*
+ * :nodoc:
+ *  Sends a raw string while the GIL is released.
+ *
+*/
+static VALUE rb_czmq_nogvl_zstr_send(void *ptr)
+{
+    struct nogvl_send_args *args = ptr;
+    errno = 0;
+    zmq_sock_wrapper *socket = args->socket;
+#ifdef HAVE_RB_THREAD_BLOCKING_REGION
+    return (VALUE)zstr_send(socket->socket, args->msg);
+#else
+    if (rb_thread_alone()) return (VALUE)zstr_send_nowait(socket->socket, args->msg);
+try_writable:
+    if ((zsockopt_events(socket->socket) & ZMQ_POLLOUT) == ZMQ_POLLOUT) {
+        return (VALUE)zstr_send_nowait(socket->socket, args->msg);
+    } else {
+        rb_thread_wait_fd(zsockopt_fd(socket->socket));
+        goto try_writable;
+    }
+#endif
+}
+
+/*
+ * :nodoc:
+ *  Sends a raw string with the multi flag set while the GIL is released.
+ *
+*/
+static VALUE rb_czmq_nogvl_zstr_sendm(void *ptr)
+{
+    struct nogvl_send_args *args = ptr;
+    errno = 0;
+    zmq_sock_wrapper *socket = args->socket;
+#ifdef HAVE_RB_THREAD_BLOCKING_REGION
+    return (VALUE)zstr_sendm(socket->socket, args->msg);
+#else
+    if (rb_thread_alone()) return (VALUE)zstr_sendm(socket->socket, args->msg);
+try_writable:
+    if ((zsockopt_events(socket->socket) & ZMQ_POLLOUT) == ZMQ_POLLOUT) {
+        return (VALUE)zstr_sendm(socket->socket, args->msg);
+    } else {
+        rb_thread_wait_fd(zsockopt_fd(socket->socket));
+        goto try_writable;
+    }
+#endif
+}
+
+/*
+ *  call-seq:
+ *     sock.send("message")  =>  boolean
+ *
+ *  Sends a string to this ZMQ socket.
+ *
+ * === Examples
+ *     ctx = ZMQ::Context.new
+ *     sock = ctx.socket(:REQ)
+ *     sock.connect("inproc://test")
+ *     sock.send("message")    =>  true
+ *
+*/
+
+static VALUE rb_czmq_socket_send(VALUE obj, VALUE msg)
+{
+    int rc;
+    struct nogvl_send_args args;
+    zmq_sock_wrapper *sock = NULL;
+    GetZmqSocket(obj);
+    ZmqAssertSocketNotPending(sock, "can only send on a bound or connected socket!");
+    ZmqSockGuardCrossThread(sock);
+    Check_Type(msg, T_STRING);
+    args.socket = sock;
+    args.msg = StringValueCStr(msg);
+    rc = (int)rb_thread_blocking_region(rb_czmq_nogvl_zstr_send, (void *)&args, RUBY_UBF_IO, 0);
+    ZmqAssert(rc);
+    if (sock->verbose)
+        zclock_log ("I: %s socket %p: send \"%s\"", zsocket_type_str(sock->socket), obj, StringValueCStr(msg));
+    return Qtrue;
+}
+
+/*
+ *  call-seq:
+ *     sock.sendm("message")  =>  boolean
+ *
+ *  Sends a string to this ZMQ socket, with a more flag set.
+ *
+ * === Examples
+ *     ctx = ZMQ::Context.new
+ *     sock = ctx.socket(:REQ)
+ *     sock.connect("inproc://test")
+ *     sock.sendm("mes")    =>  true
+ *     sock.sendm("sage")    =>  true
+ *
+*/
+
+static VALUE rb_czmq_socket_sendm(VALUE obj, VALUE msg)
+{
+    int rc;
+    struct nogvl_send_args args;
+    zmq_sock_wrapper *sock = NULL;
+    GetZmqSocket(obj);
+    ZmqAssertSocketNotPending(sock, "can only send on a bound or connected socket!");
+    ZmqSockGuardCrossThread(sock);
+    Check_Type(msg, T_STRING);
+    args.socket = sock;
+    args.msg = StringValueCStr(msg);
+    rc = (int)rb_thread_blocking_region(rb_czmq_nogvl_zstr_sendm, (void *)&args, RUBY_UBF_IO, 0);
+    ZmqAssert(rc);
+    if (sock->verbose)
+        zclock_log ("I: %s socket %p: sendm \"%s\"", zsocket_type_str(sock->socket), sock->socket, StringValueCStr(msg));
+    return Qtrue;
+}
+
+/*
+ * :nodoc:
+ *  Receives a raw string while the GIL is released.
+ *
+*/
+static VALUE rb_czmq_nogvl_recv(void *ptr)
+{
+    struct nogvl_recv_args *args = ptr;
+    errno = 0;
+    zmq_sock_wrapper *socket = args->socket;
+#ifdef HAVE_RB_THREAD_BLOCKING_REGION
+    return (VALUE)zstr_recv(socket->socket);
+#else
+    if (zlist_size(socket->str_buffer) != 0)
+       return (VALUE)zlist_pop(socket->str_buffer);
+try_readable:
+    if ((zsockopt_events(socket->socket) & ZMQ_POLLIN) == ZMQ_POLLIN) {
+        do {
+            zlist_append(socket->str_buffer, zstr_recv_nowait(socket->socket));
+        } while (zmq_errno() != EAGAIN && zmq_errno() != EINTR);
+        return (VALUE)zlist_pop(socket->str_buffer);
+     } else {
+        rb_thread_wait_fd(zsockopt_fd(socket->socket));
+        goto try_readable;
+     }
+#endif
+}
+
+/*
+ *  call-seq:
+ *     sock.recv =>  String or nil
+ *
+ *  Receive a string from this ZMQ socket. May block depending on the socket type.
+ *
+ * === Examples
+ *     ctx = ZMQ::Context.new
+ *     sock = ctx.socket(:REP)
+ *     sock.bind("inproc://test")
+ *     sock.recv    =>  "message"
+ *
+*/
+
+static VALUE rb_czmq_socket_recv(VALUE obj)
+{
+    char *str = NULL;
+    struct nogvl_recv_args args;
+    VALUE result = Qnil;
+    zmq_sock_wrapper *sock = NULL;
+    GetZmqSocket(obj);
+    ZmqAssertSocketNotPending(sock, "can only receive on a bound or connected socket!");
+    ZmqSockGuardCrossThread(sock);
+    args.socket = sock;
+    str = (char *)rb_thread_blocking_region(rb_czmq_nogvl_recv, (void *)&args, RUBY_UBF_IO, 0);
+    if (str == NULL) return result;
+    ZmqAssertSysError();
+    if (sock->verbose)
+        zclock_log ("I: %s socket %p: recv \"%s\"", zsocket_type_str(sock->socket), sock->socket, str);
+    result = ZmqEncode(rb_str_new2(str));
+    free(str);
+    return result;
+}
+
+/*
+ *  call-seq:
+ *     sock.recv_nonblock =>  String or nil
+ *
+ *  Receive a string from this ZMQ socket. Does not block.
+ *
+ * === Examples
+ *     ctx = ZMQ::Context.new
+ *     sock = ctx.socket(:REP)
+ *     sock.bind("inproc://test")
+ *     sock.recv_nonblock    =>  "message"
+ *
+*/
+
+static VALUE rb_czmq_socket_recv_nonblock(VALUE obj)
+{
+    char *str = NULL;
+    errno = 0;
+    VALUE result = Qnil;
+    zmq_sock_wrapper *sock = NULL;
+    GetZmqSocket(obj);
+    ZmqAssertSocketNotPending(sock, "can only receive on a bound or connected socket!");
+    ZmqSockGuardCrossThread(sock);
+    str = zstr_recv_nowait(sock->socket);
+    if (str == NULL) return result;
+    ZmqAssertSysError();
+    if (sock->verbose)
+        zclock_log ("I: %s socket %p: recv_nonblock \"%s\"", zsocket_type_str(sock->socket), sock->socket, str);
+    result = ZmqEncode(rb_str_new2(str));
+    free(str);
+    return result;
+}
+
+/*
+ * :nodoc:
+ *  Sends a frame while the GIL is released.
+ *
+*/
+static VALUE rb_czmq_nogvl_send_frame(void *ptr)
+{
+    struct nogvl_send_frame_args *args = ptr;
+    errno = 0;
+    zmq_sock_wrapper *socket = args->socket;
+#ifdef HAVE_RB_THREAD_BLOCKING_REGION
+    return (VALUE)zframe_send(&(args->frame), socket->socket, args->flags);
+#else
+    if (rb_thread_alone()) return (VALUE)zframe_send(&(args->frame), socket->socket, args->flags);
+try_writable:
+    if ((zsockopt_events(socket->socket) & ZMQ_POLLOUT) == ZMQ_POLLOUT) {
+        return (VALUE)zframe_send(&(args->frame), socket->socket, args->flags);
+    } else {
+        rb_thread_wait_fd(zsockopt_fd(socket->socket));
+        goto try_writable;
+    }
+#endif
+}
+
+/*
+ *  call-seq:
+ *     sock.send_frame(frame) =>  nil
+ *
+ *  Sends a ZMQ::Frame instance to this socket.
+ *
+ * === Examples
+ *     ctx = ZMQ::Context.new
+ *     sock = ctx.socket(:REP)
+ *     sock.bind("inproc://test")
+ *     frame = ZMQ::Frame("frame")
+ *     sock.send_frame(frame)    =>  nil
+ *     frame = ZMQ::Frame("multi")
+ *     sock.send_frame(frame, ZMQ::Frame::MORE)
+ *
+*/
+
+static VALUE rb_czmq_socket_send_frame(int argc, VALUE *argv, VALUE obj)
+{
+    struct nogvl_send_frame_args args;
+    VALUE frame_obj;
+    VALUE flags;
+    char print_prefix[255];
+    char *cur_time = NULL;
+    zframe_t *print_frame = NULL;
+    int rc, flgs;
+    zmq_sock_wrapper *sock = NULL;
+    GetZmqSocket(obj);
+    ZmqAssertSocketNotPending(sock, "can only send on a bound or connected socket!");
+    ZmqSockGuardCrossThread(sock);
+    rb_scan_args(argc, argv, "11", &frame_obj, &flags);
+    ZmqGetFrame(frame_obj);
+
+    if (NIL_P(flags)) {
+        flgs = 0;
+    } else {
+        if (SYMBOL_P(flags)) flags = rb_const_get_at(rb_cZmqFrame, rb_to_id(flags));
+        Check_Type(flags, T_FIXNUM);
+        flgs = FIX2INT(flags);
+    }
+
+    if (sock->verbose) {
+        cur_time = rb_czmq_formatted_current_time();
+        print_frame = (flgs & ZFRAME_REUSE) ? frame : zframe_dup(frame);
+    }
+    args.socket = sock;
+    args.frame = frame;
+    args.flags = flgs;
+    rc = (int)rb_thread_blocking_region(rb_czmq_nogvl_send_frame, (void *)&args, RUBY_UBF_IO, 0);
+    ZmqAssert(rc);
+    if (sock->verbose) ZmqDumpFrame("send_frame", print_frame);
+    return Qtrue;
+}
+
+/*
+ * :nodoc:
+ *  Sends a message while the GIL is released.
+ *
+*/
+static VALUE rb_czmq_nogvl_send_message(void *ptr)
+{
+    struct nogvl_send_message_args *args = ptr;
+    zmq_sock_wrapper *socket = args->socket;
+    errno = 0;
+#ifdef HAVE_RB_THREAD_BLOCKING_REGION
+    zmsg_send(&(args->message), socket->socket);
+#else
+    if (rb_thread_alone()) {
+        zmsg_send(&(args->message), socket->socket);
+        return Qnil;
+    }
+try_writable:
+    if ((zsockopt_events(socket->socket) & ZMQ_POLLOUT) == ZMQ_POLLOUT) {
+        zmsg_send(&(args->message), socket->socket);
+    } else {
+        rb_thread_wait_fd(zsockopt_fd(socket->socket));
+        goto try_writable;
+    }
+#endif
+    return Qnil;
+}
+
+/*
+ *  call-seq:
+ *     sock.send_message(msg) =>  nil
+ *
+ *  Sends a ZMQ::Message instance to this socket.
+ *
+ * === Examples
+ *     ctx = ZMQ::Context.new
+ *     sock = ctx.socket(:REP)
+ *     sock.bind("inproc://test")
+ *     msg = ZMQ::Message.new
+ *     msg.push ZMQ::Frame("header")
+ *     sock.send_message(msg)   =>  nil
+ *
+*/
+
+static VALUE rb_czmq_socket_send_message(VALUE obj, VALUE message_obj)
+{
+    struct nogvl_send_message_args args;
+    zmsg_t *print_message = NULL;
+    zmq_sock_wrapper *sock = NULL;
+    GetZmqSocket(obj);
+    ZmqAssertSocketNotPending(sock, "can only send on a bound or connected socket!");
+    ZmqSockGuardCrossThread(sock);
+    ZmqGetMessage(message_obj);
+    if (sock->verbose) print_message = zmsg_dup(message->message);
+    args.socket = sock;
+    args.message = message->message;
+    rb_thread_blocking_region(rb_czmq_nogvl_send_message, (void *)&args, RUBY_UBF_IO, 0);
+    message->flags |= ZMQ_MESSAGE_DESTROYED;
+    if (sock->verbose) ZmqDumpMessage("send_message", print_message);
+    return Qnil;
+}
+
+/*
+ * :nodoc:
+ *  Receives a frame while the GIL is released.
+ *
+*/
+static VALUE rb_czmq_nogvl_recv_frame(void *ptr)
+{
+    struct nogvl_recv_args *args = ptr;
+    errno = 0;
+    zmq_sock_wrapper *socket = args->socket;
+#ifdef HAVE_RB_THREAD_BLOCKING_REGION
+    return (VALUE)zframe_recv(socket->socket);
+#else
+    if (zlist_size(socket->frame_buffer) != 0)
+       return (VALUE)zlist_pop(socket->frame_buffer);
+try_readable:
+    if ((zsockopt_events(socket->socket) & ZMQ_POLLIN) == ZMQ_POLLIN) {
+        do {
+            zlist_append(socket->frame_buffer, zframe_recv_nowait(socket->socket));
+        } while (zmq_errno() != EAGAIN && zmq_errno() != EINTR);
+        return (VALUE)zlist_pop(socket->frame_buffer);
+     } else {
+        rb_thread_wait_fd(zsockopt_fd(socket->socket));
+        goto try_readable;
+     }
+#endif
+}
+
+/*
+ *  call-seq:
+ *     sock.recv_frame =>  ZMQ::Frame or nil
+ *
+ *  Receives a ZMQ frame from this socket.
+ *
+ * === Examples
+ *     ctx = ZMQ::Context.new
+ *     sock = ctx.socket(:REP)
+ *     sock.bind("inproc://test")
+ *     sock.recv_frame  =>  ZMQ::Frame or nil
+ *
+*/
+
+static VALUE rb_czmq_socket_recv_frame(VALUE obj)
+{
+    zframe_t *frame = NULL;
+    struct nogvl_recv_args args;
+    char print_prefix[255];
+    char *cur_time = NULL;
+    zmq_sock_wrapper *sock = NULL;
+    GetZmqSocket(obj);
+    ZmqAssertSocketNotPending(sock, "can only receive on a bound or connected socket!");
+    ZmqSockGuardCrossThread(sock);
+    args.socket = sock;
+    frame = (zframe_t *)rb_thread_blocking_region(rb_czmq_nogvl_recv_frame, (void *)&args, RUBY_UBF_IO, 0);
+    if (frame == NULL) return Qnil;
+    if (sock->verbose) {
+        cur_time = rb_czmq_formatted_current_time();
+        ZmqDumpFrame("recv_frame", frame);
+    }
+    return rb_czmq_alloc_frame(frame);
+}
+
+/*
+ *  call-seq:
+ *     sock.recv_frame_nonblock =>  ZMQ::Frame or nil
+ *
+ *  Receives a ZMQ frame from this socket. Does not block
+ *
+ * === Examples
+ *     ctx = ZMQ::Context.new
+ *     sock = ctx.socket(:REP)
+ *     sock.bind("inproc://test")
+ *     sock.recv_frame_nonblock  =>  ZMQ::Frame or nil
+ *
+*/
+
+static VALUE rb_czmq_socket_recv_frame_nonblock(VALUE obj)
+{
+    zframe_t *frame = NULL;
+    char print_prefix[255];
+    char *cur_time = NULL;
+    errno = 0;
+    zmq_sock_wrapper *sock = NULL;
+    GetZmqSocket(obj);
+    ZmqAssertSocketNotPending(sock, "can only receive on a bound or connected socket!");
+    ZmqSockGuardCrossThread(sock);
+    frame = zframe_recv_nowait(sock->socket);
+    if (frame == NULL) return Qnil;
+    if (sock->verbose) {
+        cur_time = rb_czmq_formatted_current_time();
+        ZmqDumpFrame("recv_frame_nonblock", frame);
+    }
+    return rb_czmq_alloc_frame(frame);
+}
+
+/*
+ * :nodoc:
+ *  Receives a message while the GIL is released.
+ *
+*/
+static VALUE rb_czmq_nogvl_recv_message(void *ptr)
+{
+    struct nogvl_recv_args *args = ptr;
+    errno = 0;
+    zmq_sock_wrapper *socket = args->socket;
+#ifdef HAVE_RB_THREAD_BLOCKING_REGION
+    return (VALUE)zmsg_recv(socket->socket);
+#else
+    if (zlist_size(socket->msg_buffer) != 0)
+       return (VALUE)zlist_pop(socket->msg_buffer);
+try_readable:
+    if ((zsockopt_events(socket->socket) & ZMQ_POLLIN) == ZMQ_POLLIN) {
+        do {
+            zlist_append(socket->msg_buffer, zmsg_recv(socket->socket));
+        } while (zmq_errno() != EAGAIN && zmq_errno() != EINTR);
+        return (VALUE)zlist_pop(socket->msg_buffer);
+     } else {
+        rb_thread_wait_fd(zsockopt_fd(socket->socket));
+        goto try_readable;
+     }
+#endif
+}
+
+/*
+ *  call-seq:
+ *     sock.recv_message =>  ZMQ::Message or nil
+ *
+ *  Receives a ZMQ message from this socket.
+ *
+ * === Examples
+ *     ctx = ZMQ::Context.new
+ *     sock = ctx.socket(:REP)
+ *     sock.bind("inproc://test")
+ *     sock.recv_message  =>  ZMQ::Message or nil
+ *
+*/
+
+static VALUE rb_czmq_socket_recv_message(VALUE obj)
+{
+    zmsg_t *message = NULL;
+    struct nogvl_recv_args args;
+    zmq_sock_wrapper *sock = NULL;
+    GetZmqSocket(obj);
+    ZmqAssertSocketNotPending(sock, "can only receive on a bound or connected socket!");
+    ZmqSockGuardCrossThread(sock);
+    args.socket = sock;
+    message = (zmsg_t *)rb_thread_blocking_region(rb_czmq_nogvl_recv_message, (void *)&args, RUBY_UBF_IO, 0);
+    if (message == NULL) return Qnil;
+    if (sock->verbose) ZmqDumpMessage("recv_message", message);
+    return rb_czmq_alloc_message(message);
+}
+
+/*
+ *  call-seq:
+ *     sock.recv_timeout = 5 =>  nil
+ *
+ *  Sets a receive timeout for this socket.
+ *
+ * === Examples
+ *     ctx = ZMQ::Context.new
+ *     sock = ctx.socket(:REP)
+ *     sock.recv_timeout = 5 => nil
+ *
+*/
+
+static VALUE rb_czmq_socket_set_recv_timeout(VALUE obj, VALUE timeout)
+{
+    zmq_sock_wrapper *sock = NULL;
+    GetZmqSocket(obj);
+    if (TYPE(timeout) != T_FIXNUM && TYPE(timeout) != T_FLOAT) rb_raise(rb_eTypeError, "wrong timeout type %s (expected Fixnum or Float)", RSTRING_PTR(rb_obj_as_string(timeout)));
+    sock->recv_timeout = timeout;
+    return Qnil;
+}
+
+/*
+ *  call-seq:
+ *     sock.recv_timeout =>  Fixnum or nil
+ *
+ *  Returns the recv timeout currently associated with this socket.
+ *
+ * === Examples
+ *     ctx = ZMQ::Context.new
+ *     sock = ctx.socket(:REP)
+ *     sock.recv_timeout = 5
+ *     sock.recv_timeout   =>   5
+ *
+*/
+
+static VALUE rb_czmq_socket_recv_timeout(VALUE obj)
+{
+    zmq_sock_wrapper *sock = NULL;
+    GetZmqSocket(obj);
+    return sock->recv_timeout;
+}
+
+/*
+ *  call-seq:
+ *     sock.send_timeout = 5 =>  nil
+ *
+ *  Sets a send timeout for this socket.
+ *
+ * === Examples
+ *     ctx = ZMQ::Context.new
+ *     sock = ctx.socket(:REP)
+ *     sock.send_timeout = 5 => nil
+ *
+*/
+
+static VALUE rb_czmq_socket_set_send_timeout(VALUE obj, VALUE timeout)
+{
+    zmq_sock_wrapper *sock = NULL;
+    GetZmqSocket(obj);
+    if (TYPE(timeout) != T_FIXNUM && TYPE(timeout) != T_FLOAT) rb_raise(rb_eTypeError, "wrong timeout type %s (expected Fixnum or Float)", RSTRING_PTR(rb_obj_as_string(timeout)));
+    sock->send_timeout = timeout;
+    return Qnil;
+}
+
+/*
+ *  call-seq:
+ *     sock.send_timeout =>  Fixnum or nil
+ *
+ *  Returns the send timeout currently associated with this socket.
+ *
+ * === Examples
+ *     ctx = ZMQ::Context.new
+ *     sock = ctx.socket(:REP)
+ *     sock.send_timeout = 5
+ *     sock.send_timeout   =>   5
+ *
+*/
+
+static VALUE rb_czmq_socket_send_timeout(VALUE obj)
+{
+    zmq_sock_wrapper *sock = NULL;
+    GetZmqSocket(obj);
+    return sock->send_timeout;
+}
+
+/*
+ *  call-seq:
+ *     sock.hwm =>  Fixnum
+ *
+ *  Returns the socket HWM (High Water Mark) value.
+ *
+ * === Examples
+ *     ctx = ZMQ::Context.new
+ *     sock = ctx.socket(:REP)
+ *     sock.hwm  =>  0
+ *
+*/
+
+static VALUE rb_czmq_socket_opt_hwm(VALUE obj)
+{
+    zmq_sock_wrapper *sock = NULL;
+    GetZmqSocket(obj);
+    return INT2NUM(zsockopt_hwm(sock->socket));
+}
+
+/*
+ *  call-seq:
+ *     sock.hwm = 100 =>  nil
+ *
+ *  Sets the socket HWM (High Water Mark() value.
+ *
+ * === Examples
+ *     ctx = ZMQ::Context.new
+ *     sock = ctx.socket(:REP)
+ *     sock.hwm = 100  =>  nil
+ *     sock.hwm  =>  100
+ *
+*/
+
+static VALUE rb_czmq_socket_set_opt_hwm(VALUE obj, VALUE value)
+{
+    zmq_sock_wrapper *sock = NULL;
+    ZmqSetSockOpt(obj, zsockopt_set_hwm, "HWM", value);
+}
+
+/*
+ *  call-seq:
+ *     sock.swap =>  Fixnum
+ *
+ *  Returns the socket SWAP value.
+ *
+ * === Examples
+ *     ctx = ZMQ::Context.new
+ *     sock = ctx.socket(:REP)
+ *     sock.swap  =>  0
+ *
+*/
+
+static VALUE rb_czmq_socket_opt_swap(VALUE obj)
+{
+    zmq_sock_wrapper *sock = NULL;
+    GetZmqSocket(obj);
+    return INT2NUM(zsockopt_swap(sock->socket));
+}
+
+/*
+ *  call-seq:
+ *     sock.swap = 100 =>  nil
+ *
+ *  Sets the socket SWAP value.
+ *
+ * === Examples
+ *     ctx = ZMQ::Context.new
+ *     sock = ctx.socket(:REP)
+ *     sock.swap = 100  =>  nil
+ *
+*/
+
+static VALUE rb_czmq_socket_set_opt_swap(VALUE obj, VALUE value)
+{
+    zmq_sock_wrapper *sock = NULL;
+    ZmqSetSockOpt(obj, zsockopt_set_swap, "SWAP", value);
+}
+
+/*
+ *  call-seq:
+ *     sock.affinity =>  Fixnum
+ *
+ *  Returns the socket AFFINITY value.
+ *
+ * === Examples
+ *     ctx = ZMQ::Context.new
+ *     sock = ctx.socket(:REP)
+ *     sock.affinity  =>  0
+ *
+*/
+
+static VALUE rb_czmq_socket_opt_affinity(VALUE obj)
+{
+    zmq_sock_wrapper *sock = NULL;
+    GetZmqSocket(obj);
+    return INT2NUM(zsockopt_affinity(sock->socket));
+}
+
+/*
+ *  call-seq:
+ *     sock.affinity = 1 =>  nil
+ *
+ *  Sets the socket AFFINITY value.
+ *
+ * === Examples
+ *     ctx = ZMQ::Context.new
+ *     sock = ctx.socket(:REP)
+ *     sock.affinity = 1  =>  nil
+ *
+*/
+
+static VALUE rb_czmq_socket_set_opt_affinity(VALUE obj, VALUE value)
+{
+    zmq_sock_wrapper *sock = NULL;
+    ZmqSetSockOpt(obj, zsockopt_set_affinity, "AFFINITY", value);
+}
+
+/*
+ *  call-seq:
+ *     sock.rate =>  Fixnum
+ *
+ *  Returns the socket RATE value.
+ *
+ * === Examples
+ *     ctx = ZMQ::Context.new
+ *     sock = ctx.socket(:REP)
+ *     sock.rate  =>  40000
+ *
+*/
+
+static VALUE rb_czmq_socket_opt_rate(VALUE obj)
+{
+    zmq_sock_wrapper *sock = NULL;
+    GetZmqSocket(obj);
+    return INT2NUM(zsockopt_rate(sock->socket));
+}
+
+/*
+ *  call-seq:
+ *     sock.rate = 50000 =>  nil
+ *
+ *  Sets the socket RATE value.
+ *
+ * === Examples
+ *     ctx = ZMQ::Context.new
+ *     sock = ctx.socket(:REP)
+ *     sock.rate = 50000  =>  nil
+ *
+*/
+
+static VALUE rb_czmq_socket_set_opt_rate(VALUE obj, VALUE value)
+{
+    zmq_sock_wrapper *sock = NULL;
+    ZmqSetSockOpt(obj, zsockopt_set_rate, "RATE", value);
+}
+
+/*
+ *  call-seq:
+ *     sock.recovery_ivl =>  Fixnum
+ *
+ *  Returns the socket RECOVERY_IVL value.
+ *
+ * === Examples
+ *     ctx = ZMQ::Context.new
+ *     sock = ctx.socket(:REP)
+ *     sock.recovery_ivl  =>  10
+ *
+*/
+
+static VALUE rb_czmq_socket_opt_recovery_ivl(VALUE obj)
+{
+    zmq_sock_wrapper *sock = NULL;
+    GetZmqSocket(obj);
+    return INT2NUM(zsockopt_recovery_ivl(sock->socket));
+}
+
+/*
+ *  call-seq:
+ *     sock.recovery_ivl = 20 =>  nil
+ *
+ *  Sets the socket RECOVERY_IVL value.
+ *
+ * === Examples
+ *     ctx = ZMQ::Context.new
+ *     sock = ctx.socket(:REP)
+ *     sock.recovery_ivl = 20  =>  nil
+ *
+*/
+
+static VALUE rb_czmq_socket_set_opt_recovery_ivl(VALUE obj, VALUE value)
+{
+    zmq_sock_wrapper *sock = NULL;
+    ZmqSetSockOpt(obj, zsockopt_set_recovery_ivl, "RECOVERY_IVL", value);
+}
+
+/*
+ *  call-seq:
+ *     sock.recovery_ivl_msec =>  Fixnum
+ *
+ *  Returns the socket RECOVERY_IVL_MSEC value.
+ *
+ * === Examples
+ *     ctx = ZMQ::Context.new
+ *     sock = ctx.socket(:REP)
+ *     sock.recovery_ivl_msec  =>  -1
+ *
+*/
+
+static VALUE rb_czmq_socket_opt_recovery_ivl_msec(VALUE obj)
+{
+    zmq_sock_wrapper *sock = NULL;
+    GetZmqSocket(obj);
+    return INT2NUM(zsockopt_recovery_ivl_msec(sock->socket));
+}
+
+/*
+ *  call-seq:
+ *     sock.recovery_ivl_msec = 20 =>  nil
+ *
+ *  Sets the socket RECOVERY_IVL_MSEC value.
+ *
+ * === Examples
+ *     ctx = ZMQ::Context.new
+ *     sock = ctx.socket(:REP)
+ *     sock.recovery_ivl_msec = 20  =>  nil
+ *
+*/
+
+static VALUE rb_czmq_socket_set_opt_recovery_ivl_msec(VALUE obj, VALUE value)
+{
+    zmq_sock_wrapper *sock = NULL;
+    ZmqSetSockOpt(obj, zsockopt_set_recovery_ivl_msec, "RECOVERY_IVL_MSEC", value);
+}
+
+/*
+ *  call-seq:
+ *     sock.mcast_loop? =>  boolean
+ *
+ *  Returns the socket MCAST_LOOP status.
+ *
+ * === Examples
+ *     ctx = ZMQ::Context.new
+ *     sock = ctx.socket(:REP)
+ *     sock.mcast_loop?  =>  true
+ *
+*/
+
+static VALUE rb_czmq_socket_opt_mcast_loop(VALUE obj)
+{
+    zmq_sock_wrapper *sock = NULL;
+    GetZmqSocket(obj);
+    return (zsockopt_mcast_loop(sock->socket) == 1) ? Qtrue : Qfalse;
+}
+
+/*
+ *  call-seq:
+ *     sock.mcast_loop = false =>  nil
+ *
+ *  Sets the socket MCAST_LOOP value.
+ *
+ * === Examples
+ *     ctx = ZMQ::Context.new
+ *     sock = ctx.socket(:REP)
+ *     sock.mcast_loop = false  =>  nil
+ *
+*/
+
+static VALUE rb_czmq_socket_set_opt_mcast_loop(VALUE obj, VALUE value)
+{
+    zmq_sock_wrapper *sock = NULL;
+    ZmqSetBooleanSockOpt(obj, zsockopt_set_mcast_loop, "MCAST_LOOP", value);
+}
+
+/*
+ *  call-seq:
+ *     sock.sndbuf =>  Fixnum
+ *
+ *  Returns the socket SNDBUF value.
+ *
+ * === Examples
+ *     ctx = ZMQ::Context.new
+ *     sock = ctx.socket(:REP)
+ *     sock.sndbuf  =>  0
+ *
+*/
+
+static VALUE rb_czmq_socket_opt_sndbuf(VALUE obj)
+{
+    zmq_sock_wrapper *sock = NULL;
+    GetZmqSocket(obj);
+    return INT2NUM(zsockopt_sndbuf(sock->socket));
+}
+
+/*
+ *  call-seq:
+ *     sock.sndbuf = 1000 =>  nil
+ *
+ *  Sets the socket SNDBUF value.
+ *
+ * === Examples
+ *     ctx = ZMQ::Context.new
+ *     sock = ctx.socket(:REP)
+ *     sock.sndbuf = 1000  =>  nil
+ *
+*/
+
+static VALUE rb_czmq_socket_set_opt_sndbuf(VALUE obj, VALUE value)
+{
+    zmq_sock_wrapper *sock = NULL;
+    ZmqSetSockOpt(obj, zsockopt_set_sndbuf, "SNDBUF", value);
+}
+
+/*
+ *  call-seq:
+ *     sock.rcvbuf =>  Fixnum
+ *
+ *  Returns the socket RCVBUF value.
+ *
+ * === Examples
+ *     ctx = ZMQ::Context.new
+ *     sock = ctx.socket(:REP)
+ *     sock.rcvbuf  =>  0
+ *
+*/
+
+static VALUE rb_czmq_socket_opt_rcvbuf(VALUE obj)
+{
+    zmq_sock_wrapper *sock = NULL;
+    GetZmqSocket(obj);
+    return INT2NUM(zsockopt_rcvbuf(sock->socket));
+}
+
+/*
+ *  call-seq:
+ *     sock.rcvbuf = 1000 =>  nil
+ *
+ *  Sets the socket RCVBUF value.
+ *
+ * === Examples
+ *     ctx = ZMQ::Context.new
+ *     sock = ctx.socket(:REP)
+ *     sock.rcvbuf = 1000  =>  nil
+ *
+*/
+
+static VALUE rb_czmq_socket_set_opt_rcvbuf(VALUE obj, VALUE value)
+{
+    zmq_sock_wrapper *sock = NULL;
+    ZmqSetSockOpt(obj, zsockopt_set_rcvbuf, "RCVBUF", value);
+}
+
+/*
+ *  call-seq:
+ *     sock.linger =>  Fixnum
+ *
+ *  Returns the socket LINGER value.
+ *
+ * === Examples
+ *     ctx = ZMQ::Context.new
+ *     sock = ctx.socket(:REP)
+ *     sock.linger  =>  -1
+ *
+*/
+
+static VALUE rb_czmq_socket_opt_linger(VALUE obj)
+{
+    zmq_sock_wrapper *sock = NULL;
+    GetZmqSocket(obj);
+    return INT2NUM(zsockopt_linger(sock->socket));
+}
+
+/*
+ *  call-seq:
+ *     sock.linger = 1000 =>  nil
+ *
+ *  Sets the socket LINGER value in ms.
+ *
+ * === Examples
+ *     ctx = ZMQ::Context.new
+ *     sock = ctx.socket(:REP)
+ *     sock.linger = 1000  =>  nil
+ *
+*/
+
+static VALUE rb_czmq_socket_set_opt_linger(VALUE obj, VALUE value)
+{
+    zmq_sock_wrapper *sock = NULL;
+    ZmqSetSockOpt(obj, zsockopt_set_linger, "LINGER", value);
+}
+
+/*
+ *  call-seq:
+ *     sock.backlog =>  Fixnum
+ *
+ *  Returns the socket BACKLOG value.
+ *
+ * === Examples
+ *     ctx = ZMQ::Context.new
+ *     sock = ctx.socket(:REP)
+ *     sock.backlog  =>  100
+ *
+*/
+
+static VALUE rb_czmq_socket_opt_backlog(VALUE obj)
+{
+    zmq_sock_wrapper *sock = NULL;
+    GetZmqSocket(obj);
+    return INT2NUM(zsockopt_backlog(sock->socket));
+}
+
+/*
+ *  call-seq:
+ *     sock.backlog = 200 =>  nil
+ *
+ *  Sets the socket BACKLOG value.
+ *
+ * === Examples
+ *     ctx = ZMQ::Context.new
+ *     sock = ctx.socket(:REP)
+ *     sock.backlog = 200  =>  nil
+ *
+*/
+
+static VALUE rb_czmq_socket_set_opt_backlog(VALUE obj, VALUE value)
+{
+    zmq_sock_wrapper *sock = NULL;
+    ZmqSetSockOpt(obj, zsockopt_set_backlog, "BACKLOG", value);
+}
+
+/*
+ *  call-seq:
+ *     sock.reconnect_ivl =>  Fixnum
+ *
+ *  Returns the socket RECONNECT_IVL value.
+ *
+ * === Examples
+ *     ctx = ZMQ::Context.new
+ *     sock = ctx.socket(:REP)
+ *     sock.reconnect_ivl  =>  100
+ *
+*/
+
+static VALUE rb_czmq_socket_opt_reconnect_ivl(VALUE obj)
+{
+    zmq_sock_wrapper *sock = NULL;
+    GetZmqSocket(obj);
+    return INT2NUM(zsockopt_reconnect_ivl(sock->socket));
+}
+
+/*
+ *  call-seq:
+ *     sock.reconnect_ivl = 200 =>  nil
+ *
+ *  Sets the socket RECONNECT_IVL value.
+ *
+ * === Examples
+ *     ctx = ZMQ::Context.new
+ *     sock = ctx.socket(:REP)
+ *     sock.reconnect_ivl = 200  =>  nil
+ *
+*/
+
+static VALUE rb_czmq_socket_set_opt_reconnect_ivl(VALUE obj, VALUE value)
+{
+    zmq_sock_wrapper *sock = NULL;
+    ZmqSetSockOpt(obj, zsockopt_set_reconnect_ivl, "RECONNECT_IVL", value);
+}
+
+/*
+ *  call-seq:
+ *     sock.reconnect_ivl_max =>  Fixnum
+ *
+ *  Returns the socket RECONNECT_IVL_MAX value.
+ *
+ * === Examples
+ *     ctx = ZMQ::Context.new
+ *     sock = ctx.socket(:REP)
+ *     sock.reconnect_ivl_max  =>  0
+ *
+*/
+
+static VALUE rb_czmq_socket_opt_reconnect_ivl_max(VALUE obj)
+{
+    zmq_sock_wrapper *sock = NULL;
+    GetZmqSocket(obj);
+    return INT2NUM(zsockopt_reconnect_ivl_max(sock->socket));
+}
+
+/*
+ *  call-seq:
+ *     sock.reconnect_ivl_max = 5 =>  nil
+ *
+ *  Sets the socket RECONNECT_IVL_MAX value.
+ *
+ * === Examples
+ *     ctx = ZMQ::Context.new
+ *     sock = ctx.socket(:REP)
+ *     sock.reconnect_ivl_max = 5  =>  nil
+ *
+*/
+
+static VALUE rb_czmq_socket_set_opt_reconnect_ivl_max(VALUE obj, VALUE value)
+{
+    zmq_sock_wrapper *sock = NULL;
+    ZmqSetSockOpt(obj, zsockopt_set_reconnect_ivl_max, "RECONNECT_IVL_MAX", value);
+}
+
+/*
+ *  call-seq:
+ *     sock.identity = "anonymous" =>  nil
+ *
+ *  Sets the socket IDENTITY value.
+ *
+ * === Examples
+ *     ctx = ZMQ::Context.new
+ *     sock = ctx.socket(:REP)
+ *     sock.identity = "anonymous"  =>  nil
+ *
+*/
+
+static VALUE rb_czmq_socket_set_opt_identity(VALUE obj, VALUE value)
+{
+    char *val;
+    zmq_sock_wrapper *sock = NULL;
+    GetZmqSocket(obj);
+    ZmqSockGuardCrossThread(sock);
+    Check_Type(value, T_STRING);
+    if (RSTRING_LEN(value) == 0) rb_raise(rb_eZmqError, "socket identity cannot be empty.");
+    if (RSTRING_LEN(value) > 255) rb_raise(rb_eZmqError, "maximum socket identity is 255 chars.");
+    val = StringValueCStr(value);
+    zsockopt_set_identity(sock->socket, val);
+    if (sock->verbose)
+        zclock_log ("I: %s socket %p: set option \"IDENTITY\" \"%s\"", zsocket_type_str(sock->socket), obj, val);
+    return Qnil;
+}
+
+/*
+ *  call-seq:
+ *     sock.subscribe "ruby" =>  nil
+ *
+ *  Subscribes this SUB socket to a topic.
+ *
+ * === Examples
+ *     ctx = ZMQ::Context.new
+ *     sock = ctx.socket(:SUB)
+ *     sock.subscribe "ruby"  =>  nil
+ *
+*/
+
+static VALUE rb_czmq_socket_set_opt_subscribe(VALUE obj, VALUE value)
+{
+    zmq_sock_wrapper *sock = NULL;
+    ZmqSetStringSockOpt(obj, zsockopt_set_subscribe, "SUBSCRIBE", value, {
+       ZmqAssertSockOptFor(ZMQ_SUB)
+    });
+}
+
+/*
+ *  call-seq:
+ *     sock.unsubscribe "ruby" =>  nil
+ *
+ *  Unsubscribes this SUB socket from a topic.
+ *
+ * === Examples
+ *     ctx = ZMQ::Context.new
+ *     sock = ctx.socket(:SUB)
+ *     sock.unsubscribe "ruby"  =>  nil
+ *
+*/
+
+static VALUE rb_czmq_socket_set_opt_unsubscribe(VALUE obj, VALUE value)
+{
+    zmq_sock_wrapper *sock = NULL;
+    ZmqSetStringSockOpt(obj, zsockopt_set_unsubscribe, "UNSUBSCRIBE", value, {
+       ZmqAssertSockOptFor(ZMQ_SUB)
+    });
+}
+
+/*
+ *  call-seq:
+ *     sock.rcvmore =>  boolean
+ *
+ *  Query if there's more messages to receive.
+ *
+ * === Examples
+ *     ctx = ZMQ::Context.new
+ *     sock = ctx.socket(:SUB)
+ *     sock.rcvmore =>  true
+ *
+*/
+
+static VALUE rb_czmq_socket_opt_rcvmore(VALUE obj)
+{
+    zmq_sock_wrapper *sock = NULL;
+    GetZmqSocket(obj);
+    return (zsockopt_rcvmore(sock->socket) == 1) ? Qtrue : Qfalse;
+}
+
+/*
+ *  call-seq:
+ *     sock.events =>  Fixnum
+ *
+ *  Query if this socket is in a readable or writable state.
+ *
+ * === Examples
+ *     ctx = ZMQ::Context.new
+ *     sock = ctx.socket(:SUB)
+ *     sock.events => ZMQ::POLLIN
+ *
+*/
+
+static VALUE rb_czmq_socket_opt_events(VALUE obj)
+{
+    zmq_sock_wrapper *sock = NULL;
+    GetZmqSocket(obj);
+    return INT2NUM(zsockopt_events(sock->socket));
+}
+
+void _init_rb_czmq_socket()
+{
+    rb_cZmqSocket = rb_define_class_under(rb_mZmq, "Socket", rb_cObject);
+    rb_cZmqPubSocket = rb_define_class_under(rb_cZmqSocket, "Pub", rb_cZmqSocket);
+    rb_cZmqSubSocket = rb_define_class_under(rb_cZmqSocket, "Sub", rb_cZmqSocket);;
+    rb_cZmqPushSocket = rb_define_class_under(rb_cZmqSocket, "Push", rb_cZmqSocket);;
+    rb_cZmqPullSocket = rb_define_class_under(rb_cZmqSocket, "Pull", rb_cZmqSocket);;
+    rb_cZmqRouterSocket = rb_define_class_under(rb_cZmqSocket, "Router", rb_cZmqSocket);;
+    rb_cZmqDealerSocket = rb_define_class_under(rb_cZmqSocket, "Dealer", rb_cZmqSocket);;
+    rb_cZmqRepSocket = rb_define_class_under(rb_cZmqSocket, "Rep", rb_cZmqSocket);;
+    rb_cZmqReqSocket = rb_define_class_under(rb_cZmqSocket, "Req", rb_cZmqSocket);;
+    rb_cZmqPairSocket = rb_define_class_under(rb_cZmqSocket, "Pair", rb_cZmqSocket);;
+
+    rb_define_const(rb_cZmqSocket, "PENDING", INT2NUM(ZMQ_SOCKET_PENDING));
+    rb_define_const(rb_cZmqSocket, "BOUND", INT2NUM(ZMQ_SOCKET_BOUND));
+    rb_define_const(rb_cZmqSocket, "CONNECTED", INT2NUM(ZMQ_SOCKET_CONNECTED));
+
+    rb_define_method(rb_cZmqSocket, "close", rb_czmq_socket_close, 0);
+    rb_define_method(rb_cZmqSocket, "endpoint", rb_czmq_socket_endpoint, 0);
+    rb_define_method(rb_cZmqSocket, "state", rb_czmq_socket_state, 0);
+    rb_define_method(rb_cZmqSocket, "bind", rb_czmq_socket_bind, 1);
+    rb_define_method(rb_cZmqSocket, "connect", rb_czmq_socket_connect, 1);
+    rb_define_method(rb_cZmqSocket, "fd", rb_czmq_socket_fd, 0);
+    rb_define_alias(rb_cZmqSocket, "to_i", "fd");
+    rb_define_method(rb_cZmqSocket, "verbose=", rb_czmq_socket_set_verbose, 1);
+    rb_define_method(rb_cZmqSocket, "send", rb_czmq_socket_send, 1);
+    rb_define_method(rb_cZmqSocket, "sendm", rb_czmq_socket_sendm, 1);
+    rb_define_method(rb_cZmqSocket, "send_frame", rb_czmq_socket_send_frame, -1);
+    rb_define_method(rb_cZmqSocket, "send_message", rb_czmq_socket_send_message, 1);
+    rb_define_method(rb_cZmqSocket, "recv", rb_czmq_socket_recv, 0);
+    rb_define_method(rb_cZmqSocket, "recv_nonblock", rb_czmq_socket_recv_nonblock, 0);
+    rb_define_method(rb_cZmqSocket, "recv_frame", rb_czmq_socket_recv_frame, 0);
+    rb_define_method(rb_cZmqSocket, "recv_frame_nonblock", rb_czmq_socket_recv_frame_nonblock, 0);
+    rb_define_method(rb_cZmqSocket, "recv_message", rb_czmq_socket_recv_message, 0);
+    rb_define_method(rb_cZmqSocket, "recv_timeout=", rb_czmq_socket_set_recv_timeout, 1);
+    rb_define_method(rb_cZmqSocket, "recv_timeout", rb_czmq_socket_recv_timeout, 0);
+    rb_define_method(rb_cZmqSocket, "send_timeout=", rb_czmq_socket_set_send_timeout, 1);
+    rb_define_method(rb_cZmqSocket, "send_timeout", rb_czmq_socket_send_timeout, 0);
+
+    rb_define_method(rb_cZmqSocket, "hwm", rb_czmq_socket_opt_hwm, 0);
+    rb_define_method(rb_cZmqSocket, "hwm=", rb_czmq_socket_set_opt_hwm, 1);
+    rb_define_method(rb_cZmqSocket, "swap", rb_czmq_socket_opt_swap, 0);
+    rb_define_method(rb_cZmqSocket, "swap=", rb_czmq_socket_set_opt_swap, 1);
+    rb_define_method(rb_cZmqSocket, "affinity", rb_czmq_socket_opt_affinity, 0);
+    rb_define_method(rb_cZmqSocket, "affinity=", rb_czmq_socket_set_opt_affinity, 1);
+    rb_define_method(rb_cZmqSocket, "rate", rb_czmq_socket_opt_rate, 0);
+    rb_define_method(rb_cZmqSocket, "rate=", rb_czmq_socket_set_opt_rate, 1);
+    rb_define_method(rb_cZmqSocket, "recovery_ivl", rb_czmq_socket_opt_recovery_ivl, 0);
+    rb_define_method(rb_cZmqSocket, "recovery_ivl=", rb_czmq_socket_set_opt_recovery_ivl, 1);
+    rb_define_method(rb_cZmqSocket, "recovery_ivl_msec", rb_czmq_socket_opt_recovery_ivl_msec, 0);
+    rb_define_method(rb_cZmqSocket, "recovery_ivl_msec=", rb_czmq_socket_set_opt_recovery_ivl_msec, 1);
+    rb_define_method(rb_cZmqSocket, "mcast_loop?", rb_czmq_socket_opt_mcast_loop, 0);
+    rb_define_method(rb_cZmqSocket, "mcast_loop=", rb_czmq_socket_set_opt_mcast_loop, 1);
+    rb_define_method(rb_cZmqSocket, "sndbuf", rb_czmq_socket_opt_sndbuf, 0);
+    rb_define_method(rb_cZmqSocket, "sndbuf=", rb_czmq_socket_set_opt_sndbuf, 1);
+    rb_define_method(rb_cZmqSocket, "rcvbuf", rb_czmq_socket_opt_rcvbuf, 0);
+    rb_define_method(rb_cZmqSocket, "rcvbuf=", rb_czmq_socket_set_opt_rcvbuf, 1);
+    rb_define_method(rb_cZmqSocket, "linger", rb_czmq_socket_opt_linger, 0);
+    rb_define_method(rb_cZmqSocket, "linger=", rb_czmq_socket_set_opt_linger, 1);
+    rb_define_method(rb_cZmqSocket, "backlog", rb_czmq_socket_opt_backlog, 0);
+    rb_define_method(rb_cZmqSocket, "backlog=", rb_czmq_socket_set_opt_backlog, 1);
+    rb_define_method(rb_cZmqSocket, "reconnect_ivl", rb_czmq_socket_opt_reconnect_ivl, 0);
+    rb_define_method(rb_cZmqSocket, "reconnect_ivl=", rb_czmq_socket_set_opt_reconnect_ivl, 1);
+    rb_define_method(rb_cZmqSocket, "reconnect_ivl_max", rb_czmq_socket_opt_reconnect_ivl_max, 0);
+    rb_define_method(rb_cZmqSocket, "reconnect_ivl_max=", rb_czmq_socket_set_opt_reconnect_ivl_max, 1);
+    rb_define_method(rb_cZmqSocket, "identity=", rb_czmq_socket_set_opt_identity, 1);
+    rb_define_method(rb_cZmqSocket, "subscribe", rb_czmq_socket_set_opt_subscribe, 1);
+    rb_define_method(rb_cZmqSocket, "unsubscribe", rb_czmq_socket_set_opt_unsubscribe, 1);
+    rb_define_method(rb_cZmqSocket, "rcvmore?", rb_czmq_socket_opt_rcvmore, 0);
+    rb_define_method(rb_cZmqSocket, "events", rb_czmq_socket_opt_events, 0);
+}