start implementing command handlers

.gitignore

@@ -199,3 +199,6 @@ src/mod/formats/mod_shout/*/*/mod_shout.log
 /src/mod/languages/mod_managed/x64/Release_CLR/FREESWITCH.MANAGED.DLL.metagen
 /src/mod/languages/mod_managed/x64/Release_CLR/RSAENH.DLL.bi
 /src/mod/languages/mod_managed/x64/Release_CLR/TZRES.DLL.bi
+
+src/include/switch_apr.h
+.gitignore
\ No newline at end of file

libs/freetdm/mod_freetdm/tdm.c

@@ -109,7 +109,7 @@ static switch_call_cause_t channel_outgoing_channel(switch_core_session_t *sessi
     ftdm_codec_t codec;
     uint32_t interval;
     
-    ctdm_private_t *tech_pvt;
+    ctdm_private_t *tech_pvt = NULL;
     
     if (zstr(szchanid) || zstr(szspanid)) {
         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Both "kSPAN_ID" and "kCHAN_ID" have to be set.\n");

src/include/switch_apr.h

@@ -773,7 +773,8 @@ typedef gid_t                     switch_gid_t;
 	 typedef ino_t switch_ino_t;
 	 typedef dev_t switch_dev_t;
 #endif
-	 typedef off64_t switch_off_t;
+
+typedef off_t switch_off_t;
 
 /**
  * Structure for referencing file information

src/mod/endpoints/mod_media_gateway/media_gateway_stack.c

@@ -256,8 +256,7 @@ switch_status_t sng_mgco_start(megaco_profile_t* profile )
 	else {
 		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, " mgco_mg_tsap_enable_cntrl SUCCESS \n");
 	}
-
-	mgco_mg_enble_debug();
+	//mgco_mg_enable_debug();
 
 	return SWITCH_STATUS_SUCCESS;
 }

src/mod/endpoints/mod_media_gateway/media_gateway_xml.c

@@ -243,6 +243,7 @@ static switch_status_t modify_mid(char* mid)
 		sprintf(mid,"[%s]",dup);
 	}else {
 		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Invalid input MID string[%s]\n",mid);
+        free(dup);
 		return SWITCH_STATUS_FALSE;
 	}
 

src/mod/endpoints/mod_media_gateway/mod_media_gateway.c

@@ -130,11 +130,200 @@ void handle_sng_log(uint8_t level, char *fmt, ...)
 	va_end(ptr);
 }
 
+static void mgco_print_sdp(CmSdpInfoSet *sdp)
+{
+    int i;
+    
+//   XXX check if we can use that for debug:
+// cmUnpkCmSdpInfoSet(<#CmSdpInfoSet *param#>, <#Ptr ptr#>, <#CmIntfVer intfVer#>, <#Buffer *mBuf#>);
+        
+    
+    if (sdp->numComp.pres == NOTPRSNT) {
+        return;
+    }
+    
+    for (i = 0; i < sdp->numComp.val; i++) {
+        CmSdpInfo *s = sdp->info[i];
+        int mediaId;
+        
+        if (s->conn.addrType.pres && s->conn.addrType.val == CM_SDP_ADDR_TYPE_IPV4 &&
+            s->conn.netType.type.val == CM_SDP_NET_TYPE_IN &&
+            s->conn.u.ip4.addrType.val == CM_SDP_IPV4_IP_UNI) {
+
+            if (s->conn.u.ip4.addrType.pres) {
+                 switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Address: %d.%d.%d.%d\n",
+                                   s->conn.u.ip4.u.uniIp.b[0].val,
+                                   s->conn.u.ip4.u.uniIp.b[1].val,
+                                   s->conn.u.ip4.u.uniIp.b[2].val,
+                                   s->conn.u.ip4.u.uniIp.b[3].val);
+            }
+            if (s->attrSet.numComp.pres) {
+                for (mediaId = 0; mediaId < s->attrSet.numComp.val; mediaId++) {
+                    CmSdpAttr *a = s->attrSet.attr[mediaId];
+                    
+                }
+            }
+
+            if (s->mediaDescSet.numComp.pres) {
+                for (mediaId = 0; mediaId < s->mediaDescSet.numComp.val; mediaId++) {
+                    CmSdpMediaDesc *desc = s->mediaDescSet.mediaDesc[mediaId];
+                    
+                    if (desc->field.mediaType.val == CM_SDP_MEDIA_AUDIO &&
+                        desc->field.id.type.val ==  CM_SDP_VCID_PORT &&
+                        desc->field.id.u.port.type.val == CM_SDP_PORT_INT &&
+                        desc->field.id.u.port.u.portInt.port.type.val == CM_SDP_SPEC) {
+                        int port = desc->field.id.u.port.u.portInt.port.val.val;
+                        
+                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Port: %d\n", port);
+                        
+                    }
+                    
+                }
+            }
+
+        }
+        
+    }
+}
+
 /*****************************************************************************************************************************/
 
 void handle_mgco_txn_ind(Pst *pst, SuId suId, MgMgcoMsg* msg)
 {
+    size_t txnIter;
+    
 	/*TODO*/
+    if(msg->body.type.val == MGT_TXN)
+    {
+        /* Loop over transaction list */
+        for(txnIter=0;txnIter<msg->body.u.tl.num.val;txnIter++)
+        {
+            switch(msg->body.u.tl.txns[txnIter]->type.val) {
+                case MGT_TXNREQ:
+                {
+                    MgMgcoTxnReq* txnReq; 
+                    MgMgcoTransId transId; /* XXX */
+                    int axnIter;
+                    txnReq = &(msg->body.u.tl.txns[txnIter]->u.req);
+
+                    /* Loop over action list */
+                    for (axnIter=0;axnIter<txnReq->al.num.val;axnIter++) {
+                        MgMgcoActionReq *actnReq;
+                        MgMgcoContextId ctxId;
+                        int cmdIter;
+                        
+                        actnReq = txnReq->al.actns[axnIter];
+                        ctxId = actnReq->cxtId; /* XXX */
+                        
+                        if (actnReq->pres.pres == NOTPRSNT) {
+                            continue;
+                        }
+                        
+                        /* Loop over command list */
+                        for (cmdIter=0; cmdIter < (actnReq->cl.num.val); cmdIter++) {
+                            MgMgcoCommandReq *cmdReq = actnReq->cl.cmds[cmdIter];
+                            MgMgcoTermId *termId = NULLP;
+                            
+                            switch (cmdReq->cmd.type.val) {
+                                case MGT_ADD:
+                                {
+                                    MgMgcoAmmReq *addReq = &cmdReq->cmd.u.add;
+                                    MgMgcoTermId termId = addReq->termId;
+                                    int descId;
+                                    for (descId = 0; descId < addReq->dl.num.val; descId++) {
+                                        switch (addReq->dl.descs[descId]->type.val) {
+                                            case MGT_MEDIADESC:
+                                            {
+                                                int mediaId;
+                                                for (mediaId = 0; mediaId < addReq->dl.descs[descId]->u.media.num.val; mediaId++) {
+                                                    MgMgcoMediaPar *mediaPar = addReq->dl.descs[descId]->u.media.parms[mediaId];
+                                                    switch (mediaPar->type.val) {
+                                                        case MGT_MEDIAPAR_LOCAL:
+                                                        {
+                                                            switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Textual SDP %s\n", mediaPar->u.local.sdpStr.pres ? "present" : "absent");
+                                                            break;
+                                                        }
+                                                        case MGT_MEDIAPAR_REMOTE:
+                                                        {
+                                                            break;
+                                                        }
+                                                        
+                                                        case MGT_MEDIAPAR_LOCCTL:
+                                                        {
+                                                            break;
+                                                        }
+                                                        case MGT_MEDIAPAR_TERMST:
+                                                            break;
+                                                        case MGT_MEDIAPAR_STRPAR:
+                                                        {
+                                                            MgMgcoStreamDesc *mgStream = &mediaPar->u.stream;
+                                                            switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Textual SDP %s\n", mgStream->sl.remote.sdpStr.pres ? "present" : "absent");
+                                                            
+                                                            if (mgStream->sl.remote.pres.pres) {
+                                                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "Got remote stream media description:\n");
+                                                                mgco_print_sdp(&mgStream->sl.remote.sdp);
+                                                            }
+                                                            
+                                                            if (mgStream->sl.local.pres.pres) {
+                                                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "Got local stream media description:\n");
+                                                                mgco_print_sdp(&mgStream->sl.local.sdp);
+                                                            }
+                                                            
+                                                            break;
+                                                        }
+                                                    }
+                                                }
+                                            }
+                                            case MGT_MODEMDESC:
+                                            case MGT_MUXDESC:
+                                            case MGT_REQEVTDESC:
+                                            case MGT_EVBUFDESC:
+                                            case MGT_SIGNALSDESC:
+                                            case MGT_DIGMAPDESC:
+                                            case MGT_AUDITDESC:
+                                            case MGT_STATSDESC:
+                                                break;
+                                        }
+                                    }
+                                    break;
+                                }
+                                case MGT_MODIFY:
+                                {
+                                    MgMgcoAmmReq *addReq = &cmdReq->cmd.u.mod;
+                                    break;
+                                }
+                                case MGT_MOVE:
+                                {
+                                    MgMgcoAmmReq *addReq = &cmdReq->cmd.u.move;
+                                    break;
+                                    
+                                }
+                                case MGT_SUB:
+                                {
+                                    MgMgcoSubAudReq *addReq = &cmdReq->cmd.u.sub;
+                                }
+                                case MGT_SVCCHG:
+                                case MGT_NTFY:
+                                case MGT_AUDITCAP:
+                                case MGT_AUDITVAL:
+                                    break;
+                            }
+                            
+                        }
+                    }
+                    
+                    break;
+                }
+                case MGT_TXNREPLY:
+                {
+                    break;
+                }
+                default:
+                    switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Received unknown command %d in transaction\n", msg->body.u.tl.txns[txnIter]->type.val);
+                    break;
+            }
+        }
+    }
 }
 
 /*****************************************************************************************************************************/