Search documentation of megaco

# View Source megaco_tcp (megaco v4.7.2.1)

Interface module to TPKT transport protocol for Megaco/H.248.

This module contains the public interface to the TPKT (TCP/IP) version transport protocol for Megaco/H.248.

# Summary

## Types

counter()

Defines the different counters handled by this transport.

handle()

An opaque data type representing a TPKT connection.

## Functions

block(Handle)

Stop receiving incoming messages on the socket.

close(Handle)

This function is used for closing an active TPKT connection.

connect(TransportRef, Opts)

This function is used to open a TPKT connection.

get_stats()

Get all counter values for all known connections.

get_stats(Handle)

Get all counter values for a given (connection) handle.

get_stats(Handle, Counter)

Get the value of a specific counter.

listen(TransportRef, Options)

This function is used for starting new TPKT listening socket for TCP/IP. The option list contains the socket definitions.

reset_stats()

Reset all counters for all connections.

reset_stats(Handle)

Reset all counters for the given connection.

send_message(Handle, Msg)

Sends a message on a TPKT connection.

socket(Handle)

This function is used to convert a socket `handle()` to a inet `socket()`.

start_transport()

This function is used for starting the TCP/IP transport service. Use exit(TransportRef, Reason) to stop the transport service.

unblock(Handle)

Starting to receive incoming messages from the socket again.

upgrade_receive_handle(ControlPid, NewRecvHandle)

Upgrade the receive handle of the control process (e.g. after having changed protocol version).

# Types

# counter()

    -type counter() ::
              medGwyGatewayNumInMessages | medGwyGatewayNumInOctets | medGwyGatewayNumOutMessages |
              medGwyGatewayNumOutOctets | medGwyGatewayNumErrors.

Defines the different counters handled by this transport.

# handle()

    -opaque handle()

An opaque data type representing a TPKT connection.

# Functions

# block(Handle)

    -spec block(Handle) -> ok when Handle :: handle().

Stop receiving incoming messages on the socket.

# close(Handle)

    -spec close(Handle) -> ok when Handle :: handle().

This function is used for closing an active TPKT connection.

# connect(TransportRef, Opts)

    -spec connect(TransportRef, Opts) -> {ok, Handle, ControlPid} | {error, Reason}
                     when
                         TransportRef :: pid() | RegName,
                         RegName :: atom(),
                         Opts :: [Option],
                         Option ::
                             {inet_backend, default | inet | socket} |
                             {host, Host} |
                             {port, PortNum} |
                             {options, list()} |
                             {receive_handle, term()} |
                             {module, atom()},
                         Host :: inet:socket_address() | inet:hostname(),
                         PortNum :: inet:port_number(),
                         Handle :: handle(),
                         ControlPid :: pid(),
                         Reason :: term().

This function is used to open a TPKT connection.

- `module` - This option makes it possible for the user to provide their own callback module. The `receive_message/4` or `process_received_message/4` functions of this module is called when a new message is received. Which one is called depends on the size of the message;

  - `small` - receive_message

  - `large` - process_received_message

  Default value is megaco.

- `inet_backend` - Choose the inet-backend.

  This option make it possible to use a different inet-backend ('default', 'inet' or 'socket').

  Default is `default` (system default).

# get_stats()

    -spec get_stats() -> {ok, TotalStats} | {error, Reason}
                       when
                           TotalStats :: [{Handle, [{Counter, integer()}]}],
                           Handle :: handle(),
                           Counter :: counter(),
                           Reason :: term().

Get all counter values for all known connections.

# get_stats(Handle)

    -spec get_stats(Handle) -> {ok, Stats} | {error, Reason}
                       when
                           Handle :: handle(),
                           Stats :: [{Counter, integer()}],
                           Counter :: counter(),
                           Reason :: term().

Get all counter values for a given (connection) handle.

# get_stats(Handle, Counter)

    -spec get_stats(Handle, Counter) -> {ok, integer()} | {error, Reason}
                       when Handle :: handle(), Counter :: counter(), Reason :: term().

Get the value of a specific counter.

# listen(TransportRef, Options)

    -spec listen(TransportRef, Options) -> ok
                    when
                        TransportRef :: pid() | RegName,
                        RegName :: atom(),
                        Options :: [Option],
                        Option ::
                            {inet_backend, default | inet | socket} |
                            {port, inet:port_number()} |
                            {options, list()} |
                            {receive_handle, term()}.

This function is used for starting new TPKT listening socket for TCP/IP. The option list contains the socket definitions.

- `inet_backend` - Choose the inet-backend.

  This option make it possible to use a different inet-backend ('default', 'inet' or 'socket').

  Default is `default` (system default).

# reset_stats()

    -spec reset_stats() -> megaco:void().

Reset all counters for all connections.

# reset_stats(Handle)

    -spec reset_stats(Handle) -> megaco:void() when Handle :: handle().

Reset all counters for the given connection.

# send_message(Handle, Msg)

    -spec send_message(Handle, Msg) -> ok when Handle :: handle(), Msg :: binary() | iolist().

Sends a message on a TPKT connection.

# socket(Handle)

    -spec socket(Handle) -> Socket when Handle :: handle(), Socket :: inet:socket().

This function is used to convert a socket `handle()` to a inet `socket()`.

# start_transport()

    -spec start_transport() -> {ok, TransportRef} when TransportRef :: pid().

This function is used for starting the TCP/IP transport service. Use exit(TransportRef, Reason) to stop the transport service.

# unblock(Handle)

    -spec unblock(Handle) -> ok when Handle :: handle().

Starting to receive incoming messages from the socket again.

# upgrade_receive_handle(ControlPid, NewRecvHandle)

    -spec upgrade_receive_handle(ControlPid, NewRecvHandle) -> ok
                                    when ControlPid :: pid(), NewRecvHandle :: term().

Upgrade the receive handle of the control process (e.g. after having changed protocol version).