libcouchbase 0.0.9 → 0.1.0

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

@@ -173,10 +173,12 @@ public:
 
     enum ReadState {
         PKT_READ_COMPLETE,
-        PKT_READ_PARTIAL
+        PKT_READ_PARTIAL,
+        PKT_READ_ABORT
     };
 
     ReadState try_read(lcbio_CTX *ctx, rdb_IOROPE *ior);
+    bool handle_unknown_error(const MemcachedResponse& resinfo, lcb_error_t& newerr);
     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);

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

@@ -16,6 +16,10 @@
  */
 
 #include <algorithm>
+#include <string>
+#include <sstream>
+#include <vector>
+
 #include "packetutils.h"
 #include "mcserver.h"
 #include "logging.h"
@@ -26,6 +30,7 @@
 #include <cbsasl/cbsasl.h>
 #include "negotiate.h"
 #include "ctx-log-inl.h"
+#include "auth-priv.h"
 
 using namespace lcb;
 
@@ -34,6 +39,7 @@ static void cleanup_negotiated(SessionInfo* info);
 static void handle_ioerr(lcbio_CTX *ctx, lcb_error_t err);
 #define SESSREQ_LOGFMT "<%s:%s> (SASLREQ=%p) "
 
+
 static void timeout_handler(void *arg);
 
 #define SESSREQ_LOGID(s) get_ctx_host(s->ctx), get_ctx_port(s->ctx), (void*)s
@@ -65,9 +71,12 @@ public:
     bool read_hello(const lcb::MemcachedResponse& packet);
     void send_auth(const char *sasl_data, unsigned ndata);
     void handle_read(lcbio_CTX *ioctx);
+    bool maybe_select_bucket();
 
     enum MechStatus { MECH_UNAVAILABLE, MECH_NOT_NEEDED, MECH_OK };
     MechStatus set_chosen_mech(std::string& mechlist, const char **data, unsigned int *ndata);
+    bool request_errmap();
+    bool update_errmap(const lcb::MemcachedResponse& packet);
 
     SessionRequestImpl(lcbio_CONNDONE_cb callback, void *data, uint32_t timeout, lcbio_TABLE *iot, lcb_settings* settings_)
         : ctx(NULL), cb(callback), cbdata(data),
@@ -324,6 +333,10 @@ SessionRequestImpl::send_hello()
     unsigned nfeatures = 0;
     features[nfeatures++] = PROTOCOL_BINARY_FEATURE_TLS;
     features[nfeatures++] = PROTOCOL_BINARY_FEATURE_XATTR;
+    features[nfeatures++] = PROTOCOL_BINARY_FEATURE_SELECT_BUCKET;
+    if (settings->use_errmap) {
+        features[nfeatures++] = PROTOCOL_BINARY_FEATURE_XERROR;
+    }
     if (settings->tcp_nodelay) {
         features[nfeatures++] = PROTOCOL_BINARY_FEATURE_TCPNODELAY;
     }
@@ -360,6 +373,7 @@ SessionRequestImpl::send_hello()
         lcb_U16 tmp = htons(features[ii]);
         lcbio_ctx_put(ctx, &tmp, sizeof tmp);
     }
+
     lcbio_ctx_rwant(ctx, 24);
     return true;
 }
@@ -381,12 +395,68 @@ SessionRequestImpl::read_hello(const lcb::MemcachedResponse& resp)
     return true;
 }
 
-typedef enum {
-    SREQ_S_WAIT,
-    SREQ_S_AUTHDONE,
-    SREQ_S_HELLODONE,
-    SREQ_S_ERROR
-} sreq_STATE;
+bool
+SessionRequestImpl::request_errmap() {
+    lcb::MemcachedRequest hdr(PROTOCOL_BINARY_CMD_GET_ERROR_MAP);
+    uint16_t version = htons(1);
+    hdr.sizes(0, 0, 2);
+    const char *p = reinterpret_cast<const char *>(&version);
+
+    lcbio_ctx_put(ctx, hdr.data(), hdr.size());
+    lcbio_ctx_put(ctx, p, 2);
+    lcbio_ctx_rwant(ctx, 24);
+    return true;
+}
+
+bool
+SessionRequestImpl::update_errmap(const lcb::MemcachedResponse& resp)
+{
+    // Get the error map object
+    using lcb::errmap::ErrorMap;
+
+    std::string errmsg;
+    ErrorMap& mm = *settings->errmap;
+    ErrorMap::ParseStatus status = mm.parse(
+        resp.body<const char*>(), resp.bodylen(), errmsg);
+
+    if (status != ErrorMap::UPDATED && status != ErrorMap::NOT_UPDATED) {
+        errmsg = "Couldn't update error map: " + errmsg;
+        set_error(LCB_PROTOCOL_ERROR, errmsg.c_str());
+        return false;
+    }
+
+    return true;
+}
+
+// Returns true if sending the SELECT_BUCKET command, false otherwise.
+bool
+SessionRequestImpl::maybe_select_bucket() {
+
+    // Only send a SELECT_BUCKET if we have the SELECT_BUCKET bit enabled.
+    if (!info->has_feature(PROTOCOL_BINARY_FEATURE_SELECT_BUCKET)) {
+        return false;
+    }
+
+    if (!settings->select_bucket) {
+        lcb_log(LOGARGS(this, WARN), SESSREQ_LOGFMT "SELECT_BUCKET Disabled by application", SESSREQ_LOGID(this));
+        return false;
+    }
+
+    // send the SELECT_BUCKET command:
+    lcb_log(LOGARGS(this, INFO), SESSREQ_LOGFMT "Sending SELECT_BUCKET", SESSREQ_LOGID(this));
+    lcb::MemcachedRequest req(PROTOCOL_BINARY_CMD_SELECT_BUCKET);
+    req.sizes(0, strlen(settings->bucket), 0);
+    lcbio_ctx_put(ctx, req.data(), req.size());
+    lcbio_ctx_put(ctx, settings->bucket, strlen(settings->bucket));
+    LCBIO_CTX_RSCHEDULE(ctx, 24);
+    return true;
+}
+
+static bool isUnsupported(uint16_t status) {
+    return status == PROTOCOL_BINARY_RESPONSE_NOT_SUPPORTED ||
+            status == PROTOCOL_BINARY_RESPONSE_UNKNOWN_COMMAND ||
+            status == PROTOCOL_BINARY_RESPONSE_EACCESS;
+}
 
 /**
  * It's assumed the server buffers will be reset upon close(), so we must make
@@ -397,7 +467,7 @@ SessionRequestImpl::handle_read(lcbio_CTX *ioctx)
 {
     lcb::MemcachedResponse resp;
     unsigned required;
-    sreq_STATE state = SREQ_S_WAIT;
+    bool completed = false;
 
     GT_NEXT_PACKET:
 
@@ -416,66 +486,92 @@ SessionRequestImpl::handle_read(lcbio_CTX *ioctx)
         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;
+            // Do nothing - error already set
         } else {
-            state = SREQ_S_HELLODONE;
+            completed = !maybe_select_bucket();
         }
         break;
     }
 
     case PROTOCOL_BINARY_CMD_SASL_AUTH: {
         if (status == PROTOCOL_BINARY_RESPONSE_SUCCESS) {
-            send_hello();
-            state = SREQ_S_AUTHDONE;
+            completed = !maybe_select_bucket();
             break;
-        }
-
-        if (status != PROTOCOL_BINARY_RESPONSE_AUTH_CONTINUE) {
+        } else if (status == PROTOCOL_BINARY_RESPONSE_AUTH_CONTINUE) {
+            send_step(resp);
+        } else {
             set_error(LCB_AUTH_ERROR, "SASL AUTH failed");
-            state = SREQ_S_ERROR;
             break;
         }
-        if (send_step(resp) && send_hello()) {
-            state = SREQ_S_WAIT;
-        } else {
-            state = SREQ_S_ERROR;
-        }
         break;
     }
 
     case PROTOCOL_BINARY_CMD_SASL_STEP: {
-        if (status != PROTOCOL_BINARY_RESPONSE_SUCCESS) {
+        if (status == PROTOCOL_BINARY_RESPONSE_SUCCESS) {
+            completed = !maybe_select_bucket();
+        } else {
             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 */
-            state = SREQ_S_AUTHDONE;
         }
         break;
     }
 
     case PROTOCOL_BINARY_CMD_HELLO: {
-        state = SREQ_S_HELLODONE;
         if (status == PROTOCOL_BINARY_RESPONSE_SUCCESS) {
             if (!read_hello(resp)) {
                 set_error(LCB_PROTOCOL_ERROR, "Couldn't parse HELLO");
+                break;
             }
-        } else if (status == PROTOCOL_BINARY_RESPONSE_UNKNOWN_COMMAND ||
-                status == PROTOCOL_BINARY_RESPONSE_NOT_SUPPORTED) {
+        } else if (isUnsupported(status)) {
             lcb_log(LOGARGS(this, DEBUG), SESSREQ_LOGFMT "Server does not support HELLO", SESSREQ_LOGID(this));
-            /* nothing */
         } else {
             set_error(LCB_PROTOCOL_ERROR, "Hello response unexpected");
-            state = SREQ_S_ERROR;
+            break;
+        }
+
+        if (info->has_feature(PROTOCOL_BINARY_FEATURE_XERROR)) {
+            request_errmap();
+        } else {
+            lcb_log(LOGARGS(this, TRACE), SESSREQ_LOGFMT "GET_ERRORMAP unsupported/disabled", SESSREQ_LOGID(this));
+        }
+
+        // In any event, it's also time to send the LIST_MECHS request
+        lcb::MemcachedRequest req(PROTOCOL_BINARY_CMD_SASL_LIST_MECHS);
+        lcbio_ctx_put(ctx, req.data(), req.size());
+        LCBIO_CTX_RSCHEDULE(ctx, 24);
+
+        break;
+    }
+
+    case PROTOCOL_BINARY_CMD_GET_ERROR_MAP: {
+        if (status == PROTOCOL_BINARY_RESPONSE_SUCCESS) {
+            if (!update_errmap(resp)) {
+            }
+        } else if (isUnsupported(status)) {
+            lcb_log(LOGARGS(this, DEBUG), SESSREQ_LOGFMT "Server does not support GET_ERRMAP (0x%x)", SESSREQ_LOGID(this), status);
+        } else {
+            lcb_log(LOGARGS(this, ERROR), SESSREQ_LOGFMT "Unexpected status 0x%x received for GET_ERRMAP", SESSREQ_LOGID(this), status);
+            set_error(LCB_PROTOCOL_ERROR, "GET_ERRMAP response unexpected");
+        }
+        // Note, there is no explicit state transition here. LIST_MECHS is
+        // pipelined after this request.
+        break;
+    }
+
+    case PROTOCOL_BINARY_CMD_SELECT_BUCKET: {
+        if (status == PROTOCOL_BINARY_RESPONSE_SUCCESS) {
+            completed = true;
+        } else if (status == PROTOCOL_BINARY_RESPONSE_EACCESS) {
+            set_error(LCB_AUTH_ERROR, "Provided credentials not allowed for bucket");
+        } else {
+            lcb_log(LOGARGS(this, ERROR), SESSREQ_LOGFMT "Unexpected status 0x%x received for SELECT_BUCKET", SESSREQ_LOGID(this), status);
+            set_error(LCB_PROTOCOL_ERROR, "Other auth error");
         }
         break;
     }
 
     default: {
-        state = SREQ_S_ERROR;
         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;
@@ -490,9 +586,7 @@ SessionRequestImpl::handle_read(lcbio_CTX *ioctx)
     // or fail the request, potentially destroying the underlying connection
     if (has_error()) {
         fail();
-    } else if (state == SREQ_S_ERROR) {
-        fail(LCB_ERROR, "FIXME: Error code set without description");
-    } else if (state == SREQ_S_HELLODONE) {
+    } else if (completed) {
         success();
     } else {
         goto GT_NEXT_PACKET;
@@ -537,8 +631,7 @@ SessionRequestImpl::start(lcbio_SOCKET *sock) {
         return;
     }
 
-    lcb::MemcachedRequest hdr(PROTOCOL_BINARY_CMD_SASL_LIST_MECHS);
-    lcbio_ctx_put(ctx, hdr.data(), hdr.size());
+    send_hello();
     LCBIO_CTX_RSCHEDULE(ctx, 24);
 }
 

data/ext/libcouchbase/src/nodeinfo.cc

@@ -167,7 +167,7 @@ lcb_int32_t lcb_get_num_nodes(lcb_t instance)
 LIBCOUCHBASE_API
 const char *const *lcb_get_server_list(lcb_t instance)
 {
-    return hostlist_strents(instance->ht_nodes);
+    return instance->ht_nodes->get_strlist();
 }
 
 LIBCOUCHBASE_API

data/ext/libcouchbase/src/settings.c

@@ -57,6 +57,7 @@ void lcb_default_settings(lcb_settings *settings)
     settings->tcp_nodelay = LCB_DEFAULT_TCP_NODELAY;
     settings->retry_nmv_interval = LCB_DEFAULT_RETRY_NMV_INTERVAL;
     settings->vb_noguess = LCB_DEFAULT_VB_NOGUESS;
+    settings->select_bucket = LCB_DEFAULT_SELECT_BUCKET;
 }
 
 LCB_INTERNAL_API
@@ -67,6 +68,7 @@ lcb_settings_new(void)
     lcb_default_settings(settings);
     settings->refcount = 1;
     settings->auth = lcbauth_new();
+    settings->errmap = lcb_errmap_new();
     return settings;
 }
 
@@ -83,6 +85,7 @@ lcb_settings_unref(lcb_settings *settings)
     free(settings->client_string);
 
     lcbauth_unref(settings->auth);
+    lcb_errmap_free(settings->errmap);
 
     if (settings->ssl_ctx) {
         lcbio_ssl_free(settings->ssl_ctx);

data/ext/libcouchbase/src/settings.h

@@ -84,9 +84,11 @@
 #define LCB_DEFAULT_RETRY_NMV_INTERVAL LCB_MS2US(100)
 #define LCB_DEFAULT_VB_NOGUESS 1
 #define LCB_DEFAULT_TCP_NODELAY 1
+#define LCB_DEFAULT_SELECT_BUCKET 0
 
 #include "config.h"
 #include <libcouchbase/couchbase.h>
+#include "errmap.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -148,6 +150,8 @@ typedef struct lcb_settings_st {
     unsigned ipv6 : 2;
     unsigned tcp_nodelay : 1;
     unsigned readj_ts_wait : 1;
+    unsigned use_errmap : 1;
+    unsigned select_bucket : 1;
 
     short max_redir;
     unsigned refcount;
@@ -165,6 +169,7 @@ typedef struct lcb_settings_st {
     void (*dtorcb)(const void *);
     void *dtorarg;
     char *client_string;
+    lcb_pERRMAP errmap;
     lcb_U32 retry_nmv_interval;
 } lcb_settings;
 

data/ext/libcouchbase/src/ssl/ssl_common.c

@@ -156,7 +156,9 @@ iotssl_log_errors(lcbio_XSSL *xs)
         if (ERR_GET_LIB(curerr) == ERR_LIB_SSL) {
             switch (ERR_GET_REASON(curerr)) {
             case SSL_R_CERTIFICATE_VERIFY_FAILED:
+#ifdef SSL_R_MISSING_VERIFY_MESSAGE
             case SSL_R_MISSING_VERIFY_MESSAGE:
+#endif
                 xs->errcode = LCB_SSL_CANTVERIFY;
                 break;
 

data/ext/libcouchbase/tests/basic/t_host.cc

@@ -82,117 +82,109 @@ TEST_F(Hostlist, testEquals)
 
 TEST_F(Hostlist, testParseList)
 {
-    hostlist_t hosts = hostlist_create();
-    ASSERT_FALSE(NULL == hosts);
+    lcb::Hostlist hosts;
 
     lcb_error_t err;
-    err = hostlist_add_stringz(hosts, "1.1.1.1",  8091);
+    err = hosts.add("1.1.1.1",  8091);
     ASSERT_EQ(LCB_SUCCESS, err);
-    ASSERT_EQ(1, hosts->size());
-    ASSERT_TRUE(hosts->exists("1.1.1.1:8091"));
+    ASSERT_EQ(1, hosts.size());
+    ASSERT_TRUE(hosts.exists("1.1.1.1:8091"));
 
-
-    hostlist_clear(hosts);
-    err = hostlist_add_stringz(hosts, "1.1.1.1;",  8091);
+    hosts.clear();
+    err = hosts.add("1.1.1.1;",  8091);
     ASSERT_EQ(LCB_SUCCESS, err);
-    ASSERT_EQ(1, hosts->size());
-    ASSERT_TRUE(hosts->exists("1.1.1.1:8091"));
+    ASSERT_EQ(1, hosts.size());
+    ASSERT_TRUE(hosts.exists("1.1.1.1:8091"));
 
-    hostlist_clear(hosts);
-    err = hostlist_add_stringz(hosts, ";",  8091);
+    hosts.clear();
+    err = hosts.add(";",  8091);
     ASSERT_EQ(LCB_SUCCESS, err);
-    ASSERT_EQ(0, hosts->size());
+    ASSERT_EQ(0, hosts.size());
 
-    hostlist_clear(hosts);
-    err = hostlist_add_stringz(hosts, ";;;;",  8091);
+    hosts.clear();
+    err = hosts.add(";;;;",  8091);
     ASSERT_EQ(LCB_SUCCESS, err);
-    ASSERT_EQ(0, hosts->size());
+    ASSERT_EQ(0, hosts.size());
 
-    hostlist_clear(hosts);
-    err = hostlist_add_stringz(hosts, "1.1.1.1;2.2.2.2",  8091);
+    hosts.clear();
+    err = hosts.add("1.1.1.1;2.2.2.2",  8091);
     ASSERT_EQ(LCB_SUCCESS, err);
-    ASSERT_EQ(2, hosts->size());
-    ASSERT_TRUE(hosts->exists("1.1.1.1:8091"));
-    ASSERT_TRUE(hosts->exists("2.2.2.2:8091"));
-
+    ASSERT_EQ(2, hosts.size());
+    ASSERT_TRUE(hosts.exists("1.1.1.1:8091"));
+    ASSERT_TRUE(hosts.exists("2.2.2.2:8091"));
 
-    hostlist_clear(hosts);
-    err = hostlist_add_stringz(hosts, "1.1.1.1:1000;2.2.2.2:2000;3.3.3.3", 8091);
+    hosts.clear();
+    err = hosts.add("1.1.1.1:1000;2.2.2.2:2000;3.3.3.3", 8091);
     ASSERT_EQ(LCB_SUCCESS, err);
-    ASSERT_EQ(3, hosts->size());
-    ASSERT_TRUE(hosts->exists("1.1.1.1:1000"));
-    ASSERT_TRUE(hosts->exists("2.2.2.2:2000"));
-    ASSERT_TRUE(hosts->exists("3.3.3.3:8091"));
+    ASSERT_EQ(3, hosts.size());
+    ASSERT_TRUE(hosts.exists("1.1.1.1:1000"));
+    ASSERT_TRUE(hosts.exists("2.2.2.2:2000"));
+    ASSERT_TRUE(hosts.exists("3.3.3.3:8091"));
 
-    hostlist_clear(hosts);
-    err = hostlist_add_stringz(hosts, "1.1.1.1;1.1.1.1;1.1.1.1", 8091);
+    hosts.clear();
+    err = hosts.add("1.1.1.1;1.1.1.1;1.1.1.1", 8091);
     ASSERT_EQ(LCB_SUCCESS, err);
-    ASSERT_EQ(1, hosts->size());
-    ASSERT_TRUE(hosts->exists("1.1.1.1:8091"));
+    ASSERT_EQ(1, hosts.size());
+    ASSERT_TRUE(hosts.exists("1.1.1.1:8091"));
 
 
-    hostlist_clear(hosts);
-    err = hostlist_add_stringz(hosts, "1.1.1.1:9000;1.1.1.1:9001;1.1.1.1:9002",  8091);
+    hosts.clear();
+    err = hosts.add("1.1.1.1:9000;1.1.1.1:9001;1.1.1.1:9002",  8091);
     ASSERT_EQ(LCB_SUCCESS, err);
-    ASSERT_EQ(3, hosts->size());
-    ASSERT_TRUE(hosts->exists("1.1.1.1:9000"));
-    ASSERT_TRUE(hosts->exists("1.1.1.1:9001"));
-    ASSERT_TRUE(hosts->exists("1.1.1.1:9002"));
-
-    hostlist_clear(hosts);
-    ASSERT_EQ(LCB_SUCCESS, hostlist_add_stringz(hosts, "1.1.1.1", 8091));
-    ASSERT_EQ(LCB_SUCCESS, hostlist_add_stringz(hosts, "2.2.2.2", 8091));
-    ASSERT_EQ(LCB_SUCCESS, hostlist_add_stringz(hosts, "3.3.3.3", 8091));
-    ASSERT_EQ(3, hosts->size());
-
-    ASSERT_TRUE(hosts->exists("1.1.1.1:8091"));
-    ASSERT_TRUE(hosts->exists("2.2.2.2:8091"));
-    ASSERT_TRUE(hosts->exists("3.3.3.3:8091"));
-
-    hostlist_randomize(hosts);
-    hostlist_clear(hosts);
-    hostlist_randomize(hosts);
-
-    hostlist_destroy(hosts);
+    ASSERT_EQ(3, hosts.size());
+    ASSERT_TRUE(hosts.exists("1.1.1.1:9000"));
+    ASSERT_TRUE(hosts.exists("1.1.1.1:9001"));
+    ASSERT_TRUE(hosts.exists("1.1.1.1:9002"));
+
+    hosts.clear();
+    ASSERT_EQ(LCB_SUCCESS, hosts.add("1.1.1.1", 8091));
+    ASSERT_EQ(LCB_SUCCESS, hosts.add("2.2.2.2", 8091));
+    ASSERT_EQ(LCB_SUCCESS, hosts.add("3.3.3.3", 8091));
+    ASSERT_EQ(3, hosts.size());
+
+    ASSERT_TRUE(hosts.exists("1.1.1.1:8091"));
+    ASSERT_TRUE(hosts.exists("2.2.2.2:8091"));
+    ASSERT_TRUE(hosts.exists("3.3.3.3:8091"));
+
+    hosts.randomize();
+    hosts.clear();
+    hosts.randomize();
 }
 
 TEST_F(Hostlist, testCycle)
 {
-    hostlist_t hosts = hostlist_create();
+    lcb::Hostlist hosts;
     lcb_host_t *curhost;
 
-
     // Empty list
-    ASSERT_EQ(NULL, hostlist_shift_next(hosts, 0));
-    ASSERT_EQ(NULL, hostlist_shift_next(hosts, 1));
-    hostlist_destroy(hosts);
-    hosts = hostlist_create();
+    ASSERT_EQ(NULL, hosts.next(false));
+    ASSERT_EQ(NULL, hosts.next(true));
 
-    hostlist_add_stringz(hosts, "1.1.1.1", 8091);
-    curhost = hostlist_shift_next(hosts, 0);
+    hosts.clear();
+    hosts.add("1.1.1.1", 8091);
+    curhost = hosts.next(false);
     ASSERT_TRUE(curhost != NULL);
     ASSERT_TRUE(hostEquals(*curhost, "1.1.1.1", "8091"));
 
-    curhost = hostlist_shift_next(hosts, 0);
-    ASSERT_TRUE(hostlist_shift_next(hosts, 0) == NULL);
-    ASSERT_TRUE(hostlist_shift_next(hosts, 0) == NULL);
-    ASSERT_TRUE(hosts->ix == 1);
+    curhost = hosts.next(false);
+    ASSERT_TRUE(hosts.next(false) == NULL);
+    ASSERT_TRUE(hosts.next(false) == NULL);
+    ASSERT_TRUE(hosts.ix == 1);
 
-    curhost = hostlist_shift_next(hosts, 1);
+    curhost = hosts.next(true);
     ASSERT_TRUE(curhost != NULL);
     ASSERT_TRUE(hostEquals(*curhost, "1.1.1.1", "8091"));
 
-    hostlist_add_stringz(hosts, "2.2.2.2", 8091);
-    curhost = hostlist_shift_next(hosts, 0);
+    hosts.add("2.2.2.2", 8091);
+    curhost = hosts.next(false);
     ASSERT_TRUE(hostEquals(*curhost, "2.2.2.2", "8091"));
-    ASSERT_TRUE(hostlist_shift_next(hosts, 0) == NULL);
+    ASSERT_TRUE(hosts.next(false) == NULL);
 
-    curhost = hostlist_shift_next(hosts, 1);
+    curhost = hosts.next(true);
     ASSERT_TRUE(hostEquals(*curhost, "1.1.1.1", "8091"));
-    curhost = hostlist_shift_next(hosts, 0);
+    curhost = hosts.next(false);
     ASSERT_TRUE(hostEquals(*curhost, "2.2.2.2", "8091"));
 
-    hostlist_clear(hosts);
-    ASSERT_TRUE(hostlist_shift_next(hosts, 1) == NULL);
-    hostlist_destroy(hosts);
+    hosts.clear();
+    ASSERT_TRUE(hosts.next(true) == NULL);
 }