4586 lines
121 KiB
C
4586 lines
121 KiB
C
/* MAP data structure head file */
|
|
/* Written by Liu zhiguo 2003-03-04 */
|
|
/* Version 2.0 */
|
|
/* --------------------------------- */
|
|
|
|
#ifndef _MAP_STRUCT
|
|
#define _MAP_STRUCT
|
|
|
|
#include "map_LCSCode.h"
|
|
#ifndef _SUPPORT_ANSI
|
|
#define _SUPPORT_ANSI 1
|
|
|
|
#endif
|
|
#define RER 0
|
|
#define ROK 1
|
|
|
|
#define MAP_FLAG 0x8f
|
|
#define IS41_FLAG 0x8e
|
|
#define MAX_SPCINFO_LEN 32 // specific information length
|
|
#define MAX_MAPPOPR_LEN 1024
|
|
|
|
// fix multiple definition====================================
|
|
extern int decErr;
|
|
//
|
|
|
|
/* MAP data structure. In here, ignore the extention portion */
|
|
/* common service for MAP */
|
|
typedef struct MapOpen_Arg // open argument
|
|
{
|
|
u32 param_flag;
|
|
struct
|
|
{
|
|
u8 acn;
|
|
u8 acn_ver;
|
|
} acn_data; // application context name
|
|
struct SCCP_ADDRESS peer_add;
|
|
u8 peerref_len;
|
|
u8 peer_reference[ISDN_LEN+1];
|
|
struct SCCP_ADDRESS local_add;
|
|
u8 localref_len;
|
|
u8 local_reference[ISDN_LEN+1];
|
|
struct
|
|
{
|
|
u8 info_len;
|
|
u8 info_data[MAX_SPCINFO_LEN];
|
|
} specific_info;
|
|
} MapOpen_Arg;
|
|
|
|
|
|
typedef struct map_open_arg_param{
|
|
u32 pid;
|
|
u32 did;
|
|
u8 uDelimeterFlag;
|
|
SCCP_ADDR local_add;
|
|
SCCP_ADDR peer_add;
|
|
u8 acn;
|
|
}
|
|
MapOpenArgParam;
|
|
|
|
typedef struct MapOpen_Res // open response
|
|
{
|
|
u32 param_flag;
|
|
struct
|
|
{
|
|
u8 acn;
|
|
u8 acn_ver;
|
|
} acn_data; // application context name
|
|
struct
|
|
{
|
|
u8 info_len;
|
|
u8 info_data[MAX_SPCINFO_LEN];
|
|
} specific_info;
|
|
struct SCCP_ADDRESS respond_add;
|
|
u8 result;
|
|
u8 refuse_reason;
|
|
u8 provider_error;
|
|
} MapOpen_Res;
|
|
|
|
typedef struct MapClose_Arg // close argument
|
|
{
|
|
u32 param_flag;
|
|
u8 release_method;
|
|
struct
|
|
{
|
|
u8 info_len;
|
|
u8 info_data[MAX_SPCINFO_LEN];
|
|
} specific_info;
|
|
} MapClose_Arg;
|
|
|
|
typedef struct MapUAbort_Arg // u-abort argument
|
|
{
|
|
u32 param_flag;
|
|
u8 user_reason;
|
|
u8 diag_info; // diagnostic info
|
|
struct
|
|
{
|
|
u8 info_len;
|
|
u8 info_data[MAX_SPCINFO_LEN];
|
|
} specific_info;
|
|
} MapUAbort_Arg;
|
|
|
|
typedef struct MapPAbort_Arg // p-abort argument
|
|
{
|
|
u32 param_flag;
|
|
u8 provider_reason;
|
|
u8 source;
|
|
} MapPAbort_Arg;
|
|
|
|
typedef struct MapNotice_Arg // notice argument
|
|
{
|
|
u32 param_flag;
|
|
u8 problem;// problem diagnostic
|
|
} MapNotice_Arg;
|
|
|
|
typedef struct MapComSrv_struct // common service
|
|
{
|
|
u8 map_flag;//is41 or map
|
|
u32 port_id;
|
|
u32 dialogue_id;
|
|
u8 message_type;
|
|
u8 message_flag; // distinguish REQUEST,INDICATE,RESPONSE,CONFIRM
|
|
u8 component_present;
|
|
union
|
|
{
|
|
struct MapOpen_Arg open_arg;
|
|
struct MapOpen_Res open_res;
|
|
struct MapClose_Arg close_arg;
|
|
struct MapUAbort_Arg uabort_arg;
|
|
struct MapPAbort_Arg pabort_arg;
|
|
struct MapNotice_Arg notice_arg;
|
|
} dlg_list;
|
|
} MapComSrv_struct;
|
|
|
|
/* ************************ */
|
|
/* MAP operation structure */
|
|
/* ************************ */
|
|
|
|
/* ++++++++++++++++++++++++++++++++++++ */
|
|
/* common data types, occording 17.7.8 */
|
|
/* ++++++++++++++++++++++++++++++++++++ */
|
|
typedef enum ProtocolId_enum // protocol id
|
|
{
|
|
gsm0408 = 1,
|
|
gsm0806 = 2,
|
|
gsmBSSMAP = 3,
|
|
ets3001021 = 4
|
|
} ProtocolId_enum;
|
|
|
|
typedef enum ExtProtocolId_e //ext-ProtocolId
|
|
{
|
|
ets300356 = 1 //ets-300356
|
|
}ExtProtocolId_e;
|
|
|
|
typedef enum NetRes_enum // network resource
|
|
{
|
|
plmn = 0,
|
|
hlr = 1,
|
|
vlr = 2,
|
|
pvlr = 3,
|
|
ctrmsc = 4, // controlling MSC
|
|
vmsc = 5,
|
|
eir = 6,
|
|
rss = 7
|
|
} NetRes_enum;
|
|
|
|
typedef struct SigInfo_struct // signal information
|
|
{
|
|
u8 siginfo_len;
|
|
u8 signal_info[SIGNALINFO_LEN]; // signal information
|
|
} SigInfo_struct;
|
|
|
|
typedef struct ExtSigInfo_struct // external signal information
|
|
{
|
|
u8 param_flag;
|
|
enum ProtocolId_enum prt_id; // protocol id
|
|
struct SigInfo_struct siginfo;
|
|
} ExtSigInfo_struct; // can not used in version 2
|
|
|
|
typedef struct AddSigInfo_s //additionalSignalInfo
|
|
{
|
|
u8 param_flag;
|
|
enum ExtProtocolId_e prt_id; //ext-ProtocolId
|
|
struct SigInfo_struct sig_info; //signalInfo
|
|
}AddSigInfo_s;
|
|
|
|
typedef struct SubId_struct // subscriber ID
|
|
{
|
|
u8 choice_flag;
|
|
union
|
|
{
|
|
u8 imsi[IMSI_LEN]; // flag = 1
|
|
u8 tmsi[TMSI_LEN]; // flag = 2
|
|
} id_choice;
|
|
} SubId_struct;
|
|
|
|
typedef struct NaeaPrefCi_struct // NAEA preferred CI
|
|
{
|
|
u8 cic[NAEA_LEN]; // NAEA CIC
|
|
} NaeaPrefCi_struct;
|
|
|
|
typedef struct CellIdLai_struct // cell id or lai
|
|
{
|
|
u8 choice_flag;
|
|
union
|
|
{
|
|
u8 cellid[GCID_LEN]; // flag = 1
|
|
u8 lai[LAI_LEN]; // flag = 2
|
|
} cell_choice;
|
|
} CellIdLai_struct;
|
|
|
|
typedef struct BSCode_struct // basic service code
|
|
{
|
|
u8 param_flag;
|
|
u16 tele_code;
|
|
u32 bearer_code;
|
|
} BSCode_struct;
|
|
|
|
typedef struct BS_Choice //MAP V1 Basic service
|
|
{
|
|
u8 choice_flag;
|
|
union
|
|
{
|
|
u8 bear_service;
|
|
u8 tele_service;
|
|
} choice;
|
|
} BS_Choice;
|
|
|
|
typedef struct EmlppInfo_struct // EMLPP info
|
|
{
|
|
u8 param_flag;
|
|
u8 maxent_prio; // maximum entitle priority
|
|
u8 default_prio; // default priority
|
|
} EmlppInfo_struct;
|
|
|
|
/* +++++++++++++++++++++++++++++++++++++++++ */
|
|
/* short message structure, according 17.7.6 */
|
|
/* +++++++++++++++++++++++++++++++++++++++++ */
|
|
typedef enum SMDeliOutcome_enum // SM delivery outcome
|
|
{
|
|
MemCapExceed = 0, // memory capacity exceeded
|
|
AbsSub = 1, // absent subscriber
|
|
SuccessTrans = 2 // successful transfer
|
|
} SMDeliOutcome_enum;
|
|
|
|
typedef enum SMDeliNotInt_e //sm-deliveryNotIntended
|
|
{
|
|
onlyIMSIReq = 0, //onlyIMSI-requested
|
|
onlyMCCMNCReq = 1 //onlyMCC-MNC-requested
|
|
}SMDeliNotInt_e;
|
|
|
|
typedef enum AltReason_enum // alert reason
|
|
{
|
|
ms_present = 0,
|
|
mem_avail = 1
|
|
} AltReason_enum;
|
|
|
|
typedef struct AddNum_struct // additional number
|
|
{
|
|
u8 choice_flag;
|
|
union
|
|
{
|
|
u8 msc_num[ISDN_LEN+1]; // MSC number,flag = 1
|
|
u8 sgsn_num[ISDN_LEN+1]; // SGSN number,flag = 2
|
|
} choice;
|
|
} AddNum_struct;
|
|
|
|
typedef struct LocInfoLMSI_struct // location info with LMSI
|
|
{
|
|
u8 param_flag;
|
|
u8 netnode_num[ISDN_LEN+1]; // network node number
|
|
u8 lmsi[LMSI_LEN];
|
|
u8 gprsnode_flag; // GPRS node indicator
|
|
struct AddNum_struct add_num;// additional number
|
|
} LocInfoLMSI_struct;
|
|
|
|
typedef struct SmRpDa_struct // SM-RP-DA
|
|
{
|
|
u8 choice_flag;
|
|
union
|
|
{
|
|
u8 imsi[IMSI_LEN]; // flag = 1
|
|
u8 lmsi[LMSI_LEN]; // flag = 2
|
|
u8 sc_add[ISDN_LEN+1]; // service centre address DA, flag = 3
|
|
u8 no_rpda; // has not SM RP DA,flag = 4
|
|
u8 roaming_num[ISDN_LEN+1];
|
|
} choice;
|
|
} SmRpDa_struct;
|
|
|
|
typedef struct SmRpOa_struct // SM-RP-OA
|
|
{
|
|
u8 choice_flag;
|
|
union
|
|
{
|
|
u8 msisdn[ISDN_LEN+1]; // flag = 1
|
|
u8 sc_add[ISDN_LEN+1]; // service centre address DA, flag = 2
|
|
u8 no_rpoa; // has not SM RP OA, flag = 3
|
|
} choice;
|
|
} SmRpOa_struct;
|
|
|
|
typedef struct MapRIFSM_Arg // routing info for SM argument
|
|
{
|
|
u32 param_flag;
|
|
u8 msisdn[ISDN_LEN+1];
|
|
u8 sm_rp_pri;
|
|
u8 sc_add[ISDN_LEN+1]; // service centre address
|
|
u8 gprssup_flag; // GPRS support indicator
|
|
u8 sm_rp_mti;
|
|
u8 sm_rp_smea[SMEA_LEN+1];
|
|
|
|
enum SMDeliNotInt_e sm_deli_not_int; //sm-deliveryNotIntended add by gxchen
|
|
} MapRIFSM_Arg;
|
|
|
|
typedef struct MapRIFSM_Res // routing info for SM response
|
|
{
|
|
u32 param_flag;
|
|
u8 imsi[IMSI_LEN];
|
|
struct LocInfoLMSI_struct loc_info; // location info with lmsi
|
|
u8 user_error;
|
|
u8 provider_error;
|
|
} MapRIFSM_Res;
|
|
|
|
typedef struct LocInfoLMSI_struct_v1
|
|
{
|
|
u32 param_flag;
|
|
u8 choice_flag;
|
|
union
|
|
{
|
|
u8 roaming_num[ISDN_LEN+1];
|
|
u8 msc_num[ISDN_LEN+1];
|
|
} choice;
|
|
u8 imsi[IMSI_LEN];
|
|
} LocInfoLMSI_struct_v1;
|
|
|
|
typedef struct MapRIFSMV1_Arg // routing info for SM argument
|
|
{
|
|
u32 param_flag;
|
|
u8 msisdn[ISDN_LEN+1];
|
|
u8 sm_rp_pri;
|
|
u8 sc_add[ISDN_LEN+1]; // service centre address
|
|
u8 tele_service;
|
|
} MapRIFSMV1_Arg;
|
|
|
|
typedef struct MapRIFSMV1_Res // routing info for SM response
|
|
{
|
|
u32 param_flag;
|
|
u8 imsi[IMSI_LEN];
|
|
LocInfoLMSI_struct_v1 loc_info; // location info with lmsi
|
|
u8 mwd_set; // boolean optional
|
|
u8 user_error;
|
|
u8 provider_error;
|
|
} MapRIFSMV1_Res;
|
|
|
|
typedef struct MapMOFSM_Arg // MO forward SM argument
|
|
{
|
|
u32 param_flag;
|
|
struct SmRpDa_struct sm_rp_da;
|
|
struct SmRpOa_struct sm_rp_oa;
|
|
struct SigInfo_struct sm_rp_ui;
|
|
|
|
u8 moremsg_flag; // more message to send, for MAP V2, MO/T have the same code
|
|
} MapMOFSM_Arg;
|
|
|
|
typedef struct MapMOFSM_Res // MO forward SM response
|
|
{
|
|
u32 param_flag;
|
|
struct SigInfo_struct sm_rp_ui;
|
|
u8 user_error;
|
|
u8 provider_error;
|
|
} MapMOFSM_Res;
|
|
|
|
typedef struct MapMTFSM_Arg // MT forward SM argument
|
|
{
|
|
u32 param_flag;
|
|
struct SmRpDa_struct sm_rp_da;
|
|
struct SmRpOa_struct sm_rp_oa;
|
|
struct SigInfo_struct sm_rp_ui;
|
|
u8 moremsg_flag; // more message to send
|
|
} MapMTFSM_Arg;
|
|
|
|
typedef struct MapMTFSM_Res // MT forward SM response
|
|
{
|
|
u32 param_flag;
|
|
struct SigInfo_struct sm_rp_ui;
|
|
u8 user_error;
|
|
u8 provider_error;
|
|
} MapMTFSM_Res;
|
|
|
|
typedef struct MapFSM_Arg
|
|
{
|
|
u32 param_flag;
|
|
union // sm_rp_da
|
|
{
|
|
u8 imsi[IMSI_LEN];
|
|
u8 lmsi[LMSI_LEN];
|
|
u8 roaming_num[ISDN_LEN+1];
|
|
u8 sc_add[ISDN_LEN+1]; // service centre address
|
|
u8 noms_rp_da;
|
|
} sm_rp_da;
|
|
u8 sm_rp_da_choice;
|
|
|
|
union //sm_rp_oa
|
|
{
|
|
u8 msisdn[ISDN_LEN];
|
|
u8 sc_add[ISDN_LEN+1]; // service centre address
|
|
u8 noms_rp_oa;
|
|
} sm_rp_oa;
|
|
u8 sm_rp_oa_choice;
|
|
|
|
u8 sm_rp_ui_len;
|
|
u8 sm_rp_ui[200]; //sm_rp_ui
|
|
|
|
u8 more_msgtosend; //more_msgtosend
|
|
} MapFSM_Arg;
|
|
|
|
typedef struct MapTSA_Arg
|
|
{
|
|
u32 param_flag;
|
|
u8 imsi[IMSI_LEN];
|
|
u8 trace_ref[2];
|
|
u8 trace_type;
|
|
u8 omc_id_len;
|
|
u8 omc_id[20];
|
|
u8 call_ref[3];
|
|
} MapTSA_Arg;
|
|
|
|
typedef struct MapRSMDS_Arg // report SM delivery status argument
|
|
{
|
|
u32 param_flag;
|
|
u8 msisdn[ISDN_LEN+1];
|
|
u8 sc_add[ISDN_LEN+1]; // service centre address
|
|
enum SMDeliOutcome_enum sm_deliout; // sm-delivery outcome
|
|
u8 abssubdiagsm; // absent subscriber diagnostic SM
|
|
u8 gprssup_flag; // GPRS support indicator
|
|
u8 deliout_flag; // delivery outcome indicator
|
|
enum SMDeliOutcome_enum addsm_deliout; // additional sm-delivery outcome
|
|
u8 add_abssubdiagsm; // additional absent subscriber diagnostic SM
|
|
|
|
//umts add by gxchen
|
|
u8 ip_sm_gw_ind; //ip-sm-gw-Indicator
|
|
enum SMDeliOutcome_enum gw_sm_deliout; //ip-sm-gw-sm-deliveryOutcome
|
|
u8 gw_abssubdiagsm; //ip-sm-gw-absentSubscriberDiagnosticSM
|
|
} MapRSMDS_Arg;
|
|
|
|
typedef struct MapRSMDS_Res // report SM delivery status response
|
|
{
|
|
u32 param_flag;
|
|
u8 stored_msisdn[ISDN_LEN+1]; // stored MSISDN
|
|
u8 user_error;
|
|
u8 provider_error;
|
|
} MapRSMDS_Res;
|
|
|
|
typedef struct MapASC_Arg // alert service centre argument
|
|
{
|
|
u32 param_flag;
|
|
u8 msisdn[ISDN_LEN+1];
|
|
u8 sc_add[ISDN_LEN+1];// service center address
|
|
} MapASC_Arg;
|
|
|
|
typedef struct MapASC_Res // alert service centre response
|
|
{
|
|
u32 param_flag;
|
|
u8 user_error;
|
|
u8 provider_error;
|
|
} MapASC_Res;
|
|
|
|
typedef struct MapISC_Arg // inform service centre argument
|
|
{
|
|
u32 param_flag;
|
|
u8 stored_msisdn[ISDN_LEN+1]; // stored MSISDN
|
|
u16 mw_status; // MW-status
|
|
|
|
//umts add by gxchen
|
|
u8 abssubdiagsm; //absentSubscriberDiagnosticSM
|
|
u8 add_abssubdiagsm; //additionalAbsentSubscriberDiagnosticSM
|
|
} MapISC_Arg;
|
|
|
|
typedef struct MapRFSM_Arg // ready for SM argument
|
|
{
|
|
u32 param_flag;
|
|
u8 imsi[IMSI_LEN];
|
|
enum AltReason_enum alert_reason; // alert reason
|
|
u8 altreason_flag; // alert reason indicator
|
|
|
|
u8 add_alt_reason_ind; //additionalAlertReasonIndicator umts
|
|
} MapRFSM_Arg;
|
|
|
|
typedef struct MapRFSM_Res // ready for SM response
|
|
{
|
|
u32 param_flag;
|
|
u8 user_error;
|
|
u8 provider_error;
|
|
} MapRFSM_Res;
|
|
|
|
/* ++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
|
|
/* supplementary service data structure, according 17.7.4 */
|
|
/* ++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
|
|
typedef enum CliResOpt_enum // Cli restriction option
|
|
{
|
|
permanent = 0,
|
|
temdefres = 1, // temporary default restricted
|
|
temdefall = 2 // temporary default allowed
|
|
} CliResOpt_enum;
|
|
|
|
typedef enum OverCate_enum // override category
|
|
{
|
|
overenable = 0, // override enabled
|
|
overdisable = 1 // override disabled
|
|
} OverCate_enum;
|
|
|
|
typedef enum GuiInfo_enum // guidance info
|
|
{
|
|
enterpw = 0,
|
|
enternewpw = 1,
|
|
enternewpw_again = 2
|
|
} GuiInfo_enum;
|
|
|
|
typedef struct FwdFeat_struct // forward feature
|
|
{
|
|
u8 param_flag;
|
|
struct BSCode_struct bs_code;
|
|
u8 ss_status;
|
|
u8 fwdto_num[ISDN_LEN+1]; // forward to number
|
|
u8 fwd_option; // forward option
|
|
u8 norc_time; // no reply condition time
|
|
|
|
u8 fwdto_addr[22]; //forwardedToSubaddress
|
|
//umts add by gxchen
|
|
u8 long_fwdto_num[ISDN_LEN+1]; //longForwardedToNumber
|
|
} FwdFeat_struct;
|
|
/*
|
|
typedef struct FwdFeat // MAP V1 forward feature
|
|
{
|
|
u8 param_flag;
|
|
struct BS_Choice bs;
|
|
u8 ss_status;
|
|
u8 fwdto_num[ISDN_LEN+1]; // forward to number
|
|
u8 fwdto_subaddr_len;
|
|
u8 fwdto_subaddr[21]; //forward to subaddress
|
|
u8 fwd_option; // forward option
|
|
u8 norc_time; // no reply condition time
|
|
} FwdFeat;
|
|
*/
|
|
typedef struct FwdInfo_struct //forwarding info
|
|
{
|
|
u8 param_flag;
|
|
u8 ss_code;
|
|
struct FwdFeat_struct fwd_feat;
|
|
// struct
|
|
// {
|
|
// u8 fwdfeat_len;
|
|
// struct FwdFeat_struct fwd_feat[BSG_LEN];
|
|
// } fwdfeat_list;
|
|
} FwdInfo_struct;
|
|
|
|
typedef struct CBFeat_struct // call barring feature
|
|
{
|
|
u8 param_flag;
|
|
struct BSCode_struct bs_code;
|
|
u8 ss_status;
|
|
} CBFeat_struct;
|
|
|
|
typedef struct CBInfo_struct // call barring info
|
|
{
|
|
u8 param_flag;
|
|
u8 ss_code;
|
|
struct CBFeat_struct cb_feat;
|
|
// struct
|
|
// {
|
|
// u8 cbfeat_len;
|
|
// struct CBFeat_struct cb_feat[BSG_LEN];
|
|
// } cbfeat_list;
|
|
} CBInfo_struct;
|
|
|
|
typedef struct SsSubsOpt_struct // SS subscription option
|
|
{
|
|
u8 choice_flag;
|
|
union
|
|
{
|
|
enum CliResOpt_enum clires_opt; // cli restriction option,flag=1
|
|
enum OverCate_enum over_cate; // override category,flag=2
|
|
} choice;
|
|
} SsSubsOpt_struct;
|
|
|
|
typedef struct SsData_struct // SS data
|
|
{
|
|
u8 param_flag;
|
|
u8 ss_code;
|
|
u8 ss_status;
|
|
struct SsSubsOpt_struct subs_opt; // ss subscription option
|
|
struct BSCode_struct bs_code; // basic service code
|
|
u8 default_prio; // default priority (EMLPP priority)
|
|
|
|
u8 nbr_user; //nbrUser umts add by gxchen
|
|
} SsData_struct;
|
|
|
|
typedef struct SsInfo_struct // SS info
|
|
{
|
|
u8 choice_flag;
|
|
union
|
|
{
|
|
struct FwdInfo_struct fwd_info; // forward info, flag = 1
|
|
struct CBInfo_struct cb_info; // call barring info, flag = 2
|
|
struct SsData_struct ss_data; // ss data, flag = 3
|
|
} choice;
|
|
} SsInfo_struct;
|
|
|
|
typedef struct SsForBsCode_struct // SS-forBs-code
|
|
{
|
|
u8 param_flag;
|
|
u8 ss_code;
|
|
struct BSCode_struct bs_code;
|
|
|
|
u8 long_ftn_supp; //longFTN-Supported umts add by gxchen
|
|
} SsForBsCode_struct;
|
|
|
|
typedef struct CcbsFeat_struct // CCBS feature
|
|
{
|
|
u8 param_flag;
|
|
u8 ccbs_index; // ccbs index
|
|
u8 bsub_num[ISDN_LEN+1]; // b-subscriber number
|
|
// u8 bsub_subadd[ISDNSUB_LEN]; // b-subscriber subaddress
|
|
struct BSCode_struct bs_code; // basic service group
|
|
} CcbsFeat_struct;
|
|
|
|
typedef struct GenSerInfo_struct // generic service info
|
|
{
|
|
u8 param_flag;
|
|
u8 ss_status;
|
|
enum CliResOpt_enum clires_opt; // Cli restriction option
|
|
u8 maxent_prio; // maximum entitle priory
|
|
u8 default_prio; // default priory
|
|
struct
|
|
{
|
|
u8 ccbs_len;
|
|
struct CcbsFeat_struct ccbs_feat[CCBS_LEN];
|
|
} ccbs_list;
|
|
|
|
//umts add by gxchen
|
|
u8 nbr_sb; //nbrSB
|
|
u8 nbr_user; //nbrUser
|
|
u8 nbr_sn; //nbrSN
|
|
} GenSerInfo_struct;
|
|
|
|
typedef struct UssdArg_struct // USSD Arg
|
|
{
|
|
u8 param_flag;
|
|
u8 ussd_scheme; // USSD data coding scheme
|
|
struct
|
|
{
|
|
u8 string_len;
|
|
u8 ussd_data[USSD_LEN];
|
|
} ussd_string;
|
|
u8 alt_pattern; // alert pattern
|
|
u8 msisdn[ISDN_LEN+1];
|
|
} UssdArg_struct;
|
|
|
|
typedef struct UssdRes_struct // USSD Res
|
|
{
|
|
u8 param_flag;
|
|
u8 ussd_scheme; // USSD data coding scheme
|
|
struct
|
|
{
|
|
u8 string_len;
|
|
u8 ussd_data[USSD_LEN];
|
|
} ussd_string;
|
|
} UssdRes_struct;
|
|
|
|
typedef struct CcbsData_struct // CCBS data
|
|
{
|
|
u8 param_flag;
|
|
struct CcbsFeat_struct ccbs_feat;
|
|
u8 trans_num[ISDN_LEN+1]; // translated B-number
|
|
u32 ser_ind; // service indicator
|
|
struct ExtSigInfo_struct call_info; // call info
|
|
struct ExtSigInfo_struct net_info; // network signal info
|
|
} CcbsData_struct;
|
|
|
|
typedef struct MapRSS_Arg // register SS argument
|
|
{
|
|
u32 param_flag;
|
|
u8 ss_code;
|
|
struct BSCode_struct bs_code;
|
|
u8 fwdto_num[ISDN_LEN+1]; // forward to number
|
|
// u8 fwdto_subadd[ISDNSUB_LEN];// forward to sub address
|
|
u8 norc_time; // no reply condition time
|
|
u8 default_prio; // default priority (EMLPP priority)
|
|
|
|
//umts
|
|
u8 nbr_user; //nbrUser
|
|
u8 long_ftn_supp; //longFTN-Supported
|
|
} MapRSS_Arg;
|
|
|
|
typedef struct MapRSS_Res // register SS response (SS info)
|
|
{
|
|
u32 param_flag;
|
|
struct SsInfo_struct ss_info;
|
|
u8 user_error;
|
|
u8 provider_error;
|
|
} MapRSS_Res;
|
|
|
|
typedef struct MapESS_Arg // erase SS argument
|
|
{
|
|
u32 param_flag;
|
|
struct SsForBsCode_struct ss_forbs;
|
|
} MapESS_Arg;
|
|
|
|
typedef struct MapESS_Res // erase SS response
|
|
{
|
|
u32 param_flag;
|
|
struct SsInfo_struct ss_info;
|
|
u8 user_error;
|
|
u8 provider_error;
|
|
} MapESS_Res;
|
|
|
|
typedef struct MapASS_Arg // activate SS argument
|
|
{
|
|
u32 param_flag;
|
|
struct SsForBsCode_struct ss_forbs;
|
|
} MapASS_Arg;
|
|
|
|
typedef struct MapASS_Res // activate SS response
|
|
{
|
|
u32 param_flag;
|
|
struct SsInfo_struct ss_info;
|
|
u8 user_error;
|
|
u8 provider_error;
|
|
} MapASS_Res;
|
|
|
|
typedef struct MapDASS_Arg // deactivate SS argument
|
|
{
|
|
u32 param_flag;
|
|
struct SsForBsCode_struct ss_forbs;
|
|
} MapDASS_Arg;
|
|
|
|
typedef struct MapDASS_Res // deactivate SS response
|
|
{
|
|
u32 param_flag;
|
|
struct SsInfo_struct ss_info;
|
|
u8 user_error;
|
|
u8 provider_error;
|
|
} MapDASS_Res;
|
|
|
|
typedef struct MapINTSS_Arg // interrogate SS argument
|
|
{
|
|
u32 param_flag;
|
|
struct SsForBsCode_struct ss_forbs;
|
|
} MapINTSS_Arg;
|
|
|
|
typedef struct MapINTSS_Res // interrogate SS response
|
|
{
|
|
u32 param_flag;
|
|
struct
|
|
{
|
|
u8 choice_flag;
|
|
union
|
|
{
|
|
u8 ss_status; // flag = 1
|
|
struct BSCode_struct bs_code;
|
|
struct FwdFeat_struct fwd_feat;
|
|
// struct // flag = 3
|
|
// {
|
|
// u8 fwdfeat_len;
|
|
// struct FwdFeat_struct fwd_feat[BSG_LEN];
|
|
// } fwdfeat_list;
|
|
struct GenSerInfo_struct genser_info; // generic service info,flag=4
|
|
} choice;
|
|
} result;
|
|
u8 user_error;
|
|
u8 provider_error;
|
|
} MapINTSS_Res;
|
|
|
|
typedef struct MapPUSSR_Arg // process Unstructured SS request argument
|
|
{
|
|
u32 param_flag;
|
|
struct UssdArg_struct ussd_arg;
|
|
} MapPUSSR_Arg;
|
|
|
|
typedef struct MapPUSSR_Res // process Unstructured SS request response
|
|
{
|
|
u32 param_flag;
|
|
struct UssdRes_struct ussd_res;
|
|
u8 user_error;
|
|
u8 provider_error;
|
|
} MapPUSSR_Res;
|
|
|
|
typedef struct MapUSSR_Arg // Unstructured SS request argument
|
|
{
|
|
u32 param_flag;
|
|
struct UssdArg_struct ussd_arg;
|
|
} MapUSSR_Arg;
|
|
|
|
typedef struct MapUSSR_Res // Unstructured SS request response
|
|
{
|
|
u32 param_flag;
|
|
struct UssdRes_struct ussd_res;
|
|
u8 user_error;
|
|
u8 provider_error;
|
|
} MapUSSR_Res;
|
|
|
|
typedef struct MapUSSN_Arg // Unstructured SS notify argument
|
|
{
|
|
u32 param_flag;
|
|
struct UssdArg_struct ussd_arg;
|
|
} MapUSSN_Arg;
|
|
|
|
typedef struct MapUSSN_Res // Unstructured SS notify response
|
|
{
|
|
u32 param_flag;
|
|
u8 user_error;
|
|
u8 provider_error;
|
|
} MapUSSN_Res;
|
|
|
|
typedef struct MapBSA_Arg // Begin subsriber activaty
|
|
{
|
|
u32 param_flag;
|
|
u8 imsi[IMSI_LEN+1];
|
|
u8 orgenty_num[9];
|
|
u8 orgenty_num_len;
|
|
} MapBSA_Arg;
|
|
|
|
typedef struct MapRPSS_Arg // register password argument
|
|
{
|
|
u32 param_flag;
|
|
u8 ss_code;
|
|
} MapRPSS_Arg;
|
|
|
|
typedef struct MapRPSS_Res // register password response
|
|
{
|
|
u32 param_flag;
|
|
u8 passwd[PASSWD_LEN];
|
|
u8 user_error;
|
|
u8 provider_error;
|
|
} MapRPSS_Res;
|
|
|
|
typedef struct MapGPSS_Arg // get password argument
|
|
{
|
|
u32 param_flag;
|
|
enum GuiInfo_enum gui_info; // guidance info
|
|
} MapGPSS_Arg;
|
|
|
|
typedef struct MapGPSS_Res // get password response
|
|
{
|
|
u32 param_flag;
|
|
u8 passwd[PASSWD_LEN];
|
|
u8 provider_error;
|
|
} MapGPSS_Res;
|
|
|
|
typedef struct MapSSIN_Arg // SS invocation notificatoin argument
|
|
{
|
|
u32 param_flag;
|
|
u8 imsi[IMSI_LEN];
|
|
u8 msisdn[ISDN_LEN+1];
|
|
u8 ss_event; // according ss code
|
|
struct
|
|
{
|
|
u8 event_len;
|
|
u8 event_spe[EVENT_LEN][ISDN_LEN+1];
|
|
} event;
|
|
} MapSSIN_Arg;
|
|
|
|
typedef struct MapSSIN_Res // SS invocation notification response
|
|
{
|
|
u32 param_flag;
|
|
u8 user_error;
|
|
u8 provider_error;
|
|
} MapSSIN_Res;
|
|
|
|
typedef struct MapRCCE_Arg // register CC entity argument
|
|
{
|
|
u32 param_flag;
|
|
u8 ss_code;
|
|
struct CcbsData_struct ccbs_data;
|
|
} MapRCCE_Arg;
|
|
|
|
typedef struct MapRCCE_Res // register CC entity response
|
|
{
|
|
u32 param_flag;
|
|
struct CcbsFeat_struct ccbs_feat;
|
|
u8 user_error;
|
|
u8 provider_error;
|
|
} MapRCCE_Res;
|
|
|
|
typedef struct MapECCE_Arg // erase CC entity
|
|
{
|
|
u32 param_flag;
|
|
u8 ss_code;
|
|
u8 ccbs_index;
|
|
} MapECCE_Arg;
|
|
|
|
typedef struct MapECCE_Res // erase CC entity
|
|
{
|
|
u32 param_flag;
|
|
u8 ss_code;
|
|
u8 ss_status;
|
|
u8 user_error;
|
|
u8 provider_error;
|
|
} MapECCE_Res;
|
|
|
|
/* +++++++++++++++++++++++++++++++++++++++++++++++++ */
|
|
/* call handling sevices structure, according 17.7.3 */
|
|
/* +++++++++++++++++++++++++++++++++++++++++++++++++ */
|
|
typedef enum InterType_enum // interrogation type
|
|
{
|
|
basiccall = 0,
|
|
forwarding = 1
|
|
} InterType_enum;
|
|
|
|
typedef enum FwdReason_enum // forwarding reason
|
|
{
|
|
fwdnotreach = 0,
|
|
fwdbusy = 1,
|
|
noreply = 2
|
|
} FwdReason_enum;
|
|
|
|
typedef enum TBTriDetPnt_enum // T-Bcsm trigger detection point
|
|
{
|
|
termattmauth = 12, // term attempt authorized
|
|
|
|
//umts add by gxchen
|
|
tbusy = 13, //tBusy
|
|
tnoanswer = 14 //tNoAnswer
|
|
} TBTriDetPnt_enum;
|
|
|
|
typedef enum DefCallHand_enum // default call handling
|
|
{
|
|
continue_call = 0,
|
|
release_call = 1
|
|
} DefCallHand_enum;
|
|
|
|
typedef enum DefSMSHand_enum // default call handling
|
|
{
|
|
continue_transaction = 0,
|
|
release_transaction = 1
|
|
} DefSMSHand_enum;
|
|
|
|
typedef enum OBTriDetPnt_enum // O-Bcsm trigger detection point
|
|
{
|
|
collected_info = 2, //collectedInfo
|
|
route_sel_fail = 4 //routeSelectFailure
|
|
} OBTriDetPnt_enum;
|
|
|
|
typedef enum SMSTriDetPnt_enum // O-Bcsm trigger detection point
|
|
{
|
|
sms_CollectedInfo = 1, //sms-CollectedInfo
|
|
|
|
sms_DeliveryRequest = 2 //sms-DeliveryRequest umts gxchen
|
|
} SMSTriDetPnt_enum;
|
|
|
|
typedef enum CallTypeCrit_enum // call type criteria
|
|
{
|
|
forwarded = 0,
|
|
notforwared = 1
|
|
} CallTypeCrit_enum;
|
|
|
|
typedef enum MatchType_enum // match type
|
|
{
|
|
inhibiting = 0,
|
|
enabling = 1
|
|
} MatchType_enum;
|
|
|
|
typedef enum NotReachReason_enum // not reachable reason
|
|
{
|
|
mspurged = 0,
|
|
imsidetached = 1,
|
|
restrictedarea = 2,
|
|
notregistered = 3
|
|
} NotReachReason_enum;
|
|
|
|
typedef enum RepState_enum // reporting state
|
|
{
|
|
stopmonitor = 0,
|
|
startmonitor = 1
|
|
} RepState_enum;
|
|
|
|
typedef enum CcbsSubStat_enum // CCBS subscriber status
|
|
{
|
|
notidle = 0, // CCBS not idle
|
|
idle = 1, // CCBS idle
|
|
ccbsnotreach = 2 // CCBS not reachable
|
|
} CcbsSubStat_enum;
|
|
|
|
typedef enum MonMode_enum // monitor mode
|
|
{
|
|
aside = 0,
|
|
bside = 1
|
|
} MonMode_enum;
|
|
|
|
typedef enum CallOut_enum // call outcome
|
|
{
|
|
success = 0,
|
|
failure = 1,
|
|
cobusy = 2
|
|
} CallOut_enum;
|
|
|
|
typedef enum RUFOut_enum // RUF outcome
|
|
{
|
|
accepted = 0,
|
|
rejected = 1,
|
|
noresfree = 2, // no response from free MS
|
|
noresbusy = 3, // no response from busy MS
|
|
udubfree = 4, // udub from free MS
|
|
udubbusy = 5 // udub from busy MS
|
|
} RUFOut_enum;
|
|
|
|
typedef enum IstSuppInd_e //istSupportIndicator
|
|
{
|
|
BASIC_IST_SUPPORT = 0, //basicISTSupported
|
|
IST_CMD_SUPPORT = 1 //istCommandSupported
|
|
}IstSuppInd_e;
|
|
|
|
|
|
typedef struct CugChkInfo_struct // CUG check info
|
|
{
|
|
u8 param_flag;
|
|
u8 cug_intlock[CUGLOCK_LEN]; // CUG interlock
|
|
u8 cug_outacc; // CUG outgoing access
|
|
} CugChkInfo_struct;
|
|
|
|
typedef struct CamelInfo_struct // camel info
|
|
{
|
|
u8 param_flag;
|
|
u8 camel_phase[3]; // supported camel phases
|
|
u8 supp_tcsi; //(0) suppress T-CSI
|
|
|
|
u16 offer_camel; //offeredCamel4CSIs //add by gxchen
|
|
} CamelInfo_struct;
|
|
|
|
typedef struct FwdData_struct // forwarding data
|
|
{
|
|
u8 param_flag;
|
|
u8 fwd_num[ISDN_LEN + 1]; //(0)
|
|
u8 fwd_subadd[ISDNSUB_LEN + 1]; //(1)
|
|
u8 fwd_option; //(2) forwarding option
|
|
|
|
u8 long_fwd_num[16]; //longForwardedToNumber add by gxchen
|
|
} FwdData_struct;
|
|
|
|
typedef struct RoutInfo_struct // routing info
|
|
{
|
|
u8 choice_flag;
|
|
union
|
|
{
|
|
u8 roam_num[ISDN_LEN+1]; // roaming number,flag = 1
|
|
struct FwdData_struct fwd_data; // flag = 2
|
|
} choice;
|
|
} RoutInfo_struct;
|
|
|
|
typedef struct TBCTDPData_struct // T-Bcsm camel TDP data
|
|
{
|
|
u8 param_flag;
|
|
enum TBTriDetPnt_enum det_point; // t-Bcsm trigger detection point
|
|
u32 service_key;
|
|
u8 scf_add[ISDN_LEN+1];
|
|
enum DefCallHand_enum def_hand; // default call handling
|
|
} TBCTDPData_struct;
|
|
|
|
typedef struct TCsi_struct // T-CSI
|
|
{
|
|
u8 param_flag;
|
|
struct
|
|
{
|
|
u8 tdpdata_len;
|
|
struct TBCTDPData_struct tdp_data[TDPDATA_NUM];
|
|
} tdpdata_list;
|
|
u8 camel_caphand; // camel capability handling
|
|
|
|
//umts add by gxchen
|
|
u8 ntfy_cse; //notificationToCSE
|
|
u8 csi_active; //csi-Active
|
|
} TCsi_struct;
|
|
|
|
typedef struct OBCTDPData_struct // O-Bcsm camel TDP data
|
|
{
|
|
u8 param_flag;
|
|
enum OBTriDetPnt_enum det_point; // O-Bcsm trigger detection point
|
|
enum DefCallHand_enum def_hand; // default call handling
|
|
u8 scf_add[ISDN_LEN+1];
|
|
u32 service_key;
|
|
} OBCTDPData_struct;
|
|
|
|
typedef struct OCsi_struct // O-CSI
|
|
{
|
|
u8 param_flag;
|
|
struct
|
|
{
|
|
u8 tdpdata_len;
|
|
struct OBCTDPData_struct tdp_data[TDPDATA_NUM];
|
|
} tdpdata_list;
|
|
u8 camel_caphand; // camel capability handling
|
|
|
|
//umts add by gxchen
|
|
u8 ntfy_cse; //notificationToCSE
|
|
u8 csi_active; //csi-Active
|
|
} OCsi_struct;
|
|
|
|
typedef struct SMSCTDPData_struct // SMS camel TDP data
|
|
{
|
|
enum SMSTriDetPnt_enum det_point; // SMS trigger detection point
|
|
enum DefSMSHand_enum def_hand; // default call handling
|
|
u8 scf_add[ISDN_LEN + 1];
|
|
u32 service_key;
|
|
} SMSCTDPData_struct;
|
|
|
|
typedef struct SMSCsi_struct // O-CSI
|
|
{
|
|
u8 param_flag;
|
|
struct
|
|
{
|
|
u8 tdpdata_len;
|
|
struct SMSCTDPData_struct tdp_data[TDPDATA_NUM];
|
|
} tdpdata_list; //(0)
|
|
u8 camel_caphand; //(1)camel capability handling
|
|
u8 notificationToCSE; //(2)notificationToCSE
|
|
u8 csi_Active; //(3)csi-Active
|
|
} SMSCsi_struct;
|
|
|
|
typedef struct MCsi_s //m-CSI
|
|
{
|
|
u8 param_flag;
|
|
struct
|
|
{
|
|
u8 mobtri_len;
|
|
u8 mob_tri[TDPDATA_NUM];
|
|
}mobtri; //mobilityTriggers
|
|
u32 service_key; //serviceKey
|
|
u8 scf_add[ISDN_LEN+1]; //gsmSCF-Address
|
|
u8 ntfy_cse; //notificationToCSE
|
|
u8 csi_active; //csi-Active
|
|
}MCsi_s;
|
|
|
|
typedef struct VTCsi_s //vt-CSI
|
|
{
|
|
u8 param_flag;
|
|
struct TBCTDPData_struct tdp_data[TDPDATA_NUM]; //t-BcsmCamelTDPDataList
|
|
u8 camel_caphand; //camelCapabilityHandling
|
|
u8 ntfy_cse; //notificationToCSE
|
|
u8 csi_active; //csi-Active
|
|
}VTCsi_s;
|
|
|
|
|
|
typedef struct DstNumCrit_struct // destination number criteria
|
|
{
|
|
u8 param_flag;
|
|
enum MatchType_enum match_type;
|
|
struct
|
|
{
|
|
u8 dstnum_len;
|
|
u8 dst_num[MAX_DSTNUM][ISDN_LEN+1];
|
|
} dstnum_list; //destination number list
|
|
struct
|
|
{
|
|
u8 numlength_len;
|
|
u8 num_length[DSTNUM_LEN];
|
|
} dstnumlen_list;
|
|
} DstNumCrit_struct;
|
|
|
|
typedef struct OBCTDPCrit_struct // O-Bcsm camel TDP criteria
|
|
{
|
|
u8 param_flag;
|
|
enum OBTriDetPnt_enum det_point; // O-Bcsm trigger detection point
|
|
struct DstNumCrit_struct dstCriteria;
|
|
struct BSCode_struct bs_code;
|
|
enum CallTypeCrit_enum call_crit; // call type criteria
|
|
|
|
//umts add by gxchen
|
|
struct
|
|
{
|
|
u8 causeval_len;
|
|
u8 cause_val[5];
|
|
}o_cause_var_cri; //o-CauseValueCriteria
|
|
} OBCTDPCrit_struct;
|
|
|
|
typedef struct OBCritLst_struct
|
|
{
|
|
u8 list_len;
|
|
struct OBCTDPCrit_struct crit_data[TDPDATA_NUM];
|
|
}OBCritLst_struct;
|
|
|
|
typedef struct TBCTDPCrit_s
|
|
{
|
|
u8 param_flag;
|
|
enum TBTriDetPnt_enum det_point; //t-BCSM-TriggerDetectionPoint
|
|
struct BSCode_struct bs_code; //basicServiceCriteria
|
|
struct
|
|
{
|
|
u8 causeval_len;
|
|
u8 cause_val[5];
|
|
}t_cause_var_cri; //t-CauseValueCriteria
|
|
}TBCTDPCrit_s;
|
|
typedef struct TBCritLst_s //t-BCSM-CAMEL-TDP-CriteriaList
|
|
{
|
|
u8 list_len;
|
|
struct TBCTDPCrit_s crit_data[TDPDATA_NUM];
|
|
}TBCritLst_s;
|
|
|
|
typedef struct DPAnaInfoCrit_s //dp-AnalysedInfoCriteriaList
|
|
{
|
|
u8 param_flag;
|
|
u8 dial_num[ISDN_LEN+1]; //dialedNumber
|
|
u32 service_key; //serviceKey
|
|
u8 scf_add[ISDN_LEN+1]; //gsmSCF-Address
|
|
enum DefCallHand_enum def_hand; //defaultCallHandling
|
|
}DPAnaInfoCrit_s;
|
|
typedef struct DCsi_s //d-CSI
|
|
{
|
|
u8 param_flag;
|
|
struct
|
|
{
|
|
u8 dpcrit_len;
|
|
struct DPAnaInfoCrit_s dp_crit[TDPDATA_NUM];
|
|
}dpcrit_list;
|
|
u8 camel_caphand; //camelCapabilityHandling
|
|
u8 ntfy_cse; //notificationToCSE
|
|
u8 csi_active; //csi-Active
|
|
}DCsi_s;
|
|
|
|
typedef struct GCSubsInfo_struct // GMSC camel subscription info
|
|
{
|
|
u8 param_flag;
|
|
struct TCsi_struct t_csi;
|
|
struct OCsi_struct o_csi;
|
|
struct OBCritLst_struct ob_list; // O-Bcsm camel TDP criteria list
|
|
|
|
//umts add by gxchen
|
|
struct TBCritLst_s tb_list;
|
|
struct DCsi_s d_csi;
|
|
} GCSubsInfo_struct;
|
|
|
|
typedef struct CamelRoutInfo_struct // camel routing info
|
|
{
|
|
u8 param_flag;
|
|
struct FwdData_struct fwd_data; //(0)
|
|
struct GCSubsInfo_struct subs_info; // GMSC camel subscription info
|
|
} CamelRoutInfo_struct;
|
|
|
|
typedef struct ExtRoutInfo_struct // extended routing info
|
|
{
|
|
u8 choice_flag;
|
|
union
|
|
{
|
|
struct RoutInfo_struct rout_info; // flag = 1
|
|
struct CamelRoutInfo_struct camel_info; // camel routing info,flag = 2
|
|
} choice;
|
|
} ExtRoutInfo_struct;
|
|
|
|
typedef struct SubState_struct // subscriber state
|
|
{// flag=1:assumeidle;flag=2:camelbusy;flag=4:netnotreachable;flag=8:notprovidfromvlr
|
|
u8 choice_flag;
|
|
union
|
|
{
|
|
u8 assume_idle; //assumedIdle
|
|
u8 camel_busy; //camelBusy
|
|
enum NotReachReason_enum net_reason;
|
|
u8 not_pro_vlr; //notProvidedFromVLR
|
|
} choice;
|
|
} SubState_struct;
|
|
|
|
typedef struct LocInfo_struct // location information
|
|
{
|
|
u8 param_flag;
|
|
u16 age_info; // age of location information
|
|
u8 geog_info[8]; // geographical information
|
|
u8 vlr_num[ISDN_LEN+1];
|
|
u8 loc_num[LOCATION_NUM]; // location number
|
|
struct CellIdLai_struct cell_lai; // cell id or lai
|
|
|
|
//umts add by gxchen
|
|
u8 sel_lsa_id[3]; //selectedLSA-Id
|
|
u8 msc_num[ISDN_LEN+1]; //msc-Number
|
|
u8 geo_info[10]; //geodeticInformation
|
|
u8 cur_loc_rtrv; //currentLocationRetrieved
|
|
u8 sai_pre; //sai-Present
|
|
} LocInfo_struct;
|
|
|
|
typedef struct LocInfoGprs_s //locationInformationGPRS
|
|
{
|
|
u8 param_flag;
|
|
struct CellIdLai_struct cell_lai; //cellGlobalIdOrServiceAreaIdOrLAI
|
|
u8 route_area_id[6]; //routeingAreaIdentity
|
|
u8 geogr_info[8]; //geographicalInfomartion
|
|
u8 sgsn_num[ISDN_LEN+1]; //sgsn-Present
|
|
u8 sel_lsa_id[3]; //selectedLSAIdentity
|
|
u8 sai_pre; //sai-Present
|
|
u8 geo_info[10]; //geodeticInformation
|
|
u8 cur_loc_rtrv; //currentLocationRetrieved
|
|
u16 age_info; //ageOfLocationInformation
|
|
}LocInfoGprs_s;
|
|
|
|
typedef struct PsSubState_s //ps-SubscriberState
|
|
{
|
|
u8 choice_flag;
|
|
union
|
|
{
|
|
u8 not_pro_sgsn; //notProvidedFromSGSN
|
|
u8 ps_detach; //ps-Detached
|
|
u8 ps_attach_nrfp; //ps-AttachedNotReachableForPaging
|
|
u8 ps_attach_rfp; //ps-AttachedReachableForPaging
|
|
u8 ps_pdp_active_nrfp; //ps-ActiveNotReachableForPaging //define later
|
|
u8 ps_pdp_active_rfp; //ps-ActiveReachableForPaging //define later
|
|
enum NotReachReason_enum net_reason; //netDetNotReachable
|
|
}choice;
|
|
}PsSubState_s;
|
|
|
|
/*
|
|
typedef struct SubInfo_struct // subscriber information
|
|
{
|
|
u8 param_flag;
|
|
struct LocInfo_struct loc_info;
|
|
struct SubState_struct sub_state;
|
|
// CapLocationInformation loc_info; //(0) location information
|
|
//<---defined in capmsg.h
|
|
// u8 sub_state_ch;
|
|
// CapSubscriberState sub_state; //(1) param_flag=1 subscriber state
|
|
//<---defined in capmsg.h
|
|
} SubInfo_struct;
|
|
*/
|
|
|
|
typedef enum NumberPortabilityStatus
|
|
{
|
|
//notKnownToBePorted = 0,
|
|
//ownNumberPortedOut = 1,
|
|
//foreignNumberPortedToForeignNetwork = 2,
|
|
ownNumberNotPortedOut = 4,
|
|
foreignNumberPortedIn = 5
|
|
}NumberPortabilityStatus;
|
|
|
|
typedef struct MnpInfoRes
|
|
{
|
|
u8 param_flag;
|
|
u8 routing_number[ISDN_LEN+1];
|
|
u8 imsi[IMSI_LEN];
|
|
u8 msisdn[ISDN_LEN+1];
|
|
enum NumberPortabilityStatus mnp_status;
|
|
}MnpInfoRes;
|
|
|
|
|
|
typedef struct SubInfo_struct // subscriber information
|
|
{
|
|
u8 param_flag;
|
|
struct LocInfo_struct loc_info;
|
|
struct SubState_struct sub_state;
|
|
u8 locationInfoGPRS; // define later
|
|
// struct LocInfoGprs_s loc_info_gprs;
|
|
u8 ps_subscriber_state; //define later
|
|
// struct PsSubState_s ps_sub_state;
|
|
u8 imei[IMEI_LEN];
|
|
u8 ms_classmark; //define later
|
|
u8 gprs_ms_class; //define later
|
|
struct MnpInfoRes mnp_info_res;
|
|
// CapLocationInformation loc_info; //(0) location information
|
|
// //<---defined in capmsg.h
|
|
// // u8 sub_state_ch;
|
|
// CapSubscriberState sub_state; //(1) param_flag=1 subscriber state
|
|
// //<---defined in capmsg.h
|
|
} SubInfo_struct;
|
|
|
|
|
|
typedef struct CcbsInd_struct // CCBS indicator
|
|
{
|
|
u8 param_flag;
|
|
u8 ccbs_possible; // CCBS possible
|
|
u8 ccbs_indicator; // keep CCBS call indicator
|
|
} CcbsInd_struct;
|
|
|
|
typedef struct EveRepData_struct // event report data
|
|
{
|
|
u8 param_flag;
|
|
enum CcbsSubStat_enum ccbs_stat; // CCBS subscriber status
|
|
} EveRepData_struct;
|
|
|
|
typedef struct CallRepData_struct // call report data
|
|
{
|
|
u8 param_flag;
|
|
enum MonMode_enum monitor_mode; // monitor mode
|
|
enum CallOut_enum call_outcome; // call outcome
|
|
} CallRepData_struct;
|
|
|
|
typedef struct MapSRI_Arg // send routing info argument
|
|
{
|
|
u32 param_flag;
|
|
u8 msisdn[ISDN_LEN+1]; //0
|
|
struct CugChkInfo_struct chk_info; // CUG check info
|
|
u8 fwd_num; // number of forwarding
|
|
enum InterType_enum inter_type; // interrogation type
|
|
u8 or_inter; // or-interrogation
|
|
u8 or_cap; // or-capability
|
|
u8 gmsc_add[ISDN_LEN+1]; // gmsc address
|
|
u8 callref_num[CALLREF_NUM+1]; // call reference number
|
|
enum FwdReason_enum fwd_reason; // forwarding reason
|
|
struct BSCode_struct bs_group; // basic service group
|
|
struct ExtSigInfo_struct net_info; // network signal info
|
|
struct CamelInfo_struct camel_info; // camel info
|
|
u8 supp_ann; // suppression of announcement
|
|
u8 alt_pattern; // alert pattern
|
|
u8 ccbs_call; // CCBS call
|
|
u8 ccbs_phase; // supported CCBS phase
|
|
struct AddSigInfo_s add_info; //additionalSignalInfo
|
|
|
|
//add by gxchen umts
|
|
enum IstSuppInd_e supp_ind; //istSupportIndicator
|
|
u8 pre_page_supp; //pre-pagingSupported
|
|
u8 call_div_ind; //callDiversionTreatmentIndicator
|
|
u8 ftn_supp; //longFTNSupported
|
|
u8 sps_vt_csi; //suppress-VT-CSI
|
|
u8 sps_in_call_bar; //suppressIncomingCallBarring
|
|
u8 gsmscf_init_call; //gsmSCF-InitiatedCall
|
|
struct BSCode_struct bs_group2; //basicServiceGroup2
|
|
struct ExtSigInfo_struct net_info2; //networkSingalInfo2
|
|
u8 sps_mt_ss[3]; //suppressMTSS
|
|
u8 mt_roam_retry_supp; //mtRoamingRetrySupported
|
|
u8 call_pri; //callPriority
|
|
} MapSRI_Arg;
|
|
|
|
typedef enum MNPStatus_enum
|
|
// mnp status type, for MNP looping detect, added by Pierre, 06-01-23
|
|
{
|
|
notKnownToBePorted=0,
|
|
ownNumberPortedOut,
|
|
foreignNumberPortedToForeignNetwork,
|
|
}MNPStatus_enum;
|
|
|
|
typedef enum UnAvailCause_e //unavailabilityCause
|
|
{
|
|
bearerServiceNotProvisioned = 1,
|
|
teleserviceNotProvisioned = 2,
|
|
absentSubscriber = 3,
|
|
busySubscriber = 4,
|
|
callBarred = 5,
|
|
cugReject = 6
|
|
}UnAvailCause_e;
|
|
|
|
|
|
typedef struct MapSRI_Res // send routing information response
|
|
{
|
|
u32 param_flag;
|
|
u8 imsi[IMSI_LEN]; //(0)
|
|
struct ExtRoutInfo_struct rout_info; //(1)extended routing info
|
|
struct CugChkInfo_struct cugchk_info; //(2)CUG check info
|
|
u8 cugsubs_flag; //(3)CUG subsription flag
|
|
struct SubInfo_struct sub_info; //(4)subscriber info
|
|
struct
|
|
{
|
|
u8 sslist_len;
|
|
u8 ss_code[SS_LEN];
|
|
} ss_list; //(5)
|
|
struct BSCode_struct bs_code;
|
|
u8 fwdinter_req; // forwarding interrogate required
|
|
u8 vmsc_add[ISDN_LEN+1];
|
|
struct NaeaPrefCi_struct naea_ci; // NAEA preferred CI
|
|
struct CcbsInd_struct ccbs_ind; // CCBS indicator
|
|
u8 msisdn[ISDN_LEN+1];
|
|
MNPStatus_enum mnp_indicator; //bit:0x800
|
|
|
|
//umts add by gxchen
|
|
u8 ist_alert_timer; //istAlertTimer (15~255)
|
|
u8 camel_phase_vmsc; //supportedCamelPhasesInVMSC
|
|
u8 offer_camel_vmsc; //offeredCamel4CSIsInVMSC
|
|
struct RoutInfo_struct rout_info_2; //routingInfo2
|
|
struct
|
|
{
|
|
u8 sslist_len;
|
|
u8 ss_code[SS_LEN];
|
|
}ss_list_2; //ss-List2
|
|
u8 allow_serv[2]; //allowedServices
|
|
enum UnAvailCause_e unavail_cause;
|
|
u8 rel_res_supp; //releaseResourcesSupported
|
|
struct ExtSigInfo_struct bear_cap; //gsm-BearerCapability
|
|
|
|
u8 user_error;
|
|
u8 provider_error;
|
|
} MapSRI_Res;
|
|
|
|
|
|
typedef enum CallTermInd_e //callTerminationIndicator
|
|
{
|
|
terminateCallActivityReferred = 0,
|
|
terminateAllCallActivities = 1
|
|
}CallTermInd_e;
|
|
|
|
typedef struct MapISTAlert_Arg //ist-Alert argument
|
|
{
|
|
u32 param_flag;
|
|
u8 imsi[IMSI_LEN];
|
|
}MapISTAlert_Arg;
|
|
|
|
typedef struct MapISTAlert_Res //ist-Alert response
|
|
{
|
|
u32 param_flag;
|
|
u8 ist_alert_timer; //istAlertTimer (15~255)
|
|
u8 ist_info_withdraw; //istInformationWithdraw
|
|
enum CallTermInd_e callterm_ind;
|
|
|
|
u8 user_error;
|
|
u8 provider_error;
|
|
}MapISTAlert_Res;
|
|
|
|
typedef struct MapISTCmd_Arg //ist-Commad argument
|
|
{
|
|
u32 param_flag;
|
|
u8 imsi[IMSI_LEN];
|
|
}MapISTCmd_Arg;
|
|
|
|
typedef struct MapISTCmd_Res //ist-Command response
|
|
{
|
|
u32 param_flag;
|
|
|
|
u8 user_error;
|
|
u8 provider_error;
|
|
}MapISTCmdRes;
|
|
|
|
|
|
typedef struct PageArea_s //pagingArea
|
|
{
|
|
u8 choice_flag;
|
|
union
|
|
{
|
|
u8 lai_fix[5]; //laiFixedLength 0
|
|
u8 lac; //lac 1
|
|
}choice;
|
|
}PageArea_s;
|
|
|
|
typedef struct MapPRN_Arg // provide roaming number argument
|
|
{
|
|
u32 param_flag;
|
|
u8 imsi[IMSI_LEN];
|
|
u8 msc_num[ISDN_LEN+1]; // MSC number
|
|
u8 msisdn[ISDN_LEN+1];
|
|
u8 lmsi[LMSI_LEN];
|
|
struct ExtSigInfo_struct bearer_cap; // gsm bearer capability
|
|
struct ExtSigInfo_struct net_info; // network signal info
|
|
u8 sup_ann; // suppression of announcement
|
|
u8 gmsc_add[ISDN_LEN+1]; // GMSC address
|
|
u8 callref_num[CALLREF_NUM+1]; // call reference number
|
|
u8 or_interr; // or-interrogation
|
|
u8 alt_pattern; // alert pattern
|
|
u8 ccbs_call; // CCBS call
|
|
u8 camel_phase[3]; // supported camel phase
|
|
|
|
struct AddSigInfo_s add_info; //additionalSignalInfo
|
|
u8 not_supp_gmsc; //orNotSupportedInGMSC
|
|
//umts add by gxchen
|
|
u8 pre_page_supp; //pre-pagingSupported
|
|
u8 long_ftn_supp; //longFTN-Supported
|
|
u8 sps_vt_csi; //suppress-VT-CSI
|
|
u16 offer_camel_node; //offeredCamel4CSIsInInterrogatingNode
|
|
u8 mt_roam_retry_supp; //mtRoamingRetrySupported
|
|
struct PageArea_s page_area; //pagingArea
|
|
u8 call_pri; //callPriority
|
|
} MapPRN_Arg;
|
|
|
|
typedef struct MapPRN_Res // provider roaming number response
|
|
{
|
|
u32 param_flag;
|
|
u8 roam_num[ISDN_LEN+1];
|
|
|
|
u8 rel_res_supp; //releaseResourcesSupported umts add by gxchen
|
|
u8 user_error;
|
|
u8 provider_error;
|
|
} MapPRN_Res;
|
|
|
|
typedef struct MapRCH_Arg // resume call handling argument
|
|
{
|
|
u32 param_flag;
|
|
u8 callref_num[CALLREF_NUM+1]; // call reference number
|
|
struct BSCode_struct bs_group; // basic service group
|
|
struct FwdData_struct fwd_data; // forwarding data
|
|
u8 imsi[IMSI_LEN];
|
|
struct CugChkInfo_struct cugchk_info;// CUG check info
|
|
struct OCsi_struct o_csi; // o-CSI
|
|
u8 ccbs_possible; // CCBS possible
|
|
} MapRCH_Arg;
|
|
|
|
typedef struct MapRCH_Res // resume call handling response
|
|
{
|
|
u32 param_flag;
|
|
u8 user_error;
|
|
u8 provider_error;
|
|
} MapRCH_Res;
|
|
|
|
typedef struct MapPSN_Arg // provide SIWFS number argument
|
|
{
|
|
u32 param_flag;
|
|
struct ExtSigInfo_struct gsm_bc; // GSM bearer capability
|
|
struct ExtSigInfo_struct isdn_bc; // ISDN bearer capability
|
|
u8 call_direction; // call direction
|
|
u8 bsub_add[ISDN_LEN+1]; // b-subscriber address
|
|
struct ExtSigInfo_struct chose_chan; // chosen channel
|
|
struct ExtSigInfo_struct low_camp; // low layer compatibility
|
|
struct ExtSigInfo_struct high_camp; // high layer compatibility
|
|
} MapPSN_Arg;
|
|
|
|
typedef struct MapPSN_Res // provide SIWFS number response
|
|
{
|
|
u32 param_flag;
|
|
u8 siwfs_num[ISDN_LEN+1]; // sIWFS number
|
|
u8 user_error;
|
|
u8 provider_error;
|
|
} MapPSN_Res;
|
|
|
|
typedef struct MapSSM_Arg // SIWFS signalling modify argument
|
|
{
|
|
u32 param_flag;
|
|
struct ExtSigInfo_struct chan_type; // channel type
|
|
struct ExtSigInfo_struct chose_chan; // chosen channel
|
|
} MapSSM_Arg;
|
|
|
|
typedef struct MapSSM_Res // SIWFS signalling modify response
|
|
{
|
|
u32 param_flag;
|
|
struct ExtSigInfo_struct chose_chan; // chosen channel
|
|
u8 user_error;
|
|
u8 provider_error;
|
|
} MapSSM_Res;
|
|
|
|
typedef struct MapSRS_Arg // set reporting state argument
|
|
{
|
|
u32 param_flag;
|
|
u8 imsi[IMSI_LEN];
|
|
u8 lmsi[LMSI_LEN];
|
|
enum RepState_enum ccbs_monitor; // CCBS monitoring
|
|
} MapSRS_Arg;
|
|
|
|
typedef struct MapSRS_Res // set reporting state response
|
|
{
|
|
u32 param_flag;
|
|
enum CcbsSubStat_enum ccbs_stat; // CCBS subscriber status
|
|
u8 user_error;
|
|
u8 provider_error;
|
|
} MapSRS_Res;
|
|
|
|
typedef struct MapSR_Arg // status report argument
|
|
{
|
|
u32 param_flag;
|
|
u8 imsi[IMSI_LEN];
|
|
struct EveRepData_struct event_data; // event report data
|
|
struct CallRepData_struct call_data; // call report data
|
|
} MapSR_Arg;
|
|
|
|
typedef struct MapSR_Res // status report response
|
|
{
|
|
u32 param_flag;
|
|
u8 user_error;
|
|
u8 provider_error;
|
|
} MapSR_Res;
|
|
|
|
typedef struct MapRUF_Arg // remote user free argument
|
|
{
|
|
u32 param_flag;
|
|
u8 imsi[IMSI_LEN];
|
|
struct ExtSigInfo_struct call_info; // call info
|
|
struct CcbsFeat_struct ccbs_feat; // CCBS feature
|
|
u8 trans_num[ISDN_LEN+1]; // translate number
|
|
u8 replace_num; // replace number
|
|
u8 alt_pattern; // alert pattern
|
|
} MapRUF_Arg;
|
|
|
|
typedef struct MapRUF_Res // remote user free response
|
|
{
|
|
u32 param_flag;
|
|
enum RUFOut_enum ruf_outcome; // RUF outcome
|
|
u8 user_error;
|
|
u8 provider_error;
|
|
} MapRUF_Res;
|
|
|
|
/* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
|
|
/* operation and maintenance data structure, according 17.7.2 */
|
|
/* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
|
|
typedef enum TraceDepth_e //TraceDepth
|
|
{
|
|
Trd_Min = 0, //minimum
|
|
Trd_Mid = 1, //medium
|
|
Trd_Max = 2 //maximum
|
|
}TraceDepth_e;
|
|
|
|
typedef struct TraceDepthLst_s //traceDepthList
|
|
{
|
|
enum TraceDepth_e msc_trd; //msc-s-TraceDepth
|
|
enum TraceDepth_e mgw_trd; //mgw-TraceDepth
|
|
enum TraceDepth_e sgsn_trd; //sgsn-TraceDepth
|
|
enum TraceDepth_e ggsn_trd; //ggsn-TraceDepth
|
|
enum TraceDepth_e rnc_trd; //rnc-TraceDepth
|
|
enum TraceDepth_e bmsc_trd; //bmsc-TraceDepth
|
|
enum TraceDepth_e mme_trd; //mme-TraceDepth
|
|
enum TraceDepth_e sgw_trd; //sgw-TraceDepth
|
|
enum TraceDepth_e pgw_trd; //pgw-TraceDepth
|
|
enum TraceDepth_e enb_trd; //eNB-TraceDepth
|
|
}TraceDepthLst_s;
|
|
|
|
typedef struct TraceLst_s //trace List
|
|
{
|
|
u16 msc_list; //msc-s-List
|
|
u8 mgw_list; //mgw-List
|
|
u16 sgsn_list; //sgsn-List
|
|
u8 ggsn_list; //ggsn-List
|
|
u8 bmsc_list; //bmsc-List
|
|
u8 mme_list; //mme-List
|
|
u8 sgw_list; //sgw-List
|
|
u16 pgw_list; //pgw-List
|
|
|
|
u8 rnc_list; //rnc-List
|
|
u8 enb_list; //eNB-List
|
|
}TraceLst_s;
|
|
|
|
typedef struct MapATM_Arg // activate trace mode argument
|
|
{
|
|
u32 param_flag;
|
|
u8 imsi[IMSI_LEN];
|
|
u8 trace_ref[2]; // trace reference
|
|
u8 trace_type;
|
|
u8 omc_id[ISDN_LEN+1];// OMC ID
|
|
|
|
//umts add by gxchen
|
|
u8 trace_ref_2; //traceReference2
|
|
struct TraceDepthLst_s trace_depth; //traceDepthList
|
|
u16 trace_type_list; //traceNE-TypeList
|
|
struct TraceLst_s trace_if; //traceInterfaceList
|
|
struct TraceLst_s trace_event; //traceEventList
|
|
u8 trace_col_ent; //traceCollectionEntity
|
|
} MapATM_Arg;
|
|
|
|
typedef struct MapATM_Res // activate trace mode response
|
|
{
|
|
u32 param_flag;
|
|
u8 trace_supp_ind; //traceSupportIndicator umts add by gxchen
|
|
u8 user_error;
|
|
u8 provider_error;
|
|
} MapATM_Res;
|
|
|
|
typedef struct MapDTM_Arg // deactivate trace mode argument
|
|
{
|
|
u32 param_flag;
|
|
u8 imsi[IMSI_LEN];
|
|
u8 trace_ref[2]; // trace reference
|
|
|
|
u8 trace_ref_2; //traceReference2 umts add by gxchen
|
|
} MapDTM_Arg;
|
|
|
|
typedef struct MapDTM_Res // deactivate trace maode response
|
|
{
|
|
u32 param_flag;
|
|
u8 user_error;
|
|
u8 provider_error;
|
|
} MapDTM_Res;
|
|
|
|
typedef struct MapSIMSI_Arg // send IMSI argument
|
|
{
|
|
u32 param_flag;
|
|
u8 msisdn[ISDN_LEN+1];
|
|
} MapSIMSI_Arg;
|
|
|
|
typedef struct MapSIMSI_Res // send IMSI response
|
|
{
|
|
u32 param_flag;
|
|
u8 imsi[IMSI_LEN];
|
|
u8 user_error;
|
|
u8 provider_error;
|
|
} MapSIMSI_Res;
|
|
|
|
/* ++++++++++++++++++++++++++++++++++++++++++ */
|
|
/* mobile service structure, according 14.7.1 */
|
|
/* ++++++++++++++++++++++++++++++++++++++++++ */
|
|
typedef enum CanLocType_enum // cancel location type
|
|
{
|
|
update = 0, // update procedure
|
|
withdraw = 1 // subscription withdraw
|
|
} CanLocType_enum;
|
|
|
|
typedef enum TypeUpdate_e //typeOfUpdate
|
|
{
|
|
sgsnChg = 0, //sgsn-change
|
|
mmeChg = 1 //mme-change
|
|
}TypeUpdate_e;
|
|
|
|
typedef enum EquipStatus_enum // equipment status
|
|
{
|
|
whitelist = 0,
|
|
blacklist = 1,
|
|
greylist = 2
|
|
} EquipStatus_enum;
|
|
|
|
typedef enum NetAccMode_enum // network access mode
|
|
{
|
|
mscandsgsn = 0,
|
|
onlymsc = 1,
|
|
onlysgsn = 2
|
|
} NetAccMode_enum;
|
|
|
|
typedef enum SubStatus_enum // subscriber status
|
|
{
|
|
servicegrant = 0, // service granted
|
|
oprbarring = 1 // operator determined barring
|
|
} SubStatus_enum;
|
|
|
|
typedef enum IntraCugOpt_enum // intra CUG option
|
|
{
|
|
norestric = 0, // no CUG restriction
|
|
iccallbar = 1, // CUG ic call barring
|
|
ogcallbar = 2 // CUG og call barring
|
|
} IntraCugOpt_enum;
|
|
|
|
typedef enum RegSubsRes_enum // regional subscription response
|
|
{
|
|
netrestrict = 0, // network node area restricted
|
|
toomanyzc = 1, // too many zone code
|
|
zcconflict = 2, // zone code conflict
|
|
regnotsupport = 3 // regional subscription not support
|
|
} RegSubsRes_enum;
|
|
|
|
typedef struct ChgSuppISNE_s
|
|
{
|
|
u8 choice_flag;
|
|
union
|
|
{
|
|
u8 send_sub_data; //sendSubscriberData
|
|
u8 sub_data_store[7]; //subscriberDataStored
|
|
}choice;
|
|
}ChgSuppISNE_s;
|
|
|
|
typedef struct VlrCap_struct // VLR capability
|
|
{
|
|
u8 param_flag;
|
|
u8 camel_phase[3]; // supported camel phase
|
|
u8 sol_supp_ind; //solsaSupportIndicator add by gxchen
|
|
|
|
//umts add by gxchen
|
|
enum IstSuppInd_e ist_supp_ind; //istSupportIndicator
|
|
struct ChgSuppISNE_s chg_supp_isne; //superChargerSupportedInServingNetworkEntity
|
|
u8 long_ftn_supp; //longFTN-Supported
|
|
u16 supp_cap_set; //supportedLCS-CapabilitySets
|
|
u16 offer_camel; //offeredCamel4CSIs
|
|
u8 supp_type_ind; //supportedRAT-TypesIndicator
|
|
u8 long_Gr_id_supp;//longGroupID-Supported
|
|
} VlrCap_struct;
|
|
|
|
typedef struct SgsnCap_s //sgsn-Capability
|
|
{
|
|
u32 param_flag;
|
|
u8 sol_supp_ind; //solsaSupportIndicator
|
|
struct ChgSuppISNE_s chg_supp_isne; //superChargerSupportedInServingNetworkEntity
|
|
u8 gprs_supp_ind; //gprsEnhancementsSupportIndicator
|
|
u16 camel_phase; //supportedCamelPhases
|
|
u16 supp_cap_set; //supportedLCS-CapabilitySets
|
|
u16 offer_camel; //offeredCamel4CSIs
|
|
u8 scb_supp_ind; //smsCallBarringSupportIndicator
|
|
u8 supp_type_ind; //supportedRAT-TypesIndicator
|
|
u32 supp_feat; //supportedFeatures
|
|
}SgsnCap_s;
|
|
|
|
typedef struct AddInfo_s //add-info
|
|
{
|
|
u8 param_flag;
|
|
u8 imei_sv[8]; //imeisv
|
|
u8 skip_sub_data_update; //skipSubscriberDataUpdate
|
|
}AddInfo_s;
|
|
|
|
typedef struct PdnGwUpdate_s //pdn-gw-update
|
|
{
|
|
u8 param_flag;
|
|
struct
|
|
{
|
|
u8 apn_len;
|
|
u8 apn_data[APN_LEN];
|
|
}apn; //apn
|
|
u8 pdn_gw_id; //pdn-gw-Identity define later
|
|
u8 con_id; //contextId
|
|
}PdnGwUpdate_s;
|
|
typedef struct EpsInfo_s //eps-info
|
|
{
|
|
u8 choice_flag;
|
|
union
|
|
{
|
|
struct PdnGwUpdate_s gw_up;//pdn-gw-update
|
|
u8 isr_info; //isr-Information
|
|
}choice;
|
|
}EpsInfo_s;
|
|
|
|
typedef struct AuthSet_struct // authentication set
|
|
{
|
|
u8 param_flag;
|
|
u8 rand[RAND_LEN];
|
|
u8 sres[SRES_LEN];
|
|
u8 kc[KC_LEN];
|
|
} AuthSet_struct;
|
|
|
|
/*
|
|
typedef struct ReqInfo_struct // requested info
|
|
{
|
|
u8 param_flag;
|
|
u8 loc_info; // location information
|
|
u8 sub_state; // subscriber state
|
|
} ReqInfo_struct;
|
|
*/
|
|
typedef struct ReqInfo_struct // requested info
|
|
{
|
|
u8 param_flag;
|
|
u8 loc_info; // location information
|
|
u8 sub_state; // subscriber state
|
|
u8 cur_location;
|
|
u8 req_domain;
|
|
u8 imei;
|
|
u8 ms_classmark;
|
|
u8 mnp_req_info;
|
|
} ReqInfo_struct;
|
|
|
|
typedef struct SubIdent_struct // subscriber identity
|
|
{
|
|
u8 choice_flag;
|
|
union
|
|
{
|
|
u8 imsi[IMSI_LEN]; // flag = 1
|
|
u8 msisdn[ISDN_LEN+1]; // flag = 2
|
|
} choice;
|
|
} SubIdent_struct;
|
|
|
|
typedef struct PdpContext_struct // PDP context
|
|
{
|
|
u16 param_flag;
|
|
u8 pdpcontext_id; // PDP context ID
|
|
u8 pdp_type[2];
|
|
u8 pdp_add[PDP_LEN+1]; // PDP address
|
|
u8 qos_sub[3]; // QOS subscribed
|
|
u8 vplmn_allow; // VPLMN address allowed
|
|
struct
|
|
{
|
|
u8 apn_len;
|
|
u8 apn_data[APN_LEN];
|
|
} apn;
|
|
|
|
//umts add by gxchen
|
|
u8 ext_qos_sub[EXT_QOS_SUB_LEN+1]; //ext-QoS-Subscribed
|
|
u8 pdp_chg_char[2]; //pdp-ChargingCharacteristics
|
|
u8 ext2_qos_sub[EXT2_QOS_SUB_LEN+1]; //ext2-QoS-Subscribed 4
|
|
u8 ext3_qos_sub[EXT3_QOS_SUB_LEN+1]; //ext3-QoS-Subscribed 3
|
|
} PdpContext_struct;
|
|
|
|
typedef struct GprsSubsData_struct // GPRS subsequent data
|
|
{
|
|
u8 param_flag;
|
|
u8 data_include; // complete data list included
|
|
struct
|
|
{
|
|
u8 list_len;
|
|
struct PdpContext_struct pdp_context[PDPCONTEXT_LEN];
|
|
} gprs_list;
|
|
} GprsSubsData_struct;
|
|
|
|
typedef struct ExtFwdInfo_struct // ext forward info
|
|
{ // 0: CFU 1: CFB 2: CFNRy 3: CFNRc
|
|
u8 param_flag; // param_flag=0x01 => ss_code[0] & fwd_feat[0]
|
|
u8 ss_code[4];
|
|
struct FwdFeat_struct fwd_feat[4];
|
|
} ExtFwdInfo_struct;
|
|
|
|
typedef struct CallBarFeatList_struct
|
|
{
|
|
u8 param_flag; /*bit0-4 = array index0-4 */ /* code and status are always in pairs */
|
|
struct BSCode_struct bs_code[5];
|
|
u8 ss_status[5];
|
|
}CallBarFeatList_struct;
|
|
|
|
typedef struct ExtCallBarInfo_struct // ext call barring info
|
|
{ // 0: BAOC 1:BOIC 2:BOIC-exHPLMN 3:BAIC 4:BIC-Roam
|
|
u8 param_flag;
|
|
u8 ss_code[5];
|
|
struct CallBarFeatList_struct bar_list[5];
|
|
u8 ss_status[5];
|
|
struct BSCode_struct bs_code[5];
|
|
} ExtCallBarInfo_struct;
|
|
|
|
typedef struct CugSubs_struct // CUG subscription
|
|
{
|
|
u8 param_flag;
|
|
u16 cug_index;
|
|
u8 cug_lock[CUGLOCK_LEN]; // CUG interlock
|
|
enum IntraCugOpt_enum cug_opt;// intra CUG options
|
|
struct BSCode_struct bs_code;
|
|
} CugSubs_struct;
|
|
|
|
typedef struct CugFeat_struct // CUG feature
|
|
{
|
|
u8 param_flag;
|
|
struct BSCode_struct bs_code;
|
|
u16 cug_indicator; // preferntial CUG indicator
|
|
u8 cug_restric; // inter CUG restrictions
|
|
} CugFeat_struct;
|
|
|
|
typedef struct CugInfo_struct // CUG info
|
|
{
|
|
u8 param_flag;
|
|
struct
|
|
{
|
|
u8 list_len;
|
|
struct CugSubs_struct cug_subs[CUG_LEN];
|
|
} subs_list; // CUG subscription list
|
|
struct
|
|
{
|
|
u8 list_len;
|
|
struct CugFeat_struct cug_feat[EXTBSG_LEN];
|
|
} feat_list; // CUG feature list
|
|
} CugInfo_struct;
|
|
|
|
typedef struct McSSInfo_s //mc-SS-Info
|
|
{
|
|
u8 param_flag;
|
|
u8 ss_code; //ss-Code
|
|
u8 ss_status[5]; //ss-Status
|
|
u8 nbr_sb; //nbrSB (2~7)
|
|
u8 nbr_user; //nbrUser (1~7)
|
|
}McSSInfo_s;
|
|
|
|
typedef struct ExtSsData_struct // ext SS data
|
|
{// 0: CLIP 1: CLIR 2: COLP 3: COLR
|
|
u32 param_flag;
|
|
u8 ss_code[SSDATA_NUM];
|
|
u8 ss_status[SSDATA_NUM];
|
|
struct SsSubsOpt_struct subs_opt[SSDATA_NUM]; // ss subscription option
|
|
struct BSCode_struct bs_code[SSDATA_NUM];
|
|
} ExtSsData_struct;
|
|
|
|
typedef struct ExtSsInfo_struct
|
|
{
|
|
u8 param_flag;
|
|
struct ExtFwdInfo_struct fwd_info;
|
|
struct ExtCallBarInfo_struct call_info;
|
|
struct CugInfo_struct cug_info;
|
|
struct ExtSsData_struct ss_data;
|
|
struct EmlppInfo_struct emlpp_info;
|
|
} ExtSsInfo_struct;
|
|
|
|
typedef struct OdbData_struct // ODB data
|
|
{
|
|
u8 param_flag;
|
|
u32 odb_general; // ODB general data
|
|
u32 odb_hplmn; // ODB hplmn data
|
|
} OdbData_struct;
|
|
|
|
typedef struct VGCData_struct // voice group call data
|
|
{
|
|
u8 param_flag;
|
|
u8 group_id[3];
|
|
|
|
//umts
|
|
u8 add_sub; //additionalSubscriptions
|
|
u8 add_info[17]; //additionalInfo
|
|
u8 long_group_id[4]; //longGroupId
|
|
} VGCData_struct;
|
|
|
|
typedef struct VBSData_struct //voice broadcast data
|
|
{
|
|
u8 param_flag;
|
|
u8 group_id[3];
|
|
u8 init_entitle; // broadcast init entitlement
|
|
|
|
u8 long_group_id[4]; //longGroupId umts
|
|
} VBSData_struct;
|
|
|
|
typedef struct SsCsi_struct // SS CSI
|
|
{
|
|
u8 param_flag;
|
|
struct
|
|
{
|
|
u8 list_len;
|
|
u8 ss_code[CAMELSS_LEN];
|
|
} event_list; // ss event list
|
|
u8 scf_add[ISDN_LEN+1];
|
|
|
|
//umts add by gxchen
|
|
u8 ntfy_cse; //notificationToCSE
|
|
u8 csi_active; //csi-Active
|
|
} SsCsi_struct;
|
|
|
|
typedef enum GTriDetPnt_e //gprs-TriggerDetectionPoint
|
|
{
|
|
GTDP_Attach = 1, //attach
|
|
GTDP_Attach_Chg_Pos = 2, //attachChangeOfPosition
|
|
GTDP_Pdp_Con_Est = 11, //pdp-ContextEstablishment
|
|
GTDP_Pdp_Con_Est_Ack = 12, //pdp-ContextEstablishmentAcknowledgement
|
|
GTDP_Pdp_Con_Chg_Pos = 14 //pdp-ContextChangeOfPosition
|
|
}GTriDetPnt_e;
|
|
typedef enum TpduTypeCrit_e //tpdu-TypeCriterion
|
|
{
|
|
Tpdu_sms_Deliver = 0, //sms-DELIVER
|
|
Tpdu_sms_Submit_report, //sms-SUBMIT-REPORT
|
|
Tpdu_sms_Status_report //sms-STATUS-REPORT
|
|
}TpduTypeCrit_e;
|
|
typedef struct GCTDPData_s //gprs-CamelTDPDataList
|
|
{
|
|
u8 param_flag;
|
|
enum GTriDetPnt_e det_point; //gprs-TriggerDetectionPoint
|
|
u32 service_key; //serviceKey
|
|
u8 scf_add[ISDN_LEN+1]; //gsmSCF-Address
|
|
enum DefCallHand_enum def_hand; //defaultSessionHandling
|
|
}GCTDPData_s;
|
|
typedef struct GprsCsi_s //gprs-CSI
|
|
{
|
|
u8 param_flag;
|
|
struct GCTDPData_s gc_tdp_data[TDPDATA_NUM];//gprs-CamelTDPDataList
|
|
u8 camel_caphand; //camelCapabilityHandling
|
|
u8 ntfy_cse; //notificationToCSE
|
|
u8 csi_active; //csi-Active
|
|
}GprsCsi_s;
|
|
|
|
typedef struct SMSCTDPCrit_s //mt-smsCAMELTDP-CriteriaList
|
|
{
|
|
u8 param_flag;
|
|
enum SMSTriDetPnt_enum det_point; //sms-TriggerDetectionPoint
|
|
struct
|
|
{
|
|
u8 typecrit_len;
|
|
enum TpduTypeCrit_e type_crit[5]; //tpdu-TypeCriterion
|
|
}tt_crit; //tpdu-TypeCriterion
|
|
}SMSCTDPCrit_s;
|
|
|
|
|
|
typedef struct VCSubsInfo_struct // VLR CAMEL subscription info
|
|
{
|
|
u8 param_flag;
|
|
struct OCsi_struct o_csi; //O-CSI
|
|
struct SsCsi_struct ss_csi; //SS-CSI
|
|
struct OBCritLst_struct tdp_list; //o-bcsm camel TDP criteria list
|
|
struct SMSCsi_struct sms_csi; // SMS-CSI
|
|
|
|
u8 tif_csi; //tif-CSI
|
|
//umts
|
|
struct MCsi_s m_csi; //m-CSI
|
|
struct VTCsi_s vt_csi; //vt-CSI
|
|
struct TBCritLst_s tb_list; //t-BCSM-CAMEL-TDP-CriteriaList
|
|
struct DCsi_s d_csi; //d-CSI
|
|
struct SMSCsi_struct mt_sms_csi; //mt-sms-CSI
|
|
}VCSubsInfo_struct;
|
|
|
|
typedef struct SgsnCamelSub_s //sgsn-CAMEL-SubscriptionInfo
|
|
{
|
|
u32 param_flag;
|
|
struct GprsCsi_s gprs_csi; //gprs-CSI
|
|
struct SMSCsi_struct mo_sms_csi; //mo-sms-CSI
|
|
struct SMSCsi_struct mt_sms_csi; //mt-sms-CSI
|
|
struct
|
|
{
|
|
u8 smscri_len;
|
|
struct SMSCTDPCrit_s sms_cri[TDPDATA_NUM];
|
|
}mtsms_cri_list; //mt-smsCAMELTDP-CriteriaList
|
|
struct MCsi_s mg_csi; //mg-csi
|
|
}SgsnCamelSub_s;
|
|
|
|
typedef struct GprsSDWithdraw_struct // GPRS subscription data withdrwa
|
|
{
|
|
u8 choice_flag;
|
|
union
|
|
{
|
|
u8 allgprs_data; // flag = 1
|
|
struct // flag = 2
|
|
{
|
|
u8 list_len;
|
|
u8 context_id[PDPCONTEXT_LEN];
|
|
} context_list; // context id list
|
|
} choice;
|
|
} GprsSDWithdraw_struct;
|
|
|
|
typedef struct MapUL_Arg // update location argument
|
|
{
|
|
u32 param_flag;
|
|
u8 imsi[IMSI_LEN];
|
|
u8 msc_num[ISDN_LEN+1]; // MSC number
|
|
u8 vlr_num[ISDN_LEN+1]; // VLR number
|
|
u8 lmsi[LMSI_LEN];
|
|
struct VlrCap_struct vlr_cap;// VLR capability
|
|
u8 roaming_num[ISDN_LEN+1];
|
|
|
|
//umts add by gxchen
|
|
u8 inform_pre_ne; //informPreviousNetworkEntity
|
|
u8 cs_lcs_not_supp; //cs-LCS-NotSupportedByUE
|
|
u8 v_gmlc_add[17]; //v-gmlc-Address
|
|
struct AddInfo_s add_info; //add-info
|
|
struct PageArea_s page_area; //pagingArea
|
|
u8 skip_sub_data_update; //skipSubscriberDataUpdate
|
|
} MapUL_Arg;
|
|
|
|
typedef struct MapUL_Res // update location response
|
|
{
|
|
u32 param_flag;
|
|
u8 hlr_num[ISDN_LEN+1];
|
|
|
|
//umts add by gxchen
|
|
u8 add_cap; //add-Capability
|
|
u8 page_area_cap; //pagingArea-Capability
|
|
|
|
u8 user_error; // bit 31, 0x80000000
|
|
u8 provider_error; // bit 30, 0x40000000
|
|
} MapUL_Res;
|
|
|
|
typedef struct CL_identity
|
|
{
|
|
u32 choice_flag;
|
|
union
|
|
{
|
|
u8 imsi[IMSI_LEN];
|
|
struct imsi_withLmsi
|
|
{
|
|
u8 imsi[IMSI_LEN];
|
|
u8 lmsi[4];
|
|
} imsi_withlmsi;
|
|
} choice;
|
|
} CL_identity;
|
|
|
|
typedef struct MapCL_Arg // cancel location argument
|
|
{
|
|
u32 param_flag;
|
|
CL_identity id;
|
|
enum CanLocType_enum type; // cancel location type
|
|
|
|
enum TypeUpdate_e type_update; //typeOfUpdate umts
|
|
} MapCL_Arg;
|
|
|
|
|
|
typedef struct MapNP_Arg //NoteSubscriberPresent argumnet
|
|
{
|
|
u8 param_flag;
|
|
u8 imsi[IMSI_LEN];
|
|
} MapNP_Arg;
|
|
|
|
typedef struct MapPUSSD_Arg //ProcessUnstructuredSS-Data Response
|
|
{
|
|
u8 param_flag;
|
|
u8 ussd_len;
|
|
u8 ussd_data[200];
|
|
} MapPUSSD_Arg;
|
|
|
|
|
|
|
|
typedef struct MapPUSSD_Res //ProcessUnstructuredSS-Data Response
|
|
{
|
|
u8 param_flag;
|
|
u8 ussd_len;
|
|
u8 ussd_data[200];
|
|
} MapPUSSD_Res;
|
|
|
|
|
|
typedef struct MapSA_Arg //BeginSubscriberActivity argumnet
|
|
{
|
|
u8 param_flag;
|
|
u8 imsi[IMSI_LEN+1];
|
|
u8 enity_len;
|
|
u8 Enity_num[9];
|
|
} MapSA_Arg;
|
|
|
|
typedef struct MapHO_Arg //perform hand over argument
|
|
{
|
|
u8 param_flag;
|
|
u8 tgt_cellID[7];
|
|
u8 tgt_cellid_len;
|
|
u8 srv_cellID[7];
|
|
u8 srv_cellid_len;
|
|
u8 chl_type[10];
|
|
u8 chl_type_len;
|
|
u8 class_mark[2];
|
|
u8 ho_priority;
|
|
u8 kc[8];
|
|
} MapHO_Arg;
|
|
|
|
typedef struct MapHO_Res //perform hand over response
|
|
{
|
|
u8 param_flag;
|
|
u8 ho_num[9];
|
|
u8 ho_num_len;
|
|
struct
|
|
{
|
|
u8 protocol_id;
|
|
u8 singal_info_len;
|
|
u8 signal_info[200];
|
|
} access_singal_info;
|
|
} MapHO_Res;
|
|
|
|
|
|
|
|
typedef struct MapCL_Res // cancel location response
|
|
{
|
|
u32 param_flag;
|
|
u8 user_error;
|
|
u8 provider_error;
|
|
} MapCL_Res;
|
|
|
|
typedef struct MapPMS_Arg // purge MS argument
|
|
{
|
|
u32 param_flag;
|
|
u8 imsi[IMSI_LEN];
|
|
u8 vlr_num[ISDN_LEN+1]; // VLR number
|
|
u8 sgsn_num[ISDN_LEN+1]; // SGSN number
|
|
} MapPMS_Arg;
|
|
|
|
typedef struct MapPMS_Res // purge MS response
|
|
{
|
|
u32 param_flag;
|
|
u8 freeze_tmsi; // freeze TMSI
|
|
u8 freeze_ptmsi; // freeze P-TMSI
|
|
|
|
u8 freeze_mtmsi; //freezeM-TMSI umts add by gxchen
|
|
u8 user_error;
|
|
u8 provider_error;
|
|
} MapPMS_Res;
|
|
|
|
typedef struct MapSI_Arg // send identification argument
|
|
{
|
|
u32 param_flag;
|
|
u8 tmsi[TMSI_LEN];
|
|
|
|
//umts add by gxchen start
|
|
u8 num_req_vec; //number of requested vectors (1...5)
|
|
u8 msc_num[ISDN_LEN+1]; //msc number
|
|
u8 pre_lai[5]; //previous LAI
|
|
u8 hop_counter; //hop counter (0...3)
|
|
//add by gxchen end
|
|
} MapSI_Arg;
|
|
|
|
//add by gxchen start
|
|
typedef enum _Authlist_e
|
|
{
|
|
AUTH_LIST_TRIPLET = 0,
|
|
AUTH_LIST_QUINTUPLET=1
|
|
}Authlist_e;
|
|
typedef enum _Auth_e //_AuthSecCon_e
|
|
{
|
|
AUTH_GSM=0, //AUTH_SEC_CON_GSM
|
|
AUTH_UMTS=1 //AUTH_SEC_CON_UMTS
|
|
}Auth_e;
|
|
|
|
typedef struct _Triplet_st //triplet
|
|
{
|
|
u8 param_flag;
|
|
u8 rand[RAND_LEN];
|
|
u8 sres[SRES_LEN];
|
|
u8 kc[KC_LEN];
|
|
}Triplet_st;
|
|
typedef struct _Quintuplet_st //quintuplet
|
|
{
|
|
u8 param_flag;
|
|
u8 rand[RAND_LEN];
|
|
u8 xres[XRES_LEN];
|
|
u8 ck[CK_LEN];
|
|
u8 ik[IK_LEN];
|
|
u8 autn[AUTN_LEN];
|
|
}Quintuplet_st;
|
|
typedef struct EpsAuthSet_s //eps-AuthenticationSet
|
|
{
|
|
u8 param_flag;
|
|
u8 rand[RAND_LEN];
|
|
u8 xres[XRES_LEN];
|
|
u8 autn[AUTN_LEN];
|
|
u8 kasme[IK_LEN]; //Key for the Access Security Management Entity
|
|
}EpsAuthSet_s;
|
|
|
|
typedef struct _AuthSetListGsm_st //authenticationSetList
|
|
{
|
|
u8 auth_len;
|
|
AuthSet_struct auth_set[AUTHLIST_LEN];
|
|
}AuthSetListGsm_st;
|
|
|
|
typedef struct _AuthSetListUmts_st //authenticationSetList UMTS
|
|
{
|
|
// u8 auth_len;
|
|
Authlist_e choice_flag; //0:tripletList, 1:quintupletList
|
|
union
|
|
{
|
|
struct
|
|
{
|
|
u8 tri_len; //auth_len
|
|
Triplet_st triplet[AUTHLIST_LEN];
|
|
}tri_list;
|
|
struct
|
|
{
|
|
u8 quin_len; //auth_len
|
|
Quintuplet_st quintuplet[AUTHLIST_LEN];
|
|
}quin_list;
|
|
}choice;
|
|
}AuthSetListUmts_st;
|
|
|
|
typedef struct _gsmSecCon_st //gsm-SecurityContextData
|
|
{
|
|
u8 param_flag;
|
|
u8 kc[KC_LEN];
|
|
u8 cksn;
|
|
}GsmSecCon_st;
|
|
typedef struct _umtsSecCon_st //umts-SecurityContextData
|
|
{
|
|
u8 param_flag;
|
|
u8 ck[CK_LEN];
|
|
u8 ik[IK_LEN];
|
|
u8 ksi;
|
|
}UmtsSecCon_st;
|
|
typedef struct _AuthSecCon_st //currentSecurityContext
|
|
{
|
|
Auth_e choice_flag; //0:gsm-SecurityContextData, 1:umts-SecuritycontextData
|
|
union
|
|
{
|
|
GsmSecCon_st gsmCon;
|
|
UmtsSecCon_st umtsCon;
|
|
}choice;
|
|
}AuthSecCon_st;
|
|
typedef struct MapSI_Res // send identification response
|
|
{
|
|
u32 param_flag;
|
|
u8 imsi[IMSI_LEN];
|
|
struct
|
|
{
|
|
u8 auth_len;
|
|
struct AuthSet_struct auth_set[AUTHLIST_LEN];
|
|
} authlist;
|
|
u8 provider_error;
|
|
} MapSI_Res;
|
|
//add by gxchen end
|
|
|
|
typedef enum UserRatType_e //usedRAT-Type
|
|
{
|
|
Rat_Utran = 0, //utran
|
|
Rat_Geran = 1, //geran
|
|
Rat_Gan = 2, //gan
|
|
Rat_HspaEvo = 3, //i-hspa-evolution
|
|
Rat_EUtran = 4 //e-utran
|
|
}UserRatType_e;
|
|
typedef struct MapUGL_Arg // update GPRS location argument
|
|
{
|
|
u32 param_flag;
|
|
u8 imsi[IMSI_LEN];
|
|
u8 sgsn_num[ISDN_LEN+1]; // SGSN number
|
|
u8 sgsn_add[GSN_LEN+1]; // SGSN address
|
|
|
|
struct SgsnCap_s sgsn_cap; //sgsn-Capability
|
|
//umts add by gxchen
|
|
u8 inform_pre_ne; //informPreviousNetworkEntity
|
|
u8 ps_lcs_not_supp; //ps-LCS-NotSupportedByUE
|
|
u8 v_gmlc_add[17]; //v-gmlc-Address
|
|
struct AddInfo_s add_info; //add-info
|
|
struct EpsInfo_s eps_info; //eps-info
|
|
u8 ser_node_type_ind; //servingNodeTypeIndicator
|
|
u8 skip_sub_data_update; //skipSubscriberDataUpdate
|
|
enum UserRatType_e rat_type; //usedRAT-Type
|
|
u8 gprs_subdata_notneed; //gprsSubscriptionDataNotNeeded
|
|
u8 node_type_ind; //nodeTypeIndicator
|
|
} MapUGL_Arg;
|
|
|
|
typedef struct MapUGL_Res // update GPRS location response
|
|
{
|
|
u32 param_flag;
|
|
u8 hlr_num[ISDN_LEN+1];
|
|
|
|
//umts add by gxchen
|
|
u8 add_cap; //add-Capability
|
|
u8 sgsn_mme_sep_supp; //sgsn-mmeSeparationSupported
|
|
|
|
u8 user_error;
|
|
u8 provider_error;
|
|
} MapUGL_Res;
|
|
|
|
typedef struct MapPSI_Arg // provide subscriber info argument
|
|
{
|
|
u32 param_flag;
|
|
u8 imsi[IMSI_LEN];
|
|
u8 lmsi[LMSI_LEN];
|
|
struct ReqInfo_struct req_info;// requested info
|
|
} MapPSI_Arg;
|
|
|
|
typedef struct MapPSI_Res // provide subscriber info response
|
|
{
|
|
u32 param_flag;
|
|
struct SubInfo_struct sub_info;// subscriber info
|
|
u8 user_error;
|
|
u8 provider_error;
|
|
} MapPSI_Res;
|
|
|
|
typedef struct MapATI_Arg // any time interrogation argument
|
|
{
|
|
u32 param_flag;
|
|
struct SubIdent_struct sub_ident; // subscriber identity
|
|
struct ReqInfo_struct req_info; // requested info
|
|
u8 scf_add[ISDN_LEN+1]; // gsmSCF address
|
|
} MapATI_Arg;
|
|
|
|
typedef struct MapATI_Res // any time interrogation response
|
|
{
|
|
u32 param_flag;
|
|
struct SubInfo_struct sub_info; // subscriber info
|
|
u8 user_error;
|
|
u8 provider_error;
|
|
} MapATI_Res;
|
|
|
|
typedef struct MapATSI_Arg // any time subscription interrogation argument
|
|
{
|
|
u32 param_flag;
|
|
struct SubIdent_struct sub_ident; // subscriber identity
|
|
} MapATSI_Arg;
|
|
|
|
typedef struct MapATSI_Res // any time interrogation response
|
|
{
|
|
u32 param_flag;
|
|
struct VCSubsInfo_struct subs_info; //(10)Camel subscription info
|
|
u8 user_error;
|
|
u8 provider_error;
|
|
} MapATSI_Res;
|
|
|
|
|
|
typedef struct MapPHO_Arg // prepare handover argument
|
|
{
|
|
u32 param_flag;
|
|
u8 target_id[GCID_LEN]; // target cell id
|
|
u8 numnot_require; // ho-number not required
|
|
struct ExtSigInfo_struct bss_apdu; // bss APDU
|
|
} MapPHO_Arg;
|
|
|
|
typedef struct MapPHO_Res // prepare handover response
|
|
{
|
|
u32 param_flag;
|
|
u8 ho_num[ISDN_LEN+1]; // handover number
|
|
struct ExtSigInfo_struct bss_apdu; // bss APDU
|
|
u8 user_error;
|
|
u8 provider_error;
|
|
} MapPHO_Res;
|
|
|
|
typedef struct MapSES_Arg // send end signal argument
|
|
{
|
|
u32 param_flag;
|
|
struct ExtSigInfo_struct bss_apdu; // bss APDU
|
|
} MapSES_Arg;
|
|
|
|
typedef struct MapSES_Res // send end signal response
|
|
{
|
|
u32 param_flag;
|
|
u8 provider_error;
|
|
} MapSES_Res;
|
|
|
|
typedef struct MapPAS_Arg // process access signalling argument
|
|
{
|
|
u32 param_flag;
|
|
struct ExtSigInfo_struct bss_apdu;
|
|
} MapPAS_Arg;
|
|
|
|
typedef struct MapFAS_Arg // forward access signalling argument
|
|
{
|
|
u32 param_flag;
|
|
struct ExtSigInfo_struct bss_apdu;
|
|
} MapFAS_Arg;
|
|
|
|
typedef struct MapPSHO_Arg // prepare subsequent handover argument
|
|
{
|
|
u32 param_flag;
|
|
u8 target_id[GCID_LEN]; // target cell id
|
|
u8 msc_num[ISDN_LEN+1]; // target MSC number
|
|
struct ExtSigInfo_struct bss_apdu;
|
|
} MapPSHO_Arg;
|
|
|
|
typedef struct MapPSHO_Res // prepare subsequent handover response
|
|
{
|
|
u32 param_flag;
|
|
struct ExtSigInfo_struct bss_apdu;
|
|
u8 user_error;
|
|
u8 provider_error;
|
|
} MapPSHO_Res;
|
|
|
|
|
|
typedef struct MapPFSHO_Arg // preform subsequent handover argument
|
|
{
|
|
u32 param_flag;
|
|
u8 target_id[GCID_LEN]; // target cell id
|
|
u8 service_id[GCID_LEN]; // Serving cell id
|
|
u8 msc_num[ISDN_LEN+1]; // target MSC number
|
|
u8 classmark_info[2];
|
|
} MapPFSHO_Arg;
|
|
|
|
typedef struct MapPFSHO_Res // preform subsequent handover response
|
|
{
|
|
u32 param_flag;
|
|
struct ExtSigInfo_struct access_sig_info;
|
|
u8 user_error;
|
|
u8 provider_error;
|
|
} MapPFSHO_Res;
|
|
|
|
|
|
typedef struct MapNIHO_Arg // preform note internal hand over
|
|
{
|
|
u32 param_flag;
|
|
u8 ho_type; // handover type
|
|
u8 target_id[GCID_LEN];
|
|
struct ExtSigInfo_struct channel_id;
|
|
} MapNIHO_Arg;
|
|
|
|
|
|
//add by gxchen start
|
|
typedef struct _AuthReSynInfo_st //re-synchronisationInfo
|
|
{
|
|
u8 param_flag;
|
|
u8 rand[RAND_LEN];
|
|
u8 auts[AUTS_LEN];
|
|
}AuthReSynInfo_st;
|
|
typedef enum _AuthNodeType_e //requestingNodeType
|
|
{
|
|
AUTH_VLR=0, //vlr
|
|
AUTH_SGSN=1, //sgsn
|
|
AUTH_SCSCF=2, //s-cscf
|
|
AUTH_BSF=3, //bsf
|
|
AUTH_GAN=4, //gan-aaa-server
|
|
AUTH_WLAN=5, //wlan-aaa-server
|
|
AUTH_MME=16, //mme
|
|
AUTH_MME_SGSN=17 //mme-sgsn
|
|
}AuthNodeType_e;
|
|
//add by gxchen end
|
|
|
|
typedef struct MapSAI_Arg // send authenticate info argument
|
|
{
|
|
u32 param_flag;
|
|
u8 imsi[IMSI_LEN];
|
|
|
|
//add by gxchen start umts
|
|
u8 num_req_vec; //number of requested vectors (1...5)
|
|
u8 seg_prohibit; //segmentationProhibited
|
|
u8 imm_res_prefer; //immediateResponsePreferred
|
|
AuthReSynInfo_st resyn_info; //re-synchronisation info
|
|
AuthNodeType_e node_type; //requestingNodeType
|
|
u8 req_plmn_id[3]; //requestingPLMN-Id
|
|
u8 num_req_add_vec; //number of requested additional vectors (1...5)
|
|
u8 add_vec_eps; //additionalVectorsAreForEPS
|
|
//add by gxchen end
|
|
} MapSAI_Arg;
|
|
|
|
//modify by gxchen
|
|
typedef struct MapSAI_Res_GSM // send authenticate info response GSM
|
|
{
|
|
u32 param_flag;
|
|
struct
|
|
{
|
|
u8 auth_len;
|
|
struct AuthSet_struct auth_set[AUTHLIST_LEN];
|
|
} authlist;
|
|
u8 user_error;
|
|
u8 provider_error;
|
|
} MapSAI_Res_GSM;
|
|
typedef struct MapSAI_Res_UMTS // send authenticate info response UMTS
|
|
{
|
|
u32 param_flag;
|
|
AuthSetListUmts_st authlist; //authenticationSetList
|
|
struct
|
|
{
|
|
u8 auth_len;
|
|
EpsAuthSet_s eps_auth_set[AUTHLIST_LEN];
|
|
}eps_authlist; //eps-AuthenticationSetList
|
|
u8 user_error;
|
|
u8 provider_error;
|
|
}MapSAI_Res_UMTS;
|
|
|
|
typedef struct MapSAI_Res // send authenticate info response
|
|
{
|
|
u32 param_flag;
|
|
Auth_e choice_flag;
|
|
union
|
|
{
|
|
struct
|
|
{
|
|
struct
|
|
{
|
|
u8 auth_len;
|
|
struct AuthSet_struct auth_set[AUTHLIST_LEN];
|
|
} authlist; //authenticationSetList
|
|
}gsm;
|
|
struct
|
|
{
|
|
AuthSetListUmts_st authlist; //authenticationSetList
|
|
struct
|
|
{
|
|
u8 auth_len;
|
|
EpsAuthSet_s eps_auth_set[AUTHLIST_LEN];
|
|
}eps_authlist; //eps-AuthenticationSetList
|
|
}umts;
|
|
}choice;
|
|
u8 user_error;
|
|
u8 provider_error;
|
|
}MapSAI_Res;
|
|
/*typedef struct MapSAI_Res // send authenticate info response
|
|
{
|
|
u32 param_flag;
|
|
union
|
|
{
|
|
AuthSetListGsm_st gsm;
|
|
AuthSetListUmts_st umts;
|
|
}choice;
|
|
u8 user_error;
|
|
u8 provider_error;
|
|
} MapSAI_Res;
|
|
*/
|
|
|
|
//add by gxchen start
|
|
typedef enum _AuthFailCause_e
|
|
{
|
|
AUTH_WRONG_USER_RESPONSE = 0, //wrong user response
|
|
AUTH_WRONG_NET_SIGNATURE = 1 //wrong network signature
|
|
}AuthFailCause_e;
|
|
typedef enum _AuthAccessType_e
|
|
{
|
|
AUTH_CALL = 0, //call
|
|
AUTH_EMER_CALL = 1, //emergencyCall
|
|
AUTH_LOC_UPDATE = 2, //locationUpdating
|
|
AUTH_SU_SERVICE = 3, //supplementaryService
|
|
AUTH_SMS = 4, //shortMessage
|
|
AUTH_GPRS_ATTACH = 5, //gprsAttach
|
|
AUTH_RA_UPDATE = 6, //routingAreaUpdating
|
|
AUTH_SER_REQUEST = 7, //serviceRequest
|
|
AUTH_PDP_CON_ACT = 8, //pdpContextActivation
|
|
AUTH_PDP_CON_DEACT = 9, //pdpContextDeactivation
|
|
AUTH_GPRS_DETACH = 10, //gprsDetach
|
|
}AuthAccessType_e;
|
|
typedef enum _AuthFailReportError_e
|
|
{
|
|
AUTH_SYS_FAIL = 0, //system failure
|
|
AUTH_UNEXP_VAL = 1, //unexpected data value
|
|
AUTH_UNK_SUB = 2 //unknown subscriber
|
|
}AuthFailReportError_e;
|
|
|
|
typedef struct MapAuthFailReport_Arg //authentication failure report argument
|
|
{
|
|
u32 param_flag;
|
|
u8 imsi[IMSI_LEN];
|
|
AuthFailCause_e cause;
|
|
u8 reattemp; // 0: fail, 1: true
|
|
AuthAccessType_e access_type;
|
|
u8 rand[RAND_LEN];
|
|
u8 vlr_num[ISDN_LEN+1]; // vlr-number [0]
|
|
u8 sgsn_num[ISDN_LEN+1]; // sgsn-number [1]
|
|
}MapAuthFailReport_Arg;
|
|
|
|
typedef struct MapAuthFailReport_Res //authentication failure report response
|
|
{
|
|
u32 param_flag;
|
|
u8 user_error;
|
|
u8 provider_error;
|
|
}MapAuthFailReport_Res;
|
|
//add by gxchen end
|
|
|
|
typedef struct MapCIMEI_Arg // check IMEI argument
|
|
{
|
|
u32 param_flag;
|
|
u8 imei[IMEI_LEN];
|
|
} MapCIMEI_Arg;
|
|
|
|
typedef struct MapCIMEI_Res // check IMEI response
|
|
{
|
|
u32 param_flag;
|
|
enum EquipStatus_enum equip_status; // equipment status
|
|
u8 user_error;
|
|
u8 provider_error;
|
|
} MapCIMEI_Res;
|
|
|
|
typedef struct MapISD_Arg // insert subscriber data argument
|
|
{
|
|
u32 param_flag;
|
|
u8 imsi[IMSI_LEN]; //(0)
|
|
u8 msisdn[ISDN_LEN+1]; //(1)
|
|
u8 category; //(2)
|
|
enum SubStatus_enum sub_status; //(3)subscriber status
|
|
struct OdbData_struct odb_data; //(4)
|
|
u32 bearer_data; //(5)
|
|
u16 tele_data; //(6)
|
|
struct ExtSsInfo_struct ss_info; //(7)
|
|
u8 roam_feature; //(8)roaming restriction due to unsupported feature
|
|
struct
|
|
{
|
|
u8 list_len;
|
|
u8 zone_code[ZONECODE_LEN][2];
|
|
} zc_list; //(9):zone code list
|
|
struct
|
|
{
|
|
u8 list_len;
|
|
struct VBSData_struct vbs_data[VBS_LEN];
|
|
} vbsdata_list; //(10):VBS data list
|
|
struct
|
|
{
|
|
u8 list_len;
|
|
struct VGCData_struct vgc_data[VGCS_LEN];
|
|
} vgcdata_list; //(11)VGC data list
|
|
struct VCSubsInfo_struct subs_info; //(12)VLR Camel subscription info
|
|
struct NaeaPrefCi_struct naea_ci; //(13)NAEA preferred CI
|
|
struct GprsSubsData_struct gprs_data; //(14)GPRS subscription data
|
|
u8 roamsgsn_feature; //(15)roaming restricted in SGSN due to unsupported feature
|
|
enum NetAccMode_enum net_mode; //(16)network access mode
|
|
|
|
//struct LsaInfo_s lsa_info;//lsaInformation
|
|
u8 lmu_ind; //lmu-Indicator
|
|
//struct LcsInfo_s lcs_info;//lcsInformation
|
|
//umts add by gxchen
|
|
u8 ist_alert_timer; //istAlertTimer
|
|
u8 chg_supp_hlr[7]; //superChargerSupportedInHLR
|
|
struct McSSInfo_s mc_ss_info; //mc-SS-Info
|
|
u8 cs_allo_prior; //cs-AllocationRetentionPriority
|
|
struct SgsnCamelSub_s sgsn_camel_sub; //sgsn-CAMEL-SubscriptionInfo
|
|
u8 chg_char[2]; //chargingCharacteristics
|
|
u8 acc_restrict_data; //accessRestrictionData
|
|
u8 ics_ind; //ics-Indicator
|
|
//eps-SubscriptionData
|
|
//csg-SubscriptionDataList
|
|
}MapISD_Arg;
|
|
|
|
typedef struct MapISD_Res // insert subscriber data response
|
|
{
|
|
u32 param_flag;
|
|
u16 tele_data;
|
|
u32 bearer_data;
|
|
struct
|
|
{
|
|
u8 sslist_len;
|
|
u8 ss_code[SS_LEN];
|
|
} ss_list; // ss list
|
|
u32 odb_data; // odb general data
|
|
enum RegSubsRes_enum subs_res; // regional subscription response
|
|
u8 camel_phase[3]; // supported camel phases
|
|
|
|
//umts add by gxchen
|
|
u16 offer_camel; //offeredCamel4CSIs
|
|
u32 supp_feat; //supportedFeatures
|
|
|
|
u8 user_error;
|
|
u8 provider_error;
|
|
} MapISD_Res;
|
|
|
|
typedef struct MapSP_Arg//send parameters argument
|
|
{
|
|
u8 param_flag;
|
|
SubId_struct sub_id;
|
|
u8 ReqPara_num;
|
|
u8 ReqPara[2];
|
|
} MapSP_Arg;
|
|
|
|
typedef struct Sub_data_struct
|
|
{
|
|
u32 param_flag;
|
|
u8 imsi[IMSI_LEN]; //(0) **** unused
|
|
u8 msisdn[ISDN_LEN+1]; //(1)
|
|
u8 category; //(2)
|
|
enum SubStatus_enum sub_status; //(3)subscriber status
|
|
struct OdbData_struct odb_data; //(4)
|
|
u32 bearer_data; //(5)
|
|
u16 tele_data; //(6)
|
|
struct ExtSsInfo_struct ss_info; //(7)
|
|
u8 roam_feature; //(8)roaming restriction due to unsupported feature
|
|
struct
|
|
{
|
|
u8 list_len;
|
|
u8 zone_code[ZONECODE_LEN][2];
|
|
} zc_list; //(9):zone code list
|
|
} Sub_data_struct;
|
|
|
|
typedef struct SendParaList
|
|
{
|
|
u32 choice_flag;//1=IMSI, 2=AuthenticationSet, 4==SubscriberData,8=Ki, Others:Null
|
|
union
|
|
{
|
|
u8 imsi[IMSI_LEN]; //imsi
|
|
struct AuthSet_struct auth_set;
|
|
struct Sub_data_struct sub_data; //subscriber data
|
|
u8 ki[16]; //ki
|
|
} SP_Res_Choice;
|
|
} SendParaList;
|
|
|
|
typedef struct MapSP_Res // Send parameters response
|
|
{
|
|
u32 param_flag;
|
|
u8 sendparamlist_num;
|
|
struct SendParaList sendparalist[6]; //sentparalist
|
|
u8 user_error;
|
|
u8 provider_error;
|
|
}MapSP_Res;
|
|
|
|
|
|
|
|
typedef struct MapDSD_Arg // delete subscriber data argument
|
|
{
|
|
u32 param_flag;
|
|
u8 imsi[IMSI_LEN];
|
|
struct BSCode_struct bs_code;
|
|
struct
|
|
{
|
|
u8 sslist_len;
|
|
u8 ss_code[SS_LEN];
|
|
} ss_list; // ss list
|
|
u8 roam_feature; // roaming restriction due to unsupported feature
|
|
u8 regional_ident[2]; // regional subscription identifier (zone code)
|
|
u8 vbsg_ind; // vbs group indication
|
|
u8 vgcsg_ind; // vgcs group indication
|
|
u8 camel_withdraw; // camel subscription info withdraw
|
|
struct GprsSDWithdraw_struct gprs_withdraw; // gprs subscription data withdraw
|
|
u8 roamsgsn_feature; // roaming restricted in SGSN due to unsupported feature
|
|
|
|
//lsaInformationWithdraw
|
|
//gmlc-ListWithdraw
|
|
//umts add by gxchen
|
|
u8 ist_info_withdraw; //istInformationWithdraw
|
|
u32 spe_csi_withdraw; //specificCSI-Withdraw
|
|
u8 chg_char_withdraw; //chargingCharacteristicsWithdraw
|
|
u8 stn_sr_withdraw; //stn-srWithdraw
|
|
struct GprsSDWithdraw_struct eps_sub_withdraw; //epsSubscriptionDataWithdraw
|
|
u8 apn_replace_withdraw; //apn-oi-replacementWithdraw
|
|
u8 csg_sub_del; //csg-SubscriptionDeleted
|
|
} MapDSD_Arg;
|
|
|
|
typedef struct MapDSD_Res // delete subscriber data response
|
|
{
|
|
u32 param_flag;
|
|
enum RegSubsRes_enum subs_res; // regional subscription response
|
|
u8 user_error;
|
|
u8 provider_error;
|
|
} MapDSD_Res;
|
|
|
|
typedef struct MapReset_Arg // reset argument
|
|
{
|
|
u32 param_flag;
|
|
u8 hlr_num[ISDN_LEN+1]; // hlr number
|
|
struct
|
|
{
|
|
u8 list_len;
|
|
u8 hlr_id[HLRID_NUM][IMSI_LEN];
|
|
} hlr_list; // HLR list
|
|
u8 networkResource;
|
|
} MapReset_Arg;
|
|
|
|
typedef struct MapRD_Arg // restore data argument
|
|
{
|
|
u32 param_flag;
|
|
u8 imsi[IMSI_LEN];
|
|
u8 lmsi[LMSI_LEN];
|
|
struct VlrCap_struct vlr_cap; // vlr capability
|
|
} MapRD_Arg;
|
|
|
|
typedef struct MapRD_Res // restore data response
|
|
{
|
|
u32 param_flag;
|
|
u8 hlr_num[ISDN_LEN+1];
|
|
u8 msnot_reach; // MS not reachable
|
|
u8 user_error;
|
|
u8 provider_error;
|
|
} MapRD_Res;
|
|
|
|
typedef struct MapSRIFG_Arg // send routing info for GPRS argument
|
|
{
|
|
u32 param_flag;
|
|
u8 imsi[IMSI_LEN];
|
|
u8 ggsn_add[GSN_LEN+1]; // GGSN address
|
|
u8 ggsn_num[ISDN_LEN+1]; // GGSN number
|
|
} MapSRIFG_Arg;
|
|
|
|
typedef struct MapSRIFG_Res // send routing info for GPRS response
|
|
{
|
|
u32 param_flag;
|
|
u8 sgsn_add[GSN_LEN+1]; // SGSN address
|
|
u8 ggsn_add[GSN_LEN+1]; // GGSN address
|
|
u8 mobile_reason; // mobile not reachable reason
|
|
u8 user_error;
|
|
u8 provider_error;
|
|
} MapSRIFG_Res;
|
|
|
|
typedef struct MapFR_Arg // failure report argument
|
|
{
|
|
u32 param_flag;
|
|
u8 imsi[IMSI_LEN];
|
|
u8 ggsn_num[ISDN_LEN+1]; // GGSN number
|
|
u8 ggsn_add[GSN_LEN+1]; // GGSN address
|
|
} MapFR_Arg;
|
|
|
|
typedef struct MapFR_Res // failure report response
|
|
{
|
|
u32 param_flag;
|
|
u8 ggsn_add[GSN_LEN+1]; // GGSN address
|
|
u8 user_error;
|
|
u8 provider_error;
|
|
} MapFR_Res;
|
|
|
|
typedef struct MapNMPFG_Arg // note MS present for GPRS argument
|
|
{
|
|
u32 param_flag;
|
|
u8 imsi[IMSI_LEN];
|
|
u8 sgsn_add[GSN_LEN+1]; // SGSN address
|
|
u8 ggsn_add[GSN_LEN+1]; // GGSN address
|
|
} MapNMPFG_Arg;
|
|
|
|
typedef struct MapNMPFG_Res // note MS present for GPRS response
|
|
{
|
|
u32 param_flag;
|
|
u8 user_error;
|
|
u8 provider_error;
|
|
} MapNMPFG_Res;
|
|
|
|
/* +++++++++++++++++++++++++++++ */
|
|
/* MAP-H (with AUC) structure */
|
|
/* +++++++++++++++++++++++++++++ */
|
|
typedef struct MapST_Arg // security triplets argument
|
|
{
|
|
u32 param_flag;
|
|
u8 imsi[IMSI_LEN];
|
|
u8 hlr_id[HLRID_LEN];
|
|
// Authlist_e choice_flag;
|
|
|
|
//add by gxchen start
|
|
u8 num_req_vec; //number of requested vectors (1...5)
|
|
u8 seg_prohibit; //segmentationProhibited
|
|
u8 imm_res_prefer; //immediateResponsePreferred
|
|
AuthReSynInfo_st resyn_info; //re-synchronisation info
|
|
AuthNodeType_e node_type; //requestingNodeType
|
|
u8 req_plmn_id[3]; //requestingPLMN-Id
|
|
u8 num_req_add_vec; //number of requested additional vectors (1...5)
|
|
u8 add_vec_eps; //additionalVectorsAreForEPS
|
|
//add by gxchen end
|
|
} MapST_Arg;
|
|
|
|
//modify by gxchen
|
|
typedef struct MapST_Res // security triplets response
|
|
{
|
|
u32 param_flag;
|
|
Authlist_e choice_flag; //0:triplet, 1:quintuplet
|
|
union
|
|
{
|
|
struct
|
|
{
|
|
u8 tri_len;
|
|
Triplet_st triplet[AUTHLIST_LEN];
|
|
}tri_list;
|
|
struct
|
|
{
|
|
u8 quin_len;
|
|
Quintuplet_st quintuplet[AUTHLIST_LEN];
|
|
}quin_list;
|
|
}choice;
|
|
u8 user_error;
|
|
u8 provider_error;
|
|
} MapST_Res;
|
|
|
|
typedef struct MapIS_Arg // interrogation subscriber argument
|
|
{
|
|
u32 param_flag;
|
|
u8 imsi[IMSI_LEN];
|
|
u8 hlr_id[HLRID_LEN];
|
|
} MapIS_Arg;
|
|
|
|
typedef struct MapIS_Res // interrogation subscriber response
|
|
{
|
|
u32 param_flag;
|
|
u8 user_error;
|
|
u8 provider_error;
|
|
} MapIS_Res;
|
|
|
|
typedef struct MapCS_Arg // create subscriber argument
|
|
{
|
|
u32 param_flag;
|
|
u8 imsi[IMSI_LEN];
|
|
u8 hlr_id[HLRID_LEN];
|
|
} MapCS_Arg;
|
|
|
|
typedef struct MapCS_Res // create subscriber response
|
|
{
|
|
u32 param_flag;
|
|
u8 user_error;
|
|
u8 provider_error;
|
|
} MapCS_Res;
|
|
|
|
typedef struct MapDS_Arg // delete subscriber argument
|
|
{
|
|
u32 param_flag;
|
|
u8 imsi[IMSI_LEN];
|
|
u8 hlr_id[HLRID_LEN];
|
|
} MapDS_Arg;
|
|
|
|
typedef struct MapDS_Res // delete subscriber response
|
|
{
|
|
u32 param_flag;
|
|
u8 user_error;
|
|
u8 provider_error;
|
|
} MapDS_Res;
|
|
|
|
/********** OPR *******************/
|
|
typedef struct MapDetermineOprUser_Arg
|
|
{
|
|
u32 param_flag;
|
|
u8 imsi[IMSI_LEN+1];
|
|
u8 imei[IMEI_LEN];
|
|
u8 roamingRestraintFlag;
|
|
} MapDetermineOprUser_Arg;
|
|
|
|
typedef struct MapDetermineOprUser_Res
|
|
{
|
|
u32 param_flag;
|
|
u8 imsi[IMSI_LEN+1];
|
|
u8 imei[IMEI_LEN];
|
|
u8 oprflag;
|
|
u8 msisdn[ISDN_LEN+1];
|
|
} MapDetermineOprUser_Res;
|
|
|
|
typedef struct MapVlrUpdateLocation_Arg
|
|
{
|
|
u32 param_flag;
|
|
u8 imsi[IMSI_LEN+1];
|
|
u8 status;
|
|
} MapVlrUpdateLocation_Arg;
|
|
|
|
typedef struct MapVlrUpdateLocation_Res
|
|
{
|
|
u32 param_flag;
|
|
u8 imsi[IMSI_LEN+1];
|
|
u8 status;
|
|
u8 error;
|
|
} MapVlrUpdateLocation_Res;
|
|
|
|
typedef struct MapCreateUserWithMsisdnImsi_Arg
|
|
{
|
|
u32 param_flag;
|
|
u8 imsi[IMSI_LEN+1];
|
|
u8 msisdn[ISDN_LEN+1];
|
|
u8 imsiflag;
|
|
u8 camelflag;
|
|
} MapCreateUserWithMsisdnImsi_Arg;
|
|
|
|
typedef struct MapCreateUserWithMsisdnImsi_Res
|
|
{
|
|
u32 param_flag;
|
|
u8 imsi[IMSI_LEN+1];
|
|
u8 msisdn[ISDN_LEN+1];
|
|
u8 result;
|
|
u8 cause;
|
|
} MapCreateUserWithMsisdnImsi_Res;
|
|
|
|
|
|
typedef struct MapDeleteOprUser_Arg
|
|
{
|
|
u32 param_flag;
|
|
u8 imsi[IMSI_LEN+1];
|
|
u8 msisdn[ISDN_LEN+1];
|
|
} MapDeleteOprUser_Arg;
|
|
|
|
typedef struct MapDeleteOprUser_Res
|
|
{
|
|
u32 param_flag;
|
|
u8 imsi[IMSI_LEN+1];
|
|
u8 msisdn[ISDN_LEN+1];
|
|
u8 result;
|
|
u8 cause;
|
|
} MapDeleteOprUser_Res;
|
|
|
|
/********** OPR *******************/
|
|
/********** IMDM *******************/
|
|
typedef struct MapVlrEnquiryIMDM_Arg
|
|
{
|
|
u32 param_flag;
|
|
u8 imsi[IMSI_LEN+1];
|
|
u8 msisdn[ISDN_LEN+1];
|
|
|
|
}MapVlrEnquiryIMDM_Arg;
|
|
|
|
typedef struct MapVlrEnquiryIMDM_Res
|
|
{
|
|
u32 param_flag;
|
|
u8 imsi[IMSI_LEN+1];
|
|
u8 msisdn[ISDN_LEN+1];
|
|
u8 status;
|
|
}MapVlrEnquiryIMDM_Res;
|
|
/********** IMDM *******************/
|
|
|
|
/**** is41 *****/
|
|
#define MAX_IS41POPR_LEN 1024
|
|
|
|
typedef struct IS41ParBearerData
|
|
{
|
|
u32 param_flag;
|
|
u8 MessageId[3];
|
|
u8 UserDataLen;
|
|
u8 UserData[128];
|
|
u8 UserRespondingCode;
|
|
u8 MessageCenterTimeStamp[6];
|
|
u8 ValidityPeriod_Absolute[6];
|
|
u8 ValidityPeriod_Relative;
|
|
u8 DeferredDeliveryTime_Absolute[6];
|
|
u8 DeferredDeliveryTime_Relative;
|
|
u8 PriorityIndicator;
|
|
u8 PrivacyIndicator;
|
|
u8 ReplyOption;
|
|
u8 NumberOfMessages;
|
|
u8 AlertOnMessageDelivery;
|
|
u8 LanguageIndicator;
|
|
u8 CallBackNumberLen;
|
|
u8 CallBackNumber[MAX_IS41_VARPAR_LEN];
|
|
u8 MessageDisplayMode;
|
|
u8 MultipleEncodingUserDataLen;
|
|
u8 MultipleEncodingUserData[MAX_IS41_VARPAR_LEN];
|
|
u8 MessageStatus;
|
|
u8 TPFailureCause;
|
|
}IS41ParBearerData;
|
|
|
|
/**IS41 Auc operation **/
|
|
typedef struct IS41_AUTHDIR_ARG
|
|
{
|
|
u32 param_flag;
|
|
|
|
u8 esn[4];
|
|
u8 min[MIN_LEN];
|
|
|
|
//optional part--->
|
|
u8 aav;
|
|
u8 authu[3];
|
|
u8 count;
|
|
u8 denacc;
|
|
u8 locid[2];
|
|
u8 randssd[7];
|
|
u8 randu[3];
|
|
u8 senderinLen;
|
|
u8 senderin[32];
|
|
u8 ssd[16];
|
|
u8 nossd;
|
|
u8 updcount;
|
|
}IS41_AUTHDIR_ARG;
|
|
|
|
typedef struct IS41_AUTHDIR_RSP
|
|
{
|
|
u32 param_flag;
|
|
|
|
//optional part--->
|
|
u8 count;
|
|
}IS41_AUTHDIR_RSP;
|
|
|
|
typedef struct IS41AucDirectiveForward_arg
|
|
{
|
|
u32 param_flag;
|
|
|
|
u8 InterMSCCircuitID[2];
|
|
u8 MobileIdentificationNumber[MIN_LEN];
|
|
|
|
//optional part--->
|
|
u8 AuthenticationResponseUniqueChallenge[3];
|
|
u8 RandomVariableUniqueChallenge[3];
|
|
}IS41AucDirectiveForward_arg;
|
|
|
|
typedef struct IS41_AFREPORT_ARG
|
|
{
|
|
u32 param_flag;
|
|
|
|
u8 esn[4];
|
|
u8 min[MIN_LEN];
|
|
u8 rpttyp1;
|
|
u8 sysacctype;
|
|
u8 syscap;
|
|
|
|
//optional part--->
|
|
u8 count;
|
|
u8 countex;
|
|
u8 mscid[3];
|
|
u8 rpttyp2;
|
|
u8 senderinLen;
|
|
u8 senderin[32];
|
|
}IS41_AFREPORT_ARG;
|
|
|
|
typedef struct IS41_AFREPORT_RSP
|
|
{
|
|
u32 param_flag;
|
|
|
|
//optional part--->
|
|
u8 aav;
|
|
u8 authu[3];
|
|
u8 count;
|
|
u8 denacc;
|
|
u8 randssd[7];
|
|
u8 randu[3];
|
|
u8 ssd[16];
|
|
u8 nossd;
|
|
u8 termtyp;
|
|
u8 updcount;
|
|
|
|
u8 user_error;
|
|
u8 provider_error;
|
|
}IS41_AFREPORT_RSP;
|
|
|
|
typedef struct IS41_AUTHREQ_ARG
|
|
{
|
|
u32 param_flag;
|
|
|
|
u8 esn[4];
|
|
u8 min[MIN_LEN];
|
|
u8 mscid[3]; // serving MSC
|
|
u8 sysacctype;
|
|
u8 syscap; // serving
|
|
|
|
// optional part--->
|
|
u8 authdata[3];
|
|
u8 authr[3];
|
|
u8 count;
|
|
u8 cmodes; // actual
|
|
u8 DigitsLen;
|
|
u8 digits[32]; // dialed
|
|
u8 pcssn[5];
|
|
u8 rand[4];
|
|
u8 senderinLen;
|
|
u8 senderin[32];
|
|
u8 termtyp;
|
|
}IS41_AUTHREQ_ARG;
|
|
|
|
typedef struct IS41_AUTHREQ_RSP
|
|
{
|
|
u32 param_flag;
|
|
|
|
//optional part-->
|
|
u8 aav;
|
|
u8 authu[3];
|
|
u8 count;
|
|
u8 cdmaplcm[6];
|
|
u8 denacc;
|
|
u8 randssd[7];
|
|
u8 randu[3];
|
|
u8 ssd[16];
|
|
u8 smekey[8];
|
|
u8 nossd;
|
|
u8 updcount;
|
|
u8 vpmask[66];
|
|
|
|
u8 user_error;
|
|
u8 provider_error;
|
|
}IS41_AUTHREQ_RSP;
|
|
|
|
typedef struct IS41_ASREPORT_ARG
|
|
{
|
|
u32 param_flag;
|
|
|
|
u8 esn[4];
|
|
u8 min[MIN_LEN];
|
|
u8 syscap; // serving
|
|
|
|
//optional part--->
|
|
u8 CntUpdRepLen;
|
|
u8 countrpt[32];
|
|
u8 senderinLen;
|
|
u8 senderin[32];
|
|
u8 SSDUpdRepLen;
|
|
u8 ssdurpt[32];
|
|
u8 UniChaRepLen;
|
|
u8 uchalrpt[32];
|
|
}IS41_ASREPORT_ARG;
|
|
|
|
typedef struct IS41_ASREPORT_RSP
|
|
{
|
|
u32 param_flag;
|
|
|
|
//optional part--->
|
|
u8 aav;
|
|
u8 authu[3];
|
|
u8 count;
|
|
u8 denacc;
|
|
u8 randssd[7];
|
|
u8 randu[3];
|
|
u8 ssd[16];
|
|
u8 nossd;
|
|
u8 updcount;
|
|
|
|
u8 user_error;
|
|
u8 provider_error;
|
|
}IS41_ASREPORT_RSP;
|
|
|
|
typedef struct IS41_BSCHALL_ARG
|
|
{
|
|
u32 param_flag;
|
|
|
|
u8 esn[4];
|
|
u8 min[MIN_LEN];
|
|
u8 randbs[4];
|
|
|
|
//optional part--->
|
|
u8 senderinLen;
|
|
u8 senderin[32];
|
|
}IS41_BSCHALL_ARG;
|
|
|
|
typedef struct IS41_BSCHALL_RSP
|
|
{
|
|
u32 param_flag;
|
|
|
|
u8 authbs[3];
|
|
|
|
u8 user_error;
|
|
u8 provider_error;
|
|
}IS41_BSCHALL_RSP;
|
|
|
|
typedef struct IS41_COUNTREQ_ARG
|
|
{
|
|
u32 param_flag;
|
|
|
|
u8 esn[4];
|
|
u8 min[MIN_LEN];
|
|
u8 senderinLen;
|
|
u8 senderin[32];
|
|
}IS41_COUNTREQ_ARG;
|
|
|
|
typedef struct IS41_COUNTREQ_RSP
|
|
{
|
|
u32 param_flag;
|
|
|
|
u8 count;
|
|
}IS41_COUNTREQ_RSP;
|
|
|
|
/* IS41 Auc operation **/
|
|
|
|
|
|
/* IS41 SMSC operation **/
|
|
typedef struct IS41_SMDBACK_ARG
|
|
{
|
|
u32 param_flag;
|
|
|
|
u8 imsccid[2];
|
|
u8 min[MIN_LEN];
|
|
u8 BearerDataLen;
|
|
u8 BearerData[256];
|
|
u8 smstidLen;
|
|
u8 smstid[MAX_IS41_VARPAR_LEN];//IS41PAR_SMSTID
|
|
|
|
//optional part--->
|
|
u8 esn[4];
|
|
u8 smscidLen;
|
|
u8 smscid[MAX_IS41_VARPAR_LEN];//IS41PAR_SMSCID
|
|
u8 smsdaLen;
|
|
u8 smsda[MAX_IS41_VARPAR_LEN];//IS41PAR_SMSDA
|
|
u8 smsodaLen;
|
|
u8 smsoda[MAX_IS41_VARPAR_LEN];//IS41PAR_SMSODA
|
|
u8 smsodsLen;
|
|
u8 smsods[MAX_IS41_VARPAR_LEN];//IS41PAR_SMSODS
|
|
u8 smsooaLen;
|
|
u8 smsooa[MAX_IS41_VARPAR_LEN];//IS41PAR_SMSOOA
|
|
u8 smsoosLen;
|
|
u8 smsoos[MAX_IS41_VARPAR_LEN];//IS41PAR_SMSOOS
|
|
u8 smsoaLen;
|
|
u8 smsoa[MAX_IS41_VARPAR_LEN];//IS41PAR_SMSOA
|
|
}IS41_SMDBACK_ARG;
|
|
|
|
typedef struct IS41_SMDBACK_RSP
|
|
{
|
|
u32 param_flag;
|
|
|
|
u8 BearerDataLen;
|
|
u8 BearerData[256];
|
|
|
|
u8 smsccLen;
|
|
u8 smscc[MAX_IS41_VARPAR_LEN];//IS41PAR_SMSCC
|
|
}IS41_SMDBACK_RSP;
|
|
|
|
|
|
typedef struct IS41_SMDFWD_ARG
|
|
{
|
|
u32 param_flag;
|
|
|
|
u8 imsccid[2];
|
|
u8 min[MIN_LEN];
|
|
|
|
u8 BearerDataLen;
|
|
u8 BearerData[256];
|
|
u8 smstidLen;
|
|
u8 smstid[MAX_IS41_VARPAR_LEN];//IS41PAR_SMSTID
|
|
|
|
//optional part--->
|
|
u8 esn[4];
|
|
u8 smscidLen;
|
|
u8 smscid[MAX_IS41_VARPAR_LEN];//IS41PAR_SMSCID
|
|
u8 smsdaLen;
|
|
u8 smsda[MAX_IS41_VARPAR_LEN];//IS41PAR_SMSDA
|
|
u8 smsodaLen;
|
|
u8 smsoda[MAX_IS41_VARPAR_LEN];//IS41PAR_SMSODA
|
|
u8 smsodsLen;
|
|
u8 smsods[MAX_IS41_VARPAR_LEN];//IS41PAR_SMSODS
|
|
u8 smsooaLen;
|
|
u8 smsooa[MAX_IS41_VARPAR_LEN];//IS41PAR_SMSOOA
|
|
u8 smsoosLen;
|
|
u8 smsoos[MAX_IS41_VARPAR_LEN];//IS41PAR_SMSOOS
|
|
u8 smsoaLen;
|
|
u8 smsoa[MAX_IS41_VARPAR_LEN];//IS41PAR_SMSOA
|
|
}IS41_SMDFWD_ARG;
|
|
|
|
typedef struct IS41_SMDFWD_RSP
|
|
{
|
|
u32 param_flag;
|
|
|
|
u8 BearerDataLen;
|
|
u8 BearerData[256];
|
|
u8 smsccLen;
|
|
u8 smscc[MAX_IS41_VARPAR_LEN];//IS41PAR_SMSCC
|
|
}IS41_SMDFWD_RSP;
|
|
|
|
|
|
typedef struct IS41_SMDPP_ARG
|
|
{
|
|
u32 param_flag;
|
|
|
|
u8 BearerDataLen;
|
|
u8 BearerData[256];
|
|
u8 smstidLen;
|
|
u8 smstid[MAX_IS41_VARPAR_LEN];//IS41PAR_SMSTID
|
|
|
|
//optional part--->
|
|
u8 esn[4];
|
|
u8 min[MIN_LEN];
|
|
u8 smscidLen;
|
|
u8 smscid[MAX_IS41_VARPAR_LEN];//IS41PAR_SMSCID
|
|
u8 smsdaLen;
|
|
u8 smsda[MAX_IS41_VARPAR_LEN];//IS41PAR_SMSDA
|
|
u8 smsmsgcntLen;
|
|
u8 smsmsgcnt[MAX_IS41_VARPAR_LEN];//IS41PAR_SMSMSGCNT
|
|
u8 smsnotindLen;
|
|
u8 smsnotind[MAX_IS41_VARPAR_LEN];//IS41PAR_SMSNOTIND
|
|
|
|
u8 smsodaLen;
|
|
u8 smsoda[MAX_IS41_VARPAR_LEN];//IS41PAR_SMSODA
|
|
u8 smsodsLen;
|
|
u8 smsods[MAX_IS41_VARPAR_LEN];//IS41PAR_SMSODS
|
|
u8 smsooaLen;
|
|
u8 smsooa[MAX_IS41_VARPAR_LEN];//IS41PAR_SMSOOA
|
|
u8 smsoosLen;
|
|
u8 smsoos[MAX_IS41_VARPAR_LEN];//IS41PAR_SMSOOS
|
|
u8 smsoaLen;
|
|
u8 smsoa[MAX_IS41_VARPAR_LEN];//IS41PAR_SMSOA
|
|
}IS41_SMDPP_ARG;
|
|
|
|
typedef struct IS41_SMDPP_RSP
|
|
{
|
|
u32 param_flag;
|
|
|
|
u8 BearerDataLen;
|
|
u8 BearerData[256];
|
|
u8 smsccLen;
|
|
u8 smscc[MAX_IS41_VARPAR_LEN];//IS41PAR_SMSCC
|
|
}IS41_SMDPP_RSP;
|
|
|
|
typedef struct IS41_SMSNOT_ARG
|
|
{
|
|
u32 param_flag;
|
|
|
|
u8 esn[4];
|
|
u8 min[MIN_LEN];
|
|
|
|
//optional part--->
|
|
u8 smsaccdenLen;
|
|
u8 smsaccden[MAX_IS41_VARPAR_LEN];//IS41PAR_SMSACCDEN
|
|
u8 smsaddrLen;
|
|
u8 smsaddr[MAX_IS41_VARPAR_LEN];//IS41PAR_SMSADDR
|
|
}IS41_SMSNOT_ARG;
|
|
|
|
typedef struct IS41_SMSNOT_RSP
|
|
{
|
|
u32 param_flag;
|
|
//NULL
|
|
}IS41_SMSNOT_RSP;
|
|
|
|
typedef struct IS41_SMSREQ_ARG
|
|
{
|
|
u32 param_flag;
|
|
|
|
u8 min[MIN_LEN];
|
|
|
|
//optional part--->
|
|
u8 esn[4];
|
|
u8 smsnotindLen;
|
|
u8 smsnotind[MAX_IS41_VARPAR_LEN];//IS41PAR_SMSNOTIND
|
|
u8 smstidLen;
|
|
u8 smstid[MAX_IS41_VARPAR_LEN];//IS41PAR_SMSTID
|
|
}IS41_SMSREQ_ARG;
|
|
|
|
typedef struct IS41_SMSREQ_RSP
|
|
{
|
|
u32 param_flag;
|
|
|
|
//optional part--->
|
|
u8 esn[4];
|
|
u8 smsaccdenLen;
|
|
u8 smsaccden[MAX_IS41_VARPAR_LEN];//IS41PAR_SMSACCDEN
|
|
u8 smsaddrLen;
|
|
u8 smsaddr[MAX_IS41_VARPAR_LEN];//IS41PAR_SMSADDR
|
|
|
|
u8 user_error;
|
|
u8 provider_error;
|
|
}IS41_SMSREQ_RSP;
|
|
|
|
typedef struct IS41_PAR_TRIGGER_LIST
|
|
{
|
|
u32 param_flag;
|
|
|
|
u8 destaddrLen;
|
|
u8 destaddr[32]; //DestinationAddress -- choice global title
|
|
u8 wintriglistLen;
|
|
u8 wintriglist[32]; //WIN_TriggerList
|
|
}IS41_PAR_TRIGGER_LIST;
|
|
|
|
typedef struct IS41_PAR_WIN_CAP
|
|
{
|
|
u32 param_flag;
|
|
|
|
u8 triggercapLen;
|
|
u8 triggercap[32]; //TriggerCapability
|
|
u8 winoprcapLen;
|
|
u8 winoprcap[32]; //WIN_OperationsCapability
|
|
}IS41_PAR_WIN_CAP;
|
|
|
|
typedef struct IS41_PAR_PROFILE
|
|
{
|
|
u32 param_flag;
|
|
|
|
// optional
|
|
u8 authcapLen;
|
|
u8 authcap[32];//AuthenticationCapability,IMPLICIT OCTET STRING
|
|
u8 cfiLen;
|
|
u8 cfi[32];//CallingFeaturesIndicator,IMPLICIT OCTET STRING
|
|
u8 cardgtsLen;
|
|
u8 cardgts[32];//CarrierDigits,IMPLICIT DigitsType
|
|
u8 acdgtsLen;
|
|
u8 acdgts[32];//DMH_AccountCodeDigits,IMPLICIT DigitsType
|
|
u8 abdgtsLen;
|
|
u8 abdgts[32];//DMH_AlternateBillingDigits,IMPLICIT DigitsType
|
|
u8 billdgtsLen;
|
|
u8 billdgts[32];//DMH_BillingDigits,IMPLICIT DigitsType
|
|
u8 geoauthLen;
|
|
u8 geoauth[32];//GeographicAuthorization,IMPLICIT OCTET STRING
|
|
u8 mwncountLen;
|
|
u8 mwncount[32];//MessageWaitingNotificationCount,IMPLICIT OCTET STRING
|
|
u8 mwntypeLen;
|
|
u8 mwntype[32];//MessageWaitingNotificationType,IMPLICIT OCTET STRING
|
|
u8 mdnLen;
|
|
u8 mdn[32];//MobileDirectoryNumber,IMPLICIT DigitsType
|
|
u8 origind;//OriginationIndicator,IMPLICIT Unsigned Enumerated
|
|
u8 origtrigLen;
|
|
u8 origtrig[32];//OriginationTriggers,IMPLICIT OCTET STRING
|
|
u8 pacaind;//PACAIndicator,IMPLICIT OCTET STRING
|
|
u8 plind;//PreferredLanguageIndicator,IMPLICIT OCTET STRING
|
|
u8 resdgtsLen;
|
|
u8 resdgts[32];//RestrictionDigits,IMPLICIT DigitsType
|
|
u8 routdgtsLen;
|
|
u8 routdgts[32];//RoutingDigits,IMPLICIT Digits Type
|
|
u8 smsorgres;//SMS_OriginationRestrictions,IMPLICIT OCTET STRING
|
|
u8 smstermres;//SMS_TerminationRestrictions,IMPLICIT OCTET STRING
|
|
u8 spinipinLen;
|
|
u8 spinipin[32];//SPINIPIN,IMPLICIT DigitsType
|
|
u8 spinitrigLen;
|
|
u8 spinitrig[32];//SPINITriggers,IMPLICIT OCTET STRING
|
|
u8 termres;//TerminationRestrictionCode,IMPLICIT Unsigned Enumerated
|
|
u8 termtrigLen;
|
|
u8 termtrig[32];//TerminationTriggers,IMPLICIT OCTET STRING
|
|
u8 triggerlistnum;
|
|
IS41_PAR_TRIGGER_LIST triggerlist[MAX_IS41_TRIG_LIST_NUM]; //TriggerAddressList, IMPLICIT SET OF
|
|
|
|
}IS41_PAR_PROFILE;
|
|
|
|
typedef struct IS41_PAR_ISTERM
|
|
{
|
|
u32 param_flag;
|
|
|
|
u8 destdgtsLen;
|
|
u8 destdgts[32];//DestinationDigits,IMPLICIT DigitsType
|
|
u8 mscid[3];//serving
|
|
|
|
//optional
|
|
u8 accden;//AccessDeniedReason,IMPLICIT Unsigned Enumerated
|
|
u8 billid[7];//BillingID,IMPLICIT OCTET STRING
|
|
u8 cardgtsLen;
|
|
u8 cardgts[32];//CarrierDigits,IMPLICIT DigitsType
|
|
u8 esn[4];
|
|
u8 leginfoLen;
|
|
u8 leginfo[32];//LegInformation IMPLICIT OCTET STRING
|
|
u8 mdnLen;
|
|
u8 mdn[32];//MobileDirectoryNumber,IMPLICIT DigitsType
|
|
u8 min[MIN_LEN];
|
|
u8 mscinLen;
|
|
u8 mscin[32];//MSCIdentificationNumber,IMPLICIT Digits Type
|
|
u8 routdgtsLen;
|
|
u8 routdgts[32];//RoutingDigits,IMPLICIT Digits Type
|
|
u8 termtrigLen;
|
|
u8 termtrig[32];//TerminationTriggers,IMPLICIT OCTET STRING
|
|
}IS41_PAR_ISTERM;
|
|
|
|
typedef struct IS41_PAR_LOCTERM
|
|
{
|
|
u32 param_flag;
|
|
|
|
u8 esn[4];
|
|
u8 min[MIN_LEN];
|
|
u8 termtrmtLen;
|
|
u8 termtrmt[32];//TerminationTreatment,IMPLICIT OCTET STRING
|
|
|
|
//optional
|
|
u8 alrtcodeLen;
|
|
u8 alrtcode[32];//AlertCode,IMPLICIT OCTET STRING
|
|
u8 cardgtsLen;
|
|
u8 cardgts[32];//CarrierDigits,IMPLICIT DigitsType
|
|
u8 destdgtsLen;
|
|
u8 destdgts[32];//DestinationDigits,IMPLICIT DigitsType
|
|
u8 leginfoLen;
|
|
u8 leginfo[32];//LegInformation IMPLICIT OCTET STRING
|
|
u8 mdnLen;
|
|
u8 mdn[32];//MobileDirectoryNumber,IMPLICIT DigitsType
|
|
u8 otfiLen;
|
|
u8 otfi[32];//OneTimeFeatureIndicator,IMPLICIT OCTET STRING
|
|
u8 routdgtsLen;
|
|
u8 routdgts[32];//RoutingDigits,IMPLICIT Digits Type
|
|
u8 termtrigLen;
|
|
u8 termtrig[32];//TerminationTriggers,IMPLICIT OCTET STRING
|
|
u8 vmspinLen;
|
|
u8 vmspin[32];//VoiceMailboxPIN,IMPLICIT DigitsType
|
|
u8 vmboxLen;
|
|
u8 vmbox[32];//VoiceMailboxNumber,IMPLICIT DigitsType
|
|
}IS41_PAR_LOCTERM;
|
|
|
|
typedef struct IS41_PAR_PSTNTERM
|
|
{
|
|
u32 param_flag;
|
|
|
|
u8 destdgtsLen;
|
|
u8 destdgts[32];//DestinationDigits,IMPLICIT DigitsType
|
|
|
|
//optional
|
|
u8 cardgtsLen;
|
|
u8 cardgts[32];//CarrierDigits,IMPLICIT DigitsType
|
|
u8 esn[4];
|
|
u8 leginfoLen;
|
|
u8 leginfo[32];//LegInformation IMPLICIT OCTET STRING
|
|
u8 min[MIN_LEN];
|
|
u8 routdgtsLen;
|
|
u8 routdgts[32];//RoutingDigits,IMPLICIT Digits Type
|
|
u8 termtrigLen;
|
|
u8 termtrig[32];//TerminationTriggers,IMPLICIT OCTET STRING
|
|
}IS41_PAR_PSTNTERM;
|
|
|
|
typedef struct IS41_PAR_TERMLIST
|
|
{
|
|
u32 param_flag;
|
|
|
|
IS41_PAR_ISTERM isterm;
|
|
IS41_PAR_LOCTERM locterm;
|
|
IS41_PAR_PSTNTERM pstnterm;
|
|
}IS41_PAR_TERMLIST;
|
|
|
|
typedef struct IS41_REGNOT_ARG
|
|
{
|
|
u32 param_flag;
|
|
|
|
u8 esn[4];
|
|
u8 min[MIN_LEN];
|
|
u8 mscid[3];
|
|
u8 qualcode;//QualificationInformationCode,IMPLICIT Unsigned Enumerated
|
|
u8 mytyp;//SystemMyTypeCode,IMPLICIT Unsigned Enumerated
|
|
|
|
//optional
|
|
u8 avtyp;//Availability Type,IMPLICIT OCTET STRING
|
|
u8 bordacc;//BorderCellAccess,IMPLICIT Unsigned Enumerated
|
|
u8 ccdata[4];//ControlChannelData,IMPLICIT OCTET STRING
|
|
u8 extmscid[4];//ExtendedMSCID,IMPLICIT OCTET STRING
|
|
u8 locid[2];//LocationAreaID,IMPLICIT OCTET STRING
|
|
u8 pcssn[5];
|
|
u8 rsigqual;//ReceivedSignalQuality,IMPLICIT Unsigned Integer
|
|
u8 rpttyp;
|
|
u8 senderinLen;
|
|
u8 senderin[32];
|
|
u8 smsaddrLen;
|
|
u8 smsaddr[MAX_IS41_VARPAR_LEN];//IS41PAR_SMSADDR
|
|
u8 smsmwi;//SMS_MessageWaitingIndicator null,zero length
|
|
u8 sysaccdata[5];//SystemAccessData,IMPLICIT OCTET STRING
|
|
u8 sysacctype;
|
|
u8 syscap;
|
|
u8 termtyp;
|
|
u8 transcapLen;
|
|
u8 transcap[32];//TransactionCapability,IMPLICIT OCTET STRING
|
|
IS41_PAR_WIN_CAP wincap;
|
|
}IS41_REGNOT_ARG;
|
|
|
|
typedef struct IS41_REGNOT_RSP
|
|
{
|
|
u32 param_flag;
|
|
|
|
u8 mytyp;//SystemMyTypeCode,IMPLICIT Unsigned Enumerated
|
|
|
|
//optional
|
|
u8 authden;//AuthorizationDenied,IMPLICIT Unsigned Enumerated
|
|
u8 authper[2];//AuthorizationPeriod,IMPLICIT OCTET STRING
|
|
u8 ccdata[4];//ControlChannelData,IMPLICIT OCTET STRING
|
|
u8 denauthperLen;
|
|
u8 denauthper[32];//DeniedAuthorizationPeriod,IMPLICIT OCTET STRING
|
|
u8 digitsCarrierLen;
|
|
u8 digitsCarrier[32]; // carrier
|
|
u8 digitsDestLen;
|
|
u8 digitsDest[32]; // Destination
|
|
u8 mscid[3]; // HLR
|
|
|
|
IS41_PAR_PROFILE profile;
|
|
|
|
u8 rsigqual;//ReceivedSignalQuality,IMPLICIT Unsigned Integer
|
|
u8 senderinLen;
|
|
u8 senderin[32];
|
|
u8 smsmwi;//SMS_MessageWaitingIndicator null,zero length
|
|
u8 sysaccdata[5];//SystemAccessData,IMPLICIT OCTET STRING
|
|
|
|
u8 user_error;
|
|
u8 provider_error;
|
|
}IS41_REGNOT_RSP;
|
|
|
|
typedef struct IS41_REGCANC_ARG
|
|
{
|
|
u32 param_flag;
|
|
|
|
u8 esn[4];
|
|
u8 min[MIN_LEN];
|
|
|
|
//optional
|
|
u8 canctyplen;
|
|
u8 canctyp[4];//Cancellation Type,IMPLICIT OCTET STRING
|
|
u8 ccdata[4];//ControlChannelData,IMPLICIT OCTET STRING
|
|
u8 rsigqual;//ReceivedSignalQuality,IMPLICIT Unsigned Integer
|
|
u8 senderinLen;
|
|
u8 senderin[32];
|
|
u8 sysaccdata[5];//SystemAccessData,IMPLICIT OCTET STRING
|
|
}IS41_REGCANC_ARG;
|
|
|
|
typedef struct IS41_REGCANC_RSP
|
|
{
|
|
u32 param_flag;
|
|
|
|
//optional
|
|
u8 count; //CallHistoryCount
|
|
u8 cancdenied; //CancellationDenied, IMPLICIT Unsigned Enumerated
|
|
u8 ccdata[4];//ControlChannelData,IMPLICIT OCTET STRING
|
|
u8 rsigqual;//ReceivedSignalQuality,IMPLICIT Unsigned Integer
|
|
u8 smsmwi;//SMS_MessageWaitingIndicator null,zero length
|
|
u8 sysaccdata[5];//SystemAccessData,IMPLICIT OCTET STRING
|
|
}IS41_REGCANC_RSP;
|
|
|
|
typedef struct IS41_LOCREQ_ARG
|
|
{
|
|
u32 param_flag;
|
|
|
|
u8 billid[7];//BillingID,IMPLICIT OCTET STRING
|
|
u8 digitsLen;
|
|
u8 digits[32]; // originating
|
|
u8 mscid[3];//originating
|
|
u8 mytyp;//SystemMyTypeCode,IMPLICIT Unsigned Enumerated
|
|
|
|
//optional
|
|
u8 cpndgts1Len;
|
|
u8 cpndgts1[32];//CallingPartyNumberDigits1,IMPLICIT Digits Type
|
|
u8 cpndgts2Len;
|
|
u8 cpndgts2[32];//CallingPartyNumberDigits2,IMPLICIT Digits Type
|
|
u8 cpsubLen;
|
|
u8 cpsub[32];//CallingPartySubaddress,IMPLICIT Subaddress
|
|
u8 mscinLen;
|
|
u8 mscin[32];//MSCIdentificationNumber,IMPLICIT Digits Type
|
|
u8 pcssn[5];
|
|
u8 rndgtsLen;
|
|
u8 rndgts[32];//RedirectingNumberDigits,IMPLICIT Digits Type
|
|
u8 rsubLen;
|
|
u8 rsub[32];//RedirectingSubaddress,IMPLICIT Subaddress
|
|
u8 tat;//TerminationAccessType,IMPLICIT OCTET STRING
|
|
u8 transcapLen;
|
|
u8 transcap[32];//TransactionCapability,IMPLICIT OCTET STRING
|
|
IS41_PAR_WIN_CAP wincap;
|
|
}IS41_LOCREQ_ARG;
|
|
|
|
typedef struct IS41_LOCREQ_RSP
|
|
{
|
|
u32 param_flag;
|
|
|
|
u8 esn[4];
|
|
u8 min[MIN_LEN];
|
|
u8 mscid[3];
|
|
|
|
//optional
|
|
u8 accden;//AccessDeniedReason,IMPLICIT Unsigned Enumerated
|
|
u8 annlistLen;
|
|
u8 annlist[32];//AnnouncementList SEQUENCE OF
|
|
u8 cpnstrg1Len;
|
|
u8 cpnstrg1[32];//CallingPartyNumberString1,IMPLICIT Digits Type
|
|
u8 cpnstrg2Len;
|
|
u8 cpnstrg2[32];//CallingPartyNumberString2,IMPLICIT Digits Type
|
|
u8 digitsCarrierLen;
|
|
u8 digitsCarrier[32]; // carrier
|
|
u8 digitsDestLen;
|
|
u8 digitsDest[32]; // Destination
|
|
u8 acdgtsLen;
|
|
u8 acdgts[32];//DMH_AccountCodeDigits,IMPLICIT DigitsType
|
|
u8 abdgtsLen;
|
|
u8 abdgts[32];//DMH_AlternateBillingDigits,IMPLICIT DigitsType
|
|
u8 billdgtsLen;
|
|
u8 billdgts[32];//DMH_BillingDigits,IMPLICIT DigitsType
|
|
u8 redindLen;
|
|
u8 redind[32];//DMH_RedirectionIndicator,IMPLICIT ENUMERATED
|
|
u8 grpinfoLen;
|
|
u8 grpinfo[32];//GroupInformation,IMPLICIT OCTET STRING
|
|
u8 mdnLen;
|
|
u8 mdn[32];//MobileDirectoryNumber,IMPLICIT DigitsType
|
|
u8 natimeLen;
|
|
u8 natime[32];//NoAnswerTime,IMPLICIT OCTET STRING
|
|
u8 otfiLen;
|
|
u8 otfi[32];//OneTimeFeatureIndicator,IMPLICIT OCTET STRING
|
|
u8 pcssn[5];
|
|
u8 rndgtsLen;
|
|
u8 rndgts[32];//RedirectingNumberDigits,IMPLICIT Digits Type
|
|
u8 rnstringLen;
|
|
u8 rnstring[32];//RedirectingNumberString,IMPLICIT Digits Type
|
|
u8 rsubLen;
|
|
u8 rsub[32];//RedirectingSubaddress,IMPLICIT Subaddress
|
|
u8 routdgtsLen;
|
|
u8 routdgts[32];//RoutingDigits,IMPLICIT Digits Type
|
|
IS41_PAR_TERMLIST termlist;//TerminationList,SET OF CHOICE
|
|
u8 termtrigLen;
|
|
u8 termtrig[32];//TerminationTriggers,IMPLICIT OCTET STRING
|
|
u8 triggerlistnum;
|
|
IS41_PAR_TRIGGER_LIST triggerlist[MAX_IS41_TRIG_LIST_NUM]; //TriggerAddressList, IMPLICIT SET OF
|
|
|
|
|
|
u8 user_error;
|
|
u8 provider_error;
|
|
}IS41_LOCREQ_RSP;
|
|
|
|
typedef struct IS41_ROUTREQ_ARG
|
|
{
|
|
u32 param_flag;
|
|
|
|
u8 billid[7];//BillingID,IMPLICIT OCTET STRING
|
|
u8 esn[4];
|
|
u8 min[MIN_LEN];
|
|
u8 mscid[3];//originating MSC
|
|
u8 mytyp;//SystemMyTypeCode,IMPLICIT Unsigned Enumerated
|
|
|
|
//optional
|
|
u8 alrtcodeLen;
|
|
u8 alrtcode[32];//AlertCode,IMPLICIT OCTET STRING
|
|
u8 cpnstrg1Len;
|
|
u8 cpnstrg1[32];//CallingPartyNumberString1,IMPLICIT Digits Type
|
|
u8 cpnstrg2Len;
|
|
u8 cpnstrg2[32];//CallingPartyNumberString2,IMPLICIT Digits Type
|
|
u8 cpsubLen;
|
|
u8 cpsub[32];//CallingPartySubaddress,IMPLICIT Subaddress
|
|
u8 destdgtsLen;
|
|
u8 destdgts[32];//DestinationDigits,IMPLICIT DigitsType
|
|
u8 acdgtsLen;
|
|
u8 acdgts[32];//DMH_AccountCodeDigits,IMPLICIT DigitsType
|
|
u8 abdgtsLen;
|
|
u8 abdgts[32];//DMH_AlternateBillingDigits,IMPLICIT DigitsType
|
|
u8 billdgtsLen;
|
|
u8 billdgts[32];//DMH_BillingDigits,IMPLICIT DigitsType
|
|
u8 leginfoLen;
|
|
u8 leginfo[32];//LegInformation,IMPLICIT OCTET STRING
|
|
u8 locid[2];
|
|
u8 mdnLen;
|
|
u8 mdn[32];//MobileDirectoryNumber,IMPLICIT DigitsType
|
|
u8 mscinLen;
|
|
u8 mscin[32];//MSCIdentificationNumber,IMPLICIT Digits Type
|
|
u8 natimeLen;
|
|
u8 natime[32];//NoAnswerTime,IMPLICIT OCTET STRING
|
|
u8 otfiLen;
|
|
u8 otfi[32];//OneTimeFeatureIndicator,IMPLICIT OCTET STRING
|
|
u8 pcssn[5];
|
|
u8 pilotbid[7];//PilotBillingID,IMPLICIT OCTET STRING
|
|
u8 pilotLen;
|
|
u8 pilot[32];//PilotNumber,IMPLICIT DigitsType
|
|
u8 rnstringLen;
|
|
u8 rnstring[32];//RedirectingNumberString,IMPLICIT Digits Type
|
|
u8 rsubLen;
|
|
u8 rsub[32];//RedirectingSubaddress,IMPLICIT Subaddress
|
|
u8 senderinLen;
|
|
u8 senderin[32];
|
|
u8 termtrmtLen;
|
|
u8 termtrmt[32];//TerminationTreatment,IMPLICIT OCTET STRING
|
|
u8 termtrigLen;
|
|
u8 termtrig[32];//TerminationTriggers,IMPLICIT OCTET STRING
|
|
u8 vmboxLen;
|
|
u8 vmbox[32];//VoiceMailboxNumber,IMPLICIT DigitsType
|
|
u8 vmspinLen;
|
|
u8 vmspin[32];//VoiceMailboxPIN,IMPLICIT DigitsType
|
|
}IS41_ROUTREQ_ARG;
|
|
|
|
typedef struct IS41_ROUTREQ_RSP
|
|
{
|
|
u32 param_flag;
|
|
|
|
u8 mscid[3];
|
|
|
|
//optional
|
|
u8 accden;//AccessDeniedReason,IMPLICIT Unsigned Enumerated
|
|
u8 billid[7];//BillingID,IMPLICIT OCTET STRING
|
|
u8 cden;//ConditionallyDeniedReason
|
|
u8 digitsLen;
|
|
u8 digits[32]; // dialed
|
|
u8 mscinLen;
|
|
u8 mscin[32];//MSCIdentificationNumber,IMPLICIT Digits Type
|
|
u8 pcssn[5];
|
|
}IS41_ROUTREQ_RSP;
|
|
|
|
typedef struct IS41_MSINACT_ARG
|
|
{
|
|
u32 param_flag;
|
|
|
|
u8 esn[4];
|
|
u8 min[MIN_LEN];
|
|
|
|
//optional part--->
|
|
u8 count;
|
|
u8 dereg;//DeregistrationType,IMPLICIT Unsigned Enumerated
|
|
u8 locid[2];
|
|
u8 senderinLen;
|
|
u8 senderin[32];
|
|
// u8 SMS_MessageWaitingIndicator;
|
|
}IS41_MSINACT_ARG;
|
|
|
|
typedef struct IS41_MSINACT_RSP
|
|
{
|
|
u32 param_flag;
|
|
|
|
}IS41_MSINACT_RSP;//empty response
|
|
|
|
typedef struct IS41_QUALDIR_ARG
|
|
{
|
|
u32 param_flag;
|
|
|
|
u8 esn[4];
|
|
u8 min[MIN_LEN];
|
|
u8 qualcode;//QualificationInformationCode,IMPLICIT Unsigned Enumerated
|
|
u8 mytyp;//SystemMyTypeCode,IMPLICIT Unsigned Enumerated
|
|
|
|
//optional
|
|
u8 authden;//AuthorizationDenied,IMPLICIT Unsigned Enumerated
|
|
u8 authper[2];//AuthorizationPeriod,IMPLICIT OCTET STRING
|
|
u8 denauthperLen;
|
|
u8 denauthper[32];//DeniedAuthorizationPeriod,IMPLICIT OCTET STRING
|
|
u8 digitsCarrierLen;
|
|
u8 digitsCarrier[32];// Carrier
|
|
u8 digitsDestLen;
|
|
u8 digitsDest[32]; // Destination
|
|
u8 locid[2];//LocationAreaID
|
|
|
|
IS41_PAR_PROFILE profile;
|
|
|
|
u8 senderinLen;
|
|
u8 senderin[32];
|
|
}IS41_QUALDIR_ARG;
|
|
|
|
typedef struct IS41_QUALDIR_RSP
|
|
{
|
|
u32 param_flag;
|
|
}IS41_QUALDIR_RSP;//empty response
|
|
|
|
typedef struct IS41_FEATREQ_ARG
|
|
{
|
|
u32 param_flag;
|
|
|
|
u8 digitsLen;
|
|
u8 digits[32]; // dialed
|
|
u8 esn[4];
|
|
u8 min[MIN_LEN];
|
|
|
|
//optional
|
|
u8 billid[7];//BillingID,IMPLICIT OCTET STRING
|
|
u8 cpndgts1Len;
|
|
u8 cpndgts1[32];//CallingPartyNumberDigits1,IMPLICIT Digits Type
|
|
u8 cpndgts2Len;
|
|
u8 cpndgts2[32];//CallingPartyNumberDigits2,IMPLICIT Digits Type
|
|
u8 cpsubLen;
|
|
u8 cpsub[32];//CallingPartySubaddress,IMPLICIT Subaddress
|
|
u8 cciLen;
|
|
u8 cci[32];//ConferenceCallingIndicator,IMPLICIT OCTET STRING
|
|
u8 mdnLen;
|
|
u8 mdn[32];//MobileDirectoryNumber,IMPLICIT DigitsType
|
|
u8 mscid[3];
|
|
u8 mscinLen;
|
|
u8 mscin[32];//MSCIdentificationNumber,IMPLICIT Digits Type
|
|
u8 otfiLen;
|
|
u8 otfi[32];//OneTimeFeatureIndicator,IMPLICIT OCTET STRING
|
|
u8 pcssn[5];
|
|
u8 senderinLen;
|
|
u8 senderin[32];
|
|
u8 transcapLen;
|
|
u8 transcap[32];//TransactionCapability,IMPLICIT OCTET STRING
|
|
}IS41_FEATREQ_ARG;
|
|
|
|
typedef struct IS41_FEATREQ_RSP
|
|
{
|
|
u32 param_flag;
|
|
|
|
u8 featresult;//FeatureResult, IMPLICIT Unsigned Enumerated
|
|
|
|
//optional
|
|
u8 accden;//AccessDeniedReason,IMPLICIT Unsigned Enumerated
|
|
u8 actcodeLen;
|
|
u8 actcode[32];//ActionCode IMPLICIT OCTET STRING
|
|
u8 annlistLen;
|
|
u8 annlist[32];//AnnouncementList SEQUENCE OF
|
|
u8 cpndgts1Len;
|
|
u8 cpndgts1[32];//CallingPartyNumberDigits1,IMPLICIT Digits Type
|
|
u8 cpndgts2Len;
|
|
u8 cpndgts2[32];//CallingPartyNumberDigits2,IMPLICIT Digits Type
|
|
u8 cpsubLen;
|
|
u8 cpsub[32];//CallingPartySubaddress,IMPLICIT Subaddress
|
|
u8 digitsCarrierLen;
|
|
u8 digitsCarrier[32];// Carrier
|
|
u8 cciLen;
|
|
u8 cci[32];//ConferenceCallingIndicator,IMPLICIT OCTET STRING
|
|
u8 digitsLen;
|
|
u8 digits[32];// Dialed
|
|
/* u8 disptextLen;//do not find
|
|
u8 disptext[32];*/
|
|
u8 acdgtsLen;
|
|
u8 acdgts[32];//DMH_AccountCodeDigits,IMPLICIT DigitsType
|
|
u8 abdgtsLen;
|
|
u8 abdgts[32];//DMH_AlternateBillingDigits,IMPLICIT DigitsType
|
|
u8 billdgtsLen;
|
|
u8 billdgts[32];//DMH_BillingDigits,IMPLICIT DigitsType
|
|
u8 redindLen;
|
|
u8 redind[32];//DMH_RedirectionIndicator,IMPLICIT ENUMERATED
|
|
u8 grpinfoLen;
|
|
u8 grpinfo[32];//GroupInformation,IMPLICIT OCTET STRING
|
|
u8 mdnLen;
|
|
u8 mdn[32];//MobileDirectoryNumber,IMPLICIT DigitsType
|
|
u8 natimeLen;
|
|
u8 natime[32];//NoAnswerTime,IMPLICIT OCTET STRING
|
|
u8 otfiLen;
|
|
u8 otfi[32];//OneTimeFeatureIndicator,IMPLICIT OCTET STRING
|
|
u8 pacaind;//PACAIndicator,IMPLICIT OCTET STRING
|
|
u8 pilotLen;
|
|
u8 pilot[32];//PilotNumber,IMPLICIT DigitsType
|
|
u8 rndgtsLen;
|
|
u8 rndgts[32];//RedirectingNumberDigits,IMPLICIT Digits Type
|
|
u8 rnstringLen;
|
|
u8 rnstring[32];//RedirectingNumberString,IMPLICIT Digits Type
|
|
u8 rsubLen;
|
|
u8 rsub[32];//RedirectingSubaddress,IMPLICIT Subaddress
|
|
u8 resumepic;//ResumePIC, IMPLICIT Unsigned Enumerated
|
|
u8 routdgtsLen;
|
|
u8 routdgts[32];//RoutingDigits,IMPLICIT Digits Type
|
|
IS41_PAR_TERMLIST termlist;//TerminationList,SET OF CHOICE
|
|
u8 termtrigLen;
|
|
u8 termtrig[32];//TerminationTriggers,IMPLICIT OCTET STRING
|
|
u8 triggerlistnum;
|
|
IS41_PAR_TRIGGER_LIST triggerlist[MAX_IS41_TRIG_LIST_NUM]; //TriggerAddressList, IMPLICIT SET OF
|
|
|
|
u8 user_error;
|
|
u8 provider_error;
|
|
|
|
}IS41_FEATREQ_RSP;
|
|
|
|
typedef struct IS41_REDREQ_ARG
|
|
{
|
|
u32 param_flag;
|
|
|
|
u8 billid[7];//BillingID,IMPLICIT OCTET STRING
|
|
u8 esn[4];
|
|
u8 min[MIN_LEN];
|
|
u8 redreason;//RedirectionReason IMPLICIT Unsigned Enumerated
|
|
|
|
//optional
|
|
u8 leginfoLen;
|
|
u8 leginfo[32];//LegInformation IMPLICIT OCTET STRING
|
|
u8 mscinLen;
|
|
u8 mscin[32];//MSCIdentificationNumber,IMPLICIT Digits Type
|
|
}IS41_REDREQ_ARG;
|
|
|
|
typedef struct IS41_REDREQ_RSP
|
|
{
|
|
u32 param_flag;
|
|
}IS41_REDREQ_RSP;//empty response
|
|
|
|
typedef struct IS41_TRANUMREQ_ARG
|
|
{
|
|
u32 param_flag;
|
|
|
|
u8 esn[4];
|
|
u8 min[MIN_LEN];
|
|
u8 redreason;//RedirectionReason IMPLICIT Unsigned Enumerated
|
|
u8 mytyp;//SystemMyTypeCode,IMPLICIT Unsigned Enumerated
|
|
|
|
//optional
|
|
u8 billid[7];//BillingID,IMPLICIT OCTET STRING
|
|
u8 grpinfoLen;
|
|
u8 grpinfo[32];//GroupInformation,IMPLICIT OCTET STRING
|
|
u8 leginfoLen;
|
|
u8 leginfo[32];//LegInformation IMPLICIT OCTET STRING
|
|
u8 mscid[3];//originating MSC
|
|
u8 mscinLen;
|
|
u8 mscin[32];//MSCIdentificationNumber,IMPLICIT Digits Type
|
|
u8 pilotbid[7];//PilotBillingID,IMPLICIT OCTET STRING
|
|
u8 pilotLen;
|
|
u8 pilot[32];//PilotNumber,IMPLICIT DigitsType
|
|
u8 transcapLen;
|
|
u8 transcap[32];//TransactionCapability,IMPLICIT OCTET STRING
|
|
IS41_PAR_WIN_CAP wincap;
|
|
}IS41_TRANUMREQ_ARG;
|
|
|
|
typedef struct IS41_TRANUMREQ_RSP
|
|
{
|
|
u32 param_flag;
|
|
|
|
u8 digitsLen;
|
|
u8 digits[32];// Destination
|
|
|
|
//optional
|
|
u8 accden;//AccessDeniedReason,IMPLICIT Unsigned Enumerated
|
|
u8 actcodeLen;
|
|
u8 actcode[32];//ActionCode IMPLICIT OCTET STRING
|
|
u8 annlistLen;
|
|
u8 annlist[32];//AnnouncementList SEQUENCE OF
|
|
u8 cpnstrg1Len;
|
|
u8 cpnstrg1[32];//CallingPartyNumberString1,IMPLICIT Digits Type
|
|
u8 cpnstrg2Len;
|
|
u8 cpnstrg2[32];//CallingPartyNumberString2,IMPLICIT Digits Type
|
|
u8 cpsubLen;
|
|
u8 cpsub[32];//CallingPartySubaddress,IMPLICIT Subaddress
|
|
u8 digitsCarrierLen;
|
|
u8 digitsCarrier[32];
|
|
u8 acdgtsLen;
|
|
u8 acdgts[32];//DMH_AccountCodeDigits,IMPLICIT DigitsType
|
|
u8 abdgtsLen;
|
|
u8 abdgts[32];//DMH_AlternateBillingDigits,IMPLICIT DigitsType
|
|
u8 billdgtsLen;
|
|
u8 billdgts[32];//DMH_BillingDigits,IMPLICIT DigitsType
|
|
u8 redindLen;
|
|
u8 redind[32];//DMH_RedirectionIndicator,IMPLICIT ENUMERATED
|
|
u8 dmh_svcidLen;
|
|
u8 dmh_svcid[32];//DMH_ServiceID, IMPLICIT Octet String
|
|
u8 grpinfoLen;
|
|
u8 grpinfo[32];//GroupInformation,IMPLICIT OCTET STRING
|
|
u8 mdnLen;
|
|
u8 mdn[32];//MobileDirectoryNumber,IMPLICIT DigitsType
|
|
u8 natimeLen;
|
|
u8 natime[32];//NoAnswerTime,IMPLICIT OCTET STRING
|
|
u8 plind;//PreferredLanguageIndicator,IMPLICIT OCTET STRING
|
|
u8 rndgtsLen;
|
|
u8 rndgts[32];//RedirectingNumberDigits,IMPLICIT Digits Type
|
|
u8 rnstringLen;
|
|
u8 rnstring[32];//RedirectingNumberString,IMPLICIT Digits Type
|
|
u8 rsubLen;
|
|
u8 rsub[32];//RedirectingSubaddress,IMPLICIT Subaddress
|
|
IS41_PAR_TERMLIST termlist;//TerminationList,SET OF CHOICE
|
|
u8 termtrigLen;
|
|
u8 termtrig[32];//TerminationTriggers,IMPLICIT OCTET STRING
|
|
u8 triggerlistnum;
|
|
IS41_PAR_TRIGGER_LIST triggerlist[MAX_IS41_TRIG_LIST_NUM]; //TriggerAddressList, IMPLICIT SET OF
|
|
|
|
u8 user_error;
|
|
u8 provider_error;
|
|
}IS41_TRANUMREQ_RSP;
|
|
|
|
#include "win_struct.h"
|
|
/***** is41 *******/
|
|
|
|
|
|
/***** AIN *******/
|
|
#define AIN_CDPN_LEN 11
|
|
#define AIN_CGPN_LEN 9
|
|
#define LATA_LEN 6
|
|
#define AIN_CIC_LEN 6
|
|
#define AIN_RN_LEN 9
|
|
|
|
enum _ansiTypeOfDigits
|
|
{
|
|
NotUsed = 0,
|
|
CalledPartyNumber,
|
|
CallingPartyNumber,
|
|
CallerInteraction,
|
|
RoutingNumber,
|
|
BillingNumber,
|
|
DestinationNumber,
|
|
LATA,
|
|
Carrier,
|
|
LastCallingParty,
|
|
LastPartyCalled,
|
|
CallingDirectoryNumber,
|
|
VMSRIdentifier,
|
|
OriginalCalledNumber,
|
|
RedirectingNumber,
|
|
ConnectedNumber
|
|
};
|
|
|
|
enum _ainsiNatureOfNumber
|
|
{
|
|
National = 0,
|
|
International
|
|
};
|
|
|
|
enum _ansiCoding
|
|
{
|
|
CodingNotUsed,
|
|
CodingBCD,
|
|
CodingIA5
|
|
};
|
|
|
|
enum _ansiNumberingPlan
|
|
{
|
|
Unknown,
|
|
ISDNNumber,
|
|
TelephonyNumbering,
|
|
DataNumbering,
|
|
TelexNumbering,
|
|
MaritimeMobileNumbering,
|
|
LandMobileNumbering,
|
|
PrivateNumberingPlan
|
|
};
|
|
|
|
typedef struct _ansiTcapDigits
|
|
{
|
|
u8 typeOfDigits;
|
|
u8 natureOfNumber;
|
|
u8 numberingPlan;
|
|
u8 encoding;//BCD or
|
|
u8 numberOfDigits;
|
|
u8 digits[10];// 2 digits 1 byte
|
|
}ansiDigit;
|
|
|
|
typedef struct _ProvideInstructionStart
|
|
{
|
|
//In UWave IN-MNP implementation LATA and Originating Station Type are hard coded as: 0x000000000000, 0x00
|
|
//All numbers in the message are of 10 digit NDD format.
|
|
u32 param_flag;
|
|
u8 calledPartyNumber[AIN_CDPN_LEN+1];//10 digit called party number digits
|
|
u8 callingPartyNumber[AIN_CGPN_LEN+1];//AIN Digits
|
|
u8 LATA[LATA_LEN+1];//LATA ID
|
|
u8 OriginatingStationType;//Binary value of AIN II digits
|
|
}PIStart;
|
|
|
|
typedef struct _ConnectionControlConnect
|
|
{
|
|
//If the called number is ported then NPDB will response with Routing Number; otherwise the dialed number is returned. This is the way for MSC/PPS to check whether the dialed number is ported or not.
|
|
u32 param_flag;
|
|
u8 CIC[AIN_CIC_LEN +1];//3 or 4 digit CIC
|
|
u8 RoutingNumber[AIN_RN_LEN +1];//10 digit RN or dialed number
|
|
u8 BillingIndicator;//Unspecified
|
|
}CCConect;
|
|
|
|
|
|
/***** AIN *******/
|
|
|
|
/* +++++++++++++++++++++++++++++ */
|
|
/* the whole operation structure */
|
|
/* +++++++++++++++++++++++++++++ */
|
|
typedef struct MapOprSrv_struct // operation service struct
|
|
{
|
|
u32 port_id;
|
|
u32 dialogue_id;
|
|
u8 invoke_id;
|
|
u8 message_type;
|
|
u8 message_flag; // distinguish REQUEST,INDICATE,RESPONSE,CONFIRM
|
|
u8 version;
|
|
union
|
|
{
|
|
struct MapRIFSM_Arg rifsm_arg; // routing info for SM argument
|
|
struct MapRIFSM_Res rifsm_res; // routing info for SM response
|
|
struct MapRIFSMV1_Arg rifsm_v1_arg; // routing info for SM argument
|
|
struct MapRIFSMV1_Res rifsm_v1_res; // routing info for SM response
|
|
struct MapFSM_Arg fsm_arg; // foward sm argument v1;
|
|
struct MapMOFSM_Arg mofsm_arg; // MO forward SM argument
|
|
struct MapMOFSM_Res mofsm_res; // MO forward SM response
|
|
struct MapMTFSM_Arg mtfsm_arg; // MT forward SM argument
|
|
struct MapMTFSM_Res mtfsm_res; // MT forward SM response
|
|
struct MapRSMDS_Arg rsmds_arg; // report SM delivery status argument
|
|
struct MapRSMDS_Res rsmds_res; // report SM delivery status response
|
|
struct MapASC_Arg asc_arg; // alert service centre argument
|
|
struct MapASC_Res asc_res; // alert service centre response
|
|
struct MapISC_Arg isc_arg; // inform service centre argument
|
|
struct MapRFSM_Arg rfsm_arg; // ready for SM argument
|
|
struct MapRFSM_Res rfsm_res; // ready for SM response
|
|
struct MapRSS_Arg rss_arg; // register SS argument
|
|
struct MapRSS_Res rss_res; // register SS response
|
|
struct MapESS_Arg ess_arg; // erase SS argument
|
|
struct MapESS_Res ess_res; // erase SS response
|
|
struct MapASS_Arg ass_arg; // activate SS argument
|
|
struct MapASS_Res ass_res; // activate SS response
|
|
struct MapDASS_Arg dass_arg; // deactivate SS argument
|
|
struct MapDASS_Res dass_res; // deactivate SS response
|
|
struct MapINTSS_Arg intss_arg; // interrogation SS argument
|
|
struct MapINTSS_Res intss_res; // interrogation SS response
|
|
struct MapPUSSR_Arg pussr_arg;
|
|
struct MapPUSSR_Res pussr_res;
|
|
struct MapUSSR_Arg ussr_arg;
|
|
struct MapUSSR_Res ussr_res;
|
|
struct MapUSSN_Arg ussn_arg;
|
|
struct MapUSSN_Res ussn_res;
|
|
struct MapRPSS_Arg rpss_arg; // register password argument
|
|
struct MapRPSS_Res rpss_res; // register password response
|
|
struct MapGPSS_Arg gpss_arg; // get password argument
|
|
struct MapGPSS_Res gpss_res; // get password response
|
|
struct MapSSIN_Arg ssin_arg;
|
|
struct MapSSIN_Res ssin_res;
|
|
struct MapRCCE_Arg rcce_arg;
|
|
struct MapRCCE_Res rcce_res;
|
|
struct MapECCE_Arg ecce_arg;
|
|
struct MapECCE_Res ecce_res;
|
|
struct MapSRI_Arg sri_arg; // send routing info argument
|
|
struct MapSRI_Res sri_res; // send routing info response
|
|
struct MapPRN_Arg prn_arg; // provide roaming number argument
|
|
struct MapPRN_Res prn_res; // provide roaming number response
|
|
struct MapRCH_Arg rch_arg;
|
|
struct MapRCH_Res rch_res;
|
|
struct MapPSN_Arg psn_arg;
|
|
struct MapPSN_Res psn_res;
|
|
struct MapSSM_Arg ssm_arg;
|
|
struct MapSSM_Res ssm_res;
|
|
struct MapSRS_Arg srs_arg;
|
|
struct MapSRS_Res srs_res;
|
|
struct MapSR_Arg sr_arg;
|
|
struct MapSR_Res sr_res;
|
|
struct MapRUF_Arg ruf_arg;
|
|
struct MapRUF_Res ruf_res;
|
|
struct MapISTAlert_Arg istalt_arg; //ist-Alert argument
|
|
struct MapISTAlert_Res istalt_res; //ist-Alert response
|
|
struct MapISTCmd_Arg istcmd_arg; //ist-Command argument
|
|
struct MapISTCmd_Res istcmd_res; //ist-Command response
|
|
struct MapATM_Arg atm_arg; // activate trace mode argument
|
|
struct MapATM_Res atm_res; // activate trace mode response
|
|
struct MapDTM_Arg dtm_arg; // deactivate trace mode argument
|
|
struct MapDTM_Res dtm_res; // deactivate trace mode response
|
|
struct MapSIMSI_Arg simsi_arg; // send IMSI argument
|
|
struct MapSIMSI_Res simsi_res; // send IMSI response
|
|
struct MapUL_Arg ul_arg; // update location argument
|
|
struct MapUL_Res ul_res; // update location response
|
|
struct MapCL_Arg cl_arg; // cancel location argument
|
|
struct MapCL_Res cl_res; // cancel location response
|
|
struct MapPMS_Arg pms_arg; // purge MS argument
|
|
struct MapPMS_Res pms_res; // purge MS response
|
|
struct MapSI_Arg si_arg; // send identification argument
|
|
struct MapSI_Res si_res; // send identification response
|
|
struct MapUGL_Arg ugl_arg; // update GPRS location argument
|
|
struct MapUGL_Res ugl_res; // update GPRS location response
|
|
struct MapPSI_Arg psi_arg; // provide subscriber info argument
|
|
struct MapPSI_Res psi_res; // provide subscriber info response
|
|
struct MapATI_Arg ati_arg; // any time interrogation argument
|
|
struct MapATI_Res ati_res; // any time interrogation response
|
|
struct MapPHO_Arg pho_arg; // prepare handover argument
|
|
struct MapPHO_Res pho_res; // prepare handover response
|
|
struct MapPFSHO_Arg pfsho_arg; // Preform Subsequence Handover
|
|
struct MapPFSHO_Res pfsho_res; // Preform Subsequence Handover
|
|
struct MapNIHO_Arg niho_arg; // NoteInternalHandover
|
|
struct MapSES_Arg ses_arg; // send end signal argument
|
|
struct MapSES_Res ses_res; // send end signal response
|
|
struct MapTSA_Arg tsa_arg; // Trace Subscriber activate
|
|
struct MapPAS_Arg pas_arg; // process access signalling argument
|
|
struct MapFAS_Arg fas_arg; // forward access signalling argument
|
|
struct MapPSHO_Arg psho_arg; // prepare subsequent handover argument
|
|
struct MapPSHO_Res psho_res; // prepare subsequent handover response
|
|
struct MapSAI_Arg sai_arg; // send authenticate info argument
|
|
struct MapSAI_Res sai_res; // send authenticate info response
|
|
MapAuthFailReport_Arg authfr_arg; //authentication failure report argument add by gxchen
|
|
MapAuthFailReport_Res authfr_res; //authentication failure report response add by gxchen
|
|
struct MapCIMEI_Arg cimei_arg; // check IMEI argument
|
|
struct MapCIMEI_Res cimei_res; // check IMEI response
|
|
struct MapISD_Arg isd_arg; // insert subscriber data argument
|
|
struct MapISD_Res isd_res; // insert subscriber data response
|
|
struct MapDSD_Arg dsd_arg; // delete subscriber data argument
|
|
struct MapDSD_Res dsd_res; // delete subscriber data response
|
|
struct MapSP_Arg sp_arg; // send parameters argument
|
|
struct MapSP_Res sp_res; // send parameters respons
|
|
struct MapReset_Arg reset_arg; // reset argument
|
|
struct MapRD_Arg rd_arg; // restore data argument
|
|
struct MapRD_Res rd_res; // restore data response
|
|
struct MapSRIFG_Arg srifg_arg; // send routing info for GPRS argument
|
|
struct MapSRIFG_Res srifg_res; // send routing info for GPRS response
|
|
struct MapFR_Arg fr_arg; // failure report argument
|
|
struct MapBSA_Arg bsa_arg; // Begin subscriber activaty
|
|
struct MapFR_Res fr_res; // failure report response
|
|
struct MapNMPFG_Arg nmpfg_arg; // note MS present for GPRS argument
|
|
struct MapNMPFG_Res nmpfg_res; // note MS present for GPRS response
|
|
struct MapST_Arg st_arg; // security triplets argument
|
|
struct MapST_Res st_res; // security triplets response
|
|
struct MapIS_Arg is_arg; // interrogate subscriber argument
|
|
struct MapIS_Res is_res; // interrogate subscriber response
|
|
struct MapCS_Arg cs_arg; // create subscriber argument
|
|
struct MapCS_Res cs_res; // create subscriber response
|
|
struct MapDS_Arg ds_arg; // delete subscriber argument
|
|
struct MapDS_Res ds_res; // delete subscirber response
|
|
struct MapATSI_Arg atsi_arg; // any time subscription interrogation argument
|
|
struct MapATSI_Res atsi_res; // any time subscrption interrogation response
|
|
|
|
|
|
/* MAP_V1 */
|
|
struct MapNP_Arg np_arg; //NoteSubscriberPresent argumnet
|
|
struct MapPUSSD_Arg pussd_arg; //UnstructuredSS-Data Response
|
|
struct MapPUSSD_Res pussd_res; //UnstructuredSS-Data Response
|
|
//struct MapSA_Arg sa_arg; //BeginSubscriberActivity argumnet
|
|
struct MapHO_Arg ho_arg; //perform hand over argument
|
|
struct MapHO_Res ho_res; //perform hand over response
|
|
|
|
/* OPR */
|
|
struct MapDetermineOprUser_Arg DetermineOprUser_Arg;
|
|
struct MapDetermineOprUser_Res DetermineOprUser_Res;
|
|
struct MapCreateUserWithMsisdnImsi_Arg CreateUserWithMsisdnImsi_Arg;
|
|
struct MapCreateUserWithMsisdnImsi_Res CreateUserWithMsisdnImsi_Res;
|
|
struct MapVlrUpdateLocation_Arg VlrUpdateLocation_Arg;
|
|
struct MapVlrUpdateLocation_Res VlrUpdateLocation_Res;
|
|
struct MapDeleteOprUser_Arg DeleteOprUser_Arg;
|
|
struct MapDeleteOprUser_Res DeleteOprUser_Res;
|
|
|
|
/* IMDM */
|
|
struct MapVlrEnquiryIMDM_Arg EnquiryIMDM_Arg;
|
|
struct MapVlrEnquiryIMDM_Res EnquiryIMDM_Res;
|
|
/* MAP_V1 */
|
|
|
|
/***************** LCS **********/
|
|
RoutingInfoForLCS_Arg routingInfoForLCS_Arg;
|
|
RoutingInfoForLCS_Res routingInfoForLCS_Res;
|
|
ProvideSubscriberLocation_Arg provideSubscriberLocation_Arg;
|
|
ProvideSubscriberLocation_Res provideSubscriberLocation_Res;
|
|
/***************** LCS **********/
|
|
|
|
/******is41********/
|
|
struct IS41_AUTHDIR_ARG authdir_arg;
|
|
struct IS41_AUTHDIR_RSP authdir_rsp;
|
|
struct IS41AucDirectiveForward_arg AUCDirForw_arg;
|
|
struct IS41_AFREPORT_ARG afreport_arg;
|
|
struct IS41_AFREPORT_RSP afreport_rsp;
|
|
struct IS41_AUTHREQ_ARG authreq_arg;
|
|
struct IS41_AUTHREQ_RSP authreq_rsp;
|
|
struct IS41_ASREPORT_ARG asreport_arg;
|
|
struct IS41_ASREPORT_RSP asreport_rsp;
|
|
struct IS41_BSCHALL_ARG bschall_arg;
|
|
struct IS41_BSCHALL_RSP bschall_rsp;
|
|
struct IS41_COUNTREQ_ARG countreq_arg;
|
|
struct IS41_COUNTREQ_RSP countreq_rsp;
|
|
|
|
struct IS41_SMDBACK_ARG smdback_arg;
|
|
struct IS41_SMDBACK_RSP smdback_rsp;
|
|
struct IS41_SMDFWD_ARG smdfwd_arg;
|
|
struct IS41_SMDFWD_RSP smdfwd_rsp;
|
|
struct IS41_SMDPP_ARG smdpp_arg;
|
|
struct IS41_SMDPP_RSP smdpp_rsp;
|
|
struct IS41_SMSNOT_ARG smsnot_arg;
|
|
struct IS41_SMSNOT_RSP smsnot_rsp;
|
|
struct IS41_SMSREQ_ARG smsreq_arg;
|
|
struct IS41_SMSREQ_RSP smsreq_rsp;
|
|
|
|
struct IS41_REGNOT_ARG regnot_arg;
|
|
struct IS41_REGNOT_RSP regnot_rsp;
|
|
struct IS41_REGCANC_ARG regcanc_arg;
|
|
struct IS41_REGCANC_RSP regcanc_rsp;
|
|
struct IS41_LOCREQ_ARG locreq_arg;
|
|
struct IS41_LOCREQ_RSP locreq_rsp;
|
|
struct IS41_ROUTREQ_ARG routreq_arg;
|
|
struct IS41_ROUTREQ_RSP routreq_rsp;
|
|
struct IS41_MSINACT_ARG msinact_arg;
|
|
struct IS41_MSINACT_RSP msinact_rsp;
|
|
struct IS41_QUALDIR_ARG qualdir_arg;
|
|
struct IS41_QUALDIR_RSP qualdir_rsp;
|
|
struct IS41_FEATREQ_ARG featreq_arg;
|
|
struct IS41_FEATREQ_RSP featreq_rsp;
|
|
struct IS41_REDREQ_ARG redreq_arg;
|
|
struct IS41_REDREQ_RSP redreq_rsp;
|
|
struct IS41_TRANUMREQ_ARG tranumreq_arg;
|
|
struct IS41_TRANUMREQ_RSP tranumreq_rsp;
|
|
|
|
/******* is41 for win ******/
|
|
struct IS41_ORREQ_ARG orreq_arg;
|
|
struct IS41_ORREQ_RSP orreq_rsp;
|
|
struct IS41_ANLYZD_ARG anlyzd_arg;
|
|
struct IS41_ANLYZD_RSP anlyzd_rsp;
|
|
struct IS41_OANSWER_ARG oanswer_arg;
|
|
struct IS41_ODISCONNECT_ARG odisconnect_arg;
|
|
struct IS41_ODISCONNECT_RSP odisconnect_rsp;
|
|
struct IS41_TANSWER_ARG tanswer_arg;
|
|
struct IS41_TDISCONNECT_ARG tdisconnect_arg;
|
|
struct IS41_TDISCONNECT_RSP tdisconnect_rsp;
|
|
struct IS41_CCDIR_ARG ccdir_arg;
|
|
struct IS41_CCDIR_RSP ccdir_rsp;
|
|
struct IS41_SEIZERES_ARG seizeres_arg;
|
|
struct IS41_SEIZERES_RSP seizeres_rsp;
|
|
struct IS41_CONNRES_ARG connres_arg;
|
|
struct IS41_SRFDIR_ARG srfdir_arg;
|
|
struct IS41_SRFDIR_RSP srfdir_rsp;
|
|
struct IS41_SM_ANLYZD_ARG smanlyzd_arg;
|
|
struct IS41_SM_ANLYZD_RSP smanlyzd_rsp;
|
|
|
|
/******** MNP AIN******/
|
|
struct _ProvideInstructionStart provideInstructionStart;
|
|
struct _ConnectionControlConnect connectionControlConnect;
|
|
|
|
/******** MNP AIN******/
|
|
} msg_list;
|
|
} MapOprSrv_struct;
|
|
|
|
typedef struct MapOprData_struct
|
|
{
|
|
u8 map_flag;//is41 or map
|
|
u32 param_flag;
|
|
u32 port_id;
|
|
u32 dialogue_id;
|
|
u8 invoke_id;
|
|
u8 message_type;
|
|
u8 message_flag;
|
|
u32 param_len;
|
|
u8 param[MAX_MAPPOPR_LEN];
|
|
u8 user_error;
|
|
u8 provider_error;
|
|
u8 linked_id;
|
|
} MapOprData_struct;
|
|
|
|
#endif
|