931 lines
24 KiB
C
931 lines
24 KiB
C
/* XAP provider interface c file */
|
|
/* Written by Liu Zhiguo 2003-08-26 */
|
|
/* Version 1.0 */
|
|
/* -------------------------------- */
|
|
|
|
#include "../../public/src/include/public.h"
|
|
#include "../../public/src/include/license_id.h"
|
|
#include "../../tcap/src/include/itcap.h"
|
|
#include "../../tcap/src/include/idmanage.h"
|
|
#include "xap_provider.h"
|
|
#include "xap_monitor.h"
|
|
#include "mapp/map_public.h"
|
|
#include "capp/cap_public.h"
|
|
|
|
int xap_mscid_to_num ( u8 * mscid, u8 ssn, u8 * num )
|
|
{
|
|
int i;
|
|
|
|
for ( i = 0; i < 256; i++ )
|
|
{
|
|
if( ( memcmp ( mscid, xap_inter_ptr->mscidToNum[i], 3 ) == 0 ) && ( xap_inter_ptr->mscidToNum[i][3] == ssn ) )
|
|
{
|
|
memcpy ( num, xap_inter_ptr->mscidToNum[4], 10 );
|
|
return 1;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
void xap_get_mcc ( u8 * mcc )
|
|
{
|
|
memcpy ( mcc, xap_inter_ptr->mcc, 2 );
|
|
}
|
|
|
|
void xap_get_mnc ( u8 * mnc )
|
|
{
|
|
memcpy ( mnc, &xap_inter_ptr->mnc, 2 );
|
|
}
|
|
|
|
void xap_get_cc ( u8 * cc )
|
|
{
|
|
memcpy ( cc, xap_inter_ptr->cc, 2 );
|
|
}
|
|
|
|
void xap_get_ndc ( u8 * ndc )
|
|
{
|
|
memcpy ( ndc, xap_inter_ptr->ndc, 3 );
|
|
}
|
|
|
|
void xap_get_interprefix ( u8 * inter_prefix )
|
|
{
|
|
memcpy ( inter_prefix, xap_inter_ptr->inter_prefix, 2 );
|
|
}
|
|
|
|
void xap_get_nationalprefix ( u8 * national_prefix )
|
|
{
|
|
memcpy ( national_prefix, xap_inter_ptr->national_prefix, 2 );
|
|
}
|
|
|
|
void xap_get_localprefix ( u8 * local_prefix )
|
|
{
|
|
memcpy ( local_prefix, xap_inter_ptr->local_prefix, 2 );
|
|
}
|
|
|
|
int imap_reg_ssn ( u8 ssn )
|
|
{
|
|
u8 ii, jj;
|
|
|
|
ii = xap_inter_ptr->regssn_len;
|
|
if( ii >= MAX_XAP_SSN )
|
|
{
|
|
xap_send_error ( "Can not register ssn in map provider" );
|
|
return -1;
|
|
}
|
|
for ( jj = 0; jj < ii; jj++ )
|
|
{
|
|
if( xap_inter_ptr->reg_ssn[jj] == ssn )
|
|
{
|
|
xap_send_error ( "ssn has registered in map provider" );
|
|
return -1;
|
|
}
|
|
}
|
|
xap_inter_ptr->reg_ssn[ii] = ssn;
|
|
xap_inter_ptr->regssn_flag[ii] = XAP_MAP_SSN;
|
|
xap_inter_ptr->regssn_len++;
|
|
return itcap_reg_ssn ( ssn );
|
|
}
|
|
|
|
u8 map_check_sendcom ( u32 did )
|
|
{
|
|
struct xapp_vm_data *vm_ptr;
|
|
|
|
if( did >= ( xap_vm_ptr->grantdid ) )
|
|
return 0;
|
|
vm_ptr = ( xapp_vm_data * ) & xap_vm_ptr->xap_data[did];
|
|
if( vm_ptr->recvcom_flag == 0 )
|
|
return 1;
|
|
return 0;
|
|
}
|
|
|
|
u8 map_send_comdata_struct ( MapComSrv_struct * map_com ) // send map common service data
|
|
{
|
|
u32 temp_did;
|
|
struct xapp_vm_data *vm_ptr;
|
|
struct psmvm_data *psm_ptr;
|
|
|
|
if( xap_vm_ptr->debug_data.send_control )
|
|
{
|
|
u8 data_flow[512];
|
|
|
|
map_com_stof ( map_com, data_flow, 1 );
|
|
xap_send_error ( "[%d]Sending Com:%d in Structure", map_com->dialogue_id, map_com->message_type );
|
|
xap_msg_display ( data_flow );
|
|
}
|
|
|
|
temp_did = map_com->dialogue_id;
|
|
if( temp_did >= ( xap_vm_ptr->grantdid ) )
|
|
{
|
|
xap_send_error ( "[%d]Com:%d sending did error", temp_did, map_com->message_type );
|
|
return 0;
|
|
}
|
|
vm_ptr = ( xapp_vm_data * ) & xap_vm_ptr->xap_data[temp_did];
|
|
if( ( vm_ptr->recvcom_flag == 1 ) && ( map_com->message_type != MAP_U_ABORT ) ) /* daniel change on 2005-4-29 */
|
|
{
|
|
xap_send_error ( "[%d]Com:%d sending without permit", temp_did, map_com->message_type );
|
|
return 0;
|
|
}
|
|
psm_ptr = ( psmvm_data * ) & vm_ptr->psm_data;
|
|
// if (result == 2 || map_com->message_type == MAP_DELIMITER)
|
|
psm_ptr->delimiter_flag = 1;
|
|
if( map_com->message_type != MAP_DELIMITER )
|
|
{
|
|
memcpy ( &vm_ptr->recvcom_data, map_com, sizeof ( MapComSrv_struct ) );
|
|
psm_ptr->msg_type = map_com->message_type;
|
|
psm_ptr->msg_flag = map_com->message_flag;
|
|
vm_ptr->recvcom_flag = 1;
|
|
xap_watch_dog(27);
|
|
}
|
|
xap_watch_dog(25);
|
|
return 1;
|
|
}
|
|
|
|
u8 map_send_comdata ( u8 * data_flow ) // send map common service data
|
|
{
|
|
u8 result;
|
|
u32 temp_did;
|
|
struct xapp_vm_data *vm_ptr;
|
|
struct psmvm_data *psm_ptr;
|
|
struct MapComSrv_struct map_com;
|
|
|
|
xap_msg_display ( data_flow );
|
|
if( ( result = map_com_ftos ( &map_com, data_flow ) ) == 0 )
|
|
{
|
|
xap_send_error ( "[%d]Com:%d sending translate error", map_com.dialogue_id, map_com.message_type );
|
|
return 0;
|
|
}
|
|
temp_did = map_com.dialogue_id;
|
|
if( temp_did >= ( xap_vm_ptr->grantdid ) )
|
|
{
|
|
xap_send_error ( "[%d]Com:%d sending did error", temp_did, map_com.message_type );
|
|
return 0;
|
|
}
|
|
vm_ptr = ( xapp_vm_data * ) & xap_vm_ptr->xap_data[temp_did];
|
|
if( ( vm_ptr->recvcom_flag == 1 ) && ( map_com.message_type != MAP_U_ABORT ) ) /* daniel change on 2005-4-29 */
|
|
{
|
|
xap_send_error ( "[%d]Com:%d sending without permit", temp_did, map_com.message_type );
|
|
return 0;
|
|
}
|
|
psm_ptr = ( psmvm_data * ) & vm_ptr->psm_data;
|
|
if( result == 2 || map_com.message_type == MAP_DELIMITER )
|
|
{
|
|
if (result == 2)
|
|
xap_watch_dog(64);
|
|
else
|
|
xap_watch_dog(65);
|
|
psm_ptr->delimiter_flag = 1;
|
|
}
|
|
if( map_com.message_type != MAP_DELIMITER )
|
|
{
|
|
memcpy ( &vm_ptr->recvcom_data, &map_com, sizeof ( MapComSrv_struct ) );
|
|
psm_ptr->msg_type = map_com.message_type;
|
|
psm_ptr->msg_flag = map_com.message_flag;
|
|
vm_ptr->recvcom_flag = 1;
|
|
xap_watch_dog(28);
|
|
}
|
|
xap_watch_dog(25);
|
|
return 1;
|
|
}
|
|
|
|
u8 map_check_sendopr ( u32 did )
|
|
{
|
|
struct xapp_vm_data *vm_ptr;
|
|
|
|
if( did >= ( xap_vm_ptr->grantdid ) )
|
|
return 0;
|
|
vm_ptr = ( xapp_vm_data * ) & xap_vm_ptr->xap_data[did];
|
|
if( vm_ptr->recvopr_flag == 1 )
|
|
return 0;
|
|
return 1;
|
|
}
|
|
|
|
u8 map_send_oprdata ( u8 * data_flow ) // send map operation service data
|
|
{
|
|
u8 result;
|
|
u32 temp_did;
|
|
struct xapp_vm_data *vm_ptr;
|
|
struct MapOprData_struct map_opr;
|
|
|
|
//xap_msg_display ( data_flow );
|
|
if( ( result = map_opr_ftos ( &map_opr, data_flow ) ) == 0 )
|
|
{
|
|
xap_send_error ( "[%d]Opr:%d sending translate error", map_opr.dialogue_id, map_opr.message_type );
|
|
return 0;
|
|
}
|
|
temp_did = map_opr.dialogue_id;
|
|
if( temp_did >= ( xap_vm_ptr->grantdid ) )
|
|
{
|
|
xap_send_error ( "[%d]Opr:%d sending did error", temp_did, map_opr.message_type );
|
|
return 0;
|
|
}
|
|
vm_ptr = ( xapp_vm_data * ) & xap_vm_ptr->xap_data[temp_did];
|
|
if( vm_ptr->recvopr_flag == 1 )
|
|
{
|
|
xap_send_error ( "[%d]Opr:%d sending without permit", temp_did, map_opr.message_type );
|
|
return 0;
|
|
}
|
|
xap_msg_display ( data_flow );
|
|
memcpy ( &vm_ptr->recvopr_data, &map_opr, sizeof ( MapOprData_struct ) );
|
|
if( result == 2 )
|
|
{
|
|
vm_ptr->psm_data.delimiter_flag = 1;
|
|
xap_watch_dog(68);
|
|
}
|
|
vm_ptr->recvopr_flag = 1;
|
|
xap_watch_dog(45);
|
|
xap_watch_dog(47);
|
|
if(map_opr.message_type == SndRoutInfo)
|
|
{
|
|
if(map_opr.message_flag == 1)
|
|
{
|
|
xap_watch_dog(16);
|
|
}
|
|
else
|
|
{
|
|
xap_watch_dog(17);
|
|
}
|
|
}
|
|
else if(map_opr.message_type == ProvRoamNum)
|
|
{
|
|
if(map_opr.message_flag == 1)
|
|
{
|
|
xap_watch_dog(20);
|
|
}
|
|
else
|
|
{
|
|
xap_watch_dog(21);
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
u8 map_send_oprdata_struct ( MapOprData_struct * map_opr ) // send map operation service data
|
|
{
|
|
u32 temp_did;
|
|
struct xapp_vm_data *vm_ptr;
|
|
|
|
// struct MapOprData_struct map_opr;
|
|
|
|
temp_did = map_opr->dialogue_id;
|
|
if( temp_did >= ( xap_vm_ptr->grantdid ) )
|
|
{
|
|
xap_send_error ( "[%d]Opr:%d sending did error", temp_did, map_opr->message_type );
|
|
return 0;
|
|
}
|
|
vm_ptr = ( xapp_vm_data * ) & xap_vm_ptr->xap_data[temp_did];
|
|
|
|
if( xap_vm_ptr->debug_data.send_control )
|
|
{
|
|
u8 data_flow[512];
|
|
|
|
map_opr_stof ( map_opr, data_flow, 1 );
|
|
xap_send_error ( "[%d]Sending Opr:%d in Structure ", map_opr->dialogue_id, map_opr->message_type );
|
|
xap_msg_display ( data_flow );
|
|
}
|
|
if( vm_ptr->recvopr_flag == 1 )
|
|
{
|
|
xap_send_error ( "[%d]Opr:%d sending without permit", temp_did, map_opr->message_type );
|
|
return 0;
|
|
}
|
|
memcpy ( &vm_ptr->recvopr_data, map_opr, sizeof ( MapOprData_struct ) );
|
|
// if (result == 2)
|
|
vm_ptr->psm_data.delimiter_flag = 1;
|
|
vm_ptr->recvopr_flag = 1;
|
|
xap_watch_dog(45);
|
|
xap_watch_dog(48);
|
|
if(map_opr->message_type == SndRoutInfo)
|
|
{
|
|
if(map_opr->message_flag == 1)
|
|
{
|
|
xap_watch_dog(16);
|
|
}
|
|
else
|
|
{
|
|
xap_watch_dog(17);
|
|
}
|
|
}
|
|
else if(map_opr->message_type == ProvRoamNum)
|
|
{
|
|
if(map_opr->message_flag == 1)
|
|
{
|
|
xap_watch_dog(20);
|
|
}
|
|
else
|
|
{
|
|
xap_watch_dog(21);
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
u8 map_get_comdata ( u8 * data_flow, u32 did )
|
|
{
|
|
struct xapp_vm_data *vm_ptr;
|
|
struct psmvm_data *psm_ptr;
|
|
|
|
vm_ptr = ( xapp_vm_data * ) & xap_vm_ptr->xap_data[did];
|
|
if( vm_ptr->sendcom_flag == 0 )
|
|
return 0;
|
|
psm_ptr = ( psmvm_data * ) & vm_ptr->psm_data;
|
|
map_com_stof ( &vm_ptr->sendcom_data, data_flow, 0 );
|
|
vm_ptr->sendcom_flag = 0;
|
|
xap_watch_dog(6);
|
|
xap_watch_dog(7);
|
|
xap_msg_display ( data_flow );
|
|
return 1;
|
|
}
|
|
|
|
u8 map_get_comdata_struct ( MapComSrv_struct * map_com, u32 did )
|
|
{
|
|
struct xapp_vm_data *vm_ptr;
|
|
struct psmvm_data *psm_ptr;
|
|
|
|
vm_ptr = ( xapp_vm_data * ) & xap_vm_ptr->xap_data[did];
|
|
if( vm_ptr->sendcom_flag == 0 )
|
|
return 0;
|
|
psm_ptr = ( psmvm_data * ) & vm_ptr->psm_data;
|
|
memcpy ( map_com, &vm_ptr->sendcom_data, sizeof ( struct MapComSrv_struct ) );
|
|
if( xap_vm_ptr->debug_data.send_control )
|
|
{
|
|
u8 data_flow[512];
|
|
|
|
map_com_stof ( map_com, data_flow, 0 );
|
|
xap_msg_display ( data_flow );
|
|
}
|
|
vm_ptr->sendcom_flag = 0;
|
|
xap_watch_dog(6);
|
|
xap_watch_dog(8);
|
|
return 1;
|
|
}
|
|
|
|
u8 map_get_open ( u8 * data_flow, u8 ssn )
|
|
{
|
|
u8 aa;
|
|
u8 ii;
|
|
u8 flag = 0;
|
|
u32 temp_did;
|
|
|
|
for ( aa = 0; aa < xap_inter_ptr->regssn_len; aa++ )
|
|
{
|
|
if( xap_inter_ptr->reg_ssn[aa] == ssn ) // find ssn
|
|
{
|
|
flag = 1;
|
|
break;
|
|
}
|
|
}
|
|
if( flag == 0 )
|
|
{
|
|
xap_send_error ( "SSN--%d is not registerd", ssn );
|
|
return 0;
|
|
}
|
|
ii = xap_inter_ptr->open_tail[aa];
|
|
if( xap_inter_ptr->open_head[aa] == ii ) // empty
|
|
return 0;
|
|
temp_did = xap_inter_ptr->open_did[aa][ii];
|
|
xap_inter_ptr->open_tail[aa] = ( ii + 1 ) % XAP_OPEN_LEN;
|
|
if( !map_get_comdata ( data_flow, temp_did ) )
|
|
return 0;
|
|
return 1;
|
|
}
|
|
|
|
u8 map_get_open_struct ( MapComSrv_struct * map_com, u8 ssn )
|
|
{
|
|
u8 aa;
|
|
u8 ii;
|
|
u8 flag = 0;
|
|
u32 temp_did;
|
|
|
|
for ( aa = 0; aa < xap_inter_ptr->regssn_len; aa++ )
|
|
{
|
|
if( xap_inter_ptr->reg_ssn[aa] == ssn ) // find ssn
|
|
{
|
|
flag = 1;
|
|
break;
|
|
}
|
|
}
|
|
if( flag == 0 )
|
|
{
|
|
xap_send_error ( "SSN--%d is not registerd", ssn );
|
|
return 0;
|
|
}
|
|
ii = xap_inter_ptr->open_tail[aa];
|
|
if( xap_inter_ptr->open_head[aa] == ii ) // empty
|
|
return 0;
|
|
temp_did = xap_inter_ptr->open_did[aa][ii];
|
|
xap_inter_ptr->open_tail[aa] = ( ii + 1 ) % XAP_OPEN_LEN;
|
|
if( !map_get_comdata_struct ( map_com, temp_did ) )
|
|
return 0;
|
|
return 1;
|
|
}
|
|
|
|
u8 map_get_oprdata ( u8 * data_flow, u32 did )
|
|
{
|
|
struct xapp_vm_data *vm_ptr;
|
|
struct psmvm_data *psm_ptr;
|
|
|
|
if( did >= ( xap_vm_ptr->grantdid ) )
|
|
return 0;
|
|
vm_ptr = ( xapp_vm_data * ) & xap_vm_ptr->xap_data[did];
|
|
if( vm_ptr->sendopr_flag != 1 )
|
|
return 0;
|
|
psm_ptr = ( psmvm_data * ) & vm_ptr->psm_data;
|
|
map_opr_stof ( &vm_ptr->sendopr_data, data_flow, 0 );
|
|
vm_ptr->sendopr_flag = 0;
|
|
xap_watch_dog(11);
|
|
xap_msg_display ( data_flow );
|
|
|
|
if(vm_ptr->sendopr_data.message_type == SndRoutInfo)
|
|
{
|
|
if(vm_ptr->sendopr_data.message_flag == 2)
|
|
{
|
|
xap_watch_dog(18);
|
|
}
|
|
else
|
|
{
|
|
xap_watch_dog(19);
|
|
}
|
|
}
|
|
else if(vm_ptr->sendopr_data.message_type == ProvRoamNum)
|
|
{
|
|
if(vm_ptr->sendopr_data.message_flag == 2)
|
|
{
|
|
xap_watch_dog(22);
|
|
}
|
|
else
|
|
{
|
|
xap_watch_dog(23);
|
|
}
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
u8 map_get_oprdata_struct ( MapOprData_struct * map_opr, u32 did )
|
|
{
|
|
struct xapp_vm_data *vm_ptr;
|
|
struct psmvm_data *psm_ptr;
|
|
|
|
if( did >= ( xap_vm_ptr->grantdid ) )
|
|
return 0;
|
|
vm_ptr = ( xapp_vm_data * ) & xap_vm_ptr->xap_data[did];
|
|
if( vm_ptr->sendopr_flag != 1 )
|
|
return 0;
|
|
psm_ptr = ( psmvm_data * ) & vm_ptr->psm_data;
|
|
|
|
memcpy ( map_opr, &vm_ptr->sendopr_data, sizeof ( struct MapOprData_struct ) );
|
|
if( xap_vm_ptr->debug_data.send_control )
|
|
{
|
|
u8 data_flow[512];
|
|
|
|
map_opr_stof ( map_opr, data_flow, 0 );
|
|
xap_msg_display ( data_flow );
|
|
}
|
|
vm_ptr->sendopr_flag = 0;
|
|
xap_watch_dog(11);
|
|
if(vm_ptr->sendopr_data.message_type == SndRoutInfo)
|
|
{
|
|
if(vm_ptr->sendopr_data.message_flag == 2)
|
|
{
|
|
xap_watch_dog(18);
|
|
}
|
|
else
|
|
{
|
|
xap_watch_dog(19);
|
|
}
|
|
}
|
|
else if(vm_ptr->sendopr_data.message_type == ProvRoamNum)
|
|
{
|
|
if(vm_ptr->sendopr_data.message_flag == 2)
|
|
{
|
|
xap_watch_dog(22);
|
|
}
|
|
else
|
|
{
|
|
xap_watch_dog(23);
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
int map_get_oprType ( u32 did )
|
|
{
|
|
struct xapp_vm_data *vm_ptr;
|
|
|
|
if( did >= ( xap_vm_ptr->grantdid ) )
|
|
return 0;
|
|
vm_ptr = ( xapp_vm_data * ) & xap_vm_ptr->xap_data[did];
|
|
if( vm_ptr->psm_data.psm_state == XAP_IDLE )
|
|
{
|
|
return -1;
|
|
}
|
|
if( ( vm_ptr->sendopr_data.message_type != 0 ) && ( vm_ptr->sendopr_flag != 0 ) )
|
|
{
|
|
return vm_ptr->sendopr_data.message_type;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
u32 map_get_dialogueid ( u8 ssn )
|
|
{
|
|
u32 did;
|
|
|
|
if( ( did = assign_did ( ) ) == 0 )
|
|
{
|
|
xap_send_error ( "Fail to get did(Map)" );
|
|
return 0;
|
|
}
|
|
xap_vm_ptr->xap_data[did].psm_data.xap_flag = XAP_MAP_SSN;
|
|
xap_watch_dog(55);
|
|
return did;
|
|
}
|
|
|
|
#if _SUPPORT_ANSI
|
|
u32 is41_get_dialogueid ( u8 ssn )
|
|
{
|
|
u32 did;
|
|
|
|
if( ( did = assign_did ( ) ) == 0 )
|
|
{
|
|
xap_send_error ( "IS41 Fail to get did(Map)" );
|
|
return 0;
|
|
}
|
|
xap_vm_ptr->xap_data[did].psm_data.xap_flag = XAP_IS41_SSN;
|
|
xap_watch_dog(56);
|
|
return did;
|
|
}
|
|
#endif
|
|
|
|
u8 map_get_invokeid ( u32 did )
|
|
{
|
|
return assign_iid ( did );
|
|
}
|
|
|
|
#if _SUPPORT_ANSI
|
|
u8 map_check_map_flag ( u32 did )
|
|
{
|
|
if( did >= ( xap_vm_ptr->grantdid ) )
|
|
return 0;
|
|
if( xap_vm_ptr->xap_data[did].psm_data.xap_flag == XAP_IS41_SSN )
|
|
return 0;
|
|
|
|
return 1;
|
|
}
|
|
#endif
|
|
|
|
int icap_reg_ssn ( u8 ssn )
|
|
{
|
|
u8 ii, jj;
|
|
if(wxc2_get_license(LIC_CAP)<=0)
|
|
{
|
|
xap_send_error ( "Can not register ssn in cap provider:no license" );
|
|
return -1;
|
|
}
|
|
ii = xap_inter_ptr->regssn_len;
|
|
if( ii >= MAX_XAP_SSN )
|
|
{
|
|
xap_send_error ( "Can not register ssn in map provider" );
|
|
return -1;
|
|
}
|
|
for ( jj = 0; jj < ii; jj++ )
|
|
{
|
|
if( xap_inter_ptr->reg_ssn[jj] == ssn )
|
|
{
|
|
xap_send_error ( "ssn has registered in map provider" );
|
|
return -1;
|
|
}
|
|
}
|
|
xap_inter_ptr->reg_ssn[ii] = ssn;
|
|
xap_inter_ptr->regssn_flag[ii] = XAP_CAP_SSN;
|
|
xap_inter_ptr->regssn_len++;
|
|
return itcap_reg_ssn ( ssn );
|
|
}
|
|
|
|
u8 cap_check_sendcom ( u32 did )
|
|
{
|
|
struct xapp_vm_data *vm_ptr;
|
|
|
|
if( did >= ( xap_vm_ptr->grantdid ) )
|
|
return 0;
|
|
vm_ptr = ( xapp_vm_data * ) & xap_vm_ptr->xap_data[did];
|
|
if( vm_ptr->recvcom_flag == 0 )
|
|
return 1;
|
|
return 0;
|
|
}
|
|
|
|
u8 cap_send_comdata ( u8 * data_flow ) // send cap common service data
|
|
{
|
|
u8 result;
|
|
u32 temp_did;
|
|
struct xapp_vm_data *vm_ptr;
|
|
struct psmvm_data *psm_ptr;
|
|
struct MapComSrv_struct map_com;
|
|
|
|
xap_msg_display ( data_flow );
|
|
if( ( result = cap_com_ftos ( &map_com, data_flow ) ) == 0 )
|
|
return 0;
|
|
temp_did = map_com.dialogue_id;
|
|
if( temp_did >= ( xap_vm_ptr->grantdid ) )
|
|
return 0;
|
|
vm_ptr = ( xapp_vm_data * ) & xap_vm_ptr->xap_data[temp_did];
|
|
if( vm_ptr->recvcom_flag == 1 )
|
|
return 0;
|
|
psm_ptr = ( psmvm_data * ) & vm_ptr->psm_data;
|
|
if( result == 2 || map_com.message_type == MAP_DELIMITER )
|
|
psm_ptr->delimiter_flag = 1;
|
|
if( map_com.message_type != MAP_DELIMITER )
|
|
{
|
|
memcpy ( &vm_ptr->recvcom_data, &map_com, sizeof ( MapComSrv_struct ) );
|
|
psm_ptr->msg_type = map_com.message_type;
|
|
psm_ptr->msg_flag = map_com.message_flag;
|
|
vm_ptr->recvcom_flag = 1;
|
|
xap_watch_dog(29);
|
|
}
|
|
xap_watch_dog(25);
|
|
return 1;
|
|
}
|
|
|
|
u8 cap_check_sendopr ( u32 did )
|
|
{
|
|
struct xapp_vm_data *vm_ptr;
|
|
|
|
if( did >= ( xap_vm_ptr->grantdid ) )
|
|
return 0;
|
|
vm_ptr = ( xapp_vm_data * ) & xap_vm_ptr->xap_data[did];
|
|
if( vm_ptr->recvopr_flag == 1 )
|
|
return 0;
|
|
return 1;
|
|
}
|
|
|
|
u8 cap_send_oprdata ( u8 * data_flow ) // send cap operation service data
|
|
{
|
|
u8 result;
|
|
u32 temp_did;
|
|
struct xapp_vm_data *vm_ptr;
|
|
struct MapOprData_struct map_opr;
|
|
//u8 info[1024];
|
|
|
|
//xap_msg_display ( data_flow );
|
|
if( ( result = cap_opr_ftos ( &map_opr, data_flow ) ) == 0 )
|
|
{
|
|
xap_send_error ( "errro: cap ftos failed" );
|
|
return 0;
|
|
}
|
|
temp_did = map_opr.dialogue_id;
|
|
if( temp_did >= ( xap_vm_ptr->grantdid ) )
|
|
{
|
|
xap_send_error ( "cap errro: did > max did" );
|
|
return 0;
|
|
}
|
|
vm_ptr = ( xapp_vm_data * ) & xap_vm_ptr->xap_data[temp_did];
|
|
if( vm_ptr->recvopr_flag == 1 )
|
|
{
|
|
//xap_send_error("cap errro: quence full");
|
|
return 0;
|
|
}
|
|
xap_msg_display ( data_flow );
|
|
memcpy ( &vm_ptr->recvopr_data, &map_opr, sizeof ( MapOprData_struct ) );
|
|
if( result == 2 )
|
|
{
|
|
vm_ptr->psm_data.delimiter_flag = 1;
|
|
//xap_send_ascout("Delimiter Flag = YES\r\n");
|
|
}
|
|
vm_ptr->recvopr_flag = 1;
|
|
xap_watch_dog(45);
|
|
xap_watch_dog(49);
|
|
//sprintf(info, "cap_send_oprdata: did: %ld, iid: %d, iid_state: %d\r\n", map_opr.dialogue_id, map_opr.invoke_id, xap_vm_ptr->xap_data[map_opr.dialogue_id].psm_data.opr_state[map_opr.invoke_id]);
|
|
//xap_send_ascout(info);
|
|
|
|
return 1;
|
|
}
|
|
|
|
u8 cap_get_comdata ( u8 * data_flow, u32 did )
|
|
{
|
|
struct xapp_vm_data *vm_ptr;
|
|
struct psmvm_data *psm_ptr;
|
|
|
|
vm_ptr = ( xapp_vm_data * ) & xap_vm_ptr->xap_data[did];
|
|
if( vm_ptr->sendcom_flag == 0 )
|
|
return 0;
|
|
psm_ptr = ( psmvm_data * ) & vm_ptr->psm_data;
|
|
cap_com_stof ( &vm_ptr->sendcom_data, data_flow, 0 );
|
|
vm_ptr->sendcom_flag = 0;
|
|
xap_watch_dog(6);
|
|
xap_watch_dog(9);
|
|
xap_msg_display ( data_flow );
|
|
return 1;
|
|
}
|
|
|
|
u8 cap_get_open ( u8 * data_flow, u8 ssn )
|
|
{
|
|
u8 aa;
|
|
u8 ii;
|
|
u8 flag = 0;
|
|
u32 temp_did;
|
|
|
|
for ( aa = 0; aa < xap_inter_ptr->regssn_len; aa++ )
|
|
{
|
|
if( xap_inter_ptr->reg_ssn[aa] == ssn ) // find ssn
|
|
{
|
|
flag = 1;
|
|
break;
|
|
}
|
|
}
|
|
if( flag == 0 )
|
|
{
|
|
xap_send_error ( "SSN--%d is not registerd", ssn );
|
|
return 0;
|
|
}
|
|
ii = xap_inter_ptr->open_tail[aa];
|
|
if( xap_inter_ptr->open_head[aa] == ii ) // empty
|
|
return 0;
|
|
temp_did = xap_inter_ptr->open_did[aa][ii];
|
|
xap_inter_ptr->open_tail[aa] = ( ii + 1 ) % XAP_OPEN_LEN;
|
|
if( !cap_get_comdata ( data_flow, temp_did ) )
|
|
return 0;
|
|
return 1;
|
|
}
|
|
|
|
u8 cap_get_oprdata ( u8 * data_flow, u32 did )
|
|
{
|
|
struct xapp_vm_data *vm_ptr;
|
|
struct psmvm_data *psm_ptr;
|
|
|
|
if( did >= ( xap_vm_ptr->grantdid ) )
|
|
return 0;
|
|
vm_ptr = ( xapp_vm_data * ) & xap_vm_ptr->xap_data[did];
|
|
if( vm_ptr->sendopr_flag != 1 )
|
|
return 0;
|
|
psm_ptr = ( psmvm_data * ) & vm_ptr->psm_data;
|
|
cap_opr_stof ( &vm_ptr->sendopr_data, data_flow, 0 );
|
|
vm_ptr->sendopr_flag = 0;
|
|
xap_watch_dog(11);
|
|
xap_msg_display ( data_flow );
|
|
return 1;
|
|
}
|
|
|
|
u32 cap_get_dialogueid ( u8 ssn )
|
|
{
|
|
u32 did;
|
|
|
|
if( ( did = assign_did ( ) ) == 0 )
|
|
{
|
|
xap_send_error ( "Fail to get did(Cap)" );
|
|
return 0;
|
|
}
|
|
xap_vm_ptr->xap_data[did].psm_data.xap_flag = XAP_CAP_SSN;
|
|
xap_watch_dog(57);
|
|
return did;
|
|
}
|
|
|
|
u8 cap_get_invokeid ( u32 did )
|
|
{
|
|
return assign_iid ( did );
|
|
}
|
|
|
|
u8 xapp_check_did_state ( u32 did )
|
|
{
|
|
if( xap_vm_ptr->xap_data[did].psm_data.psm_state == XAP_IDLE )
|
|
{
|
|
return 1;
|
|
}
|
|
xap_vm_ptr->debug_data.watch_dog[108]++;
|
|
return 0;
|
|
}
|
|
|
|
u8 xapp_check_did ( u32 did )
|
|
{
|
|
if( xap_vm_ptr->xap_data[did].psm_data.psm_state <= XAP_IDLE )
|
|
{
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
u8 map_send_oprsrv ( MapOprSrv_struct * srv_ptr, u8 DelimiterFlag, u8 * data_flow )
|
|
{
|
|
u32 len;
|
|
u8 buf[4096];
|
|
MapOprData_struct data_ptr;
|
|
|
|
data_ptr.port_id = srv_ptr->port_id;
|
|
data_ptr.dialogue_id = srv_ptr->dialogue_id;
|
|
data_ptr.invoke_id = srv_ptr->invoke_id;
|
|
data_ptr.message_type = srv_ptr->message_type;
|
|
data_ptr.message_flag = srv_ptr->message_flag;
|
|
data_ptr.param_flag = 0x1f;
|
|
len = build_mapparam ( srv_ptr, buf );
|
|
//printf ( "map_send_oprsrv: build map param len ; %d \n", len );
|
|
if( len < 0 || len > MAX_MAPPOPR_LEN )
|
|
{
|
|
xap_send_error ( "map_send_oprsrv: build mapparam too long!" );
|
|
return 0;
|
|
}
|
|
data_ptr.param_len = len;
|
|
memcpy ( data_ptr.param, buf, len );
|
|
data_ptr.param_flag |= 0x20;
|
|
map_opr_stof ( &data_ptr, data_flow, DelimiterFlag );
|
|
|
|
return map_send_oprdata ( data_flow );
|
|
}
|
|
|
|
u8 map_send_comsrv ( MapComSrv_struct * com_ptr, u8 uDelimiterFlag, u8 * data_flow )
|
|
{
|
|
map_com_stof ( com_ptr, data_flow, uDelimiterFlag );
|
|
return map_send_comdata ( data_flow );
|
|
}
|
|
|
|
u8 map_send_open ( MapOpenArgParam * pOpenParam, u8 * uDataFlow )
|
|
{
|
|
MapComSrv_struct map_com;
|
|
MapOpen_Arg *pOpenArg;
|
|
|
|
pOpenArg = &map_com.dlg_list.open_arg;
|
|
|
|
map_com.message_type = MAP_OPEN;
|
|
map_com.message_flag = MAP_REQUEST;
|
|
map_com.port_id = pOpenParam->pid;
|
|
map_com.dialogue_id = pOpenParam->did;
|
|
memcpy ( &pOpenArg->local_add, &pOpenParam->local_add, sizeof ( SCCP_ADDR ) );
|
|
memcpy ( &pOpenArg->peer_add, &pOpenParam->peer_add, sizeof ( SCCP_ADDR ) );
|
|
pOpenArg->acn_data.acn = pOpenParam->acn;
|
|
pOpenArg->acn_data.acn_ver = map_get_acnver ( &pOpenParam->local_add, pOpenParam->acn );
|
|
pOpenArg->param_flag = 0x0b;
|
|
xap_watch_dog(60);
|
|
if (pOpenParam->uDelimeterFlag != 0)
|
|
xap_watch_dog(61);
|
|
return map_send_comsrv ( &map_com, pOpenParam->uDelimeterFlag, uDataFlow );
|
|
}
|
|
|
|
u8 map_send_close ( u32 pid, u32 did, u8 uCloseReasion )
|
|
{
|
|
MapComSrv_struct map_com;
|
|
u8 uDataFlow[4096];
|
|
|
|
map_com.message_type = MAP_CLOSE;
|
|
map_com.message_flag = MAP_REQUEST;
|
|
map_com.port_id = pid;
|
|
map_com.dialogue_id = did;
|
|
map_com.dlg_list.close_arg.release_method = uCloseReasion;
|
|
map_com.dlg_list.close_arg.param_flag = 0x01;
|
|
|
|
return map_send_comsrv ( &map_com, 0, uDataFlow );
|
|
|
|
}
|
|
|
|
u8 map_extract_param ( MapOprSrv_struct * srv_ptr, MapOprData_struct * data_ptr, int ver )
|
|
{
|
|
srv_ptr->port_id = data_ptr->port_id;
|
|
srv_ptr->dialogue_id = data_ptr->dialogue_id;
|
|
srv_ptr->invoke_id = data_ptr->invoke_id;
|
|
srv_ptr->message_type = data_ptr->message_type;
|
|
srv_ptr->message_flag = data_ptr->message_flag;
|
|
srv_ptr->version = ver;
|
|
/*
|
|
if( !( data_ptr->param_flag & 0x20 ) ) // has not parameter
|
|
return 0;
|
|
//some response doesn't take any parameter, like V2 fwdMOSMSResponse...
|
|
*/
|
|
return extract_mapparam ( srv_ptr, data_ptr->message_type, data_ptr->message_flag, data_ptr->param_len, data_ptr->param );
|
|
}
|
|
|
|
u8 cap_send_oprsrv ( CapArg * pCapArg, u8 DelimiterFlag, u8 * data_flow )
|
|
{
|
|
|
|
u32 len;
|
|
u8 buf[4096];
|
|
MapOprData_struct data_ptr;
|
|
|
|
data_ptr.port_id = pCapArg->port_id;
|
|
data_ptr.dialogue_id = pCapArg->dialogue_id;
|
|
data_ptr.invoke_id = pCapArg->invoke_id;
|
|
data_ptr.message_type = pCapArg->ocode;
|
|
data_ptr.message_flag = pCapArg->message_flag;
|
|
data_ptr.param_flag = 0x1f;
|
|
len = encode_capmsg ( *pCapArg, buf, 4096 );
|
|
//printf ( "cap_send_oprsrv: build map param len ; %d \n", len );
|
|
if( len == 0 || len > MAX_MAPPOPR_LEN )
|
|
{
|
|
xap_send_error ( "cap_send_oprsrv: build capparam too long!" );
|
|
return 0;
|
|
}
|
|
data_ptr.param_len = len;
|
|
memcpy ( data_ptr.param, buf, len );
|
|
data_ptr.param_flag |= 0x20;
|
|
cap_opr_stof ( &data_ptr, data_flow, DelimiterFlag );
|
|
|
|
return cap_send_oprdata ( data_flow );
|
|
}
|
|
|
|
u8 cap_send_comsrv ( MapComSrv_struct * com_ptr, u8 uDelimiterFlag, u8 * data_flow )
|
|
{
|
|
cap_com_stof ( com_ptr, data_flow, uDelimiterFlag );
|
|
return cap_send_comdata ( data_flow );
|
|
}
|
|
|
|
void wxc2_trace_xapp(u32 did)
|
|
{
|
|
if (did >= (xap_vm_ptr->grantdid))
|
|
return;
|
|
xap_vm_ptr->debug_data.monitor_did = did;
|
|
}
|