void hw_ActivateHS()
{
HWinterfaceReqType hwreq;
hwreq.Primitive = HW_interface_req;
hwreq.CtrlCmd = ActivateHS_req;
hwreq.CtrlValue = 0;/*not used.*/
macLink.sendMailToMac((MailType *) &hwreq, sizeof(HWinterfaceReqType), 0, 0, 4);
_sprintf_(StatusString, "hw_ActivateHS");
PrintStatus(0, StatusString);
}
static void PPAlreadySubscribedHandler(SignalType * Signal)
{
switch (Signal->Event)
{
case IWU_PRIMITIVE:
{
switch (Signal->SubEvent)
{
case OM_SUBS_SELECT_cfm:
{
OmSubsSelectCfmType *OmSubsSelectCfm = (OmSubsSelectCfmType *) Signal;
if (OmSubsSelectCfm->NotAccepted) {
PrintStatus(0, "Login to subscribed base failed!");
}
}
break;
case OM_SUBS_STATUS_ind:
{
OmSubsStatusIndType *OmSubsStatusInd = (OmSubsStatusIndType *) Signal;
if (OmSubsStatusInd->Status & SS_LocRegSucceeded) {
PrintStatus(0, "Login to subscribed base completed");
} else if (OmSubsStatusInd->Status & SS_Locked) {
PrintStatus(0, "Locked to subscribed base");
} else if (OmSubsStatusInd->Status & SS_Subscripted) {
_sprintf_(StatusString, "Subscription number [%02x]", OmSubsStatusInd->SubsNo);
PrintStatus(0, StatusString);
}
}
break;
case OM_ATTACH_ind:
{
OmAttachIndType * OmAttachInd = (OmAttachIndType *) Signal;
IwuToIwuType * IwuToIwuPtr;
IwuToIwuPtr = (IwuToIwuType *) FindInfoElement(IwuToIwuId, getOmAttachIndTypeIE(OmAttachInd) - 2, OmAttachInd->SignalHeader.SignalLength - sizeof(OmAttachIndType) + 2);
if (IwuToIwuPtr != NULL) {
if (IwuToIwuPtr->ProtocolDiscrim == UserSpecific && IwuToIwuPtr->DiscrimType == UseOfEmc) {
StandByTxtIEType *standbyText = (StandByTxtIEType *) FindInfoElement(StandByTxtAPEIEId, getIwuToIwuSIE(IwuToIwuPtr) - 2, OmAttachInd->SignalHeader.SignalLength - sizeof(OmAttachIndType) - sizeof(IwuToIwuType) + 2);
if (standbyText) {
memcpy(StatusString, standbyText->StandByTxt, standbyText->LengthOfContents);
StatusString[standbyText->LengthOfContents] = '\0';
PrintStatus(0, StatusString);
}
}
}
setSignalHandler(APPLICATION_PROCESS_ID_PP, PPLockedHandler, 0);
}
}
}
break;
}
DeleteBuffer(Signal);
}
void at_data_from_msf(char command,UByte * data, UByte length)
{
_sprintf_(StatusString,"at handler.msf: %x",command);
PrintStatus(0,StatusString);
switch (command)
{
case 'a':
case 'A':/*answer*/
{
if (state == AT_DIAL_REQ)
{
state = AT_BINARY;
enter_binary_mode();
serprintf232("\r\nCONNECT\r\n");
}
}break;
case 'd':
case 'D':/*dial*/
{
if (state == AT_IDLE)
{
serprintf232("\r\nRING\r\n");
state = AT_DIAL_REQ;
}
}break;
case 'h':
case 'H':/*hangup*/
{
if (state == AT_BINARY)
{
sendMsfAtCmd('H');
leave_binary_mode();
state = AT_IDLE;
}
}break;
case 'b':
case 'B':/*binary*/
{
if (state == AT_BINARY)
{
sendTestResponse((char*)data,length);
}
}break;
}
}
void at_data_from_rs232(char command,UByte * data, UByte length)
{
_sprintf_(StatusString,"at handler.232: %x",command);
PrintStatus(0,StatusString);
switch (command)
{
case 'A':/*answer*/
{
if (state == AT_DIAL_REQ)
{
state = AT_BINARY;
sendMsfAtCmd('a');
enter_binary_mode();
serprintf232("\r\nOK\r\n");
}
}break;
case 'd':
case 'D':/*dial*/
{
if (state == AT_IDLE)
{
sendMsfAtCmd('d');
state = AT_DIAL_REQ;
}
}break;
case 'h':
case 'H':/*hangup*/
{
if (state == AT_BINARY_TERMINATED)
{
state = AT_IDLE;
sendMsfAtCmd('h');
serprintf232("\r\nOK\r\n");
}
}break;
case 'b':
case 'B':/*binary*/
{
if (state == AT_BINARY)
{
int cnt;
char result[255];
result[0] = 'b';
for (cnt=0;cnt<length;cnt++)
result[cnt+1] = data[cnt];
SendPPStatusInd(0x12,(BYTE*)result,length+1);
}
}break;
case 's':/*status*/
{
_sprintf_(StatusString,"State: %x",state);
serprintf232(StatusString);
}break;
case '+':/*leave binary*/
{
if (state == AT_BINARY)
{
state = AT_BINARY_TERMINATED;
serprintf232("\r\nOK\r\n");
}
}break;
case 'O':/*Open binary data again*/
{
if (state == AT_BINARY_TERMINATED) {
state = AT_BINARY;
enter_binary_mode();
}
}
break;
case 'E':/*Echo*/
{
AT_echo = *data - 0x30; /*Convert from ascii*/
serprintf232("\r\nOK\r\n");
}
break;
}
}
void ApplicationSignalHandler_FP(SignalType * TheSignal)
{
ApplicationInstanceType * applicationInstanceData;
if (common_signalHander(TheSignal)) {
return;
}
if (TheSignal->Event == INITIALIZE_EVENT) {
InitializeTreeTop(&applicationTree, sizeof(PMIDType));
DeleteBuffer(TheSignal);
fp_system_init();
return;
}
applicationInstanceData = getApplicationInstance(TheSignal->Address);
switch (TheSignal->Event)
{
case APPLICATION_PRIMITIVE:
{
switch (TheSignal->SubEvent)
{
case APPCCSetupInd:
{
handleAPPCCSetupInd(TheSignal, applicationInstanceData);
}
break;
case APPCCInfoInd:
{
handleAPPCCInfoInd(TheSignal, applicationInstanceData);
}
break;
case APPCCAbnormal:
{
if (applicationInstanceData) {
PrintStatus(0, "abnormal release in application, user found");
handleReleasePrim(TheSignal, applicationInstanceData);
} else {
_sprintf_(StatusString, "abnormal %x %x %x %x", TheSignal->Address[0], TheSignal->Address[1], TheSignal->Address[2], TheSignal->Address[3]);
PrintStatus(0, StatusString);
}
}
break;
case 0x86:
{
UByte * data = getSignalData(TheSignal);
fp_module2module_ack_received(PMID2PPID(TheSignal->Address), &data[1]);
}
break;
case SS_MSF_prim:
{
UByte *messageData;
UByte DestinationIdLenght;
UByte *DestinationId;
UByte DisplaytextLength;
UByte *DisplayText;
UByte CallBackNumberLength;
UByte *CallBackNumber;
UByte SSAAAD[SSAAADLength];
int index, count;
APPMSFind* appMSFind = (APPMSFind*) TheSignal;
char* tmp;
index = 0;
messageData = getAPPMSFindIE(appMSFind);
DestinationIdLenght = messageData[index++];
DestinationId = (UByte*) mem_malloc(DestinationIdLenght + 1, 0x42);
for (count = 0; count < DestinationIdLenght; count++) {
DestinationId[count] = messageData[index++];
}
DestinationId[count] = '\0';
DisplaytextLength = messageData[index++];
DisplayText = (UByte*) mem_malloc(DisplaytextLength + 1, 0x42);
for (count = 0; count < DisplaytextLength; count++) {
DisplayText[count] = messageData[index++];
}
DisplayText[count] = '\0';
CallBackNumberLength = messageData[index++];
CallBackNumber = (UByte*) mem_malloc(CallBackNumberLength + 1, 0x42);
for (count = 0; count < CallBackNumberLength; count++) {
CallBackNumber[count] = messageData[index++];
}
CallBackNumber[count] = '\0';
memcpy(&SSAAAD[0], &messageData[index], SSAAADLength);
tmp = StatusString;
tmp = StringPrint(tmp, "MSF: [");
tmp = StringPrint(tmp, (char*) DisplayText);
tmp = StringPrint(tmp, "] from [");
tmp = StringPrint(tmp, (char*) CallBackNumber);
tmp = StringPrint(tmp, "] to [");
tmp = StringPrint(tmp, (char*) DestinationId);
tmp = StringPrint(tmp, "]");
PrintStatus(0, StatusString);
if (strlen((char*) DisplayText) == 1) {
if ((DisplayText[0] >= '0') && (DisplayText[0] <= '9')) {
char * ptr = StringPrint(StatusString, "Dialing: ");
UByte receiver = DisplayText[0] - '0';
ptr = StrPrintHexByte(ptr, receiver);
PrintStatus(0, StatusString);
/*callUser((char*) DisplayText, 0, "Call from FP");*/
}
}
msf_outgMessageIndReceived(PMID2PPID(TheSignal->Address), SSAAAD[0], SSAAAD[1], SSAAAD[2], SSAAAD[3], SSAAAD[4], SSAAAD[5], (char*) DestinationId, (char*) DisplayText, PMID2PPID(TheSignal->Address));
mem_free(DestinationId);
mem_free(DisplayText);
mem_free(CallBackNumber);
}
break;
}
}
break;
case IWU_PRIMITIVE:
{
switch (TheSignal->SubEvent)
{
case CC_ALERTING_prim:
{
if (applicationInstanceData != NULL) {
voice_incommingCallAlerting(PMID2PPID(applicationInstanceData->pmid), applicationInstanceData->connectedTo);
}
PrintStatus(0, "Application: alerting....\n");
}
break;
case CC_CONNECT_prim:
{
extern void setupvoice(PPIDType a, PPIDType b);
setupvoice(PMID2PPID(applicationInstanceData->pmid), applicationInstanceData->connectedTo);
PrintStatus(0, "fp_application: CC_CONNECT_prim");
handleConnectPrim(TheSignal->Address, applicationInstanceData);
voice_callConnected(PMID2PPID(applicationInstanceData->pmid), applicationInstanceData->connectedTo);
}
break;
case CC_RELEASE_prim:
{
ApplicationInstanceType * wasConnectedTo;
PPID2PMID(&tmpPmid, applicationInstanceData->connectedTo);
wasConnectedTo = getApplicationInstance(tmpPmid);
wasConnectedTo->connectedTo = 0xffff;
voice_callDisconnected(PMID2PPID(applicationInstanceData->pmid), applicationInstanceData->connectedTo, 0x00);
handleReleasePrim(TheSignal, applicationInstanceData);
}
break;
};
}
break;
case APP_SS_PRIMITIVE:
{
switch (TheSignal->SubEvent)
{
case SIO_MSF_SETUP_req: /*from serial / ip*/
{
}
break;
case SIO_MSF_SETUP_ind: /*from pp*/
{
applicationInstanceData->msfState = msf_session_requested_from_pp;
msf_msfsetupIndReceived(PMID2PPID(TheSignal->Address), (char*) getSignalData(TheSignal));
}
break;
case SIO_MSF_CONNECT_res:
{
/*SioMsfConnectResType *SioMsfConnectRes = (SioMsfConnectResType *) TheSignal;*/
}
break;
case SIO_MSF_CONNECT_cfm:
{
msf_connectCfmReceived(PMID2PPID(TheSignal->Address));
}
break;
case SIO_MSF_INFO_ind:
{
msf_infoIndReceived(PMID2PPID(TheSignal->Address), getSignalData(TheSignal)[0]);
}
break;
case SIO_MSF_INFO_req:
{
/*SioMsfInfoReqType *SioMsfInfoReq = (SioMsfInfoReqType *) TheSignal;*/
}
break;
case SIO_MSF_RELEASE_req:
{
/*SioMsfReleaseReqType *SioMsfReleaseReq = (SioMsfReleaseReqType *) TheSignal;*/
}
break;
case SIO_MSF_RELEASE_ind:
{
applicationInstanceData->msfState = msf_idle;
msf_releaseIndReceived(PMID2PPID(applicationInstanceData->pmid), getSignalData(TheSignal)[0]);
}
break;
case SIO_MSF_OUTG_MESSAGE_ind:
{
}
break;
case SIO_PP_STATUS_req:
{
/*SioPpStatusReadReqType *SioPpStatusReq = (SioPpStatusReadReqType *) TheSignal;*/
/*int i = 0;*/
}
break;
case SIO_PP_STATUS_ind:
{
SioPpStatusIndType *SioPpStatusInd;
SioPpStatusInd = (SioPpStatusIndType*) TheSignal;
msf_ppstatus_ind_received(PMID2PPID(applicationInstanceData->pmid), SioPpStatusInd->StatusType, getSioPpStatusIndTypeIE(SioPpStatusInd), SioPpStatusInd->SignalHeader.SignalLength
- offsetof(SioPpStatusIndType,StatusType) - 1);
}
break;
}
}
break;
case TIME_OUT_EVENT:
{
TimerType * timerPtr = (TimerType*) TheSignal;
PMIDType pmid;
UByte dataLength = TheSignal->SignalLength - timerSize();
PPID2PMID(&pmid, (PPIDType) -1);
if (memcmp(TheSignal->Address, pmid, sizeof(PMIDType)) != 0) {
getApplicationInstance(TheSignal->Address)->timer = NULL;
}
fp_general_timeout(PMID2PPID(TheSignal->Address), TheSignal->SubEvent, getTimerData(timerPtr), dataLength);
}
break;
};
DeleteBuffer(TheSignal);
}
void at_data_from_rs232(char command,UByte * data, UByte length)
{
_sprintf_(StatusString,"at handler.232: %x",command);
PrintStatus(0,StatusString);
switch (command)
{
case 'A':/*answer*/
{
if (state == AT_DIAL_REQ)
{
state = AT_BINARY;
enter_binany_mode();
serprintf232("CONNECTED");
}
}break;
case 'd':
case 'D':/*dial*/
{
if (state == AT_IDLE)
{
serprintf232("RING");
state = AT_DIAL_REQ;
/*sendMsfAtCmd('A');*/
/*state = AT_BINARY;*/
}
/*sendMsfAtCmd('A');*/
/*state = AT_BINARY;*/
}break;
case 'h':
case 'H':/*hangup*/
{
if (state == AT_BINARY_TERMINATED)
{
state = AT_IDLE;
serprintf232("OK\n");
}
}break;
case 'b':
case 'B':/*binary*/
{
if (state == AT_BINARY)
{
int cnt;
char result[255];
result[0] = 'b';
for (cnt=0;cnt<length;cnt++)
result[cnt+1] = data[cnt];
SendPPStatusInd(0x12,(BYTE*)result,length+1);
}
}break;
case 's':/*status*/
{
_sprintf_(StatusString,"State: %x",state);
serprintf232(StatusString);
}break;
case '+':/*leave binary*/
{
if (state == AT_BINARY)
{
state = AT_BINARY_TERMINATED;
}
}break;
}
}
