]> git.ipfire.org Git - thirdparty/freeswitch.git/commitdiff
adding echo cancel code based on tdmc package
authorKapil Gupta <kgupta@sangoma.com>
Mon, 10 Sep 2012 22:26:39 +0000 (18:26 -0400)
committerKapil Gupta <kgupta@sangoma.com>
Mon, 10 Sep 2012 22:26:39 +0000 (18:26 -0400)
src/mod/endpoints/mod_media_gateway/media_gateway.c
src/mod/endpoints/mod_media_gateway/media_gateway_cmd_handler.c
src/mod/endpoints/mod_media_gateway/media_gateway_stack.h
src/mod/endpoints/mod_media_gateway/media_gateway_utils.c
src/mod/endpoints/mod_media_gateway/mod_media_gateway.h

index e63c922f65988fe18e277d7594c8bb79c7510a95..98c10a7ca3bd041e081f60af3779c3c6230c6c83 100644 (file)
@@ -493,6 +493,7 @@ switch_status_t megaco_context_is_term_present(mg_context_t *ctx, mg_termination
 
 switch_status_t megaco_context_add_termination(mg_context_t *ctx, mg_termination_t *term)
 {
+       mg_termination_t* tdm_term = NULL;
     switch_status_t status = SWITCH_STATUS_SUCCESS;
 
     switch_assert(ctx != NULL);
@@ -531,7 +532,19 @@ switch_status_t megaco_context_add_termination(mg_context_t *ctx, mg_termination
         
         switch_ivr_uuid_bridge(ctx->terminations[0]->uuid, ctx->terminations[1]->uuid);
 
-         ctx->terminations[0]->profile->mg_stats->total_num_of_call_recvd++;
+               if(MG_TERM_TDM == ctx->terminations[0]->type){
+                       tdm_term = ctx->terminations[0];
+               }else{
+                       tdm_term = ctx->terminations[1];
+               }
+               if(MG_EC_ENABLE == tdm_term->ec_type){
+                               mg_term_set_ec(tdm_term,0x01);
+               }else if(MG_EC_DISABLE == tdm_term->ec_type){
+                               mg_term_set_ec(tdm_term,0x00);
+               }
+               mg_set_term_ec_status(tdm_term, MG_EC_UNDEFINED);
+
+               ctx->terminations[0]->profile->mg_stats->total_num_of_call_recvd++;
     }
 
     return SWITCH_STATUS_SUCCESS;
@@ -893,7 +906,10 @@ void mg_term_set_ec(mg_termination_t *term, int enable)
         switch_core_session_rwunlock(session);
         
         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Sent echo_cancel event to [%s] to [%s]\n", term->uuid, enable ? "enable" : "disable");
-    }
+       }else{
+                       mg_ec_types_t status = ((enable)?MG_EC_ENABLE:MG_EC_DISABLE);
+                       mg_set_term_ec_status(term, status);
+       }
     
     switch_event_destroy(&event);
 }
index 10157c173f3f3a2e9bd94f833773d6f8171c12bc..5a6b4d8936b4721130cd4ba359ee21bbcef395ef 100644 (file)
@@ -248,319 +248,336 @@ switch_status_t mg_prc_sig_desc(MgMgcoSignalsReq* req, megaco_profile_t* mg_prof
 *
 *
 */
-switch_status_t mg_prc_descriptors(megaco_profile_t* mg_profile, MgMgcoCommand *cmd, mg_termination_t* term, CmMemListCp     *memCp)
+switch_status_t mg_prc_descriptors(megaco_profile_t* mg_profile, MgMgcoCommand *cmd, mg_termination_t* term, CmMemListCp  *memCp)
 {
-    CmSdpMedProtoFmts *format;
-    TknU8 *fmt;
-    CmSdpMedFmtRtpList      *fmt_list;
-    MgMgcoTermStateDesc  *tstate;
-    int                  fmtCnt;
-    int                  i;
-    int                  descId = 0x00;
-    int                  j;
-    MgMgcoLocalParm   *lclParm;
-    CmSdpInfo    *sdp;
-    MgMgcoLclCtlDesc  *locCtl;
-    MgMgcoTermStateParm *tsp;
-    MgMgcoAmmReq* desc = NULL;
-    MgMgcoLocalDesc   *local; 
-    MgMgcoRemoteDesc*  remote;
-
-    switch (cmd->cmdType.val)
-    {
-        case CH_CMD_TYPE_IND:
-            switch(cmd->u.mgCmdInd[0]->cmd.type.val)
-            {
-                case MGT_ADD:
-                    {
-                        desc = &cmd->u.mgCmdInd[0]->cmd.u.add;
-                        break;
-                    }
-                case MGT_MOVE:
-                    {
-                        desc = &cmd->u.mgCmdInd[0]->cmd.u.move;
-                        break;
-                    }
-                case MGT_MODIFY:
-                    {
-                        desc = &cmd->u.mgCmdInd[0]->cmd.u.mod;
-                        break;
-                    }
-                default:
-                    switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR,"Invalid cmd.type[%d] for descriptor processing \n",
-                            cmd->u.mgCmdInd[0]->cmd.type.val);
-                    return SWITCH_STATUS_FALSE;
-            }
-            break;
-        default:
-            {
-                return SWITCH_STATUS_FALSE;
-            }
-    }
-
-    if(NULL == desc){
-        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR,"No Valid descriptor found \n");
-        return SWITCH_STATUS_FALSE;
-    }
-
-    //switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR,"descriptors[%d] found in-coming megaco request \n", desc->dl.num.val);
-
-    if(NOTPRSNT == desc->dl.num.pres){
-        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR,"No descriptor found in-coming megaco request \n");
-        return SWITCH_STATUS_SUCCESS;
-    }
-
-
-    for (descId = 0; descId < desc->dl.num.val; descId++) {
-        //switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR,"descriptors[%d] type in-coming megaco request \n", desc->dl.descs[descId]->type.val); 
-        switch (desc->dl.descs[descId]->type.val) {
-            case MGT_MEDIADESC:
-                {
-                    int mediaId;
-                    for (mediaId = 0; mediaId < desc->dl.descs[descId]->u.media.num.val; mediaId++) {
-                        MgMgcoMediaPar *mediaPar = desc->dl.descs[descId]->u.media.parms[mediaId];
-                        switch (mediaPar->type.val) {
-                            case MGT_MEDIAPAR_LOCAL:
-                                {
-                                    switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "MGT_MEDIAPAR_LOCAL");
-                                    /* Matt - check local descriptor processing */
-                                    local = &mediaPar->u.local;
-                                    sdp = local->sdp.info[0];
-                                    for (i = 0; i < sdp->mediaDescSet.numComp.val; i++) {
-                                        /* sdp formats  */
-                                        for (j = 0; j <
-                                                sdp->mediaDescSet.mediaDesc[i]->field.par.numProtFmts.val; j++)
-                                        {
-                                            format = sdp->mediaDescSet.mediaDesc[i]->field.par.pflst[j];
-                                            /* Matt - format has field for T38 also  */
-                                            if ((format->protType.pres != NOTPRSNT) &&
-                                                    (format->protType.val == CM_SDP_MEDIA_PROTO_RTP)) {
-
-                                                /* protocol type RTP */
-                                                fmt_list = &format->u.rtp;
-
-                                                /* print format */
-                                                for(fmtCnt = 0; fmtCnt <  fmt_list->num.val; fmtCnt++){
-                                                    fmt = &fmt_list->fmts[i]->val;
-                                                    if(fmt->pres == NOTPRSNT) continue;
-                                                   switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE,"Format [%d]\n", fmt->val);
-                                                }
-                                            }
-                                        }
-                                    }
-
-                                   mgco_handle_incoming_sdp(&local->sdp, term, MG_SDP_LOCAL, mg_profile, memCp);
-
-                                    break;
-                                }
-
-                            case MGT_MEDIAPAR_REMOTE:
-                                {
-                                    switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "MGT_MEDIAPAR_REMOTE");
-                                    /* Matt - check remote descriptor processing */
-                                    remote = &mediaPar->u.remote;
-                                    sdp = remote->sdp.info[0];
-                                    /* for Matt - same like local descriptor */
-                                    mgco_handle_incoming_sdp(&remote->sdp, term, MG_SDP_REMOTE, mg_profile, memCp);
-                                    break;
-                                }
-
-                            case MGT_MEDIAPAR_LOCCTL:
-                                {
-                                    /* Matt - check Local Control descriptor processing */
-                                    locCtl = &mediaPar->u.locCtl;
-                                    for (i = 0; i < locCtl->num.val; i++){
-                                        lclParm = locCtl->parms[i];
-                                        if (PRSNT_NODEF == lclParm->type.pres){
-                                            switch(lclParm->type.val)
-                                            {
-                                                case MGT_LCLCTL_MODE:
-                                                    {
-                                                        /* Mode Property */
-                                                       //switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE,"MGT_LCLCTL_MODE - Mode value [%d]\n", lclParm->u.mode.val);
-                                                        break;
-                                                    }
-                                                case MGT_LCLCTL_RESVAL:
-                                                    {
-                                                        /* Reserve Value */
-                                                       //switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE,"MGT_LCLCTL_RESVAL: Reserve Value[%d] \n", lclParm->u.resVal.val);
-                                                        break;
-                                                    }
-                                                case MGT_LCLCTL_RESGRP:
-                                                    {
-                                                        /* Reserve group */
-                                                       //switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE,"MGT_LCLCTL_RESGRP: Reserve Group[%d]\n", lclParm->u.resGrp.val);
-                                                        break;
-                                                    }
-                                                case MGT_LCLCTL_PROPPARM:
-                                                    {
-                                                        /* Properties (of a termination) */
-                                                        /* Matt - See how we can apply this to a termination */
-                                                       //switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE,"MGT_LCLCTL_PROPPARM: \n");
-                                                        break;
-                                                    }
-                                                default:
-                                                   switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE,"Invalid local control descriptor type[%d]\n",lclParm->type.val);
-                                                    break;
-                                            }
-                                        }
-                                    }
-
-                                    switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "MGT_MEDIAPAR_LOCCTL");
-                                    break;
-                                }
-                            case MGT_MEDIAPAR_TERMST:
-                                {
-                                    /* Matt - apply termination state descriptor */
-                                    switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "MGT_MEDIAPAR_TERMST");
-                                    tstate = &mediaPar->u.tstate;      
-                                    for (i = 0; i < tstate->numComp.val; i++)
-                                    {
-                                        /* Matt to see how to apply below descriptors to a termination */
-                                        tsp = tstate->trmStPar[i];
-                                        if (PRSNT_NODEF == tsp->type.pres) {
-                                            switch(tsp->type.val)
-                                            {
-                                                case MGT_TERMST_PROPLST:
-                                                    {
-                                                        /* Matt to see how to apply properties to a termination */
-                                                        /* Properties of a termination */
-                                                       switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE,"MGT_TERMST_PROPLST:\n");
-                                                        break;
-                                                    }
-                                                case MGT_TERMST_EVTBUFCTL:
-                                                    {
-                                                        /* Event /buffer Control Properties */
-                                                       switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE," MGT_TERMST_EVTBUFCTL: value[%d]\n", tsp->u.evtBufCtl.val);
-                                                        break;
-                                                    }
-                                                case MGT_TERMST_SVCST:
-                                                    {
-                                                        /* Service State Properties */
-                                                       switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE," MGT_TERMST_SVCST: value[%d]\n", tsp->u.svcState.val);
-                                                        break;
-                                                    }
-                                                default:
-                                                   switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE,"Invalid termination state descriptor type[%d]\n",tsp->type.val);
-                                                    break;
-                                            }
-                                        }
-                                    }
-                                    break;
-                                }
-                            case MGT_MEDIAPAR_STRPAR:
-                                {
-                                    MgMgcoStreamDesc *mgStream = &mediaPar->u.stream;
-
-                                    if (mgStream->sl.remote.pres.pres) {
-                                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "Got remote stream media description:\n");
-                                        mgco_handle_incoming_sdp(&mgStream->sl.remote.sdp, term, MG_SDP_LOCAL, mg_profile, memCp);
-                                    }
-
-                                    if (mgStream->sl.local.pres.pres) {
-                                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "Got local stream media description:\n");
-                                        mgco_handle_incoming_sdp(&mgStream->sl.local.sdp, term, MG_SDP_REMOTE, mg_profile, memCp);
-                                    }
-
-                                    break;
-                                }
-                        }
-                    }
-                    break;
-                }
-            case MGT_REQEVTDESC:
-                {
-                    MgMgcoReqEvtDesc* evt = &desc->dl.descs[descId]->u.evts; 
-
-                    switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG," Requested Event descriptor\n");
-            
-                    /* If we receive events from MGC , means clear any ongoing events */
-                    /* as such we dont apply any events to term, so for us (as of now) clear events means clear active_events structure*/
+       CmSdpMedProtoFmts *format;
+       TknU8 *fmt;
+       CmSdpMedFmtRtpList      *fmt_list;
+       MgMgcoTermStateDesc  *tstate;
+       int               fmtCnt;
+       int               i;
+       int               descId = 0x00;
+       int               j;
+       MgMgcoLocalParm   *lclParm;
+       CmSdpInfo         *sdp;
+       MgMgcoLclCtlDesc  *locCtl;
+       MgMgcoTermStateParm *tsp;
+       MgMgcoAmmReq* desc = NULL;
+       MgMgcoLocalDesc   *local; 
+       MgMgcoRemoteDesc*  remote;
+
+       switch (cmd->cmdType.val)
+       {
+               case CH_CMD_TYPE_IND:
+                       switch(cmd->u.mgCmdInd[0]->cmd.type.val)
+                       {
+                               case MGT_ADD:
+                                       {
+                                               desc = &cmd->u.mgCmdInd[0]->cmd.u.add;
+                                               break;
+                                       }
+                               case MGT_MOVE:
+                                       {
+                                               desc = &cmd->u.mgCmdInd[0]->cmd.u.move;
+                                               break;
+                                       }
+                               case MGT_MODIFY:
+                                       {
+                                               desc = &cmd->u.mgCmdInd[0]->cmd.u.mod;
+                                               break;
+                                       }
+                               default:
+                                       switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR,"Invalid cmd.type[%d] for descriptor processing \n",
+                                                       cmd->u.mgCmdInd[0]->cmd.type.val);
+                                       return SWITCH_STATUS_FALSE;
+                       }
+                       break;
+               default:
+                       {
+                               return SWITCH_STATUS_FALSE;
+                       }
+       }
 
-                    if(NULL != term->active_events){
-                       mgUtlDelMgMgcoReqEvtDesc(term->active_events);
-                       MG_STACK_MEM_FREE(term->active_events, sizeof(MgMgcoReqEvtDesc));
-                    }
+       if(NULL == desc){
+               switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR,"No Valid descriptor found \n");
+               return SWITCH_STATUS_FALSE;
+       }
 
-                   MG_STACK_MEM_ALLOC(&term->active_events, sizeof(MgMgcoReqEvtDesc));
+       //switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR,"descriptors[%d] found in-coming megaco request \n", desc->dl.num.val);
 
-                   if(NULL == term->active_events){
-                           switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR," term->active_events Memory Alloc failed \n");
-                           return SWITCH_STATUS_FALSE;
-                   }
+       if(NOTPRSNT == desc->dl.num.pres){
+               switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR,"No descriptor found in-coming megaco request \n");
+               return SWITCH_STATUS_SUCCESS;
+       }
 
-                    /* copy requested event */
-                    if(RFAILED == mgUtlCpyMgMgcoReqEvtDesc(term->active_events, evt, NULLP)){
-                       switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR," copy new events to term->active_events failed \n");
-                       MG_STACK_MEM_FREE(term->active_events, sizeof(MgMgcoReqEvtDesc));
-                        return SWITCH_STATUS_FALSE;
-                    }
 
-                    /* print Requested event descriptor */
-                    /*mgAccEvntPrntMgMgcoReqEvtDesc(term->active_events, stdout);*/
-                    
-                    break;
-                }
-            case MGT_SIGNALSDESC:
-                {
-                    MgMgcoSignalsDesc* sig = &desc->dl.descs[descId]->u.sig; 
-                    MgMgcoSignalsParm* param = NULL;
-                    int i = 0x00;
-                    switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG," Requested Signal descriptor\n");
+       for (descId = 0; descId < desc->dl.num.val; descId++) {
+               //switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR,"descriptors[%d] type in-coming megaco request \n", desc->dl.descs[descId]->type.val); 
+               switch (desc->dl.descs[descId]->type.val) {
+                       case MGT_MEDIADESC:
+                               {
+                                       int mediaId;
+                                       for (mediaId = 0; mediaId < desc->dl.descs[descId]->u.media.num.val; mediaId++) {
+                                               MgMgcoMediaPar *mediaPar = desc->dl.descs[descId]->u.media.parms[mediaId];
+                                               switch (mediaPar->type.val) {
+                                                       case MGT_MEDIAPAR_LOCAL:
+                                                               {
+                                                                       switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "MGT_MEDIAPAR_LOCAL\n");
+                                                                       /* Matt - check local descriptor processing */
+                                                                       local = &mediaPar->u.local;
+                                                                       sdp = local->sdp.info[0];
+                                                                       for (i = 0; i < sdp->mediaDescSet.numComp.val; i++) {
+                                                                               /* sdp formats  */
+                                                                               for (j = 0; j <
+                                                                                               sdp->mediaDescSet.mediaDesc[i]->field.par.numProtFmts.val; j++)
+                                                                               {
+                                                                                       format = sdp->mediaDescSet.mediaDesc[i]->field.par.pflst[j];
+                                                                                       /* Matt - format has field for T38 also  */
+                                                                                       if ((format->protType.pres != NOTPRSNT) &&
+                                                                                                       (format->protType.val == CM_SDP_MEDIA_PROTO_RTP)) {
+
+                                                                                               /* protocol type RTP */
+                                                                                               fmt_list = &format->u.rtp;
+
+                                                                                               /* print format */
+                                                                                               for(fmtCnt = 0; fmtCnt <  fmt_list->num.val; fmtCnt++){
+                                                                                                       fmt = &fmt_list->fmts[i]->val;
+                                                                                                       if(fmt->pres == NOTPRSNT) continue;
+                                                                                                       switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE,"Format [%d]\n", fmt->val);
+                                                                                               }
+                                                                                       }
+                                                                               }
+                                                                       }
+
+                                                                       mgco_handle_incoming_sdp(&local->sdp, term, MG_SDP_LOCAL, mg_profile, memCp);
+
+                                                                       break;
+                                                               }
+
+                                                       case MGT_MEDIAPAR_REMOTE:
+                                                               {
+                                                                       switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "MGT_MEDIAPAR_REMOTE\n");
+                                                                       /* Matt - check remote descriptor processing */
+                                                                       remote = &mediaPar->u.remote;
+                                                                       sdp = remote->sdp.info[0];
+                                                                       /* for Matt - same like local descriptor */
+                                                                       mgco_handle_incoming_sdp(&remote->sdp, term, MG_SDP_REMOTE, mg_profile, memCp);
+                                                                       break;
+                                                               }
+
+                                                       case MGT_MEDIAPAR_LOCCTL:
+                                                               {
+                                                                       /* Matt - check Local Control descriptor processing */
+                                                                       locCtl = &mediaPar->u.locCtl;
+                                                                       for (i = 0; i < locCtl->num.val; i++){
+                                                                               lclParm = locCtl->parms[i];
+                                                                               if (PRSNT_NODEF == lclParm->type.pres){
+                                                                                       switch(lclParm->type.val)
+                                                                                       {
+                                                                                               case MGT_LCLCTL_MODE:
+                                                                                                       {
+                                                                                                               /* Mode Property */
+                                                                                                               //switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE,"MGT_LCLCTL_MODE - Mode value [%d]\n", lclParm->u.mode.val);
+                                                                                                               break;
+                                                                                                       }
+                                                                                               case MGT_LCLCTL_RESVAL:
+                                                                                                       {
+                                                                                                               /* Reserve Value */
+                                                                                                               //switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE,"MGT_LCLCTL_RESVAL: Reserve Value[%d] \n", lclParm->u.resVal.val);
+                                                                                                               break;
+                                                                                                       }
+                                                                                               case MGT_LCLCTL_RESGRP:
+                                                                                                       {
+                                                                                                               /* Reserve group */
+                                                                                                               //switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE,"MGT_LCLCTL_RESGRP: Reserve Group[%d]\n", lclParm->u.resGrp.val);
+                                                                                                               break;
+                                                                                                       }
+                                                                                               case MGT_LCLCTL_PROPPARM:
+                                                                                                       {
+                                                                                                               MgMgcoPropParm* p = &lclParm->u.propParm;
+                                                                                                               /* Properties (of a termination) */
+                                                                                                               switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE,"MGT_LCLCTL_PROPPARM: \n");
+
+                                                                                                               if((MGT_PKG_KNOWN == p->pkg.valType.val) &&
+                                                                                                                               (MGT_PKG_TDM_CKT == p->pkg.u.val.val) && 
+                                                                                                                               (MGT_GEN_TYPE_KNOWN == p->name.type.val) && 
+                                                                                                                               (MGT_PKG_TDMC_PROP_EC == p->name.u.val.val) && 
+                                                                                                                               (PRSNT_NODEF == p->val.type.pres) && 
+                                                                                                                               (MGT_VALUE_EQUAL == p->val.type.val) &&
+                                                                                                                               (NOTPRSNT != p->val.u.eq.type.pres) && 
+                                                                                                                               (MGT_VALTYPE_ENUM == p->val.u.eq.type.val)) {
+                                                                                                                       if(MGT_PKG_ENUM_PROPPARMTDMCEC_ON == p->val.u.eq.u.enume.val){
+                                                                                                                               switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE,"TDMC EC=ON\n");
+                                                                                                                               mg_term_set_ec(term,0x01);
+                                                                                                                       }else if(MGT_PKG_ENUM_PROPPARMTDMCEC_OFF == p->val.u.eq.u.enume.val){ 
+                                                                                                                               switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE,"TDMC EC=OFF\n");
+                                                                                                                               mg_term_set_ec(term,0x00);
+                                                                                                                       }
+                                                                                                               }
+                                                                                                               break;
+                                                                                                       }
+                                                                                               default:
+                                                                                                       switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE,"Invalid local control descriptor type[%d]\n",lclParm->type.val);
+                                                                                                       break;
+                                                                                       }
+                                                                               }
+                                                                       }
+
+                                                                       //switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "MGT_MEDIAPAR_LOCCTL\n");
+                                                                       break;
+                                                               }
+                                                       case MGT_MEDIAPAR_TERMST:
+                                                               {
+                                                                       /* Matt - apply termination state descriptor */
+                                                                       switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "MGT_MEDIAPAR_TERMST");
+                                                                       tstate = &mediaPar->u.tstate;   
+                                                                       for (i = 0; i < tstate->numComp.val; i++)
+                                                                       {
+                                                                               /* Matt to see how to apply below descriptors to a termination */
+                                                                               tsp = tstate->trmStPar[i];
+                                                                               if (PRSNT_NODEF == tsp->type.pres) {
+                                                                                       switch(tsp->type.val)
+                                                                                       {
+                                                                                               case MGT_TERMST_PROPLST:
+                                                                                                       {
+                                                                                                               /* Matt to see how to apply properties to a termination */
+                                                                                                               /* Properties of a termination */
+                                                                                                               switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE,"MGT_TERMST_PROPLST:\n");
+                                                                                                               break;
+                                                                                                       }
+                                                                                               case MGT_TERMST_EVTBUFCTL:
+                                                                                                       {
+                                                                                                               /* Event /buffer Control Properties */
+                                                                                                               switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE," MGT_TERMST_EVTBUFCTL: value[%d]\n", tsp->u.evtBufCtl.val);
+                                                                                                               break;
+                                                                                                       }
+                                                                                               case MGT_TERMST_SVCST:
+                                                                                                       {
+                                                                                                               /* Service State Properties */
+                                                                                                               switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE," MGT_TERMST_SVCST: value[%d]\n", tsp->u.svcState.val);
+                                                                                                               break;
+                                                                                                       }
+                                                                                               default:
+                                                                                                       switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE,"Invalid termination state descriptor type[%d]\n",tsp->type.val);
+                                                                                                       break;
+                                                                                       }
+                                                                               }
+                                                                       }
+                                                                       break;
+                                                               }
+                                                       case MGT_MEDIAPAR_STRPAR:
+                                                               {
+                                                                       MgMgcoStreamDesc *mgStream = &mediaPar->u.stream;
+
+                                                                       if (mgStream->sl.remote.pres.pres) {
+                                                                               switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "Got remote stream media description:\n");
+                                                                               mgco_handle_incoming_sdp(&mgStream->sl.remote.sdp, term, MG_SDP_LOCAL, mg_profile, memCp);
+                                                                       }
+
+                                                                       if (mgStream->sl.local.pres.pres) {
+                                                                               switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "Got local stream media description:\n");
+                                                                               mgco_handle_incoming_sdp(&mgStream->sl.local.sdp, term, MG_SDP_REMOTE, mg_profile, memCp);
+                                                                       }
+
+                                                                       break;
+                                                               }
+                                               }
+                                       }
+                                       break;
+                               }
+                       case MGT_REQEVTDESC:
+                               {
+                                       MgMgcoReqEvtDesc* evt = &desc->dl.descs[descId]->u.evts; 
 
-                    if((NOTPRSNT != sig->pres.pres) && (NOTPRSNT != sig->num.pres) && (0 != sig->num.val)){
+                                       switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG," Requested Event descriptor\n");
 
-                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO," Total number of Signal descriptors[%d]\n", sig->num.val);
+                                       /* If we receive events from MGC , means clear any ongoing events */
+                                       /* as such we dont apply any events to term, so for us (as of now) clear events means clear active_events structure*/
 
-                        for(i=0; i< sig->num.val; i++){
-                                param = sig->parms[i];
+                                       if(NULL != term->active_events){
+                                               mgUtlDelMgMgcoReqEvtDesc(term->active_events);
+                                               MG_STACK_MEM_FREE(term->active_events, sizeof(MgMgcoReqEvtDesc));
+                                       }
 
-                                if(NOTPRSNT == param->type.pres) continue;
+                                       MG_STACK_MEM_ALLOC(&term->active_events, sizeof(MgMgcoReqEvtDesc));
 
-                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO," Signal Descriptor[%d] type[%s]\n",
-                                        i, ((MGT_SIGSPAR_LST == param->type.val)?"MGT_SIGSPAR_LST":"MGT_SIGSPAR_REQ"));
-                                
-                                switch(param->type.val)
-                                {
-                                    case MGT_SIGSPAR_LST:
-                                        {
-                                            MgMgcoSignalsLst* lst = &param->u.lst;
-                                            int sigId = 0x00;
+                                       if(NULL == term->active_events){
+                                               switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR," term->active_events Memory Alloc failed \n");
+                                               return SWITCH_STATUS_FALSE;
+                                       }
 
-                                            if((NOTPRSNT == lst->pl.num.pres) || (0 == lst->pl.num.val)) break;
+                                       /* copy requested event */
+                                       if(RFAILED == mgUtlCpyMgMgcoReqEvtDesc(term->active_events, evt, NULLP)){
+                                               switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR," copy new events to term->active_events failed \n");
+                                               MG_STACK_MEM_FREE(term->active_events, sizeof(MgMgcoReqEvtDesc));
+                                               return SWITCH_STATUS_FALSE;
+                                       }
 
-                                            for(sigId = 0; sigId < lst->pl.num.val; sigId++){
-                                                mg_prc_sig_desc(lst->pl.reqs[sigId], mg_profile, term);
-                                            }
+                                       /* print Requested event descriptor */
+                                       /*mgAccEvntPrntMgMgcoReqEvtDesc(term->active_events, stdout);*/
 
-                                            break;
-                                        }
-                                    case MGT_SIGSPAR_REQ:
-                                        {
-                                            MgMgcoSignalsReq* req = &param->u.req;
-                                            mg_prc_sig_desc(req, mg_profile, term);
-                                            break;
-                                        }
-                                    default:
-                                        break;
-                                }
-                        }
-                    }
+                                       break;
+                               }
+                       case MGT_SIGNALSDESC:
+                               {
+                                       MgMgcoSignalsDesc* sig = &desc->dl.descs[descId]->u.sig; 
+                                       MgMgcoSignalsParm* param = NULL;
+                                       int i = 0x00;
+                                       switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG," Requested Signal descriptor\n");
+
+                                       if((NOTPRSNT != sig->pres.pres) && (NOTPRSNT != sig->num.pres) && (0 != sig->num.val)){
+
+                                               switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO," Total number of Signal descriptors[%d]\n", sig->num.val);
+
+                                               for(i=0; i< sig->num.val; i++){
+                                                       param = sig->parms[i];
+
+                                                       if(NOTPRSNT == param->type.pres) continue;
+
+                                                       switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO," Signal Descriptor[%d] type[%s]\n",
+                                                                       i, ((MGT_SIGSPAR_LST == param->type.val)?"MGT_SIGSPAR_LST":"MGT_SIGSPAR_REQ"));
+
+                                                       switch(param->type.val)
+                                                       {
+                                                               case MGT_SIGSPAR_LST:
+                                                                       {
+                                                                               MgMgcoSignalsLst* lst = &param->u.lst;
+                                                                               int sigId = 0x00;
+
+                                                                               if((NOTPRSNT == lst->pl.num.pres) || (0 == lst->pl.num.val)) break;
+
+                                                                               for(sigId = 0; sigId < lst->pl.num.val; sigId++){
+                                                                                       mg_prc_sig_desc(lst->pl.reqs[sigId], mg_profile, term);
+                                                                               }
+
+                                                                               break;
+                                                                       }
+                                                               case MGT_SIGSPAR_REQ:
+                                                                       {
+                                                                               MgMgcoSignalsReq* req = &param->u.req;
+                                                                               mg_prc_sig_desc(req, mg_profile, term);
+                                                                               break;
+                                                                       }
+                                                               default:
+                                                                       break;
+                                                       }
+                                               }
+                                       }
 
-                    break;
-                }
-            case MGT_MODEMDESC:
-            case MGT_MUXDESC:
-            case MGT_EVBUFDESC:
-            case MGT_DIGMAPDESC:
-            case MGT_AUDITDESC:
-            case MGT_STATSDESC:
-                break;
+                                       break;
+                               }
+                       case MGT_MODEMDESC:
+                       case MGT_MUXDESC:
+                       case MGT_EVBUFDESC:
+                       case MGT_DIGMAPDESC:
+                       case MGT_AUDITDESC:
+                       case MGT_STATSDESC:
+                               break;
 
-        }
-    }
+               }
+       }
 
-    return SWITCH_STATUS_SUCCESS;
+       return SWITCH_STATUS_SUCCESS;
 }
 
 
@@ -744,6 +761,7 @@ switch_status_t handle_mg_add_cmd(megaco_profile_t* mg_profile, MgMgcoCommand *i
        mg_apply_tdm_dtmf_removal(term, mg_ctxt);
 
        mg_apply_tdm_ec(term, mg_ctxt);
+
        mg_print_t38_attributes(term);
 
 
@@ -1063,9 +1081,8 @@ switch_status_t handle_mg_modify_cmd(megaco_profile_t* mg_profile, MgMgcoCommand
                mg_apply_tdm_dtmf_removal(term, mg_ctxt);
 
                mg_apply_tdm_ec(term, mg_ctxt);
-               mg_print_t38_attributes(term);
-
 
+               mg_print_t38_attributes(term);
 
                /* SDP updated to termination */
                if(SWITCH_STATUS_SUCCESS != megaco_activate_termination(term)) {
index e599ce70c43939805357e1993a77f4cc0f040c23..b2e9a913402ca817348c3e927041cf431304f8ac 100644 (file)
@@ -167,7 +167,9 @@ typedef enum {
    (_reqId)->id.val = 0xFFFFFFFF;
 
 
-switch_status_t mg_prc_descriptors(megaco_profile_t* mg_profile, MgMgcoCommand *inc_cmd, mg_termination_t* term, CmMemListCp     *memCp);
+
+void mg_set_term_ec_status(mg_termination_t* term, mg_ec_types_t status);
+switch_status_t mg_prc_descriptors(megaco_profile_t* mg_profile, MgMgcoCommand *inc_cmd, mg_termination_t* term, CmMemListCp  *memCp);
 void handle_sng_log(uint8_t level, char *fmt, ...);
 void handle_mgco_sta_ind(Pst *pst, SuId suId, MgMgtSta* msg);
 void handle_mgco_txn_sta_ind(Pst *pst, SuId suId, MgMgcoInd* msg);
index 1fd2a9cdad70e010665f914dc28af9bb1b162dc3..02f568a78d45c9c1eb45548d1a0975a7db0c2421 100644 (file)
@@ -2397,3 +2397,11 @@ void mg_apply_tdm_ec(mg_termination_t* term, mg_context_t *mg_ctxt)
        }
 }
 /*****************************************************************************************************************************/
+void mg_set_term_ec_status(mg_termination_t* term, mg_ec_types_t status)
+{
+       if(NULL != term) {
+               term->ec_type = status;
+               switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO,"Setting Term EC[%s]\n",mg_ec_types_tostr(term->ec_type));        
+       }
+}
+/*****************************************************************************************************************************/
index 004c5153b7fe119a0450d6c6e6b7539e46ea008c..1c09fdc517d16e0d9040d7a350e5fa54f6d27e35 100644 (file)
@@ -132,6 +132,29 @@ typedef enum {
     MG_T38_FAX_NOTIFY_INVALID,
 } mg_t38_fax_notify_t;
 
+typedef enum {
+    MG_EC_UNDEFINED = 0,
+    MG_EC_ENABLE,
+    MG_EC_DISABLE,
+    MG_EC_INVALID
+} mg_ec_types_t;
+
+static inline const char *mg_ec_types_tostr(mg_ec_types_t type) {
+    switch (type) {
+        case MG_EC_UNDEFINED:
+            return "UNDEFINED";
+        case MG_EC_ENABLE:
+            return "ENABLE";
+        case MG_EC_DISABLE:
+            return "DISABLE";
+        case MG_EC_INVALID:
+            return "INVALID";
+        default:
+            return "Invalid";
+    }
+    return NULL;
+}
+
 
 typedef enum {
     MGM_AUDIO = 0,
@@ -205,6 +228,7 @@ struct mg_termination_s {
     int  *mg_error_code; /* MEGACO error code */
     uint32_t flags;
     const char *tech; /* Endpoint controlling the TDM interface - only FreeTDM tested so far */
+       mg_ec_types_t ec_type;
     
     union {
         struct {