The R13B03 release.OTP_R13B03

1 files changed, 1221 insertions, 0 deletions

diff --git a/lib/megaco/test/megaco_test_mgc.erl b/lib/megaco/test/megaco_test_mgc.erl
new file mode 100644
index 0000000000..05c482f1af
--- /dev/null
+++ b/lib/megaco/test/megaco_test_mgc.erl
@@ -0,0 +1,1221 @@
+%%
+%% %CopyrightBegin%
+%% 
+%% Copyright Ericsson AB 2003-2009. All Rights Reserved.
+%% 
+%% The contents of this file are subject to the Erlang Public License,
+%% Version 1.1, (the "License"); you may not use this file except in
+%% compliance with the License. You should have received a copy of the
+%% Erlang Public License along with this software. If not, it can be
+%% retrieved online at http://www.erlang.org/.
+%% 
+%% Software distributed under the License is distributed on an "AS IS"
+%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+%% the License for the specific language governing rights and limitations
+%% under the License.
+%% 
+%% %CopyrightEnd%
+%%
+
+%%
+%%----------------------------------------------------------------------
+%% Purpose: Implements an "MGC" used by the test suite
+%%----------------------------------------------------------------------
+-module(megaco_test_mgc).
+
+-export([start/4, start/5, stop/1,
+	 get_stats/2, reset_stats/1,
+	 user_info/1, user_info/2, conn_info/1, conn_info/2, 
+	 update_user_info/3, update_conn_info/3, 
+	 request_ignore/1, 
+	 request_discard/1, request_discard/2, 
+	 request_pending/1, request_pending/2, request_pending_ignore/1, 
+	 request_handle/1, request_handle/2, 
+	 request_handle_pending/1, request_handle_pending/2, 
+	 request_handle_sloppy/1, request_handle_sloppy/2, 
+	 ack_info/2, abort_info/2, req_info/2, 
+	 disconnect/2, 
+	 verbosity/2]).
+-export([mgc/3]).
+
+%% Megaco callback api
+-export([
+	 handle_connect/3,
+	 handle_disconnect/4,
+	 handle_syntax_error/4,
+	 handle_message_error/4,
+	 handle_trans_request/4,
+	 handle_trans_long_request/4,
+	 handle_trans_reply/5,
+	 handle_trans_ack/5,
+         handle_unexpected_trans/4,
+         handle_trans_request_abort/5
+	]).
+
+-include("megaco_test_lib.hrl").
+-include_lib("megaco/include/megaco.hrl").
+-include_lib("megaco/include/megaco_message_v1.hrl").
+
+-define(A4444, ["11111111", "00000000", "00000000"]).
+-define(A4445, ["11111111", "00000000", "11111111"]).
+-define(A5555, ["11111111", "11111111", "00000000"]).
+-define(A5556, ["11111111", "11111111", "11111111"]).
+
+-define(valid_actions, 
+	[ignore, pending, pending_ignore, discard_ack, handle_ack, handle_pending_ack, handle_sloppy_ack]).
+
+-record(mgc, {parent      = undefined,
+	      tcp_sup     = undefined,
+	      udp_sup     = undefined,
+	      req_action  = discard_ack,
+	      req_timeout = 0,
+	      mid         = undefined,
+	      ack_info    = undefined,
+	      abort_info  = undefined,
+	      req_info    = undefined,
+	      mg          = [],
+	      dsi_timer}).
+
+
+%%% ------------------------------------------------------------------
+
+start(Node, Mid, ET, Verbosity) ->
+    %% Conf = [{megaco_trace, io}],
+    %% Conf = [{megaco_trace, "megaco-mgc.trace"}],
+    Conf = [{megaco_trace, false}],
+    start(Node, Mid, ET, Conf, Verbosity).
+
+start(Node, Mid, ET, Conf, Verbosity) ->
+    d("start mgc[~p]: ~p", [Node, Mid]),
+    RI = {receive_info, mk_recv_info(ET)},
+    Config = [{local_mid, Mid}, RI] ++ Conf,
+    Pid = spawn_link(Node, ?MODULE, mgc, [self(), Verbosity, Config]),
+    await_started(Pid).
+
+mk_recv_info(ET) ->
+    mk_recv_info(ET, []).
+
+mk_recv_info([], Acc) ->
+    Acc;
+mk_recv_info([{Encoding, Transport}|ET], Acc) 
+  when is_atom(Encoding) andalso is_atom(Transport) ->
+    {EMod, Port} = select_encoding(Encoding),
+    TMod         = select_transport(Transport),
+    RI = [{encoding_module,  EMod},
+	  {encoding_config,  []},
+	  {transport_module, TMod},
+	  {port,             Port}],
+    mk_recv_info(ET, [RI|Acc]);
+mk_recv_info([{Encoding, Transport, TO}|ET], Acc) 
+  when is_atom(Encoding) andalso is_atom(Transport) andalso is_list(TO) ->
+    {EMod, Port} = select_encoding(Encoding),
+    TMod         = select_transport(Transport),
+    RI = [{encoding_module,  EMod},
+	  {encoding_config,  []},
+	  {transport_module, TMod},
+	  {port,             Port},
+          {transport_opts,   TO}],
+    mk_recv_info(ET, [RI|Acc]);
+mk_recv_info([{Encoding, EC, Transport}|ET], Acc) 
+  when is_atom(Encoding) andalso is_list(EC) andalso is_atom(Transport) ->
+    {EMod, Port} = select_encoding(Encoding),
+    TMod         = select_transport(Transport),
+    RI = [{encoding_module,  EMod},
+	  {encoding_config,  EC},
+	  {transport_module, TMod},
+	  {port,             Port}],
+    mk_recv_info(ET, [RI|Acc]);
+mk_recv_info([ET|_], _) ->
+    throw({error, {invalid_encoding_transport, ET}}).
+
+select_encoding(text) ->
+    {megaco_pretty_text_encoder, 2944};
+select_encoding(pretty_text) ->
+    {megaco_pretty_text_encoder, 2944};
+select_encoding(compact_text) ->
+    {megaco_compact_text_encoder, 2944};
+select_encoding(binary) ->
+    {megaco_ber_bin_encoder, 2945};
+select_encoding(erl_dist) ->
+    {megaco_erl_dist_encoder, 2946};
+select_encoding(Encoding) ->
+    throw({error, {invalid_encoding, Encoding}}).
+
+select_transport(tcp) ->
+    megaco_tcp;
+select_transport(udp) ->
+    megaco_udp;
+select_transport(Transport) ->
+    throw({error, {invalid_transport, Transport}}).
+
+
+await_started(Pid) ->
+    receive
+	{started, Pid} ->
+	    d("await_started ~p: ok", [Pid]),
+	    {ok, Pid};
+	{'EXIT', Pid, 
+	 {failed_starting_tcp_listen, {could_not_start_listener, {gen_tcp_listen, eaddrinuse}}}} ->
+	    i("await_started ~p: address already in use", [Pid]),
+	    ?SKIP(eaddrinuse);
+	{'EXIT', Pid, Reason} ->
+	    i("await_started ~p: received exit signal: ~p", [Pid, Reason]),
+	    exit({failed_starting, Pid, Reason})
+    after 10000 ->
+	    i("await_started ~p: timeout", [Pid]),
+	    exit({error, timeout})
+    end.
+
+
+stop(Pid) ->
+    server_request(Pid, stop, stopped).
+
+get_stats(Pid, No) ->
+    server_request(Pid, {statistics, No}, {statistics_reply, No}).
+
+reset_stats(Pid) ->
+    server_request(Pid, reset_stats, reset_stats_ack).
+
+user_info(Pid) ->
+    server_request(Pid, {user_info, all}, user_info_ack).
+
+user_info(Pid, Tag) ->
+    server_request(Pid, {user_info, Tag}, user_info_ack).
+
+conn_info(Pid) ->
+    server_request(Pid, {conn_info, all}, conn_info_ack).
+
+conn_info(Pid, Tag) ->
+    server_request(Pid, {conn_info, Tag}, conn_info_ack).
+
+update_user_info(Pid, Tag, Val) ->
+    server_request(Pid, {update_user_info, Tag, Val}, update_user_info_ack).
+
+update_conn_info(Pid, Tag, Val) ->
+    server_request(Pid, {update_conn_info, Tag, Val}, update_conn_info_ack).
+
+disconnect(Pid, Reason) ->
+    server_request(Pid, {disconnect, Reason}, disconnected).
+
+ack_info(Pid, InfoPid) ->
+    Pid ! {ack_info, InfoPid, self()}.
+
+abort_info(Pid, InfoPid) ->
+    Pid ! {abort_info, InfoPid, self()}.
+
+req_info(Pid, InfoPid) ->
+    Pid ! {req_info, InfoPid, self()}.
+
+verbosity(Pid, V) ->
+    Pid ! {verbosity, V, self()}.
+
+request_ignore(Pid) ->
+    request_action(Pid, {ignore, infinity}).
+
+request_pending_ignore(Pid) ->
+    request_action(Pid, {pending_ignore, infinity}).
+
+request_discard(Pid) ->
+    request_discard(Pid,0).
+
+request_discard(Pid, To) ->
+    request_action(Pid, {discard_ack, To}).
+
+request_pending(Pid) ->
+    request_pending(Pid, 5000).
+
+request_pending(Pid, To) ->
+    request_action(Pid, {pending, To}).
+
+request_handle(Pid) ->
+    request_handle(Pid, 0).
+
+request_handle(Pid, To) ->
+    request_action(Pid, {handle_ack, To}).
+
+request_handle_pending(Pid) ->
+    request_handle_pending(Pid, 0).
+
+request_handle_pending(Pid, To) ->
+    request_action(Pid, {handle_pending_ack, To}).
+
+request_handle_sloppy(Pid) ->
+    request_handle_sloppy(Pid, 0).
+
+request_handle_sloppy(Pid, To) ->
+    request_action(Pid, {handle_sloppy_ack, To}).
+
+request_action(Pid, Action) ->
+    server_request(Pid, request_action, Action, request_action_ack).
+
+
+server_request(Pid, Req, ReplyTag) ->
+    Pid ! {Req, self()},
+    receive
+	{ReplyTag, Reply, Pid} ->
+	    Reply;
+	{'EXIT', Pid, Reason} ->
+	    exit({failed, Req, Pid, Reason})
+    after 10000 ->
+	    exit({timeout, Req, Pid})
+    end.
+
+server_request(Pid, Req, ReqData, ReplyTag) ->
+    Pid ! {Req, ReqData, self()},
+    receive
+	{ReplyTag, Reply, Pid} ->
+	    Reply;
+	{'EXIT', Pid, Reason} ->
+	    exit({failed, Req, Pid, Reason})
+    after 10000 ->
+	    exit({timeout, Req, Pid})
+    end.
+
+
+server_reply(Pid, ReplyTag, Reply) ->
+    Pid ! {ReplyTag, Reply, self()}.
+
+
+%%% ------------------------------------------------------------------
+
+
+mgc(Parent, Verbosity, Config) ->
+    process_flag(trap_exit, true),
+    put(verbosity, Verbosity),
+    put(sname,   "MGC"),
+    i("mgc -> starting"),
+    case (catch init(Config)) of
+	{error, Reason} ->
+	    exit(Reason);
+	{Mid, TcpSup, UdpSup, DSITimer} ->
+	    notify_started(Parent),
+	    S = #mgc{parent    = Parent, 
+		     tcp_sup   = TcpSup, 
+		     udp_sup   = UdpSup, 
+		     mid       = Mid,
+		     dsi_timer = DSITimer},
+	    i("mgc -> started"),
+	    display_system_info("at start "),
+	    loop(S)
+    end.
+
+init(Config) ->
+    d("init -> entry"),
+    random_init(),
+    Mid = get_conf(local_mid, Config),
+    RI  = get_conf(receive_info, Config),
+
+    d("init -> maybe start the display system info timer"),
+    DSITimer = 
+	case get_conf(display_system_info, Config, undefined) of
+	    Time when is_integer(Time) ->
+		d("init -> creating display system info timer"),
+		create_timer(Time, display_system_info);
+	    _ ->
+		undefined
+	end,
+    Conf0 = lists:keydelete(display_system_info, 1, Config),
+
+    d("init -> start megaco"),
+    application:start(megaco),
+
+    d("init -> possibly enable megaco trace"),
+    case lists:keysearch(megaco_trace, 1, Config) of
+	{value, {megaco_trace, true}} ->
+	    megaco:enable_trace(max, io);
+	{value, {megaco_trace, io}} ->
+	    megaco:enable_trace(max, io);
+	{value, {megaco_trace, File}} when is_list(File) ->
+	    megaco:enable_trace(max, File);
+	_ ->
+	    ok
+    end,
+    Conf1 = lists:keydelete(megaco_trace,    1, Conf0),
+
+    d("init -> start megaco user"),
+    Conf2 = lists:keydelete(local_mid,    1, Conf1),
+    Conf3 = lists:keydelete(receive_info, 1, Conf2),
+    ok = megaco:start_user(Mid, Conf3),
+
+    d("init -> update user info (user_mod)"),
+    ok = megaco:update_user_info(Mid, user_mod,  ?MODULE),
+
+    d("init -> update user info (user_args)"),
+    ok = megaco:update_user_info(Mid, user_args, [self()]),
+
+    d("init -> get user info (receive_handle)"),
+    RH = megaco:user_info(Mid,receive_handle),
+    d("init -> parse receive info"),
+    Transports = parse_receive_info(RI, RH),
+
+    d("init -> start transports"),
+    {Tcp, Udp} = start_transports(Transports),
+    {Mid, Tcp, Udp, DSITimer}.
+    
+loop(S) ->
+    d("loop -> await request"),
+    receive
+	{display_system_info, Time} ->
+	    display_system_info(S#mgc.mid),
+	    NewTimer = create_timer(Time, display_system_info),
+	    loop(S#mgc{dsi_timer = NewTimer});
+
+	{stop, Parent} when S#mgc.parent =:= Parent ->
+	    i("loop -> stopping", []),
+	    display_system_info(S#mgc.mid, "at finish "),
+	    cancel_timer(S#mgc.dsi_timer),
+  	    Mid = S#mgc.mid,
+	    (catch close_conns(Mid)),
+	    megaco:stop_user(Mid),
+	    application:stop(megaco),
+	    i("loop -> stopped", []),
+	    server_reply(Parent, stopped, ok),
+	    exit(normal);
+
+	{{disconnect, Reason}, Parent} when S#mgc.parent == Parent ->
+	    i("loop -> disconnecting", []),
+  	    Mid = S#mgc.mid,
+	    [Conn|_] = megaco:user_info(Mid, connections),
+	    Res = megaco:disconnect(Conn, {self(), Reason}),
+	    server_reply(Parent, disconnected, Res),
+	    loop(S);
+
+	{{update_user_info, Tag, Val}, Parent} when S#mgc.parent == Parent ->
+	    i("loop -> got update_user_info: ~w -> ~p", [Tag, Val]),
+	    Res = (catch megaco:update_user_info(S#mgc.mid, Tag, Val)),
+	    d("loop -> Res: ~p", [Res]),
+	    server_reply(Parent, update_user_info_ack, Res),
+	    loop(S);
+
+	{{user_info, Tag}, Parent} when S#mgc.parent == Parent ->
+	    i("loop -> got user_info request for ~w", [Tag]),
+	    Res = (catch megaco:user_info(S#mgc.mid, Tag)),
+	    d("loop -> Res: ~p", [Res]),
+	    server_reply(Parent, user_info_ack, Res),
+	    loop(S);
+
+	{{update_conn_info, Tag, Val}, Parent} when S#mgc.parent == Parent ->
+	    i("loop -> got update_conn_info: ~w -> ~p", [Tag, Val]),
+	    Conns = megaco:user_info(S#mgc.mid, connections), 
+	    Fun = fun(CH) ->
+			  (catch megaco:update_conn_info(CH, Tag, Val))
+		  end,
+	    Res = lists:map(Fun, Conns),
+	    d("loop -> Res: ~p", [Res]),
+	    server_reply(Parent, update_conn_info_ack, Res),
+	    loop(S);
+
+	{{conn_info, Tag}, Parent} when S#mgc.parent == Parent ->
+	    i("loop -> got conn_info request for ~w", [Tag]),
+	    Conns = megaco:user_info(S#mgc.mid, connections), 
+	    Fun = fun(CH) ->
+			  {CH, (catch megaco:conn_info(CH, Tag))}
+		  end,
+	    Res = lists:map(Fun, Conns),
+	    d("loop -> Res: ~p", [Res]),
+	    server_reply(Parent, conn_info_ack, Res),
+	    loop(S);
+
+
+	%% 
+	{request_action, {Action, To}, Parent} when S#mgc.parent == Parent ->
+	    i("loop -> got new request_action: ~p:~w", [Action,To]),
+	    {Reply, S1} = 
+		case lists:member(Action, ?valid_actions) of
+		    true when To >= 0; To == infinity ->
+			{{ok, S#mgc.req_action}, 
+			 S#mgc{req_action = Action, req_timeout = To}};
+		    true ->
+			{{error, {invalid_action_timeout, To}}, S};
+		    false ->
+			{{error, {invalid_action, Action}}, S}
+		end,
+	    server_reply(Parent, request_action_ack, Reply),
+	    loop(S1);
+
+
+	%% Reset stats
+	{reset_stats, Parent} when S#mgc.parent == Parent ->
+	    i("loop -> got request to reset stats counters"),
+	    do_reset_stats(S#mgc.mid),
+	    server_reply(Parent, reset_stats_ack, ok),
+	    loop(S);
+
+
+	%% Give me statistics
+	{{statistics, 1}, Parent} when S#mgc.parent == Parent ->
+	    i("loop -> got request for statistics 1"),
+	    {ok, Gen} = megaco:get_stats(),
+	    GetTrans = 
+		fun(CH) ->
+			Reason = {statistics, CH}, 
+			Pid = megaco:conn_info(CH, control_pid),
+			SendMod = megaco:conn_info(CH, send_mod),
+			SendHandle = megaco:conn_info(CH, send_handle),
+			{ok, Stats} = 
+			    case SendMod of
+				megaco_tcp -> megaco_tcp:get_stats(SendHandle);
+				megaco_udp -> megaco_udp:get_stats(SendHandle);
+				SendMod    -> exit(Pid, Reason)
+			    end,
+			{SendHandle, Stats}
+		end,
+	    Mid = S#mgc.mid,
+	    Trans = 
+		lists:map(GetTrans, megaco:user_info(Mid, connections)),
+	    Reply = {ok, [{gen, Gen}, {trans, Trans}]},
+	    server_reply(Parent, {statistics_reply, 1}, Reply),
+	    loop(S);
+
+
+	{{statistics, 2}, Parent} when S#mgc.parent == Parent ->
+	    i("loop -> got request for statistics 2"),
+	    {ok, Gen} = megaco:get_stats(),
+	    #mgc{tcp_sup = TcpSup, udp_sup = UdpSup} = S,
+	    TcpStats = get_trans_stats(TcpSup, megaco_tcp),
+	    UdpStats = get_trans_stats(UdpSup, megaco_udp),
+	    Reply = {ok, [{gen, Gen}, {trans, [TcpStats, UdpStats]}]},
+	    server_reply(Parent, {statistics_reply, 2}, Reply),
+	    loop(S);
+
+
+	%% Megaco callback messages
+	{request, Request, From} ->
+	    d("loop -> received megaco request from ~p:~n~p", 
+	      [From, Request]),
+	    {Reply, S1} = handle_megaco_request(Request, S),
+	    d("loop -> send request reply: ~n~p", [Reply]),
+	    reply(From, Reply),
+	    loop(S1);
+
+
+	{ack_info, To, Parent} when S#mgc.parent == Parent ->
+	    i("loop -> received request to inform about received ack's ", []),
+	    loop(S#mgc{ack_info = To});
+
+
+	{abort_info, To, Parent} when S#mgc.parent == Parent ->
+	    i("loop -> received request to inform about received aborts ", []),
+	    loop(S#mgc{abort_info = To});
+
+
+	{req_info, To, Parent} when S#mgc.parent == Parent ->
+	    i("loop -> received request to inform about received req's ", []),
+	    loop(S#mgc{req_info = To});
+
+
+	{verbosity, V, Parent} when S#mgc.parent == Parent ->
+	    i("loop -> received new verbosity: ~p", [V]),
+	    put(verbosity,V),
+	    loop(S);
+
+
+	{'EXIT', Pid, Reason} when S#mgc.tcp_sup =:= Pid ->
+	    error_msg("MGC received unexpected exit "
+		      "from TCP transport supervisor (~p):~n~p", 
+		      [Pid, Reason]),
+	    i("loop -> [tcp] exiting", []),
+	    display_system_info(S#mgc.mid, "at bad finish (tcp) "),
+	    cancel_timer(S#mgc.dsi_timer),
+  	    Mid = S#mgc.mid,
+	    (catch close_conns(Mid)),
+	    megaco:stop_user(Mid),
+	    application:stop(megaco),
+	    i("loop -> stopped", []),
+	    StopReason = {error, {tcp_terminated, Pid, Reason}}, 
+	    server_reply(S#mgc.parent, stopped, StopReason),
+	    exit(StopReason);
+
+
+	{'EXIT', Pid, Reason} when S#mgc.udp_sup =:= Pid ->
+	    error_msg("MGC received unexpected exit "
+		      "from UDP transport supervisor (~p):~n~p", 
+		      [Pid, Reason]),
+	    i("loop -> [udp] exiting", []),
+	    display_system_info(S#mgc.mid, "at bad finish (udp) "),
+	    cancel_timer(S#mgc.dsi_timer),
+  	    Mid = S#mgc.mid,
+	    (catch close_conns(Mid)),
+	    megaco:stop_user(Mid),
+	    application:stop(megaco),
+	    i("loop -> stopped", []),
+	    StopReason = {error, {udp_terminated, Pid, Reason}}, 
+	    server_reply(S#mgc.parent, stopped, StopReason),
+	    exit(StopReason);
+
+
+	Invalid ->
+	    i("loop -> received invalid request: ~p", [Invalid]),
+	    loop(S)
+    end.
+
+
+do_reset_stats(Mid) ->
+    megaco:reset_stats(),
+    do_reset_trans_stats(megaco:user_info(Mid, connections), []).
+
+do_reset_trans_stats([], _Reset) ->
+    ok;
+do_reset_trans_stats([CH|CHs], Reset) ->
+    SendMod = megaco:conn_info(CH, send_mod),
+    case lists:member(SendMod, Reset) of
+	true ->
+	    do_reset_trans_stats(CHs, Reset);
+	false ->
+	    SendMod:reset_stats(),
+	    do_reset_trans_stats(CHs, [SendMod|Reset])
+    end.
+	    
+
+close_conns(Mid) ->
+    Reason = {self(), ignore},
+    Disco  = fun(CH) ->
+		     (catch do_close_conn(CH, Reason))
+	     end,
+    lists:map(Disco, megaco:user_info(Mid, connections)).
+
+do_close_conn(CH, Reason) ->
+    d("close connection to ~p", [CH#megaco_conn_handle.remote_mid]),
+    Pid        = megaco:conn_info(CH, control_pid),
+    SendMod    = megaco:conn_info(CH, send_mod),
+    SendHandle = megaco:conn_info(CH, send_handle),
+    megaco:disconnect(CH, Reason),
+    case SendMod of
+	megaco_tcp -> megaco_tcp:close(SendHandle);
+	megaco_udp -> megaco_udp:close(SendHandle);
+	SendMod    -> exit(Pid, Reason)
+    end.
+    
+get_trans_stats(P, SendMod) when is_pid(P) ->
+    case (catch SendMod:get_stats()) of
+	{ok, Stats} ->
+	    {SendMod, Stats};
+	Else ->
+	    {SendMod, Else}
+    end;
+get_trans_stats(_P, SendMod) ->
+    {SendMod, undefined}.
+
+parse_receive_info([], _RH) ->
+    throw({error, no_receive_info});
+parse_receive_info(RI, RH) ->
+    parse_receive_info(RI, RH, []).
+
+parse_receive_info([], _RH, Transports) ->
+    d("parse_receive_info -> done when"
+      "~n   Transports: ~p", [Transports]),
+    Transports;
+parse_receive_info([RI|RIs], RH, Transports) ->
+    d("parse_receive_info -> parse receive info"),
+    case (catch parse_receive_info1(RI, RH)) of
+	{error, Reason} ->
+	    i("failed parsing receive info: ~p~n~p", [RI, Reason]),
+	    exit({failed_parsing_recv_info, RI, Reason});
+	RH1 ->
+	    parse_receive_info(RIs, RH, [RH1|Transports])
+    end.
+    
+parse_receive_info1(RI, RH) ->
+    d("parse_receive_info1 -> get encoding module"),
+    EM = get_encoding_module(RI),
+    d("parse_receive_info1 -> get encoding config"),
+    EC = get_encoding_config(RI, EM),
+    d("parse_receive_info1 -> get transport module"),
+    TM = get_transport_module(RI),
+    d("parse_receive_info1 -> get transport port"),
+    TP = get_transport_port(RI),
+    d("parse_receive_info1 -> get transport opts"),
+    TO = get_transport_opts(RI),
+    RH1 = RH#megaco_receive_handle{send_mod        = TM,
+				   encoding_mod    = EM,
+				   encoding_config = EC},
+    d("parse_receive_info1 -> "
+      "~n   Transport Opts: ~p"
+      "~n   Port:           ~p"
+      "~n   Receive handle: ~p", [TO, TP, RH1]),
+    {TO, TP, RH1}.
+
+
+
+%% --------------------------------------------------------
+%% On some platforms there seem to take some time before 
+%% a port is released by the OS (after having been used, 
+%% as is often the case in the test suites).
+%% So, starting the transports is done in two steps.
+%% First)  Start the actual transport(s)
+%% Second) Create the listener (tcp) or open the 
+%%         send/receive port (udp). 
+%% The second step *may* need to be repeated!
+%% --------------------------------------------------------
+start_transports([]) ->
+    throw({error, no_transport});
+start_transports(Transports) when is_list(Transports) ->
+    {Tcp, Udp} = start_transports1(Transports, undefined, undefined),
+    ok = start_transports2(Transports, Tcp, Udp),
+    {Tcp, Udp}.
+    
+start_transports1([], Tcp, Udp) ->
+    {Tcp, Udp};
+start_transports1([{_TO, _Port, RH}|Transports], Tcp, Udp) 
+  when ((RH#megaco_receive_handle.send_mod =:= megaco_tcp) andalso 
+	(not is_pid(Tcp)))  ->
+    case megaco_tcp:start_transport() of
+	{ok, Sup} ->
+	    start_transports1(Transports, Sup, Udp);
+	Else ->
+	    throw({error, {failed_starting_tcp_transport, Else}})
+    end;
+start_transports1([{_TO, _Port, RH}|Transports], Tcp, Udp) 
+  when ((RH#megaco_receive_handle.send_mod =:= megaco_udp) andalso 
+	(not is_pid(Udp))) ->
+    case megaco_udp:start_transport() of
+	{ok, Sup} ->
+	    start_transports1(Transports, Tcp, Sup);
+	Else ->
+	    throw({error, {failed_starting_udp_transport, Else}})
+    end;
+start_transports1([_|Transports], Tcp, Udp) ->
+    start_transports1(Transports, Tcp, Udp).
+
+start_transports2([], _, _) ->
+    ok;
+start_transports2([{TO, Port, RH}|Transports], Tcp, Udp) 
+  when RH#megaco_receive_handle.send_mod =:= megaco_tcp ->
+    start_tcp(TO, RH, Port, Tcp),
+    start_transports2(Transports, Tcp, Udp);
+start_transports2([{TO, Port, RH}|Transports], Tcp, Udp) 
+  when RH#megaco_receive_handle.send_mod =:= megaco_udp ->
+    start_udp(TO, RH, Port, Udp),
+    start_transports2(Transports, Tcp, Udp).
+
+start_tcp(TO, RH, Port, Sup) ->
+    d("start tcp transport"),
+    start_tcp(TO, RH, Port, Sup, 250).
+
+start_tcp(TO, RH, Port, Sup, Timeout) 
+  when is_pid(Sup) andalso is_integer(Timeout) andalso (Timeout > 0) ->
+    d("tcp listen on ~p", [Port]),
+    Opts = [{port,           Port}, 
+	    {receive_handle, RH}, 
+	    {tcp_options,    [{nodelay, true}]}] ++ TO,
+    try_start_tcp(Sup, Opts, Timeout, noError).
+
+try_start_tcp(Sup, Opts, Timeout, Error0) when (Timeout < 5000) ->
+    Sleep = random(Timeout) + 100,
+    d("try create tcp listen socket (~p,~p)", [Timeout, Sleep]),
+    case megaco_tcp:listen(Sup, Opts) of
+	ok ->
+	    d("listen socket created", []),
+	    Sup;
+	Error1 when Error0 =:= noError -> % Keep the first error
+	    d("failed creating listen socket [1]: ~p", [Error1]),
+	    sleep(Sleep),
+	    try_start_tcp(Sup, Opts, Timeout*2, Error1);
+	Error2 ->
+	    d("failed creating listen socket [2]: ~p", [Error2]),
+	    sleep(Sleep),
+	    try_start_tcp(Sup, Opts, Timeout*2, Error0)
+    end;
+try_start_tcp(Sup, _Opts, _Timeout, Error) ->
+    megaco_tcp:stop_transport(Sup),
+    case Error of
+	{error, Reason} ->
+	    throw({error, {failed_starting_tcp_listen, Reason}});
+	_ ->
+	    throw({error, {failed_starting_tcp_listen, Error}})
+    end.
+
+
+start_udp(TO, RH, Port, Sup) ->
+    d("start udp transport"),
+    start_udp(TO, RH, Port, Sup, 250).
+
+start_udp(TO, RH, Port, Sup, Timeout) ->
+    d("udp open ~p", [Port]),
+    Opts = [{port, Port}, {receive_handle, RH}] ++ TO,
+    try_start_udp(Sup, Opts, Timeout, noError).
+
+try_start_udp(Sup, Opts, Timeout, Error0) when (Timeout < 5000) ->
+    d("try open udp socket (~p)", [Timeout]),
+    case megaco_udp:open(Sup, Opts) of
+	{ok, _SendHandle, _ControlPid} ->
+	    d("port opened", []),
+	    Sup;
+	Error1 when Error0 =:= noError -> % Keep the first error
+	    d("failed open port [1]: ~p", [Error1]),
+	    sleep(Timeout),
+	    try_start_udp(Sup, Opts, Timeout*2, Error1);
+	Error2 ->
+	    d("failed open port [2]: ~p", [Error2]),
+	    sleep(Timeout),
+	    try_start_udp(Sup, Opts, Timeout*2, Error0)
+    end;
+try_start_udp(Sup, _Opts, _Timeout, Error) ->
+    megaco_udp:stop_transport(Sup),
+    throw({error, {failed_starting_udp_open, Error}}).
+
+
+%% -----------------------
+%% Handle megaco callbacks
+%%
+
+handle_megaco_request({handle_connect, CH, _PV}, #mgc{mg = MGs} = S) ->
+    case lists:member(CH, MGs) of
+	true ->
+	    i("MG already connected: ~n   ~p", [CH]),
+	    {error, S};
+	false ->
+	    {ok, S#mgc{mg = [CH|MGs]}}
+    end;
+
+handle_megaco_request({handle_disconnect, CH, _PV, R}, S) ->
+    d("handle_megaco_request(handle_disconnect) -> entry with"
+      "~n   CH: ~p"
+      "~n   R:  ~p", [CH, R]),
+    CancelRes = (catch megaco:cancel(CH, R)), % Cancel the outstanding messages
+    d("handle_megaco_request(handle_disconnect) -> megaco cancel result: ~p", [CancelRes]),
+    MGs = lists:delete(CH, S#mgc.mg),
+    d("handle_megaco_request(handle_disconnect) -> MGs: ~p", [MGs]),
+    {ok, S#mgc{mg = MGs}};
+
+handle_megaco_request({handle_syntax_error, _RH, _PV, _ED}, S) ->
+    {reply, S};
+
+handle_megaco_request({handle_message_error, _CH, _PV, _ED}, S) ->
+    {no_reply, S};
+
+handle_megaco_request({handle_trans_request, CH, PV, ARs}, 
+		      #mgc{req_info = P} = S) when is_pid(P) ->
+    d("handle_megaco_request(handle_trans_request,~p) -> entry", [P]),
+    P ! {req_received, self(), ARs},
+    do_handle_trans_request(CH, PV, ARs, S);
+handle_megaco_request({handle_trans_request, CH, PV, ARs}, S) ->
+    d("handle_megaco_request(handle_trans_request) -> entry"),
+    do_handle_trans_request(CH, PV, ARs, S);
+
+handle_megaco_request({handle_trans_long_request, CH, PV, RD}, S) ->
+    d("handle_megaco_request(handle_long_trans_request) -> entry"),
+    Reply0 = handle_act_requests(CH, PV, RD, discard_ack),
+    Reply  = 
+	case S of
+	    #mgc{req_action = ignore, req_timeout = To} ->
+		d("handle_megaco_request(handle_long_trans_request) -> "
+		  "~n   To: ~p", [To]),
+		{delay_reply, To, Reply0};
+	    _ ->
+		d("handle_megaco_request(handle_long_trans_request) -> "
+		  "~n   S: ~p", [S]),
+		Reply0
+	end,
+    {Reply, S};
+
+handle_megaco_request({handle_trans_reply, _CH, _PV, _AR, _RD}, S) ->
+    {ok, S};
+
+handle_megaco_request({handle_trans_ack, CH, PV, AS, AD}, 
+		      #mgc{ack_info = P} = S) when is_pid(P) ->
+    d("handle_megaco_request(handle_trans_ack,~p) -> entry when"
+      "~n   CH: ~p"
+      "~n   PV: ~p"
+      "~n   AS: ~p"
+      "~n   AD: ~p", [P, CH, PV, AS, AD]),
+    P ! {ack_received, self(), AS},
+    {ok, S};
+
+handle_megaco_request({handle_trans_ack, CH, PV, AS, AD}, S) ->
+    d("handle_megaco_request(handle_trans_ack) -> entry with"
+      "~n   CH: ~p"
+      "~n   PV: ~p"
+      "~n   AS: ~p"
+      "~n   AD: ~p", [CH, PV, AS, AD]),
+    {ok, S};
+
+handle_megaco_request({handle_unexpected_trans, CH, PV, TR}, S) ->
+    d("handle_megaco_request(handle_unexpected_trans) -> entry with"
+      "~n   CH: ~p"
+      "~n   PV: ~p"
+      "~n   TR: ~p", [CH, PV, TR]),
+    {ok, S};
+
+handle_megaco_request({handle_trans_request_abort, CH, PV, TI, Handler}, S) ->
+    d("handle_megaco_request(handle_trans_request_abort) -> entry with"
+      "~n   CH:      ~p"
+      "~n   PV:      ~p"
+      "~n   TI:      ~p"
+      "~n   Handler: ~p", [CH, PV, TI, Handler]),
+    Reply = 
+	case S#mgc.abort_info of
+	    P when is_pid(P) ->
+		P ! {abort_received, self(), TI},
+		ok;
+	    _ ->
+		ok
+	end,
+    {Reply, S}.
+
+
+do_handle_trans_request(CH, PV, ARs, 
+			#mgc{req_action = Action, req_timeout = To} = S) ->
+    d("do_handle_megaco_request(handle_trans_request) -> entry with"
+      "~n   Action: ~p"
+      "~n   To:     ~p", [Action, To]),
+    case handle_act_requests(CH, PV, ARs, Action) of
+	{pending_ignore, ActReqs} ->
+	    {{pending, ActReqs}, S#mgc{req_action = ignore}};
+	Reply ->
+	    {{delay_reply, To, Reply}, S}
+    end.
+
+
+handle_act_requests(_CH, _PV, _ActReqs, ignore) ->
+    ignore;
+handle_act_requests(_CH, _PV, ActReqs, pending) ->
+    {pending, ActReqs};
+handle_act_requests(_CH, _PV, ActReqs, pending_ignore) ->
+    {pending_ignore, ActReqs};
+handle_act_requests(CH, PV, ActReqs, handle_ack) ->
+    Reply = (catch do_handle_act_requests(CH, PV, ActReqs, [])),
+    {{handle_ack, ActReqs}, Reply};
+handle_act_requests(CH, PV, ActReqs, handle_sloppy_ack) ->
+    Reply = (catch do_handle_act_requests(CH, PV, ActReqs, [])),
+    {{handle_sloppy_ack, ActReqs}, Reply};
+handle_act_requests(CH, PV, ActReqs, _) ->
+    Reply = (catch do_handle_act_requests(CH, PV, ActReqs, [])),
+    {discard_ack, Reply}.
+
+do_handle_act_requests(_CH, _PV, [], ActReplies) ->
+    lists:reverse(ActReplies);
+do_handle_act_requests(CH, PV, [ActReq|ActReqs], ActReplies) ->
+    ActReply = handle_act_request(CH, PV, ActReq),
+    do_handle_act_requests(CH, PV, ActReqs, [ActReply|ActReplies]).
+    
+handle_act_request(CH, PV, ActReq) ->
+    #'ActionRequest'{contextId = CtxId, commandRequests = Cmds} = ActReq,
+    CmdReplies = handle_cmd_requests(CH, PV, CtxId, Cmds),
+    #'ActionReply'{contextId    = CtxId,
+		   commandReply = CmdReplies}.
+
+handle_cmd_requests(CH, PV, ?megaco_null_context_id, 
+			[#'CommandRequest'{command={serviceChangeReq,Req}}]) ->
+    Rep = service_change(CH, PV, Req),
+    [{serviceChangeReply, Rep}];
+handle_cmd_requests(CH, PV, CtxId, Cmds) ->
+    do_handle_cmd_requests(CH, PV, CtxId, Cmds, []).
+
+do_handle_cmd_requests(_CH, _PV, _CtxId, [], CmdReplies) ->
+    lists:reverse(CmdReplies);
+do_handle_cmd_requests(CH, PV, CtxId, [Cmd|Cmds], CmdReplies) ->
+    CmdReply = handle_cmd_request(CH, PV, CtxId, Cmd),
+    do_handle_cmd_requests(CH, PV, CtxId, Cmds, [CmdReply|CmdReplies]).
+
+handle_cmd_request(CH, PV, CtxId, 
+		       #'CommandRequest'{command = {Tag,Req}}) ->
+    case Tag of
+        notifyReq ->
+            (catch handle_notify_req(CH,PV,CtxId,Req));
+
+        serviceChangeReq ->
+	    ED =  cre_error_descr(?megaco_not_implemented,
+				  "Service change only allowed "
+				  "on null context handled"),
+	    throw(ED);
+
+        _ ->
+            Code = ?megaco_not_implemented,
+            ED   = cre_error_descr(Code,"Unknown command requst received:"
+                                   "~n   Tag: ~p~n   Req: ~p",[Tag,Req]),
+            throw(ED)
+    end.
+
+handle_notify_req(CH, PV, CtxId, 
+		      #'NotifyRequest'{terminationID            = [Tid],
+				       observedEventsDescriptor = EvDesc}) ->
+    handle_event(CH, PV, CtxId, Tid, EvDesc).
+
+handle_event(_CH, _PV, _Cid, Tid, EvDesc) ->
+    d("handle_event -> received"
+      "~n   EvDesc: ~p"
+      "~n   Tid:    ~p", [EvDesc, Tid]),
+    {notifyReply, cre_notifyRep(Tid)}.
+    
+
+service_change(CH, _PV, SCR) ->
+    SCP = SCR#'ServiceChangeRequest'.serviceChangeParms,
+    #'ServiceChangeParm'{serviceChangeAddress = Address,
+                         serviceChangeProfile = Profile,
+                         serviceChangeReason  = [_Reason]} = SCP,
+    TermId = SCR#'ServiceChangeRequest'.terminationID,
+    if
+        TermId == [?megaco_root_termination_id] ->
+            MyMid = CH#megaco_conn_handle.local_mid,
+            Res = {serviceChangeResParms,
+		   cre_serviceChangeResParms(MyMid, Address, Profile)},
+            cre_serviceChangeReply(TermId, Res);
+        true ->
+            Res = {errorDescriptor,
+                   cre_error_descr(?megaco_not_implemented,
+				   "Only handled for root")},
+            cre_serviceChangeReply(TermId, Res)
+    end.
+
+    
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+ 
+cre_serviceChangeReply(TermId, Result) ->
+    #'ServiceChangeReply'{terminationID       = TermId,
+			  serviceChangeResult = Result}.
+
+cre_serviceChangeResParms(Mid, Addr, Prof) ->
+    #'ServiceChangeResParm'{serviceChangeMgcId   = Mid,
+			    serviceChangeAddress = Addr,
+			    serviceChangeProfile = Prof}.
+
+
+cre_notifyRep(Tid) ->
+    #'NotifyReply'{terminationID = [Tid]}.
+
+% cre_notifyRep(Tid,Err) ->
+%     #'NotifyReply'{terminationID = [Tid], errorDescriptor = Err}.
+
+cre_error_descr(Code,Text) ->
+    #'ErrorDescriptor'{errorCode = Code, errorText = Text}.
+
+cre_error_descr(Code,FormatString,Args) ->
+    Text = lists:flatten(io_lib:format(FormatString,Args)),
+    cre_error_descr(Code,Text).
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+notify_started(Parent) ->
+    Parent ! {started, self()}.
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+%% The megaco user callback interface 
+
+handle_connect(CH, PV, Pid) ->
+    case CH#megaco_conn_handle.remote_mid of
+        preliminary_mid ->
+	    %% Avoids deadlock
+	    ok;
+	_ ->
+	    Reply = request(Pid, {handle_connect, CH, PV}),
+	    Reply
+    end.
+
+handle_disconnect(_CH, _PV, 
+		  {user_disconnect, {Pid, ignore}}, 
+		  Pid) ->
+    ok;
+handle_disconnect(CH, _PV, 
+		  {user_disconnect, {Pid, cancel}}, 
+		  Pid) ->
+    megaco:cancel(CH, disconnected),
+    ok;
+handle_disconnect(CH, PV, R, Pid) ->
+    request(Pid, {handle_disconnect, CH, PV, R}).
+
+handle_syntax_error(ReceiveHandle, ProtocolVersion, ErrorDescriptor, Pid) ->
+    Req = {handle_syntax_error, ReceiveHandle, ProtocolVersion, 
+	   ErrorDescriptor},
+    request(Pid, Req).
+    
+handle_message_error(ConnHandle, ProtocolVersion, ErrorDescriptor, Pid) ->
+    Req = {handle_message_error, ConnHandle, ProtocolVersion, ErrorDescriptor},
+    request(Pid, Req).
+
+handle_trans_request(CH, PV, AR, Pid) ->
+    Reply = request(Pid, {handle_trans_request, CH, PV, AR}),
+    Reply.
+
+handle_trans_long_request(ConnHandle, ProtocolVersion, ReqData, Pid) ->
+    Req = {handle_trans_long_request, ConnHandle, ProtocolVersion, ReqData},
+    request(Pid, Req).
+
+handle_trans_reply(ConnHandle, ProtocolVersion, ActualReply, ReplyData, Pid) ->
+    Req = {handle_trans_reply, ConnHandle, ProtocolVersion, 
+	   ActualReply, ReplyData},
+    request(Pid, Req).
+
+handle_trans_ack(ConnHandle, ProtocolVersion, AckStatus, AckData, Pid) ->
+    Req = {handle_trans_ack, ConnHandle, ProtocolVersion, AckStatus, AckData},
+    request(Pid, Req).
+
+handle_unexpected_trans(ConnHandle, ProtocolVersion, Trans, Pid) ->
+    Req = {handle_unexpected_trans, ConnHandle, ProtocolVersion, Trans},
+    request(Pid, Req).
+
+handle_trans_request_abort(ConnHandle, ProtocolVersion, TransId, 
+			   Handler, Pid) ->
+    Req = {handle_trans_request_abort, 
+	   ConnHandle, ProtocolVersion, TransId, Handler},
+    request(Pid, Req).
+
+
+request(Pid, Request) ->
+    Pid ! {request, Request, self()},
+    receive
+	{reply, {delay_reply, To, Reply}, Pid} ->
+	    megaco:report_event(ignore, self(), Pid, 
+				"reply: delay_reply", [To, Reply]),
+	    sleep(To),
+	    megaco:report_event(ignore, self(), Pid, 
+				"reply: delay done now return", []),
+	    Reply;
+	{reply, {exit, To, Reason}, Pid} ->
+	    megaco:report_event(ignore, self(), Pid, 
+				"reply: exit", [To, Reason]),
+	    sleep(To),
+	    megaco:report_event(ignore, self(), Pid, 
+				"reply: sleep done now exit", []),
+	    exit(Reason);
+	{reply, Reply, Pid} ->
+	    megaco:report_event(ignore, self(), Pid, "reply", [Reply]),
+	    Reply
+    end.
+
+
+reply(To, Reply) ->
+    To ! {reply, Reply, self()}.
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+sleep(X) ->
+    d("sleep -> ~w", [X]),
+    receive after X -> ok end.
+
+
+error_msg(F,A) -> error_logger:error_msg("MGC: " ++ F ++ "~n",A).
+
+
+get_encoding_module(RI) ->
+    case (catch get_conf(encoding_module, RI)) of
+	{error, _} ->
+	    undefined;
+	Val ->
+	    Val
+    end.
+
+get_encoding_config(RI, EM) ->
+    case text_codec(EM) of
+	true ->
+	    case megaco:system_info(text_config) of
+		[Conf] when is_list(Conf) ->
+		    Conf;
+		_ ->
+		    []
+	    end;
+
+	false ->
+	    get_conf(encoding_config, RI)
+    end.
+
+text_codec(megaco_compact_text_encoder) ->
+    true;
+text_codec(megaco_pretty_text_encoder) ->
+    true;
+text_codec(_) ->
+    false.
+
+
+get_transport_module(RI) ->
+    get_conf(transport_module, RI).
+
+get_transport_port(RI) ->
+    get_conf(port, RI).
+
+get_transport_opts(RI) ->
+    get_conf(transport_opts, RI, []).
+
+
+get_conf(Key, Config) ->
+    case lists:keysearch(Key, 1, Config) of
+	{value, {Key, Val}} ->
+	    Val;
+	_ ->
+	    exit({error, {not_found, Key, Config}})
+    end.
+
+get_conf(Key, Config, Default) ->
+    case lists:keysearch(Key, 1, Config) of
+	{value, {Key, Val}} ->
+	    Val;
+	_ ->
+	    Default
+    end.
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+random_init() ->
+    {A,B,C} = now(),
+    random:seed(A,B,C).
+
+random(N) ->
+    random:uniform(N).
+
+
+display_system_info(Mid) ->
+    display_system_info(Mid, "").
+
+display_system_info(Mid, Pre) ->
+    TimeStr = format_timestamp(now()),
+    MibStr  = lists:flatten(io_lib:format("~p ", [Mid])), 
+    megaco_test_lib:display_system_info(MibStr ++ Pre ++ TimeStr).
+
+
+create_timer(Time, Event) ->
+    erlang:send_after(Time, self(), {Event, Time}).
+
+cancel_timer(undefined) ->
+    ok;
+cancel_timer(Ref) ->
+    erlang:cancel_timer(Ref).
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+i(F) ->
+    i(F, []).
+
+i(F, A) ->
+    print(info, get(verbosity), "", F, A).
+
+
+d(F) ->
+    d(F, []).
+
+d(F, A) ->
+    print(debug, get(verbosity), "DBG: ", F, A).
+
+
+printable(_, debug)   -> true;
+printable(info, info) -> true;
+printable(_,_)        -> false.
+
+print(Severity, Verbosity, P, F, A) ->
+    print(printable(Severity,Verbosity), P, F, A).
+
+print(true, P, F, A) ->
+    print(P, F, A);
+print(_, _, _, _) ->
+    ok.
+
+print(P, F, A) ->
+    io:format("*** [~s] ~s ~p ~s ***"
+	      "~n   " ++ F ++ "~n~n", 
+	      [format_timestamp(now()), P, self(), get(sname) | A]).
+
+format_timestamp({_N1, _N2, N3} = Now) ->
+    {Date, Time}   = calendar:now_to_datetime(Now),
+    {YYYY,MM,DD}   = Date,
+    {Hour,Min,Sec} = Time,
+    FormatDate = 
+        io_lib:format("~.4w:~.2.0w:~.2.0w ~.2.0w:~.2.0w:~.2.0w 4~w",
+                      [YYYY,MM,DD,Hour,Min,Sec,round(N3/1000)]),  
+    lists:flatten(FormatDate).
+