%%
%% %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: Misc functions used both from the megaco_messenger module
%% and the megaco_ack_sender module.
%%
%%----------------------------------------------------------------------
-module(megaco_messenger_misc).
%% Application internal export
-export([encode_body/3,
encode_trans_request/2,
encode_trans_reply/2,
encode_actions/3,
send_body/3,
send_message/3,
transform_transaction_reply/2
]).
%% Test functions
-export([compose_message/3, encode_message/2]).
-include_lib("megaco/include/megaco.hrl").
-include("megaco_message_internal.hrl").
-include_lib("megaco/src/app/megaco_internal.hrl").
-define(MSG_HDR_SZ, 128). % This is just a guess...
-ifdef(MEGACO_TEST_CODE).
-define(SIM(Other,Where),
fun(Afun,Bfun) ->
Kfun = {?MODULE,Bfun},
case (catch ets:lookup(megaco_test_data, Kfun)) of
[{Kfun,Cfun}] ->
Cfun(Afun);
_ ->
Afun
end
end(Other,Where)).
-define(TC_AWAIT_SEND_EVENT(SendFunction),
case megaco_tc_controller:lookup(send_function) of
{value, {Tag, Pid}} when is_pid(Pid) ->
Pid ! {Tag, self(), SendFuncion},
receive
{Tag, Pid} ->
ok
end;
_ ->
ok
end).
-else.
-define(SIM(Other,Where),Other).
-define(TC_AWAIT_SEND_EVENT(_),ok).
-endif.
%%----------------------------------------------------------------------
%% Encode the transaction request
%%----------------------------------------------------------------------
encode_trans_request(CD, TR) when is_record(TR, 'TransactionRequest') ->
?report_debug(CD, "encode trans request", [TR]),
Trans = {transactionRequest, TR},
encode_transaction(CD, Trans).
encode_trans_reply(#conn_data{segment_send = SegSend,
max_pdu_size = Max,
protocol_version = V} = CD, Reply)
when (SegSend == infinity) or (is_integer(SegSend) and (SegSend > 0)) and
is_integer(V) and (V >= 3) and
is_integer(Max) and (Max >= ?MSG_HDR_SZ) ->
(catch encode_segmented_trans_reply(CD, Reply));
encode_trans_reply(CD, TR) when is_record(TR, megaco_transaction_reply) ->
?report_debug(CD, "encode trans reply", [TR]),
Trans = {transactionReply, transform_transaction_reply(CD, TR)},
encode_transaction(CD, Trans);
encode_trans_reply(CD, TR) when is_tuple(TR) and
(element(1, TR) == 'TransactionReply') ->
?report_debug(CD, "encode trans reply", [TR]),
Trans = {transactionReply, TR},
encode_transaction(CD, Trans).
encode_segmented_trans_reply(#conn_data{max_pdu_size = Max} = CD, Rep) ->
#megaco_transaction_reply{transactionResult = Res1} = Rep,
case Res1 of
{actionReplies, AR} when is_list(AR) andalso (length(AR) >= 1) ->
case encode_action_replies(CD, AR) of
{Size, EncodedARs} when Size =< (Max - ?MSG_HDR_SZ) ->
?report_debug(CD, "action replies encoded size ok",
[Size, Max]),
%% No need to segment message: within size limit
Res2 = {actionReplies, EncodedARs},
TR = Rep#megaco_transaction_reply{transactionResult = Res2},
TR2 = transform_transaction_reply(CD, TR),
Trans = {transactionReply, TR2},
encode_transaction(CD, Trans);
{Size, EncodecARs} ->
?report_debug(CD,
"action replies encoded size to large - "
"segment",
[Size, Max]),
%% Over size limit, so go segment the message
encode_segments(CD, Rep, EncodecARs)
end;
_ ->
TR = transform_transaction_reply(CD, Rep),
Trans = {transactionReply, TR},
encode_transaction(CD, Trans)
end.
encode_segments(CD, Reply, EncodecARs) ->
encode_segments(CD, Reply, EncodecARs, 1, []).
encode_segments(CD, Reply, [EncodedAR], SN, EncodedSegs) ->
Bin = encode_segment(CD, Reply, EncodedAR, SN, 'NULL'),
{ok, lists:reverse([{SN, Bin}|EncodedSegs])};
encode_segments(CD, Reply, [EncodedAR|EncodedARs], SN, EncodedSegs) ->
Bin = encode_segment(CD, Reply, EncodedAR, SN, asn1_NOVALUE),
encode_segments(CD, Reply, EncodedARs, SN + 1, [{SN, Bin}|EncodedSegs]).
encode_segment(CD, Reply, EncodedAR, SN, SC) ->
Res = {actionReplies, [EncodedAR]},
TR0 = Reply#megaco_transaction_reply{transactionResult = Res,
segmentNumber = SN,
segmentationComplete = SC},
TR = transform_transaction_reply(CD, TR0),
Trans = {transactionReply, TR},
case encode_transaction(CD, Trans) of
{ok, Bin} ->
Bin;
Error ->
throw(Error)
end.
encode_transaction(#conn_data{protocol_version = V,
encoding_mod = EM,
encoding_config = EC} = CD, Trans) ->
case (catch EM:encode_transaction(EC, V, Trans)) of
{ok, Bin} ->
?SIM({ok, Bin}, encode_trans);
{'EXIT', {undef, _}} ->
{error, not_implemented};
{error, not_implemented} = Error1 ->
Error1;
{error, Reason} ->
incNumErrors(CD#conn_data.conn_handle),
{error, {EM, encode_transaction, [EC, V, Trans], Reason}};
Error2 ->
incNumErrors(CD#conn_data.conn_handle),
{error, {EM, encode_transaction, [EC, V, Trans], Error2}}
end.
%%----------------------------------------------------------------------
%% Encode the action request's
%%----------------------------------------------------------------------
encode_actions(#conn_data{protocol_version = V} = CD, TraceLabel, ARs) ->
?report_debug(CD, TraceLabel, [ARs]),
%% Encode the actions
EM = CD#conn_data.encoding_mod,
EC = CD#conn_data.encoding_config,
case (catch EM:encode_action_requests(EC, V, ARs)) of
{ok, Bin} when is_binary(Bin) ->
?SIM({ok, Bin}, encode_actions);
{'EXIT', {undef, _}} ->
incNumErrors(CD#conn_data.conn_handle),
Reason = not_implemented,
{error, {EM, encode_action_requests, [EC, ARs], Reason}};
{error, Reason} ->
incNumErrors(CD#conn_data.conn_handle),
{error, {EM, encode_action_requests, [EC, ARs], Reason}};
Error ->
incNumErrors(CD#conn_data.conn_handle),
{error, {EM, encode_action_requests, [EC, ARs], Error}}
end.
%%----------------------------------------------------------------------
%% Encode the action reply's
%%----------------------------------------------------------------------
encode_action_replies(CD, AR) ->
encode_action_replies(CD, AR, 0, []).
encode_action_replies(_, [], Size, Acc) ->
{Size, lists:reverse(Acc)};
encode_action_replies(#conn_data{protocol_version = V,
encoding_mod = Mod,
encoding_config = Conf} = CD,
[AR|ARs], Size, Acc) ->
case (catch Mod:encode_action_reply(Conf, V, AR)) of
{ok, Bin} when is_binary(Bin) ->
encode_action_replies(CD, ARs, Size + size(Bin), [Bin|Acc]);
{'EXIT', {undef, _}} ->
throw({error, not_implemented});
{error, not_implemented} = Error1 ->
throw(Error1);
{error, Reason} ->
incNumErrors(CD#conn_data.conn_handle),
throw({error, {Mod, encode_action_reply, [Conf, AR], Reason}});
Error ->
incNumErrors(CD#conn_data.conn_handle),
throw({error, {Mod, encode_action_reply, [Conf, AR], Error}})
end.
%%----------------------------------------------------------------------
%% Encode the message body
%%----------------------------------------------------------------------
encode_body(#conn_data{protocol_version = V} = ConnData,
TraceLabel, Body) ->
%% Create the message envelope
MegaMsg = compose_message(ConnData, V, Body),
?report_debug(ConnData, TraceLabel, [MegaMsg]),
%% Encode the message
EM = ConnData#conn_data.encoding_mod,
EC = ConnData#conn_data.encoding_config,
case (catch EM:encode_message(EC, V, MegaMsg)) of
{ok, Bin} when is_binary(Bin) ->
?SIM({ok, Bin}, encode_body);
{error, Reason} ->
incNumErrors(ConnData#conn_data.conn_handle),
{error, {EM, [EC, MegaMsg], Reason}};
Error ->
incNumErrors(ConnData#conn_data.conn_handle),
{error, {EM, [EC, MegaMsg], Error}}
end.
%%----------------------------------------------------------------------
%% Compose and encode a message
%%----------------------------------------------------------------------
compose_message(#conn_data{conn_handle = CH,
auth_data = MsgAuth}, V, Body) ->
LocalMid = CH#megaco_conn_handle.local_mid,
Msg = #'Message'{version = V,
mId = LocalMid,
messageBody = Body},
MegaMsg = #'MegacoMessage'{authHeader = MsgAuth, % BUGBUG: Compute?
mess = Msg},
MegaMsg.
encode_message(#conn_data{protocol_version = Version,
encoding_mod = EncodingMod,
encoding_config = EncodingConfig}, MegaMsg) ->
(catch EncodingMod:encode_message(EncodingConfig, Version, MegaMsg)).
%%----------------------------------------------------------------------
%% Send the message body
%%----------------------------------------------------------------------
send_body(ConnData, TraceLabel, Body) ->
case encode_body(ConnData, TraceLabel, Body) of
{ok, Bin} ->
send_message(ConnData, false, Bin);
{error, Reason} ->
{error, Reason}
end.
%%----------------------------------------------------------------------
%% Send the (encoded) message
%%----------------------------------------------------------------------
send_message(#conn_data{resend_indication = flag} = ConnData,
Resend, Bin) ->
do_send_message(ConnData, send_message, Bin, [Resend]);
send_message(#conn_data{resend_indication = true} = ConnData,
true, Bin) ->
do_send_message(ConnData, resend_message, Bin, []);
send_message(ConnData, _Resend, Bin) ->
do_send_message(ConnData, send_message, Bin, []).
do_send_message(ConnData, SendFunc, Bin, Extra) ->
%% Send the message
#conn_data{send_mod = SendMod,
send_handle = SendHandle} = ConnData,
?TC_AWAIT_SEND_EVENT(SendFunc),
?report_trace(ConnData, "send bytes", [{bytes, Bin},
{send_func, SendFunc}]),
Args = [SendHandle, Bin | Extra],
case (catch apply(SendMod, SendFunc, Args)) of
ok ->
?SIM({ok, Bin}, send_message);
{cancel, Reason} ->
?report_trace(ConnData, "<CANCEL> send_message callback",
[{bytes, Bin}, {cancel, Reason}]),
{error, {send_message_cancelled, Reason}};
{error, Reason} ->
incNumErrors(ConnData#conn_data.conn_handle),
?report_important(ConnData, "<ERROR> send_message callback",
[{bytes, Bin}, {error, Reason}]),
error_msg("failed (error) sending message [using ~w] (~p):"
"~n~w", [SendFunc, SendHandle, Reason]),
{error, {send_message_failed, Reason}};
{'EXIT', Reason} = Error ->
incNumErrors(ConnData#conn_data.conn_handle),
?report_important(ConnData, "<ERROR> send_message callback",
[{bytes, Bin}, {exit, Reason}]),
error_msg("failed (exit) sending message [using ~w] (~p):"
"~n~w", [SendFunc, SendHandle, Reason]),
{error, {send_message_failed, Error}};
Reason ->
incNumErrors(ConnData#conn_data.conn_handle),
?report_important(ConnData, "<ERROR> send_message callback",
[{bytes, Bin}, {error, Reason}]),
error_msg("failed sending message [using ~w] on (~p): "
"~n~w", [SendFunc, SendHandle, Reason]),
{error, {send_message_failed, Reason}}
end.
%%%-----------------------------------------------------------------
%%% Misc internal util functions
%%%-----------------------------------------------------------------
transform_transaction_reply(#conn_data{protocol_version = V}, TR)
when is_integer(V) and (V >= 3) ->
#megaco_transaction_reply{transactionId = TransId,
immAckRequired = IAR,
transactionResult = TransRes,
segmentNumber = SegNo,
segmentationComplete = SegComplete} = TR,
{'TransactionReply', TransId, IAR, TransRes, SegNo, SegComplete};
transform_transaction_reply(_, TR) ->
#megaco_transaction_reply{transactionId = TransId,
immAckRequired = IAR,
transactionResult = TransRes} = TR,
{'TransactionReply', TransId, IAR, TransRes}.
%%-----------------------------------------------------------------
%% Func: error_msg/2
%% Description: Send an error message
%%-----------------------------------------------------------------
error_msg(F, A) ->
?megaco_error(F, A).
%%-----------------------------------------------------------------
%% Func: incNumErrors/0, incNumErrors/1, incNumTimerRecovery/1
%% Description: SNMP counter increment functions
%%-----------------------------------------------------------------
incNumErrors(CH) ->
incNum({CH, medGwyGatewayNumErrors}).
incNum(Cnt) ->
case (catch ets:update_counter(megaco_stats, Cnt, 1)) of
{'EXIT', {badarg, _R}} ->
ets:insert(megaco_stats, {Cnt, 1});
Old ->
Old
end.
%% p(F, A) ->
%% print(now(), F, A).
%% print(Ts, F, A) ->
%% io:format("*** [~s] ~p ***"
%% "~n " ++ F ++ "~n",
%% [format_timestamp(Ts), self() | A]).
%% format_timestamp(Now) ->
%% {_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).
