void riak_set_object_response_values_get(struct RIACK_CLIENT* client, struct RIACK_GET_OBJECT *object, RpbGetResp* getresp)
{
size_t cnt, i;
if (!object || !getresp) {
return;
}
object->unchanged_present = getresp->has_unchanged ? 1 : 0;
object->unchanged = getresp->unchanged ? 1 : 0;
object->object.bucket.value = 0;
object->object.bucket.len = 0;
object->object.key.value = 0;
object->object.key.len = 0;
object->object.vclock.len = 0;
object->object.vclock.clock = 0;
if (getresp->has_vclock) {
object->object.vclock.len = getresp->vclock.len;
object->object.vclock.clock = (uint8_t*)RMALLOC(client, getresp->vclock.len);
memcpy(object->object.vclock.clock, getresp->vclock.data, getresp->vclock.len);
}
cnt = getresp->n_content;
object->object.content_count = cnt;
if (cnt > 0) {
object->object.content = RMALLOC(client, sizeof(struct RIACK_CONTENT)*cnt);
for (i=0; i<cnt; ++i) {
riack_copy_rpbcontent_to_content(client, getresp->content[i], &object->object.content[i]);
}
}
}
void riak_set_object_response_values(struct RIACK_CLIENT* client, struct RIACK_OBJECT *pobject, RpbPutResp* pput_resp)
{
size_t content_cnt, i;
if (!pput_resp || !pobject) {
return;
}
pobject->bucket.value = 0;
pobject->bucket.len = 0;
pobject->key.len = 0;
pobject->key.value = 0;
if (pput_resp->has_key) {
RMALLOCCOPY(client, pobject->key.value, pobject->key.len, pput_resp->key.data, pput_resp->key.len);
}
pobject->vclock.len = 0;
pobject->vclock.clock = 0;
if (pput_resp->has_vclock) {
RMALLOCCOPY(client, pobject->vclock.clock, pobject->vclock.len,
pput_resp->vclock.data, pput_resp->vclock.len);
}
content_cnt = pput_resp->n_content;
pobject->content_count = content_cnt;
if (content_cnt > 0) {
pobject->content = RMALLOC(client, sizeof(struct RIACK_CONTENT)*content_cnt);
for (i=0; i<content_cnt; ++i) {
riack_copy_rpbcontent_to_content(client, pput_resp->content[i], &pobject->content[i]);
}
}
}
int riack_connect(struct RIACK_CLIENT *client, const char* host, int port,
struct RIACK_CONNECTION_OPTIONS* options)
{
client->sockfd = sock_open(host, port);
if (client->sockfd > 0) {
if (client->host && host != client->host) {
RFREE(client, client->host);
}
if (host != client->host) {
client->host = (char*)RMALLOC(client, strlen(host)+1);
strcpy(client->host, host);
}
client->port = port;
if (options) {
client->options = *options;
if (!sock_set_timeouts(client->sockfd, options->recv_timeout_ms, options->send_timeout_ms)) {
sock_close(client->sockfd);
client->sockfd = -1;
// TODO set last error
}
}
return RIACK_SUCCESS;
}
return RIACK_ERROR_COMMUNICATION;
}
void riack_set_del_properties(struct RIACK_CLIENT *client, struct RIACK_DEL_PROPERTIES* props, RpbDelReq* del_req)
{
if (props) {
del_req->has_dw = props->dw_use;
del_req->dw = props->dw;
del_req->has_pr = props->pr_use;
del_req->pr = props->pr;
del_req->has_pw = props->pw_use;
del_req->pw = props->pw;
del_req->has_r = props->r_use;
del_req->r = props->r;
del_req->has_rw = props->rw_use;
del_req->rw = props->rw;
del_req->has_w = props->w_use;
del_req->w = props->w;
del_req->has_vclock = 0;
del_req->vclock.data = 0;
if (props->vclock.clock != 0) {
del_req->has_vclock = 1;
del_req->vclock.len = props->vclock.len;
del_req->vclock.data = RMALLOC(client, props->vclock.len);
memcpy(del_req->vclock.data, props->vclock.clock, props->vclock.len);
}
} else {
del_req->has_dw = 0;
del_req->has_pr = 0;
del_req->has_pw = 0;
del_req->has_r = 0;
del_req->has_rw = 0;
del_req->has_w = 0;
del_req->has_vclock = 0;
del_req->vclock.data = 0;
}
}
static int
grab_token(char **str, char **out)
{
int _status;
char *c = *str;
int len;
char *tmp;
while (*c != ' ' && *c != '\0')
++c;
len = c - *str;
tmp = RMALLOC(len + 1);
if (!tmp)
ABORT(R_NO_MEMORY);
strncpy(tmp, *str, len);
tmp[len] = '\0';
*str = c;
*out = tmp;
_status = 0;
abort:
return _status;
}
// convenience methods, call RFREE on the returned data
int
NR_reg_alloc_data(NR_registry name, Data *data)
{
int r, _status;
size_t length;
UCHAR *tmp = 0;
size_t sanity_check;
if ((r=NR_reg_get_length(name, &length)))
ABORT(r);
if (!(tmp = (void*)RMALLOC(length)))
ABORT(R_NO_MEMORY);
if ((r=NR_reg_get_bytes(name, tmp, length, &sanity_check)))
ABORT(r);
assert(length == sanity_check);
data->len = length;
data->data = tmp;
_status=0;
abort:
if (_status) {
if (tmp) RFREE(tmp);
}
return(_status);
}
int nr_concat_strings(char **outp,...)
{
va_list ap;
char *s,*out=0;
int len=0;
int _status;
va_start(ap,outp);
while(s=va_arg(ap,char *)){
len+=strlen(s);
}
va_end(ap);
if(!(out=RMALLOC(len+1)))
ABORT(R_NO_MEMORY);
*outp=out;
va_start(ap,outp);
while(s=va_arg(ap,char *)){
len=strlen(s);
memcpy(out,s,len);
out+=len;
}
va_end(ap);
*out=0;
_status=0;
abort:
return(_status);
}
int riack_set_clientid(struct RIACK_CLIENT *client, RIACK_STRING clientid)
{
int result;
struct RIACK_PB_MSG msg_req, *msg_resp;
RpbSetClientIdReq req;
size_t packed_size;
uint8_t *request_buffer;
rpb_set_client_id_req__init(&req);
req.client_id.len = clientid.len;
req.client_id.data = (uint8_t*)clientid.value;
packed_size = rpb_set_client_id_req__get_packed_size(&req);
request_buffer = (uint8_t*)RMALLOC(client, packed_size);
result = RIACK_ERROR_COMMUNICATION;
if (request_buffer) {
rpb_set_client_id_req__pack(&req, request_buffer);
msg_req.msg_len = packed_size;
msg_req.msg_code = mc_RpbSetClientIdReq;
msg_req.msg = request_buffer;
if ((riack_send_message(client, &msg_req) > 0)&&
(riack_receive_message(client, &msg_resp) > 0)) {
if (msg_resp->msg_code == mc_RpbSetClientIdResp) {
result = RIACK_SUCCESS;
} else {
riack_got_error_response(client, msg_resp);
result = RIACK_ERROR_RESPONSE;
}
riack_message_free(client, &msg_resp);
}
RFREE(client, request_buffer);
}
return result;
}
int riack_send_message(struct RIACK_CLIENT *client, struct RIACK_PB_MSG* msg)
{
uint8_t *buf;
uint32_t netlen, sendlen;
sendlen = 5 + msg->msg_len;
buf = (uint8_t*)RMALLOC(client, sendlen);
netlen = htonl(msg->msg_len+1);
memcpy(buf, &netlen, 4);
buf[4] = msg->msg_code;
if (msg->msg_len > 0)
{
memcpy(buf+5, msg->msg, (int)msg->msg_len);
}
// first send header
if (sock_send(client->sockfd, buf, sendlen) != sendlen)
{
printf("sock_send failed to send correct number of bytes\n");
// Error failed to send bytes most have lost connection
RFREE(client, buf);
return -1;
}
RFREE(client, buf);
return sendlen;
}
int
NR_reg_alloc_string(NR_registry name, char **data)
{
int r, _status;
size_t length;
char *tmp = 0;
if ((r=NR_reg_get_length(name, &length)))
ABORT(r);
if (!(tmp = (void*)RMALLOC(length+1)))
ABORT(R_NO_MEMORY);
if ((r=NR_reg_get_string(name, tmp, length+1)))
ABORT(r);
assert(length == strlen(tmp));
*data = tmp;
_status=0;
abort:
if (_status) {
if (tmp) RFREE(tmp);
}
return(_status);
}
void riack_string_linked_list_set_entry(struct RIACK_CLIENT *client,
struct RIACK_STRING_LINKED_LIST** entry,
RIACK_STRING string_new)
{
*entry = RMALLOC(client, sizeof(struct RIACK_STRING_LINKED_LIST));
(*entry)->next = 0;
(*entry)->string = string_new;
}
void riack_string_linked_list_set_entry(riack_client *client,
riack_string_linked_list** entry,
riack_string string_new)
{
*entry = RMALLOC(client, sizeof(riack_string_linked_list));
(*entry)->next = 0;
(*entry)->string = string_new;
}
int riack_get(struct RIACK_CLIENT *client,
RIACK_STRING bucket,
RIACK_STRING key,
struct RIACK_GET_PROPERTIES* props,
struct RIACK_GET_OBJECT* result_object)
{
int result;
size_t packed_size;
struct RIACK_PB_MSG msg_req, *msg_resp;
ProtobufCAllocator pb_allocator;
RpbGetReq get_req;
RpbGetResp *get_resp;
uint8_t *request_buffer;
if (!bucket.value || !key.value || key.len == 0 || bucket.len == 0 || !client) {
return RIACK_ERROR_INVALID_INPUT;
}
pb_allocator = riack_pb_allocator(&client->allocator);
result = RIACK_ERROR_COMMUNICATION;
rpb_get_req__init(&get_req);
get_req.key.data = (uint8_t *) key.value;
get_req.key.len = key.len;
get_req.bucket.data = (uint8_t *) bucket.value;
get_req.bucket.len = bucket.len;
riack_set_get_properties(client, props, &get_req);
packed_size = rpb_get_req__get_packed_size(&get_req);
request_buffer = (uint8_t*)RMALLOC(client, packed_size);
if (request_buffer) {
rpb_get_req__pack(&get_req, request_buffer);
msg_req.msg_code = mc_RpbGetReq;
msg_req.msg_len = packed_size;
msg_req.msg = request_buffer;
if ((riack_send_message(client, &msg_req) > 0)&&
(riack_receive_message(client, &msg_resp) > 0))
{
if (msg_resp->msg_code == mc_RpbGetResp) {
get_resp = rpb_get_resp__unpack(&pb_allocator, msg_resp->msg_len, msg_resp->msg);
if (get_resp) {
riak_set_object_response_values_get(client, result_object, get_resp);
rpb_get_resp__free_unpacked(get_resp, &pb_allocator);
result = RIACK_SUCCESS;
} else {
result = RIACK_FAILED_PB_UNPACK;
}
} else {
riack_got_error_response(client, msg_resp);
result = RIACK_ERROR_RESPONSE;
}
riack_message_free(client, &msg_resp);
}
RFREE(client, request_buffer);
}
return result;
}
/// Copies all optional search parameters to the protobuffers request.
void riack_set_optional_search_properties_on_req(riack_client *client, riack_search_optional_params* props,
RpbSearchQueryReq* search_req)
{
size_t cnt;
if (!props) {
return;
}
if (props->default_field_present) {
search_req->has_df = 1;
RMALLOCCOPY(client,
search_req->df.data, search_req->df.len,
props->default_field.value, props->default_field.len);
}
if (props->default_operation_present) {
search_req->has_op = 1;
RMALLOCCOPY(client,
search_req->op.data, search_req->op.len,
props->default_operation.value, props->default_operation.len);
}
if (props->filter_present) {
search_req->has_filter = 1;
RMALLOCCOPY(client,
search_req->filter.data, search_req->filter.len,
props->filter.value, props->filter.len);
}
if (props->presort_present) {
search_req->has_presort = 1;
RMALLOCCOPY(client,
search_req->presort.data, search_req->presort.len,
props->presort.value, props->presort.len);
}
if (props->rowlimit_present) {
search_req->has_rows = 1;
search_req->rows = props->rowlimit;
}
if (props->sort_present) {
search_req->has_sort = 1;
RMALLOCCOPY(client,
search_req->sort.data, search_req->sort.len,
props->sort.value, props->sort.len);
}
if (props->start_present) {
search_req->has_start = 1;
search_req->start = props->start;
}
cnt = props->field_limits_count;
search_req->n_fl = cnt;
if (cnt > 0) {
size_t i;
search_req->fl = RMALLOC(client, sizeof(ProtobufCBinaryData) * cnt);
for (i = 0; i<cnt; ++i) {
RMALLOCCOPY(client,
search_req->fl[i].data, search_req->fl[i].len,
props->field_limits[i].value, props->field_limits[i].len);
}
}
}
int riack_2i_query(struct RIACK_CLIENT *client, RpbIndexReq* request, RIACK_STRING_LIST* result_keys)
{
struct RIACK_PB_MSG msg_req, *msg_resp;
ProtobufCAllocator pb_allocator;
RpbIndexResp *index_resp;
int result;
size_t packed_size, keys, i;
uint8_t *request_buffer;
result = RIACK_ERROR_COMMUNICATION;
pb_allocator = riack_pb_allocator(&client->allocator);
packed_size = rpb_index_req__get_packed_size(request);
request_buffer = (uint8_t*)RMALLOC(client, packed_size);
if (request_buffer) {
rpb_index_req__pack(request, request_buffer);
msg_req.msg = request_buffer;
msg_req.msg_code = mc_RpbIndexReq;
msg_req.msg_len = packed_size;
if ((riack_send_message(client, &msg_req) > 0) &&
(riack_receive_message(client, &msg_resp) > 0)) {
if (msg_resp->msg_code == mc_RpbIndexResp) {
index_resp = rpb_index_resp__unpack(&pb_allocator, msg_resp->msg_len, msg_resp->msg);
if (index_resp) {
keys = index_resp->n_keys;
result_keys->string_count = keys;
result_keys->strings = RMALLOC(client, sizeof(RIACK_STRING) * keys);
for (i=0; i<keys; ++i) {
RMALLOCCOPY(client, result_keys->strings[i].value, result_keys->strings[i].len,
index_resp->keys[i].data, index_resp->keys[i].len);
}
rpb_index_resp__free_unpacked(index_resp, &pb_allocator);
result = RIACK_SUCCESS;
} else {
result = RIACK_FAILED_PB_UNPACK;
}
} else {
riack_got_error_response(client, msg_resp);
result = RIACK_ERROR_RESPONSE;
}
riack_message_free(client, &msg_resp);
}
RFREE(client, request_buffer);
}
return result;
}
static void _map_reduce_stream_callback(struct RIACK_CLIENT *client, void *args_raw, struct RIACK_MAPRED_RESPONSE *result)
{
struct RIACK_MAPRED_RESPONSE_LIST** chain = (struct RIACK_MAPRED_RESPONSE_LIST**)args_raw;
struct RIACK_MAPRED_RESPONSE_LIST* mapred_result_current =
(struct RIACK_MAPRED_RESPONSE_LIST*)RMALLOC(client, sizeof(struct RIACK_MAPRED_RESPONSE_LIST));
assert(chain);
assert(result);
riack_copy_strmapred_to_mapred(client, result, mapred_result_current);
riack_mapred_add_to_chain(client, chain, mapred_result_current);
}
void riak_copy_rpbpair_to_pair(struct RIACK_CLIENT* client, RpbPair* rpc_pair, struct RIACK_PAIR* rpair)
{
RMALLOCCOPY(client, rpair->key.value, rpair->key.len, rpc_pair->key.data, rpc_pair->key.len);
rpair->value_present = rpc_pair->has_value;
if (rpair->value_present) {
rpair->value_len = rpc_pair->value.len;
rpair->value = (uint8_t*)RMALLOC(client, rpair->value_len);
memcpy(rpair->value, rpc_pair->value.data, rpair->value_len);
}
}
void riack_copy_rpbpair_to_pair(riack_client* client, RpbPair* rpc_pair, riack_pair* rpair)
{
RMALLOCCOPY(client, rpair->key.value, rpair->key.len, rpc_pair->key.data, rpc_pair->key.len);
rpair->value_present = (uint8_t) rpc_pair->has_value;
if (rpair->value_present) {
rpair->value_len = rpc_pair->value.len;
rpair->value = (uint8_t*)RMALLOC(client, rpair->value_len);
memcpy(rpair->value, rpc_pair->value.data, rpair->value_len);
}
}
int riack_put(struct RIACK_CLIENT *client,
struct RIACK_OBJECT object,
struct RIACK_OBJECT* preturned_object,
struct RIACK_PUT_PROPERTIES* properties)
{
int result;
size_t packed_size;
struct RIACK_PB_MSG msg_req, *msg_resp;
ProtobufCAllocator pb_allocator;
RpbPutReq put_req;
RpbPutResp *put_resp;
uint8_t *request_buffer;
if (!client || !object.bucket.value) {
return RIACK_ERROR_INVALID_INPUT;
}
pb_allocator = riack_pb_allocator(&client->allocator);
result = RIACK_ERROR_COMMUNICATION;
rpb_put_req__init(&put_req);
riack_copy_object_to_rpbputreq(client, &object, &put_req);
riack_set_object_properties(properties, &put_req);
packed_size = rpb_put_req__get_packed_size(&put_req);
request_buffer = (uint8_t*)RMALLOC(client, packed_size);
if (request_buffer) {
rpb_put_req__pack(&put_req, request_buffer);
msg_req.msg_code = mc_RpbPutReq;
msg_req.msg_len = packed_size;
msg_req.msg = request_buffer;
if ((riack_send_message(client, &msg_req) > 0)&&
(riack_receive_message(client, &msg_resp) > 0))
{
if (msg_resp->msg_code == mc_RpbPutResp) {
result = RIACK_SUCCESS;
if (preturned_object) {
put_resp = rpb_put_resp__unpack(&pb_allocator, msg_resp->msg_len, msg_resp->msg);
if (put_resp) {
riak_set_object_response_values(client, preturned_object, put_resp);
rpb_put_resp__free_unpacked(put_resp, &pb_allocator);
} else {
result = RIACK_FAILED_PB_UNPACK;
}
}
} else {
riack_got_error_response(client, msg_resp);
result = RIACK_ERROR_RESPONSE;
}
riack_message_free(client, &msg_resp);
}
RFREE(client, request_buffer);
}
riack_free_copied_rpb_put_req(client, &put_req);
return result;
}
void riack_copy_strmapred_to_mapred(struct RIACK_CLIENT* client, struct RIACK_MAPRED_STREAM_RESULT* source,
struct RIACK_MAPRED_RESULT* target)
{
memset(target, 0, sizeof(*target));
target->phase = source->phase;
target->phase_present = source->phase_present;
if (source->data_size > 0) {
target->data_size = source->data_size;
target->data = (uint8_t*)RMALLOC(client, source->data_size);
memcpy(target->data, source->data, source->data_size);
}
}
void riack_copy_strmapred_to_mapred(riack_client* client, riack_mapred_response* source,
riack_mapred_response_list* target)
{
memset(target, 0, sizeof(*target));
target->response.phase = source->phase;
target->response.phase_present = source->phase_present;
if (source->data_size > 0) {
target->response.data_size = source->data_size;
target->response.data = (uint8_t*)RMALLOC(client, source->data_size);
memcpy(target->response.data, source->data, source->data_size);
}
}
int riack_get_bucket_props(struct RIACK_CLIENT *client, RIACK_STRING bucket, uint32_t *n_val, uint8_t *allow_mult)
{
int result;
struct RIACK_PB_MSG msg_req, *msg_resp;
ProtobufCAllocator pb_allocator;
size_t packed_size;
uint8_t *request_buffer;
RpbGetBucketResp *response;
RpbGetBucketReq get_request = RPB_GET_BUCKET_REQ__INIT;
if (!client || !bucket.value || bucket.len == 0) {
return RIACK_ERROR_INVALID_INPUT;
}
pb_allocator = riack_pb_allocator(&client->allocator);
result = RIACK_ERROR_COMMUNICATION;
get_request.bucket.len = bucket.len;
get_request.bucket.data = (uint8_t*)bucket.value;
packed_size = rpb_get_bucket_req__get_packed_size(&get_request);
request_buffer = (uint8_t*)RMALLOC(client, packed_size);
if (request_buffer) {
rpb_get_bucket_req__pack(&get_request, request_buffer);
msg_req.msg_code = mc_RpbGetBucketReq;
msg_req.msg_len = packed_size;
msg_req.msg = request_buffer;
if ((riack_send_message(client, &msg_req) > 0)&&
(riack_receive_message(client, &msg_resp) > 0))
{
if (msg_resp->msg_code == mc_RpbGetBucketResp) {
response = rpb_get_bucket_resp__unpack(&pb_allocator, msg_resp->msg_len, msg_resp->msg);
if (response) {
if (response->props->has_allow_mult) {
*allow_mult = response->props->allow_mult ? 1 : 0;
}
if (response->props->has_n_val) {
*n_val = response->props->n_val;
}
rpb_get_bucket_resp__free_unpacked(response, &pb_allocator);
result = RIACK_SUCCESS;
} else {
result = RIACK_FAILED_PB_UNPACK;
}
} else {
riack_got_error_response(client, msg_resp);
result = RIACK_ERROR_RESPONSE;
}
riack_message_free(client, &msg_resp);
}
RFREE(client, request_buffer);
}
return result;
}
void riack_copy_rpbsearchdoc_to_searchdoc(riack_client *client, RpbSearchDoc* rpbsearchdoc,
riack_search_doc *searchdoc)
{
size_t cnt, i;
cnt = rpbsearchdoc->n_fields;
searchdoc->field_count = cnt;
if (cnt > 0) {
searchdoc->fields = RMALLOC(client, sizeof(riack_pair)*cnt);
for (i=0; i<cnt; ++i) {
riack_copy_rpbpair_to_pair(client, rpbsearchdoc->fields[i], &searchdoc->fields[i]);
}
}
}
int riack_receive_message(struct RIACK_CLIENT *client, struct RIACK_PB_MSG** msg)
{
struct RIACK_PB_MSG* recvMsg;
uint32_t msgLenN;
int rcvBytes = 0;
if (msg == 0)
return 0;
*msg = 0;
recvMsg = (struct RIACK_PB_MSG*)RMALLOC(client, sizeof(struct RIACK_PB_MSG));
recvMsg->msg_len = 0;
recvMsg->msg = 0;
rcvBytes = sock_recv(client->sockfd, (uint8_t*)&msgLenN, 4);
if (rcvBytes == 4)
{
rcvBytes = sock_recv(client->sockfd, &recvMsg->msg_code, 1);
if (rcvBytes == 1)
{
recvMsg->msg_len = ntohl(msgLenN)-1;
if (recvMsg->msg_len > 0)
{
recvMsg->msg = (uint8_t*)RMALLOC(client, recvMsg->msg_len);
rcvBytes = sock_recv(client->sockfd, recvMsg->msg, recvMsg->msg_len);
if (rcvBytes == recvMsg->msg_len)
{
*msg = recvMsg;
return recvMsg->msg_len + 5;
}
}
else
{
*msg = recvMsg;
return 5;
}
}
}
riack_message_free(client, &recvMsg);
return -1;
}
void riack_copy_rpbmapred_to_mapred(struct RIACK_CLIENT* client, RpbMapRedResp* source, struct RIACK_MAPRED_RESULT* target)
{
target->next_result = 0;
target->phase_present = source->has_phase;
target->phase = source->phase;
if (source->has_response) {
target->data_size = source->response.len;
target->data = (uint8_t*)RMALLOC(client, source->response.len);
memcpy(target->data, source->response.data, source->response.len);
} else {
target->data_size = 0;
target->data = 0;
}
}
void riack_copy_object_to_rpbputreq(struct RIACK_CLIENT* client, struct RIACK_OBJECT *pobject, RpbPutReq* pput_req)
{
RpbContent *content;
content = (RpbContent*)RMALLOC(client, sizeof(RpbContent));
rpb_content__init(content);
riack_copy_content_to_rpbcontent(client, pobject->content, content);
pput_req->content = content;
pput_req->bucket.len = pobject->bucket.len;
pput_req->bucket.data = (uint8_t*)RMALLOC(client, pobject->bucket.len);
memcpy(pput_req->bucket.data, pobject->bucket.value, pobject->bucket.len);
if (pobject->key.value) {
pput_req->has_key = 1;
pput_req->key.len = pobject->key.len;
pput_req->key.data = (uint8_t*)RMALLOC(client, pobject->key.len);
memcpy(pput_req->key.data, pobject->key.value, pobject->key.len);
}
if (pobject->vclock.len > 0) {
pput_req->has_vclock = 1;
pput_req->vclock.len = pobject->vclock.len;
pput_req->vclock.data = (uint8_t*)RMALLOC(client, pobject->vclock.len);
memcpy(pput_req->vclock.data, pobject->vclock.clock, pobject->vclock.len);
}
}
int
nr_stun_remove_duplicate_addrs(nr_local_addr addrs[], int remove_loopback, int remove_link_local, int *count)
{
int r, _status;
nr_local_addr *tmp = 0;
int i;
int n;
tmp = RMALLOC(*count * sizeof(*tmp));
if (!tmp)
ABORT(R_NO_MEMORY);
n = 0;
for (i = 0; i < *count; ++i) {
if (nr_stun_is_duplicate_addr(tmp, n, &addrs[i])) {
/* skip addrs[i], it's a duplicate */
}
else if (remove_loopback && nr_transport_addr_is_loopback(&addrs[i].addr)) {
/* skip addrs[i], it's a loopback */
}
else if (remove_link_local &&
addrs[i].addr.ip_version == NR_IPV6 &&
nr_transport_addr_is_link_local(&addrs[i].addr)) {
/* skip addrs[i], it's a link-local address */
}
else {
/* otherwise, copy it to the temporary array */
if ((r=nr_local_addr_copy(&tmp[n], &addrs[i])))
ABORT(r);
++n;
}
}
*count = n;
memset(addrs, 0, *count * sizeof(*addrs));
/* copy temporary array into passed in/out array */
for (i = 0; i < *count; ++i) {
if ((r=nr_local_addr_copy(&addrs[i], &tmp[i])))
ABORT(r);
}
_status = 0;
abort:
RFREE(tmp);
return _status;
}
int riack_list_buckets(struct RIACK_CLIENT *client, RIACK_STRING_LIST* bucket_list)
{
int result;
struct RIACK_PB_MSG msg_req;
struct RIACK_PB_MSG *msg_resp;
RpbListBucketsResp *list_resp;
ProtobufCAllocator pb_allocator;
size_t i;
if (!client || !bucket_list) {
return RIACK_ERROR_INVALID_INPUT;
}
pb_allocator = riack_pb_allocator(&client->allocator);
result = RIACK_ERROR_COMMUNICATION;
msg_req.msg_code = mc_RpbListBucketsReq;
msg_req.msg_len = 0;
bucket_list->string_count = 0;
if ((riack_send_message(client, &msg_req) > 0)&&
(riack_receive_message(client, &msg_resp) > 0)) {
if (msg_resp->msg_code == mc_RpbListBucketsResp) {
list_resp = rpb_list_buckets_resp__unpack(&pb_allocator, msg_resp->msg_len, msg_resp->msg);
if (list_resp) {
bucket_list->string_count = list_resp->n_buckets;
bucket_list->strings = (RIACK_STRING*)RMALLOC(client, sizeof(RIACK_STRING) * list_resp->n_buckets);
for (i=0; i<list_resp->n_buckets; ++i) {
RMALLOCCOPY(client,
bucket_list->strings[i].value,
bucket_list->strings[i].len,
list_resp->buckets[i].data,
list_resp->buckets[i].len);
}
rpb_list_buckets_resp__free_unpacked(list_resp, &pb_allocator);
result = RIACK_SUCCESS;
} else {
result = RIACK_FAILED_PB_UNPACK;
}
} else {
riack_got_error_response(client, msg_resp);
result = RIACK_ERROR_RESPONSE;
}
riack_message_free(client, &msg_resp);
}
return result;
}
int riack_delete(struct RIACK_CLIENT *client, RIACK_STRING bucket, RIACK_STRING key, struct RIACK_DEL_PROPERTIES *props)
{
int result;
size_t packed_size;
struct RIACK_PB_MSG msg_req, *msg_resp;
RpbDelReq del_req;
uint8_t *request_buffer;
if (!client || !bucket.value || !key.value || key.len == 0 || bucket.len == 0) {
return RIACK_ERROR_INVALID_INPUT;
}
result = RIACK_ERROR_COMMUNICATION;
rpb_del_req__init(&del_req);
del_req.bucket.len = bucket.len;
del_req.bucket.data = (uint8_t *) bucket.value;
del_req.key.len = key.len;
del_req.key.data = (uint8_t *) key.value;
riack_set_del_properties(client, props, &del_req);
packed_size = rpb_del_req__get_packed_size(&del_req);
request_buffer = (uint8_t*)RMALLOC(client, packed_size);
if (request_buffer) {
rpb_del_req__pack(&del_req, request_buffer);
msg_req.msg_code = mc_RpbDelReq;
msg_req.msg_len = packed_size;
msg_req.msg = request_buffer;
if ((riack_send_message(client, &msg_req) > 0)&&
(riack_receive_message(client, &msg_resp) > 0))
{
if (msg_resp->msg_code == mc_RpbDelResp) {
result = RIACK_SUCCESS;
} else {
riack_got_error_response(client, msg_resp);
result = RIACK_ERROR_RESPONSE;
}
riack_message_free(client, &msg_resp);
}
RFREE(client, request_buffer);
}
RFREE(client, del_req.vclock.data);
return result;
}
int riack_put_simple(struct RIACK_CLIENT *client, char* bucket, char* key, uint8_t* data, size_t datalen, char* content_type)
{
int result;
struct RIACK_OBJECT object;
object.bucket.value = bucket;
object.bucket.len = strlen(bucket);
object.key.value = key;
object.key.len = strlen(key);
object.vclock.len = 0;
object.content = (struct RIACK_CONTENT*)RMALLOC(client, sizeof(struct RIACK_CONTENT));
memset(object.content, 0, sizeof(struct RIACK_CONTENT));
object.content[0].content_type.value = content_type;
object.content[0].content_type.len = strlen(content_type);
object.content[0].data_len = datalen;
object.content[0].data = data;
result = riack_put(client, object, 0, (struct RIACK_PUT_PROPERTIES*)0);
RFREE(client, object.content);
return result;
}
