// -------------------------------------------------------
void DispEventInfo ( Acs_Evt_t *pAcsEvt )
{
char TmpStr[512] = {0};
char TmpS[256] = {0};
char SendTiffFileName[ACS_MAX_FILE_NAME_LEN];
char RecvTiffFileName[ACS_MAX_FILE_NAME_LEN];
char dtmf='?';
Acs_Dev_List_Head_t * pAcsDevList = NULL;
Acs_UniFailure_Data * pAcsUniFailure = NULL;
Acs_GeneralProc_Data *pGeneralData = NULL;
Acs_CallControl_Data *pCallControl = NULL;
Acs_IO_Data *pIOData = NULL;
Acs_CAS_ExtraInfo_t *pCAS_ExtraInfo = NULL;
Acs_AnalogInterface_Data* pAnalogInterface=NULL;
Acs_CSPDataReq_Data* pCspReqData=NULL;
Acs_ParamProc_Data* pSetParam=NULL;
Acs_ParamProc_Data* pGetParam=NULL;
Acs_MediaProc_Data* pMedia=NULL;
Acs_ParamData_UserReadXmsBoardInfo* pBoardInfor=NULL;
sprintf ( TmpStr, "" );
strcat ( TmpStr, GetString_EventType ( pAcsEvt->m_s32EventType ) );
Acs_MediaProc_Data * pMediaData = (Acs_MediaProc_Data *)FetchEventData(pAcsEvt);
switch ( pAcsEvt->m_s32EventType )
{
case XMS_EVT_GETPARAM:
{
pGetParam = (Acs_ParamProc_Data*)FetchEventData(pAcsEvt);
pBoardInfor = (Acs_ParamData_UserReadXmsBoardInfo*)((char*)pGetParam+sizeof(Acs_ParamProc_Data));
}
break;
case XMS_EVT_DEV_TIMER:
{
char ioFskBuf[512];
int iFskLen;
char MsgStr[512];
memset(ioFskBuf,0,sizeof(ioFskBuf));
pdlg->GetDlgItemText(IDC_EDIT_CALLINGNUM,MsgStr,sizeof(MsgStr));
EncodeFskCaller(MsgStr,ioFskBuf,&iFskLen);
int r = XMS_ctsSendIOData ( g_acsHandle, &pAcsEvt->m_DeviceID,
XMS_IO_TYPE_FSK, (DJ_U16)iFskLen, (DJ_Void *) ioFskBuf );
if ( r < 0 )
{
sprintf ( MsgStr, "X(%d) XMS_ctsSendIOData( %s, %d, [%s] ) FAIL! (%s)",
r, "GTG ", g_iLen, TmpStr,
GetString_DeviceAll (&pAcsEvt->m_DeviceID) );
AddMsg ( MSG_TYPE_FUNCTION, MsgStr );
}
else
{
sprintf ( MsgStr, "XMS_ctsSendIOData( %s, %d, [%s] ) OK! (%s)",
"GTG ", g_iLen, TmpStr,
GetString_DeviceAll (&pAcsEvt->m_DeviceID) );
AddMsg ( MSG_TYPE_FUNCTION, MsgStr );
}
}
break;
case XMS_EVT_BUILDINDEX:
pMedia=(Acs_MediaProc_Data*)FetchEventData(pAcsEvt);
sprintf(TmpS," EvtState=%d taskID=%d fileIndex=%u,%x",pMedia->m_s32AcsEvtState,pMedia->m_u8TaskID,pMedia->m_u32CurFileIndex,pMedia->m_u32CurFileIndex);
strcat(TmpStr,TmpS);
break;
case XMS_EVT_PLAY:
pMedia=(Acs_MediaProc_Data*)FetchEventData(pAcsEvt);
sprintf(TmpS," EvtState=%d Errcode=%d taskID=%d fileIndex=%d",pMedia->m_s32AcsEvtState,pMedia->m_s32AcsEvtErrCode,pMedia->m_u8TaskID,pMedia->m_u32CurFileIndex);
strcat(TmpStr,TmpS);
break;
case XMS_EVT_SETPARAM:
pSetParam = (Acs_ParamProc_Data*)FetchEventData(pAcsEvt);
sprintf(TmpS," CmdType=[%d]",pSetParam->m_u16ParamCmdType);
strcat(TmpStr,TmpS);
break;
case XMS_EVT_UNLINKDEVICE:
pGeneralData = (Acs_GeneralProc_Data*) FetchEventData(pAcsEvt);
break;
case XMS_EVT_PLAYCSPREQ:
//
pCspReqData = (Acs_CSPDataReq_Data*)FetchEventData(pAcsEvt);
sprintf(TmpS,"CSPPLAYREQ datalen =%d",pCspReqData->m_u16ReqCspDataLen);
strcat(TmpStr,TmpS);
break;
case XMS_EVT_ANALOG_INTERFACE:
pAnalogInterface = (Acs_AnalogInterface_Data*)FetchEventData(pAcsEvt);
sprintf(TmpS,"(%d,%s)",pAnalogInterface->m_u8AnalogInterfaceState,GetString_AnalogInterfaceState(pAcsEvt->m_DeviceID.m_s16DeviceSub,pAnalogInterface->m_u8AnalogInterfaceState));
strcat(TmpStr,TmpS);
break;
case XMS_EVT_SENDIODATA:
sprintf ( TmpS, " (%s,%s,MachineID:%2d,ModuleID:%3d,Ch:%d)",
GetString_DeviceMain(pAcsEvt->m_DeviceID.m_s16DeviceMain),
GetString_DeviceSub(pAcsEvt->m_DeviceID.m_s16DeviceMain,pAcsEvt->m_DeviceID.m_s16DeviceSub),
pAcsEvt->m_DeviceID.m_s8MachineID,
pAcsEvt->m_DeviceID.m_s8ModuleID,
pAcsEvt->m_DeviceID.m_s16ChannelID );
/*strcat ( TmpStr, TmpS );
{
CmdParamData_AnalogTrunk_t cmdAnalogTrunk;
void*p =(void*)&cmdAnalogTrunk; ;
XMS_ctsSetParam(g_acsHandle,&pAcsEvt->m_DeviceID,ANALOGTRUNK_PARAM_UNBINDVOC,sizeof(CmdParamData_AnalogTrunk_t),p);
////
}*/
strcat(TmpStr,TmpS);
break;
case XMS_EVT_LINKDEVICE:
case XMS_EVT_CLEARCALL:
sprintf ( TmpS, " (%s,%s,MachineID:%2d,ModuleID:%3d,Ch:%d)",
GetString_DeviceMain(pAcsEvt->m_DeviceID.m_s16DeviceMain),
GetString_DeviceSub(pAcsEvt->m_DeviceID.m_s16DeviceMain,pAcsEvt->m_DeviceID.m_s16DeviceSub),
pAcsEvt->m_DeviceID.m_s8MachineID,
pAcsEvt->m_DeviceID.m_s8ModuleID,
pAcsEvt->m_DeviceID.m_s16ChannelID );
strcat ( TmpStr, TmpS );
break;
case XMS_EVT_OPEN_STREAM:
break;
case XMS_EVT_QUERY_DEVICE:
pAcsDevList = (Acs_Dev_List_Head_t *)FetchEventData(pAcsEvt);
sprintf ( TmpS, " (%s,%2d,%3d)",
GetString_DeviceMain(pAcsDevList->m_s32DeviceMain),
pAcsDevList->m_s32ModuleID,
pAcsDevList->m_s32DeviceNum );
strcat ( TmpStr, TmpS );
break;
case XMS_EVT_QUERY_ONE_DSP_START:
case XMS_EVT_QUERY_ONE_DSP_END:
sprintf ( TmpS, " (%d)", pAcsEvt->m_DeviceID.m_s8ModuleID );
strcat ( TmpStr, TmpS );
break;
case XMS_EVT_OPEN_DEVICE:
{
pGeneralData = (Acs_GeneralProc_Data*)FetchEventData(pAcsEvt);
int isize = sizeof(Acs_GeneralProc_Evt);
isize = sizeof(Acs_GeneralProc_Data);
sprintf ( TmpS, "(%s) CallID(%d,%d)", GetString_DeviceAll(&pAcsEvt->m_DeviceID),
pAcsEvt->m_DeviceID.m_CallID.m_s32FlowType, pAcsEvt->m_DeviceID.m_CallID.m_s32FlowChannel );
strcat ( TmpStr, TmpS );
}
break;
case XMS_EVT_DEVICESTATE:
pGeneralData = (Acs_GeneralProc_Data *)FetchEventData(pAcsEvt);
sprintf ( TmpS, "(%s) S=0x%X(%s)", GetString_DeviceAll(&pAcsEvt->m_DeviceID),
pGeneralData->m_s32DeviceState, GetString_DeviceState(pGeneralData->m_s32DeviceState) );
strcat ( TmpStr, TmpS );
break;
case XMS_EVT_CALLIN:
pCallControl = (Acs_CallControl_Data *)FetchEventData(pAcsEvt);
sprintf ( TmpS, "(%s) (%s,%s)", GetString_DeviceAll(&pAcsEvt->m_DeviceID),
pCallControl->m_s8CallingNum, pCallControl->m_s8CalledNum);
strcat ( TmpStr, TmpS );
break;
case XMS_EVT_CALLOUT:
pCallControl = (Acs_CallControl_Data *)FetchEventData(pAcsEvt);
sprintf ( TmpS, "(%s) EvtState=%d, ErrCode=%d,ClearCause=%d) calling=%s called=%s", GetString_DeviceAll(&pAcsEvt->m_DeviceID),
pCallControl->m_s32AcsEvtState, pCallControl->m_s32AcsEvtErrCode, pCallControl->m_s32CallClearCause,pCallControl->m_s8CallingNum,pCallControl->m_s8CalledNum );
strcat ( TmpStr, TmpS );
break;
case XMS_EVT_RECVIODATA:
{
pIOData = (Acs_IO_Data *)FetchEventData(pAcsEvt);
//strcat ( TmpStr, TmpS );
//AddMsg ( MSG_TYPE_EVENT, TmpStr );
pdlg->GetDlgItem ( IDC_EDIT_SENDFAX )->GetWindowText ( SendTiffFileName, ACS_MAX_FILE_NAME_LEN-1 );
pdlg->GetDlgItem ( IDC_EDIT_RECEIVEFAX )->GetWindowText ( RecvTiffFileName, ACS_MAX_FILE_NAME_LEN-1 );
//sprintf ( s8LocalID, "DJ:83636988" );
if( pAcsEvt->m_DeviceID.m_s16DeviceMain == XMS_DEVMAIN_VOIP)
{
//Fax Process....begin
switch (pIOData->m_u16IoType)
{
case XMS_IO_TYPE_VOIP_H245UII:
if (pIOData->m_u16IoDataLen == sizeof(Acs_VoIP_H245UII))
{
Acs_VoIP_H245UII *h245Uii = (Acs_VoIP_H245UII *)FetchIOData(pAcsEvt);
dtmf = h245Uii->m_s8Signal;
}
sprintf ( TmpS, "(%s) (%s,%d) [%c]", GetString_DeviceAll(&pAcsEvt->m_DeviceID),
GetString_IOType(pIOData->m_u16IoType), pIOData->m_u16IoDataLen, dtmf );
break;
case XMS_IO_TYPE_VOIP_SIPINFO:
if (pIOData->m_u16IoDataLen == sizeof(Acs_VoIP_SIPINFO))
{
Acs_VoIP_SIPINFO *sipInfo = (Acs_VoIP_SIPINFO *)FetchIOData(pAcsEvt);
if (strcmp(sipInfo->m_s8ContentType, "application/dtmf") == 0)
sscanf(sipInfo->m_s8Body, "dtmf=%c", &dtmf);
}
sprintf ( TmpS, "(%s) (%s,%d) [%c]", GetString_DeviceAll(&pAcsEvt->m_DeviceID),
GetString_IOType(pIOData->m_u16IoType), pIOData->m_u16IoDataLen, dtmf );
break;
case XMS_IO_TYPE_VOIP_RTPDTMF:
if (pIOData->m_u16IoDataLen == sizeof(Acs_VoIP_RTPDTMF))
{
Acs_VoIP_RTPDTMF *rtpDtmf = (Acs_VoIP_RTPDTMF *)FetchIOData(pAcsEvt);
dtmf = rtpDtmf->m_s8EventChar;
}
sprintf ( TmpS, "(%s) (%s,%d) [%c]", GetString_DeviceAll(&pAcsEvt->m_DeviceID),
GetString_IOType(pIOData->m_u16IoType), pIOData->m_u16IoDataLen, dtmf );
break;
case XMS_IO_TYPE_VOIP_T38START:
if (pIOData->m_u16IoDataLen == sizeof(DJ_S32))
{
DJ_S32 *ret = (DJ_S32 *)FetchIOData(pAcsEvt);
if (*ret == 0)
{
pdlg->UpdateData();
if (g_iSendRecv == 0)//SendFax
{
//pdlg->m_lstIP.SetItemText(iDevice, 3, _T("Send Fax"));
XMS_ctsSendFax(g_acsHandle,
&DevOpened[iOpenedIndex1].DevID,
&DevOpened[iOpenedIndex2].DevID,
//&g_deviceVoIP[iDevice].device,
(DJ_S8 *)(LPCTSTR)SendTiffFileName, "1234", NULL);
sprintf ( TmpS, "(%s) (%s,%d) T38START SENDFAX", GetString_DeviceAll(&pAcsEvt->m_DeviceID),
GetString_IOType(pIOData->m_u16IoType), pIOData->m_u16IoDataLen );
}
else
{
//pdlg->m_lstIP.SetItemText(iDevice, 3, _T("Recv Fax"));
XMS_ctsReceiveFax(g_acsHandle,
&DevOpened[iOpenedIndex1].DevID,
&DevOpened[iOpenedIndex2].DevID,
//&g_deviceVoIP[iDevice].device,
(DJ_S8 *)(LPCTSTR)RecvTiffFileName, "1234", NULL);
sprintf ( TmpS, "(%s) (%s,%d) T38START RECVFAX", GetString_DeviceAll(&pAcsEvt->m_DeviceID),
GetString_IOType(pIOData->m_u16IoType), pIOData->m_u16IoDataLen );
}
}
}
break;
//default:
// sprintf ( TmpS, "(%s) (%s,%d) INVALID IOTYPE FOR VOIP", GetString_DeviceAll(&pAcsEvt->m_DeviceID),
// GetString_IOType(pIOData->m_u16IoType), pIOData->m_u16IoDataLen );
// break;
}
//Fax Process....end
}
else //NO IP Device
{
char *p;
p = (char *)(pIOData) + sizeof(Acs_IO_Data);
switch( pIOData->m_u16IoType)
{
case XMS_IO_TYPE_DTMF:
sprintf ( TmpS, "(%s) (%s,%d) [%s]",
GetString_DeviceAll(&pAcsEvt->m_DeviceID),
GetString_IOType(pIOData->m_u16IoType),
pIOData->m_u16IoDataLen,
p );
break;
case XMS_IO_TYPE_GTG:
sprintf ( TmpS, "(%s) (%s,%d) [%c]",
GetString_DeviceAll(&pAcsEvt->m_DeviceID),
GetString_IOType(pIOData->m_u16IoType),
pIOData->m_u16IoDataLen,
*p );
break;
case XMS_IO_TYPE_FSK:
sprintf ( TmpS, "(%s) (%s,Len:%d) [%d][%d][%d][%s]",
GetString_DeviceAll(&pAcsEvt->m_DeviceID),
GetString_IOType(pIOData->m_u16IoType),
pIOData->m_u16IoDataLen,
p[0],p[1],p[2],p );
break;
case XMS_IO_TYPE_PVD:
sprintf ( TmpS, "(%s) (%s,%d) [%c]",
GetString_DeviceAll(&pAcsEvt->m_DeviceID),
GetString_IOType(pIOData->m_u16IoType),
pIOData->m_u16IoDataLen,
*p );
break;
default:
break;
}
}
}
strcat ( TmpStr, TmpS );
//AddMsg ( MSG_TYPE_EVENT, TmpStr );
break;
case XMS_EVT_CAS_MFC_START:
case XMS_EVT_CAS_MFC_END:
pCAS_ExtraInfo = (Acs_CAS_ExtraInfo_t *)FetchEventData(pAcsEvt);
sprintf ( TmpS, "(%s) KA=%d, KD=%d)", GetString_DeviceAll(&pAcsEvt->m_DeviceID),
pCAS_ExtraInfo->m_u8KA, pCAS_ExtraInfo->m_u8KD );
strcat ( TmpStr, TmpS );
break;
case XMS_EVT_UNIFAILURE:
pAcsUniFailure = (Acs_UniFailure_Data *)FetchEventData(pAcsEvt);
sprintf ( TmpS, ": %s(0x%X)", GetString_ErrorCode(pAcsUniFailure->m_s32AcsEvtErrCode), pAcsUniFailure->m_s32AcsEvtErrCode );
strcat ( TmpStr, TmpS );
if ( pAcsEvt->m_DeviceID.m_s16DeviceMain != 0 )
{
//Unifailure event that some device link each other
sprintf ( TmpS, " (%s)", GetString_DeviceAll(&pAcsEvt->m_DeviceID) );
strcat ( TmpStr, TmpS );
}
break;
default:
break;
}
AddMsg ( MSG_TYPE_EVENT, TmpStr );
}
void DTrunkWork(INTERFACE_STRUCT* pOneTrunk, Acs_Evt_t* pAcsEvt)
{
DJ_S8 pCallerNum[64] = {0};
DJ_S8 pCalledNum[64] = {0};
DJ_S8 pTempcalledNum[64] = {0};
char TmpDtmf[1] = {0};
Acs_CallControl_Data *pCallControl = NULL;
VOIP_STRUCT *pOneVOIP = NULL;
int i = -1;
RetCode_t ret;
try
{
if (pAcsEvt->m_s32EventType == XMS_EVT_CLEARCALL)
{
TRACE("Recv ss7 clearCall evt\n");
long mDspID=pOneTrunk->pVoipDeviceID.m_s8ModuleID;
long mChannelID=pOneTrunk->pVoipDeviceID.m_s16ChannelID;
pOneVOIP=&M_OneVOIP(pOneTrunk->pVoipDeviceID);
if(pOneTrunk->mExchangeType == SS7_VOIP)
{
pOneVOIP=&M_OneVOIP(pOneTrunk->pVoipDeviceID);
if (pOneVOIP->iLineState != DCS_FREE)
{
pubIpSendClearCallCount++;
XMS_ctsClearCall(g_acsHandle, &pOneVOIP->deviceID, 0, NULL);
if(pOneVOIP->pVoiceDeviceID.m_s8ModuleID>0 )
My_DualUnlink(&pOneTrunk->deviceID, &pOneVOIP->pVoiceDeviceID);
DrawVOIP_LinkDev (pOneVOIP);
if (g_logfp != NULL)
{
char mLog[512]={0};
char mCurrTime[50]={0};
getCurrTime(mCurrTime);
sprintf(mLog,"%s Direct SS7 call in: ss7 receive clearCall so clear voip.Dsp:%d Ch:%d GlobalID:%d CallerNum:%s CalledNum:%s\n\r",
mCurrTime,
pOneVOIP->deviceID.m_s8ModuleID,
pOneVOIP->deviceID.m_s16ChannelID,
pOneVOIP->iGlobeID,
pOneVOIP->CallerNum,
pOneVOIP->CalleeNum);
fwrite(mLog,strlen(mLog),1,g_logfp);
fflush(g_logfp);
}
}
}
if(AllDeviceRes[mDspID].pVOIP[mChannelID].mExchangeType == VOIP_SS7 &&
AllDeviceRes[mDspID].pVOIP[mChannelID].iLineState !=DCS_FREE &&
AllDeviceRes[mDspID].pVOIP[mChannelID].iLineState !=DCS_CALLIN )
{
pOneVOIP=&M_OneVOIP(pOneTrunk->pVoipDeviceID);
ret = XMS_ctsClearCall(g_acsHandle, &pOneVOIP->deviceID, 0, NULL);
if (g_logfp != NULL)
{
char mLog[512]={0};
char mCurrTime[50]={0};
getCurrTime(mCurrTime);
sprintf(mLog,"%s Direct VOIP call in: ss7 receive clearCall so clear voip.Dsp:%d Ch:%d GlobalID:%d CallerNum:%s CalledNum:%s\n\r",
mCurrTime,
pOneVOIP->deviceID.m_s8ModuleID,
pOneVOIP->deviceID.m_s16ChannelID,
pOneVOIP->iGlobeID,
pOneVOIP->CallerNum,
pOneVOIP->CalleeNum);
fwrite(mLog,strlen(mLog),1,g_logfp);
fflush(g_logfp);
}
}
ResetTrunk(pOneTrunk,pAcsEvt);
return;
}
//状态处理
switch(pOneTrunk->DTrkState)
{
case TRK_FREE:
/*call in from Digit Signal */
if (pAcsEvt->m_s32EventType == XMS_EVT_CALLIN)
{
pCallControl = (Acs_CallControl_Data *)((DJ_S8 *)pAcsEvt + sizeof(Acs_Evt_t));
strncpy(pCallerNum, pCallControl->m_s8CallingNum, sizeof(pCallerNum));
strncpy(pTempcalledNum, pCallControl->m_s8CalledNum, sizeof(pTempcalledNum));
//hao ma gui ze
memset(pCalledNum, 0, sizeof(pCalledNum));
if (Rule(pTempcalledNum, pDailRuleHead, pCalledNum) == 0)
strcpy(pCalledNum, pTempcalledNum);
pOneTrunk->mExchangeType = SS7_VOIP;
pOneVOIP=&M_OneVOIP(pOneTrunk->pVoipDeviceID);
if (g_logfp != NULL)
{
char mLog[512]={0};
char mCurrTime[50]={0};
getCurrTime(mCurrTime);
sprintf(mLog,"%s SS7 RECEVICE CallIn:Dsp:%d Ch:%d GlobalID:%d CallerNum:%s CalledNum:%s\n\r",
mCurrTime,
pOneVOIP->deviceID.m_s8ModuleID,
pOneVOIP->deviceID.m_s16ChannelID,
pOneVOIP->iGlobeID,
pCallerNum,
pCalledNum);
fwrite(mLog,strlen(mLog),1,g_logfp);
fflush(g_logfp);
}
if(pOneVOIP->iLineState==DCS_FREE && pOneVOIP->State == VOIP_FREE)
{
pOneVOIP=&M_OneVOIP(pOneTrunk->pVoipDeviceID);
if(PSTNToVOIPCallout(pCallerNum, pCalledNum, &pOneVOIP->deviceID, pOneTrunk) < 0)
{
XMS_ctsClearCall(g_acsHandle, &pOneTrunk->deviceID, 0, NULL);
TRACE("3 ClearCall SS7\n");
Change_DTrunkState(pOneTrunk, TRK_HANGUP);
if (g_logfp != NULL)
{
char mLog[512]={0};
char mCurrTime[50]={0};
getCurrTime(mCurrTime);
sprintf(mLog,"%s First Direct SS7 callin: voip function error, so clear ss7 :Dsp:%d Ch:%d GlobalID:%d CallerNum:%s CalledNum:%s\n\r",
mCurrTime,
pOneVOIP->deviceID.m_s8ModuleID,
pOneVOIP->deviceID.m_s16ChannelID,
pOneVOIP->iGlobeID,
pOneVOIP->CallerNum,
pOneVOIP->CalleeNum);
fwrite(mLog,strlen(mLog),1,g_logfp);
fflush(g_logfp);
}
break;
}
DrawVOIP_LinkDev(pOneVOIP);
DrawVOIP_CallInfo(pOneVOIP);
Change_VOIPState(pOneVOIP, VOIP_CALLOUT);
strncpy(pOneVOIP->CalleeNum,pCalledNum,20);
strncpy(pOneVOIP->CallerNum,pCallerNum,20);
strncpy(pOneTrunk->CalleeCode, pCalledNum, 20);
strncpy(pOneTrunk->CallerCode, pCallerNum, 20);
DrawDTrunk_CallInfo(pOneTrunk);
DrawDTrunk_LinkDev(pOneTrunk);
Change_DTrunkState(pOneTrunk, TRK_WAIT_ANSERCALL);
}
else
{
XMS_ctsSetDevTimer(g_acsHandle,&pOneTrunk->deviceID,400);
pOneTrunk->TimeOut = 0;
DrawDTrunk_DTMF(pOneTrunk);
Change_DTrunkState(pOneTrunk,TRK_WAIT_CALL_VOIP);
}
}
break;
case TRK_WAIT_CALL_VOIP:
{
if(pOneTrunk->iLineState == DCS_FREE )
{
if (pOneTrunk->mExchangeType == SS7_VOIP)
{
pOneVOIP=&M_OneVOIP(pOneTrunk->pVoipDeviceID);
if (pOneVOIP->iLineState != DCS_FREE)
{
XMS_ctsClearCall(g_acsHandle, &pOneVOIP->deviceID, 0, NULL);
if(pOneVOIP->pVoiceDeviceID.m_s8ModuleID>0 )
My_DualUnlink(&pOneTrunk->deviceID, &pOneVOIP->pVoiceDeviceID);
DrawVOIP_LinkDev (pOneVOIP);
if (g_logfp != NULL)
{
char mLog[512]={0};
char mCurrTime[50]={0};
getCurrTime(mCurrTime);
sprintf(mLog,"%s Direct SS7 call in: wait call IP,then SS7 Linestate is free so clear voip:Dsp:%d Ch:%d GlobalID:%d CallerNum:%s CalledNum:%s\n\r",
mCurrTime,
pOneVOIP->deviceID.m_s8ModuleID,
pOneVOIP->deviceID.m_s16ChannelID,
pOneVOIP->iGlobeID,
pOneVOIP->CallerNum,
pOneVOIP->CalleeNum);
fwrite(mLog,strlen(mLog),1,g_logfp);
fflush(g_logfp);
}
}
}
ResetTrunk(pOneTrunk,pAcsEvt);
}
if(pAcsEvt->m_s32EventType == XMS_EVT_DEV_TIMER && pOneTrunk->iLineState != DCS_FREE)
{
pOneTrunk->TimeOut++;
DrawDTrunk_DTMF(pOneTrunk);
if(pOneTrunk->TimeOut >4 )
{
pOneTrunk->TimeOut = 0;
pOneVOIP=&M_OneVOIP(pOneTrunk->pVoipDeviceID);
XMS_ctsClearCall(g_acsHandle, &pOneTrunk->deviceID, 0, NULL);
TRACE("4 ClearCall SS7\n");
if (g_logfp != NULL)
{
char mLog[512]={0};
char mCurrTime[50]={0};
getCurrTime(mCurrTime);
sprintf(mLog,"%s Direct SS7 call in: voip wait time is timeover,so clear ss7 :Dsp:%d Ch:%d GlobalID:%d CallerNum:%s CalledNum:%d\n\r",
mCurrTime,
pOneVOIP->deviceID.m_s8ModuleID,
pOneVOIP->deviceID.m_s16ChannelID,
pOneVOIP->iGlobeID,
pOneVOIP->CallerNum,
pOneVOIP->CalleeNum);
fwrite(mLog,strlen(mLog),1,g_logfp);
fflush(g_logfp);
}
break;
}
pOneVOIP=&M_OneVOIP(pOneTrunk->pVoipDeviceID);
if(pOneVOIP->iLineState==DCS_FREE && pOneVOIP->State == VOIP_FREE)
{
if(PSTNToVOIPCallout(pCallerNum, pCalledNum, &pOneVOIP->deviceID, pOneTrunk) < 0)
{
XMS_ctsClearCall(g_acsHandle, &pOneTrunk->deviceID, 0, NULL);
TRACE("5 ClearCall SS7\n");;
Change_DTrunkState(pOneTrunk, TRK_HANGUP);
if (g_logfp != NULL)
{
char mLog[512]={0};
char mCurrTime[50]={0};
getCurrTime(mCurrTime);
sprintf(mLog,"%s Second Direct SS7 call in: Voip call function error, so clear ss7:Dsp:%d Ch:%d GlobalID:%d CallerNum:%s CalledNum:%s\n\r",
mCurrTime,
pOneVOIP->deviceID.m_s8ModuleID,
pOneVOIP->deviceID.m_s16ChannelID,
pOneVOIP->iGlobeID,
pOneVOIP->CallerNum,
pOneVOIP->CalleeNum);
fwrite(mLog,strlen(mLog),1,g_logfp);
fflush(g_logfp);
}
break;
}
DrawVOIP_LinkDev(pOneVOIP);
DrawVOIP_CallInfo(pOneVOIP);
Change_VOIPState(pOneVOIP, VOIP_CALLOUT);
strncpy(pOneTrunk->CalleeCode, pCalledNum, 20);
strncpy(pOneTrunk->CallerCode, pCallerNum, 20);
DrawDTrunk_CallInfo(pOneTrunk);
DrawDTrunk_LinkDev(pOneTrunk);
Change_DTrunkState(pOneTrunk, TRK_WAIT_ANSERCALL);
}
else
{
XMS_ctsSetDevTimer(g_acsHandle,&pOneTrunk->deviceID,400);
Change_DTrunkState(pOneTrunk,TRK_WAIT_CALL_VOIP);
}
}
}
break;
case TRK_WAIT_ANSERCALL:
if(pOneTrunk->iLineState == DCS_FREE)
{
if (pOneTrunk->mExchangeType == SS7_VOIP)
{
pOneVOIP=&M_OneVOIP(pOneTrunk->pVoipDeviceID);
if (pOneVOIP->iLineState != DCS_FREE)
{
XMS_ctsClearCall(g_acsHandle, &pOneVOIP->deviceID, 0, NULL);
if(pOneVOIP->pVoiceDeviceID.m_s8ModuleID>0 )
My_DualUnlink(&pOneTrunk->deviceID, &pOneVOIP->pVoiceDeviceID);
DrawVOIP_LinkDev (pOneVOIP);
if (g_logfp != NULL)
{
char mLog[512]={0};
char mCurrTime[50]={0};
getCurrTime(mCurrTime);
sprintf(mLog,"%s SS7 wait ansercall but SS7 Linestate is free so clear VOIP: Dsp:%d Ch:%d GlobalID:%d CallerNum:%s CalledNum:%s\n\r",
mCurrTime,
pOneVOIP->deviceID.m_s8ModuleID,
pOneVOIP->deviceID.m_s16ChannelID,
pOneVOIP->iGlobeID,
pOneVOIP->CallerNum,
pOneVOIP->CalleeNum);
fwrite(mLog,strlen(mLog),1,g_logfp);
fflush(g_logfp);
}
}
}
ResetTrunk(pOneTrunk,pAcsEvt);
}
if(pAcsEvt->m_s32EventType == XMS_EVT_ANSWERCALL)
{
Change_DTrunkState(pOneTrunk, TRK_CONNECT);
}
break;
case TRK_CALLOUT:
if ( pAcsEvt->m_s32EventType == XMS_EVT_CALLOUT )
{
INTERFACE_STRUCT *pOneInterface = NULL;
pOneVOIP = &M_OneVOIP(pOneTrunk->pVoipDeviceID);
pCallControl = (Acs_CallControl_Data *)((DJ_S8 *)pAcsEvt + sizeof(Acs_Evt_t));
if ( pCallControl->m_s32AcsEvtState == 1 ) // 呼出成功，对方摘机
{
// pOneTrunk->bcallFailFalg = false;
if (g_logfp != NULL)
{
char mLog[512]={0};
char mCurrTime[50]={0};
getCurrTime(mCurrTime);
sprintf(mLog,"%s SS7 CallOut Success:Dsp:%d Ch:%d GlobalID:%d CallerNum:%s CalledNum:%s\n\r",
mCurrTime,
pOneVOIP->deviceID.m_s8ModuleID,
pOneVOIP->deviceID.m_s16ChannelID,
pOneVOIP->iGlobeID,
pOneVOIP->CallerNum,
pOneVOIP->CalleeNum);
fwrite(mLog,strlen(mLog),1,g_logfp);
fflush(g_logfp);
}
pubIpSS7ConnectCount++;
Change_DTrunkState(pOneTrunk, TRK_CONNECT);
Change_VOIPState(pOneVOIP, VOIP_WAIT_ANSWERCALL);
XMS_ctsAnswerCallIn(g_acsHandle, &pOneVOIP->deviceID, NULL);
}
else // 呼出失败
{
pOneTrunk->bcallFailFalg = true;
DrawDTrunk_Reason(pOneTrunk, pCallControl->m_s32AcsEvtErrCode, pCallControl->m_s32CallClearCause);
Change_DTrunkState(pOneTrunk, TRK_FREE);
pubIpSS7ErrorCount++;
pubErrorClearCallCount++;
//带原因值的拆线--ADD by WWK
int mCallErrorCode = 0;
if(pCallControl->m_s32AcsEvtErrCode == 17 ) mCallErrorCode = 486; //被叫忙
if(pCallControl->m_s32AcsEvtErrCode == 28 ) mCallErrorCode = 404; //号码不存在
if(pCallControl->m_s32AcsEvtErrCode == 19 ) mCallErrorCode = 408; //被叫关机或者无应答
XMS_ctsClearCall(g_acsHandle, &pOneVOIP->deviceID, mCallErrorCode, NULL);
Change_VOIPState(pOneVOIP, VOIP_HANGUP);
if (g_logfp != NULL)
{
char mTemp[512]={0};
char mCurrTime[50]={0};
getCurrTime(mCurrTime);
sprintf(mTemp,"%s SS7 call out failed, so clear voip!! DSP:%d Ch:%d ErrorCode:%d Reason:%d, bcallFailFalg:%d\n\r",
mCurrTime,
pOneTrunk->deviceID.m_s8ModuleID,
pOneTrunk->deviceID.m_s16ChannelID,
pCallControl->m_s32AcsEvtErrCode,
pCallControl->m_s32CallClearCause,
pOneTrunk->bcallFailFalg);
fwrite(mTemp,strlen(mTemp),1,g_logfp);
fflush(g_logfp);
}
}
}
break;
case TRK_CONNECT:
if(pOneTrunk->iLineState == DCS_FREE )
{
if (pOneTrunk->mExchangeType == SS7_VOIP)
{
pOneVOIP=&M_OneVOIP(pOneTrunk->pVoipDeviceID);
if (pOneVOIP->iLineState != DCS_FREE)
{
XMS_ctsClearCall(g_acsHandle, &pOneVOIP->deviceID, 0, NULL);
if(pOneVOIP->pVoiceDeviceID.m_s8ModuleID>0 )
My_DualUnlink(&pOneTrunk->deviceID, &pOneVOIP->pVoiceDeviceID);
DrawVOIP_LinkDev (pOneVOIP);
if (g_logfp != NULL)
{
char mLog[512]={0};
char mCurrTime[50]={0};
getCurrTime(mCurrTime);
sprintf(mLog,"%s SS7 Connected and Line State Is Free So Clear VOIP CALL :Dsp:%d Ch:%d GlobalID:%d CallerNum:%s CalledNum:%s\n\r",
mCurrTime,
pOneVOIP->deviceID.m_s8ModuleID,
pOneVOIP->deviceID.m_s16ChannelID,
pOneVOIP->iGlobeID,
pOneVOIP->CallerNum,
pOneVOIP->CalleeNum);
fwrite(mLog,strlen(mLog),1,g_logfp);
fflush(g_logfp);
}
}
}
ResetTrunk(pOneTrunk, pAcsEvt);
return;
}
TmpDtmf[0] = My_GetIntfDtmfCode(pAcsEvt);
if ( TmpDtmf[0] != -1 ) //DTMF按键
{
My_AddIntfDtmfBuf(pOneTrunk, TmpDtmf[0]);
DrawDTrunk_DTMF(pOneTrunk);
if(pOneTrunk->DtmfCount > 0 )
{
DeviceID_t *pOneVOIP = &AllDeviceRes[pOneTrunk->deviceID.m_s8ModuleID].pInterf[pOneTrunk->deviceID.m_s16ChannelID].pVoipDeviceID;
switch(pubSendRTPDTMFType)
{
case 1:
{
Acs_VoIP_H245UII h245Uii = {0};
h245Uii.m_s8Signal = pOneTrunk->DtmfBuf[0]; // dtmf char in "0123456789#*ABCD!"
h245Uii.m_u32Duration = 200; // milliseconds
XMS_ctsSendIOData(g_acsHandle,pOneVOIP,XMS_IO_TYPE_VOIP_H245UII,sizeof(h245Uii),&h245Uii);
}
break;
case 2:
{
Acs_VoIP_SIPINFO sipInfo = {0};
strcpy(sipInfo.m_s8ContentType, "application/dtmf");
sprintf(sipInfo.m_s8Body, "dtmf=%c\nduration=%d", pOneTrunk->DtmfBuf[0], 200);
XMS_ctsSendIOData(g_acsHandle,pOneVOIP,XMS_IO_TYPE_VOIP_SIPINFO,sizeof(sipInfo),&sipInfo);
}
break;
case 3:
{
Acs_VoIP_RTPDTMF rtpDtmf = {0};
rtpDtmf.m_s8EventChar = pOneTrunk->DtmfBuf[0]; // rtp dtmf event char
rtpDtmf.m_s8Volume = -32; // volume (in dbm0 from -63 to 0)
rtpDtmf.m_u16Duration = 200; // duration (in timestamp units
XMS_ctsSendIOData(g_acsHandle,pOneVOIP,XMS_IO_TYPE_VOIP_RTPDTMF,sizeof(rtpDtmf),&rtpDtmf);
}
break;
default:
{
Acs_VoIP_H245UII h245Uii = {0};
h245Uii.m_s8Signal = pOneTrunk->DtmfBuf[0]; // dtmf char in "0123456789#*ABCD!"
h245Uii.m_u32Duration = 200; // milliseconds
XMS_ctsSendIOData(g_acsHandle,pOneVOIP,XMS_IO_TYPE_VOIP_H245UII,sizeof(h245Uii),&h245Uii);
}
break;
}
My_InitIntfDtmfBuf(pOneTrunk);
}
}
break;
}
}catch(...)
{
if (g_logfp != NULL)
{
char mTemp[255]={0};
char mCurrTime[50]={0};
getCurrTime(mCurrTime);
sprintf(mTemp,"%s DT Trunk Run Error\n\r",mCurrTime);
fwrite(mTemp,strlen(mTemp),1,g_logfp);
fflush(g_logfp);
}
}
return;
}
//////////////////////////////////////////////////////////////////////////
// XMS_EVT_RECVIODATA event handler (H.245 UserInputIndication/SIP INFO/RFC 2833 DTMF)
void OnRecvIOData(Acs_Evt_t *pAcsEvt)
{
Acs_IO_Data *pIOEvt = (Acs_IO_Data *)FetchEventData(pAcsEvt);
TRACE(_T("Device[%02d][%02d][%02d] receive IO Data\n"),
pAcsEvt->m_DeviceID.m_s8ModuleID,
pAcsEvt->m_DeviceID.m_s16DeviceMain,
pAcsEvt->m_DeviceID.m_s16ChannelID);
int iDevice = pAcsEvt->m_DeviceID.m_s16ChannelID;
int iDtmfLen = strlen(g_deviceVoIP[iDevice].szDtmf);
if (iDtmfLen >= sizeof(g_deviceVoIP[iDevice].szDtmf)-1)
{
memset(g_deviceVoIP[iDevice].szDtmf, 0, sizeof(g_deviceVoIP[iDevice].szDtmf));
iDtmfLen = 0;
}
char dtmf = '?';
switch (pIOEvt->m_u16IoType)
{
case XMS_IO_TYPE_VOIP_REGREQUEST:
if (pIOEvt->m_u16IoDataLen == sizeof(Acs_VoIP_REGSTATE))
{
// check client's info
Acs_VoIP_REGSTATE *pRegRequest = (Acs_VoIP_REGSTATE *)FetchIOData(pAcsEvt);
TRACE(_T("Client registrates from: \"%s\" %s@%s:%d\n"),
pRegRequest->m_s8UserID, pRegRequest->m_s8TelNo, pRegRequest->m_s8Address, pRegRequest->m_u16Port);
// response to registration
// if authentication is disabled,
// set Acs_VoIP_REGRESP::m_u8Granted to 0/1 to grant/disgrant registration
// if authentication is enabled,
// set Acs_VoIP_REGRESP::m_u8Granted to 0, and fill Acs_VoIP_REGRESP::m_s8Password to authenticate,
// or
// set Acs_VoIP_REGRESP::m_u8Granted to 0, and leave Acs_VoIP_REGRESP::m_s8Password empty to disgrant registration,
// or
// set Acs_VoIP_REGRESP::m_u8Granted to 1 to grant registration without authenticating.
Acs_VoIP_REGRESP regResponse = {0};
regResponse.m_u16SlotID = pRegRequest->m_u16SlotID;
regResponse.m_u8Granted = 1;
// strcpy(regResponse.m_s8Password, "passwd");
XMS_ctsSendIOData(g_acsHandle, &g_deviceVoIP[iDevice].device, XMS_IO_TYPE_VOIP_REGRESPONSE,
sizeof(regResponse), ®Response);
}
break;
case XMS_IO_TYPE_VOIP_REGSTATE:
if (pIOEvt->m_u16IoDataLen == sizeof(Acs_VoIP_REGSTATE))
{
Acs_VoIP_REGSTATE *pRegState = (Acs_VoIP_REGSTATE *)FetchIOData(pAcsEvt);
TRACE(_T("Client %s on slot(%d): %s@%s:%d\n"),
pRegState->m_u8State?_T("registered"):_T("unregistered"),
pRegState->m_u16SlotID,
pRegState->m_s8TelNo, pRegState->m_s8Address, pRegState->m_u16Port);
}
break;
case XMS_IO_TYPE_VOIP_H245UII:
if (pIOEvt->m_u16IoDataLen == sizeof(Acs_VoIP_H245UII))
{
Acs_VoIP_H245UII *h245Uii = (Acs_VoIP_H245UII *)FetchIOData(pAcsEvt);
dtmf = h245Uii->m_s8Signal;
g_deviceVoIP[iDevice].szDtmf[iDtmfLen] = dtmf;
}
break;
case XMS_IO_TYPE_VOIP_SIPINFO:
if (pIOEvt->m_u16IoDataLen == sizeof(Acs_VoIP_SIPINFO))
{
Acs_VoIP_SIPINFO *sipInfo = (Acs_VoIP_SIPINFO *)FetchIOData(pAcsEvt);
if (strcmp(sipInfo->m_s8ContentType, "application/dtmf") == 0)
sscanf(sipInfo->m_s8Body, "dtmf=%c", &dtmf);
g_deviceVoIP[iDevice].szDtmf[iDtmfLen] = dtmf;
}
break;
case XMS_IO_TYPE_VOIP_RTPDTMF:
if (pIOEvt->m_u16IoDataLen == sizeof(Acs_VoIP_RTPDTMF))
{
Acs_VoIP_RTPDTMF *rtpDtmf = (Acs_VoIP_RTPDTMF *)FetchIOData(pAcsEvt);
dtmf = rtpDtmf->m_s8EventChar;
g_deviceVoIP[iDevice].szDtmf[iDtmfLen] = dtmf;
}
break;
case XMS_IO_TYPE_VOIP_RTPTONE:
if (pIOEvt->m_u16IoDataLen == sizeof(Acs_VoIP_RTPTONE))
{
Acs_VoIP_RTPTONE *rtpTone = (Acs_VoIP_RTPTONE *)FetchIOData(pAcsEvt);
}
break;
case XMS_IO_TYPE_VOIP_REFER_NOTIFY:
if (pIOEvt->m_u16IoDataLen == sizeof(Acs_VoIP_ReferResult))
{
Acs_VoIP_ReferResult *pTransferResult = (Acs_VoIP_ReferResult *)FetchIOData(pAcsEvt);
TRACE("XMS_IO_TYPE_VOIP_REFER_NOTIFY state:%d reason:%d\n", pTransferResult->m_u8State, pTransferResult->m_u8Reason);
if(pTransferResult->m_u8State==17)
{
if(pTransferResult->m_u8Reason==23 || pTransferResult->m_u8Reason==24)
{
RetCode_t ret = XMS_ctsClearCall(g_acsHandle, &g_deviceVoIP[iDevice].device, 0, NULL);
}
else
{
VoIPCallModifyPrivate_t callModify = {0};
callModify.m_PrivateData.m_u32DataSize = sizeof(VoIPCallModifyPrivate_t);
callModify.m_u8MediaCapNum = 0;
// set media mode to send/recv
callModify.u8MediaMode = 0;
RetCode_t ret = XMS_ctsSendIOData(g_acsHandle, &g_deviceVoIP[iDevice].device, XMS_IO_TYPE_VOIP_CALLMODIFY, sizeof(VoIPCallModifyPrivate_t), (void*)&callModify);
}
}
}
break;
}
if (pIOEvt->m_u16IoType != XMS_IO_TYPE_VOIP_REGREQUEST &&
pIOEvt->m_u16IoType != XMS_IO_TYPE_VOIP_REGSTATE)
g_pDlg->refreshListIP(iDevice);
}
