File: megaco.html

package info (click to toggle)
erlang-doc-html 1%3A11.b.2-1
links: PTS
area: main
in suites: etch, etch-m68k
size: 23,284 kB
ctags: 10,724
sloc: erlang: 505; ansic: 323; makefile: 62; perl: 61; sh: 45
file content (2306 lines) | stat: -rw-r--r-- 73,156 bytes
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<!-- This document was generated using DocBuilder 3.3.3 -->
<HTML>
<HEAD>
  <TITLE>megaco</TITLE>
  <SCRIPT type="text/javascript" src="../../../../doc/erlresolvelinks.js">
</SCRIPT>
  <STYLE TYPE="text/css">
<!--
    .REFBODY     { margin-left: 13mm }
    .REFTYPES    { margin-left: 8mm }
-->
  </STYLE>
</HEAD>
<BODY BGCOLOR="#FFFFFF" TEXT="#000000" LINK="#0000FF" VLINK="#FF00FF"
      ALINK="#FF0000">
<!-- refpage -->
<CENTER>
<A HREF="http://www.erlang.se">
  <IMG BORDER=0 ALT="[Ericsson AB]" SRC="min_head.gif">
</A>
<H1>megaco</H1>
</CENTER>

<H3>MODULE</H3>
<DIV CLASS=REFBODY>
megaco
</DIV>

<H3>MODULE SUMMARY</H3>
<DIV CLASS=REFBODY>
 Main API of the Megaco application

</DIV>

<H3>DESCRIPTION</H3>
<DIV CLASS=REFBODY>

<P> Interface module for the Megaco application

</DIV>

<H3>DATA TYPES</H3>
<DIV CLASS=REFBODY>

<PRE>
megaco_timer() = infinity | integer() | megaco_incr_timer()
megaco_incr_timer() = #megaco_incr_timer{}
    
</PRE>

<P>The record <CODE>megaco_incr_timer</CODE> contains the following fields: 
<P>
<DL>

<DT>
<CODE>wait_for = integer()</CODE>
</DT>

<DD>
 The actual timer time.<BR>


</DD>

<DT>
<CODE>factor = integer()</CODE>
</DT>

<DD>
 The factor when calculating the new timer time (wait_for).<BR>


</DD>

<DT>
<CODE>incr = integer()</CODE>
</DT>

<DD>
 The increment value when calculating the new timer time 
(wait_for).<BR>


</DD>

<DT>
<CODE>max_retries = infinity | infinity_restartable | integer()</CODE>
</DT>

<DD>
 The maximum number of repetitions of the timer.<BR>

There is a special case for this field. When the 
max_retries has the value <CODE>infinity_restartable</CODE>, it 
means that the timer is restartable as long as some 
external event occurs (e.g. receipt of a pending 
message for instance). But the timer will never be
restarted &#34;by itself&#34;, i.e. when the timer expires 
(whatever the timeout time), so does the timer. 
Whever the timer is restarted, the timeout time will 
be calculated in the usual way!<BR>


</DD>

</DL>

</DIV>

<H3>EXPORTS</H3>

<P><A NAME="start/0"><STRONG><CODE>start() -&#62; ok | {error, Reason}</CODE></STRONG></A><BR>

<DIV CLASS=REFBODY><P>Types:
  <DIV CLASS=REFTYPES>
<P>
<STRONG><CODE>Reason = term()</CODE></STRONG><BR>

  </DIV>
</DIV>

<DIV CLASS=REFBODY>

<P>Starts the Megaco application
<P>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.
</DIV>

<P><A NAME="stop/0"><STRONG><CODE>stop() -&#62; ok | {error, Reason}</CODE></STRONG></A><BR>
<A NAME="stop"><STRONG><CODE>stop</CODE></STRONG></A><BR>

<DIV CLASS=REFBODY><P>Types:
  <DIV CLASS=REFTYPES>
<P>
<STRONG><CODE>Reason = term()</CODE></STRONG><BR>

  </DIV>
</DIV>

<DIV CLASS=REFBODY>

<P>Stops the Megaco application
</DIV>

<P><A NAME="start_user/2"><STRONG><CODE>start_user(UserMid, Config) -&#62; ok | {error, Reason}</CODE></STRONG></A><BR>

<DIV CLASS=REFBODY><P>Types:
  <DIV CLASS=REFTYPES>
<P>
<STRONG><CODE>UserMid = megaco_mid()</CODE></STRONG><BR>
<STRONG><CODE>Config = [{user_info_item(), user_info_value()}]</CODE></STRONG><BR>
<STRONG><CODE>Reason = term()</CODE></STRONG><BR>

  </DIV>
</DIV>

<DIV CLASS=REFBODY>

<P>Initial configuration of a user
<P>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.
<P>A user is identified by its UserMid, which must be a legal
         Megaco MID.
<P>Config is a list of {Item, Value} tuples. See
         megaco:user_info/2 about which items and values that are valid.
</DIV>

<P><A NAME="stop_user/1"><STRONG><CODE>stop_user(UserMid) -&#62; ok | {error, Reason}</CODE></STRONG></A><BR>

<DIV CLASS=REFBODY><P>Types:
  <DIV CLASS=REFTYPES>
<P>
<STRONG><CODE>UserMid = megaco_mid()</CODE></STRONG><BR>
<STRONG><CODE>Reason = term()</CODE></STRONG><BR>

  </DIV>
</DIV>

<DIV CLASS=REFBODY>

<P>Delete the configuration of a user
<P>Requires that the user does not have any active connection.<A NAME="user_info"><!-- Empty --></A>
</DIV>

<P><A NAME="user_info/2"><STRONG><CODE>user_info(UserMid, Item) -&#62; Value | exit(Reason)</CODE></STRONG></A><BR>

<DIV CLASS=REFBODY><P>Types:
  <DIV CLASS=REFTYPES>
<P>
<STRONG><CODE>Handle = user_info_handle()</CODE></STRONG><BR>
<STRONG><CODE>UserMid = megaco_mid() </CODE></STRONG><BR>
<STRONG><CODE>Item = user_info_item()</CODE></STRONG><BR>
<STRONG><CODE>Value = user_info_value()</CODE></STRONG><BR>
<STRONG><CODE>Reason = term()</CODE></STRONG><BR>

  </DIV>
</DIV>

<DIV CLASS=REFBODY>

<P>Lookup user information
<P>The following Item's are valid:
<P>
<DL>

<DT>
<CODE>connections</CODE>
</DT>

<DD>
         Lists all active connections for this user. Returns a
         list of megaco_conn_handle records.<BR>

         
</DD>

<DT>
<CODE>receive_handle</CODE>
</DT>

<DD>
         Construct a megaco_receive_handle record from user config<BR>

         
</DD>

<DT>
<CODE>trans_id</CODE>
</DT>

<DD>
         Current transaction id. <BR>

A positive integer or the atom 
<CODE>undefined_serial</CODE> (in case no messages has been sent).<BR>

         
</DD>

<DT>
<CODE>min_trans_id</CODE>
</DT>

<DD>
         First trans id. <BR>

A positive integer, defaults to 1.<BR>

         
</DD>

<DT>
<CODE>max_trans_id</CODE>
</DT>

<DD>
         Last trans id. <BR>

A positive integer or <CODE>infinity</CODE>, 
defaults to <CODE>infinity</CODE>.<BR>

         
</DD>

<DT>
<CODE>request_timer</CODE>
</DT>

<DD>
         Wait for reply. <BR>

The timer is cancelled when a reply is received. <BR>

When a pending message is received, the timer is 
cancelled and the <CODE>long_request_timer</CODE> is started instead 
(see below). No resends will be performed from this point 
(since we now know that the other side has received the 
request). <BR>

When the timer reaches an intermediate expire, the request
is resent and the timer is restarted. <BR>

         When the timer reaches the final expire, either the function 
<CODE>megaco:call</CODE> will return with <CODE>{error, timeout}</CODE>
or the callback function <CODE>handle_trans_reply</CODE> will be 
called with <CODE>UserReply = {error, timeout}</CODE> (if 
<CODE>megaco:cast</CODE> was used).<BR>

A Megaco Timer (see explanation above), 
         defaults to <CODE>#megaco_incr_timer{}</CODE>.<BR>

         
</DD>

<DT>
<CODE>long_request_timer</CODE>
</DT>

<DD>
         Wait for reply after having received a pending message. <BR>

When the timer reaches an intermediate expire, the timer 
is restarted. <BR>

When a pending message is received, and the 
<CODE>long_request_timer</CODE> 
is <STRONG>not</STRONG> &#34;on it's final leg&#34;, the timer will be 
restarted, and, if <CODE>long_request_resend = true</CODE>, the
request will be re-sent. <BR>

A Megaco Timer (see explanation above), 
         defaults to <CODE>infinity</CODE>.<BR>

         
</DD>

<DT>
<CODE>long_request_resend</CODE>
</DT>

<DD>
         This option indicates weather the request should be 
resent until the reply is received,
<STRONG>even</STRONG> though a pending message has been received. <BR>

Normally, after a pending message has been received, 
the request is not resent 
(since a pending message is an indication that the
request has been received). But since the reply (to the 
request) can be
lost, this behaviour has it's values.<BR>

It is ofcourse pointless to set this value to <STRONG>true</STRONG>
unless the <CODE>long_request_timer</CODE> (see above) is also set
to an incremental timer (<CODE>#megaco_incr_timer{}</CODE>). <BR>

A <CODE>boolean</CODE>, 
         defaults to <CODE>false</CODE>.<BR>

         
</DD>

<DT>
<CODE>reply_timer</CODE>
</DT>

<DD>
         Wait for an ack. <BR>

When a request is received, some info
related to the reply is store internally (e.g. the
binary of the reply). This info will live until either
an ack is received or this timer expires. For instance,
if the same request is received again (e.g. a request
with the same transaction id), the (stored) reply will
be (re-) sent automatically by megaco.<BR>

         If the timer is of type <CODE>#megaco_incr_timer{}</CODE>, 
then for each intermediate timout, the reply will be resent
(this is valid until the ack is received or 
the timer expires). <BR>

A Megaco Timer (see explanation above), defaults to 30000.<BR>

         
</DD>

<DT>
<CODE>auto_ack</CODE>
</DT>

<DD>
         Automatic send transaction ack when the transaction
         reply has been received (see <CODE>trans_ack</CODE> below). <BR>

         This is used for <STRONG>three-way-handshake</STRONG>.<BR>

         A <CODE>boolean</CODE>, defaults to <CODE>false</CODE>.<BR>

         
</DD>

<DT>
<CODE>trans_ack</CODE>
</DT>

<DD>
         Shall ack's be accumulated or not. <BR>

         This property is only valid if <CODE>auto_ack</CODE> is true.<BR>

         If <CODE>auto_ack</CODE> is true, then if <CODE>trans_ack</CODE> is
         <CODE>false</CODE>, ack's will be sent immediatelly. 
If <CODE>trans_ack</CODE> is <CODE>true</CODE>, then 
ack's will instead be sent to the transaction 
         sender process for accumulation and later sending 
         (see <CODE>trans_ack_maxcount</CODE>, <CODE>trans_req_maxcount</CODE>, 
         <CODE>trans_req_maxsize</CODE>, <CODE>trans_ack_maxcount</CODE> and 
         <CODE>trans_timer</CODE>). <BR>

         See also <A HREF="megaco_run.html#transaction_sender"> transaction sender</A> for more info.<BR>

         An <CODE>boolean</CODE>, defaults to <CODE>false</CODE>.<BR>

         
</DD>

<DT>
<CODE>trans_ack_maxcount</CODE>
</DT>

<DD>
         Maximum number of accumulated ack's. At most this many ack's
         will be accumulated by the transaction sender (if started and 
         configured to accumulate ack's).<BR>

         See also <A HREF="megaco_run.html#transaction_sender">         transaction sender</A> for more info. <BR>

         An <CODE>integer</CODE>, defaults to 10.<BR>

         
</DD>

<DT>
<CODE>trans_req</CODE>
</DT>

<DD>
         Shall requests be accumulated or not. <BR>

         If <CODE>trans_req</CODE> is <CODE>false</CODE>, then request(s)
         will be sent immediatelly (in it's own message).<BR>

         If <CODE>trans_req</CODE> is true, then request(s) will 
         instead be sent to the transaction sender process for 
         accumulation and later sending 
         (see <CODE>trans_ack_maxcount</CODE>, <CODE>trans_req_maxcount</CODE>, 
         <CODE>trans_req_maxsize</CODE>, <CODE>trans_ack_maxcount</CODE> and 
         <CODE>trans_timer</CODE>). <BR>

         See also <A HREF="megaco_run.html#transaction_sender"> transaction sender</A> for more info. <BR>

         An <CODE>boolean</CODE>, defaults to <CODE>false</CODE>.<BR>

         
</DD>

<DT>
<CODE>trans_req_maxcount</CODE>
</DT>

<DD>
         Maximum number of accumulated requests. At most this many 
         requests will be accumulated by the transaction sender 
         (if started and configured to accumulate requests). <BR>

         See also <A HREF="megaco_run.html#transaction_sender"> transaction sender</A> for more info.<BR>

         An <CODE>integer</CODE>, defaults to 10.<BR>

         
</DD>

<DT>
<CODE>trans_req_maxsize</CODE>
</DT>

<DD>
         Maximum size of the accumulated requests. At most this much
         requests will be accumulated by the transaction sender 
         (if started and configured to accumulate requests).<BR>

         See also <A HREF="megaco_run.html#transaction_sender">         transaction sender</A> for more info.<BR>

         An <CODE>integer</CODE>, defaults to 2048.<BR>

         
</DD>

<DT>
<CODE>trans_timer</CODE>
</DT>

<DD>
         Transaction sender timeout time. Has two functions. First, if 
         the value is 0, then transactions will not be accumulated 
         (e.g. the transaction sender process will not be started). 
         Second, if the value is greater then 0 and <CODE>auto_ack</CODE> 
         and <CODE>trans_ack</CODE> is true or if <CODE>trans_req</CODE> is true, 
         then transaction sender will be started and transactions 
         (which is depending on the values of <CODE>auto_ack</CODE>, 
         <CODE>trans_ack</CODE> and <CODE>trans_req</CODE>) will be accumulated,
         for later sending. <BR>
 
         See also <A HREF="megaco_run.html#transaction_sender"> transaction sender</A> for more info. <BR>

An <CODE>integer</CODE>, defaults to 0.<BR>

         
</DD>

<DT>
<CODE>pending_timer</CODE>
</DT>

<DD>
         Automatically send pending if the timer expires before a
         transaction reply has been sent. This timer is also called 
         provisional response timer. <BR>

A Megaco Timer (see explanation above), defaults to 30000.<BR>

         
</DD>

<DT>
<CODE>sent_pending_limit</CODE>
</DT>

<DD>
         Sent pending limit (see the MGOriginatedPendingLimit
         and the MGCOriginatedPendingLimit of the megaco root package).
         This parameter specifies how many pending messages that can
         be sent (for a given received transaction request).
         When the limit is exceeded, the transaction is aborted
         (see <A HREF="megaco_user.html#request_abort">         handle_trans_request_abort</A>) and an error message 
         is sent to the other side. <BR>

         Note that this has no effect on the actual sending of
         pending transactions. This is either implicit (e.g. when 
         receiving a re-sent transaction request for a request which
         is beeing processed) or controlled by the pending_timer,
         see above. <BR>

         A positive integer or <CODE>infinity</CODE>, 
defaults to <CODE>infinity</CODE>.<BR>

         
</DD>

<DT>
<CODE>recv_pending_limit</CODE>
</DT>

<DD>
         Receive pending limit (see the MGOriginatedPendingLimit
         and the MGCOriginatedPendingLimit of the megaco root package).
         This parameter specifies how many pending messages that can
         be received (for a sent transaction request).
         When the limit is exceeded, the transaction is considered
         lost, and an error returned to the user (through the call-back
         function <STRONG>handle_trans_reply</STRONG>). <BR>

         A positive integer or <CODE>infinity</CODE>, 
defaults to <CODE>infinity</CODE>. <BR>

         
</DD>

<DT>
<CODE>send_mod</CODE>
</DT>

<DD>
         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. <BR>

An <CODE>atom</CODE>, defaults to <CODE>megaco_tcp</CODE>.<BR>

         
</DD>

<DT>
<CODE>encoding_mod</CODE>
</DT>

<DD>
         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. <BR>

An <CODE>atom</CODE>, defaults to <CODE>megaco_pretty_text_encoder</CODE>.<BR>

         
</DD>

<DT>
<CODE>encoding_config</CODE>
</DT>

<DD>
         Encoding module config. <BR>

A <CODE>list</CODE>, defaults to <CODE>[]</CODE>.<BR>

         
</DD>

<DT>
<CODE>protocol_version</CODE>
</DT>

<DD>
         Actual protocol version. <BR>

An <CODE>integer</CODE>, default is 1.<BR>

         
</DD>

<DT>
<CODE>strict_version</CODE>
</DT>

<DD>
         Strict version control, i.e. when a message is received,
verify that the version is that which was negotiated. <BR>

An <CODE>boolean</CODE>, default is true.<BR>

         
</DD>

<DT>
<CODE>reply_data</CODE>
</DT>

<DD>
         Default reply data. <BR>

Any term, defaults to the atom <CODE>undefined</CODE>.<BR>

         
</DD>

<DT>
<CODE>user_mod</CODE>
</DT>

<DD>
         Name of the user callback module. See the the reference
         manual for megaco_user for more info.<BR>

         
</DD>

<DT>
<CODE>user_args</CODE>
</DT>

<DD>
         List of extra arguments to the user callback
         functions. See the the reference manual for megaco_user
         for more info.<BR>

         
</DD>

<DT>
<CODE>threaded</CODE>
</DT>

<DD>
         If a received message contains several transaction requests, 
         this option indicates whether the requests should be handled
         sequencially in the same process (<CODE>false</CODE>), or if each 
         request should be handled by it's own process (<CODE>true</CODE>
         i.e. a separate process is spawned for each request). <BR>

         An <CODE>boolean</CODE>, defaults to <CODE>false</CODE>. <BR>

         
</DD>

</DL>
<A NAME="update_user_info"><!-- Empty --></A>
</DIV>

<P><A NAME="update_user_info/3"><STRONG><CODE>update_user_info(UserMid, Item, Value) -&#62; ok | {error, Reason}</CODE></STRONG></A><BR>

<DIV CLASS=REFBODY><P>Types:
  <DIV CLASS=REFTYPES>
<P>
<STRONG><CODE>UserMid = megaco_mid() </CODE></STRONG><BR>
<STRONG><CODE>Item = user_info_item()</CODE></STRONG><BR>
<STRONG><CODE>Value = user_info_value()</CODE></STRONG><BR>
<STRONG><CODE>Reason = term()</CODE></STRONG><BR>

  </DIV>
</DIV>

<DIV CLASS=REFBODY>

<P>Update information about a user
<P>Requires that the user is started. See megaco:user_info/2
         about which items and values that are valid.<A NAME="conn_info"><!-- Empty --></A>
</DIV>

<P><A NAME="conn_info/2"><STRONG><CODE>conn_info(ConnHandle, Item) -&#62; Value | exit(Reason)</CODE></STRONG></A><BR>

<DIV CLASS=REFBODY><P>Types:
  <DIV CLASS=REFTYPES>
<P>
<STRONG><CODE>ConnHandle = #megaco_conn_handle{}</CODE></STRONG><BR>
<STRONG><CODE>Item = conn_info_item()</CODE></STRONG><BR>
<STRONG><CODE>Value = conn_info_value()</CODE></STRONG><BR>
<STRONG><CODE>Reason = term()</CODE></STRONG><BR>

  </DIV>
</DIV>

<DIV CLASS=REFBODY>

<P>Lookup information about an active connection
<P>Requires that the connection is active.
<P>
<DL>

<DT>
<CODE>control_pid</CODE>
</DT>

<DD>
         The process identifier of the controlling process for a
         connenction.<BR>

         
</DD>

<DT>
<CODE>send_handle</CODE>
</DT>

<DD>
         Opaque send handle whose contents is internal for the
         send module. May be any term.<BR>

         
</DD>

<DT>
<CODE>local_mid</CODE>
</DT>

<DD>
         The local mid (of the connection, i.e. the own mid). 
<CODE>megaco_mid()</CODE>.<BR>

         
</DD>

<DT>
<CODE>remote_mid</CODE>
</DT>

<DD>
         The remote mid (of the connection). 
<CODE>megaco_mid()</CODE>.<BR>

         
</DD>

<DT>
<CODE>receive_handle</CODE>
</DT>

<DD>
         Construct a megaco_receive_handle record.<BR>

         
</DD>

<DT>
<CODE>trans_id</CODE>
</DT>

<DD>
         Next transaction id. A positive integer or the atom 
<CODE>undefined_serial</CODE> (only in case of error). <BR>

Note that transaction id's are (currently) maintained 
on a per user basis so there is no way to be sure that 
the value returned will actually be used for a transaction 
sent on this connection (in case a user has several 
connections, which is not at all unlikely). <BR>

         
</DD>

<DT>
<CODE>max_trans_id</CODE>
</DT>

<DD>
         Last trans id. <BR>

A positive integer or <CODE>infinity</CODE>, 
defaults to <CODE>infinity</CODE>.<BR>

         
</DD>

<DT>
<CODE>request_timer</CODE>
</DT>

<DD>
         Wait for reply. <BR>

The timer is cancelled when a reply is received. <BR>

When a pending message is received, the timer is 
cancelled and the <CODE>long_request_timer</CODE> is started instead 
(see below). No resends will be performed from this point 
(since we now know that the other side has received the 
request). <BR>

When the timer reaches an intermediate expire, the request
is resent and the timer is restarted. <BR>

         When the timer reaches the final expire, either the function 
<CODE>megaco:call</CODE> will return with <CODE>{error, timeout}</CODE>
or the callback function <CODE>handle_trans_reply</CODE> will be 
called with <CODE>UserReply = {error, timeout}</CODE> (if 
<CODE>megaco:cast</CODE> was used).<BR>

A Megaco Timer (see explanation above), 
         defaults to #megaco_incr_timer{}.<BR>

         
</DD>

<DT>
<CODE>long_request_timer</CODE>
</DT>

<DD>
         Wait for reply after having received a pending message. <BR>

When the timer reaches an intermediate expire, the timer 
restarted. <BR>

When a pending message is received, and the 
<CODE>long_request_timer</CODE> 
is <STRONG>not</STRONG> &#34;on it's final leg&#34;, the timer will be 
restarted, and, if <CODE>long_request_resend = true</CODE>, the
request will be re-sent. <BR>

A Megaco Timer (see explanation above), 
defaults to <CODE>infinity</CODE>.<BR>

         
</DD>

<DT>
<CODE>long_request_resend</CODE>
</DT>

<DD>
         This option indicates weather the request should be 
resent until the reply is received,
<STRONG>even</STRONG> though a pending message has been received. <BR>

Normally, after a pending message has been received, 
the request is not resent 
(since a pending message is an indication that the
request has been received). But since the reply (to the 
request) can be
lost, this behaviour has it's values.<BR>

It is ofcourse pointless to set this value to <STRONG>true</STRONG>
unless the <CODE>long_request_timer</CODE> (see above) is also set
to an incremental timer (<CODE>#megaco_incr_timer{}</CODE>). <BR>

A <CODE>boolean</CODE>, 
         defaults to <CODE>false</CODE>.<BR>

         
</DD>

<DT>
<CODE>reply_timer</CODE>
</DT>

<DD>
         Wait for an ack. <BR>

When a request is received, some info
related to the reply is store internally (e.g. the
binary of the reply). This info will live until either
an ack is received or this timer expires. For instance,
if the same request is received again (e.g. a request
with the same transaction id), the (stored) reply will
be (re-) sent automatically by megaco.<BR>

         If the timer is of type <CODE>#megaco_incr_timer{}</CODE>, 
then for each intermediate timout, the reply will be resent
(this is valid until the ack is received or 
the timer expires). <BR>

A Megaco Timer (see explanation above), defaults to 30000.<BR>

         
</DD>

<DT>
<CODE>auto_ack</CODE>
</DT>

<DD>
         Automatic send transaction ack when the transaction
         reply has been received (see <CODE>trans_ack</CODE> below). <BR>

         This is used for <STRONG>three-way-handshake</STRONG>. <BR>

         A <CODE>boolean</CODE>, defaults to <CODE>false</CODE>.<BR>

         
</DD>

<DT>
<CODE>trans_ack</CODE>
</DT>

<DD>
         Shall ack's be accumulated or not. <BR>

         This property is only valid if <CODE>auto_ack</CODE> is true. <BR>

         If <CODE>auto_ack</CODE> is true, then if <CODE>trans_ack</CODE> is
         <CODE>false</CODE>, ack's will be sent immediatelly. 
If <CODE>trans_ack</CODE> is
         <CODE>true</CODE>, then ack's will instead be sent to the transaction 
         sender process for accumulation and later sending 
         (see <CODE>trans_ack_maxcount</CODE>, <CODE>trans_req_maxcount</CODE>, 
         <CODE>trans_req_maxsize</CODE>, <CODE>trans_ack_maxcount</CODE> and 
         <CODE>trans_timer</CODE>). <BR>

         See also <A HREF="megaco_run.html#transaction_sender"> transaction sender</A> for more info. <BR>

         An <CODE>boolean</CODE>, defaults to <CODE>false</CODE>.<BR>

         
</DD>

<DT>
<CODE>trans_ack_maxcount</CODE>
</DT>

<DD>
         Maximum number of accumulated ack's. At most this many ack's
         will be accumulated by the transaction sender (if started and 
         configured to accumulate ack's).
         <BR>
See also <A HREF="megaco_run.html#transaction_sender">          transaction sender</A> for more info.
         <BR>
An integer, defaults to 10.<BR>

         
</DD>

<DT>
<CODE>trans_req</CODE>
</DT>

<DD>
         Shall requests be accumulated or not. <BR>

         If <CODE>trans_req</CODE> is <CODE>false</CODE>, then request(s)
         will be sent immediatelly (in it's own message). <BR>

         If <CODE>trans_req</CODE> is true, then request(s) will 
         instead be sent to the transaction sender process for 
         accumulation and later sending 
         (see <CODE>trans_ack_maxcount</CODE>, <CODE>trans_req_maxcount</CODE>, 
         <CODE>trans_req_maxsize</CODE>, <CODE>trans_ack_maxcount</CODE> and 
         <CODE>trans_timer</CODE>). <BR>

         See also <A HREF="megaco_run.html#transaction_sender"> transaction sender</A> for more info. <BR>

         An <CODE>boolean</CODE>, defaults to <CODE>false</CODE>.<BR>

         
</DD>

<DT>
<CODE>trans_req_maxcount</CODE>
</DT>

<DD>
         Maximum number of accumulated requests. At most this many 
         requests will be accumulated by the transaction sender 
         (if started and configured to accumulate requests). <BR>

         See also <A HREF="megaco_run.html#transaction_sender"> transaction sender</A> for more info. <BR>

         An <CODE>integer</CODE>, defaults to 10.<BR>

         
</DD>

<DT>
<CODE>trans_req_maxsize</CODE>
</DT>

<DD>
         Maximum size of the accumulated requests. At most this much
         requests will be accumulated by the transaction sender 
         (if started and configured to accumulate requests). <BR>

         See also <A HREF="megaco_run.html#transaction_sender"> transaction sender</A> for more info. <BR>

         An <CODE>integer</CODE>, defaults to 2048.<BR>

         
</DD>

<DT>
<CODE>trans_timer</CODE>
</DT>

<DD>
         Transaction sender timeout time. Has two functions. First, if 
         the value is 0, then transactions will not be accumulated 
         (e.g. the transaction sender process will not be started). 
         Second, if the value is greater then 0 and <CODE>auto_ack</CODE> 
         and <CODE>trans_ack</CODE> is true or if <CODE>trans_req</CODE> is true, 
         then transaction sender will be started and transactions 
         (which is depending on the values of <CODE>auto_ack</CODE>, 
         <CODE>trans_ack</CODE> and <CODE>trans_req</CODE>) will be accumulated,
         for later sending. <BR>

         See also <A HREF="megaco_run.html#transaction_sender"> transaction sender</A> for more info. <BR>

An <CODE>integer</CODE>, defaults to 0.<BR>

         
</DD>

<DT>
<CODE>pending_timer</CODE>
</DT>

<DD>
         Automatic send transaction pending if the timer expires
         before a transaction reply has been sent. This timer is
         also called provisional response timer. <BR>

A Megaco Timer (see explanation above), defaults to 30000.<BR>

         
</DD>

<DT>
<CODE>sent_pending_limit</CODE>
</DT>

<DD>
         Sent pending limit (see the MGOriginatedPendingLimit
         and the MGCOriginatedPendingLimit of the megaco root package).
         This parameter specifies how many pending messages that can
         be sent (for a given received transaction request).
         When the limit is exceeded, the transaction is aborted
         (see <A HREF="megaco_user.html#request_abort">         handle_trans_request_abort</A>) and an error message 
         is sent to the other side. <BR>

         Note that this has no effect on the actual sending of
         pending transactions. This is either implicit (e.g. when 
         receiving a re-sent transaction request for a request which
         is beeing processed) or controlled by the pending_timer,
         see above. <BR>

         A positive integer or <CODE>infinity</CODE>, 
         defaults to <CODE>infinity</CODE>.<BR>

         
</DD>

<DT>
<CODE>recv_pending_limit</CODE>
</DT>

<DD>
         Receive pending limit (see the MGOriginatedPendingLimit
         and the MGCOriginatedPendingLimit of the megaco root package).
         This parameter specifies how many pending messages that can
         be received (for a sent transaction request).
         When the limit is exceeded, the transaction is considered
         lost, and an error returned to the user (through the call-back
         function <STRONG>handle_trans_reply</STRONG>). <BR>

         A positive integer or <CODE>infinity</CODE>, 
         defaults to <CODE>infinity</CODE>.<BR>

         
</DD>

<DT>
<CODE>send_mod</CODE>
</DT>

<DD>
         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. <BR>

An <CODE>atom</CODE>, defaults to <CODE>megaco_tcp</CODE>.<BR>

         
</DD>

<DT>
<CODE>encoding_mod</CODE>
</DT>

<DD>
         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. <BR>

An <CODE>atom</CODE>, 
defaults to <CODE>megaco_pretty_text_encoder</CODE>.<BR>

         
</DD>

<DT>
<CODE>encoding_config</CODE>
</DT>

<DD>
         Encoding module config. <BR>

A <CODE>list</CODE>, defaults to [].<BR>

         
</DD>

<DT>
<CODE>protocol_version</CODE>
</DT>

<DD>
         Actual protocol version. <BR>

An positive integer, Current default is 1.<BR>

         
</DD>

<DT>
<CODE>strict_version</CODE>
</DT>

<DD>
         Strict version control, i.e. when a message is received,
verify that the version is that which was negotiated. <BR>

An <CODE>boolean</CODE>, default is true.<BR>

         
</DD>

<DT>
<CODE>reply_data</CODE>
</DT>

<DD>
         Default reply data. <BR>

Any term, defaults to the atom <CODE>undefined</CODE>.<BR>

         
</DD>

<DT>
<CODE>threaded</CODE>
</DT>

<DD>
         If a received message contains several transaction requests, 
         this option indicates whether the requests should be handled
         sequencially in the same process (<CODE>false</CODE>), or if each 
         request should be handled by it's own process (<CODE>true</CODE>
         i.e. a separate process is spawned for each request). <BR>

         An <CODE>boolean</CODE>, defaults to <CODE>false</CODE>. <BR>

         
</DD>

</DL>
<A NAME="update_conn_info"><!-- Empty --></A>
</DIV>

<P><A NAME="update_conn_info/3"><STRONG><CODE>update_conn_info(ConnHandle, Item, Value) -&#62; ok | {error, Reason}</CODE></STRONG></A><BR>

<DIV CLASS=REFBODY><P>Types:
  <DIV CLASS=REFTYPES>
<P>
<STRONG><CODE>ConnHandle = #megaco_conn_handle{}</CODE></STRONG><BR>
<STRONG><CODE>Item = conn_info_item()</CODE></STRONG><BR>
<STRONG><CODE>Value = conn_info_value()</CODE></STRONG><BR>
<STRONG><CODE>Reason = term()</CODE></STRONG><BR>

  </DIV>
</DIV>

<DIV CLASS=REFBODY>

<P>Update information about an active connection
<P>Requires that the connection is activated. See
         megaco:conn_info/2 about which items and values that are
         valid.<A NAME="system_info"><!-- Empty --></A>
</DIV>

<P><A NAME="system_info/1"><STRONG><CODE>system_info(Item) -&#62; Value | exit(Reason)</CODE></STRONG></A><BR>

<DIV CLASS=REFBODY><P>Types:
  <DIV CLASS=REFTYPES>
<P>
<STRONG><CODE>Item = system_info_item()</CODE></STRONG><BR>

  </DIV>
</DIV>

<DIV CLASS=REFBODY>

<P>Lookup system information
<P>The following items are valid:
<P>
<DL>

<DT>
<CODE>text_config</CODE>
</DT>

<DD>
         The text encoding config.<BR>

         
</DD>

<DT>
<CODE>connections</CODE>
</DT>

<DD>
         Lists all active connections. Returns a list of
         megaco_conn_handle records.<BR>

         
</DD>

<DT>
<CODE>users</CODE>
</DT>

<DD>
         Lists all active users. Returns a list of
         megaco_mid()'s.<BR>

         
</DD>

<DT>
<CODE>n_active_requests</CODE>
</DT>

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

         
</DD>

<DT>
<CODE>n_active_replies</CODE>
</DT>

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

         
</DD>

<DT>
<CODE>n_active_connections</CODE>
</DT>

<DD>
         Returns an integer representing the number of active
         connections.<BR>

         
</DD>

</DL>

</DIV>

<P><A NAME="connect/4"><STRONG><CODE>connect(ReceiveHandle, RemoteMid, SendHandle, ControlPid) -&#62; {ok, ConnHandle} | {error, Reason}</CODE></STRONG></A><BR>

<DIV CLASS=REFBODY><P>Types:
  <DIV CLASS=REFTYPES>
<P>
<STRONG><CODE>ReceiveHandle = #megaco_receive_handle{}</CODE></STRONG><BR>
<STRONG><CODE>RemoteMid = preliminary_mid | megaco_mid()</CODE></STRONG><BR>
<STRONG><CODE>SendHandle = term()</CODE></STRONG><BR>
<STRONG><CODE>ControlPid = pid()</CODE></STRONG><BR>
<STRONG><CODE>ConnHandle = #megaco_conn_handle{}</CODE></STRONG><BR>
<STRONG><CODE>Reason = term()</CODE></STRONG><BR>

  </DIV>
</DIV>

<DIV CLASS=REFBODY>

<P>Establish a &#34;virtual&#34; connection
<P>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.
<P>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, ...).
<P>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.
<P>A connection may be established in several ways:
<P>
<DL>

<DT>
<CODE>provisioned MID</CODE>
</DT>

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

         
</DD>

<DT>
<CODE>upgrade preliminary MID</CODE>
</DT>

<DD>
         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 &#34;normal&#34; 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.<BR>

         
</DD>

<DT>
<CODE>automatic</CODE>
</DT>

<DD>
         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.<BR>

         
</DD>

<DT>
<CODE>distributed</CODE>
</DT>

<DD>
         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 &#34;normal&#34; state. The RemoteMid must be a real
         Megaco MID and not a preliminary_mid.<BR>

         
</DD>

</DL>

<P>An initial megaco_receive_handle record may be obtained
        with megaco:user_info(UserMid, receive_handle)
<P>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.
</DIV>

<P><A NAME="disconnect/2"><STRONG><CODE>disconnect(ConnHandle, DiscoReason) -&#62; ok | {error, ErrReason}</CODE></STRONG></A><BR>

<DIV CLASS=REFBODY><P>Types:
  <DIV CLASS=REFTYPES>
<P>
<STRONG><CODE>ConnHandle = conn_handle()</CODE></STRONG><BR>
<STRONG><CODE>DiscoReason = term()</CODE></STRONG><BR>
<STRONG><CODE>ErrReason = term()</CODE></STRONG><BR>

  </DIV>
</DIV>

<DIV CLASS=REFBODY>

<P>Tear down a &#34;virtual&#34; connection
<P>Causes the UserMod:handle_disconnect/2 callback function to
         be invoked. See the megaco_user module for more info about
         the callback arguments.<A NAME="call"><!-- Empty --></A>
</DIV>

<P><A NAME="call/3"><STRONG><CODE>call(ConnHandle, Actions, Options) -&#62; {ProtocolVersion, UserReply}</CODE></STRONG></A><BR>

<DIV CLASS=REFBODY><P>Types:
  <DIV CLASS=REFTYPES>
<P>
<STRONG><CODE>ConnHandle = conn_handle()</CODE></STRONG><BR>
<STRONG><CODE>Actions = action_reqs() | [action_reqs()]</CODE></STRONG><BR>
<STRONG><CODE>action_reqs() = binary() | [#'ActionRequest'{}]</CODE></STRONG><BR>
<STRONG><CODE>Options = [send_option()]</CODE></STRONG><BR>
<STRONG><CODE>send_option() = {request_timer, megaco_timer()} | {long_request_timer, megaco_timer()} | {send_handle, term()} | {protocol_version, integer()}</CODE></STRONG><BR>
<STRONG><CODE>ProtocolVersion = integer()</CODE></STRONG><BR>
<STRONG><CODE>UserReply = user_reply() | [user_reply()]</CODE></STRONG><BR>
<STRONG><CODE>user_reply() = success() | failure()</CODE></STRONG><BR>
<STRONG><CODE>success() = {ok, [#'ActionReply'{}]}</CODE></STRONG><BR>
<STRONG><CODE>failure() = message_error() | user_cancel_error() | send_error() | other_error()</CODE></STRONG><BR>
<STRONG><CODE>message_error() = {error, error_descr()}</CODE></STRONG><BR>
<STRONG><CODE>user_cancel_error() = {error, user_cancel_reason()}</CODE></STRONG><BR>
<STRONG><CODE>user_cancel_reason() = {user_cancel, reason_for_user_cancel()}</CODE></STRONG><BR>
<STRONG><CODE>reason_for_user_cancel() = term()</CODE></STRONG><BR>
<STRONG><CODE>send_error() = {error, send_reason()}</CODE></STRONG><BR>
<STRONG><CODE>send_reason() = send_cancelled_reason() | send_failed_reason()</CODE></STRONG><BR>
<STRONG><CODE>send_cancelled_reason() = {send_message_cancelled, reason_for_send_cancel()}</CODE></STRONG><BR>
<STRONG><CODE>reason_for_send_cancel() = term()</CODE></STRONG><BR>
<STRONG><CODE>send_failed_reason() = {send_message_failed, reason_for_send_failure()}</CODE></STRONG><BR>
<STRONG><CODE>reason_for_send_failure() = term()</CODE></STRONG><BR>
<STRONG><CODE>other_error() = {error, term()}</CODE></STRONG><BR>

  </DIV>
</DIV>

<DIV CLASS=REFBODY>

<P>Sends one or more transaction request(s) and waits for the 
         reply.
<P>When sending one transaction in a message, <CODE>Actions</CODE> should be 
         <CODE>action_reqs()</CODE> (<CODE>UserReply</CODE> will then be 
         <CODE>user_reply()</CODE>). When sending several transactions in a message,
         <CODE>Actions</CODE> should be <CODE>[action_reqs()]</CODE> (<CODE>UserReply</CODE> 
         will then be <CODE>[user_reply()]</CODE>). Each element of the list is 
         part of one transaction.
<P>For some of <STRONG>our</STRONG> codecs (not binary), it is also possible 
         to pre-encode the actions, in which case <CODE>Actions</CODE> will be 
         either a <CODE>binary()</CODE> or <CODE>[binary()]</CODE>.
<P>The function returns when the reply arrives, when the
         request timer eventually times out or when the outstanding
         requests are explicitly cancelled.
<P>The default values of the send options are obtained by
         <CODE>megaco:conn_info(ConnHandle, Item)</CODE>. But the send options 
above, may explicitly be overridden.
<P>The <CODE>ProtocolVersion</CODE> version is the version actually encoded
         in the reply message.
<P>At <CODE>success()</CODE>, the <CODE>UserReply</CODE> contains a list of 
'ActionReply' records possibly containing error indications.
<P>A <CODE>message_error()</CODE>, indicates that the remote user has
         replied with an explicit transactionError.
<P>A <CODE>user_cancel_error()</CODE>, indicates that the request has been
canceled by the user. <CODE>reason_for_user_cancel()</CODE> is the reason
given in the call to the <A HREF="#cancel">cancel</A>
function. 
<P>A <CODE>send_error()</CODE>, indicates that the send function of the 
megaco transport callback module failed to send the request. 
There are two separate cases: <CODE>send_cancelled_reason()</CODE> and 
<CODE>send_failed_reason()</CODE>. 
The first is the result of the send function returning 
<CODE>{cancel, Reason}</CODE> and the second is some other kind of 
erroneous return value. See the 
<A HREF="megaco_transport.html#send_message">send_message</A>
function for more info. 
<P>An <CODE>other_error()</CODE>, indicates some other error such as 
timeout.<A NAME="cast"><!-- Empty --></A>
</DIV>

<P><A NAME="cast/3"><STRONG><CODE>cast(ConnHandle, Actions, Options) -&#62; ok | {error, Reason}</CODE></STRONG></A><BR>

<DIV CLASS=REFBODY><P>Types:
  <DIV CLASS=REFTYPES>
<P>
<STRONG><CODE>ConnHandle = conn_handle()</CODE></STRONG><BR>
<STRONG><CODE>Actions = action_reqs() | [action_reqs()]</CODE></STRONG><BR>
<STRONG><CODE>action_reqs() = binary() | [#'ActionRequest'{}]</CODE></STRONG><BR>
<STRONG><CODE>Options = [send_option()]</CODE></STRONG><BR>
<STRONG><CODE>send_option() = {request_timer, megaco_timer()} | {long_request_timer, megaco_timer()} | {send_handle, term()} | {reply_data, reply_data()} | {protocol_version, integer()}</CODE></STRONG><BR>
<STRONG><CODE>Reason = term()</CODE></STRONG><BR>

  </DIV>
</DIV>

<DIV CLASS=REFBODY>

<P>Sends one or more transaction request(s) but does NOT wait for a reply
<P>When sending one transaction in a message, <CODE>Action</CODE> should be 
         <CODE>action_reqs()</CODE>. When sending several transactions in a message,
         <CODE>Actions</CODE> should be <CODE>[action_reqs()]</CODE>. Each element of the 
         list is part of one transaction.
<P>For some of <STRONG>our</STRONG> codecs (not binary), it is also possible 
         to pre-encode the actions, in which case <CODE>Actions</CODE> will be 
         either a <CODE>binary()</CODE> or <CODE>[binary()]</CODE>.
<P>The default values of the send options are obtained by
         megaco:conn_info(ConnHandle, Item). But the send options above,
         may explicitly be overridden.
<P>The ProtocolVersion version is the version actually encoded
         in the reply message.
<P>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.
<P> Given as UserData argument to UserMod:handle_trans_reply/4.<A NAME="encode_actions"><!-- Empty --></A>
</DIV>

<P><A NAME="encode_actions/3"><STRONG><CODE>encode_actions(ConnHandle, Actions, Options) -&#62; {ok, BinOrBins} | {error, Reason}</CODE></STRONG></A><BR>

<DIV CLASS=REFBODY><P>Types:
  <DIV CLASS=REFTYPES>
<P>
<STRONG><CODE>ConnHandle = conn_handle()</CODE></STRONG><BR>
<STRONG><CODE>Actions = action_reqs() | [action_reqs()]</CODE></STRONG><BR>
<STRONG><CODE>action_reqs() = [#'ActionRequest'{}]</CODE></STRONG><BR>
<STRONG><CODE>Options = [send_option()]</CODE></STRONG><BR>
<STRONG><CODE>send_option() = {request_timer, megaco_timer()} | {long_request_timer, megaco_timer()} | {send_handle, term()} | {protocol_version, integer()}</CODE></STRONG><BR>
<STRONG><CODE>BinOrBins = binary() | [binary()]</CODE></STRONG><BR>
<STRONG><CODE>Reason = term()</CODE></STRONG><BR>

  </DIV>
</DIV>

<DIV CLASS=REFBODY>

<P>Encodes lists of action requests for one or more transaction 
         request(s).
<P>When encoding action requests for one transaction, 
         <CODE>Actions</CODE> should be <CODE>action_reqs()</CODE>. 
         When encoding action requests for several transactions,
         <CODE>Actions</CODE> should be <CODE>[action_reqs()]</CODE>. Each element 
         of the list is part of one transaction.<A NAME="token_tag2string"><!-- Empty --></A>
</DIV>

<P><A NAME="token_tag2string/1"><STRONG><CODE>token_tag2string(Tag) -&#62; Result</CODE></STRONG></A><BR>
<A NAME="token_tag2string/2"><STRONG><CODE>token_tag2string(Tag, EncoderMod) -&#62; Result</CODE></STRONG></A><BR>
<A NAME="token_tag2string/3"><STRONG><CODE>token_tag2string(Tag, EncoderMod, Version) -&#62; Result</CODE></STRONG></A><BR>

<DIV CLASS=REFBODY><P>Types:
  <DIV CLASS=REFTYPES>
<P>
<STRONG><CODE>Tag = atom()</CODE></STRONG><BR>
<STRONG><CODE>EncoderMod = pretty | compact | encoder_module()</CODE></STRONG><BR>
<STRONG><CODE>encoder_module() = megaco_pretty_text_encoder | megaco_compact_text_encoder | atom()</CODE></STRONG><BR>
<STRONG><CODE>Version = int_version() | atom_version()</CODE></STRONG><BR>
<STRONG><CODE>int_version() = 1 | 2 | 3</CODE></STRONG><BR>
<STRONG><CODE>atom_version() = v1 | v2 | v3 | prev3b</CODE></STRONG><BR>
<STRONG><CODE>Result = string() | {error, Reason}</CODE></STRONG><BR>
<STRONG><CODE>Reason = term()</CODE></STRONG><BR>

  </DIV>
</DIV>

<DIV CLASS=REFBODY>

<P>Convert a token tag to a string
<P>If no encoder module is given, the default is used 
(which is pretty).
<P>If no or an unknown version is given, 
the <STRONG>best</STRONG> version is used (which is prev3b).
<P>If no match is found for <CODE>Tag</CODE>, <CODE>Result</CODE> will be the 
empty string (<CODE>[]</CODE>).<A NAME="cancel"><!-- Empty --></A>
</DIV>

<P><A NAME="cancel/2"><STRONG><CODE>cancel(ConnHandle, CancelReason) -&#62; ok | {error, ErrReason}</CODE></STRONG></A><BR>

<DIV CLASS=REFBODY><P>Types:
  <DIV CLASS=REFTYPES>
<P>
<STRONG><CODE>ConnHandle = conn_handle()</CODE></STRONG><BR>
<STRONG><CODE>CancelReason = term()</CODE></STRONG><BR>
<STRONG><CODE>ErrReason = term()</CODE></STRONG><BR>

  </DIV>
</DIV>

<DIV CLASS=REFBODY>

<P>Cancel all outstanding messages for this connection
<P>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.<A NAME="process_received_message"><!-- Empty --></A>
</DIV>

<P><A NAME="process_received_message/4"><STRONG><CODE>process_received_message(ReceiveHandle, ControlPid, SendHandle, BinMsg) -&#62; ok</CODE></STRONG></A><BR>

<DIV CLASS=REFBODY><P>Types:
  <DIV CLASS=REFTYPES>
<P>
<STRONG><CODE>ReceiveHandle = #megaco_receive_handle{}</CODE></STRONG><BR>
<STRONG><CODE>ControlPid = pid()</CODE></STRONG><BR>
<STRONG><CODE>SendHandle = term()</CODE></STRONG><BR>
<STRONG><CODE>BinMsg = binary()</CODE></STRONG><BR>

  </DIV>
</DIV>

<DIV CLASS=REFBODY>

<P>Process a received message
<P>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.
<P>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.
<P>Note that all processing is done in the context of the calling 
         process. A transport module could call this function via one of the
         <CODE>spawn</CODE> functions (e.g. <CODE>spawn_opt</CODE>). See also 
         <CODE>receive_message/4</CODE>.

        
<P>If the message cannot be decoded the following callback
         function will be invoked:
<P>
<UL>

<LI>
UserMod:handle_syntax_error/3<BR>

</LI>


</UL>

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

<LI>
UserMod:handle_message_error/3<BR>

</LI>


</UL>

<P>If the decoded message happens to be received before the
         connection is established, a new &#34;virtual&#34; 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:
<P>
<UL>

<LI>
UserMod:handle_connect/2<BR>

</LI>


</UL>

<P>For each transaction request in the decoded message the
         following callback function will be invoked:
<P>
<UL>

<LI>
UserMod:handle_trans_request/3<BR>

</LI>


</UL>

<P>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:
<P>
<UL>

<LI>
UserMod:handle_trans_reply/4<BR>

</LI>


</UL>

<P>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:
<P>
<UL>

<LI>
UserMod:handle_trans_ack/4<BR>

</LI>


</UL>

<P>See the megaco_user module for more info about the callback
         arguments.
</DIV>

<P><A NAME="receive_message/4"><STRONG><CODE>receive_message(ReceiveHandle, ControlPid, SendHandle, BinMsg) -&#62; ok</CODE></STRONG></A><BR>

<DIV CLASS=REFBODY><P>Types:
  <DIV CLASS=REFTYPES>
<P>
<STRONG><CODE>ReceiveHandle = #megaco_receive_handle{}</CODE></STRONG><BR>
<STRONG><CODE>ControlPid = pid()</CODE></STRONG><BR>
<STRONG><CODE>SendHandle = term()</CODE></STRONG><BR>
<STRONG><CODE>BinMsg = binary()</CODE></STRONG><BR>

  </DIV>
</DIV>

<DIV CLASS=REFBODY>

<P>Process a received message
<P>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.
<P>In principle, this function calls the 
         <CODE>process_received_message/4</CODE> function via a <CODE>spawn</CODE> to
         perform the actual processing.
<P>For further information see the <CODE>process_received_message/4</CODE> 
         function.
</DIV>

<P><A NAME="parse_digit_map/1"><STRONG><CODE>parse_digit_map(DigitMapBody) -&#62; {ok, ParsedDigitMap} | {error, Reason}</CODE></STRONG></A><BR>

<DIV CLASS=REFBODY><P>Types:
  <DIV CLASS=REFTYPES>
<P>
<STRONG><CODE>DigitMapBody = string()</CODE></STRONG><BR>
<STRONG><CODE>ParsedDigitMap = parsed_digit_map()</CODE></STRONG><BR>
<STRONG><CODE>parsed_digit_map() = term()</CODE></STRONG><BR>
<STRONG><CODE>Reason = term()</CODE></STRONG><BR>

  </DIV>
</DIV>

<DIV CLASS=REFBODY>

<P>Parses a digit map body
<P>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.<A NAME="eval_digit_map"><!-- Empty --></A>
</DIV>

<P><A NAME="eval_digit_map/1"><STRONG><CODE>eval_digit_map(DigitMap) -&#62; {ok, MatchResult} | {error, Reason}</CODE></STRONG></A><BR>
<A NAME="eval_digit_map/2"><STRONG><CODE>eval_digit_map(DigitMap, Timers) -&#62; {ok, MatchResult} | {error, Reason}</CODE></STRONG></A><BR>

<DIV CLASS=REFBODY><P>Types:
  <DIV CLASS=REFTYPES>
<P>
<STRONG><CODE>DigitMap = #'DigitMapValue'{} | parsed_digit_map()</CODE></STRONG><BR>
<STRONG><CODE>parsed_digit_map() = term()</CODE></STRONG><BR>
<STRONG><CODE>ParsedDigitMap = term()</CODE></STRONG><BR>
<STRONG><CODE>Timers = ignore() | reject()</CODE></STRONG><BR>
<STRONG><CODE>ignore() = ignore | {ignore, digit_map_value()}</CODE></STRONG><BR>
<STRONG><CODE>reject() = reject | {reject, digit_map_value()} | digit_map_value()</CODE></STRONG><BR>
<STRONG><CODE>MatchResult = {Kind, Letters} | {Kind, Letters, Extra}</CODE></STRONG><BR>
<STRONG><CODE>Kind = kind()</CODE></STRONG><BR>
<STRONG><CODE>kind() = full | unambiguous</CODE></STRONG><BR>
<STRONG><CODE>Letters = [letter()]</CODE></STRONG><BR>
<STRONG><CODE>letter() = $0..$9 | $a .. $k</CODE></STRONG><BR>
<STRONG><CODE>Extra = letter()</CODE></STRONG><BR>
<STRONG><CODE>Reason = term()</CODE></STRONG><BR>

  </DIV>
</DIV>

<DIV CLASS=REFBODY>

<P>Collect digit map letters according to the digit map.
<P>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.
<P>When a complete sequence of valid events has been received,
         the result is returned as a list of letters.
<P>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.

        <A NAME="report_digit_event"><!-- Empty --></A> 

</DIV>

<P><A NAME="report_digit_event/2"><STRONG><CODE>report_digit_event(DigitMapEvalPid, Events) -&#62; ok | {error, Reason}</CODE></STRONG></A><BR>

<DIV CLASS=REFBODY><P>Types:
  <DIV CLASS=REFTYPES>
<P>
<STRONG><CODE>DigitMapEvalPid = pid()</CODE></STRONG><BR>
<STRONG><CODE>Events = Event | [Event]</CODE></STRONG><BR>
<STRONG><CODE>Event = letter() | pause() | cancel()</CODE></STRONG><BR>
<STRONG><CODE>letter() = $0..$9 | $a .. $k | $A .. $K</CODE></STRONG><BR>
<STRONG><CODE>pause() = one_second() | ten_seconds()</CODE></STRONG><BR>
<STRONG><CODE>one_second() = $s | $S</CODE></STRONG><BR>
<STRONG><CODE>ten_seconds() = $l | $L</CODE></STRONG><BR>
<STRONG><CODE>cancel() = $z | $Z | cancel</CODE></STRONG><BR>
<STRONG><CODE>Reason = term()</CODE></STRONG><BR>

  </DIV>
</DIV>

<DIV CLASS=REFBODY>

<P>Send one or more events to the event collector process.
<P>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.
<P>Note that the events <CODE>$s | $S</CODE>, <CODE>l | $L</CODE> and
<CODE>$z | $Z</CODE> has nothing to do with the timers using
the same characters.<A NAME="test_digit_event"><!-- Empty --></A>
</DIV>

<P><A NAME="test_digit_event/2"><STRONG><CODE>test_digit_event(DigitMap, Events) -&#62; {ok, Kind, Letters} | {error, Reason}</CODE></STRONG></A><BR>

<DIV CLASS=REFBODY><P>Types:
  <DIV CLASS=REFTYPES>
<P>
<STRONG><CODE>DigitMap = #'DigitMapValue'{} | parsed_digit_map()</CODE></STRONG><BR>
<STRONG><CODE>parsed_digit_map() = term()</CODE></STRONG><BR>
<STRONG><CODE>ParsedDigitMap = term()</CODE></STRONG><BR>
<STRONG><CODE>Timers = ignore() | reject()</CODE></STRONG><BR>
<STRONG><CODE>ignore() = ignore | {ignore, digit_map_value()}</CODE></STRONG><BR>
<STRONG><CODE>reject() = reject | {reject, digit_map_value()} | digit_map_value()</CODE></STRONG><BR>
<STRONG><CODE>DigitMapEvalPid = pid()</CODE></STRONG><BR>
<STRONG><CODE>Events = Event | [Event]</CODE></STRONG><BR>
<STRONG><CODE>Event = letter() | pause() | cancel()</CODE></STRONG><BR>
<STRONG><CODE>Kind = kind()</CODE></STRONG><BR>
<STRONG><CODE>kind() = full | unambiguous</CODE></STRONG><BR>
<STRONG><CODE>Letters = [letter()]</CODE></STRONG><BR>
<STRONG><CODE>letter() = $0..$9 | $a .. $k | $A .. $K</CODE></STRONG><BR>
<STRONG><CODE>pause() = one_second() | ten_seconds()</CODE></STRONG><BR>
<STRONG><CODE>one_second() = $s | $S</CODE></STRONG><BR>
<STRONG><CODE>ten_seconds() = $l | $L</CODE></STRONG><BR>
<STRONG><CODE>cancel () = $z | $Z | cancel</CODE></STRONG><BR>
<STRONG><CODE>Reason = term()</CODE></STRONG><BR>

  </DIV>
</DIV>

<DIV CLASS=REFBODY>

<P>Feed digit map collector with events and return the result
<P>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.<A NAME="encode_sdp"><!-- Empty --></A>
</DIV>

<P><A NAME="encode_sdp/1"><STRONG><CODE>encode_sdp(SDP) -&#62; {ok, PP} | {error, Reason}</CODE></STRONG></A><BR>

<DIV CLASS=REFBODY><P>Types:
  <DIV CLASS=REFTYPES>
<P>
<STRONG><CODE>SDP = sdp_property_parm() | sdp_property_group() | sdp_property_groups() | asn1_NOVALUE</CODE></STRONG><BR>
<STRONG><CODE>sdp_property_parm() = sdp() | property_parm()</CODE></STRONG><BR>
<STRONG><CODE>sdp() = sdp_c() | sdp_o() | sdp_s() | sdo_i() | sdo_u() | sdo_e() | sdo_p() | sdo_c() | sdo_b() | sdo_z() | sdo_k() | sdo_a() | sdo_a_rtpmap() | sdo_a_ptime() | sdo_t() | sdo_r() | sdo_m()</CODE></STRONG><BR>
<STRONG><CODE>sdp_v() = #megaco_sdp_v{} (Protocol version)</CODE></STRONG><BR>
<STRONG><CODE>sdp_o() = #megaco_sdp_o{} (Owner/creator and session indentifier)</CODE></STRONG><BR>
<STRONG><CODE>sdp_s() = #megaco_sdp_s{} (Session name)</CODE></STRONG><BR>
<STRONG><CODE>sdp_i() = #megaco_sdp_i{} (Session information)</CODE></STRONG><BR>
<STRONG><CODE>sdp_u() = #megaco_sdp_u{} (URI of description)</CODE></STRONG><BR>
<STRONG><CODE>sdp_e() = #megaco_sdp_e{} (Email address)</CODE></STRONG><BR>
<STRONG><CODE>sdp_p() = #megaco_sdp_p{} (Phone number)</CODE></STRONG><BR>
<STRONG><CODE>sdp_c() = #megaco_sdp_c{} (Connection information)</CODE></STRONG><BR>
<STRONG><CODE>sdp_b() = #megaco_sdp_b{} (Bandwidth information)</CODE></STRONG><BR>
<STRONG><CODE>sdp_k() = #megaco_sdp_k{} (Encryption key)</CODE></STRONG><BR>
<STRONG><CODE>sdp_a() = #megaco_sdp_a{} (Session attribute)</CODE></STRONG><BR>
<STRONG><CODE>sdp_a_rtpmap() = #megaco_sdp_rtpmap{}</CODE></STRONG><BR>
<STRONG><CODE>sdp_a_ptime() = #megaco_sdp_a_ptime{}</CODE></STRONG><BR>
<STRONG><CODE>sdp_a_quality() = #megaco_sdp_a_quality{}</CODE></STRONG><BR>
<STRONG><CODE>sdp_a_fmtp() = #megaco_sdp_a_fmtp{}</CODE></STRONG><BR>
<STRONG><CODE>sdp_z() = #megaco_sdp_z{} (Time zone adjustment)</CODE></STRONG><BR>
<STRONG><CODE>sdp_t() = #megaco_sdp_t{} (Time the session is active)</CODE></STRONG><BR>
<STRONG><CODE>sdp_r() = #megaco_sdp_r{} (Repeat times)</CODE></STRONG><BR>
<STRONG><CODE>sdp_m() = #megaco_sdp_m{} (Media name and transport address)</CODE></STRONG><BR>
<STRONG><CODE>sdp_property_group() = [sdp()]</CODE></STRONG><BR>
<STRONG><CODE>sdp_property_groups() = [sdp_property_group()]</CODE></STRONG><BR>
<STRONG><CODE>PP = property_parm() | property_group() | property_groups() | asn1_NOVALUE</CODE></STRONG><BR>
<STRONG><CODE>property_group() = [property_parm()]</CODE></STRONG><BR>
<STRONG><CODE>property_groups() = [property_group()]</CODE></STRONG><BR>
<STRONG><CODE>Reason = term()</CODE></STRONG><BR>

  </DIV>
</DIV>

<DIV CLASS=REFBODY>

<P>Encode (generate) an SDP construct.
<P>If a <CODE>property_parm()</CODE> is found as part of the input
(<CODE>SDP</CODE>) then it is left unchanged.
<P>This function performs the following transformation:
<P>
<UL>

<LI>
sdp() -&#62; property_parm()<BR>

</LI>


<LI>
sdp_property_group() -&#62; property_group()<BR>

</LI>


<LI>
sdp_property_groups() -&#62; property_groups()<BR>

</LI>


</UL>
<A NAME="decode_sdp"><!-- Empty --></A>
</DIV>

<P><A NAME="decode_sdp/1"><STRONG><CODE>decode_sdp(PP) -&#62; {ok, SDP} | {error, Reason}</CODE></STRONG></A><BR>

<DIV CLASS=REFBODY><P>Types:
  <DIV CLASS=REFTYPES>
<P>
<STRONG><CODE>PP = property_parm() | property_group() | property_groups() | asn1_NOVALUE</CODE></STRONG><BR>
<STRONG><CODE>property_group() = [property_parm()]</CODE></STRONG><BR>
<STRONG><CODE>property_groups() = [property_group()]</CODE></STRONG><BR>
<STRONG><CODE>SDP = sdp() | {property_parm(), DecodeError} | sdp_property_group() | {sdp_property_groups(), BadPPs} | asn1_NOVALUE</CODE></STRONG><BR>
<STRONG><CODE>sdp() = sdp_c() | sdp_o() | sdp_s() | sdo_i() | sdo_u() | sdo_e() | sdo_p() | sdo_c() | sdo_b() | sdo_z() | sdo_k() | sdo_a() | sdo_a_rtpmap() | sdo_a_ptime() | sdo_t() | sdo_r() | sdo_m()</CODE></STRONG><BR>
<STRONG><CODE>sdp_v() = #megaco_sdp_v{} (Protocol version)</CODE></STRONG><BR>
<STRONG><CODE>sdp_o() = #megaco_sdp_o{} (Owner/creator and session indentifier)</CODE></STRONG><BR>
<STRONG><CODE>sdp_s() = #megaco_sdp_s{} (Session name)</CODE></STRONG><BR>
<STRONG><CODE>sdp_i() = #megaco_sdp_i{} (Session information)</CODE></STRONG><BR>
<STRONG><CODE>sdp_u() = #megaco_sdp_u{} (URI of description)</CODE></STRONG><BR>
<STRONG><CODE>sdp_e() = #megaco_sdp_e{} (Email address)</CODE></STRONG><BR>
<STRONG><CODE>sdp_p() = #megaco_sdp_p{} (Phone number)</CODE></STRONG><BR>
<STRONG><CODE>sdp_c() = #megaco_sdp_c{} (Connection information)</CODE></STRONG><BR>
<STRONG><CODE>sdp_b() = #megaco_sdp_b{} (Bandwidth information)</CODE></STRONG><BR>
<STRONG><CODE>sdp_k() = #megaco_sdp_k{} (Encryption key)</CODE></STRONG><BR>
<STRONG><CODE>sdp_a() = #megaco_sdp_a{} (Session attribute)</CODE></STRONG><BR>
<STRONG><CODE>sdp_a_rtpmap() = #megaco_sdp_rtpmap{}</CODE></STRONG><BR>
<STRONG><CODE>sdp_a_ptime() = #megaco_sdp_a_ptime{}</CODE></STRONG><BR>
<STRONG><CODE>sdp_a_quality() = #megaco_sdp_a_quality{}</CODE></STRONG><BR>
<STRONG><CODE>sdp_a_fmtp() = #megaco_sdp_a_fmtp{}</CODE></STRONG><BR>
<STRONG><CODE>sdp_z() = #megaco_sdp_z{} (Time zone adjustment)</CODE></STRONG><BR>
<STRONG><CODE>sdp_t() = #megaco_sdp_t{} (Time the session is active)</CODE></STRONG><BR>
<STRONG><CODE>sdp_r() = #megaco_sdp_r{} (Repeat times)</CODE></STRONG><BR>
<STRONG><CODE>sdp_m() = #megaco_sdp_m{} (Media name and transport address)</CODE></STRONG><BR>
<STRONG><CODE>sdp_property_group() = [sdp()]</CODE></STRONG><BR>
<STRONG><CODE>sdp_property_groups() = [sdp_property_group()]</CODE></STRONG><BR>
<STRONG><CODE>DecodeError = term()</CODE></STRONG><BR>
<STRONG><CODE>Reason = term()</CODE></STRONG><BR>

  </DIV>
</DIV>

<DIV CLASS=REFBODY>

<P>Decode (parse) a property parameter construct.
<P>When decoding <CODE>property_group()</CODE> or <CODE>property_groups()</CODE>, 
those property parameter constructs that cannot be decoded
(either because of decode error or because they are unknown),
will be returned as a two-tuple. The first element of which 
will be the (ndecoded) property parameter and the other the 
actual reason. 
This means that the caller of this function has to expect not 
only sdp-records, but also this two-tuple construct.
<P>This function performs the following transformation:
<P>
<UL>

<LI>
property_parm() -&#62; sdp()<BR>

</LI>


<LI>
property_group() -&#62; sdp_property_group()<BR>

</LI>


<LI>
property_groups() -&#62; sdp_property_groups()<BR>

</LI>


</UL>
<A NAME="versions1"><!-- Empty --></A><A NAME="versions2"><!-- Empty --></A>
</DIV>

<P><A NAME="versions1/0"><STRONG><CODE>versions1() -&#62; {ok, VersionInfo} | {error, Reason}</CODE></STRONG></A><BR>
<A NAME="versions2/0"><STRONG><CODE>versions2() -&#62; {ok, Info} | {error, Reason}</CODE></STRONG></A><BR>

<DIV CLASS=REFBODY><P>Types:
  <DIV CLASS=REFTYPES>
<P>
<STRONG><CODE>VersionInfo = [version_info()]</CODE></STRONG><BR>
<STRONG><CODE>version_info() = term()</CODE></STRONG><BR>
<STRONG><CODE>Reason = term()</CODE></STRONG><BR>

  </DIV>
</DIV>

<DIV CLASS=REFBODY>

<P>Utility functions used to retreive some system and
application info.
<P>The difference between the two functions is in how they get
the modules to check. <CODE>versions1</CODE> uses the app-file and
<CODE>versions2</CODE> uses the function <CODE>application:get_key</CODE>.

<A NAME="print_version_info"><!-- Empty --></A> 

</DIV>

<P><A NAME="print_version_info/0"><STRONG><CODE>print_version_info() -&#62; void()</CODE></STRONG></A><BR>
<A NAME="print_version_info/1"><STRONG><CODE>print_version_info(VersionInfo) -&#62; void()</CODE></STRONG></A><BR>

<DIV CLASS=REFBODY><P>Types:
  <DIV CLASS=REFTYPES>
<P>
<STRONG><CODE>VersionInfo = [version_info()]</CODE></STRONG><BR>
<STRONG><CODE>version_info() = term()</CODE></STRONG><BR>

  </DIV>
</DIV>

<DIV CLASS=REFBODY>

<P>Utility function to produce a formated printout of the versions 
info generated by the <CODE>versions1</CODE> and <CODE>versions2</CODE> 
functions.
<P>The function print_version_info/0 uses the result of function
version1/0 as <CODE>VersionInfo</CODE>.
<P>Example: 
<PRE>
           {ok, V} = megaco:versions1(), megaco:format_versions(V). 
        
</PRE>
<A NAME="enable_trace"><!-- Empty --></A>
</DIV>

<P><A NAME="enable_trace/2"><STRONG><CODE>enable_trace(Level, Destination) -&#62; void()</CODE></STRONG></A><BR>

<DIV CLASS=REFBODY><P>Types:
  <DIV CLASS=REFTYPES>
<P>
<STRONG><CODE>Level = max | min | 0 &#60;= integer() &#60;= 100</CODE></STRONG><BR>
<STRONG><CODE>Destination = File | Port | HandlerSpec | io</CODE></STRONG><BR>
<STRONG><CODE>File = string()</CODE></STRONG><BR>
<STRONG><CODE>Port = integer()</CODE></STRONG><BR>
<STRONG><CODE>HandleSpec = {HandlerFun, Data}</CODE></STRONG><BR>
<STRONG><CODE>HandleFun = fun() (two arguments)</CODE></STRONG><BR>
<STRONG><CODE>Data = term()</CODE></STRONG><BR>

  </DIV>
</DIV>

<DIV CLASS=REFBODY>

<P>This function is used to start megaco tracing at a given 
         <CODE>Level</CODE> and direct result to the given <CODE>Destination</CODE>.
<P>It starts a tracer server and then sets the proper match spec 
         (according to <CODE>Level</CODE>).
<P>In the case when <CODE>Destination</CODE> is <CODE>File</CODE>, the printable 
         megaco trace events will be printed to the file <CODE>File</CODE> using
         plain <CODE>io:format/2</CODE>. 
<P>In the case when <CODE>Destination</CODE> is <CODE>io</CODE>, the printable 
         megaco trace events will be printed on stdout using plain 
         <CODE>io:format/2</CODE>. 
<P>See <CODE>dbg</CODE> for further information.<A NAME="disable_trace"><!-- Empty --></A>
</DIV>

<P><A NAME="disable_trace/0"><STRONG><CODE>disable_trace() -&#62; void()</CODE></STRONG></A><BR>

<DIV CLASS=REFBODY>

<P>This function is used to stop megaco tracing.<A NAME="set_trace"><!-- Empty --></A>
</DIV>

<P><A NAME="set_trace/1"><STRONG><CODE>set_trace(Level) -&#62; void()</CODE></STRONG></A><BR>

<DIV CLASS=REFBODY><P>Types:
  <DIV CLASS=REFTYPES>
<P>
<STRONG><CODE>Level = max | min | 0 &#60;= integer() &#60;= 100</CODE></STRONG><BR>

  </DIV>
</DIV>

<DIV CLASS=REFBODY>

<P>This function is used to change the megaco trace level.
<P>It is assumed that tracing has already been enabled (see 
         <CODE>enable_trace</CODE> above).<A NAME="stats"><!-- Empty --></A>
</DIV>

<P><A NAME="get_stats/0"><STRONG><CODE>get_stats() -&#62; {ok, TotalStats} | {error, Reason}</CODE></STRONG></A><BR>
<A NAME="get_stats/1"><STRONG><CODE>get_stats(GlobalCounter) -&#62; {ok, CounterStats} | {error, Reason}</CODE></STRONG></A><BR>
<A NAME="get_stats/1"><STRONG><CODE>get_stats(CallHandle) -&#62; {ok, CallHandleStats} | {error, Reason}</CODE></STRONG></A><BR>
<A NAME="get_stats/2"><STRONG><CODE>get_stats(CallHandle, Counter) -&#62; {ok, integer()} | {error, Reason}</CODE></STRONG></A><BR>

<DIV CLASS=REFBODY><P>Types:
  <DIV CLASS=REFTYPES>
<P>
<STRONG><CODE>TotalStats = [total_stats()]</CODE></STRONG><BR>
<STRONG><CODE>total_stats() = {call_handle(), [stats()]} | {global_counter(), integer()}</CODE></STRONG><BR>
<STRONG><CODE>GlobalCounter = global_counter()</CODE></STRONG><BR>
<STRONG><CODE>GlobalCounterStats = integer()</CODE></STRONG><BR>
<STRONG><CODE>CallHandle = call_handle()</CODE></STRONG><BR>
<STRONG><CODE>CallHandleStats = [stats()]</CODE></STRONG><BR>
<STRONG><CODE>stats() = {counter(), integer()}</CODE></STRONG><BR>
<STRONG><CODE>Counter = counter()</CODE></STRONG><BR>
<STRONG><CODE>counter() = medGwyGatewayNumTimerRecovery | 
         medGwyGatewayNumErrors</CODE></STRONG><BR>
<STRONG><CODE>global_counter() = medGwyGatewayNumErrors</CODE></STRONG><BR>
<STRONG><CODE>Reason = term()</CODE></STRONG><BR>

  </DIV>
</DIV>

<DIV CLASS=REFBODY>

<P>      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).
        <A NAME="reset_stats"><!-- Empty --></A>
</DIV>

<P><A NAME="reset_stats/0"><STRONG><CODE>reset_stats() -&#62; void()</CODE></STRONG></A><BR>
<A NAME="reset_stats/1"><STRONG><CODE>reset_stats(SendHandle) -&#62; void()</CODE></STRONG></A><BR>

<DIV CLASS=REFBODY><P>Types:
  <DIV CLASS=REFTYPES>
<P>
<STRONG><CODE>SendHandle = send_handle()</CODE></STRONG><BR>

  </DIV>
</DIV>

<DIV CLASS=REFBODY>

<P>      Reset all related (SNMP) statistics counters.
        <A NAME="test_request"><!-- Empty --></A>
</DIV>

<P><A NAME="test_request/5"><STRONG><CODE>test_request(ConnHandle, Version, EncodingMod, EncodingConfig, Actions) -&#62; {MegaMsg, EncodeRes}</CODE></STRONG></A><BR>

<DIV CLASS=REFBODY><P>Types:
  <DIV CLASS=REFTYPES>
<P>
<STRONG><CODE>ConnHandle = conn_handle()</CODE></STRONG><BR>
<STRONG><CODE>Version = integer()</CODE></STRONG><BR>
<STRONG><CODE>EncodingMod = atom()</CODE></STRONG><BR>
<STRONG><CODE>EncodingConfig = Encoding configuration</CODE></STRONG><BR>
<STRONG><CODE>Actions = A list</CODE></STRONG><BR>
<STRONG><CODE>MegaMsg = #'MegacoMessage'{}</CODE></STRONG><BR>
<STRONG><CODE>EncodeRes = {ok, Bin} | {error, Reason}</CODE></STRONG><BR>
<STRONG><CODE>Bin = binary()</CODE></STRONG><BR>
<STRONG><CODE>Reason = term()</CODE></STRONG><BR>

  </DIV>
</DIV>

<DIV CLASS=REFBODY>

<P>Tests if the Actions argument is correctly composed.
<P>This function is only intended for testing purposes. It's
         supposed to have a same kind of interface as the <A HREF="#call">call</A> or <A HREF="#cast">cast</A> functions (with the additions
         of the <CODE>EncodingMod</CODE> and <CODE>EncodingConfig</CODE>
         arguments). It composes a complete megaco message end
         attempts to encode it. The return value, will be a tuple of
         the composed megaco message and the encode result. <A NAME="test_reply"><!-- Empty --></A>
</DIV>

<P><A NAME="test_reply/5"><STRONG><CODE>test_reply(ConnHandle, Version, EncodingMod, EncodingConfig, Reply) -&#62; {MegaMsg, EncodeRes}</CODE></STRONG></A><BR>

<DIV CLASS=REFBODY><P>Types:
  <DIV CLASS=REFTYPES>
<P>
<STRONG><CODE>ConnHandle = conn_handle()</CODE></STRONG><BR>
<STRONG><CODE>Version = integer()</CODE></STRONG><BR>
<STRONG><CODE>EncodingMod = atom()</CODE></STRONG><BR>
<STRONG><CODE>EncodingConfig = A list</CODE></STRONG><BR>
<STRONG><CODE>Reply = actual_reply()</CODE></STRONG><BR>
<STRONG><CODE>MegaMsg = #'MegacoMessage'{}</CODE></STRONG><BR>
<STRONG><CODE>EncodeRes = {ok, Bin} | {error, Reason}</CODE></STRONG><BR>
<STRONG><CODE>Bin = binary()</CODE></STRONG><BR>
<STRONG><CODE>Reason = term()</CODE></STRONG><BR>

  </DIV>
</DIV>

<DIV CLASS=REFBODY>

<P>Tests if the Reply argument is correctly composed.
<P>This function is only intended for testing purposes. It's
         supposed to test the <CODE>actual_reply()</CODE> return value of
         the callback functions 
         <A HREF="megaco_user.html#trans_request">handle_trans_request</A>
         and 
         <A HREF="megaco_user.html#trans_long_request">handle_trans_long_request</A>
         functions (with the additions of the <CODE>EncodingMod</CODE> and
         <CODE>EncodingConfig</CODE> arguments). It composes a complete
         megaco message end attempts to encode it. The return value,
         will be a tuple of the composed megaco message and the
         encode result.
</DIV>

<H3>AUTHORS</H3>
<DIV CLASS=REFBODY>
Hkan Mattsson - support@erlang.ericsson.se<BR>

</DIV>
<CENTER>
<HR>
<SMALL>megaco 3.5<BR>
Copyright &copy; 1991-2006
<A HREF="http://www.erlang.se">Ericsson AB</A><BR>
</SMALL>
</CENTER>
</BODY>
</HTML>