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