megaco_text_parser_prev3c.hrl

OTP是开放电信平台的简称

%% ``The contents of this file are subject to the Erlang Public License,
%% Version 1.1, (the "License"); you may not use this file except in
%% compliance with the License. You should have received a copy of the
%% Erlang Public License along with this software. If not, it can be
%% retrieved via the world wide web at http://www.erlang.org/.
%% 
%% Software distributed under the License is distributed on an "AS IS"
%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
%% the License for the specific language governing rights and limitations
%% under the License.
%% 
%% The Initial Developer of the Original Code is Ericsson Utvecklings AB.
%% Portions created by Ericsson are Copyright 1999, Ericsson Utvecklings
%% AB. All Rights Reserved.''
%% 
%%     $Id$
%%
%%----------------------------------------------------------------------
%% Purpose : Define semantic text parser actions
%%----------------------------------------------------------------------


-include_lib("megaco/include/megaco.hrl").
-include_lib("megaco/include/megaco_message_prev3c.hrl").
-include("megaco_text_tokens.hrl").

make_safe_token({_TokenTag, Line, Text}) ->
    {safeToken, Line, Text}.

ensure_value({safeToken, _Line, Text}) ->
    ensure_value(Text);
ensure_value({'QuotedChars', _Line, Text}) ->
    ensure_value(Text);
ensure_value(Text) when list(Text) ->
    Text. %% BUGBUG: ensure length

%% NAME       = ALPHA *63(ALPHA / DIGIT / "_" )
ensure_NAME({_TokenTag, _Line, Text}) ->
    Text.  %% BUGBUG: ensure length and chars

ensure_requestID({safeToken, _Line, "*"}) ->
    ?megaco_all_request_id;
ensure_requestID(RequestId) ->
    ensure_uint32(RequestId).

ensure_streamID(StreamId) ->
    ensure_uint16(StreamId).

ensure_auth_header(SpiToken, SnToken, AdToken) ->
    Spi = ensure_hex(SpiToken, 8,  8),
    Sn  = ensure_hex(SnToken,  8,  8), 
    Ad  = ensure_hex(AdToken, 24, 64),
    #'AuthenticationHeader'{secParmIndex = Spi, seqNum = Sn, ad = Ad}.

%% The values 0x0, 0xFFFFFFFE and 0xFFFFFFFF are reserved.
%% ContextID         = (UINT32 / "*" / "-" / "$")
ensure_contextID({_TokenTag, Line, Text}) ->
    case Text of
        "*"  -> ?megaco_all_context_id;
        "-"  -> ?megaco_null_context_id;
        "\$" -> ?megaco_choose_context_id;
        Int  ->
            CID = ensure_uint32(Int),
            if
                (CID =/= 0) and
                (CID =/= 16#FFFFFFFE) and
                (CID =/= 16#FFFFFFFF) ->
                    CID;
                true ->
                    return_error(Line, {bad_ContextID, CID})
            end
    end.

ensure_domainAddress([{_T, _L, _A} = Addr0], Port) ->
    Addr = ensure_ip4addr(Addr0), 
    {ip4Address, #'IP4Address'{address = Addr, portNumber = Port}};
ensure_domainAddress([colon,colon], Port) ->
    Addr = [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
    {ip6Address, #'IP6Address'{address = Addr, portNumber = Port}};
ensure_domainAddress(Addr0, Port) ->
    Addr = ensure_ip6addr(Addr0),
    {ip6Address, #'IP6Address'{address = Addr, portNumber = Port}}.


ensure_ip4addr({TokenTag, Line, Addr}) ->
    case string:tokens(Addr, [$.]) of
	[T1, T2, T3, T4] ->
	    A1 = ensure_uint({TokenTag, Line, T1}, 0, 255),
	    A2 = ensure_uint({TokenTag, Line, T2}, 0, 255),
	    A3 = ensure_uint({TokenTag, Line, T3}, 0, 255),
	    A4 = ensure_uint({TokenTag, Line, T4}, 0, 255),
	    [A1, A2, A3, A4];
	_ ->
	    return_error(Line, {bad_IP4address, Addr})
    end.


ensure_ip6addr([colon,colon|T]) ->
    [H1|T1] = lists:reverse(T),
    case do_ensure_ip6addr(T1, true, [ensure_hex4_or_ip4addr(H1)], 1) of
	{true, A} when length(A) == 16 ->
	    A;
	{true, B} when length(B) < 16 ->
	    lists:duplicate(16 - length(B), 0) ++ B;
	{true, C} ->
	    throw({error, {?MODULE, {bad_mid_ip6addr_length, C}}})
    end;
ensure_ip6addr(L) ->
    case lists:reverse(L) of
	[colon, colon| T] ->
	    case do_ensure_ip6addr(T, true, [], 1) of
		{true, A} when length(A) == 16 ->
		    A;
		{true, B} when length(B) < 16 ->
		    B ++ lists:duplicate(16 - length(B), 0);
		{true, C} ->
		    throw({error, {?MODULE, {bad_mid_ip6addr_length, C}}})
	    end;
	[H|L1] -> % A (last element) could be an ip4 address
	    case do_ensure_ip6addr(L1,false,[ensure_hex4_or_ip4addr(H)],1) of
		{false, A} when length(A) == 16 -> 
		    A;
		%% allow a pad even if the address is full (i.e. 16)
		{true, B} when length(B) =< 17 -> 
		    do_ensure_ip6addr_padding(B, 0);
		{Pad, C} ->
		    throw({error, {?MODULE, {bad_mid_ip6addr_length, Pad, C}}})
	    end

    end.


do_ensure_ip6addr([], Pad, Acc, _) ->
    {Pad, lists:flatten(Acc)};
do_ensure_ip6addr([colon,colon|T], false, Acc, Line) ->
    do_ensure_ip6addr(T, true, [pad|Acc], Line);
do_ensure_ip6addr([colon,colon|T], true, Acc, Line) ->
    return_error(Line, {bad_mid_duplicate_padding, T, Acc});
do_ensure_ip6addr([colon|T], Pad, Acc, Line) ->
    do_ensure_ip6addr(T, Pad, Acc, Line);
do_ensure_ip6addr([{_, Line, _} = A|T], Pad, Acc, _) ->
    do_ensure_ip6addr(T, Pad, [ensure_hex4(A)|Acc], Line).

do_ensure_ip6addr_padding([], _) ->
    [];
do_ensure_ip6addr_padding([pad|T], N) ->
    lists:duplicate(16 - (N + length(T)), 0) ++ T;
do_ensure_ip6addr_padding([H|T], N) ->
    [H|do_ensure_ip6addr_padding(T, N+1)].

ensure_hex4_or_ip4addr({TokenTag, Line, Addr} = V) ->
    case string:tokens(Addr, [$.]) of
	[T1, T2, T3, T4] ->
	    A1 = ensure_uint({TokenTag, Line, T1}, 0, 255),
	    A2 = ensure_uint({TokenTag, Line, T2}, 0, 255),
	    A3 = ensure_uint({TokenTag, Line, T3}, 0, 255),
	    A4 = ensure_uint({TokenTag, Line, T4}, 0, 255),
	    [A1, A2, A3, A4];
	_ ->
	    ensure_hex4(V)
	    %% 	    %% BMK BMK BMK 
	    %% 	    %% Here we should test for hexseq
	    %% 	    return_error(Line, {bad_IP4address, Addr})
    end.

ensure_hex4({_TokenTag, Line, Hex4}) 
  when length(Hex4) =< 4, length(Hex4) > 0 ->
    case (catch do_ensure_hex4(Hex4)) of
	IL when list(IL), length(IL) == 2 ->
	    IL;
	Error ->
	    return_error(Line, {bad_hex4, Hex4, Error})
    end.

do_ensure_hex4([_H1, _H2, _H3, _H4] = H) ->
    hex_to_int(H, []);
do_ensure_hex4([H2, H3, H4]) ->
    hex_to_int([$0, H2, H3, H4], []);
do_ensure_hex4([H3, H4]) ->
    hex_to_int([$0, $0, H3, H4], []);
do_ensure_hex4([H4]) ->
    hex_to_int([$0, $0, $0, H4], []).

ensure_domainName({_TokenTag, _Line, Name}, Port) ->
    %% BUGBUG: validate name
    {domainName, #'DomainName'{name = Name, portNumber = Port}}.

%% extensionParameter= "X"  ("-" / "+") 1*6(ALPHA / DIGIT)
ensure_extensionParameter({_TokenTag, Line, Text}) ->
    case Text of
        [X, S | _Chars] ->
            if
                X /= $X, X /= $x,
                S /= $+, S /= $- ->
                    return_error(Line, {bad_extension_parameter, Text});
                true ->
                    {extension_parameter, Text}
            end;
        _ ->
            return_error(Line, {bad_extension_parameter, Text})
    end.

ensure_message(MegacopToken,  MID, Body) ->
    #'ServiceChangeProfile'{profileName = Name,
			    version     = Version} = 
	ensure_profile(MegacopToken),
    case Name of
        "megaco" ->
            #'Message'{version = Version, mId = MID, messageBody = Body};
        [$!]  ->
            #'Message'{version = Version, mId = MID, messageBody = Body}
    end.


%% Corr1:
%% As of corr 1 ModemDescriptor has been deprecated.
%% and since this functon is only used when creating
%% a ModemDescriptor, iit is removed.
%% modemType         = (V32bisToken / V22bisToken / V18Token / 
%%                      V22Token / V32Token / V34Token / V90Token / 
%%                      V91Token / SynchISDNToken / extensionParameter)
%% ensure_modemType({_TokenTag, _Line, Text} = Token) ->
%%     case Text of
%%         "v32b"      -> v32bis;
%%         "v22b"      -> v22bis;
%%         "v18"       -> v18;
%%         "v22"       -> v22;
%%         "v32"       -> v32;
%%         "v34"       -> v34;
%%         "v90"       -> v90;
%%         "v91"       -> v91;
%%         "synchisdn" -> synchISDN;
%%         "sn"        -> synchISDN;
%%         [$x | _]               -> ensure_extensionParameter(Token)
%%     end.

%% An mtp address is five octets long
ensure_mtpAddress({_TokenTag, _Line, Addr}) ->
    %% BUGBUG: validate address
    {mtpAddress, Addr}.

%% MuxType = ( H221Token / H223Token / H226Token / V76Token / extensionParameter )
ensure_muxType({_TokenTag, _Line, Text} = Token) ->
    case Text of
        "h221"  -> h221;
        "h223"  -> h223;
        "h226"  -> h226;
        "v76"   -> v76;
        "nx64k" -> nx64k; % v2
        [$x | _]          -> ensure_extensionParameter(Token)
    end.

%% packagesItem      = NAME "-" UINT16
%% NAME              = ALPHA *63(ALPHA / DIGIT / "_" )
ensure_packagesItem({_TokenTag, Line, Text} = Token) ->
    case string:tokens(Text, [$-]) of
        [Name, Version] ->
            #'PackagesItem'{packageName    = ensure_NAME(
					       setelement(3, Token, Name)), 
                            packageVersion = ensure_uint(
					       setelement(3, Token, Version), 
					       0, 99)};
        _ ->
            return_error(Line, {bad_PackagesItem, Text})
    end.

%% pkgdName          =  (PackageName / "*")  SLASH  (ItemID / "*" )
%% PackageName       = NAME
%% ItemID            = NAME
ensure_pkgdName({_TokenTag, Line, Text} = Token) ->
    case string:tokens(Text, [$/]) of
        [Name, Item] ->
            ensure_name_or_star(setelement(3, Token, Name)),
            ensure_name_or_star(setelement(3, Token, Item)),
            Text;
        _ ->
            return_error(Line, {bad_pkgdName, Text})
    end.

ensure_name_or_star({_, _, Name}) when Name == "*" ->
    Name;
ensure_name_or_star(Name) ->
    ensure_NAME(Name).



%% v2 - start

merge_indAudMediaDescriptor(Vals) ->
%%     d("merge_indAudMediaDescriptor -> entry with"
%%       "~n   Vals: ~p", [Vals]),
    merge_indAudMediaDescriptor(Vals, #'IndAudMediaDescriptor'{}).

merge_indAudMediaDescriptor(
  [], #'IndAudMediaDescriptor'{streams = Streams1} = D) ->
%%     d("merge_indAudMediaDescriptor -> entry with"
%%       "~n   Streams1: ~p"
%%       "~n   D:        ~p", [Streams1, D]),
    Streams2 = 
	case Streams1 of
	    {multiStream, Descs} ->
		{multiStream, lists:reverse(Descs)};
	    _ ->
		Streams1
	end,
    D#'IndAudMediaDescriptor'{streams = Streams2};
merge_indAudMediaDescriptor([{termStateDescr, Val}|Vals], D) 
  when D#'IndAudMediaDescriptor'.termStateDescr == asn1_NOVALUE ->
%%     d("merge_indAudMediaDescriptor(termStateDescr) -> entry with"
%%       "~n   Val: ~p"
%%       "~n   D:   ~p", [Val, D]),
    D2 = #'IndAudMediaDescriptor'{termStateDescr = Val},
    merge_indAudMediaDescriptor(Vals, D2);
merge_indAudMediaDescriptor([{streamParm, Val}|Vals], D)  
  when D#'IndAudMediaDescriptor'.streams == asn1_NOVALUE ->
%%     d("merge_indAudMediaDescriptor(streamParm) -> entry with"
%%       "~n   Val: ~p"
%%       "~n   D:   ~p", [Val, D]),
    D2 = #'IndAudMediaDescriptor'{streams = {oneStream, Val}},
    merge_indAudMediaDescriptor(Vals, D2);