int main(int argc, char *argv[])
{
double start,finish,result,precise;
setDefaults(getSel(argc,argv));
printf(" -> Starting sequence with %ld ...\n",maxval);
start = getCurrTime();
primecount(maxval);
finish = getCurrTime();
result = (finish - start)/lts2;
//printf("\nResult is: %6.3lf.\n",result);
precise = abs(lts1 - result);
printf("\nResult is: %6.3lf.\n",precise);
return (int)(result/1);
}
void clsTimers::start()
{
timeStartMilis = getCurrTime();
stopped = false;
}
LargeMemoryBlock *LargeObjectCache::get(size_t size)
{
MALLOC_ASSERT( size%largeBlockCacheStep==0, ASSERT_TEXT );
MALLOC_ASSERT( size>=minLargeSize, ASSERT_TEXT );
if ( size < maxHugeSize) {
uintptr_t currTime = getCurrTime();
cleanupCacheIfNeeded(currTime);
return size < maxLargeSize?
largeCache.get(currTime, size) : hugeCache.get(currTime, size);
}
return NULL;
}
void setup_routing_table(){
if(!table_changed){
cleanup_and_start_app();
return;
}
//printf("Setting up the routing table\n");
table_changed = false;
DATAGRAM dg;
dg.source = dg.dest = nodeinfo.address;
dg.fragOffset_nnSrc = dg.flagOffset_nnVia = nodeinfo.nodenumber;
getCurrTime(&dg.timestamp);
push_dg_for_routing(dg, n);
n -= 2;
CNET_start_timer(EV_TIMER9, 2000000, 0);
}
unsigned long long clsTimers::getElapsedTime()
{
unsigned long long elapsedTimeMilis;
elapsedTimeMilis = getCurrTime()-timeStartMilis;
if(stopped)
{
elapsedTimeMilis = 0;
}
return elapsedTimeMilis+timeElapsedMilis;
}
PROCESS_THREAD(ntpdemo_process, ev, data)
{
static struct etimer et;
PROCESS_BEGIN();
etimer_set(&et, CLOCK_SECOND);
while(1) {
PROCESS_YIELD();
if(etimer_expired(&et)) {
printf("%lu\n", getCurrTime());
etimer_restart(&et);
}
}
PROCESS_END();
}
/*---------------------------------------------------------------------------*/
PROCESS_THREAD(ntpd_process, ev, data)
{
static struct etimer et;
static uip_ipaddr_t ipaddr;
PROCESS_BEGIN();
PRINTF("ntpd process started\n");
set_connection_address(&ipaddr);
/* find the IP of router */
//etimer_set(&et, CLOCK_SECOND);
//while(1){
// if(uip_ds6_defrt_choose()){
// uip_ipaddr_copy(&ipaddr, uip_ds6_defrt_choose());
// break;
// }
// etimer_set(&et, CLOCK_SECOND);
// PROCESS_YIELD_UNTIL(etimer_expired(&et));
//}
/* new connection with remote host */
ntp_conn = udp_new(&ipaddr, UIP_HTONS(NTPD_PORT), NULL);
etimer_set(&et, SEND_INTERVAL * CLOCK_SECOND);
while(1) {
PROCESS_YIELD();
if(etimer_expired(&et)) {
timeout_handler();
if((clock_seconds() > 4294967290U) || (clock_seconds() < 20)){
SEND_INTERVAL = 2 * CLOCK_SECOND;
etimer_set(&et, SEND_INTERVAL);
} else {
if(SEND_INTERVAL <= 512 && (getCurrTime() != 0)) {
SEND_INTERVAL = 2 * SEND_INTERVAL;
}
etimer_set(&et, SEND_INTERVAL * CLOCK_SECOND);
}
} else if(ev == tcpip_event) {
tcpip_handler();
}
}
PROCESS_END();
}
void update_table(int link, DATAGRAM dg){
if(dg.source == nodeinfo.address){
//table[f.payload.B].link = link;
return;
}
bool to_send = false;
unsigned long long curr_time;
getCurrTime(&curr_time);
long curr_cost = (long)(curr_time - dg.timestamp)/1000;
if(table[dg.fragOffset_nnSrc].dest != dg.source){
//printf("filling RT\n");
table[dg.fragOffset_nnSrc].dest = dg.source;
table[dg.fragOffset_nnSrc].via = dg.dest;
table[dg.fragOffset_nnSrc].cost = curr_cost;
table[dg.fragOffset_nnSrc].link = link;
//table[f.payload.fragOffset_nnSrc].min_mtu = min(table[f.payload.A].min_mtu, f.payload.flag_offset);
to_send = true;
table_changed = true;
}
else {
if(table[dg.fragOffset_nnSrc].cost > curr_cost){
table_changed = true;
table[dg.fragOffset_nnSrc].cost = curr_cost;
table[dg.fragOffset_nnSrc].dest = dg.source;
table[dg.fragOffset_nnSrc].via = dg.dest;
table[dg.fragOffset_nnSrc].link = link;
//table[f.payload.A].min_mtu = min(table[f.payload.A].min_mtu, f.payload.flag_offset);
to_send = true;
}
}
if(to_send){
dg.flagOffset_nnVia = nodeinfo.nodenumber;
dg.dest = nodeinfo.address;
for(int i=0;i<2;i++)
push_dg_for_routing(dg);
}
}
int PSTNToVOIPCallout(char* pCallerNum, char* pCalledNum, DeviceID_t* pVoipDev, INTERFACE_STRUCT* pOneInterface)
{
RetCode_t ret = -1;
VOIP_STRUCT *pOneVOIP = NULL;
DeviceID_t FreeVocDeviceID;
MixerControlParam_t VocCmdP = {0};
CmdParamData_Voice_t VocMixParam = {0};
VoIPCallPrivate_t voipCallParam = {0};
int iPreCnt = 0;
int iRoutCnt = 0;
_ASSERT(pCallerNum != NULL);
_ASSERT(pCalledNum != NULL);
_ASSERT(pVoipDev != NULL);
_ASSERT(pOneInterface != NULL);
voipCallParam.m_PrivateData.m_u32DataSize = sizeof(VoIPCallPrivate_t);
voipCallParam.m_s32Protocol = XMS_VOIP_PROTOCOL_SIP;
strncpy(voipCallParam.m_s8CallerUserID, pCallerNum, sizeof(voipCallParam.m_s8CallerUserID));
char cfg_MapIP[255] = {0};
if (outRout == NULL)
{
sprintf(cfg_MapIP,"%s",pubOutVoipAddress);
strncpy(voipCallParam.m_s8CalleeAddress, cfg_MapIP, sizeof(voipCallParam.m_s8CallerAddress));
voipCallParam.m_s32CalleePort = pubOutVoipPort;
}
else
{
int bRout = 0;
for (iRoutCnt = 1; iRoutCnt <= cfg_routCnt; iRoutCnt++)
{
if (bRout == 1)
break;
for (iPreCnt = 0; iPreCnt < 10; iPreCnt++)
{
if (strlen(outRout[iRoutCnt].phonePreNum[iPreCnt]) > 0)
{
if (strncmp(outRout[iRoutCnt].phonePreNum[iPreCnt], pCalledNum, strlen(outRout[iRoutCnt].phonePreNum[iPreCnt])) == 0)
{
strncpy(voipCallParam.m_s8CalleeAddress, outRout[iRoutCnt].outBAddr.proxyAddr, sizeof(voipCallParam.m_s8CallerAddress));
voipCallParam.m_s32CalleePort = outRout[iRoutCnt].outBAddr.proxyPort;
bRout = 1;
break;
}
}
}
}
if (bRout == 0)
{
sprintf(cfg_MapIP,"%s",pubOutVoipAddress);
strncpy(voipCallParam.m_s8CalleeAddress, cfg_MapIP, sizeof(voipCallParam.m_s8CallerAddress));
voipCallParam.m_s32CalleePort = pubOutVoipPort;
}
}
if (g_logfp != NULL)
{
char mTemp[512]={0};
char mCurrTime[50]={0};
getCurrTime(mCurrTime);
sprintf(mTemp,"%s IPCALLOUT In PSTNToVOIPCallOut: DSP:%d Ch:%d AcsHandle:%d, FlowType:%d FlowChannelID:%d CalleAddress:%s Port:%d Caller:%s Called:%s \n\r",
mCurrTime,
pVoipDev->m_s8ModuleID,
pVoipDev->m_s16ChannelID,
g_acsHandle,
pVoipDev->m_CallID.m_s32FlowType,
pVoipDev->m_CallID.m_s32FlowChannel,
voipCallParam.m_s8CalleeAddress,
voipCallParam.m_s32CalleePort,
pCallerNum,
pCalledNum);
fwrite(mTemp,strlen(mTemp),1,g_logfp);
fflush(g_logfp);
}
pOneVOIP = &M_OneVOIP(*pVoipDev);
ret = XMS_ctsMakeCallOut(g_acsHandle, pVoipDev, pCallerNum, pCalledNum, (PrivateData_t *)&voipCallParam);
if(ret > 0)
{
FreeVocDeviceID=pOneVOIP->pVoiceDeviceID;
VocCmdP.m_u8SRC1_Ctrl = XMS_MIXER_FROM_INPUT;
VocCmdP.m_u16SRC_ChID1 = pOneVOIP->pVoiceDeviceID.m_s16ChannelID;
//如果不屏蔽这两行，会造成DTMF播放死循环
// VocCmdP.m_u8SRC2_Ctrl = XMS_MIXER_FROM_PLAY;
// VocCmdP.m_u16SRC_ChID2 = pOneVOIP->pVoiceDeviceID.m_s16ChannelID;
ret = XMS_ctsSetParam(g_acsHandle, &pOneVOIP->deviceID,
VOIP_PARAM_RTPMIXER, sizeof(VocCmdP), &VocCmdP);
/* VocMixParam.m_u8InputCtrlValid=1; //使能输入控制参数
VocMixParam.m_VocInputControl.m_u8AgcEnable=0;// inputContol使能自动增益
VocMixParam.m_VocInputControl.m_u8AgcMode = 0 ;//设为ALS模式
VocMixParam.m_VocInputControl.m_u16FixGain=1024;
VocMixParam.m_VocInputControl.m_u8EcEnable=0;//禁止回声抑制
VocMixParam.m_VocInputControl.m_u8TadEnable=1; //启动语音TONE音抑制使能
VocMixParam.m_VocInputControl.m_u8EcRefType=0; */
VocMixParam.m_u8GtdCtrlValid = 1;
VocMixParam.m_VocGtdControl.m_u8DTMFEnable = 1;
VocMixParam.m_VocGtdControl.m_u8FSKEnable = 1;
VocMixParam.m_VocGtdControl.m_u8ChannelEnable = 1;
VocMixParam.m_VocGtdControl.m_u8GTDEnable = 1;
unsigned char gtdID[] = {"GHIJKLM"};
memcpy(VocMixParam.m_VocGtdControl.m_u8GTDID, gtdID, sizeof(VocMixParam.m_VocGtdControl.m_u8GTDID));
// EnableGtg(&pOneVOIP->pVoiceDeviceID);
VocMixParam.m_u8OutputCtrlValid = 1;
VocMixParam.m_VocOutputControl.m_u8OutputType = XMS_VOC_OUTPUT_FROM_MIXER;
VocMixParam.m_VocOutputControl.m_u16FixGain = 1024;
VocMixParam.m_VocOutputControl.m_MixerControl.m_u8SRC1_Ctrl = XMS_MIXER_FROM_PLAY;
VocMixParam.m_VocOutputControl.m_MixerControl.m_u16SRC_ChID1 = pOneVOIP->pVoiceDeviceID.m_s16ChannelID;
VocMixParam.m_VocOutputControl.m_MixerControl.m_u8SRC2_Ctrl = XMS_MIXER_FROM_IP;
VocMixParam.m_VocOutputControl.m_MixerControl.m_u16SRC_ChID2 = pOneVOIP->deviceID.m_s16ChannelID;
ret = XMS_ctsSetParam(g_acsHandle, &pOneVOIP->pVoiceDeviceID,VOC_PARAM_UNIPARAM, sizeof(VocMixParam), &VocMixParam);
My_DualLink(&pOneInterface->deviceID, &pOneInterface->pVoiceDeviceID);
XMS_ctsAlertCall(g_acsHandle,&pOneInterface->deviceID,NULL);
DrawVOIP_VocInfo(pOneVOIP);
}
/* else
{
char mTemp[255]={0};
char mCurrTime[50]={0};
if (g_logfp != NULL)
{
getCurrTime(mCurrTime);
sprintf(mTemp,"%s,PSTNToVOIP Faile!!,m_s16DeviceMain=%d,m_s16DeviceSub=%d,m_s8ModuleID=%d,m_s8MachineID=%d,m_s16ChannelID=%d,m_s32FlowType=%d,m_s32FlowChannel=%d\r",
mCurrTime,
pVoipDev->m_s16DeviceMain,pVoipDev->m_s16DeviceSub,pVoipDev->m_s8ModuleID,
pVoipDev->m_s8MachineID,pVoipDev->m_s16ChannelID,
pVoipDev->m_CallID.m_s32FlowType,pVoipDev->m_CallID.m_s32FlowChannel);
fwrite(mTemp,strlen(mTemp),1,g_logfp);
}
// return ret;
}*/
return ret;
}
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;
}
void Logger::logMessage(const std::string& tag, const std::string& msg)
{
(*m_pLogStream) << '[' << getCurrTime() << ']' << tag << ' ' << msg << std::endl;
}
int main(){
printf("INICIO\n");
checkBusFileStructure();
char txt[] = "2013-03-01 00:00:00";
int ret;
if((ret = createTime_strtok(txt,&mindate))){
printf("Create time mindate Error %d\n",ret);
exit(1);
}
maxdate = getCurrTime();
FILE *fp= fopen("./avl15_21.txt","rb");
if(!fp){
printf("ARQUIVO NULO\n");
exit(0);
}
fseeko(fp, 0L, SEEK_END);
long long int EndScale = ftello(fp);
fseeko(fp, 0L, SEEK_SET);
printf("SIZE %lld \n",EndScale);
char *line_read = malloc(MAX_SIZE_LINE*sizeof(char));
fgets(line_read,MAX_SIZE_LINE,fp);//HEADER
int count=0;
int counterr=0;
double minlat,maxlat,minlon,maxlon;
minlat = 99999.99;
minlon = 99999.99;
maxlat = -99999.99;
maxlon = -99999.99;
int minbid=999999999;
int maxbid=-999999999;
int LINE_SMASK = 0x00008000;
int minLS1=999999999;
int minLS2=999999999;
int maxLS1=0;
int maxLS2=0;
time_t initime=getCurrTime();
printf("INI:%s\n",ctime(&initime));
while(fgets(line_read,MAX_SIZE_LINE,fp) ){
barraProgresso(ftello (fp),EndScale);
char *lineid_str = strtok(line_read, ",");
char *data_str = strtok(NULL, ",");
char *busid_str = strtok(NULL, ",");
char *lat_str = strtok(NULL, ",");
char *lon_str = strtok(NULL, ",");
char *dataavl_str = strtok(NULL, ",");
trim(dataavl_str);
trim(data_str);
time_t regdate;
if(ret = createTime_strtok(data_str,®date)){
printf("ERRO createTime_strtok em %s ret=%d\n",data_str,ret);
exit(1);
}
if( difftime(maxdate,regdate) < 0.0){
printf("ERRO data registro (max) %s \n",data_str);
printf("regdata %s \n",ctime(®date));
printf("maxdata %s \n",ctime(&maxdate));
exit(1);
}
if( difftime(regdate,mindate) < 0.0){
printf("ERRO data registro (min) %s \n",data_str);
printf("regdata %s \n",ctime(®date));
printf("mindate %s \n",ctime(&mindate));
exit(1);
}
int busid;
if(getIstr(busid_str,&busid)!=0){
printf("Erro conv busid_str %s \n",busid_str);
exit(1);
}
int lineid;
if(getIstr(lineid_str,&lineid)!=0){
printf("Erro conv lineid_str %s \n",lineid_str);
exit(1);
}
double lat;
if(getDstr(lat_str,&lat)!=0){
printf("Erro conv lat_str %s \n",lat_str);
exit(1);
}
double lon;
if(getDstr(lon_str,&lon)!=0){
printf("Erro conv lat_str %s \n",lon_str);
exit(1);
}
if(lat == 0.0 || lon ==0.0)
continue;
if(lat > maxlat)
maxlat=lat;
if(lon > maxlon)
maxlon=lon;
if(lat < minlat)
minlat=lat;
if(lon < minlon)
minlon=lon;
/*
Utilizando os limites da cidade de são paulo
*/
if(lat > -23.320819 || lat < -24.022634 || lon > -46.344452 || lon < -46.867676)
continue; // COORDENADAS FORA DA CIDADE DE SÃO PAULO
if(lineid & LINE_SMASK){//SENTIDO 2
if(lineid >maxLS2)
maxLS2=lineid;
if(lineid <minLS2)
minLS2=lineid;
}else{//SENTIDO 1
if(lineid >maxLS1)
maxLS1=lineid;
if(lineid <minLS1)
minLS1=lineid;
}
if( busid < minbid)
minbid=busid;
if( busid > maxbid);
maxbid=busid;
//utilizar esta função juntamente com a verificação inicial de checkBusFileStructure()
appendToBusfile(busid,lineid,regdate,lat,lon);
count++;
}
time_t fintime=getCurrTime();
printf("FIN:%s\n",ctime(&fintime));
printf("DIFF:%f\n", difftime(fintime,initime));
printf("lat %f %f\n",minlat,maxlat);
printf("lon %f %f\n",minlon,maxlon);
printf("minbid maxbid %d %d\n",minbid,maxbid);
printf("minLS1 maxLS1 %d %d\n",minLS1,maxLS1);
printf("minLS2 maxLS2 %d %d\n",minLS2,maxLS2);
printf("%d %d\n",count,counterr);
fclose(fp);
printf("FIM\n");
return 0;
}
int main(int argc, char* argv[])
{
if(argc != 3) { // Checks for argument
fprintf(stderr, "Invalid Argument: Exactly 2 argument needed\n");
printf("Usage: lyrebird.server <config file> <log file>\n");
exit(1);
} else {
/* ---------------------------- Preparation and environment set-up ----------------------------- */
/* ------ Open the config file, choose scheduling mode and start creating child processes ------ */
/* ------ Read pipe and start decryption in child processes ------------------------------------ */
FILE *configFile = fopen(argv[1], "r");
FILE *logFile = fopen(argv[2], "w");
if( configFile == NULL ) {
fprintf(stderr, "Error: config file does not exist.\n");
exit(1);
}
else if( logFile == NULL ) {
fprintf(stderr, "Error: log file opening failed.\n");
exit(1);
} else {
// Creating socket
int sockfd = socket(AF_INET, SOCK_STREAM, 0);
if(sockfd < 0) {
fprintf(stderr, "Error: opening socket failed.\n");
exit(1);
}
// Gets the IP address structure of the current computer
struct sockaddr *s_addr;
struct ifaddrs *IPConfig, *IPConfig_temp;
getifaddrs( &IPConfig );
bool done = false;
// Loop through IPConfig to find the correct structure then assign to pointer *s_addr
for( IPConfig_temp = IPConfig; IPConfig_temp && !done; IPConfig_temp = IPConfig_temp->ifa_next ) {
s_addr = IPConfig_temp->ifa_addr;
// Find the IP address that belongs to AP_INET and also ignore "127.0.0.1"
if( strcmp( inet_ntoa( ((struct sockaddr_in *)s_addr)->sin_addr ), "127.0.0.1") != 0 &&
s_addr->sa_family == AF_INET )
done = true;
}
freeifaddrs( IPConfig );
// Bind the socket to address of current computer
if( bind(sockfd, s_addr, sizeof(struct sockaddr)) == -1 )
printf("Bind error!\n");
// Start listening from the port
if( listen(sockfd, LISTEN_BACKLOG) == -1 )
printf("listen error!\n");
// Updates the sockaddr structure to find out which port the computer is listening to
struct sockaddr_in s_in_addr;
socklen_t len = sizeof(s_in_addr);
getsockname( sockfd, (struct sockaddr *)&s_in_addr, &len );
// Prints out info like address and port of the current lyrebird.server
printf( "[%s] lyrebird.server: PID %d on host %s, port %d\n",
getCurrTime(), getpid(), inet_ntoa(s_in_addr.sin_addr), ntohs(s_in_addr.sin_port) );
/* ------------------------------- Reading config file process ------------------------------- */
fd_set sockfd_set;
// Setting select timeout for 10 ms.
struct timeval timeout;
timeout.tv_sec = 0;
timeout.tv_usec = 200;
int clientfd[100];
char *client_addr[100];
int clientIndex = 0;
char line[MAX_CONFIGLINE_SIZE];
// Read config file line by line. Exits when reaches EOF.
while( fgets(line, MAX_CONFIGLINE_SIZE, configFile) != NULL )
{
// Arrays that store the input and output file location
char input[MAX_CONFIGLINE_SIZE];
char output[MAX_CONFIGLINE_SIZE];
// Processing input and output file to prepare for writing to client.
// If there is error in the config file, we skip the current iteration.
if( getInOutPath(line, input, output) == -1 ) {
fprintf(stderr, "Invalid Argument: Exactly 2 argument expected for each line in config file.\n");
continue;
}
do {
FD_ZERO(&sockfd_set);
FD_SET(sockfd, &sockfd_set);
select(sockfd + 1, &sockfd_set, NULL, NULL, &timeout);
if( FD_ISSET(sockfd, &sockfd_set) ) {
// Accepting connections from the Internet
clientfd[clientIndex] = accept(sockfd, (struct sockaddr *)&s_in_addr, &len);
if(clientfd[clientIndex] >= 0) {
client_addr[clientIndex] = inet_ntoa(s_in_addr.sin_addr);
// Print out client information
fprintf(logFile, "[%s] Successfully connected to lyrebird client %s\n",
getCurrTime(), client_addr[clientIndex] );
clientIndex++;
}
}
} while(clientIndex == 0);
fd_set clientfd_set;
FD_ZERO(&clientfd_set);
for(int i = 0; i < clientIndex; i++)
FD_SET(clientfd[i], &clientfd_set);
select(clientfd[clientIndex - 1] + 1, &clientfd_set, NULL, NULL, &timeout);
// check if there is a socket that is readable
char client_message[1100];
for(int i = 0; i < clientIndex; i++) {
memset(client_message, 0, 1100);
if( FD_ISSET(clientfd[i], &clientfd_set) ) {
read(clientfd[i], client_message, 1100);
if( strcmp(client_message, "Ready") != 0)
fprintf(logFile, "[%s] The lyrebird client %s %s",
getCurrTime(), client_addr[i], client_message);
}
}
// check if there is a socket that is writable
bool assigned = false;
while(!assigned) {
FD_ZERO(&clientfd_set);
for(int i = 0; i < clientIndex; i++)
FD_SET(clientfd[i], &clientfd_set);
select(clientfd[clientIndex - 1] + 1, NULL, &clientfd_set, NULL, &timeout);
for(int i = 0; i < clientIndex && !assigned ; i++)
if( FD_ISSET(clientfd[i], &clientfd_set) ) {
write(clientfd[i], input, 1024);
write(clientfd[i], output, 1024);
fprintf(logFile, "[%s] The lyrebird client %s has been given the task of decrypting %s.\n",
getCurrTime(), client_addr[i], input);
assigned = true;
}
}
}
printf("End of while loop.\n");
/* ---------------------------- End of scheduling Algorithms --------------------------- */
// Writes "Exit" command to child and once receiving "Exited" status that means a child has exited
for(int i = 0; i < clientIndex ; i++)
write(clientfd[i], "Exit", 4);
// Read messages from client until EOF. When EOF, this indicates the client has closed
// the socket and exited successfully.
char client_message[1100];
int remainClient = clientIndex;
while(remainClient > 0)
for(int i = 0; i < clientIndex; i++) {
memset(client_message, 0, 1100);
int readSize = read(clientfd[i], client_message, 1100);
if( readSize == 0 )
remainClient--;
else if( strcmp(client_message, "Ready") != 0)
fprintf(logFile, "[%s] The lyrebird client %s %s",
getCurrTime(), client_addr[i], client_message);
}
for(int i = 0; i < clientIndex; i++)
close(clientfd[i]);
printf("[%s] lyrebird.server: PID %d completed its tasks and is exiting successfully.\n",
getCurrTime(), getpid() );
}
}
return 0;
}
void Timer::end()
{
mEndTime = getCurrTime();
}
void Timer::start()
{
mStartTime = getCurrTime();
}
