/**
* Free all memory associated with a RpbPair
*/
void riack_free_copied_rpb_pair(riack_client* client, RpbPair* ppair)
{
RFREE(client, ppair->key.data);
if (ppair->has_value) {
RFREE(client, ppair->value.data);
}
}
void riack_free_copied_pair(riack_client* client, riack_pair *ppair)
{
RFREE(client, ppair->key.value);
if (ppair->value_present) {
RFREE(client, ppair->value);
}
}
static int nr_turn_stun_set_auth_params(nr_turn_stun_ctx *ctx,
char *realm, char *nonce)
{
int _status;
RFREE(ctx->realm);
RFREE(ctx->nonce);
assert(realm);
if (!realm)
ABORT(R_BAD_ARGS);
ctx->realm=r_strdup(realm);
if (!ctx->realm)
ABORT(R_NO_MEMORY);
assert(nonce);
if (!nonce)
ABORT(R_BAD_ARGS);
ctx->nonce=r_strdup(nonce);
if (!ctx->nonce)
ABORT(R_NO_MEMORY);
RFREE(ctx->stun->realm);
ctx->stun->realm = r_strdup(ctx->realm);
if (!ctx->stun->realm)
ABORT(R_NO_MEMORY);
ctx->stun->auth_params.realm = ctx->realm;
ctx->stun->auth_params.nonce = ctx->nonce;
ctx->stun->auth_params.authenticate = 1; /* May already be 1 */
_status=0;
abort:
return(_status);
}
/**
* Free all memory associated with a RpbPair
*/
void riak_free_copied_rpb_pair(struct RIACK_CLIENT* client, RpbPair* ppair)
{
RFREE(client, ppair->key.data);
if (ppair->has_value) {
RFREE(client, ppair->value.data);
}
}
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_ice_candidate_pair_destroy(nr_ice_cand_pair **pairp)
{
nr_ice_cand_pair *pair;
if(!pairp || !*pairp)
return(0);
pair=*pairp;
*pairp=0;
RFREE(pair->as_string);
RFREE(pair->foundation);
nr_ice_socket_deregister(pair->local->isock,pair->stun_client_handle);
if (pair->stun_client) {
RFREE(pair->stun_client->params.ice_binding_request.username);
RFREE(pair->stun_client->params.ice_binding_request.password.data);
nr_stun_client_ctx_destroy(&pair->stun_client);
}
NR_async_timer_cancel(pair->stun_cb_timer);
NR_async_timer_cancel(pair->restart_role_change_cb_timer);
NR_async_timer_cancel(pair->restart_nominated_cb_timer);
RFREE(pair);
return(0);
}
/**
* Free alle memory associated with a RpbPutReq
*/
void riack_free_copied_rpb_put_req(struct RIACK_CLIENT* client, RpbPutReq* pput_req)
{
if (pput_req) {
RFREE(client, pput_req->bucket.data);
RFREE(client, pput_req->vclock.data);
RFREE(client, pput_req->key.data);
riak_free_copied_rpb_content(client, pput_req->content);
RFREE(client, pput_req->content);
}
}
void riack_free(struct RIACK_CLIENT *client)
{
if (client != 0) {
if (client->last_error) {
RFREE(client, client->last_error);
}
if (client->host) {
RFREE(client, client->host);
}
riack_disconnect(client);
client->allocator.free(0, client);
}
}
void riack_message_free(struct RIACK_CLIENT *client, struct RIACK_PB_MSG** ppMsg)
{
struct RIACK_PB_MSG* pMsg = *ppMsg;
if (pMsg != 0)
{
if (pMsg->msg_len > 0 && pMsg->msg != 0)
{
RFREE(client, pMsg->msg);
}
RFREE(client, pMsg);
}
*ppMsg = 0;
}
void riak_free_content(struct RIACK_CLIENT* client, struct RIACK_CONTENT *pcontent)
{
size_t cnt, i;
RFREE(client, pcontent->charset.value);
RFREE(client, pcontent->content_encoding.value);
RFREE(client, pcontent->content_type.value);
RFREE(client, pcontent->vtag.value);
if (pcontent->data_len > 0) {
RFREE(client, pcontent->data);
}
cnt = pcontent->index_count;
if (cnt > 0) {
for (i=0; i<cnt; ++i) {
riak_free_copied_pair(client, &pcontent->indexes[i]);
}
RFREE(client,pcontent->indexes);
}
cnt = pcontent->usermeta_count;
if (cnt > 0) {
for (i=0; i<cnt; ++i) {
riak_free_copied_pair(client, &pcontent->usermetas[i]);
}
RFREE(client,pcontent->usermetas);
}
cnt = pcontent->link_count;
if (cnt > 0) {
for (i=0; i<cnt; ++i) {
riak_free_copied_link(client, &pcontent->links[i]);
}
RFREE(client,pcontent->links);
}
}
void riack_free_mapred_result(struct RIACK_CLIENT* client, struct RIACK_MAPRED_RESULT *result)
{
struct RIACK_MAPRED_RESULT *current, *last;
current = result;
last = 0;
while (current) {
if (current->data_size > 0 && current->data) {
RFREE(client, current->data);
}
last = current;
current = current->next_result;
RFREE(client, last);
}
}
void riack_free_mapred_result(riack_client* client, riack_mapred_response_list *result)
{
riack_mapred_response_list *current, *last;
current = result;
last = 0;
while (current) {
if (current->response.data_size > 0 && current->response.data) {
RFREE(client, current->response.data);
}
last = current;
current = current->next_result;
RFREE(client, last);
}
}
void riack_free_search_result_p(riack_client* client, riack_search_result** search_result)
{
if (search_result && *search_result) {
size_t cnt = (*search_result)->document_count;
if (cnt > 0) {
size_t i;
for (i = 0; i < cnt; ++i) {
riack_free_search_document(client, &(*search_result)->documents[i]);
}
RFREE(client, (*search_result)->documents);
}
RFREE(client, *search_result);
*search_result = 0;
}
}
int
nr_turn_client_ctx_destroy(nr_turn_client_ctx **ctxp)
{
nr_turn_client_ctx *ctx;
if(!ctxp || !*ctxp)
return(0);
ctx=*ctxp;
*ctxp = 0;
if (ctx->label)
r_log(NR_LOG_TURN, LOG_DEBUG, "TURN(%s): destroy", ctx->label);
nr_turn_client_deallocate(ctx);
/* Cancel frees the rest of our data */
RFREE(ctx->label);
ctx->label = 0;
nr_turn_client_cancel(ctx);
RFREE(ctx->username);
ctx->username = 0;
r_data_destroy(&ctx->password);
RFREE(ctx->nonce);
ctx->nonce = 0;
RFREE(ctx->realm);
ctx->realm = 0;
/* Destroy the STUN client ctxs */
while (!STAILQ_EMPTY(&ctx->stun_ctxs)) {
nr_turn_stun_ctx *stun = STAILQ_FIRST(&ctx->stun_ctxs);
STAILQ_REMOVE_HEAD(&ctx->stun_ctxs, entry);
nr_turn_stun_ctx_destroy(&stun);
}
/* Destroy the permissions */
while (!STAILQ_EMPTY(&ctx->permissions)) {
nr_turn_permission *perm = STAILQ_FIRST(&ctx->permissions);
STAILQ_REMOVE_HEAD(&ctx->permissions, entry);
nr_turn_permission_destroy(&perm);
}
RFREE(ctx);
return(0);
}
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;
}
/* {{{ proto void Riak\Bucket->getKeyStream(Riak\Output\KeyStreamOutput streamer [, int $timeout = 0])
Streams all keys in the bucket */
PHP_METHOD(RiakBucket, getKeyStream)
{
struct riak_stream_key_cb_param cb_params;
riack_string rsbucket, *rstype;
riak_connection *connection, *stream_connection;
zval* zstreamer;
long timeout;
int riackstatus;
timeout = 0;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O|l", &zstreamer, riak_key_streamer_ce, &timeout) == FAILURE) {
zend_throw_exception(riak_badarguments_exception_ce, "Bad or missing argument", 500 TSRMLS_CC);
return;
}
// Create a new connection only for this stream
// LibRiack can only handle one operation at the time pr connection
connection = get_riak_connection(getThis() TSRMLS_CC);
THROW_EXCEPTION_IF_CONNECTION_IS_NULL(connection);
stream_connection = take_connection(connection->client->host, strlen(connection->client->host), connection->client->port TSRMLS_CC);
if (!stream_connection) {
CHECK_RIACK_STATUS_THROW_AND_RETURN_ON_ERROR(stream_connection, RIACK_ERROR_COMMUNICATION);
}
rsbucket = riack_name_from_bucket(getThis() TSRMLS_CC);
#ifdef ZTS
cb_params.tsrm_ls = TSRMLS_C;
#endif
cb_params.zstreamer = zstreamer;
rstype = riack_get_bucket_type_from_bucket(connection->client, getThis() TSRMLS_CC);
// Not gonna do a retry here on purpose... no reason to retry a mistake in the first place
riackstatus = riack_stream_keys_ext(stream_connection->client, &rsbucket, rstype, riak_stream_key_cb, &cb_params, timeout);
CHECK_RIACK_STATUS_THROW_ON_ERROR(stream_connection, riackstatus);
RFREE(connection->client, rstype);
release_connection(stream_connection TSRMLS_CC);
}
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);
}
// 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_reg_get_child_registry(char *parent, unsigned int i, NR_registry child)
{
int r, _status;
size_t count;
NR_registry *children=0;
if ((r=reg_vtbl->vtbl->get_child_count(parent, &count)))
ABORT(r);
if (i >= count)
ABORT(R_NOT_FOUND);
else {
count++;
children = (NR_registry *)RCALLOC(count * sizeof(NR_registry));
if (!children)
ABORT(R_NO_MEMORY);
if ((r=reg_vtbl->vtbl->get_children(parent, children, count, &count)))
ABORT(r);
if (i >= count)
ABORT(R_NOT_FOUND);
strncpy(child, children[i], sizeof(NR_registry));
}
_status=0;
abort:
RFREE(children);
return(_status);
}
void NicerConnection::setupTurnServer() {
if (ice_config_.turn_server.empty()) {
return;
}
auto servers = std::unique_ptr<nr_ice_turn_server[]>(new nr_ice_turn_server[1]);
nr_ice_turn_server *server = &servers[0];
nr_ice_stun_server *stun_server = &server->turn_server;
memset(server, 0, sizeof(nr_ice_turn_server));
stun_server->transport = IPPROTO_UDP;
stun_server->type = NR_ICE_STUN_SERVER_TYPE_ADDR;
nr_transport_addr addr;
nr_str_port_to_transport_addr(ice_config_.turn_server.c_str(), ice_config_.turn_port, IPPROTO_UDP, &addr);
stun_server->u.addr = addr;
server->username = r_strdup(const_cast<char*>(ice_config_.turn_username.c_str()));
int r = r_data_create(&server->password,
reinterpret_cast<UCHAR*>(const_cast<char *>(&ice_config_.turn_pass[0])),
ice_config_.turn_pass.size());
if (r) {
RFREE(server->username);
return;
}
r = nicer_->IceContextSetTurnServers(ctx_, servers.get(), 1);
if (r) {
ELOG_WARN("%s message: Could not setup Turn", toLog());
}
ELOG_DEBUG("%s message: TURN server configured", toLog());
}
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;
}
nsresult NrIceTurnServer::ToNicerTurnStruct(nr_ice_turn_server *server) const {
memset(server, 0, sizeof(nr_ice_turn_server));
nsresult rv = ToNicerStunStruct(&server->turn_server);
if (NS_FAILED(rv))
return rv;
if (username_.empty())
return NS_ERROR_INVALID_ARG;
if (password_.empty())
return NS_ERROR_INVALID_ARG;
if (!(server->username=r_strdup(username_.c_str())))
return NS_ERROR_OUT_OF_MEMORY;
// TODO([email protected]): handle non-ASCII passwords somehow?
// STUN requires they be SASLpreped, but we don't know if
// they are at this point.
// C++03 23.2.4, Paragraph 1 stipulates that the elements
// in std::vector must be contiguous, and can therefore be
// used as input to functions expecting C arrays.
int r = r_data_create(&server->password,
const_cast<UCHAR *>(&password_[0]),
password_.size());
if (r) {
RFREE(server->username);
return NS_ERROR_OUT_OF_MEMORY;
}
return NS_OK;
}
void riack_free_get_object_p(riack_client *client, riack_get_object **object)
{
if (object && *object) {
riack_free_object(client, &(*object)->object);
RFREE(client, *object);
*object = 0;
}
}
void riack_free_string_p(riack_client* client, riack_string** string)
{
if (string != 0 && *string != 0) {
riack_free_string(client, *string);
RFREE(client, *string);
*string = 0;
}
}
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;
}
void riack_free_copied_rpb_search_req(riack_client *client,
RpbSearchQueryReq* search_req)
{
if (search_req->has_df) {
RFREE(client, search_req->df.data);
}
if (search_req->has_filter) {
RFREE(client, search_req->filter.data);
}
if (search_req->has_op) {
RFREE(client, search_req->op.data);
}
if (search_req->has_presort) {
RFREE(client, search_req->presort.data);
}
if (search_req->has_sort) {
RFREE(client, search_req->sort.data);
}
if (search_req->n_fl > 0) {
size_t i;
for (i=0; i<search_req->n_fl; ++i) {
RFREE(client, search_req->fl[i].data);
}
RFREE(client, search_req->fl);
}
}
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;
}
void riack_free_object(riack_client *client, riack_object *object)
{
size_t cnt, i;
if (object) {
RFREE(client, object->bucket.value);
RFREE(client, object->key.value);
if (object->vclock.len > 0) {
RFREE(client, object->vclock.clock);
}
cnt = object->content_count;
if (cnt > 0) {
for (i=0; i<cnt; ++i) {
riack_free_content(client, &object->content[i]);
}
RFREE(client,object->content);
}
}
}
/* Note: this function does not pull us off the tctx's list. */
static int nr_turn_stun_ctx_destroy(nr_turn_stun_ctx **ctxp)
{
nr_turn_stun_ctx *ctx;
if (!ctxp || !*ctxp)
return 0;
ctx = *ctxp;
*ctxp = 0;
nr_stun_client_ctx_destroy(&ctx->stun);
RFREE(ctx->realm);
RFREE(ctx->nonce);
RFREE(ctx);
return 0;
}
void riack_free_object(struct RIACK_CLIENT* client, struct RIACK_OBJECT *pobject)
{
size_t cnt, i;
if (pobject) {
RFREE(client, pobject->bucket.value);
RFREE(client, pobject->key.value);
if (pobject->vclock.len > 0) {
RFREE(client, pobject->vclock.clock);
}
cnt = pobject->content_count;
if (cnt > 0) {
for (i=0; i<cnt; ++i) {
riak_free_content(client, &pobject->content[i]);
}
RFREE(client,pobject->content);
}
}
}
