/** * 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); } } }