megaco(3)

MODULE
megaco - Main API of the Megaco application

DESCRIPTION

Interface module for the Megaco application

EXPORTS

start() -> ok | {error, Reason}

    Types
        Reason = term()

    Starts the Megaco application

    Users may either explicitly be registered with megaco:start_user/2 and/or be statically configured by setting the application environment variable 'users' to a list of {UserMid, Config} tuples. See the function megaco:start_user/2 for details.

stop() -> ok | {error, Reason}
stop

    Types
        Reason = term()

    Stops the Megaco application

start_user(UserMid, Config) -> ok | {error, Reason}

    Types
        UserMid = megaco_mid()
        Config = [{user_info_item(), user_info_value()}]
        Reason = term()

    Initial configuration of a user

    Requires the megaco application to be started. A user is either a Media Gateway (MG) or a Media Gateway Controller (MGC). One Erlang node may host many users.

    A user is identified by its UserMid, which must be a legal Megaco MID.

    Config is a list of {Item, Value} tuples. See megaco:user_info/2 about which items and values that are valid.

stop_user(UserMid) -> ok | {error, Reason}

    Types
        UserMid = megaco_mid()
        Reason = term()

    Delete the configuration of a user

    Requires that the user does not have any active connection.

user_info(UserMid, Item) -> Value | exit(Reason)

    Types
        Handle = user_info_handle()
        UserMid = megaco_mid()
        Item = user_info_item()
        Value = user_info_value()
        Reason = term()

    Lookup user information

    The following Item's are valid:

        connections:
            Lists all active connections for this user. Returns a list of megaco_conn_handle records.

        receive_handle:
            Construct a megaco_receive_handle record from user config

        min_trans_id:
            First trans id. A positive integer, defaults to 1.

        max_trans_id:
            Last trans id. A positive integer or infinity, defaults to infinity.

        request_timer:
            Wait for reply. A Timer (see explanation below, defaults to #megaco_incr_timer{}).

        long_request_timer:
            Wait for reply after pending. A Timer (see explanation below, defaults to infinity).

        auto_ack:
            Automatic send transaction ack when the transaction reply has been received (see accu_ack_timer below). A boolean, defaults to false.

        accu_ack_timer:
            Accumulated ack's timeout time. Has two functions. First, if the value is 0, then ack's will not be accumulated. Second, if the value is greater then 0 and auto_ack is true, then ack's will be accumulated (instead of sent immediatly) and the value indicates the maximum length (see accu_ack_maxcount) of time ack's will be accumulated before sending them (in one message) (see also accu_ack_maxcount below).
            An integer, defaults to 0.

        accu_ack_maxcount:
            Maximum number of accumulated ack's. At most this many ack's will be accumulated.
            The accumulated ack's will be sent either when the accu_ack_timer expires or when accu_ack_maxcount number of ack's has been accumulated, whichever happens first. (see accu_ack_timer above). An integer, defaults to 10.

        pending_timer:
            Automatic send pending if the timer expires before a transaction reply has been sent. This timer is also called provisional response timer. A Timer (see explanation below, defaults to 30000).

        reply_timer:
            Wait for an ack. A Timer (see explanation below, defaults to 30000).

        send_mod:
            Send callback module which exports send_message/2. The function SendMod:send_message(SendHandle, Binary) is invoked when the bytes needs to be transmitted to the remote user. An atom, defaults to megaco_tcp.

        encoding_mod:
            Encoding callback module which exports encode_message/2 and decode_message/2. The function EncodingMod:encode_message(EncodingConfig, MegacoMessage) is invoked whenever a 'MegacoMessage' record needs to be translated into an Erlang binary. The function EncodingMod:decode_message(EncodingConfig, Binary) is invoked whenever an Erlang binary needs to be translated into a 'MegacoMessage' record. An atom, defaults to megaco_pretty_text_encoder.

        encoding_config:
            Encoding module config. A list, defaults to [].

        protocol_version:
            Actual protocol version. Current default is 1.

        reply_data:
            Default reply data. Any term, defaults to the atom undefined.

        user_mod:
            Name of the user callback module. See the the reference manual for megaco_user for more info.

        user_args:
            List of extra arguments to the user callback functions. See the the reference manual for megaco_user for more info.

    A Timer may be:

        infinity:
            Means that the timer never will time out

        Integer:
            Waits the given number of milli seconds before it times out.

        IncrTimer:
            A megaco_incr_timer record. Waits a given number of milli seconds, recalculates a new timer by multiplying a static factor and adding a static increment and starts all over again after retransmitting the message again. A maximum number of repetition can be stated.

update_user_info(UserMid, Item, Value) -> ok | {error, Reason}

    Types
        UserMid = megaco_mid()
        Item = user_info_item()
        Value = user_info_value()
        Reason = term()

    Update information about a user

    Requires that the user is started. See megaco:user_info/2 about which items and values that are valid.

conn_info(ConnHandle, Item) -> Value | exit(Reason)

    Types
        ConnHandle = #megaco_conn_handle{}
        Item = conn_info_item()
        Value = conn_info_value()
        Reason = term()

    Lookup information about an active connection

    Requires that the connection is active.

        control_pid:
            The process identifier of the controlling process for a conenction.

        send_handle:
            Opaque send handle whose contents is internal for the send module. May be any term.

        receive_handle:
            Construct a megaco_receive_handle record.

        trans_id:
            Next trans id. A positive integer.

        max_trans_id:
            Last trans id. A positive integer or infinity, defaults to infinity.

        request_timer:
            Wait for reply. A Timer (see explanation below, defaults to #megaco_incr_timer{}.

        long_request_timer:
            Wait for reply after pending. A Timer (see explanation below, defaults to infinity.

        auto_ack:
            Automatic send transaction ack when the transaction reply has been received (see accu_ack_timer below). A boolean, defaults to false.

        accu_ack_timer:
            Accumulated ack's timeout time. Has two functions. First, if the value is 0, then ack's will not be accumulated. Second, if the value is greater then 0 and auto_ack is true, then ack's will be accumulated (instead of sent immediatly) and the value indicates the maximum length (see accu_ack_maxcount) of time ack's will be accumulated before sending them (in one message) (see also accu_ack_maxcount below).
            An integer, defaults to 0.

        accu_ack_maxcount:
            Maximum number of accumulated ack's. At most this many ack's will be accumulated.
            The accumulated ack's will be sent either when the accu_ack_timer expires or when accu_ack_maxcount number of ack's has been accumulated, whichever happens first. (see accu_ack_timer above). An integer, defaults to 10.

        pending_timer:
            Automatic send transaction pending if the timer expires before a transaction reply has been sent. This timer is also called provisional response timer. A Timer (see explanation below, defaults to 30000.

        reply_timer:
            Wait for an ack. A Timer (see explanation below, defaults to 30000.

        send_mod:
            Send callback module which exports send_message/2. The function SendMod:send_message(SendHandle, Binary) is invoked when the bytes needs to be transmitted to the remote user. An atom, defaults to megaco_tcp.

        encoding_mod:
            Encoding callback module which exports encode_message/2 and decode_message/2. The function EncodingMod:encode_message(EncodingConfig, MegacoMessage) is invoked whenever a 'MegacoMessage' record needs to be translated into an Erlang binary. The function EncodingMod:decode_message(EncodingConfig, Binary) is invoked whenever an Erlang binary needs to be translated into a 'MegacoMessage' record. An atom, defaults to megaco_pretty_text_encoder.

        encoding_config:
            Encoding module config. A list, defaults to [].

        protocol_version:
            Actual protocol version. Current default is 1.

        reply_data:
            Default reply data. Any term, defaults to the atom undefined.

    A Timer may be:

        infinity:
            Means that the timer never will time out

        Integer:
            Waits the given number of milli seconds before it times out.

        IncrTimer:
            A megaco_incr_timer record. Waits a given number of milli seconds, recalculates a new timer by multiplying a static factor and adding a static increment and starts all over again after retransmitting the message again. A maximum number of repetition can be stated.

update_conn_info(ConnHandle, Item, Value) -> ok | {error, Reason}

    Types
        ConnHandle = #megaco_conn_handle{}
        Item = conn_info_item()
        Value = conn_info_value()
        Reason = term()

    Update information about an active connection

    Requires that the connection is activated. See megaco:conn_info/2 about which items and values that are valid.

system_info(Item) -> Value | exit(Reason)

    Types
        Item = system_info_item()

    Lookup system information

    The following items are valid:

        text_config:
            The text encoding config.

        connections:
            Lists all active connections. Returns a list of megaco_conn_handle records.

        users:
            Lists all active users. Returns a list of megaco_mid()'s.

        n_active_requests:
            Returns an integer representing the number of requests that has originated from this Erlang node and still are active (and therefore consumes system resources).

        n_active_replies:
            Returns an integer representing the number of replies that has originated from this Erlang node and still are active (and therefore consumes system resources).

        n_active_connections:
            Returns an integer representing the number of active connections.

connect(ReceiveHandle, RemoteMid, SendHandle, ControlPid) -> {ok, ConnHandle} | {error, Reason}

    Types
        ReceiveHandle = #megaco_receive_handle{}
        RemoteMid = preliminary_mid | megaco_mid()
        SendHandle = term()
        ControlPid = pid()
        ConnHandle = #megaco_conn_handle{}
        Reason = term()

    Establish a "virtual" connection

    Activates a connection to a remote user. When this is done the connection can be used to send messages (with SendMod:send_message/2). The ControlPid is the identifier of a process that controls the connection. That process will be supervised and if it dies, this will be detected and the UserMod:handle_disconnect/2 callback function will be invoked. See the megaco_user module for more info about the callback arguments. The connection may also explicitly be deactivated by invoking megaco:disconnect/2.

    The ControlPid may be the identity of a process residing on another Erlang node. This is useful when you want to distribute a user over several Erlang nodes. In such a case one of the nodes has the physical connection. When a user residing on one of the other nodes needs to send a request (with megaco:call/3 or megaco:cast/3), the message will encoded on the originating Erlang node, and then be forwarded to the node with the physical connection. When the reply arrives, it will be forwarded back to the originator. The distributed connection may explicitely be deactivated by a local call to megaco:disconnect/2 or implicitely when the physical connection is deactivated (with megaco:disconnect/2, killing the controlling process, halting the other node, ...).

    The call of this function will trigger the callback function UserMod:handle_connect/2 to be invoked. See the megaco_user module for more info about the callback arguments.

    A connection may be established in several ways:

        provisioned MID:
            The MG may explicitely invoke megaco:connect/4 and use a provisioned MID of the MGC as the RemoteMid.

        upgrade preliminary MID:
            The MG may explicitely invoke megaco:connect/4 with the atom 'preliminary_mid' as a temporary MID of the MGC, send an intial message, the Service Change Request, to the MGC and then wait for an initial message, the Service Change Reply. When the reply arrives, the Megaco application will pick the MID of the MGC from the message header and automatically upgrade the connection to be a "normal" connection. By using this method of establishing the connection, the callback function UserMod:handle_connect/2 to be invoked twice. First with a ConnHandle with the remote_mid-field set to preliminary_mid, and then when the connection upgrade is done with the remote_mid-field set to the actual MID of the MGC.

        automatic:
            When the MGC receives its first message, the Service Change Request, the Megaco application will automatically establish the connection by using the MG MID found in the message header as remote mid.

        distributed:
            When a user (MG/MGC) is distributed over several nodes, it is required that the node hosting the connection already has activated the connection and that it is in the "normal" state. The RemoteMid must be a real Megaco MID and not a preliminary_mid.

    An initial megaco_receive_handle record may be obtained with megaco:user_info(UserMid, receive_handle)

    The send handle is provided by the preferred transport module, e.g. megaco_tcp, megaco_udp. Read the documentation about each transport module about the details.

disconnect(ConnHandle, DiscoReason) -> ok | {error, ErrReason}

    Types
        ConnHandle = conn_handle()
        DiscoReason = term()
        ErrReason = term()

    Tear down a "virtual" connection

    Causes the UserMod:handle_disconnect/2 callback function to be invoked. See the megaco_user module for more info about the callback arguments.

call(ConnHandle, Actions, Options) -> {ProtocolVersion, UserReply}

    Types
        ConnHandle = conn_handle()
        Actions = action_reqs() | [action_reqs()]
        action_reqs() = [#'ActionRequest'{}]
        Options = [send_option()]
        send_option() = {request_timer, timer()} | {long_request_timer, timer()} | {send_handle, term()}
        UserReply = user_reply() | [user_reply()]
        user_reply() = success() | failure()
        success() = {ok, [#'ActionReply'{}]}
        failure() = message_error() | other_error()
        message_error() = {error, error_descr()}
        other_error() = {error, term()}

    Sends one or more transaction request(s) and waits for the reply.

    When sending one transaction in a message, Action should be action_reqs() (UserReply will then be user_reply()). When sending several transactions in a message, Actions should be [action_reqs()] (UserReply will then be [user_reply()]). Each element of the list is part of one transaction.

    The function returns when the reply arrives, when the request timer eventually times out or when the outstanding requests are explicitly cancelled.

    The default values of the send options are obtained by megaco:conn_info(ConnHandle, Item). But the send options above, may explicitly be overridden.

    The ProtocolVersion version is the version actually encoded in the reply message.

    At success(), the UserReply contains a list of 'ActionReply' records possibly containing error indications.

    A message_error(), indicates that the remote user has replied with an explicit transactionError.

    An other_error(), indicates some other error such as timeout or {user_cancel, ReasonForCancel}.

cast(ConnHandle, Actions, Options) -> ok | {error, Reason}

    Types
        ConnHandle = conn_handle()
        Actions = action_reqs() | [action_reqs()]
        action_reqs() = [#'ActionRequest'{}]
        Options = [send_option()]
        send_option() = {request_timer, timer()} | {long_request_timer, timer()} | {send_handle, term()} | {reply_data, reply_data()}
        Reason = term()

    Sends one or more transaction request(s) but does NOT wait for a reply

    When sending one transaction in a message, Action should be action_reqs(). When sending several transactions in a message, Actions should be [action_reqs()]. Each element of the list is part of one transaction.

    The default values of the send options are obtained by megaco:conn_info(ConnHandle, Item). But the send options above, may explicitly be overridden.

    The ProtocolVersion version is the version actually encoded in the reply message.

    The callback function UserMod:handle_trans_reply/4 is invoked when the reply arrives, when the request timer eventually times out or when the outstanding requests are explicitly cancelled. See the megaco_user module for more info about the callback arguments.

    Given as UserData argument to UserMod:handle_trans_reply/4.

cancel(ConnHandle, CancelReason) -> ok | {error, ErrReason}

    Types
        ConnHandle = conn_handle()
        CancelReason = term()
        ErrReason = term()

    Cancel all outstanding messages for this connection

    This causes outstanding megaco:call/3 requests to return. The callback functions UserMod:handle_reply/4 and UserMod:handle_trans_ack/4 are also invoked where it applies. See the megaco_user module for more info about the callback arguments.

process_received_message(ReceiveHandle, ControlPid, SendHandle, BinMsg) -> ok

    Types
        ReceiveHandle = #megaco_receive_handle{}
        ControlPid = pid()
        SendHandle = term()
        BinMsg = binary()

    Process a received message

    This function is intended to be invoked by some transport modules when get an incoming message. Which transport that actually is used is up to the user to choose.

    The message is delivered as an Erlang binary and is decoded by the encoding module stated in the receive handle together with its encoding config (also in the receive handle). Depending of the outcome of the decoding various callback functions will be invoked. See megaco_user for more info about the callback arguments.

    Note that all processing is done in the context of the calling process. A transport module could call this function via one of the spawn functions (e.g. spawn_opt). See also receive_message/4.

    If the message cannot be decoded the following callback function will be invoked:

        *   UserMod:handle_syntax_error/3

    If the decoded message instead of transactions contains a message error, the following callback function will be invoked:

        *   UserMod:handle_message_error/3

    If the decoded message happens to be received before the connection is established, a new "virtual" connection is established. This is typically the case for the Media Gateway Controller (MGC) upon the first Service Change. When this occurs the following callback function will be invoked:

        *   UserMod:handle_connect/2

    For each transaction request in the decoded message the following callback function will be invoked:

        *   UserMod:handle_trans_request/3

    For each transaction reply in the decoded message the reply is returned to the user. Either the originating function megaco:call/3 will return. Or in case the originating function was megaco:case/3 the following callback function will be invoked:

        *   UserMod:handle_trans_reply/4

    When a transaction acknowledgement is received it is possible that user has decided not to bother about the acknowledgement. But in case the return value from UserMod:handle_trans_request/3 indicates that the acknowledgement is important the following callback function will be invoked:

        *   UserMod:handle_trans_ack/4

    See the megaco_user module for more info about the callback arguments.

receive_message(ReceiveHandle, ControlPid, SendHandle, BinMsg) -> ok

    Types
        ReceiveHandle = #megaco_receive_handle{}
        ControlPid = pid()
        SendHandle = term()
        BinMsg = binary()

    Process a received message

    This is a callback function intended to be invoked by some transport modules when get an incoming message. Which transport that actually is used is up to the user to choose.

    In principle, this function calls the process_received_message/4 function via a spawn to perform the actual processing.

    For further information see the process_received_message/4 function.

parse_digit_map(DigitMapBody) -> {ok, ParsedDigitMap} | {error, Reason}

    Types
        DigitMapBody = string()
        ParsedDigitMap = parsed_digit_map()
        parsed_digit_map() = term()
        Reason = term()

    Parses a digit map body

    Parses a digit map body, represented as a list of characters, into a list of state transitions suited to be evaluated by megaco:eval_digit_map/1,2.

eval_digit_map(DigitMap) -> {ok, Letters} | {error, Reason}
eval_digit_map(DigitMap, Timers) -> {ok, Letters} | {error, Reason}

    Types
        DigitMap = #'DigitMapValue'{} | parsed_digit_map()
        parsed_digit_map() = term()
        ParsedDigitMap = term()
        Timers = ignore() | reject()
        ignore() = ignore | {ignore, digit_map_value()}
        reject() = reject | {reject, digit_map_value()} | digit_map_value()
        Letters = [letter()]
        letter() = $0..$9 | $a .. $k
        Reason = term()

    Collect digit map letters according to the digit map

    When evaluating a digit map, a state machine waits for timeouts and letters reported by megaco:report_digit_event/2. The length of the various timeouts are defined in the digit_map_value() record.

    When a complete sequence of valid events has been received, the result is returned as a list of letters.

    There are two options for handling syntax errors (that is when an unexpected event is received when the digit map evaluator is expecting some other event). The unexpected events may either be ignored or rejected. The latter means that the evaluation is aborted and an error is returned.

report_digit_event(DigitMapEvalPid, Events) -> ok | {error, Reason}

    Types
        DigitMapEvalPid = pid()
        Events = Event | [Event]
        Event = letter() | pause() | cancel()
        letter() = $0..$9 | $a .. $k | $A .. $K
        pause() = one_second() | ten_seconds()
        one_second() = $s | $S
        ten_seconds() = $l | $L
        cancel () = $z | $Z | cancel
        Reason = term()

    Send one or more events to the event collector process

    Send one or more events to a process that is evaluating a digit map, that is a process that is executing megaco:eval_digit_map/1,2

test_digit_event(DigitMap, Events) -> {ok, Letters} | {error, Reason}

    Types
        DigitMap = #'DigitMapValue'{} | parsed_digit_map()
        parsed_digit_map() = term()
        ParsedDigitMap = term()
        Timers = ignore() | reject()
        ignore() = ignore | {ignore, digit_map_value()}
        reject() = reject | {reject, digit_map_value()} | digit_map_value()
        DigitMapEvalPid = pid()
        Events = Event | [Event]
        Event = letter() | pause() | cancel()
        letter() = $0..$9 | $a .. $k | $A .. $K
        pause() = one_second() | ten_seconds()
        one_second() = $s | $S
        ten_seconds() = $l | $L
        cancel () = $z | $Z | cancel
        Reason = term()

    Feed digit map collector with events and return the result

    This function starts the evaluation of a digit map with megaco:eval_digit_map/1 and sends a sequence of events to it megaco:report_digit_event/2 in order to simplify testing of digit maps.

enable_trace(Level, Destination) -> void()

    Types
        Level = max | min | 0 <= integer() <= 100
        Destination = File | Port | HandlerSpec
        File = string()
        Port = integer()
        HandleSpec = {HandlerFun, Data}
        HandleFun = fun() (two arguments)
        Data = term()

    This function is used to start megaco tracing at a given Level and direct result to the given Destination.

    It starts a tracer server and then sets the proper match spec (according to Level).

    See dbg for further information.

disable_trace() -> void()

    This function is used to stop megaco tracing.

set_trace(Level) -> void()

    Types
        Level = max | min | 0 <= integer() <= 100

    This function is used to change the megaco trace level.

    It is assumed that tracing has already been enabled (see enable_trace above).

get_stats() -> {ok, TotalStats} | {error, Reason}
get_stats(GlobalCounter) -> {ok, CounterStats} | {error, Reason}
get_stats(CallHandle) -> {ok, CallHandleStats} | {error, Reason}
get_stats(CallHandle, Counter) -> {ok, integer()} | {error, Reason}

    Types
        TotalStats = [total_stats()]
        total_stats() = {call_handle(), [stats()]} | {global_counter(), integer()}
        GlobalCounter = global_counter()
        GlobalCounterStats = integer()
        CallHandle = call_handle()
        CallHandleStats = [stats()]
        stats() = {counter(), integer()}
        Counter = counter()
        counter() = medGwyGatewayNumTimerRecovery | medGwyGatewayNumErrors
        global_counter() = medGwyGatewayNumErrors
        Reason = term()

    Retreive the (SNMP) statistic counters. The global counters handle events that cannot be attributed to a single connection (e.g. protocol errors that occur before the connection has been properly setup).

reset_stats() -> void()
reset_stats(SendHandle) -> void()

    Types
        SendHandle = send_handle()

    Reset all related (SNMP) statistics counters.

AUTHOR
Hakan Mattsson - support@erlang.ericsson.se