couchbase 1.2.1-x86-mingw32 → 1.2.2-x86-mingw32

data/ext/couchbase_ext/extconf.rb

@@ -131,6 +131,7 @@ have_header("mach/mach_time.h")
 have_header("stdint.h") or die("Failed to locate stdint.h")
 have_header("sys/time.h")
 have_header("fcntl.h")
+have_type("st_index_t")
 have_func("clock_gettime")
 have_func("gettimeofday")
 have_func("QueryPerformanceCounter")
@@ -139,6 +140,7 @@ have_func("rb_thread_fd_select")
 have_func("rb_thread_blocking_region")
 have_func("poll", "poll.h")
 have_func("ppoll", "poll.h")
+have_func("rb_fiber_yield")
 define("_GNU_SOURCE")
 create_header("couchbase_config.h")
 create_makefile("couchbase_ext")

data/ext/couchbase_ext/get.c

@@ -22,7 +22,7 @@ cb_get_callback(lcb_t handle, const void *cookie, lcb_error_t error, const lcb_g
 {
     struct cb_context_st *ctx = (struct cb_context_st *)cookie;
     struct cb_bucket_st *bucket = ctx->bucket;
-    VALUE key, val, flags, cas, *rv = ctx->rv, exc = Qnil, res;
+    VALUE key, val, flags, cas, exc = Qnil, res;
 
     ctx->nqueries--;
     key = STR_NEW((const char*)resp->v.v0.key, resp->v.v0.nkey);
@@ -32,7 +32,7 @@ cb_get_callback(lcb_t handle, const void *cookie, lcb_error_t error, const lcb_g
         exc = cb_check_error(error, "failed to get value", key);
         if (exc != Qnil) {
             rb_ivar_set(exc, cb_id_iv_operation, cb_sym_get);
-            ctx->exception = cb_gc_protect(bucket, exc);
+            ctx->exception = exc;
         }
     }
 
@@ -46,14 +46,10 @@ cb_get_callback(lcb_t handle, const void *cookie, lcb_error_t error, const lcb_g
             VALUE exc_str = rb_funcall(val, cb_id_to_s, 0);
             VALUE msg = rb_funcall(rb_mKernel, cb_id_sprintf, 3,
                     rb_str_new2("unable to convert value for key '%s': %s"), key, exc_str);
-            if (ctx->exception != Qnil) {
-                cb_gc_unprotect(bucket, ctx->exception);
-            }
             ctx->exception = rb_exc_new3(cb_eValueFormatError, msg);
             rb_ivar_set(ctx->exception, cb_id_iv_operation, cb_sym_get);
             rb_ivar_set(ctx->exception, cb_id_iv_key, key);
             rb_ivar_set(ctx->exception, cb_id_iv_inner_exception, val);
-            cb_gc_protect(bucket, ctx->exception);
             val = raw;
         }
     } else if (cb_flags_get_format(resp->v.v0.flags) == cb_sym_plain) {
@@ -73,17 +69,17 @@ cb_get_callback(lcb_t handle, const void *cookie, lcb_error_t error, const lcb_g
     } else {                /* synchronous */
         if (NIL_P(exc) && error != LCB_KEY_ENOENT) {
             if (ctx->extended) {
-                rb_hash_aset(*rv, key, rb_ary_new3(3, val, flags, cas));
+                rb_hash_aset(ctx->rv, key, rb_ary_new3(3, val, flags, cas));
             } else {
-                rb_hash_aset(*rv, key, val);
+                rb_hash_aset(ctx->rv, key, val);
             }
         }
     }
 
     if (ctx->nqueries == 0) {
-        cb_gc_unprotect(bucket, ctx->proc);
+        ctx->proc = Qnil;
         if (bucket->async) {
-            free(ctx);
+            cb_context_free(ctx);
         }
     }
     (void)handle;
@@ -222,36 +218,28 @@ cb_bucket_get(int argc, VALUE *argv, VALUE self)
 {
     struct cb_bucket_st *bucket = DATA_PTR(self);
     struct cb_context_st *ctx;
-    VALUE args, rv, proc, exc;
+    VALUE rv, proc, exc;
     size_t ii;
     lcb_error_t err = LCB_SUCCESS;
     struct cb_params_st params;
 
-    if (bucket->handle == NULL) {
-        rb_raise(cb_eConnectError, "closed connection");
+    if (!cb_bucket_connected_bang(bucket, cb_sym_get)) {
+        return Qnil;
     }
-    rb_scan_args(argc, argv, "0*&", &args, &proc);
+
+    memset(&params, 0, sizeof(struct cb_params_st));
+    rb_scan_args(argc, argv, "0*&", &params.args, &proc);
     if (!bucket->async && proc != Qnil) {
         rb_raise(rb_eArgError, "synchronous mode doesn't support callbacks");
     }
-    memset(&params, 0, sizeof(struct cb_params_st));
     params.type = cb_cmd_get;
     params.bucket = bucket;
-    params.cmd.get.keys_ary = cb_gc_protect(bucket, rb_ary_new());
-    cb_params_build(&params, RARRAY_LEN(args), args);
-    ctx = calloc(1, sizeof(struct cb_context_st));
-    if (ctx == NULL) {
-        rb_raise(cb_eClientNoMemoryError, "failed to allocate memory for context");
-    }
+    params.cmd.get.keys_ary = rb_ary_new();
+    cb_params_build(&params);
+    ctx = cb_context_alloc_common(bucket, proc, params.cmd.get.num);
     ctx->extended = params.cmd.get.extended;
     ctx->quiet = params.cmd.get.quiet;
     ctx->force_format = params.cmd.get.forced_format;
-    ctx->proc = cb_gc_protect(bucket, proc);
-    ctx->bucket = bucket;
-    rv = rb_hash_new();
-    ctx->rv = &rv;
-    ctx->exception = Qnil;
-    ctx->nqueries = params.cmd.get.num;
     if (params.cmd.get.replica) {
         err = lcb_get_replica(bucket->handle, (const void *)ctx,
                 params.cmd.get.num, params.cmd.get.ptr_gr);
@@ -260,10 +248,9 @@ cb_bucket_get(int argc, VALUE *argv, VALUE self)
                 params.cmd.get.num, params.cmd.get.ptr);
     }
     cb_params_destroy(&params);
-    cb_gc_unprotect(bucket, params.cmd.get.keys_ary);
     exc = cb_check_error(err, "failed to schedule get request", Qnil);
     if (exc != Qnil) {
-        free(ctx);
+        cb_context_free(ctx);
         rb_exc_raise(exc);
     }
     bucket->nbytes += params.npayload;
@@ -276,9 +263,9 @@ cb_bucket_get(int argc, VALUE *argv, VALUE self)
             lcb_wait(bucket->handle);
         }
         exc = ctx->exception;
-        free(ctx);
+        rv = ctx->rv;
+        cb_context_free(ctx);
         if (exc != Qnil) {
-            cb_gc_unprotect(bucket, exc);
             rb_exc_raise(exc);
         }
         exc = bucket->exception;

data/ext/couchbase_ext/http.c

@@ -22,24 +22,35 @@ cb_http_complete_callback(lcb_http_request_t request, lcb_t handle, const void *
 {
     struct cb_context_st *ctx = (struct cb_context_st *)cookie;
     struct cb_bucket_st *bucket = ctx->bucket;
-    VALUE *rv = ctx->rv, key, val, res, exc;
+    VALUE key, val, res, exc;
     lcb_http_status_t status;
 
     ctx->request->completed = 1;
+
+    if (bucket->destroying) {
+        cb_context_free(ctx);
+        return;
+    }
+
     key = STR_NEW((const char*)resp->v.v0.path, resp->v.v0.npath);
     val = resp->v.v0.nbytes ? STR_NEW((const char*)resp->v.v0.bytes, resp->v.v0.nbytes) : Qnil;
-    exc = cb_check_error_with_status(error, "failed to execute HTTP request", key, resp->v.v0.status);
-    if (exc != Qnil) {
-        if (val != Qnil) {
+    exc = ctx->exception;
+    if (!RTEST(exc)) {
+        exc = cb_check_error_with_status(error, "failed to execute HTTP request", key, resp->v.v0.status);
+        if (exc != Qnil && val != Qnil) {
             rb_ivar_set(exc, cb_id_iv_body, val);
         }
-        rb_funcall(exc, cb_id_parse_body_bang, 0);
-        ctx->exception = cb_gc_protect(bucket, exc);
+    }
+    if (RTEST(exc)) {
+        if (rb_obj_is_kind_of(exc, cb_eHTTPError)) {
+            rb_funcall(exc, cb_id_parse_body_bang, 0);
+        }
+        ctx->exception = exc;
     }
     status = resp->v.v0.status;
     if (resp->v.v0.headers) {
         cb_build_headers(ctx, resp->v.v0.headers);
-        cb_gc_unprotect(bucket, ctx->headers_val);
+        ctx->headers_val = Qnil;
     }
     if (ctx->extended) {
         res = rb_class_new_instance(0, NULL, cb_cResult);
@@ -55,10 +66,13 @@ cb_http_complete_callback(lcb_http_request_t request, lcb_t handle, const void *
     }
     if (ctx->proc != Qnil) {
         cb_proc_call(bucket, ctx->proc, 1, res);
-        cb_gc_unprotect(bucket, ctx->proc);
+        ctx->proc = Qnil;
     }
     if (!bucket->async && ctx->exception == Qnil) {
-        *rv = res;
+        ctx->rv = res;
+    }
+    if (bucket->async) {
+        cb_context_free(ctx);
     }
     (void)handle;
     (void)request;
@@ -81,14 +95,11 @@ cb_http_data_callback(lcb_http_request_t request, lcb_t handle, const void *cook
         if (ctx->exception != Qnil) {
             VALUE body_str = rb_ivar_get(ctx->exception, cb_id_iv_body);
             if (NIL_P(body_str)) {
-                cb_gc_protect(bucket, ctx->exception);
                 rb_ivar_set(ctx->exception, cb_id_iv_body, val);
             } else {
                 rb_str_concat(body_str, val);
             }
-            if (ctx->http_cancel_on_error) {
-                lcb_cancel_http_request(bucket->handle, request);
-            }
+            return;
         }
     }
     if (resp->v.v0.headers) {
@@ -97,7 +108,7 @@ cb_http_data_callback(lcb_http_request_t request, lcb_t handle, const void *cook
     if (ctx->proc != Qnil) {
         if (ctx->extended) {
             res = rb_class_new_instance(0, NULL, cb_cResult);
-            rb_ivar_set(res, cb_id_iv_error, ctx->exception);
+            rb_ivar_set(res, cb_id_iv_error, Qnil);
             rb_ivar_set(res, cb_id_iv_status, status ? INT2FIX(status) : Qnil);
             rb_ivar_set(res, cb_id_iv_operation, cb_sym_http_request);
             rb_ivar_set(res, cb_id_iv_key, key);
@@ -110,6 +121,7 @@ cb_http_data_callback(lcb_http_request_t request, lcb_t handle, const void *cook
         cb_proc_call(bucket, ctx->proc, 1, res);
     }
     (void)handle;
+    (void)request;
 }
 
     void
@@ -278,27 +290,25 @@ cb_http_request_perform(VALUE self)
     struct cb_context_st *ctx;
     VALUE rv, exc;
     lcb_error_t err;
-    struct cb_bucket_st *bucket;
+    struct cb_bucket_st *bucket = req->bucket;
 
-    ctx = calloc(1, sizeof(struct cb_context_st));
-    if (ctx == NULL) {
-        rb_raise(cb_eClientNoMemoryError, "failed to allocate memory");
+    if (!cb_bucket_connected_bang(bucket, cb_sym_http_request)) {
+        return Qnil;
     }
-    rv = Qnil;
-    ctx->rv = &rv;
-    ctx->bucket = bucket = req->bucket;
-    ctx->proc = rb_block_given_p() ? cb_gc_protect(bucket, rb_block_proc()) : req->on_body_callback;
+
+    ctx = cb_context_alloc(bucket);
+    ctx->rv = Qnil;
+    ctx->proc = rb_block_given_p() ? rb_block_proc() : req->on_body_callback;
     ctx->extended = req->extended;
     ctx->request = req;
-    ctx->headers_val = cb_gc_protect(bucket, rb_hash_new());
-    ctx->exception = Qnil;
+    ctx->headers_val = rb_hash_new();
 
     err = lcb_make_http_request(bucket->handle, (const void *)ctx,
             req->type, &req->cmd, &req->request);
     exc = cb_check_error(err, "failed to schedule document request",
             STR_NEW(req->cmd.v.v0.path, req->cmd.v.v0.npath));
     if (exc != Qnil) {
-        free(ctx);
+        lcb_cancel_http_request(bucket->handle, req->request);
         rb_exc_raise(exc);
     }
     req->running = 1;
@@ -308,10 +318,10 @@ cb_http_request_perform(VALUE self)
     } else {
         lcb_wait(bucket->handle);
         if (req->completed) {
+            rv = ctx->rv;
             exc = ctx->exception;
-            free(ctx);
+            cb_context_free(ctx);
             if (exc != Qnil) {
-                cb_gc_unprotect(bucket, exc);
                 rb_exc_raise(exc);
             }
             return rv;
@@ -333,7 +343,7 @@ cb_http_request_pause(VALUE self)
     VALUE
 cb_http_request_continue(VALUE self)
 {
-    VALUE exc, *rv;
+    VALUE exc, rv;
     struct cb_http_request_st *req = DATA_PTR(self);
 
     if (req->running) {
@@ -341,12 +351,11 @@ cb_http_request_continue(VALUE self)
         if (req->completed) {
             exc = req->ctx->exception;
             rv = req->ctx->rv;
-            free(req->ctx);
+            cb_context_free(req->ctx);
             if (exc != Qnil) {
-                cb_gc_unprotect(req->bucket, exc);
                 rb_exc_raise(exc);
             }
-            return *rv;
+            return rv;
         }
     } else {
         cb_http_request_perform(self);

data/ext/couchbase_ext/multithread_plugin.c

@@ -24,149 +24,9 @@
 #include <rubysig.h>
 #endif
 #include <errno.h>
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <unistd.h>
-#ifdef HAVE_FCNTL_H
-#include <fcntl.h>
-#endif
 #ifdef HAVE_POLL
 #include <poll.h>
 #endif
-#define INVALID_SOCKET (-1)
-
-/* Copied from libev plugin */
-    static lcb_ssize_t
-lcb_io_recv(struct lcb_io_opt_st *iops, lcb_socket_t sock,
-        void *buffer, lcb_size_t len, int flags)
-{
-    lcb_ssize_t ret = recv(sock, buffer, len, flags);
-    if (ret < 0) {
-        iops->v.v0.error = errno;
-    }
-    return ret;
-}
-
-    static lcb_ssize_t
-lcb_io_recvv(struct lcb_io_opt_st *iops, lcb_socket_t sock,
-        struct lcb_iovec_st *iov, lcb_size_t niov)
-{
-    struct msghdr msg;
-    struct iovec vec[2];
-    lcb_ssize_t ret;
-
-    if (niov != 2) {
-        return -1;
-    }
-    memset(&msg, 0, sizeof(msg));
-    msg.msg_iov = vec;
-    msg.msg_iovlen = iov[1].iov_len ? (lcb_size_t)2 : (lcb_size_t)1;
-    msg.msg_iov[0].iov_base = iov[0].iov_base;
-    msg.msg_iov[0].iov_len = iov[0].iov_len;
-    msg.msg_iov[1].iov_base = iov[1].iov_base;
-    msg.msg_iov[1].iov_len = iov[1].iov_len;
-    ret = recvmsg(sock, &msg, 0);
-
-    if (ret < 0) {
-        iops->v.v0.error = errno;
-    }
-
-    return ret;
-}
-
-    static lcb_ssize_t
-lcb_io_send(struct lcb_io_opt_st *iops, lcb_socket_t sock,
-        const void *msg, lcb_size_t len, int flags)
-{
-    lcb_ssize_t ret = send(sock, msg, len, flags);
-    if (ret < 0) {
-        iops->v.v0.error = errno;
-    }
-    return ret;
-}
-
-    static lcb_ssize_t
-lcb_io_sendv(struct lcb_io_opt_st *iops, lcb_socket_t sock,
-        struct lcb_iovec_st *iov, lcb_size_t niov)
-{
-    struct msghdr msg;
-    struct iovec vec[2];
-    lcb_ssize_t ret;
-
-    if (niov != 2) {
-        return -1;
-    }
-    memset(&msg, 0, sizeof(msg));
-    msg.msg_iov = vec;
-    msg.msg_iovlen = iov[1].iov_len ? (lcb_size_t)2 : (lcb_size_t)1;
-    msg.msg_iov[0].iov_base = iov[0].iov_base;
-    msg.msg_iov[0].iov_len = iov[0].iov_len;
-    msg.msg_iov[1].iov_base = iov[1].iov_base;
-    msg.msg_iov[1].iov_len = iov[1].iov_len;
-    ret = sendmsg(sock, &msg, 0);
-
-    if (ret < 0) {
-        iops->v.v0.error = errno;
-    }
-    return ret;
-}
-
-    static int
-make_socket_nonblocking(lcb_socket_t sock)
-{
-    int flags;
-    if ((flags = fcntl(sock, F_GETFL, NULL)) < 0) {
-        return -1;
-    }
-    if (fcntl(sock, F_SETFL, flags | O_NONBLOCK) == -1) {
-        return -1;
-    }
-
-    return 0;
-}
-
-    static int
-close_socket(lcb_socket_t sock)
-{
-    return close(sock);
-}
-
-    static lcb_socket_t
-lcb_io_socket(struct lcb_io_opt_st *iops, int domain, int type,
-        int protocol)
-{
-    lcb_socket_t sock = socket(domain, type, protocol);
-    if (sock == INVALID_SOCKET) {
-        iops->v.v0.error = errno;
-    } else {
-        if (make_socket_nonblocking(sock) != 0) {
-            int error = errno;
-            iops->v.v0.close(iops, sock);
-            iops->v.v0.error = error;
-            sock = INVALID_SOCKET;
-        }
-    }
-
-    return sock;
-}
-
-    static void
-lcb_io_close(struct lcb_io_opt_st *iops, lcb_socket_t sock)
-{
-    close_socket(sock);
-    (void)iops;
-}
-
-    static int
-lcb_io_connect(struct lcb_io_opt_st *iops, lcb_socket_t sock,
-        const struct sockaddr *name, unsigned int namelen)
-{
-    int ret = connect(sock, name, (socklen_t)namelen);
-    if (ret < 0) {
-        iops->v.v0.error = errno;
-    }
-    return ret;
-}
 
 /* events sorted array */
 typedef struct rb_mt_event rb_mt_event;
@@ -807,45 +667,33 @@ loop_select_cleanup(VALUE argp)
 /* code influenced by ruby's source and cool.io */
 #define POLLIN_SET (POLLIN | POLLHUP | POLLERR)
 #define POLLOUT_SET (POLLOUT | POLLHUP | POLLERR)
+#define HRTIME_INFINITY ((hrtime_t)~0)
 
-#ifndef HAVE_PPOLL
-#if SIZEOF_TIME_T == SIZEOF_LONG
-typedef unsigned long unsigned_time_t;
-#elif SIZEOF_TIME_T == SIZEOF_INT
-typedef unsigned int unsigned_time_t;
-#elif SIZEOF_TIME_T == SIZEOF_LONG_LONG
-typedef unsigned LONG_LONG unsigned_time_t;
+#ifdef HAVE_PPOLL
+    static int
+xpoll(struct pollfd *fds, nfds_t nfds, hrtime_t timeout)
+{
+    if (timeout != HRTIME_INFINITY) {
+        struct timespec ts;
+        ts.tv_sec = (long)(timeout / (1000 * 1000 * 1000));
+        ts.tv_nsec = (long)(timeout % (1000 * 1000 * 1000));
+        return ppoll(fds, nfds, &ts, NULL);
+    }
+    return ppoll(fds, nfds, NULL, NULL);
+}
 #else
-# error cannot find integer type which size is same as time_t.
-#endif
-#define TIMET_MAX (~(time_t)0 <= 0 ? (time_t)((~(unsigned_time_t)0) >> 1) : (time_t)(~(unsigned_time_t)0))
+#define TIMEOUT_MAX ((hrtime_t)(((unsigned int)~0) >> 1))
     static int
-ppoll(struct pollfd *fds, nfds_t nfds,
-        const struct timespec *ts, const sigset_t *sigmask)
+xpoll(struct pollfd *fds, nfds_t nfds, hrtime_t timeout)
 {
-    int timeout_ms;
-
-    if (ts) {
-        int tmp, tmp2;
-
-        if (ts->tv_sec > TIMET_MAX/1000) {
-            timeout_ms = -1;
-        } else {
-            tmp = ts->tv_sec * 1000;
-            tmp2 = (ts->tv_nsec + 999999) / (1000 * 1000);
-            if (TIMET_MAX - tmp < tmp2) {
-                timeout_ms = -1;
-            } else {
-                timeout_ms = tmp + tmp2;
-            }
+    int ts = -1;
+    if (timeout != HRTIME_INFINITY) {
+        timeout = (timeout + 999999) / (1000 * 1000);
+        if (timeout <= TIMEOUT_MAX) {
+            ts = (int)timeout;
         }
-    } else {
-        timeout_ms = -1;
     }
-
-    (void)sigmask;
-
-    return poll(fds, nfds, timeout_ms);
+    return poll(fds, nfds, ts);
 }
 #endif
 
@@ -854,7 +702,7 @@ struct poll_args {
     rb_mt_loop *loop;
     struct pollfd *fds;
     nfds_t nfd;
-    struct timespec *ts;
+    hrtime_t ts;
     int result;
     int lerrno;
 };
@@ -882,7 +730,7 @@ lp_arg_alloc(lp_arg **args)
 loop_blocking_poll(void *argp)
 {
     lp_arg *args = argp;
-    args->result = ppoll(args->fds, args->nfd, args->ts, NULL);
+    args->result = xpoll(args->fds, args->nfd, args->ts);
     if (args->result < 0) args->lerrno = errno;
     return Qnil;
 }
@@ -893,7 +741,6 @@ loop_run_poll(VALUE argp)
 {
     lp_arg *args = (lp_arg*)argp;
     rb_mt_loop *loop = args->loop;
-    struct timespec ts;
     hrtime_t now, next_time;
 
     if (loop->events.count) {
@@ -916,17 +763,9 @@ retry:
     next_time = timers_minimum(&loop->timers);
     if (next_time) {
         now = gethrtime();
-        if (next_time <= now) {
-            ts.tv_sec = 0;
-            ts.tv_nsec = 0;
-        } else {
-            hrtime_t hrto = next_time - now;
-            ts.tv_sec = (long)(hrto / 1000000000);
-            ts.tv_nsec = (long)(hrto % 1000000000);
-        }
-        args->ts = &ts;
+        args->ts = next_time <= now ? 0 : next_time - now;
     } else {
-        args->ts = NULL;
+        args->ts = HRTIME_INFINITY;
     }
 
 #ifdef HAVE_RB_THREAD_BLOCKING_REGION
@@ -934,21 +773,19 @@ retry:
 #else
     if (rb_thread_alone()) {
         TRAP_BEG;
-        args->result = ppoll(args->fds, args->nfd, args->ts, NULL);
+        args->result = xpoll(args->fds, args->nfd, args->ts);
         if (args->result < 0) args->lerrno = errno;
         TRAP_END;
     } else {
-        struct timespec mini_pause;
-        int exact = 0;
-        mini_pause.tv_sec = 0;
         /* 5 millisecond pause */
-        mini_pause.tv_nsec = 5000000;
-        if (args->ts && ts.tv_sec == 0 && ts.tv_nsec < 5000000) {
-            mini_pause.tv_nsec = ts.tv_nsec;
+        hrtime_t mini_pause = 5000000;
+        int exact = 0;
+        if (args->ts != HRTIME_INFINITY && args->ts < mini_pause) {
+            mini_pause = args->ts;
             exact = 1;
         }
         TRAP_BEG;
-        args->result = ppoll(args->fds, args->nfd, &mini_pause, NULL);
+        args->result = xpoll(args->fds, args->nfd, mini_pause);
         if (args->result < 0) args->lerrno = errno;
         TRAP_END;
         if (args->result == 0 && !exact) {
@@ -1206,13 +1043,13 @@ cb_create_ruby_mt_io_opts(int version, lcb_io_opt_t *io, void *arg)
     /* consider that struct isn't allocated by the library,
      * `need_cleanup' flag might be set in lcb_create() */
     ret->v.v0.need_cleanup = 0;
-    ret->v.v0.recv = lcb_io_recv;
-    ret->v.v0.send = lcb_io_send;
-    ret->v.v0.recvv = lcb_io_recvv;
-    ret->v.v0.sendv = lcb_io_sendv;
-    ret->v.v0.socket = lcb_io_socket;
-    ret->v.v0.close = lcb_io_close;
-    ret->v.v0.connect = lcb_io_connect;
+    ret->v.v0.recv = cb_io_recv;
+    ret->v.v0.send = cb_io_send;
+    ret->v.v0.recvv = cb_io_recvv;
+    ret->v.v0.sendv = cb_io_sendv;
+    ret->v.v0.socket = cb_io_socket;
+    ret->v.v0.close = cb_io_close;
+    ret->v.v0.connect = cb_io_connect;
     ret->v.v0.delete_event = lcb_io_delete_event;
     ret->v.v0.destroy_event = lcb_io_destroy_event;
     ret->v.v0.create_event = lcb_io_create_event;