libcouchbase 0.0.7 → 0.0.8

data/ext/libcouchbase/src/mcserver/mcserver.h

@@ -24,98 +24,188 @@
 #include <netbuf/netbuf.h>
 
 #ifdef __cplusplus
-extern "C" {
-#endif
+namespace lcb {
 
-struct lcb_settings_st;
-struct lcb_server_st;
+class RetryQueue;
+struct RetryOp;
 
 /**
  * The structure representing each couchbase server
  */
-typedef struct mc_SERVER_st {
-    /** Pipeline object for command queues */
-    mc_PIPELINE pipeline;
+class Server : public mc_PIPELINE {
+public:
+    /**
+     * Allocate and initialize a new server object. The object will not be
+     * connected
+     * @param instance the instance to which the server belongs
+     * @param ix the server index in the configuration
+     */
+    Server(lcb_t, int);
+
+    /**
+     * Close the server. The resources of the server may still continue to persist
+     * internally for a bit until all callbacks have been delivered and all buffers
+     * flushed and/or failed.
+     */
+    void close();
+
+    /**
+     * Schedule a flush and potentially flush some immediate data on the server.
+     * This is safe to call multiple times, however performance considerations
+     * should be taken into account
+     */
+    void flush();
+
+    /**
+     * Wrapper around mcreq_pipeline_timeout() and/or mcreq_pipeline_fail(). This
+     * function will purge all pending requests within the server and invoke
+     * their callbacks with the given error code passed as `err`. Depending on
+     * the error code, some operations may be retried.
+     *
+     * @param err the error code by which to fail the commands
+     *
+     * @note This function does not modify the server's socket or state in itself,
+     * but rather simply wipes the commands from its queue
+     */
+    void purge(lcb_error_t err) {
+        purge(err, 0, NULL, Server::REFRESH_NEVER);
+    }
+
+    /** Callback for mc_pipeline_fail_chain */
+    inline void purge_single(mc_PACKET*, lcb_error_t);
+
+    /**
+     * Returns true or false depending on whether there are pending commands on
+     * this server
+     */
+    bool has_pending() const {
+        return !SLLIST_IS_EMPTY(&requests);
+    }
+
+    int get_index() const {
+        return mc_PIPELINE::index;
+    }
+
+    lcb_t get_instance() const {
+        return instance;
+    }
+
+    const lcb_settings* get_settings() const {
+        return settings;
+    }
+
+    void set_new_index(int new_index) {
+        mc_PIPELINE::index = new_index;
+    }
+
+    const lcb_host_t& get_host() const {
+        return *curhost;
+    }
+
+    bool supports_mutation_tokens() const {
+        return mutation_tokens;
+    }
+
+    bool supports_compression() const {
+        return compsupport;
+    }
+
+    bool is_connected() const {
+        return connctx != NULL;
+    }
+
+    /** "Temporary" constructor. Only for use in retry queue */
+    Server();
+    ~Server();
+
+    enum State {
+        /* There are no known errored commands on this server */
+        S_CLEAN,
+
+        /* In the process of draining remaining commands to be flushed. The commands
+         * being drained may have already been rescheduled to another server or
+         * placed inside the error queue, but are pending being flushed. This will
+         * only happen in completion-style I/O plugins. When this state is in effect,
+         * subsequent attempts to connect will be blocked until all commands have
+         * been properly drained.
+         */
+        S_ERRDRAIN,
+
+        /* The server object has been closed, either because it has been removed
+         * from the cluster or because the related lcb_t has been destroyed.
+         */
+        S_CLOSED,
+
+        /*
+         * Server has been temporarily constructed.
+         */
+        S_TEMPORARY
+    };
+
+    static Server* get(lcbio_CTX *ctx) {
+        return reinterpret_cast<Server*>(lcbio_ctx_data(ctx));
+    }
+
+    uint32_t default_timeout() const {
+        return settings->operation_timeout;
+    }
+
+    uint32_t next_timeout() const;
+
+    bool check_closed();
+    void start_errored_ctx(State next_state);
+    void finalize_errored_ctx();
+    void socket_failed(lcb_error_t);
+    void io_timeout();
+
+    enum RefreshPolicy {
+        REFRESH_ALWAYS,
+        REFRESH_ONFAILED,
+        REFRESH_NEVER
+    };
+
+    int purge(lcb_error_t error, hrtime_t thresh, hrtime_t *next,
+              RefreshPolicy policy);
+
+    void connect();
+
+    void handle_connected(lcbio_SOCKET *socket, lcb_error_t err, lcbio_OSERR syserr);
+
+    enum ReadState {
+        PKT_READ_COMPLETE,
+        PKT_READ_PARTIAL
+    };
+
+    ReadState try_read(lcbio_CTX *ctx, rdb_IOROPE *ior);
+    bool handle_nmv(MemcachedResponse& resinfo, mc_PACKET *oldpkt);
+    bool maybe_retry_packet(mc_PACKET *pkt, lcb_error_t err);
+    bool maybe_reconnect_on_fake_timeout(lcb_error_t received_error);
+
+    /** Disable */
+    Server(const Server&);
+
+    State state;
+
+    /** IO/Operation timer */
+    lcbio_pTIMER io_timer;
 
     /** Pointer back to the instance */
     lcb_t instance;
 
     lcb_settings *settings;
 
-    /* Defined in mcserver.c */
-    int state;
-
     /** Whether compression is supported */
     short compsupport;
 
     /** Whether extended 'UUID' and 'seqno' are available for each mutation */
     short mutation_tokens;
 
-    /** IO/Operation timer */
-    lcbio_pTIMER io_timer;
-
     lcbio_CTX *connctx;
     lcbio_CONNREQ connreq;
 
     /** Request for current connection */
     lcb_host_t *curhost;
-} mc_SERVER;
-
-#define MCSERVER_TIMEOUT(c) (c)->settings->operation_timeout
-
-/**
- * Allocate and initialize a new server object. The object will not be
- * connected
- * @param instance the instance to which the server belongs
- * @param ix the server index in the configuration
- * @return the new object or NULL on allocation failure.
- */
-mc_SERVER *
-mcserver_alloc(lcb_t instance, int ix);
-
-/**
- * Close the server. The resources of the server may still continue to persist
- * internally for a bit until all callbacks have been delivered and all buffers
- * flushed and/or failed.
- * @param server the server to release
- */
-void
-mcserver_close(mc_SERVER *server);
-
-/**
- * Schedule a flush and potentially flush some immediate data on the server.
- * This is safe to call multiple times, however performance considerations
- * should be taken into account
- */
-void
-mcserver_flush(mc_SERVER *server);
-
-/**
- * Wrapper around mcreq_pipeline_timeout() and/or mcreq_pipeline_fail(). This
- * function will purge all pending requests within the server and invoke
- * their callbacks with the given error code passed as `err`. Depending on
- * the error code, some operations may be retried.
- * @param server the server to fail
- * @param err the error code by which to fail the commands
- *
- * @note This function does not modify the server's socket or state in itself,
- * but rather simply wipes the commands from its queue
- */
-void
-mcserver_fail_chain(mc_SERVER *server, lcb_error_t err);
-
-/**
- * Returns true or false depending on whether there are pending commands on
- * this server
- */
-LCB_INTERNAL_API
-int
-mcserver_has_pending(mc_SERVER *server);
-
-#define mcserver_get_host(server) (server)->curhost->host
-#define mcserver_get_port(server) (server)->curhost->port
-
-#ifdef __cplusplus
+};
 }
 #endif /* __cplusplus */
 #endif /* LCB_MCSERVER_H */

data/ext/libcouchbase/src/mcserver/negotiate.cc

@@ -15,6 +15,7 @@
  *   limitations under the License.
  */
 
+#include <algorithm>
 #include "packetutils.h"
 #include "mcserver.h"
 #include "logging.h"
@@ -26,47 +27,13 @@
 #include "negotiate.h"
 #include "ctx-log-inl.h"
 
-#include <string>
-#include <sstream>
-#include <vector>
+using namespace lcb;
 
-#define LOGARGS(ctx, lvl) ctx->sasl->settings, "negotiation", LCB_LOG_##lvl, __FILE__, __LINE__
-static void cleanup_negotiated(mc_pSESSINFO info);
+#define LOGARGS(ctx, lvl) ctx->settings, "negotiation", LCB_LOG_##lvl, __FILE__, __LINE__
+static void cleanup_negotiated(SessionInfo* info);
 static void handle_ioerr(lcbio_CTX *ctx, lcb_error_t err);
-static void handle_read(lcbio_CTX *ioctx, unsigned);
 #define SESSREQ_LOGFMT "<%s:%s> (SASLREQ=%p) "
 
-/**
- * Inner negotiation structure which is maintained as part of a 'protocol
- * context'.
- */
-struct mc_SESSINFO : public lcbio_PROTOCTX {
-    union {
-        cbsasl_secret_t secret;
-        char buffer[256];
-    } u_auth;
-
-    static mc_SESSINFO *get(void *arg) {
-        return reinterpret_cast<mc_SESSINFO*>(arg);
-    }
-
-    mc_SESSINFO(lcb_settings *settings_);
-    bool setup(const lcbio_NAMEINFO& nistrs, const lcb_host_t& host,
-        const lcb::Authenticator& auth);
-
-    ~mc_SESSINFO() {
-        if (sasl_client != NULL) {
-            cbsasl_dispose(&sasl_client);
-            sasl_client = NULL;
-        }
-    }
-
-    cbsasl_conn_t *sasl_client;
-    std::string mech;
-    std::vector<uint16_t> server_features;
-    lcb_settings *settings;
-};
-
 static void timeout_handler(void *arg);
 
 #define SESSREQ_LOGID(s) get_ctx_host(s->ctx), get_ctx_port(s->ctx), (void*)s
@@ -84,28 +51,37 @@ close_cb(lcbio_SOCKET *s, int reusable, void *arg)
  * of the request for negotiation and is deleted once negotiation has
  * completed (or failed).
  */
-struct mc_SESSREQ {
-    static mc_SESSREQ *get(void *arg) {
-        return reinterpret_cast<mc_SESSREQ*>(arg);
+class lcb::SessionRequestImpl : public SessionRequest {
+public:
+    static SessionRequestImpl *get(void *arg) {
+        return reinterpret_cast<SessionRequestImpl*>(arg);
     }
 
-    void start(lcbio_SOCKET *sock, lcb_settings *settings);
+    bool setup(const lcbio_NAMEINFO& nistrs, const lcb_host_t& host,
+        const lcb::Authenticator& auth);
+    void start(lcbio_SOCKET *sock);
     bool send_hello();
     bool send_step(const lcb::MemcachedResponse& packet);
     bool read_hello(const lcb::MemcachedResponse& packet);
+    void send_auth(const char *sasl_data, unsigned ndata);
+    void handle_read(lcbio_CTX *ioctx);
+
+    enum MechStatus { MECH_UNAVAILABLE, MECH_NOT_NEEDED, MECH_OK };
+    MechStatus set_chosen_mech(std::string& mechlist, const char **data, unsigned int *ndata);
 
-    mc_SESSREQ(lcbio_CONNDONE_cb callback, void *data, uint32_t timeout,
-               lcbio_TABLE *iot)
+    SessionRequestImpl(lcbio_CONNDONE_cb callback, void *data, uint32_t timeout, lcbio_TABLE *iot, lcb_settings* settings_)
         : ctx(NULL), cb(callback), cbdata(data),
           timer(lcbio_timer_new(iot, this, timeout_handler)),
-          last_err(LCB_SUCCESS), sasl(NULL) {
+          last_err(LCB_SUCCESS), info(NULL),
+          settings(settings_) {
 
         if (timeout) {
             lcbio_timer_rearm(timer, timeout);
         }
+        memset(&u_auth, 0, sizeof(u_auth));
     }
 
-    ~mc_SESSREQ();
+    virtual ~SessionRequestImpl();
 
     void cancel() {
         cb = NULL;
@@ -132,8 +108,8 @@ struct mc_SESSREQ {
         lcbio_ctx_close(ctx, close_cb, &s);
         ctx = NULL;
 
-        lcbio_protoctx_add(s, sasl);
-        sasl = NULL;
+        lcbio_protoctx_add(s, info);
+        info = NULL;
 
         /** Invoke the callback, marking it a success */
         cb(s, cbdata, LCB_SUCCESS, 0);
@@ -153,19 +129,29 @@ struct mc_SESSREQ {
         return last_err != LCB_SUCCESS;
     }
 
+    union {
+        cbsasl_secret_t secret;
+        char buffer[256];
+    } u_auth;
+
     lcbio_CTX *ctx;
     lcbio_CONNDONE_cb cb;
     void *cbdata;
     lcbio_pTIMER timer;
     lcb_error_t last_err;
-    mc_pSESSINFO sasl;
+    cbsasl_conn_t *sasl_client;
+    SessionInfo* info;
+    lcb_settings *settings;
 };
 
+static void handle_read(lcbio_CTX *ioctx, unsigned) {
+    SessionRequestImpl::get(lcbio_ctx_data(ioctx))->handle_read(ioctx);
+}
 
 static int
 sasl_get_username(void *context, int id, const char **result, unsigned int *len)
 {
-    mc_SESSINFO *ctx = mc_SESSINFO::get(context);
+    SessionRequestImpl *ctx = SessionRequestImpl::get(context);
     const char *u = NULL, *p = NULL;
     if (!context || !result || (id != CBSASL_CB_USER && id != CBSASL_CB_AUTHNAME)) {
         return SASL_BADPARAM;
@@ -184,7 +170,7 @@ static int
 sasl_get_password(cbsasl_conn_t *conn, void *context, int id,
                   cbsasl_secret_t **psecret)
 {
-    struct mc_SESSINFO *ctx = mc_SESSINFO::get(context);
+    SessionRequestImpl *ctx = SessionRequestImpl::get(context);
     if (!conn || ! psecret || id != CBSASL_CB_PASS || ctx == NULL) {
         return SASL_BADPARAM;
     }
@@ -193,19 +179,14 @@ sasl_get_password(cbsasl_conn_t *conn, void *context, int id,
     return SASL_OK;
 }
 
-mc_SESSINFO::mc_SESSINFO(lcb_settings *settings_)
+SessionInfo::SessionInfo()
 {
-    sasl_client = NULL;
-    memset(&u_auth, 0, sizeof(u_auth));
-
     lcbio_PROTOCTX::id = LCBIO_PROTOCTX_SESSINFO;
-    lcbio_PROTOCTX::dtor = (void (*)(struct lcbio_PROTOCTX *))cleanup_negotiated;
-
-    settings = settings_;
+    lcbio_PROTOCTX::dtor = (void (*)(lcbio_PROTOCTX *))cleanup_negotiated;
 }
 
 bool
-mc_SESSINFO::setup(const lcbio_NAMEINFO& nistrs, const lcb_host_t& host,
+SessionRequestImpl::setup(const lcbio_NAMEINFO& nistrs, const lcb_host_t& host,
     const lcb::Authenticator& auth)
 {
     cbsasl_callback_t sasl_callbacks[4];
@@ -251,7 +232,7 @@ mc_SESSINFO::setup(const lcbio_NAMEINFO& nistrs, const lcb_host_t& host,
 static void
 timeout_handler(void *arg)
 {
-    mc_pSESSREQ sreq = mc_SESSREQ::get(arg);
+    SessionRequestImpl *sreq = SessionRequestImpl::get(arg);
     sreq->fail(LCB_ETIMEDOUT, "Negotiation timed out");
 }
 
@@ -260,66 +241,62 @@ timeout_handler(void *arg)
  * @return 0 to continue authentication, 1 if no authentication needed, or
  * -1 on error.
  */
-static int
-set_chosen_mech(mc_pSESSREQ sreq, std::string& mechlist,
+SessionRequestImpl::MechStatus
+SessionRequestImpl::set_chosen_mech(std::string& mechlist,
     const char **data, unsigned int *ndata)
 {
     cbsasl_error_t saslerr;
-    mc_pSESSINFO ctx = sreq->sasl;
-
-    if (ctx->settings->sasl_mech_force) {
-        char *forcemech = ctx->settings->sasl_mech_force;
+    if (settings->sasl_mech_force) {
+        char *forcemech = settings->sasl_mech_force;
         if (mechlist.find(forcemech) == std::string::npos) {
             /** Requested mechanism not found */
-            sreq->set_error(LCB_SASLMECH_UNAVAILABLE, mechlist.c_str());
-            return -1;
+            set_error(LCB_SASLMECH_UNAVAILABLE, mechlist.c_str());
+            return MECH_UNAVAILABLE;
         }
         mechlist.assign(forcemech);
     }
 
     const char *chosenmech;
-    saslerr = cbsasl_client_start(ctx->sasl_client, mechlist.c_str(),
+    saslerr = cbsasl_client_start(sasl_client, mechlist.c_str(),
                                   NULL, data, ndata, &chosenmech);
     switch (saslerr) {
     case SASL_OK:
-        ctx->mech.assign(chosenmech);
-        return 0;
+        info->mech.assign(chosenmech);
+        return MECH_OK;
     case SASL_NOMECH:
-        lcb_log(LOGARGS(sreq, INFO), SESSREQ_LOGFMT "Server does not support SASL (no mechanisms supported)", SESSREQ_LOGID(sreq));
-        return 1;
+        lcb_log(LOGARGS(this, INFO), SESSREQ_LOGFMT "Server does not support SASL (no mechanisms supported)", SESSREQ_LOGID(this));
+        return MECH_NOT_NEEDED;
         break;
     default:
-        lcb_log(LOGARGS(sreq, INFO), SESSREQ_LOGFMT "cbsasl_client_start returned %d", SESSREQ_LOGID(sreq), saslerr);
-        sreq->set_error(LCB_EINTERNAL, "Couldn't start SASL client");
-        return -1;
+        lcb_log(LOGARGS(this, INFO), SESSREQ_LOGFMT "cbsasl_client_start returned %d", SESSREQ_LOGID(this), saslerr);
+        set_error(LCB_EINTERNAL, "Couldn't start SASL client");
+        return MECH_UNAVAILABLE;
     }
 }
 
 /**
  * Given the specific mechanisms, send the auth packet to the server.
  */
-static int
-send_sasl_auth(mc_SESSREQ *pend, const char *sasl_data, unsigned ndata)
+void
+SessionRequestImpl::send_auth(const char *sasl_data, unsigned ndata)
 {
-    mc_pSESSINFO ctx = pend->sasl;
     lcb::MemcachedRequest hdr(PROTOCOL_BINARY_CMD_SASL_AUTH);
-    hdr.sizes(0, ctx->mech.size(), ndata);
+    hdr.sizes(0, info->mech.size(), ndata);
 
-    lcbio_ctx_put(pend->ctx, hdr.data(), hdr.size());
-    lcbio_ctx_put(pend->ctx, ctx->mech.c_str(), ctx->mech.size());
-    lcbio_ctx_put(pend->ctx, sasl_data, ndata);
-    lcbio_ctx_rwant(pend->ctx, 24);
-    return 0;
+    lcbio_ctx_put(ctx, hdr.data(), hdr.size());
+    lcbio_ctx_put(ctx, info->mech.c_str(), info->mech.size());
+    lcbio_ctx_put(ctx, sasl_data, ndata);
+    lcbio_ctx_rwant(ctx, 24);
 }
 
 bool
-mc_SESSREQ::send_step(const lcb::MemcachedResponse& packet)
+SessionRequestImpl::send_step(const lcb::MemcachedResponse& packet)
 {
     cbsasl_error_t saslerr;
     const char *step_data;
     unsigned int ndata;
 
-    saslerr = cbsasl_client_step(sasl->sasl_client,
+    saslerr = cbsasl_client_step(sasl_client,
         packet.body<const char*>(), packet.bodylen(), NULL, &step_data, &ndata);
 
     if (saslerr != SASL_CONTINUE) {
@@ -328,9 +305,9 @@ mc_SESSREQ::send_step(const lcb::MemcachedResponse& packet)
     }
 
     lcb::MemcachedRequest hdr(PROTOCOL_BINARY_CMD_SASL_STEP);
-    hdr.sizes(0, sasl->mech.size(), ndata);
+    hdr.sizes(0, info->mech.size(), ndata);
     lcbio_ctx_put(ctx, hdr.data(), hdr.size());
-    lcbio_ctx_put(ctx, sasl->mech.c_str(), sasl->mech.size());
+    lcbio_ctx_put(ctx, info->mech.c_str(), info->mech.size());
     lcbio_ctx_put(ctx, step_data, ndata);
     lcbio_ctx_rwant(ctx, 24);
     return true;
@@ -340,13 +317,13 @@ mc_SESSREQ::send_step(const lcb::MemcachedResponse& packet)
 #define LCB_HELLO_DEFL_LENGTH (sizeof(LCB_HELLO_DEFL_STRING)-1)
 
 bool
-mc_SESSREQ::send_hello()
+SessionRequestImpl::send_hello()
 {
-    const lcb_settings *settings = sasl->settings;
     lcb_U16 features[MEMCACHED_TOTAL_HELLO_FEATURES];
 
     unsigned nfeatures = 0;
     features[nfeatures++] = PROTOCOL_BINARY_FEATURE_TLS;
+    features[nfeatures++] = PROTOCOL_BINARY_FEATURE_XATTR;
     if (settings->tcp_nodelay) {
         features[nfeatures++] = PROTOCOL_BINARY_FEATURE_TCPNODELAY;
     }
@@ -388,7 +365,7 @@ mc_SESSREQ::send_hello()
 }
 
 bool
-mc_SESSREQ::read_hello(const lcb::MemcachedResponse& resp)
+SessionRequestImpl::read_hello(const lcb::MemcachedResponse& resp)
 {
     /* some caps */
     const char *cur;
@@ -398,8 +375,8 @@ mc_SESSREQ::read_hello(const lcb::MemcachedResponse& resp)
         lcb_U16 tmp;
         memcpy(&tmp, cur, sizeof(tmp));
         tmp = ntohs(tmp);
-        lcb_log(LOGARGS(this, DEBUG), SESSREQ_LOGFMT "Found feature 0x%x (%s)", SESSREQ_LOGID(this), tmp, protocol_feature_2_text(tmp));
-        sasl->server_features.push_back(tmp);
+        lcb_log(LOGARGS(this, DEBUG), SESSREQ_LOGFMT "Server supports feature: 0x%x (%s)", SESSREQ_LOGID(this), tmp, protocol_feature_2_text(tmp));
+        info->server_features.push_back(tmp);
     }
     return true;
 }
@@ -415,10 +392,9 @@ typedef enum {
  * It's assumed the server buffers will be reset upon close(), so we must make
  * sure to _not_ release the ringbuffer if that happens.
  */
-static void
-handle_read(lcbio_CTX *ioctx, unsigned)
+void
+SessionRequestImpl::handle_read(lcbio_CTX *ioctx)
 {
-    mc_pSESSREQ sreq = mc_SESSREQ::get(lcbio_ctx_data(ioctx));
     lcb::MemcachedResponse resp;
     unsigned required;
     sreq_STATE state = SREQ_S_WAIT;
@@ -433,20 +409,15 @@ handle_read(lcbio_CTX *ioctx, unsigned)
 
     switch (resp.opcode()) {
     case PROTOCOL_BINARY_CMD_SASL_LIST_MECHS: {
-        int mechrc;
         const char *mechlist_data;
         unsigned int nmechlist_data;
         std::string mechs(resp.body<const char*>(), resp.bodylen());
 
-        mechrc = set_chosen_mech(sreq, mechs, &mechlist_data, &nmechlist_data);
-        if (mechrc == 0) {
-            if (0 == send_sasl_auth(sreq, mechlist_data, nmechlist_data)) {
-                state = SREQ_S_WAIT;
-            } else {
-                state = SREQ_S_ERROR;
-            }
-
-        } else if (mechrc < 0) {
+        MechStatus mechrc = set_chosen_mech(mechs, &mechlist_data, &nmechlist_data);
+        if (mechrc == MECH_OK) {
+            send_auth(mechlist_data, nmechlist_data);
+            state = SREQ_S_WAIT;
+        } else if (mechrc == MECH_UNAVAILABLE) {
             state = SREQ_S_ERROR;
         } else {
             state = SREQ_S_HELLODONE;
@@ -456,17 +427,17 @@ handle_read(lcbio_CTX *ioctx, unsigned)
 
     case PROTOCOL_BINARY_CMD_SASL_AUTH: {
         if (status == PROTOCOL_BINARY_RESPONSE_SUCCESS) {
-            sreq->send_hello();
+            send_hello();
             state = SREQ_S_AUTHDONE;
             break;
         }
 
         if (status != PROTOCOL_BINARY_RESPONSE_AUTH_CONTINUE) {
-            sreq->set_error(LCB_AUTH_ERROR, "SASL AUTH failed");
+            set_error(LCB_AUTH_ERROR, "SASL AUTH failed");
             state = SREQ_S_ERROR;
             break;
         }
-        if (sreq->send_step(resp) && sreq->send_hello()) {
+        if (send_step(resp) && send_hello()) {
             state = SREQ_S_WAIT;
         } else {
             state = SREQ_S_ERROR;
@@ -476,8 +447,8 @@ handle_read(lcbio_CTX *ioctx, unsigned)
 
     case PROTOCOL_BINARY_CMD_SASL_STEP: {
         if (status != PROTOCOL_BINARY_RESPONSE_SUCCESS) {
-            lcb_log(LOGARGS(sreq, WARN), SESSREQ_LOGFMT "SASL auth failed with STATUS=0x%x", SESSREQ_LOGID(sreq), status);
-            sreq->set_error(LCB_AUTH_ERROR, "SASL Step Failed");
+            lcb_log(LOGARGS(this, WARN), SESSREQ_LOGFMT "SASL auth failed with STATUS=0x%x", SESSREQ_LOGID(this), status);
+            set_error(LCB_AUTH_ERROR, "SASL Step Failed");
             state = SREQ_S_ERROR;
         } else {
             /* Wait for pipelined HELLO response */
@@ -489,15 +460,15 @@ handle_read(lcbio_CTX *ioctx, unsigned)
     case PROTOCOL_BINARY_CMD_HELLO: {
         state = SREQ_S_HELLODONE;
         if (status == PROTOCOL_BINARY_RESPONSE_SUCCESS) {
-            if (!sreq->read_hello(resp)) {
-                sreq->set_error(LCB_PROTOCOL_ERROR, "Couldn't parse HELLO");
+            if (!read_hello(resp)) {
+                set_error(LCB_PROTOCOL_ERROR, "Couldn't parse HELLO");
             }
         } else if (status == PROTOCOL_BINARY_RESPONSE_UNKNOWN_COMMAND ||
                 status == PROTOCOL_BINARY_RESPONSE_NOT_SUPPORTED) {
-            lcb_log(LOGARGS(sreq, DEBUG), SESSREQ_LOGFMT "Server does not support HELLO", SESSREQ_LOGID(sreq));
+            lcb_log(LOGARGS(this, DEBUG), SESSREQ_LOGFMT "Server does not support HELLO", SESSREQ_LOGID(this));
             /* nothing */
         } else {
-            sreq->set_error(LCB_PROTOCOL_ERROR, "Hello response unexpected");
+            set_error(LCB_PROTOCOL_ERROR, "Hello response unexpected");
             state = SREQ_S_ERROR;
         }
         break;
@@ -505,8 +476,8 @@ handle_read(lcbio_CTX *ioctx, unsigned)
 
     default: {
         state = SREQ_S_ERROR;
-        lcb_log(LOGARGS(sreq, ERROR), SESSREQ_LOGFMT "Received unknown response. OP=0x%x. RC=0x%x", SESSREQ_LOGID(sreq), resp.opcode(), resp.status());
-        sreq->set_error(LCB_NOT_SUPPORTED, "Received unknown response");
+        lcb_log(LOGARGS(this, ERROR), SESSREQ_LOGFMT "Received unknown response. OP=0x%x. RC=0x%x", SESSREQ_LOGID(this), resp.opcode(), resp.status());
+        set_error(LCB_NOT_SUPPORTED, "Received unknown response");
         break;
     }
     }
@@ -517,12 +488,12 @@ handle_read(lcbio_CTX *ioctx, unsigned)
 
     // Once there is no more any dependencies on the buffers, we can succeed
     // or fail the request, potentially destroying the underlying connection
-    if (sreq->has_error()) {
-        sreq->fail();
+    if (has_error()) {
+        fail();
     } else if (state == SREQ_S_ERROR) {
-        sreq->fail(LCB_ERROR, "FIXME: Error code set without description");
+        fail(LCB_ERROR, "FIXME: Error code set without description");
     } else if (state == SREQ_S_HELLODONE) {
-        sreq->success();
+        success();
     } else {
         goto GT_NEXT_PACKET;
     }
@@ -531,17 +502,17 @@ handle_read(lcbio_CTX *ioctx, unsigned)
 static void
 handle_ioerr(lcbio_CTX *ctx, lcb_error_t err)
 {
-    mc_pSESSREQ sreq = mc_SESSREQ::get(lcbio_ctx_data(ctx));
+    SessionRequestImpl* sreq = SessionRequestImpl::get(lcbio_ctx_data(ctx));
     sreq->fail(err, "IO Error");
 }
 
-static void cleanup_negotiated(mc_pSESSINFO ctx) {
+static void cleanup_negotiated(SessionInfo* ctx) {
     delete ctx;
 }
 
 void
-mc_SESSREQ::start(lcbio_SOCKET *sock, lcb_settings *settings) {
-    sasl = new mc_SESSINFO(settings);
+SessionRequestImpl::start(lcbio_SOCKET *sock) {
+    info = new SessionInfo();
 
     lcb_error_t err = lcbio_sslify_if_needed(sock, settings);
     if (err != LCB_SUCCESS) {
@@ -551,16 +522,16 @@ mc_SESSREQ::start(lcbio_SOCKET *sock, lcb_settings *settings) {
     }
 
     lcbio_CTXPROCS procs;
-    procs.cb_err = handle_ioerr;
-    procs.cb_read = handle_read;
+    procs.cb_err = ::handle_ioerr;
+    procs.cb_read = ::handle_read;
     ctx = lcbio_ctx_new(sock, this, &procs);
     ctx->subsys = "sasl";
 
     const lcb_host_t *curhost = lcbio_get_host(sock);
-    struct lcbio_NAMEINFO nistrs;
+    lcbio_NAMEINFO nistrs;
     lcbio_get_nameinfo(sock, &nistrs);
 
-    if (!sasl->setup(nistrs, *curhost, *settings->auth)) {
+    if (!setup(nistrs, *curhost, *settings->auth)) {
         set_error(LCB_EINTERNAL, "Couldn't start SASL client");
         lcbio_async_signal(timer);
         return;
@@ -571,11 +542,10 @@ mc_SESSREQ::start(lcbio_SOCKET *sock, lcb_settings *settings) {
     LCBIO_CTX_RSCHEDULE(ctx, 24);
 }
 
-
-mc_SESSREQ::~mc_SESSREQ()
+SessionRequestImpl::~SessionRequestImpl()
 {
-    if (sasl) {
-        delete sasl;
+    if (info) {
+        delete info;
     }
     if (timer) {
         lcbio_timer_destroy(timer);
@@ -583,35 +553,31 @@ mc_SESSREQ::~mc_SESSREQ()
     if (ctx) {
         lcbio_ctx_close(ctx, NULL, NULL);
     }
+    if (sasl_client) {
+        cbsasl_dispose(&sasl_client);
+    }
 }
 
-void mc_sessreq_cancel(mc_pSESSREQ sreq) {
+void lcb::sessreq_cancel(SessionRequest *sreq) {
     sreq->cancel();
 }
 
-mc_pSESSREQ
-mc_sessreq_start(lcbio_SOCKET *sock, lcb_settings *settings,
+SessionRequest *
+SessionRequest::start(lcbio_SOCKET *sock, lcb_settings_st *settings,
              uint32_t tmo, lcbio_CONNDONE_cb callback, void *data)
 {
-    mc_pSESSREQ sreq = new mc_SESSREQ(callback, data, tmo, sock->io);
-    sreq->start(sock, settings);
+    SessionRequestImpl* sreq = new SessionRequestImpl(callback, data, tmo, sock->io, settings);
+    sreq->start(sock);
     return sreq;
 }
 
-mc_pSESSINFO mc_sess_get(lcbio_SOCKET *sock) {
-    return static_cast<mc_pSESSINFO>(
-        lcbio_protoctx_get(sock, LCBIO_PROTOCTX_SESSINFO));
-}
-
-const char *mc_sess_get_saslmech(mc_pSESSINFO info) {
-    return info->mech.c_str();
+SessionInfo*
+SessionInfo::get(lcbio_SOCKET *sock) {
+    return static_cast<SessionInfo*>(lcbio_protoctx_get(sock, LCBIO_PROTOCTX_SESSINFO));
 }
 
-int mc_sess_chkfeature(mc_pSESSINFO info, uint16_t feature) {
-    for (size_t ii = 0; ii < info->server_features.size(); ++ii) {
-        if (info->server_features[ii] == feature) {
-            return 1;
-        }
-    }
-    return 0;
+bool
+SessionInfo::has_feature(uint16_t feature) const {
+    return std::find(server_features.begin(), server_features.end(), feature)
+        != server_features.end();
 }