megaco_session_internalizer.erl

一个Megaco实现源代码

    asn1_NOVALUE;
tr_opt_TransactionId(#'MegacoMessage_OptTransactionId'{label = true, value = Id}, State) ->
    tr_TransactionId(Id, State).

tr_TransactionId(Id, State) ->
    Id.

tr_TransactionRequest(#'MegacoMessage_TransactionRequest'{id = Id, actions = Actions},
                      State) when list(Actions) ->

    #'TransactionRequest'{transactionId = tr_TransactionId(Id, State),
                          actions       = [tr_ActionRequest(ActReq, State) || ActReq <- Actions]}.

tr_TransactionPending(#'MegacoMessage_TransactionPending'{id = Id},
                      State) ->
    #'TransactionPending'{transactionId = tr_TransactionId(Id, State)}.

tr_TransactionReply(#'MegacoMessage_TransactionReply'{id                = Id,
                                                      immAckRequired    = ImmAck,
                                                      transactionResult = TransRes},
                    State) ->
    #'TransactionReply'{transactionId     = tr_TransactionId(Id, State),
                        immAckRequired    = tr_opt_null(ImmAck, State),
                        transactionResult = tr_TransactionReply_transactionResult(TransRes, State)}.

tr_opt_null(false, State) -> asn1_NOVALUE;
tr_opt_null(true, State)  -> 'NULL'.

tr_TransactionReply_transactionResult( #'MegacoMessage_TransactionResultUnion'{label = Tag,
                                                                               value = Val}, State) ->
    case Tag of
        'TransactionResultChoice_transactionError' ->
            {transactionError, tr_ErrorDescriptor(Val, State)};
        'TransactionResultChoice_actionReplies' ->
            {actionReplies, [tr_ActionReply(ActRep, State) || ActRep <- Val]}
    end.

tr_opt_ErrorDescriptor(#'MegacoMessage_OptErrorDescriptor'{label = false}, State) ->
    asn1_NOVALUE;
tr_opt_ErrorDescriptor(#'MegacoMessage_OptErrorDescriptor'{label = true,
                                                           value = ErrDesc}, State) ->
    tr_ErrorDescriptor(ErrDesc, State).

tr_ErrorDescriptor(#'MegacoMessage_ErrorDescriptor'{code = Code,
                                                    text = Text},
                   State) ->
    #'ErrorDescriptor'{errorCode = tr_ErrorCode(Code, State),
                       errorText = tr_opt_ErrorText(Text, State)}.

tr_ErrorCode(Code, State) ->
    Code.

tr_opt_ErrorText(#'MegacoMessage_OptErrorText'{label = false}, State)  ->
    asn1_NOVALUE;
tr_opt_ErrorText(#'MegacoMessage_OptErrorText'{label = true, value = Text}, State)  ->
    Text.

tr_ContextID(CtxId, State) ->
    CtxId.

tr_ActionRequest(#'MegacoMessage_ActionRequest'{id                  = CtxId,
                                                contextRequest      = CtxReq,
                                                contextAttrAuditReq = CtxAuditReq,
                                                commandRequests     = CmdReqList},
                 State) ->
    #'ActionRequest'{contextId           = tr_ContextID(CtxId, State),
                     contextRequest      = tr_opt_ContextRequest(CtxReq, State),
                     contextAttrAuditReq = tr_opt_ContextAttrAuditRequest(CtxAuditReq, State),
                     commandRequests     = [tr_CommandRequest(CmdReq, State) || CmdReq <- CmdReqList]}.

tr_ActionReply(#'MegacoMessage_ActionReply'{id              = CtxId,
                                            errorDescriptor = ErrDesc,
                                            contextReply    = CtxRep,
                                            commandReply    = CmdRepList},
               State) ->
    CmdRepList2 = [tr_CommandReply(CmdRep, State) || CmdRep <- CmdRepList],
    #'ActionReply'{contextId       = tr_ContextID(CtxId, State),
                   errorDescriptor = tr_opt_ErrorDescriptor(ErrDesc, State),
                   contextReply    = tr_opt_ContextRequest(CtxRep, State),
                   commandReply    = CmdRepList2}.

tr_opt_ContextRequest(#'MegacoMessage_OptContextRequest'{label = false}, State) ->
    asn1_NOVALUE;
tr_opt_ContextRequest(#'MegacoMessage_OptContextRequest'{label = true, value = Val}, State) ->
    tr_ContextRequest(Val, State).

tr_ContextRequest(#'MegacoMessage_ContextRequest'{priority    = Prio,
                                                  emergency   = Em,
                                                  topologyReq = TopReqList},
                      State) ->
    #'ContextRequest'{priority    = tr_opt_unsigned_short(Prio, State),
                      emergency   = tr_opt_bool(Em, State),
                      topologyReq = tr_opt_TopologyRequestList(TopReqList, State)}.

tr_opt_TopologyRequestList(#'MegacoMessage_OptTopologyRequestList'{label = false}, State) ->
    asn1_NOVALUE;
tr_opt_TopologyRequestList(#'MegacoMessage_OptTopologyRequestList'{label = true,
                                                                   value = TopReqList}, State) ->
    [tr_TopologyRequest(TopReq, State) || TopReq <- TopReqList].

tr_opt_ContextAttrAuditRequest(#'MegacoMessage_OptContextAttrAuditRequest'{label = false}, State) ->
    asn1_NOVALUE;
tr_opt_ContextAttrAuditRequest(#'MegacoMessage_OptContextAttrAuditRequest'{label = true,
                                                                           value = Val},
                               State) ->
    tr_ContextAttrAuditRequest(Val, State).

tr_ContextAttrAuditRequest(#'MegacoMessage_ContextAttrAuditRequest'{topology = Top,
                                                                        emergency = Em,
                                                                        priority = Prio},
                               State) ->
    #'ContextAttrAuditRequest'{topology  = tr_opt_null(Top, State),
                               emergency = tr_opt_null(Em, State),
                               priority  = tr_opt_null(Prio, State)}.

tr_CommandRequest(#'MegacoMessage_CommandRequest'{command        = Cmd,
                                                  optional       = Opt,
                                                  wildcardReturn = Wild},
                  State) ->
    #'CommandRequest'{optional       = tr_opt_null(Opt, State),
                      wildcardReturn = tr_opt_null(Wild, State),
                      command        = tr_Command(Cmd, State)}.

tr_Command(#'MegacoMessage_CommandUnion'{label = Tag, value = Val}, State) ->
    case Tag of
        'CommandChoice_addReq' ->
            {addReq, tr_AmmRequest(Val, State)};
        'CommandChoice_moveReq' ->
            { moveReq, tr_AmmRequest(Val, State)};
        'CommandChoice_modReq' ->
            {modReq, tr_AmmRequest(Val, State)};
        'CommandChoice_subtractReq' ->
            {subtractReq, tr_SubtractRequest(Val, State)};
        'CommandChoice_auditCapRequest' ->
            {auditCapRequest, tr_AuditRequest(Val, State)};
        'CommandChoice_auditValueRequest' ->
            {auditValueRequest, tr_AuditRequest(Val, State)};
        'CommandChoice_notifyReq' ->
            {notifyReq, tr_NotifyRequest(Val, State)};
        'CommandChoice_serviceChangeReq' ->
            {serviceChangeReq, tr_ServiceChangeRequest(Val, State)}
    end.

tr_CommandReply(#'MegacoMessage_CommandReplyUnion'{label = Tag, value = Val}, State) ->
    case Tag of
        'CommandReplyChoice_addReply' ->
            { addReply, tr_AmmsReply(Val, State)};
        'CommandReplyChoice_moveReply' ->
            { moveReply, tr_AmmsReply(Val, State)};
        'CommandReplyChoice_modReply' ->
            {modReply, tr_AmmsReply(Val, State)};
        'CommandReplyChoice_subtractReply' ->
            {subtractReply, tr_AmmsReply(Val, State)};
        'CommandReplyChoice_auditCapReply' ->
            {auditCapReply, tr_AuditReply(Val, State)};
        'CommandReplyChoice_auditValueReply' ->
            {auditValueReply, tr_AuditReply(Val, State)};
        'CommandReplyChoice_notifyReply' ->
            {notifyReply, tr_NotifyReply(Val, State)};
        'CommandReplyChoice_serviceChangeReply' ->
            {serviceChangeReply, tr_ServiceChangeReply(Val, State)}
    end.

tr_TopologyRequest(#'MegacoMessage_TopologyRequest'{terminationFrom   = From,
                                                    terminationTo     = To,
                                                    dir               = Dir},
                   State) ->
    #'TopologyRequest'{terminationFrom   = tr_TerminationID(From, State),
                       terminationTo     = tr_TerminationID(To, State),
                       topologyDirection = tr_TopologyDirection(Dir, State)}.

tr_TopologyDirection(Dir, State) ->
    case Dir of
        'TopologyDirection_bothway' -> bothway;
        'TopologyDirection_isolate' -> isolate;
        'TopologyDirection_oneway'  -> oneway
    end.

tr_AmmRequest(#'MegacoMessage_AmmRequest'{termIdList = IdList,
                                          descriptors   = DescList},
              State) ->
    #'AmmRequest'{terminationID = [tr_TerminationID(Id, State) ||
                                      Id <- IdList],
                  descriptors   = [tr_ammDescriptor(Desc, State) ||
                                      Desc <- DescList]}.

tr_ammDescriptor(#'MegacoMessage_AmmDescriptorUnion'{label = Tag, value = Desc}, State) ->
    case Tag of
        'AmmDescriptorChoice_mediaDescriptor' ->
            {mediaDescriptor, tr_MediaDescriptor(Desc, State)};
        'AmmDescriptorChoice_modemDescriptor' ->
            {modemDescriptor, tr_ModemDescriptor(Desc, State)};
        'AmmDescriptorChoice_muxDescriptor' ->
            {muxDescriptor,  tr_MuxDescriptor(Desc, State)};
        'AmmDescriptorChoice_eventsDescriptor' ->
            {eventsDescriptor, tr_EventsDescriptor(Desc, State)};
        'AmmDescriptorChoice_eventBufferDescriptor' ->
            {eventBufferDescriptor, tr_EventBufferDescriptor(Desc, State)};
        'AmmDescriptorChoice_signalsDescriptor' ->
            {signalsDescriptor, tr_SignalsDescriptor(Desc, State)};
        'AmmDescriptorChoice_digitMapDescriptor' ->
            {digitMapDescriptor, tr_DigitMapDescriptor(Desc, State)};
        'AmmDescriptorChoice_auditDescriptor' ->
            {auditDescriptor, tr_AuditDescriptor(Desc, State)}
    end.

tr_AmmsReply(#'MegacoMessage_AmmsReply'{termIdList    = IdList,
                                        terminationAudit = TermAudit},
             State) ->
    #'AmmsReply'{terminationID    = [tr_TerminationID(Id, State) ||
                                        Id <- IdList],
                 terminationAudit = tr_opt_TerminationAudit(TermAudit, State)}.

tr_SubtractRequest(#'MegacoMessage_SubtractRequest'{termIdList      = IdList,
                                                    auditDescriptor = Desc},
                   State) ->
    #'SubtractRequest'{terminationID   = [tr_TerminationID(Id, State) ||
                                             Id <- IdList],
                       auditDescriptor = tr_opt_AuditDescriptor(Desc, State)}.

tr_AuditRequest(#'MegacoMessage_AuditRequest'{termId = Id,
                                              audit  = Desc},
                State) ->
    #'AuditRequest'{terminationID = tr_TerminationID(Id, State),
                    auditDescriptor = tr_AuditDescriptor(Desc, State)}.

tr_AuditReply(#'MegacoMessage_AuditReply'{label = Tag, value = Val}, State) ->
    case Tag of
        'AuditReplyChoice_ctxAuditResult' ->
            {contextAuditResult, [tr_TerminationID(Id, State) || Id <- Val]};
        'AuditReplyChoice_error' ->
            {error, tr_ErrorDescriptor(Val, State)};
        'AuditReplyChoice_auditResult' ->
            {auditResult, tr_AuditResult(Val, State)}
    end.

tr_AuditResult(#'MegacoMessage_AuditResult'{termId                 = Id,
                                            terminationAuditResult = AuditRes},
              State) ->
    #'AuditResult'{terminationID          = tr_TerminationID(Id, State),
                   terminationAuditResult = tr_TerminationAudit(AuditRes, State)}.

tr_opt_AuditDescriptor( #'MegacoMessage_OptAuditDescriptor'{label = false}, State) ->
    asn1_NOVALUE;
tr_opt_AuditDescriptor(#'MegacoMessage_OptAuditDescriptor'{label = true, value = Desc}, State) ->
    tr_AuditDescriptor(Desc, State).

tr_AuditDescriptor(#'MegacoMessage_AuditDescriptor'{auditToken = Tokens}, State) ->
    #'AuditDescriptor'{auditToken = tr_opt_AuditTokenBitsList(Tokens, State)}.

tr_opt_AuditTokenBitsList(#'MegacoMessage_OptAuditTokenBitsList'{label = false}, State) ->
    asn1_NOVALUE;
tr_opt_AuditTokenBitsList(#'MegacoMessage_OptAuditTokenBitsList'{label = true, value = Val}, State) ->
    tr_AuditTokenBitsList(Val, State).

tr_AuditTokenBitsList(Tokens, State) ->
    [tr_auditItem(Token, State) || Token <- Tokens].

tr_auditItem(Token, State) ->
    case Token of
        'AuditTokenBits_muxToken'               -> muxToken;
        'AuditTokenBits_modemToken'             -> modemToken;
        'AuditTokenBits_mediaToken'             -> mediaToken;
        'AuditTokenBits_eventsToken'            -> eventsToken;
        'AuditTokenBits_signalsToken'           -> signalsToken;
        'AuditTokenBits_digitMapToken'          -> digitMapToken;
        'AuditTokenBits_statsToken'             -> statsToken;
        'AuditTokenBits_observedEventsToken'    -> observedEventsToken;
        'AuditTokenBits_packagesToken'          -> packagesToken;
        'AuditTokenBits_eventBufferToken'       -> eventBufferToken
    end.

tr_opt_TerminationAudit(#'MegacoMessage_OptTerminationAudit'{label = false}, State) ->
    asn1_NOVALUE;
tr_opt_TerminationAudit(#'MegacoMessage_OptTerminationAudit'{label = true, value = Val}, State) ->
    tr_TerminationAudit(Val, State).

tr_TerminationAudit(ParmList, State) when list(ParmList) ->
    [tr_AuditReturnParameter(Parm, State) || Parm <- ParmList].

tr_AuditReturnParameter(#'MegacoMessage_AuditReturnParameterUnion'{label = Tag, value = Val}, State) ->
    case Tag of
        'AuditReturnParameterChoice_errorDescriptor' ->
            {errorDescriptor, tr_ErrorDescriptor(Val, State)};
        'AuditReturnParameterChoice_mediaDescriptor' ->
            {mediaDescriptor, tr_MediaDescriptor(Val, State)};
        'AuditReturnParameterChoice_modemDescriptor' ->
            {modemDescriptor, tr_ModemDescriptor(Val, State)};
        'AuditReturnParameterChoice_muxDescriptor' ->
            {muxDescriptor, tr_MuxDescriptor(Val, State)};
        'AuditReturnParameterChoice_eventsDescriptor' ->
            {eventsDescriptor, tr_EventsDescriptor(Val, State)};
        'AuditReturnParameterChoice_eventBufferDescriptor' ->
            {eventBufferDescriptor, tr_EventBufferDescriptor(Val, State)};
        'AuditReturnParameterChoice_signalsDescriptor' ->
            {signalsDescriptor, tr_SignalsDescriptor(Val, State)};
        'AuditReturnParameterChoice_digitMapDescriptor' ->
            {digitMapDescriptor, tr_DigitMapDescriptor(Val, State)};
        'AuditReturnParameterChoice_observedEventsDescriptor' ->
            {observedEventsDescriptor, tr_ObservedEventsDescriptor(Val, State)};
        'AuditReturnParameterChoice_statisticsDescriptor' ->
            {statisticsDescriptor, tr_StatisticsDescriptor(Val, State)};
        'AuditReturnParameterChoice_packagesDescriptor' ->
            {packagesDescriptor, tr_PackagesDescriptor(Val, State)};
        'AuditReturnParameterChoice_emptyDescriptors' ->
            {emptyDescriptors, tr_AuditDescriptor(Val, State)}
    end.

tr_NotifyRequest(#'MegacoMessage_NotifyRequest'{termIdList      = IdList,
                                                observed        = ObsDesc,
                                                errorDescriptor = ErrDesc},