|
|
|
|
@ -2,6 +2,31 @@
|
|
|
|
|
#include <string.h> |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
int ami_free(AMI *ami){ |
|
|
|
|
|
|
|
|
|
ami_list_action_free(ami->actions); |
|
|
|
|
ami_list_event_free(ami->events); |
|
|
|
|
|
|
|
|
|
ami_list_actionid_free( ami->asterisk.list_actionid ); |
|
|
|
|
|
|
|
|
|
free(ami); |
|
|
|
|
|
|
|
|
|
return 0; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
int ami_list_actionid_free( ACTIONID *list_actionid ){ |
|
|
|
|
|
|
|
|
|
if(list_actionid){ |
|
|
|
|
ami_list_actionid_free( list_actionid->next ); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
free( list_actionid ); |
|
|
|
|
|
|
|
|
|
return 0; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Verifica se o evento continua esperando informação da AMI |
|
|
|
|
@ -10,7 +35,7 @@
|
|
|
|
|
* \param actionid valor da actionid que será verificada |
|
|
|
|
* \return sucesso 0, falha -1 |
|
|
|
|
*/ |
|
|
|
|
int is_actionid(struct s_actionid **list_actions, const char *actionid){ |
|
|
|
|
int ami_is_actionid(ACTIONID **list_actions, const char *actionid){ |
|
|
|
|
|
|
|
|
|
int bytes = strlen(actionid); |
|
|
|
|
|
|
|
|
|
@ -34,13 +59,13 @@ int is_actionid(struct s_actionid **list_actions, const char *actionid){
|
|
|
|
|
* |
|
|
|
|
* \return sucesso 0, falha -1 |
|
|
|
|
*/ |
|
|
|
|
int actionid_add(struct s_actionid **list_actions, const char *actionid){ |
|
|
|
|
int ami_actionid_add(ACTIONID **list_actions, const char *actionid){ |
|
|
|
|
|
|
|
|
|
while( (*list_actions) ){ |
|
|
|
|
list_actions = &(*list_actions)->next; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
*list_actions = calloc(1, sizeof(struct s_actionid)); |
|
|
|
|
*list_actions = calloc(1, sizeof(ACTIONID)); |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
strcpy((*list_actions)->actionid, actionid); |
|
|
|
|
@ -57,16 +82,16 @@ int actionid_add(struct s_actionid **list_actions, const char *actionid){
|
|
|
|
|
* \param actionid actionid que será excluída da lista |
|
|
|
|
* \return sucesso 0, falha -1 |
|
|
|
|
*/ |
|
|
|
|
int actionid_remove( struct s_actionid **list_actions, const char *actionid ){ |
|
|
|
|
int ami_actionid_remove( ACTIONID **list_actions, const char *actionid ){ |
|
|
|
|
|
|
|
|
|
struct s_actionid *drop_actionid = NULL; |
|
|
|
|
ACTIONID *drop_actionid = NULL; |
|
|
|
|
|
|
|
|
|
while( (*list_actions) ){ |
|
|
|
|
|
|
|
|
|
if( !strcmp( (*list_actions)->actionid, actionid ) ){ |
|
|
|
|
drop_actionid = *list_actions; |
|
|
|
|
*list_actions = (*list_actions)->next; |
|
|
|
|
actionid_free(drop_actionid); |
|
|
|
|
ami_actionid_free(drop_actionid); |
|
|
|
|
return 0; |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
@ -80,7 +105,7 @@ int actionid_remove( struct s_actionid **list_actions, const char *actionid ){
|
|
|
|
|
* \param drop_actionid ponteiro para estrutura |
|
|
|
|
* \return 0 sempre |
|
|
|
|
*/ |
|
|
|
|
int actionid_free( struct s_actionid *drop_actionid ){ |
|
|
|
|
int ami_actionid_free( ACTIONID *drop_actionid ){ |
|
|
|
|
|
|
|
|
|
free(drop_actionid); |
|
|
|
|
return 0; |
|
|
|
|
@ -93,7 +118,7 @@ int actionid_free( struct s_actionid *drop_actionid ){
|
|
|
|
|
* \param arg actionid que será verificada se está na lista |
|
|
|
|
* \return 0 não existe, 1 existe |
|
|
|
|
*/ |
|
|
|
|
int exist_actionid(ACTIONID **list_actionid, ACTIONID *actionid){ |
|
|
|
|
int ami_exist_actionid(ACTIONID **list_actionid, ACTIONID *actionid){ |
|
|
|
|
|
|
|
|
|
while(*list_actionid){ |
|
|
|
|
if(!strcmp((*list_actionid)->actionid, actionid->actionid)){ |
|
|
|
|
@ -108,8 +133,6 @@ int exist_actionid(ACTIONID **list_actionid, ACTIONID *actionid){
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
////* EVENT *////
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Redireciona se o evento é uma resposta ou não da action |
|
|
|
|
@ -118,17 +141,17 @@ int exist_actionid(ACTIONID **list_actionid, ACTIONID *actionid){
|
|
|
|
|
* \param event estrutura evento
|
|
|
|
|
* \return sucesso 0, falha -1 ( o ponteiro event é liberado) |
|
|
|
|
*/ |
|
|
|
|
int event_redirect(AMI *ami, EVENT *event){ |
|
|
|
|
int ami_event_redirect(AMI *ami, EVENT *event){ |
|
|
|
|
const char *str_actionid = "Actionid"; |
|
|
|
|
|
|
|
|
|
if(exist_key(&event->args, str_actionid) == -1){ |
|
|
|
|
if(ami_exist_key(&event->args, str_actionid) == -1){ |
|
|
|
|
if(ami->asterisk.disable_events == 0){ |
|
|
|
|
event_add(&ami->events, event); |
|
|
|
|
ami_event_add(&ami->events, event); |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
else{ |
|
|
|
|
if(action_event_add(&ami->actions, event) == -1){ |
|
|
|
|
event_free(event); |
|
|
|
|
if(ami_action_event_add(&ami->actions, event) == -1){ |
|
|
|
|
ami_event_free(event); |
|
|
|
|
return -1; |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
@ -143,9 +166,8 @@ int event_redirect(AMI *ami, EVENT *event){
|
|
|
|
|
* Adicionar eventos lista de eventos da ami. |
|
|
|
|
* \param event lista de eventos recebido do AMI |
|
|
|
|
* \param next próximo evento que será incluído na lista de eventos |
|
|
|
|
*
|
|
|
|
|
*/ |
|
|
|
|
void event_add(EVENT **event, EVENT *next){ |
|
|
|
|
void ami_event_add(EVENT **event, EVENT *next){ |
|
|
|
|
|
|
|
|
|
EVENT **init_event = event; |
|
|
|
|
size_t len_event = 0; |
|
|
|
|
@ -160,7 +182,7 @@ void event_add(EVENT **event, EVENT *next){
|
|
|
|
|
if( len_event >= MAX_LEN_EVENT ){ |
|
|
|
|
EVENT *p_event = *init_event; |
|
|
|
|
*init_event = p_event->next; |
|
|
|
|
event_free(p_event); |
|
|
|
|
ami_event_free(p_event); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
} |
|
|
|
|
@ -173,7 +195,7 @@ void event_add(EVENT **event, EVENT *next){
|
|
|
|
|
* |
|
|
|
|
* \return p_event um novo espaço para alocar eventos da AMI |
|
|
|
|
*/ |
|
|
|
|
EVENT *event_create(){ |
|
|
|
|
EVENT *ami_event_create(){ |
|
|
|
|
EVENT *p_event = calloc(1, sizeof(EVENT)); |
|
|
|
|
return p_event; |
|
|
|
|
} |
|
|
|
|
@ -184,14 +206,14 @@ EVENT *event_create(){
|
|
|
|
|
* |
|
|
|
|
* \param event estrutura que contém um evento da AMI |
|
|
|
|
*/ |
|
|
|
|
void event_free( EVENT *event ){ |
|
|
|
|
void ami_event_free( EVENT *event ){ |
|
|
|
|
|
|
|
|
|
if(!event){ |
|
|
|
|
return; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
free(event->event); |
|
|
|
|
list_args_free(event->args); |
|
|
|
|
ami_list_args_free(event->args); |
|
|
|
|
free(event); |
|
|
|
|
|
|
|
|
|
} |
|
|
|
|
@ -203,13 +225,13 @@ void event_free( EVENT *event ){
|
|
|
|
|
* |
|
|
|
|
* \param event lista de eventos que serão liberadas |
|
|
|
|
*/ |
|
|
|
|
void list_event_free(EVENT *event){ |
|
|
|
|
void ami_list_event_free(EVENT *event){ |
|
|
|
|
|
|
|
|
|
if(event){ |
|
|
|
|
list_event_free(event->next); |
|
|
|
|
ami_list_event_free(event->next); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
event_free(event); |
|
|
|
|
ami_event_free(event); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
@ -222,7 +244,7 @@ void list_event_free(EVENT *event){
|
|
|
|
|
* \param args lista de argumentos |
|
|
|
|
* \param arg argumento que será inserido |
|
|
|
|
*/ |
|
|
|
|
void args_add( ARGS **args, ARGS *arg ){ |
|
|
|
|
void ami_args_add( ARGS **args, ARGS *arg ){ |
|
|
|
|
|
|
|
|
|
while(*args){ |
|
|
|
|
args = &(*args)->next; |
|
|
|
|
@ -235,10 +257,10 @@ void args_add( ARGS **args, ARGS *arg ){
|
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
* Cria uma estrutura para um argumento. |
|
|
|
|
* \return arg estrutura do tipo struct s_args |
|
|
|
|
* \return arg estrutura do tipo ARGS |
|
|
|
|
*/ |
|
|
|
|
struct s_args *arg_create(){ |
|
|
|
|
struct s_args *arg = calloc(1, sizeof(struct s_args)); |
|
|
|
|
ARGS *ami_arg_create(){ |
|
|
|
|
ARGS *arg = calloc(1, sizeof(ARGS)); |
|
|
|
|
return arg; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
@ -247,7 +269,7 @@ struct s_args *arg_create(){
|
|
|
|
|
* libera o ponteiro para estrutura do argumento.
|
|
|
|
|
* \param arg liberar ponteiro |
|
|
|
|
*/ |
|
|
|
|
void args_free(ARGS *arg){ |
|
|
|
|
void ami_args_free(ARGS *arg){ |
|
|
|
|
|
|
|
|
|
if(!arg){ |
|
|
|
|
return; |
|
|
|
|
@ -265,13 +287,13 @@ void args_free(ARGS *arg){
|
|
|
|
|
* \param args pointeiro para essa lista |
|
|
|
|
*
|
|
|
|
|
*/ |
|
|
|
|
void list_args_free(ARGS *args){ |
|
|
|
|
void ami_list_args_free(ARGS *args){ |
|
|
|
|
|
|
|
|
|
if(args){ |
|
|
|
|
list_args_free(args->next); |
|
|
|
|
ami_list_args_free(args->next); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
args_free(args); |
|
|
|
|
ami_args_free(args); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
/*!
|
|
|
|
|
@ -279,7 +301,7 @@ void list_args_free(ARGS *args){
|
|
|
|
|
* \param args lista de argumentos |
|
|
|
|
* \return sucesso actionid, NULL não existe actionid(ou valoe é nulo) |
|
|
|
|
*/ |
|
|
|
|
const char *get_actionid(ARGS **args){ |
|
|
|
|
const char *ami_get_actionid(ARGS **args){ |
|
|
|
|
|
|
|
|
|
char *str_actionid = "Actionid"; |
|
|
|
|
|
|
|
|
|
@ -301,7 +323,7 @@ const char *get_actionid(ARGS **args){
|
|
|
|
|
* \param key chave que será procurada |
|
|
|
|
* \return retorna o valor da chave, NULL chave não existe ou o valor é nulo( use exist_key para verificar se chave existe) |
|
|
|
|
*/ |
|
|
|
|
const char *get_key_value(ARGS **args, const char *key){ |
|
|
|
|
const char *ami_get_key_value(ARGS **args, const char *key){ |
|
|
|
|
|
|
|
|
|
if(!key){ |
|
|
|
|
return NULL; |
|
|
|
|
@ -326,7 +348,7 @@ const char *get_key_value(ARGS **args, const char *key){
|
|
|
|
|
* \param key chave do argumento |
|
|
|
|
* \return existe 0, não existe -1 |
|
|
|
|
*/ |
|
|
|
|
int exist_key(ARGS **args, const char *key){ |
|
|
|
|
int ami_exist_key(ARGS **args, const char *key){ |
|
|
|
|
|
|
|
|
|
while(*args){ |
|
|
|
|
if(!strcasecmp((*args)->key, key)){ |
|
|
|
|
@ -345,7 +367,7 @@ int exist_key(ARGS **args, const char *key){
|
|
|
|
|
* Cria estrutura RESPONSE |
|
|
|
|
* \return response estrutura vazia que será usada para preencher resposta da AMI |
|
|
|
|
*/ |
|
|
|
|
RESPONSE *response_create(){ |
|
|
|
|
RESPONSE *ami_response_create(){ |
|
|
|
|
RESPONSE *response; |
|
|
|
|
response = calloc(1, sizeof(RESPONSE)); |
|
|
|
|
return response; |
|
|
|
|
@ -357,7 +379,7 @@ RESPONSE *response_create(){
|
|
|
|
|
* \param action estrutura action |
|
|
|
|
* \param response será adicionado para o ACtion |
|
|
|
|
*/ |
|
|
|
|
void action_response_add(ACTION *action, RESPONSE *response){ |
|
|
|
|
void ami_action_response_add(ACTION *action, RESPONSE *response){ |
|
|
|
|
|
|
|
|
|
if(!action->response){ |
|
|
|
|
action->response = response; |
|
|
|
|
@ -369,13 +391,13 @@ void action_response_add(ACTION *action, RESPONSE *response){
|
|
|
|
|
* Libera espaço do ponteiro da entrutura RESPONSE |
|
|
|
|
* \param response estrutura response que será liberada |
|
|
|
|
*/ |
|
|
|
|
int response_free(RESPONSE *response){ |
|
|
|
|
int ami_response_free(RESPONSE *response){ |
|
|
|
|
|
|
|
|
|
if(!response){ |
|
|
|
|
return -1; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
list_args_free(response->args); |
|
|
|
|
ami_list_args_free(response->args); |
|
|
|
|
free(response); |
|
|
|
|
|
|
|
|
|
return 0; |
|
|
|
|
@ -387,7 +409,7 @@ int response_free(RESPONSE *response){
|
|
|
|
|
* criar estrutura para preenche-la com resposta da action |
|
|
|
|
* \return action nova estrutura ACTION
|
|
|
|
|
*/ |
|
|
|
|
ACTION *action_create(){ |
|
|
|
|
ACTION *ami_action_create(){ |
|
|
|
|
ACTION * action; |
|
|
|
|
action = calloc(1, sizeof(ACTION)); |
|
|
|
|
return action; |
|
|
|
|
@ -400,13 +422,13 @@ ACTION *action_create(){
|
|
|
|
|
* \param toremove o action que será escluída da lista |
|
|
|
|
* \return
|
|
|
|
|
*/ |
|
|
|
|
int action_remove(ACTION **list_action, ACTION *toremove){ |
|
|
|
|
int ami_action_remove(ACTION **list_action, ACTION *toremove){ |
|
|
|
|
|
|
|
|
|
while(*list_action){ |
|
|
|
|
if(*list_action == toremove){ |
|
|
|
|
ACTION *p = (*list_action); |
|
|
|
|
(*list_action) = (*list_action)->next; |
|
|
|
|
action_free(p); |
|
|
|
|
ami_action_free(p); |
|
|
|
|
return 0; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
@ -422,13 +444,13 @@ int action_remove(ACTION **list_action, ACTION *toremove){
|
|
|
|
|
* \param list_action lista das action |
|
|
|
|
* \return 0 |
|
|
|
|
*/ |
|
|
|
|
int list_action_free(ACTION *list_action){ |
|
|
|
|
int ami_list_action_free(ACTION *list_action){ |
|
|
|
|
|
|
|
|
|
if(list_action){ |
|
|
|
|
list_action_free(list_action->next); |
|
|
|
|
ami_list_action_free(list_action->next); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
action_free(list_action); |
|
|
|
|
ami_action_free(list_action); |
|
|
|
|
|
|
|
|
|
return 0; |
|
|
|
|
} |
|
|
|
|
@ -439,15 +461,15 @@ int list_action_free(ACTION *list_action){
|
|
|
|
|
* \param action ponteiro para estrutura action |
|
|
|
|
* \return sempre sucesso 0 |
|
|
|
|
*/ |
|
|
|
|
int action_free(ACTION *action){ |
|
|
|
|
int ami_action_free(ACTION *action){ |
|
|
|
|
|
|
|
|
|
if(!action){ |
|
|
|
|
return -1; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
response_free(action->response); |
|
|
|
|
ami_response_free(action->response); |
|
|
|
|
free(action->actionid); |
|
|
|
|
list_event_free(action->events); |
|
|
|
|
ami_list_event_free(action->events); |
|
|
|
|
free(action); |
|
|
|
|
|
|
|
|
|
return 0; |
|
|
|
|
@ -460,13 +482,13 @@ int action_free(ACTION *action){
|
|
|
|
|
* \param next estrutura action que será inserida |
|
|
|
|
* \return sucesso 0, falha -1 (ponteiro next será liberado) |
|
|
|
|
*/ |
|
|
|
|
int action_add(ACTION **action, ACTION *next){ |
|
|
|
|
int ami_action_add(ACTION **action, ACTION *next){ |
|
|
|
|
|
|
|
|
|
ACTION **init_action = action; |
|
|
|
|
size_t len_action = 0; |
|
|
|
|
|
|
|
|
|
if(!next->actionid){ |
|
|
|
|
action_free(next); |
|
|
|
|
ami_action_free(next); |
|
|
|
|
return -1; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
@ -478,7 +500,7 @@ int action_add(ACTION **action, ACTION *next){
|
|
|
|
|
if(len_action > MAX_LEN_ACTION){ |
|
|
|
|
ACTION *p_action = *init_action; |
|
|
|
|
*init_action = p_action->next; |
|
|
|
|
action_free(p_action); |
|
|
|
|
ami_action_free(p_action); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
*action = next; |
|
|
|
|
@ -494,9 +516,9 @@ int action_add(ACTION **action, ACTION *next){
|
|
|
|
|
* \para event estrutura EVENT |
|
|
|
|
* \return sucesso 0, event não adicionado -1 |
|
|
|
|
*/ |
|
|
|
|
int action_event_add(ACTION **list_action, EVENT *event){ |
|
|
|
|
int ami_action_event_add(ACTION **list_action, EVENT *event){ |
|
|
|
|
|
|
|
|
|
const char *actionid = get_actionid(&event->args); |
|
|
|
|
const char *actionid = ami_get_actionid(&event->args); |
|
|
|
|
|
|
|
|
|
if(!actionid){ |
|
|
|
|
return -1; |
|
|
|
|
@ -504,7 +526,7 @@ int action_event_add(ACTION **list_action, EVENT *event){
|
|
|
|
|
|
|
|
|
|
while((*list_action)){ |
|
|
|
|
if(!strcasecmp((*list_action)->actionid, actionid)){ |
|
|
|
|
event_add(&(*list_action)->events, event); |
|
|
|
|
ami_event_add(&(*list_action)->events, event); |
|
|
|
|
return 0; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
@ -522,12 +544,12 @@ int action_event_add(ACTION **list_action, EVENT *event){
|
|
|
|
|
* \param action ponteiro action |
|
|
|
|
* \return sucesso 0, falha -1 |
|
|
|
|
*/ |
|
|
|
|
int set_action_actionid( ACTION *action ){ |
|
|
|
|
int ami_set_action_actionid( ACTION *action ){ |
|
|
|
|
|
|
|
|
|
const char *actionid = NULL; |
|
|
|
|
RESPONSE *response = action->response; |
|
|
|
|
|
|
|
|
|
actionid = get_key_value(&response->args, "Actionid"); |
|
|
|
|
actionid = ami_get_key_value(&response->args, "Actionid"); |
|
|
|
|
if( NULL == actionid ){ |
|
|
|
|
return -1; |
|
|
|
|
} |
|
|
|
|
@ -546,7 +568,7 @@ int set_action_actionid( ACTION *action ){
|
|
|
|
|
* \param actionid procurar a actions que tem o mesmo |
|
|
|
|
* \return sucesso action, NULL não existe action com aquela actionid
|
|
|
|
|
*/ |
|
|
|
|
ACTION *get_action(ACTION **list_actions, const char* actionid){ |
|
|
|
|
ACTION *ami_get_action(ACTION **list_actions, const char* actionid){ |
|
|
|
|
if(!(*list_actions)){ |
|
|
|
|
return NULL; |
|
|
|
|
} |
|
|
|
|
@ -569,7 +591,7 @@ ACTION *get_action(ACTION **list_actions, const char* actionid){
|
|
|
|
|
* \param events lista de eventos |
|
|
|
|
* \return np_events
|
|
|
|
|
*/ |
|
|
|
|
EVENT *isolate_events(EVENT **events){ |
|
|
|
|
EVENT *ami_isolate_events(EVENT **events){ |
|
|
|
|
EVENT *np_events; |
|
|
|
|
np_events = *events; |
|
|
|
|
*events = NULL; |
|
|
|
|
@ -583,7 +605,7 @@ EVENT *isolate_events(EVENT **events){
|
|
|
|
|
* \param action estrutura da resposta |
|
|
|
|
* \return reponse
|
|
|
|
|
*/ |
|
|
|
|
RESPONSE *isolate_action_response( ACTION *action ){ |
|
|
|
|
RESPONSE *ami_isolate_action_response( ACTION *action ){ |
|
|
|
|
|
|
|
|
|
RESPONSE *response = NULL; |
|
|
|
|
|
|
|
|
|
@ -603,7 +625,7 @@ RESPONSE *isolate_action_response( ACTION *action ){
|
|
|
|
|
* \param action estrutura de resposta |
|
|
|
|
* \return events
|
|
|
|
|
*/ |
|
|
|
|
EVENT *isolate_action_events(ACTION *action){ |
|
|
|
|
EVENT *ami_isolate_action_events(ACTION *action){ |
|
|
|
|
|
|
|
|
|
EVENT *events = NULL; |
|
|
|
|
|
|
|
|
|
|
Rodgger
2 years ago