static void load_reader_driver_options(sc_context_t *ctx)
{
struct sc_reader_driver *driver = ctx->reader_driver;
scconf_block *conf_block = NULL;
sc_reader_t *reader;
int max_send_size;
int max_recv_size;
conf_block = sc_get_conf_block(ctx, "reader_driver", driver->short_name, 1);
if (conf_block != NULL) {
max_send_size = scconf_get_int(conf_block, "max_send_size", -1);
max_recv_size = scconf_get_int(conf_block, "max_recv_size", -1);
if (max_send_size >= 0 || max_recv_size >= 0) {
if (list_iterator_start(&ctx->readers)) {
reader = list_iterator_next(&ctx->readers);
while (reader) {
if (max_send_size >= 0)
reader->max_send_size = max_send_size;
if (max_recv_size >= 0)
reader->max_recv_size = max_recv_size;
reader = list_iterator_next(&ctx->readers);
}
list_iterator_stop(&ctx->readers);
}
}
}
}
int list__tail(data_t **args, argc_t argc, data_t *ret, scope_t *scope)
{
(void) argc;
list_node_t *node;
list_iterator_t *it = list_iterator_new(args[0]->value.list, LIST_HEAD);
check_mem(it);
ret->type = typedup(args[0]->type, scope->gc);
ret->value.list = gc_add_list(scope->gc, list_new());
node = list_iterator_next(it);
while ((node = list_iterator_next(it))) {
list_rpush(ret->value.list, list_node_new(node->val));
}
if (it) list_iterator_destroy(it);
return 0;
error:
if (it) list_iterator_destroy(it);
return -1;
}
Server* schedule_weighted_round_robin(Service* service, Endpoint* client_endpoint) {
uint32_t count = list_size(service->active_servers);
RoundRobin* roundrobin = service->priv;
if(count == 0)
return NULL;
uint32_t whole_weight = 0;
ListIterator iter;
list_iterator_init(&iter, service->active_servers);
while(list_iterator_has_next(&iter)) {
Server* server = list_iterator_next(&iter);
whole_weight += server->weight;
}
uint32_t _index = (roundrobin->robin++) & whole_weight;
list_iterator_init(&iter, service->active_servers);
while(list_iterator_has_next(&iter)) {
Server* server = list_iterator_next(&iter);
if(_index < server->weight)
return server;
else
_index -= server->weight;
}
return NULL;
}
void free_policy(bool runtime, policy_t* policy)
{
if (runtime)
return;
if (policy->name != NULL)
bdestroy(policy->name);
if (policy->instructions != NULL)
{
list_iterator_start(policy->instructions);
while (list_iterator_hasnext(policy->instructions))
free_policy_instruction(runtime, list_iterator_next(policy->instructions));
list_iterator_stop(policy->instructions);
list_destroy(policy->instructions);
free(policy->instructions);
}
if (policy->settings != NULL)
{
list_iterator_start(policy->settings);
while (list_iterator_hasnext(policy->settings))
free_policy_setting(runtime, list_iterator_next(policy->settings));
list_iterator_stop(policy->settings);
list_destroy(policy->settings);
free(policy->settings);
}
free(policy);
}
static void find_speaker(fd_set *set,
t_list *list,
SOCKET (*extract)(void *),
void (*execute)(void *))
{
t_list_iterator *it;
int ret;
void *tmp;
if (!set || !list || !extract || !execute)
return;
it = list_iterator_begin(list);
ret = (list_empty(list))?EXIT_FAILURE:EXIT_SUCCESS;
while (ret != EXIT_FAILURE)
{
tmp = list_iterator_get(it);
if (FD_ISSET(extract(tmp), set) && tmp)
{
logger_verbose("[NETWORK] message from fd : %d", extract(tmp));
ret = list_iterator_next(it);
(*execute)(tmp);
}
else
ret = list_iterator_next(it);
}
flush_list();
list_iterator_destroy(it);
}
/**
* Free stream data.
*
* @param sd
*/
void free_stream_data(stream_data *sd) {
if (sd == NULL) return;
// Free stream chunks, if any
if (sd->chunks != NULL) {
chunk_t *chunk = NULL;
list_iterator_reset(sd->chunks);
while((chunk = list_iterator_next(sd->chunks)) != NULL) {
free(chunk->data);
free(chunk);
}
list_destroy(&sd->chunks);
}
// Free inbound chunks, if any
if (sd->inbound_chunks != NULL) {
chunk_t *chunk = NULL;
list_iterator_reset(sd->inbound_chunks);
while((chunk = list_iterator_next(sd->inbound_chunks)) != NULL) {
free(chunk->data);
free(chunk);
}
list_destroy(&sd->inbound_chunks);
}
// Free outbound chunks, if any
if (sd->outbound_chunks != NULL) {
chunk_t *chunk = NULL;
list_iterator_reset(sd->outbound_chunks);
while((chunk = list_iterator_next(sd->outbound_chunks)) != NULL) {
free(chunk->data);
free(chunk);
}
list_destroy(&sd->outbound_chunks);
}
// Close the stream file, if we have it open
if (sd->fd != -1) {
close(sd->fd);
}
free(sd);
}
/*
====================================================================
Functions to access a PData tree.
'name' is the pass within tree 'pd' where subtrees are separated
by '/' (e.g.: name = 'config/graphics/animations')
parser_get_pdata : get pdata entry associated with 'name'
parser_get_entries : get list of subtrees (PData structs) in 'name'
parser_get_values : get value list of 'name'
parser_get_value : get a single value from value list of 'name'
parser_get_int : get first value of 'name' converted to integer
parser_get_double : get first value of 'name' converted to double
parser_get_string : get first value of 'name' _duplicated_
If an error occurs result is set NULL, False is returned and
parse_error is set.
====================================================================
*/
int parser_get_pdata ( PData *pd, const char *name, PData **result )
{
int i, found;
PData *pd_next = pd;
PData *entry = 0;
char *sub = 0;
List *path = parser_explode_string( name, '/' );
for ( i = 0, list_reset( path ); i < path->count; i++ ) {
ListIterator it;
sub = list_next( path );
if ( !pd_next->entries ) {
sprintf( parser_sub_error, tr("%s: no subtrees"), pd_next->name );
goto failure;
}
it = list_iterator( pd_next->entries ); found = 0;
while ( ( entry = list_iterator_next( &it ) ) )
if ( strlen( entry->name ) == strlen( sub ) && !strncmp( entry->name, sub, strlen( sub ) ) ) {
pd_next = entry;
found = 1;
break;
}
if ( !found ) {
sprintf( parser_sub_error, tr("%s: subtree '%s' not found"), pd_next->name, sub );
goto failure;
}
}
list_delete( path );
*result = pd_next;
return 1;
failure:
sprintf( parser_error, "parser_get_pdata: %s/%s: %s", pd->name, name, parser_sub_error );
list_delete( path );
*result = 0;
return 0;
}
int dbg_lua_handle_lines(lua_State* L)
{
struct dbg_state* state = dbg_lua_extract_state(L, 1);
void* ud = dbg_lua_extract_state_ud(L, 1);
list_t* symbols = state->dbg_lua_get_symbols();
struct dbg_sym* current = NULL;
struct dbg_sym_payload_line* payload = NULL;
int tbl;
lua_newtable(L);
if (symbols == NULL)
return 1;
tbl = lua_gettop(L);
list_iterator_start(symbols);
while (list_iterator_hasnext(symbols))
{
current = (struct dbg_sym*)list_iterator_next(symbols);
if (current->type != DBGFMT_SYMBOL_LINE)
continue;
payload = (struct dbg_sym_payload_line*)current->payload;
if (payload->path == NULL)
continue;
lua_newtable(L);
lua_pushstring(L, payload->path->data);
lua_setfield(L, -2, "file");
lua_pushnumber(L, payload->lineno);
lua_setfield(L, -2, "line");
lua_pushnumber(L, payload->address);
lua_setfield(L, -2, "address");
lua_rawseti(L, tbl, lua_objlen(L, tbl) + 1);
}
list_iterator_stop(symbols);
return 1;
}
int list__length(data_t **args, argc_t argc, data_t *ret, scope_t *scope)
{
(void) argc;
(void) scope;
list_node_t *node;
list_iterator_t *it = list_iterator_new(args[0]->value.list, LIST_HEAD);
check_mem(it);
int length = 0;
while ((node = list_iterator_next(it))) {
++length;
}
ret->type = construct_type(tid_integral, NULL, scope->gc);
ret->value.integral = length;
if (it) list_iterator_destroy(it);
return 0;
error:
if (it) list_iterator_destroy(it);
return -1;
}
static inline int
install_packages(list_t *list, const char *dir, int verbose) {
if (!list || !dir) return 0;
list_node_t *node;
list_iterator_t *it = list_iterator_new(list, LIST_HEAD);
while ((node = list_iterator_next(it))) {
clib_package_dependency_t *dep = node->val;
char *slug = clib_package_slug(dep->author, dep->name, dep->version);
clib_package_t *pkg = clib_package_new_from_slug(slug, verbose);
free(slug);
if (NULL == pkg) {
return -1;
}
int rc = clib_package_install(pkg, dir, verbose);
clib_package_free(pkg);
if (-1 == rc) {
list_iterator_destroy(it);
return -1;
}
}
list_iterator_destroy(it);
return 0;
}
int procauth_isauthoritative(int service_code, pid_t pid) {
procpid *pp;
list_iterator_start(&proclist);
while (list_iterator_hasnext(&proclist)) {
pp = (procpid *)list_iterator_next(&proclist);
if (pp->service_code == service_code) {
/* wanted service found, compare pids... */
list_iterator_stop(&proclist);
if (pp->current_pid == pid) /* authoritative */
return 1;
else {
pp->current_pid = procauth_getprocpid(pp->filename);
if (pp->current_pid == -1) { /* error accessing pidfile */
return 0;
} else {
if (pp->current_pid != pid) {
/* check if this is a child of the parent pid */
return procauth_ischildof(pid, pp->current_pid);
}
/* pid correctly updated and matching */
return 1;
}
}
}
}
list_iterator_stop(&proclist);
/* service_code was unknown */
return 0;
}
static void stdio_callback(uint32_t vmid, int thread_id, int fd, char* buffer, volatile size_t* head, volatile size_t* tail, size_t size) {
size_t len0, len1, len2;
bool wrapped;
if(*head <= *tail) {
wrapped = false;
len0 = *tail - *head;
} else {
wrapped = true;
len1 = size - *head;
len2 = *tail;
}
if(!manager_core) return;
ListIterator iter;
list_iterator_init(&iter, manager_core->clients);
while(list_iterator_has_next(&iter)) {
RPC* rpc = list_iterator_next(&iter);
if(wrapped) {
rpc_stdio(rpc, vmid, thread_id, fd, buffer + *head, len1, NULL, NULL);
rpc_stdio(rpc, vmid, thread_id, fd, buffer, len2, NULL, NULL);
} else {
rpc_stdio(rpc, vmid, thread_id, fd, buffer + *head, len0, NULL, NULL);
}
rpc_loop(rpc);
}
if(wrapped)
*head = (*head + len1 + len2) % size;
else
*head += len0;
}
struct lprov_entry* list_revert(list_t* list)
{
struct lprov_entry* first = NULL;
struct lprov_entry* previous = NULL;
struct lprov_entry* current = NULL;
struct lconv_entry* entry = NULL;
if (list == NULL)
return NULL;
list_iterator_start(list);
while (list_iterator_hasnext(list))
{
entry = list_iterator_next(list);
current = malloc(sizeof(struct lprov_entry));
current->address = entry->address;
current->label = bstr2cstr(entry->label, '0');
current->next = NULL;
if (previous != NULL)
previous->next = current;
if (first == NULL)
first = current;
previous = current;
}
list_iterator_stop(list);
return first;
}
void timers_handleMessage(int type, int reason, int value){
if (type == SDK_PRC_MESSAGE_CLK){
int nearest_id = getNearestFinishedTimer();
while (nearest_id >= 0){
if (nearest_id >= 0){
// process timer
list_node_t * node;
list_iterator_t * it = list_iterator_new(timers_list, LIST_HEAD);
while(node = list_iterator_next(it)){
STR_TIMER * timer = (STR_TIMER*)node->val;
if (timer->timer_number == nearest_id){
timer->last_tick = sdk_clk_timeSinceBoot();
(*timer->cback)(timer->timer_number);
break;
}
}
list_iterator_destroy(it);
}
nearest_id = getNearestFinishedTimer();
}
// set next timer
int nearest = getNearestTimerDelta();
if (nearest >= 0)
sdk_clk_setCountdownTimer(APP_TIMER_RESERVED, nearest, false);
}
}
void free_policy_value(bool runtime, policy_value_t* value)
{
if ((runtime && !value->runtime) ||
(!runtime && value->runtime))
return;
switch (value->type)
{
case NUMBER:
case TABLE:
case FIELD:
break;
case WORD:
case VARIABLE:
bdestroy(value->string);
break;
case FUNCTION:
free_policy_function_call(runtime, value->function);
break;
case LIST:
list_iterator_start(value->list);
while (list_iterator_hasnext(value->list))
free_policy_value(runtime, list_iterator_next(value->list));
list_iterator_stop(value->list);
list_destroy(value->list);
free(value->list);
break;
default:
break;
}
free(value);
}
/**
* Destroys a multipart/form-data parser.
*
* @param mpartp
*/
void htp_mpartp_destroy(htp_mpartp_t ** _mpartp) {
if ((_mpartp == NULL) || (*_mpartp == NULL)) return;
htp_mpartp_t * mpartp = *_mpartp;
if (mpartp->boundary != NULL) {
free(mpartp->boundary);
}
bstr_builder_destroy(mpartp->part_pieces);
bstr_builder_destroy(mpartp->boundary_pieces);
// Free parts
if (mpartp->parts != NULL) {
htp_mpart_part_t * part = NULL;
list_iterator_reset(mpartp->parts);
while ((part = list_iterator_next(mpartp->parts)) != NULL) {
htp_mpart_part_destroy(part);
}
list_destroy(&mpartp->parts);
}
free(mpartp);
*_mpartp = NULL;
}
static void nl_stream_destroy(nl_stream_t *s)
{
struct list_iterator_t it;
nl_buf_t *buf;
for (it = list_begin(s->tosend);
!list_iterator_equal(list_end(s->tosend), it);
it = list_iterator_next(it)) {
buf = list_iterator_item(it);
free(buf->buf);
}
list_destroy(s->tosend);
while (s->encoders != NULL) {
nl_stream_encoder_pop_back(s);
}
while (s->decoders != NULL) {
nl_stream_decoder_pop_back(s);
}
log_trace("#%d destroyed", s->sock.fd);
nl_close(&s->sock);
if (s->cbs.on_closed != NULL) {
s->cbs.on_closed(s);
}
}
/**
* Finalize MULTIPART processing.
*
* @param d
*/
int htp_ch_multipart_callback_request_body_data(htp_tx_data_t *d) {
if (d->data != NULL) {
// Process one chunk of data
htp_mpartp_parse(d->tx->request_mpartp, d->data, d->len);
} else {
// Finalize parsing
htp_mpartp_finalize(d->tx->request_mpartp);
d->tx->request_params_body =
d->tx->cfg->create_table(list_size(d->tx->request_mpartp->parts));
// TODO RC
// Extract parameters
d->tx->request_params_body_reused = 1;
htp_mpart_part_t *part = NULL;
list_iterator_reset(d->tx->request_mpartp->parts);
while ((part = (htp_mpart_part_t *) list_iterator_next(d->tx->request_mpartp->parts)) != NULL) {
// Only use text parameters
if (part->type == MULTIPART_PART_TEXT) {
if (d->tx->connp->cfg->parameter_processor == NULL) {
table_add(d->tx->request_params_body, part->name, part->value);
} else {
d->tx->connp->cfg->parameter_processor(d->tx->request_params_body, part->name, part->value);
}
}
}
}
return HOOK_OK;
}
void sc_initialize_boxing_cmds(sc_context_t *ctx)
{
sc_reader_t *reader;
if (!ctx)
return;
if (!list_iterator_start(&ctx->readers))
return;
reader = list_iterator_next(&ctx->readers);
while (reader) {
reader = list_iterator_next(&ctx->readers);
sc_detect_boxing_cmds(reader);
}
}
/**
* This function will search the list of cached pattern IDs for a pattern ID according to the given filename.
* If it finds one, the found ID will be returned.
* If not, -1 will be returned.
*/
int getPatternIDFromList(const char *filename) {
int id = -1;
#ifdef DEBUG_LOGGING
__android_log_write(ANDROID_LOG_INFO,"AR native","trying to retrieve pattern from list");
#endif
if (patternIDs == NULL) {
#ifdef DEBUG_LOGGING
__android_log_write(ANDROID_LOG_INFO,"AR native","list of patterns is null!!");
#endif
return -1;
}
list_iterator_start(patternIDs);
while (list_iterator_hasnext(patternIDs)) {
patternID * currPatt = (patternID *) list_iterator_next(patternIDs);
#ifdef DEBUG_LOGGING
__android_log_print(ANDROID_LOG_INFO,"AR native","current pattern fiel: %s",currPatt->filename);
#endif
if (strcmp(filename, currPatt->filename) == 0) {
#ifdef DEBUG_LOGGING
__android_log_write(ANDROID_LOG_INFO,"AR native","found pattern in list");
#endif
id = currPatt->id;
break;
}
}
list_iterator_stop(patternIDs);
#ifdef DEBUG_LOGGING
if(id==-1)
__android_log_print(ANDROID_LOG_INFO,"AR native","found no pattern in the list for file %s",filename);
#endif
return id;
}
int list__to_tuple(data_t **args, argc_t argc, data_t *ret, scope_t *scope)
{
(void) argc;
data_t ret1;
checkf(list__length(args, 1, &ret1, scope) == 0, "Failed to find list length.");
int len = ret1.value.integral;
struct type **multiple = gc_add(scope->gc, malloc(sizeof(struct type *) * (len + 1)));
multiple[len] = NULL;
ret->value.tuple = gc_add(scope->gc, malloc(sizeof(data_t *) * (len + 1)));
ret->value.tuple[len] = NULL;
list_node_t *node;
list_iterator_t *it = list_iterator_new(args[0]->value.list, LIST_HEAD);
int i = 0;
while ((node = list_iterator_next(it))) {
ret->value.tuple[i] = copy_data((data_t *) node->val, scope);
multiple[i] = ret->value.tuple[i]->type;
check_mem(ret->value.tuple[i]);
++i;
}
ret->type = construct_type(tid_tuple, multiple, scope->gc);
if (it) list_iterator_destroy(it);
return 0;
error:
if (it) list_iterator_destroy(it);
return -1;
}
likedListNo* linkedList_posicao(likedList *self, int index) {
likedListDirecao direction = LISTA_FINAL;
if (index < 0) {
direction = LISTA_FINAL;
index = ~index;
}
if ((unsigned)index < self->len) {
listIterator *it = list_iterator_new(self, direction);
likedListNo*node = list_iterator_next(it);
while (index--) node = list_iterator_next(it);
list_iterator_destroy(it);
return node;
}
return NULL;
}
///
/// Pops a scope from the stack.
///
void ppimpl_pop_scope(state_t* state)
{
scope_t* scope;
match_t* match;
match_t* old;
bstring name;
size_t a, i;
if (list_size(&state->scopes) == 0)
return;
scope = list_extract_at(&state->scopes, list_size(&state->scopes) - 1);
// Delete text if this scope was silenced.
if (!scope->active)
{
list_delete_range(&state->cached_output,
scope->start_index,
list_size(&state->cached_output) - 1);
}
// Delete handlers that were defined this scope.
list_iterator_start(&scope->new_handlers);
while (list_iterator_hasnext(&scope->new_handlers))
{
name = list_iterator_next(&scope->new_handlers);
for (i = 0; i < list_size(&state->handlers); i++)
{
old = list_get_at(&state->handlers, i);
if (biseq(name, old->text.ref))
{
// We need remove the old handler.
// FIXME: Free the old handler.
list_delete_at(&state->handlers, i);
i--;
}
}
bdestroy(name);
}
list_iterator_stop(&scope->new_handlers);
list_destroy(&scope->new_handlers);
// Restore handlers.
for (a = 0; a < list_size(&scope->old_handlers); a++)
{
match = list_get_at(&scope->old_handlers, a);
// Restore the old handler.
list_append(&state->handlers, match);
list_extract_at(&scope->old_handlers, a);
a--;
}
list_destroy(&scope->old_handlers);
// Free memory.
free(scope);
}
list_node_t *
list_at(list_t *self, int index) {
list_direction_t direction = LIST_HEAD;
if (index < 0) {
direction = LIST_TAIL;
index = ~index;
}
if ((unsigned)index < self->len) {
list_iterator_t *it = list_iterator_new(self, direction);
list_node_t *node = list_iterator_next(it);
while (index--) node = list_iterator_next(it);
list_iterator_destroy(it);
return node;
}
return NULL;
}
void free_policy_state(bool runtime, policy_state_t* state)
{
if (runtime)
return;
list_iterator_start(&state->variables);
while (list_iterator_hasnext(&state->variables))
free_policy_instruction(runtime, list_iterator_next(&state->variables));
list_iterator_stop(&state->variables);
list_destroy(&state->variables);
free(state);
}
void wr_rtp_packet_destroy(wr_rtp_packet_t * rtp_packet)
{
list_iterator_start(&rtp_packet->data_frames);
while(list_iterator_hasnext(&rtp_packet->data_frames)){
wr_data_frame_t * frame = (wr_data_frame_t * ) list_iterator_next(&rtp_packet->data_frames);
free(frame->data);
free(frame);
}
list_iterator_stop(&rtp_packet->data_frames);
list_destroy(&rtp_packet->data_frames);
}
int wr_rtp_packet_copy_with_data(wr_rtp_packet_t * new_packet, wr_rtp_packet_t * old_packet)
{
wr_rtp_packet_copy(new_packet, old_packet);
list_init(&new_packet->data_frames);
list_iterator_start(&old_packet->data_frames);
while(list_iterator_hasnext(&old_packet->data_frames)){
wr_data_frame_t * frame = (wr_data_frame_t * ) list_iterator_next(&old_packet->data_frames);
wr_rtp_packet_add_frame(new_packet, frame->data, frame->size, frame->length_in_ms);
}
list_iterator_stop(&old_packet->data_frames);
return 0;
}
void app_chat_server(){
canvas2 = (Canvas *)sdk_prc_getCanvas();
sdk_scr_printfXY(canvas2, 0, 0, "Starting server.\n");
while (1){
int addr;
char msg[1024];
memset(msg, 0, 1024 * sizeof(char));
int recv_size = sdk_nic_recv(msg, 1024, &addr);
if ((strlen(msg) > 0) && (strcmp(msg, "> SEARCH CR CHAT SERVER") == 0)){
sdk_scr_printf(canvas2, "New client addr: %d. Reply.\n", addr);
sdk_nic_send(addr, "< SEARCH RESPONSE", strlen("< SEARCH RESPONSE"));
}
if ((strlen(msg) > 0) && (strncmp(msg, "> NICKNAME", 8) == 0)){
sdk_scr_printf(canvas2, "name: %s\n", &msg[11]);
ClientInfo * cl = malloc(sizeof(ClientInfo));
memset(cl, 0, sizeof(ClientInfo));
cl->addr = addr;
strncpy(cl->name, &msg[10], strlen(&msg[10]));
if (list_clients == 0){
list_clients = list_new((void*)cl);
}
list_rpush(list_clients, list_node_new((void*)cl));
sendMsg(addr, "< NEWUSER %s", cl->name);
}
if ((strlen(msg) > 0) && (strncmp(msg, "> MESSAGE ", 8) == 0)){
sdk_scr_printf(canvas2, "msg: %s\n", &msg[10]);
//sender name
ClientInfo * author = NULL;
list_node_t *node;
list_iterator_t *it = list_iterator_new(list_clients, LIST_HEAD);
while ((node = list_iterator_next(it))) {
author = (ClientInfo*)node->val;
if (author->addr == addr){
break;
}
}
list_iterator_destroy(it);
sendMsg(addr, "< MESSAGE %s: %s", author->name, &msg[10]);
}
}
}
/**
* Destroys an existing hook. It is all right to send a NULL
* to this method because it will simply return straight away.
*
* @param hook
*/
void hook_destroy(htp_hook_t *hook) {
if (hook == NULL) return;
htp_callback_t *callback = NULL;
list_iterator_reset(hook->callbacks);
while ((callback = list_iterator_next(hook->callbacks)) != NULL) {
free(callback);
}
list_destroy(&hook->callbacks);
free(hook);
}
void free_policies(bool runtime, policies_t* policies)
{
if (runtime)
return;
list_iterator_start(&policies->policies);
while (list_iterator_hasnext(&policies->policies))
free_policy(runtime, list_iterator_next(&policies->policies));
list_iterator_stop(&policies->policies);
list_destroy(&policies->policies);
if (policies->settings != NULL)
free_policy(runtime, policies->settings);
free(policies);
}
