megaco_test_msg_v2_lib.erl

来自「OTP是开放电信平台的简称」· ERL 代码 · 共 1,969 行 · 第 1/5 页

			      eventDM           = EDM, 
			      signalsDescriptor = SD}.

cre_EventBufferDescriptor([H|_] = D) when record(H, 'EventSpec') ->
    D.

cre_EventSpec(N, [H|_] = EPL) when list(N), record(H, 'EventParameter') ->
    #'EventSpec'{eventName = N, eventParList = EPL}.

cre_EventSpec(N, SID, [H|_] = EPL) 
  when list(N), integer(SID), record(H, 'EventParameter') ->
    #'EventSpec'{eventName = N, streamID = SID, eventParList = EPL}.
    
cre_SignalsDescriptor(D) when list(D) ->
    D.

cre_SignalRequest(S) when record(S, 'Signal') ->
    {signal, S};
cre_SignalRequest(S) when record(S, 'SeqSigList') ->
    {seqSigList, S}.

cre_SeqSigList(ID, [H|_] = SL) 
  when integer(ID), 0 =< ID, ID =< 65535, record(H, 'Signal') ->
    #'SeqSigList'{id = ID, signalList = SL}.

cre_Signal(N) when list(N) ->
    #'Signal'{signalName = N}.

cre_Signal(N, [H|_] = SPL) when list(N), record(H, 'SigParameter') ->
    #'Signal'{signalName = N,
	      sigParList = SPL}.

cre_Signal(N, SID, ST, Dur, NC, KA, [H|_] = SPL) 
  when is_list(N) and 
       (is_integer(SID) or (SID == asn1_NOVALUE)) and 
       ((ST == brief) or (ST == onOff) or (ST == timeOut) or 
	(ST == asn1_NOVALUE)) and
       ((is_integer(Dur) and (0 =< Dur) and (Dur =< 65535)) or 
	(Dur == asm1_NOVALUE)) and
       is_list(NC) and
       ((KA == true) or (KA == false) or (KA == asn1_NOVALUE)) and
       is_record(H, 'SigParameter') ->
    #'Signal'{signalName       = N,
	      streamID         = SID,
	      sigType          = ST,
	      duration         = Dur,
	      notifyCompletion = NC,
	      keepActive       = KA,
	      sigParList       = SPL}.

cre_SignalType(brief = ST) ->
    ST;
cre_SignalType(onOff = ST) ->
    ST;
cre_SignalType(timeOut = ST) ->
    ST.

cre_SignalName(N) ->
    cre_PkgdName(N).

cre_NotifyCompletion(L) when list(L) ->
    Vals = [onTimeOut, onInterruptByEvent, 
	    onInterruptByNewSignalDescr, otherReason],
    F = fun(E) -> case lists:member(E, Vals) of
		      true ->
			  ok;
		      false ->
			  exit({invalid_NotifyCompletion, E})
		  end
	end,
    lists:foreach(F, L),
    L.

cre_SigParameter(N, V) when list(N), list(V) ->
    #'SigParameter'{sigParameterName = N, value = V}.

cre_SigParameter(N, V, relation = Tag, R) 
  when is_list(N) and is_list(V) and is_atom(R) ->
    EI = {Tag, R}, 
    #'SigParameter'{sigParameterName = N, value = V, extraInfo = EI};
cre_SigParameter(N, V, range = Tag, B) 
  when is_list(N) and is_list(V) and is_atom(B) ->
    EI = {Tag, B}, 
    #'SigParameter'{sigParameterName = N, value = V, extraInfo = EI};
cre_SigParameter(N, V, sublist = Tag, B) 
  when is_list(N) and is_list(V) and is_atom(B) ->
    EI = {Tag, B}, 
    #'SigParameter'{sigParameterName = N, value = V, extraInfo = EI}.

cre_RequestID(Val) when 0 =< Val, Val =< 4294967295 ->
    Val;
cre_RequestID(Val) ->
    exit({invalid_RequestID, Val}).

cre_ModemDescriptor(MTL, MPL) when list(MTL), list(MPL) ->
    #'ModemDescriptor'{mtl = MTL, mpl = MPL}.

%% cre_ModemDescriptor(MTL, MPL, NSD) 
%%   when list(MTL), list(MPL), record(NSD, 'NonStandardData') ->
%%     #'ModemDescriptor'{mtl = MTL, mpl = MPL}.

cre_ModemType(v18 = MT) ->
    MT;
cre_ModemType(v22 = MT) ->
    MT;
cre_ModemType(v22bis = MT) ->
    MT;
cre_ModemType(v32 = MT) ->
    MT;
cre_ModemType(v32bis = MT) ->
    MT;
cre_ModemType(v34 = MT) ->
    MT;
cre_ModemType(v90 = MT) ->
    MT;
cre_ModemType(v91 = MT) ->
    MT;
cre_ModemType(synchISDN = MT) ->
    MT.

cre_DigitMapDescriptor() ->
    #'DigitMapDescriptor'{}.

cre_DigitMapDescriptor(N) when list(N) ->
    #'DigitMapDescriptor'{digitMapName = N};
cre_DigitMapDescriptor(V) when record(V, 'DigitMapValue') ->
    #'DigitMapDescriptor'{digitMapValue = V}.

cre_DigitMapDescriptor(N, V) when list(N), record(V, 'DigitMapValue') ->
    #'DigitMapDescriptor'{digitMapName = N, digitMapValue = V}.

cre_DigitMapName(N) ->
    cre_Name(N).

cre_DigitMapValue(DMB) when list(DMB) ->
    #'DigitMapValue'{digitMapBody = DMB}.

cre_DigitMapValue(Start, Short, Long, DMB) ->
    cre_DigitMapValue(Start, Short, Long, DMB, asn1_NOVALUE).

cre_DigitMapValue(Start, Short, Long, DMB, Dur) 
  when ((is_integer(Start) and (0 =< Start) and (Start =< 99)) or
	(Start == asn1_NOVALUE)) and
       ((is_integer(Short) and (0 =< Short) and (Short =< 99)) or
	(Short == asn1_NOVALUE)) and
       ((is_integer(Long) and (0 =< Long) and (Long =< 99)) or
	(Long == asn1_NOVALUE)) and
       is_list(DMB) and
       ((is_integer(Dur) and (0 =< Dur) and (Dur =< 99)) or
	(Dur == asn1_NOVALUE)) ->
    #'DigitMapValue'{startTimer    = Start,
		     shortTimer    = Short,
		     longTimer     = Long,
		     digitMapBody  = DMB,
		     durationTimer = Dur}.

cre_ServiceChangeParm(M, R) when atom(M), list(R) ->
    #'ServiceChangeParm'{serviceChangeMethod = M,
			 serviceChangeReason = R}.

cre_ServiceChangeParm(M, Addr, Prof, Reason) ->
    cre_ServiceChangeParm(M, Addr, asn1_NOVALUE, Prof, Reason, asn1_NOVALUE, 
			  asn1_NOVALUE, asn1_NOVALUE, asn1_NOVALUE).
				
%% Addr = asn1_NOVALUE | {AddrTag, AddrVal}
cre_ServiceChangeParm(M, Addr, Ver, Prof, R, D, Mid, TS, I) 
  when is_atom(M) and 
       ((is_integer(Ver) and (0 =< Ver) and (Ver =< 99)) or
	(Ver == asn1_NOVALUE)) and
       (is_record(Prof, 'ServiceChangeProfile') or (Prof == asn1_NOVALUE)) and
       is_list(R) and
       ((is_integer(D) and (0 =< D) and (D =< 4294967295)) or 
	(D == asn1_NOVALUE)) and
       (is_record(TS, 'TimeNotation') or (TS == asn1_NOVALUE)) and
       (is_record(I, 'AuditDescriptor') or (I == asn1_NOVALUE)) ->
    F = fun(A) -> 
		(A == asn1_NOVALUE) orelse 
				      (is_tuple(A) 
				       andalso is_atom(element(1, A))) 
	end,
    case (F(Addr) andalso F(Mid)) of
	true ->
	    #'ServiceChangeParm'{serviceChangeMethod  = M,
				 serviceChangeAddress = Addr, 
				 serviceChangeVersion = Ver, 
				 serviceChangeProfile = Prof,
				 serviceChangeReason  = R,
				 serviceChangeDelay   = D,
				 serviceChangeMgcId   = Mid, 
				 timeStamp            = TS, 
				 serviceChangeInfo    = I};
	_ ->
	    exit({invalid_ServiceChangeParm_args, {Addr, Mid}})
    end.
		
cre_ServiceChangeAddress(portNumber = Tag, P) 
  when integer(P), 0 =< P, P =< 65535 ->
    {Tag, P};
cre_ServiceChangeAddress(ip4Address = Tag, A) when record(A, 'IP4Address') ->
    {Tag, A};
cre_ServiceChangeAddress(ip6Address = Tag, A) when record(A, 'IP6Address') ->
    {Tag, A};
cre_ServiceChangeAddress(domainName = Tag, N) when record(N, 'DomainName') ->
    {Tag, N};
cre_ServiceChangeAddress(deviceName = Tag, N) when list(N) ->
    {Tag, N};
cre_ServiceChangeAddress(mtpAddress = Tag, A) when list(A) ->
    {Tag, A}.

cre_ServiceChangeResParm() ->
    #'ServiceChangeResParm'{}.
cre_ServiceChangeResParm(Addr, Prof) ->
    cre_ServiceChangeResParm(asn1_NOVALUE, Addr, asn1_NOVALUE, 
			     Prof, asn1_NOVALUE).
cre_ServiceChangeResParm(Mid, Addr, Ver, Prof, TS)
  when ((is_integer(Ver) and (0 =< Ver) and (Ver =< 99)) or 
	(Ver == asn1_NOVALUE)) and 
       (is_record(Prof, 'ServiceChangeProfile') or (Prof == asn1_NOVALUE)) and
       (is_record(TS, 'TimeNotation') or (TS == asn1_NOVALUE)) ->
    F = fun(A) -> 
		(A == asn1_NOVALUE) orelse 
				      (is_tuple(A) 
				       andalso is_atom(element(1, A))) 
	end,
    case (F(Addr) andalso F(Mid)) of
	true ->
	    #'ServiceChangeResParm'{serviceChangeMgcId   = Mid, 
				    serviceChangeAddress = Addr, 
				    serviceChangeVersion = Ver, 
				    serviceChangeProfile = Prof,
				    timeStamp            = TS};
	_ ->
	    exit({invalid_ServiceChangeResParm_args, {Addr, Mid}})
    end.

cre_ServiceChangeMethod(failover = M) ->
    M;
cre_ServiceChangeMethod(forced = M) ->
    M;
cre_ServiceChangeMethod(graceful = M) ->
    M;
cre_ServiceChangeMethod(restart = M) ->
    M;
cre_ServiceChangeMethod(disconnected = M) ->
    M;
cre_ServiceChangeMethod(handOff = M) ->
    M.

%% The version field is added to make it look more like ABNF
cre_ServiceChangeProfile(N) ->
    cre_ServiceChangeProfile(N, 1).

cre_ServiceChangeProfile(N, V) 
  when is_list(N) and is_integer(V) and (0 =< V) and (V =< 99) ->
    #'ServiceChangeProfile'{profileName = N, version = V}.
    
cre_PackagesDescriptor([H|_] = D) when record(H, 'PackagesItem') ->
    D.

cre_PackagesItem(N, Ver) when list(N), integer(Ver), 0 =< Ver, Ver =< 99 ->
    #'PackagesItem'{packageName    = N, 
		    packageVersion = Ver}.

cre_StatisticsDescriptor([H|_] = D) when record(H, 'StatisticsParameter') ->
    D.

cre_StatisticsParameter(N) when list(N) ->
    #'StatisticsParameter'{statName = N}.

cre_StatisticsParameter(N, V) when list(N), list(V) ->
    #'StatisticsParameter'{statName = N, statValue = V}.

%% cre_NonStandardData({Tag, _} = Id, Data) when atom(Tag), list(Data) ->
%%     #'NonStandardData'{nonStandardIdentifier = Id, data = Data}.

%% cre_NonStandardIdentifier(H221) when record(H221, 'H221NonStandard') ->
%%     {h221NonStandard, H221};
%% cre_NonStandardIdentifier(Obj) when tuple(Obj) ->
%%     {object, Obj};
%% cre_NonStandardIdentifier(Exp) when list(Exp), length(Exp) == 8 ->
%%     {experimental, Exp}.

%% cre_H221NonStandard(CC1, CC2, Ext, MC) 
%%   when (is_integer(CC1) and (0 =< CC1) and (CC1 =< 255)) and
%%        (is_integer(CC2) and (0 =< CC2) and (CC2 =< 255)) and
%%        (is_integer(Ext) and (0 =< Ext) and (Ext =< 255)) and
%%        (is_integer(MC)  and (0 =< MC)  and (MC =< 255)) ->
%%     #'H221NonStandard'{t35CountryCode1  = CC1, 
%% 		       t35CountryCode2  = CC2, 
%% 		       t35Extension     = Ext, 
%% 		       manufacturerCode = MC}.
       
cre_TimeNotation(D, T) 
  when list(D), length(D) == 8, list(T), length(T) == 8 ->
    #'TimeNotation'{date = D, time = T}.
    
cre_Value([H|_] = V) when list(H) ->
    V.

cre_BOOLEAN(true = B) ->
    B;
cre_BOOLEAN(false = B) ->
    B.


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%% -- MegacoMessage -- 

is_MegacoMessage(#'MegacoMessage'{authHeader = Auth,
				  mess       = Mess}) ->
    is_opt_AuthenticationHeader(Auth) andalso is_Message(Mess);
is_MegacoMessage(_) ->
    false.

    
chk_MegacoMessage(M, M) ->
    chk_type(fun is_MegacoMessage/1, 'MegacoMessage', M);
chk_MegacoMessage(#'MegacoMessage'{authHeader = Auth1,
				   mess       = Mess1},
		  #'MegacoMessage'{authHeader = Auth2,
				   mess       = Mess2}) ->
    chk_opt_AuthenticationHeader(Auth1,Auth2),
    chk_Message(Mess1,Mess2),
    ok;
chk_MegacoMessage(M1, M2) ->
    wrong_type('MegacoMessage', M1, M2).


%% -- AuthenticationHeader -- 

is_opt_AuthenticationHeader(AH) ->
    is_OPTIONAL(fun is_AuthenticationHeader/1, AH).

is_AuthenticationHeader(#'AuthenticationHeader'{secParmIndex = SPI, 
						seqNum       = SN, 
						ad           = AD}) ->
    is_SecurityParmIndex(SPI) andalso 
	is_SequenceNum(SN) andalso 
	is_AuthData(AD);
is_AuthenticationHeader(_) ->
    false.
    
%% This stuff is not really used, so make it simple...
chk_opt_AuthenticationHeader(A1, A2) ->
    chk_OPTIONAL('AuthenticationHeader', A1, A2, 
		 fun is_AuthenticationHeader/1, 
		 fun chk_AuthenticationHeader/2).

chk_AuthenticationHeader(A, A) ->
    chk_type(fun is_AuthenticationHeader/1, 'AuthenticationHeader', A);
chk_AuthenticationHeader(A1, A2) ->
    case (is_AuthenticationHeader(A1) andalso is_AuthenticationHeader(A2)) of
	true ->
	    not_equal('AuthenticationHeader', A1, A2);
	false ->
	    wrong_type('AuthenticationHeader', A1, A2)
    end.


%% -- SecurityParmIndex --

is_SecurityParmIndex(V) -> is_OCTET_STRING(V, {exact, 4}).


%% -- SequenceNum --

is_SequenceNum(V) -> is_OCTET_STRING(V, {exact, 4}).


%% -- AuthData --

is_AuthData(V) -> is_OCTET_STRING(V, {range, 12, 32}).


%% -- Message --

is_Message(#'Message'{version     = V,
		      mId         = MID,
		      messageBody = Body}) ->
    is_INTEGER(V, {range, 0, 99}) andalso 
	is_MId(MID) andalso 
	is_Message_messageBody(Body);
is_Message(_) ->
    false.

chk_Message(M,M) when record(M,'Message') ->
    ok;
chk_Message(#'Message'{version     = V1,
		       mId         = MID1,
		       messageBody = Body1},
	    #'Message'{version     = V2,
		       mId         = MID2,
		       messageBody = Body2}) ->