/* 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