megaco_session_internalizer.erl

一个Megaco实现源代码

                 State) ->
    #'NotifyRequest'{terminationID            = [tr_TerminationID(Id, State) ||
                                                    Id <- IdList],
                     observedEventsDescriptor = tr_ObservedEventsDescriptor(ObsDesc, State),
                     errorDescriptor          = tr_opt_ErrorDescriptor(ErrDesc, State)}.

tr_NotifyReply(#'MegacoMessage_NotifyReply'{termIdList  = IdList,
                                            error       = ErrDesc},
               State) ->
    #'NotifyReply'{terminationID   = [tr_TerminationID(Id, State) || Id <- IdList],
                   errorDescriptor = tr_opt_ErrorDescriptor(ErrDesc, State)}.

tr_ObservedEventsDescriptor(#'MegacoMessage_ObservedEventsDescriptor'{id = Id,
                                                                      observedEventLst = Events},
                            State) when list (Events) ->
    #'ObservedEventsDescriptor'{requestId        = tr_RequestID(Id, State),
                                observedEventLst = [tr_ObservedEvent(E, State) || E <- Events]}.

tr_ObservedEvent(#'MegacoMessage_ObservedEvent'{name         = Name,
                                                id           = Id,
                                                eventParList = Parms,
                                                timeNotation = Time},
                 State) ->
    #'ObservedEvent'{eventName    = tr_EventName(Name, State),
                     streamID     = tr_opt_StreamID(Id, State),
                     eventParList = [tr_EventParameter(P, Name, State) || P <- Parms],
                     timeNotation = tr_opt_TimeNotation(Time, State)}.

tr_EventName(Name, State) ->
    tr_PkgdName(Name, State).

tr_EventParameter(#'MegacoMessage_EventParameter'{eventParameterName = ParName,
						  eventParameterValue= Value,
						  extraInfo          = Extra},
                  EventName,
                  State) ->
    #'EventParameter'{eventParameterName = tr_Name(ParName, State),
		      value              = tr_Value(Value, State),
		      extraInfo          = tr_opt_extraInfo(Extra, State)}.

tr_ServiceChangeRequest(#'MegacoMessage_ServiceChangeRequest'{termIdList      = IdList,
                                                              serviceChangeParms = Parms},
                        State) ->
    #'ServiceChangeRequest'{terminationID      = [tr_TerminationID(Id, State) || Id <- IdList],
                            serviceChangeParms = tr_ServiceChangeParm(Parms, State)}.

tr_ServiceChangeReply(#'MegacoMessage_ServiceChangeReply'{termIdList          = IdList,
                                                          serviceChangeResult = Res},
                      State) ->
    #'ServiceChangeReply'{terminationID       = [tr_TerminationID(Id, State) || Id <- IdList],
                          serviceChangeResult = tr_ServiceChangeResult(Res, State)}.

tr_ServiceChangeResult(#'MegacoMessage_ServiceChangeResultUnion'{label = Tag, 
								 value = Val}, State) ->
    case Tag of
	'ServiceChangeResultChoice_errorDescriptor' -> 
	    {errorDescriptor, tr_ErrorDescriptor(Val, State)};
	'ServiceChangeResultChoice_serviceChangeResParms' -> 
	    {serviceChangeResParms, tr_ServiceChangeResParm(Val, State)}
    end.

tr_TerminationID(#'MegacoMessage_TerminationIdUnion'{label = Tag, value = Val}, State) ->
    case Tag of
        'Encoding_binary' ->
            #'MegacoMessage_BinaryTerminationId'{wildcard = Wild, 
						 id = Id} = Val,
            #'TerminationID'{wildcard = Wild, id = Id};
        'Encoding_text' ->
            #'MegacoMessage_TextTerminationId'{containsWildcards = IsWild, 
					       id = Id} = Val,
            #megaco_term_id{contains_wildcards = IsWild, id = Id}
    end.

tr_opt_bool(#'MegacoMessage_OptBoolean'{label = false}, State) ->
    asn1_NOVALUE;
tr_opt_bool(#'MegacoMessage_OptBoolean'{label = true,
                                        value = Bool}, State) ->
    tr_bool(Bool, State).

tr_bool(Bool, State)  -> Bool.

tr_MediaDescriptor(#'MegacoMessage_MediaDescriptor'{termStateDescr = TermState,
                                                    streams        = Streams},
                   State) ->
    #'MediaDescriptor'{termStateDescr = tr_opt_TerminationStateDescriptor(TermState, State),
                       streams        = tr_opt_streams(Streams, State)}.

tr_opt_streams(#'MegacoMessage_OptStreamsUnion'{label = false}, State) ->
    asn1_NOVALUE;
tr_opt_streams(#'MegacoMessage_OptStreamsUnion'{label = true, value = Val}, State) ->
    tr_streams(Val, State).

tr_streams(#'MegacoMessage_StreamsUnion'{label = Tag, value = Val}, State) ->
    case Tag of
        'OptStreamsChoice_oneStream' ->
            {oneStream, tr_StreamParms(Val, State)};
        'OptStreamsChoice_multiStream' ->
            {multiStream, [tr_StreamDescriptor(SD, State) || SD <- Val]}
    end.

tr_StreamParms(#'MegacoMessage_StreamParms'{localControlDescriptor = Control,
                              localDescriptor        = Local,
                              remoteDescriptor       = Remote},
               State) ->
    #'StreamParms'{localControlDescriptor = tr_opt_LocalControlDescriptor(Control, State),
                   localDescriptor        = tr_opt_LocalRemoteDescriptor(Local, State),
                   remoteDescriptor       = tr_opt_LocalRemoteDescriptor(Remote, State)}.

tr_StreamDescriptor(#'MegacoMessage_StreamDescriptor'{id    = Id,
                                                      parms = Parms},
                    State) ->
    #'StreamDescriptor'{streamID    = tr_StreamID(Id, State),
                        streamParms = tr_StreamParms(Parms, State)}.

tr_opt_LocalControlDescriptor(#'MegacoMessage_OptLocalControlDescriptor'{label = false}, State) ->
    asn1_NOVALUE;
tr_opt_LocalControlDescriptor(Val, State) ->
    tr_LocalControlDescriptor(Val, State).

tr_LocalControlDescriptor(#'MegacoMessage_LocalControlDescriptor'{streamMode    = Mode,
                                                                  reserveGroup  = Group,
                                                                  reserveValue  = Value,
                                                                  propertyParms = Props},
                          State) ->
    #'LocalControlDescriptor'{streamMode    = tr_opt_StreamMode(Mode, State),
                              reserveGroup  = tr_opt_bool(Group, State),
                              reserveValue  = tr_opt_bool(Value, State),
                              propertyParms = [tr_PropertyParm(P, State) || P <- Props]}.

tr_opt_StreamMode(#'MegacoMessage_OptStreamMode'{label = false}, State) ->
    asn1_NOVALUE;
tr_opt_StreamMode(#'MegacoMessage_OptStreamMode'{label = true, value = Val}, State) ->
    tr_StreamMode(Val, State).

tr_StreamMode(Mode, State) ->
    case Mode of
        'StreamMode_sendOnly' -> sendOnly;
        'StreamMode_recvOnly' -> recvOnly;
        'StreamMode_sendRecv' -> sendRecv;
        'StreamMode_inactive' -> inactive;
        'StreamMode_loopBack' -> loopBack
    end.

tr_Name(Name, State) ->
    Name.

tr_PkgdName(Name, State) ->
    Name.

tr_opt_LocalRemoteDescriptor(#'MegacoMessage_OptLocalRemoteDescriptor'{label = false}, State) ->
    asn1_NOVALUE;
tr_opt_LocalRemoteDescriptor(#'MegacoMessage_OptLocalRemoteDescriptor'{label = true, value = Val}, State) ->
    tr_LocalRemoteDescriptor(Val, State).

tr_LocalRemoteDescriptor(#'MegacoMessage_LocalRemoteDescriptor'{propGrps = Groups}, State) ->
    #'LocalRemoteDescriptor'{propGrps = [tr_PropertyGroup(G, State) || G <- Groups]}.

tr_PropertyGroup(Props, State) ->
    [tr_PropertyGroup(P, State) || P <- Props].

tr_PropertyParm(#'MegacoMessage_PropertyParm'{name      = Name,
                                              value     = Value,
                                              extraInfo = Extra},
                State) ->
    #'PropertyParm'{name      = tr_PkgdName(Name, State),
                    value     = tr_Value(Value, State),
                    extraInfo = tr_opt_extraInfo(Extra, State)}.

tr_opt_extraInfo(#'MegacoMessage_OptExtraInfoUnion'{label = false}, State) ->
    asn1_NOVALUE;
tr_opt_extraInfo(#'MegacoMessage_OptExtraInfoUnion'{label = true, value = Val}, State) ->
    tr_extraInfo(Val, State).

tr_extraInfo(#'MegacoMessage_ExtraInfoUnion'{label = Tag, value = Val}, State) ->
    case Tag of
        'ExtraInfoChoice_relation' ->
            {relation, tr_Relation(Val, State)};
        'ExtraInfoChoice_range' ->
            {range, tr_bool(Val, State)};
        'ExtraInfoChoice_sublist' ->
            {sublist, tr_bool(Val, State)}
    end.

tr_Relation(Val, State) ->
    case Val of
        'Relation_greaterThan' -> greaterThan;
        'Relation_smallerThan' -> smallerThan ;
        'Relation_unequalTo'   -> unequalTo
    end.

tr_opt_TerminationStateDescriptor(#'MegacoMessage_OptTerminationStateDescriptor'{label = false}, State) ->
    asn1_NOVALUE;
tr_opt_TerminationStateDescriptor(#'MegacoMessage_OptTerminationStateDescriptor'{label = true,
                                                                                 value = Val}, State) ->
    tr_TerminationStateDescriptor(Val, State).

tr_TerminationStateDescriptor(#'TerminationStateDescriptor'{propertyParms      = Props,
                                                            eventBufferControl = Control,
                                                            serviceState       = Service},
                              State) ->
    #'MegacoMessage_TerminationStateDescriptor'{propertyParms      = [tr_PropertyParm(P, State) || P <- Props],
                                                eventBufferControl = tr_opt_EventBufferControl(Control, State),
                                                serviceState       = tr_opt_ServiceState(Service, State)}.

tr_opt_EventBufferControl(#'MegacoMessage_OptEventBufferControl'{label = false}, State) ->
    asn1_NOVALUE;
tr_opt_EventBufferControl(#'MegacoMessage_OptEventBufferControl'{label = true,
                                                                 value = Val}, State) ->
    tr_EventBufferControl(Val, State).

tr_EventBufferControl(Control, State) ->
    case Control of
        'EventBufferControl_off'      -> off;
        'EventBufferControl_lockStep' -> lockStep
    end.

tr_opt_ServiceState(#'MegacoMessage_OptServiceState'{label = false}, State) ->
    asn1_NOVALUE;
tr_opt_ServiceState(#'MegacoMessage_OptServiceState'{label = true,
                                                     value = Val}, State) ->
    tr_ServiceState(Val, State).

tr_ServiceState(Service, State) ->
    case Service of
        'ServiceState_test'     -> test;
        'ServiceState_outOfSvc' -> outOfSvc;
        'ServiceState_inSvc'    -> inSvc
    end.

tr_MuxDescriptor(#'MegacoMessage_MuxDescriptor'{type  = Type,
                                                termIdList = IdList},
                 State) ->
    #'MuxDescriptor'{muxType  = tr_MuxType(Type, State),
                     termList = [tr_TerminationID(Id, State) || Id <- IdList]}.

tr_MuxType(Type, State) ->
    case Type of
        'MuxType_h221' -> h221;
        'MuxType_h223' -> h223;
        'MuxType_h226' -> h226;
        'MuxType_v76'  -> v76
    end.

tr_opt_StreamID(#'MegacoMessage_OptStreamID'{label = false}, State) ->
    asn1_NOVALUE;
tr_opt_StreamID(#'MegacoMessage_OptStreamID'{label = true,
                                             value = Val}, State) ->
    tr_StreamID(Val, State).

tr_StreamID(Id, State) ->
    Id.

tr_EventsDescriptor(#'MegacoMessage_EventsDescriptor'{requestID = Id,
                                                      eventList = Events},
                    State) ->
    #'EventsDescriptor'{requestID = tr_opt_RequestID(Id, State),
                        eventList = [tr_RequestedEvent(E, State) || E <- Events]}.

tr_RequestedEvent(#'MegacoMessage_RequestedEvent'{name    = Name,
                                                  streamID    = Id,
                                                  evParList   = Parms,
                                                  eventAction = Actions},
                  State)  ->
    #'RequestedEvent'{pkgdName    = tr_PkgdName(Name, State),
                      streamID    = tr_opt_StreamID(Id, State),
                      eventAction = tr_opt_RequestedActions(Actions, State),
                      evParList   = [tr_EventParameter(P, Name, State) || P <- Parms]}.

tr_opt_RequestedActions(#'MegacoMessage_OptRequestedActions'{label = false}, State) ->
    asn1_NOVALUE;
tr_opt_RequestedActions(#'MegacoMessage_OptRequestedActions'{label = true, value = Val}, State) ->
    tr_RequestedActions(Val, State).

tr_RequestedActions(#'MegacoMessage_RequestedActions'{keepActive        = Keep,
                                                      eventDM           = DM,
                                                      secondEvent       = Event,
                                                      signalsDescriptor = SigDesc},
                    State) ->
    #'RequestedActions'{keepActive        = tr_opt_bool(Keep, State),
                        eventDM           = tr_opt_EventDM(DM, State),
                        secondEvent       = tr_opt_SecondEventsDescriptor(Event, State),
                        signalsDescriptor = tr_opt_SignalsDescriptor(SigDesc, State)}.

tr_opt_EventDM(#'MegacoMessage_OptEventDMUnion'{label = false}, State) ->
    asn1_NOVALUE;
tr_opt_EventDM(#'MegacoMessage_OptEventDMUnion'{label = true,
                                                value = Val}, State) ->
    tr_EventDM(Val, State).

tr_EventDM(#'MegacoMessage_EventDMUnion'{label = Tag, value = Val}, State) ->
    case Tag of
        'digitMapName'  ->
            {digitMapName,tr_DigitMapName(Val, State)};
        'digitMapValue' ->
            {digitMapValue, tr_DigitMapValue(Val, State)}
    end.

tr_opt_SecondEventsDescriptor(#'MegacoMessage_OptSecondEventsDescriptor'{label = false}, State) ->
    asn1_NOVALUE;
tr_opt_SecondEventsDescriptor(#'MegacoMessage_OptSecondEventsDescriptor'{label = true,
                                                                         value = Val}, State) ->
    tr_SecondEventsDescriptor(Val, State).

tr_SecondEventsDescriptor(#'MegacoMessage_SecondEventsDescriptor'{id = Id,
                                                                  eventList = Events},
                          State) ->
    #'SecondEventsDescriptor'{requestID = tr_RequestID(Id, State),
                              eventList = [tr_SecondRequestedEvent(E, State) || E <- Events]}.

tr_SecondRequestedEvent(#'MegacoMessage_SecondRequestedEvent'{name        = Name,
							      streamID    = Id,