lcb_error_t lcb_apply_vbucket_config(lcb_t instance, VBUCKET_CONFIG_HANDLE config)
{
lcb_uint16_t ii, max, buii;
lcb_size_t num;
lcb_error_t err;
instance->vbucket_config = config;
instance->weird_things = 0;
num = (lcb_size_t)vbucket_config_get_num_servers(config);
/* servers array should be freed in the caller */
instance->servers = calloc(num, sizeof(lcb_server_t));
if (instance->servers == NULL) {
return lcb_error_handler(instance,
LCB_CLIENT_ENOMEM, "Failed to allocate memory");
}
instance->nservers = num;
lcb_free_backup_nodes(instance);
instance->backup_nodes = calloc(num + 1, sizeof(char *));
if (instance->backup_nodes == NULL) {
return lcb_error_handler(instance,
LCB_CLIENT_ENOMEM, "Failed to allocate memory");
}
err = setup_sasl_params(instance);
if (err != LCB_SUCCESS) {
return lcb_error_handler(instance, err, "sasl setup");
}
for (buii = 0, ii = 0; ii < num; ++ii) {
instance->servers[ii].instance = instance;
err = lcb_server_initialize(instance->servers + ii, (int)ii);
if (err != LCB_SUCCESS) {
return lcb_error_handler(instance, err, "Failed to initialize server");
}
instance->backup_nodes[buii] = instance->servers[ii].rest_api_server;
if (instance->randomize_bootstrap_nodes) {
/* swap with random position < ii */
if (buii > 0) {
lcb_size_t nn = (lcb_size_t)(gethrtime() >> 10) % buii;
char *pp = instance->backup_nodes[buii];
instance->backup_nodes[ii] = instance->backup_nodes[nn];
instance->backup_nodes[nn] = pp;
}
}
buii++;
}
mc_pSESSREQ
mc_sessreq_start(lcbio_SOCKET *sock, lcb_settings *settings,
uint32_t tmo, lcbio_CONNDONE_cb callback, void *data)
{
lcb_error_t err;
cbsasl_error_t saslerr;
protocol_binary_request_no_extras req;
const lcb_host_t *curhost;
struct lcbio_NAMEINFO nistrs;
mc_pSESSREQ sreq;
mc_pSESSINFO sasl;
lcbio_CTXPROCS procs;
if ((sreq = calloc(1, sizeof(*sreq))) == NULL) {
return NULL;
}
if ((sasl = calloc(1, sizeof(*sasl))) == NULL) {
cleanup_pending(sreq);
return NULL;
}
procs.cb_err = handle_ioerr;
procs.cb_read = handle_read;
lcbio_get_nameinfo(sock, &nistrs);
sreq->cb = callback;
sreq->data = data;
sreq->inner = sasl;
sreq->timer = lcbio_timer_new(sock->io, sreq, timeout_handler);
if ((err = lcbio_sslify_if_needed(sock, settings)) != LCB_SUCCESS) {
set_error_ex(sreq, err, "Couldn't initialize SSL on socket");
lcbio_async_signal(sreq->timer);
return sreq;
}
sreq->ctx = lcbio_ctx_new(sock, sreq, &procs);
sreq->ctx->subsys = "sasl";
if (tmo) {
lcbio_timer_rearm(sreq->timer, tmo);
}
sasl->base.id = LCBIO_PROTOCTX_SESSINFO;
sasl->base.dtor = (void (*)(struct lcbio_PROTOCTX *))cleanup_negotiated;
sasl->settings = settings;
err = setup_sasl_params(sasl);
if (err != LCB_SUCCESS) {
cleanup_pending(sreq);
return NULL;
}
curhost = lcbio_get_host(sock);
saslerr = cbsasl_client_new(
"couchbase", curhost->host, nistrs.local, nistrs.remote,
sasl->sasl_callbacks, 0, &sasl->sasl);
if (saslerr != SASL_OK) {
cleanup_pending(sreq);
return NULL;
}
memset(&req, 0, sizeof(req));
req.message.header.request.magic = PROTOCOL_BINARY_REQ;
req.message.header.request.opcode = PROTOCOL_BINARY_CMD_SASL_LIST_MECHS;
req.message.header.request.datatype = PROTOCOL_BINARY_RAW_BYTES;
req.message.header.request.bodylen = 0;
req.message.header.request.keylen = 0;
req.message.header.request.opaque = 0;
lcbio_ctx_put(sreq->ctx, req.bytes, sizeof(req.bytes));
LCBIO_CTX_RSCHEDULE(sreq->ctx, 24);
return sreq;
}
