megaco_transport(3erl) [linux man page]

megaco_transport(3erl)					     Erlang Module Definition					    megaco_transport(3erl)

NAME

       megaco_transport - Megaco transport behaviour.

DESCRIPTION

       The following functions should be exported from a megaco_transport callback module:

	 * send_message/2 [ mandatory ]

	 * send_message/3 [ optional ]

	 * resend_message/2 [ optional ]

	 *

EXPORTS

       Module:send_message(Handle, Msg) -> ok | {cancel, Reason} | Error
       Module:send_message(Handle, Msg, Resend) -> ok | {cancel, Reason} | Error

	      Types  Handle = term()
		     Msg = binary() | iolist()
		     Resend = boolean()
		     Reason = term()
		     Error = term()

	      Send a megaco message.

	      If the function returns {cancel, Reason} , this means the transport module decided not to send the message. This is not an error. No
	      error messages will be issued and no error counters incremented. What actions this will result in depends on what  kind  of  message
	      was sent.

	      In  the  case of requests, megaco will cancel the message in much the same way as if megaco:cancel had been called (after a success-
	      full send). The information will be propagated back to the user differently depending  on  how  the  request(s)  where  issued:  For
	      requests	issued	using megaco:call , the info will be delivered in the return value. For requests issued using megaco:cast the info
	      will be delivered via a call to the callback function handle_trans_reply .

	      In the case of reply, megaco will cancel the reply and information of this will be returned to the user via a call to  the  callback
	      function handle_trans_ack .

	      The  function  send_message/3  will only be called if the resend_indication config option has been set to the value flag . The third
	      argument, Resend then indicates if the message send is a resend or not.

       Module:resend_message(Handle, Msg) -> ok | {cancel, Reason} | Error

	      Types  Handle = term()
		     Msg = binary() | iolist()
		     Reason = term()
		     Error = term()

	      Re-send a megaco message.

	      Note that this function will only be called if the user has set the resend_indication config option to true and it is in fact a mes-
	      sage resend. If not both of these condition's are meet, send_message will be called.

	      If the function returns {cancel, Reason} , this means the transport module decided not to send the message. This is not an error. No
	      error messages will be issued and no error counters incremented. What actions this will result in depends on what  kind  of  message
	      was sent.

	      In  the  case of requests, megaco will cancel the message in much the same way as if megaco:cancel had been called (after a success-
	      full send). The information will be propagated back to the user differently depending  on  how  the  request(s)  where  issued:  For
	      requests	issued	using megaco:call , the info will be delivered in the return value. For requests issued using megaco:cast the info
	      will be delivered via a call to the callback function handle_trans_reply .

	      In the case of reply, megaco will cancel the reply and information of this will be returned to the user via a call to  the  callback
	      function handle_trans_ack .

Ericsson AB							   megaco 3.15.1					    megaco_transport(3erl)

megaco_tcp(3erl)					     Erlang Module Definition						  megaco_tcp(3erl)

NAME

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

DESCRIPTION

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

EXPORTS

       start_transport() -> {ok, TransportRef}

	      Types  TransportRef = pid()

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

       listen(TransportRef, ListenPortSpecList) -> ok

	      Types  TransportRef = pid() | regname()
		     OptionListPerPort = [Option]
		     Option = {port, integer()} |{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.

       connect(TransportRef, OptionList) -> {ok, Handle, ControlPid} | {error, Reason}

	      Types  TransportRef = pid() | regname()
		     OptionList = [Option]
		     Option = {host, Ipaddr} | {port, integer()} |{options, list()} |{receive_handle, term()} |{module, atom()}
		     Handle = socket_handle()
		     ControlPid = pid()
		     Reason = term()

	      This function is used to open a TPKT connection.

	      The   module   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 depends on the size  of  the
	      message; small - receive_message, large - process_received_message). Default value is megaco .

       close(Handle) -> ok

	      Types  Handle = socket_handle()

	      This function is used for closing an active TPKT connection.

       socket(Handle) -> Socket

	      Types  Handle = socket_handle()
		     Socket = inet_socket()

	      This function is used to convert a socket_handle() to a inet_socket(). inet_socket() is a plain socket, see the inet module for more
	      info.

       send_message(Handle, Message) -> ok

	      Types  Handle = socket_handle()
		     Message = binary() | iolist()

	      Sends a message on a connection.

       block(Handle) -> ok

	      Types  Handle = socket_handle()

	      Stop receiving incoming messages on the socket.

       unblock(Handle) -> ok

	      Types  Handle = socket_handle()

	      Starting to receive incoming messages from the socket again.

       upgrade_receive_handle(ControlPid) -> ok

	      Types  ControlPid = pid()

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

       get_stats() -> {ok, TotalStats} | {error, Reason}
       get_stats(SendHandle) -> {ok, SendHandleStats} | {error, Reason}
       get_stats(SendHandle, Counter) -> {ok, CounterStats} | {error, Reason}

	      Types  TotalStats = [send_handle_stats()]
		     total_stats() = {send_handle(), [stats()]}
		     SendHandle = send_handle()
		     SendHandleStats = [stats()]
		     Counter = tcp_stats_counter()
		     CounterStats = integer()
		     stats() = {tcp_stats_counter(), integer()}
		     tcp_stats_counter() = medGwyGatewayNumInMessages | medGwyGatewayNumInOctets | medGwyGatewayNumOutMessages |  medGwyGatewayNu-
		     mOutOctets | medGwyGatewayNumErrors
		     Reason = term()

	      Retreive the TCP related (SNMP) statistics counters.

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

	      Types  SendHandle = send_handle()

	      Reset all TCP related (SNMP) statistics counters.

Ericsson AB							   megaco 3.15.1						  megaco_tcp(3erl)