static void on_call_state (pjsua_call_id call_id, pjsip_event *e) {
ics_t *data;
pjsua_call_info ci;
PJ_UNUSED_ARG(e);
pjsua_call_get_info(call_id, &ci);
//Handle hold call problem
#if 0
if ( (strcmp(ci.state_text.ptr,"CALLING") == 0) && (current_call != PJSUA_INVALID_ID) )
_ics_hold_call(data);
#endif
current_call = call_id;
if (strcmp(ci.state_text.ptr,"DISCONNCTD") == 0){
find_call();
}
data = (ics_t *)pjsua_acc_get_user_data(ci.acc_id);
opool_item_t *p_item = opool_get(&data->opool);
build_call_state_event((ics_event_t *)p_item->data, call_id,ci.state, ci.state_text.ptr, ci.remote_info.ptr);
ics_event_t *event = (ics_event_t *)p_item->data;
process_event(event);
opool_free(&data->opool, p_item);
}
/**
* \fn on_reg_started(), on_reg_state(), on_incoming_call(), on_call_state(), on_call_transfer_status(), on_call_media_state()
* \brief cac ham callback
*/
static void on_reg_started(pjsua_acc_id acc_id, pj_bool_t renew) {
ics_t *data;
data = (ics_t *)pjsua_acc_get_user_data(acc_id);
opool_item_t *p_item = opool_get(&data->opool);
ics_event_t *event = (ics_event_t *)p_item->data;
build_reg_start_event((ics_event_t *)p_item->data, acc_id);
process_event(event);
opool_free(&data->opool, p_item);
}
static void on_reg_state(pjsua_acc_id acc_id, pjsua_reg_info *info) {
ics_t *data;
data = (ics_t *)pjsua_acc_get_user_data(acc_id);
opool_item_t *p_item = opool_get(&data->opool);
ics_event_t *event = (ics_event_t *)p_item->data;
build_reg_state_event((ics_event_t *)p_item->data, acc_id,info->cbparam->expiration, info->cbparam->code,
info->cbparam->reason.ptr, info->cbparam->reason.slen);
process_event(event);
opool_free(&data->opool, p_item);
}
int do_test(void *user) {
int i;
pj_pool_t *pool = (pj_pool_t *)user;
opool_init(&opool, 10, strlen(s)+10, pool);
for (i = 0; i < 100; i++) {
opool_item_t *p_item = opool_get(&opool);
pj_memcpy(p_item->data, s, strlen(s));
printf("%d: %s\n", i, p_item->data);
pj_thread_sleep(pj_rand()%100);
opool_free(&opool, p_item);
}
return 0;
}
static void on_incoming_call(pjsua_acc_id acc_id, pjsua_call_id call_id, pjsip_rx_data *rdata) {
PJ_UNUSED_ARG(rdata);
ics_t *data;
pjsua_call_info ci;
pjsua_call_get_info(call_id, &ci);
data = (ics_t *)pjsua_acc_get_user_data(acc_id);
//_ics_hold_call(data);
opool_item_t *p_item = opool_get(&data->opool);
build_incoming_call_event((ics_event_t *)p_item->data, acc_id,call_id, ci.state, ci.remote_info.ptr, ci.local_info.ptr);
ics_event_t *event = (ics_event_t *)p_item->data;
//queue_enqueue(&data->queue, (void *)p_item);
process_event(event);
current_call = call_id;
opool_free(&data->opool, p_item);
}
static void on_call_media_state(pjsua_call_id call_id) {
ics_t *data;
pjsua_call_info ci;
pjsua_call_get_info(call_id, &ci);
//! Khoi tao mot connect media flow tu app nay sang app khac
if (ci.media_status == PJSUA_CALL_MEDIA_ACTIVE) {
pjsua_conf_connect(ci.conf_slot, 0); // ntt1->quy
pjsua_conf_connect(0, ci.conf_slot); // quy->ntt1
}
pjsua_call_get_info(call_id, &ci);
data = (ics_t *)pjsua_acc_get_user_data(ci.acc_id);
opool_item_t *p_item = opool_get(&data->opool);
build_call_media_state_event((ics_event_t *)p_item->data, call_id, ci.media_status, ci.remote_info.ptr);
ics_event_t *event = (ics_event_t *)p_item->data;
// queue_enqueue(&data->queue, (void *)p_item);
process_event(event);
opool_free(&data->opool, p_item);
}
TagValueFunction* tnfa_match(TNFA* tnfa, char* input, int anchorStart, int anchorEnd){
Vector* reach, *reachNext, *tmp;
TagValueFunction** reachTVFs, **reachNextTVFs, **tmpTVFs;
int i;
int leftmostMatchFound = 0;
TagValueFunction* finalTVF = NULL;
void** vd;
TNFAMatcher m;
/* Construct the matcher Object */
m.tnfa = tnfa;
m.pos = 0;
m.counts = ecalloc(tnfa->laststate+1,sizeof(int));
m.queue = ibqueue_create(tnfa->laststate+1);
m.priorities = ecalloc(tnfa->laststate+1,sizeof(PriorityList*));
m.tmp = tvf_create(tnfa->tagcount);
m.tvfpool = opool_createWithExt((void*(*)(void*))tvf_create,shared_free,NULL,NULL,(void*)tnfa->tagcount,10);
m.plistpool = opool_createWithExt((void*(*)(void*))plist_create,shared_free,NULL,NULL,(void*)tnfa->maxpath,10);
reach = vec_createDefault();
reachTVFs = ecalloc(tnfa->laststate+1,sizeof(TagValueFunction*));
reachNext = vec_createDefault();
reachNextTVFs = ecalloc(tnfa->laststate+1,sizeof(TagValueFunction*));
/* Initialize reach to consistentClosure({<s,v0>}); */
vec_add(reach,(void*)tnfa->start);
reachTVFs[tnfa->start] = (TagValueFunction*)opool_grab(m.tvfpool);
reach = tnfa_close(m,reach,reachTVFs);
/* If this regex matches the empty string then we may already have a possible match :P */
if(reachTVFs[tnfa->finish]!=NULL && (!anchorEnd || (anchorEnd && !*input)) ){
leftmostMatchFound = 1;
finalTVF = (TagValueFunction*)opool_grab(m.tvfpool);
tvf_copyInto(finalTVF,reachTVFs[tnfa->finish],m.tnfa->tagcount);
}
/*{int i;
printf("{");
for(i=0;i<vec_size(reach);i++)
printf("%d,",vec_get(reach,i));
printf("}");
printf("{");
for(i=0;i<m.tnfa->laststate+1;i++){
int j;int found=0;
if(reachTVFs[i] != NULL){
for(j=0;j<vec_size(reach);j++)
if(vec_get(reach,j) == i) found =1;
if(found) printf("*,"); else printf("?");
} else { printf("_,"); }
}
printf("}\n");
} */
//printf("\nclosure(s%d) = %s",tnfa->start,match_toString(reach,tnfa));
/* while pos < |input| */
while(*input && vec_size(reach) > 0){
/* fetch the next input symbol */
char c = *input;
input ++;
m.pos++;
vec_clear(reachNext);
memset(reachNextTVFs,'\0',(tnfa->laststate+1) * sizeof(TagValueFunction*));
/* For each item <q,v> in reach */
for(i=vec_size(reach)-1,vd=vec_data(reach);i>=0;i--){
TFATrans* t;
TagValueFunction* v;
int q = (int)vd[i];
v = reachTVFs[q];
/* For each transition on c out of q do */
t = tnfa->cStates[q];
while(t != NULL){
/* add <t->to,v> to reachNext */
if(t->c == c){
/* WARNING: ... dangerous : I believe that with NFAs constructed
with the thompson construction there is a 1to1 mapping between
'from' states and 'to' states on a non-epsilon transition. If that
were not the case then there might be two different ways to get to
the same state from reach on c and I would need to add those seperately
to reachNext prohibiting the use of a hash */
reachNextTVFs[t->to] = (TagValueFunction*)opool_grab(m.tvfpool);
tvf_copyInto(reachNextTVFs[t->to],v,m.tnfa->tagcount);
vec_add(reachNext,(void*)t->to);
}
t = t->next;
}
}
/* Free reach */
for(i=vec_size(reach)-1,vd=vec_data(reach);i>=0;i--)
opool_release(m.tvfpool,reachTVFs[(int)vd[i]]);
if(!anchorStart && (!leftmostMatchFound || anchorEnd)){
if(reachNextTVFs[tnfa->start] == NULL){
reachNextTVFs[tnfa->start] = (TagValueFunction*)opool_grab(m.tvfpool);
tvf_initialize(reachNextTVFs[tnfa->start],tnfa->tagcount);
vec_add(reachNext,(void*)tnfa->start);
}
}
reachNext = tnfa_close(m,reachNext,reachNextTVFs);
if(reachNextTVFs[tnfa->finish] != NULL){
leftmostMatchFound = 1;
if( (!anchorEnd && (finalTVF == NULL || reachNextTVFs[tnfa->finish][0] <= finalTVF[0])) ||
(anchorEnd && !*input) ){
if(finalTVF!=NULL) opool_release(m.tvfpool,finalTVF);
finalTVF = (TagValueFunction*)opool_grab(m.tvfpool);
tvf_copyInto(finalTVF,reachNextTVFs[tnfa->finish],m.tnfa->tagcount);
// printf("\tFound potential match: %s\n",match_toString(reachNext,tnfa));
}
}
//printf("\nclosure = %s",match_toString(reachNext,tnfa));
// Swap reach and reachNext
tmp = reach;
tmpTVFs = reachTVFs;
reach = reachNext;
reachTVFs = reachNextTVFs;
reachNext = tmp;
reachNextTVFs = tmpTVFs;
}
/* Free reach */
for(i=vec_size(reach)-1,vd=vec_data(reach);i>=0;i--)
opool_release(m.tvfpool,reachTVFs[(int)vd[i]]);
vec_free(reach);
free(reachTVFs);
vec_free(reachNext);
free(reachNextTVFs);
free(m.tmp);
free(m.counts);
free(m.priorities);
ibqueue_free(m.queue);
if(finalTVF){
TagValueFunction* tmp = finalTVF;
finalTVF = tvf_copyInto(tvf_create(tnfa->tagcount),finalTVF,tnfa->tagcount);
opool_release(m.tvfpool,tmp);
} else {
finalTVF = tvf_create(tnfa->tagcount);
}
if(anchorEnd && *input) {
TagValueFunction* tmp = finalTVF;
finalTVF = tvf_create(tnfa->tagcount);
free(tmp);
}
opool_free(m.tvfpool);
opool_free(m.plistpool);
return finalTVF;
}
void
moto_freeEnv(MotoEnv *env) {
Enumeration *e;
/* Free any outstanding frames */
while(vec_size(env->frames) > 0) {
moto_freeFrame(env);
}
/* Free all the globals */
e = stab_getKeys(env->globals);
while (enum_hasNext(e)) {
char* n = (char*)enum_next(e);
MotoVar* var = stab_get(env->globals,n);
if(env->mode != COMPILER_MODE) {
moto_freeVal(env,var->vs);
} else {
opool_release(env->valpool,var->vs);
}
free(var);
}
enum_free(e);
stab_free(env->globals);
/* free all cached regular expressions */
e = stab_getKeys(env->rxcache);
while (enum_hasNext(e)) {
char *rx = (char *)enum_next(e);
MDFA *mdfa = (MDFA *)stab_get(env->rxcache, rx);
if (mdfa != NULL) {
mdfa_free(mdfa);
}
}
enum_free(e);
/* free all remaining pointers */
e = hset_elements(env->ptrs);
while (enum_hasNext(e)) {
void *ptr = enum_next(e);
if (shared_check(ptr)) {
free(ptr);
}
}
enum_free(e);
/* free all errors */
e = sset_elements(env->errs);
while (enum_hasNext(e)) {
void *ptr = enum_next(e);
if (shared_check(ptr)) {
free(ptr);
}
}
enum_free(e);
/* free all scopes */
e = stack_elements(env->scope);
while (enum_hasNext(e)) {
free(enum_next(e));
}
enum_free(e);
/* free all cells */
moto_freeTreeCells(env);
/* free all class defs */
stab_free(env->cdefs);
/* free remainder of env struct */
hset_free(env->ptrs);
buf_free(env->out);
buf_free(env->err);
stab_free(env->types);
vec_free(env->frames);
ftab_free(env->ftable);
/* Free all the stuff that got put in the mpool ... this includes
MotoFunctions and MotoClassDefinitions */
mpool_free(env->mpool);
stack_free(env->scope);
stab_free(env->rxcache);
//stack_free(env->callstack);
sset_free(env->errs);
sset_free(env->uses);
sset_free(env->includes);
buf_free(env->fcodebuffer);
istack_free(env->scopeIDStack);
htab_free(env->fdefs);
htab_free(env->adefs);
buf_free(env->constantPool);
moto_freeTree(env->tree);
opool_free(env->valpool);
opool_free(env->bufpool);
opool_free(env->stkpool);
e = stab_getKeys(env->fcache);
while (enum_hasNext(e))
free((char *)enum_next(e));
enum_free(e);
stab_free(env->fcache);
free(env);
}
