diff options
Diffstat (limited to 'lib/megaco/src/engine/megaco_config.erl')
| -rw-r--r-- | lib/megaco/src/engine/megaco_config.erl | 2113 |
1 files changed, 2113 insertions, 0 deletions
diff --git a/lib/megaco/src/engine/megaco_config.erl b/lib/megaco/src/engine/megaco_config.erl new file mode 100644 index 0000000000..2058c53973 --- /dev/null +++ b/lib/megaco/src/engine/megaco_config.erl @@ -0,0 +1,2113 @@ +%% +%% %CopyrightBegin% +%% +%% Copyright Ericsson AB 2000-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: Handle configuration of Megaco/H.248 +%%---------------------------------------------------------------------- + +-module(megaco_config). + +-behaviour(gen_server). + +%% Application internal exports +-export([ + start_link/0, + stop/0, + + start_user/2, + stop_user/1, + + user_info/2, + update_user_info/3, + conn_info/2, + update_conn_info/3, + system_info/1, + + %% incr_counter/2, + incr_trans_id_counter/1, + incr_trans_id_counter/2, + + %% Verification functions + verify_val/2, + verify_strict_uint/1, + verify_strict_int/1, verify_strict_int/2, + verify_uint/1, + verify_int/1, verify_int/2, + + + %% Reply limit counter + cre_reply_counter/2, + get_reply_counter/2, + incr_reply_counter/2, + del_reply_counter/2, + + %% Pending limit counter + cre_pending_counter/3, + get_pending_counter/2, + incr_pending_counter/2, + del_pending_counter/2, + %% Backward compatibillity functions (to be removed in later versions) + cre_pending_counter/1, + get_pending_counter/1, + incr_pending_counter/1, + del_pending_counter/1, + + lookup_local_conn/1, + connect/4, finish_connect/4, + autoconnect/4, + disconnect/1, + connect_remote/3, + disconnect_remote/2, + init_conn_data/4, + + trans_sender_exit/2 + + ]). + + +%% gen_server callbacks +-export([init/1, handle_call/3, handle_cast/2, handle_info/2, + terminate/2, code_change/3]). + +-define(SERVER, ?MODULE). +-record(state, {parent_pid}). + +-include_lib("megaco/include/megaco.hrl"). +-include_lib("megaco/src/app/megaco_internal.hrl"). + + +-ifdef(MEGACO_TEST_CODE). +-define(megaco_test_init(), + (catch ets:new(megaco_test_data, [set, public, named_table]))). +-else. +-define(megaco_test_init(), + ok). +-endif. + +-define(TID_CNT(LMID), {LMID, trans_id_counter}). + + +%%%---------------------------------------------------------------------- +%%% API +%%%---------------------------------------------------------------------- + +start_link() -> + ?d("start_link -> entry", []), + gen_server:start_link({local, ?SERVER}, ?MODULE, [self()], []). + +stop() -> + ?d("stop -> entry", []), + call({stop, self()}). + +start_user(UserMid, Config) -> + call({start_user, UserMid, Config}). + +stop_user(UserMid) -> + call({stop_user, UserMid}). + +user_info(UserMid, all) -> + All0 = ets:match_object(megaco_config, {{UserMid, '_'}, '_'}), + All1 = [{Item, Val} || {{_, Item}, Val} <- All0, Item /= trans_sender], + case lists:keysearch(trans_id_counter, 1, All1) of + {value, {_, Val}} -> + lists:keyreplace(trans_id_counter, 1, All1, {trans_id, Val}); + false when UserMid /= default -> + [{trans_id, undefined_serial}|All1]; + false -> + All1 + end; +user_info(UserMid, receive_handle) -> + case call({receive_handle, UserMid}) of + {ok, RH} -> + RH; + {error, Reason} -> + exit(Reason) + end; +user_info(UserMid, conn_data) -> + HandlePat = #megaco_conn_handle{local_mid = UserMid, remote_mid = '_'}, + Pat = #conn_data{conn_handle = HandlePat, + serial = '_', + max_serial = '_', + request_timer = '_', + long_request_timer = '_', + + auto_ack = '_', + + trans_ack = '_', + trans_ack_maxcount = '_', + + trans_req = '_', + trans_req_maxcount = '_', + trans_req_maxsize = '_', + + trans_timer = '_', + trans_sender = '_', + + pending_timer = '_', + sent_pending_limit = '_', + recv_pending_limit = '_', + reply_timer = '_', + control_pid = '_', + monitor_ref = '_', + send_mod = '_', + send_handle = '_', + encoding_mod = '_', + encoding_config = '_', + protocol_version = '_', + auth_data = '_', + user_mod = '_', + user_args = '_', + reply_action = '_', + reply_data = '_', + threaded = '_', + strict_version = '_', + long_request_resend = '_', + call_proxy_gc_timeout = '_', + cancel = '_', + resend_indication = '_', + segment_reply_ind = '_', + segment_recv_acc = '_', + segment_recv_timer = '_', + segment_send = '_', + segment_send_timer = '_', + max_pdu_size = '_', + request_keep_alive_timeout = '_' + }, + %% ok = io:format("PATTERN: ~p~n", [Pat]), + ets:match_object(megaco_local_conn, Pat); +user_info(UserMid, connections) -> + [C#conn_data.conn_handle || C <- user_info(UserMid, conn_data)]; +user_info(UserMid, mid) -> + ets:lookup_element(megaco_config, {UserMid, mid}, 2); +user_info(UserMid, orig_pending_limit) -> + user_info(UserMid, sent_pending_limit); +user_info(UserMid, trans_id) -> + case (catch user_info(UserMid, trans_id_counter)) of + {'EXIT', _} -> + %% There is only two cases where this can occure: + %% 1) The user does not exist + %% 2) Called before the first message is sent, use + %% undefined_serial, since there is no + %% "current transaction id" + case (catch user_info(UserMid, mid)) of + {'EXIT', _} -> + %% case 1: + exit({no_such_user, UserMid}); + _ -> + undefined_serial + end; + Else -> + Else + end; +user_info(UserMid, Item) -> + ets:lookup_element(megaco_config, {UserMid, Item}, 2). + +update_user_info(UserMid, orig_pending_limit, Val) -> + update_user_info(UserMid, sent_pending_limit, Val); +update_user_info(UserMid, Item, Val) -> + call({update_user_info, UserMid, Item, Val}). + +conn_info(CH, Item) + when is_record(CH, megaco_conn_handle) andalso (Item /= cancel) -> + case Item of + conn_handle -> + CH; + mid -> + CH#megaco_conn_handle.local_mid; + local_mid -> + CH#megaco_conn_handle.local_mid; + remote_mid -> + CH#megaco_conn_handle.remote_mid; + conn_data -> + case lookup_local_conn(CH) of + [] -> + exit({no_such_connection, CH}); + [ConnData] -> + ConnData + end; + _ -> + case lookup_local_conn(CH) of + [] -> + exit({no_such_connection, CH}); + [ConnData] -> + conn_info(ConnData, Item) + end + end; +conn_info(#conn_data{conn_handle = CH}, cancel) -> + %% To minimise raise-condition propabillity, + %% we always look in the table instead of + %% in the record for this one + ets:lookup_element(megaco_local_conn, CH, #conn_data.cancel); + +conn_info(CD, Item) when is_record(CD, conn_data) -> + case Item of + all -> + Tags0 = record_info(fields, conn_data), + Tags1 = replace(serial, trans_id, Tags0), + Tags = [mid, local_mid, remote_mid] ++ + replace(max_serial, max_trans_id, Tags1), + [{Tag, conn_info(CD,Tag)} || Tag <- Tags, + Tag /= conn_data, + Tag /= trans_sender, + Tag /= cancel]; + conn_data -> CD; + conn_handle -> CD#conn_data.conn_handle; + mid -> (CD#conn_data.conn_handle)#megaco_conn_handle.local_mid; + local_mid -> (CD#conn_data.conn_handle)#megaco_conn_handle.local_mid; + remote_mid -> (CD#conn_data.conn_handle)#megaco_conn_handle.remote_mid; + trans_id -> CH = CD#conn_data.conn_handle, + LocalMid = CH#megaco_conn_handle.local_mid, + Item2 = {LocalMid, trans_id_counter}, + case (catch ets:lookup(megaco_config, Item2)) of + {'EXIT', _} -> + undefined_serial; + [] -> + user_info(LocalMid, min_trans_id); + [{_, Serial}] -> + Max = CD#conn_data.max_serial, + if + ((Max =:= infinity) andalso + is_integer(Serial) andalso + (Serial < 4294967295)) -> + Serial + 1; + (Max =:= infinity) andalso + is_integer(Serial) andalso + (Serial =:= 4294967295) -> + user_info(LocalMid, + min_trans_id); + Serial < Max -> + Serial + 1; + Serial =:= Max -> + user_info(LocalMid, + min_trans_id); + Serial =:= 4294967295 -> + user_info(LocalMid, + min_trans_id); + true -> + undefined_serial + end + end; + max_trans_id -> CD#conn_data.max_serial; + request_timer -> CD#conn_data.request_timer; + long_request_timer -> CD#conn_data.long_request_timer; + + auto_ack -> CD#conn_data.auto_ack; + + trans_ack -> CD#conn_data.trans_ack; + trans_ack_maxcount -> CD#conn_data.trans_ack_maxcount; + + trans_req -> CD#conn_data.trans_req; + trans_req_maxcount -> CD#conn_data.trans_req_maxcount; + trans_req_maxsize -> CD#conn_data.trans_req_maxsize; + + trans_timer -> CD#conn_data.trans_timer; + + pending_timer -> CD#conn_data.pending_timer; + orig_pending_limit -> CD#conn_data.sent_pending_limit; + sent_pending_limit -> CD#conn_data.sent_pending_limit; + recv_pending_limit -> CD#conn_data.recv_pending_limit; + reply_timer -> CD#conn_data.reply_timer; + control_pid -> CD#conn_data.control_pid; + monitor_ref -> CD#conn_data.monitor_ref; + send_mod -> CD#conn_data.send_mod; + send_handle -> CD#conn_data.send_handle; + encoding_mod -> CD#conn_data.encoding_mod; + encoding_config -> CD#conn_data.encoding_config; + protocol_version -> CD#conn_data.protocol_version; + auth_data -> CD#conn_data.auth_data; + user_mod -> CD#conn_data.user_mod; + user_args -> CD#conn_data.user_args; + reply_action -> CD#conn_data.reply_action; + reply_data -> CD#conn_data.reply_data; + threaded -> CD#conn_data.threaded; + strict_version -> CD#conn_data.strict_version; + long_request_resend -> CD#conn_data.long_request_resend; + call_proxy_gc_timeout -> CD#conn_data.call_proxy_gc_timeout; + cancel -> CD#conn_data.cancel; + resend_indication -> CD#conn_data.resend_indication; + segment_reply_ind -> CD#conn_data.segment_reply_ind; + segment_recv_acc -> CD#conn_data.segment_recv_acc; + segment_recv_timer -> CD#conn_data.segment_recv_timer; + segment_send -> CD#conn_data.segment_send; + segment_send_timer -> CD#conn_data.segment_send_timer; + max_pdu_size -> CD#conn_data.max_pdu_size; + request_keep_alive_timeout -> CD#conn_data.request_keep_alive_timeout; + receive_handle -> + LocalMid = (CD#conn_data.conn_handle)#megaco_conn_handle.local_mid, + #megaco_receive_handle{local_mid = LocalMid, + encoding_mod = CD#conn_data.encoding_mod, + encoding_config = CD#conn_data.encoding_config, + send_mod = CD#conn_data.send_mod}; + _ -> + exit({no_such_item, Item}) + end; +conn_info(BadHandle, _Item) -> + {error, {no_such_connection, BadHandle}}. + +replace(_, _, []) -> + []; +replace(Item, WithItem, [Item|List]) -> + [WithItem|List]; +replace(Item, WithItem, [OtherItem|List]) -> + [OtherItem | replace(Item, WithItem, List)]. + + +update_conn_info(#conn_data{conn_handle = CH}, Item, Val) -> + do_update_conn_info(CH, Item, Val); +update_conn_info(CH, Item, Val) + when is_record(CH, megaco_conn_handle) andalso (Item /= cancel) -> + do_update_conn_info(CH, Item, Val); +update_conn_info(BadHandle, _Item, _Val) -> + {error, {no_such_connection, BadHandle}}. + +do_update_conn_info(CH, orig_pending_limit, Val) -> + do_update_conn_info(CH, sent_pending_limit, Val); +do_update_conn_info(CH, Item, Val) -> + call({update_conn_data, CH, Item, Val}). + + +system_info(all) -> + AllItems = [n_active_requests, + n_active_replies, + n_active_connections, + users, + connections, + text_config, + reply_counters, + pending_counters], + [{Item, system_info(Item)} || Item <- AllItems]; +system_info(Item) -> + case Item of + n_active_requests -> + ets:info(megaco_requests, size); + n_active_replies -> + ets:info(megaco_replies, size); + n_active_connections -> + ets:info(megaco_local_conn, size); + users -> + Pat = {{'_', mid}, '_'}, + [Mid || {_, Mid} <- ets:match_object(megaco_config, Pat)]; + connections -> + [C#conn_data.conn_handle || C <- ets:tab2list(megaco_local_conn)]; + text_config -> + case ets:lookup(megaco_config, text_config) of + [] -> + []; + [{text_config, Conf}] -> + [Conf] + end; + + reply_counters -> + reply_counters(); + + pending_counters -> + pending_counters(); + + recv_pending_counters -> + pending_counters(recv); + + sent_pending_counters -> + pending_counters(sent); + + BadItem -> + exit({no_such_item, BadItem}) + + end. + + +get_env(Env, Default) -> + case application:get_env(megaco, Env) of + {ok, Val} -> Val; + undefined -> Default + end. + +lookup_local_conn(Handle) -> + ets:lookup(megaco_local_conn, Handle). + + +autoconnect(RH, RemoteMid, SendHandle, ControlPid) -> + ?d("autoconnect -> entry with " + "~n RH: ~p" + "~n RemoteMid: ~p" + "~n SendHandle: ~p" + "~n ControlPid: ~p", [RH, RemoteMid, SendHandle, ControlPid]), + case RemoteMid of + {MidType, _MidValue} when is_atom(MidType) -> + call({connect, RH, RemoteMid, SendHandle, ControlPid, auto}); + preliminary_mid -> + call({connect, RH, RemoteMid, SendHandle, ControlPid, auto}); + BadMid -> + {error, {bad_remote_mid, BadMid}} + end. + +connect(RH, RemoteMid, SendHandle, ControlPid) -> + ?d("connect -> entry with " + "~n RH: ~p" + "~n RemoteMid: ~p" + "~n SendHandle: ~p" + "~n ControlPid: ~p", [RH, RemoteMid, SendHandle, ControlPid]), + case RemoteMid of + {MidType, _MidValue} when is_atom(MidType) -> + call({connect, RH, RemoteMid, SendHandle, ControlPid, + {plain, self()}}); + preliminary_mid -> + call({connect, RH, RemoteMid, SendHandle, ControlPid, + {plain, self()}}); + BadMid -> + {error, {bad_remote_mid, BadMid}} + end. + +finish_connect(ConnHandle, SendHandle, ControlPid, MFA) -> + ?d("finish_connect -> entry with " + "~n ConnHandle: ~p" + "~n SendHandle: ~p" + "~n ControlPid: ~p" + "~n MFA: ~p", [ConnHandle, SendHandle, ControlPid, MFA]), + call({finish_connect, ConnHandle, SendHandle, ControlPid, MFA}). + +connect_remote(ConnHandle, UserNode, Ref) -> + call({connect_remote, ConnHandle, UserNode, Ref}). + +disconnect(ConnHandle) -> + call({disconnect, ConnHandle}). + +disconnect_remote(ConnHandle, UserNode) -> + call({disconnect_remote, ConnHandle, UserNode}). + + +incr_counter(Item, Incr) -> + try + begin + ets:update_counter(megaco_config, Item, Incr) + end + catch + error:_ -> + try + begin + cre_counter(Item, Incr) + end + catch + exit:_ -> + %% Ok, some other process got there before us, + %% so try again + ets:update_counter(megaco_config, Item, Incr) + end + end. +%% incr_counter(Item, Incr) -> +%% case (catch ets:update_counter(megaco_config, Item, Incr)) of +%% {'EXIT', _} -> +%% case (catch cre_counter(Item, Incr)) of +%% {'EXIT', _} -> +%% %% Ok, some other process got there before us, +%% %% so try again +%% ets:update_counter(megaco_config, Item, Incr); +%% NewVal -> +%% NewVal +%% end; +%% NewVal -> +%% NewVal +%% end. + +cre_counter(Item, Initial) -> + case whereis(?SERVER) =:= self() of + false -> + case call({cre_counter, Item, Initial}) of + {ok, Value} -> + Value; + Error -> + exit(Error) + end; + true -> + %% Check that the counter does not already exists + %% so we don't overwrite an already existing counter + case ets:lookup(megaco_config, Item) of + [] -> + ets:insert(megaco_config, {Item, Initial}), + {ok, Initial}; + [_] -> + %% Ouch, now what? + {error, already_exists} + + end + end. + + +cre_reply_counter(ConnHandle, TransId) -> + Counter = {reply_counter, ConnHandle, TransId}, + Initial = 1, + cre_counter(Counter, Initial). + +incr_reply_counter(ConnHandle, TransId) -> + Counter = {reply_counter, ConnHandle, TransId}, + incr_counter(Counter, 1). + +get_reply_counter(ConnHandle, TransId) -> + Counter = {reply_counter, ConnHandle, TransId}, + [{Counter, Val}] = ets:lookup(megaco_config, Counter), + Val. + +del_reply_counter(ConnHandle, TransId) -> + Counter = {reply_counter, ConnHandle, TransId}, + ets:delete(megaco_config, Counter). + +reply_counters() -> + Pattern = {{reply_counter, '_', '_'}, '_'}, + Counters1 = ets:match_object(megaco_config, Pattern), + [{ConnHandle, TransId, CounterVal} || + {{reply_counter, ConnHandle, TransId}, CounterVal} <- Counters1]. + + +cre_pending_counter(TransId) -> + cre_pending_counter(sent, TransId, 0). + +cre_pending_counter(Direction, TransId, Initial) -> + Counter = {pending_counter, Direction, TransId}, + cre_counter(Counter, Initial). + +incr_pending_counter(TransId) -> + incr_pending_counter(sent, TransId). + +incr_pending_counter(Direction, TransId) -> + Counter = {pending_counter, Direction, TransId}, + incr_counter(Counter, 1). + +get_pending_counter(TransId) -> + get_pending_counter(sent, TransId). + +get_pending_counter(Direction, TransId) -> + Counter = {pending_counter, Direction, TransId}, + [{Counter, Val}] = ets:lookup(megaco_config, Counter), + Val. + +del_pending_counter(TransId) -> + del_pending_counter(sent, TransId). + +del_pending_counter(Direction, TransId) -> + Counter = {pending_counter, Direction, TransId}, + ets:delete(megaco_config, Counter). + + +pending_counters() -> + Pattern = {{pending_counter, '_', '_'}, '_'}, + Counters1 = ets:match_object(megaco_config, Pattern), + Counters2 = [{Direction, TransId, CounterVal} || + {{pending_counter, Direction, TransId}, CounterVal} <- + Counters1], + RecvCounters = [{TransId, CounterVal} || + {recv, TransId, CounterVal} <- Counters2], + SentCounters = [{TransId, CounterVal} || + {sent, TransId, CounterVal} <- Counters2], + [{recv, RecvCounters}, {sent, SentCounters}]. + + +pending_counters(Direction) + when ((Direction =:= sent) orelse (Direction =:= recv)) -> + Pattern = {{pending_counter, Direction, '_'}, '_'}, + Counters = ets:match_object(megaco_config, Pattern), + [{TransId, CounterVal} || + {{pending_counter, D, TransId}, CounterVal} <- + Counters, (Direction == D)]. + +%% A wrapping transaction id counter +incr_trans_id_counter(ConnHandle) -> + incr_trans_id_counter(ConnHandle, 1). +incr_trans_id_counter(ConnHandle, Incr) + when is_integer(Incr) andalso (Incr > 0) -> + case megaco_config:lookup_local_conn(ConnHandle) of + [] -> + {error, {no_such_connection, ConnHandle}}; + [ConnData] -> + LocalMid = ConnHandle#megaco_conn_handle.local_mid, + Min = user_info(LocalMid, min_trans_id), + Max = + case ConnData#conn_data.max_serial of + infinity -> + 4294967295; + MS -> + MS + end, + Item = ?TID_CNT(LocalMid), + do_incr_trans_id_counter(ConnData, Item, Min, Max, Incr, -1) + end. + +do_incr_trans_id_counter(ConnData, _Item, _Min, _Max, 0, Serial) -> + ConnData2 = ConnData#conn_data{serial = Serial}, + {ok, ConnData2}; +do_incr_trans_id_counter(ConnData, Item, Min, Max, N, _) -> + case (catch ets:update_counter(megaco_config, Item, {2, 1, Max, Min})) of + {'EXIT', _} -> + %% This can only happen for the first ever increment, + %% in which case N is equal to (the initial) Incr + ConnHandle = ConnData#conn_data.conn_handle, + init_trans_id_counter(ConnHandle, Item, N); + Serial -> + do_incr_trans_id_counter(ConnData, Item, Min, Max, N-1, Serial) + end. + +init_trans_id_counter(ConnHandle, Item, Incr) -> + case whereis(?SERVER) == self() of + false -> + call({init_trans_id_counter, ConnHandle, Item, Incr}); + true -> + do_init_trans_id_counter(ConnHandle, Item, Incr) + end. + +do_init_trans_id_counter(ConnHandle, Item, Incr) -> + case megaco_config:lookup_local_conn(ConnHandle) of + [] -> + {error, {no_such_connection, ConnHandle}}; + [ConnData] -> + %% Make sure that the counter still does not exist + LocalMid = ConnHandle#megaco_conn_handle.local_mid, + Min = user_info(LocalMid, min_trans_id), + Max = + case ConnData#conn_data.max_serial of + infinity -> + 4294967295; + MS -> + MS + end, + Item = ?TID_CNT(LocalMid), + Incr2 = {2, Incr, Max, Min}, + case (catch ets:update_counter(megaco_config, Item, Incr2)) of + {'EXIT', _} -> + %% Yep, we are the first one here + Serial1 = Min + (Incr-1), + ets:insert(megaco_config, {Item, Serial1}), + ConnData2 = ConnData#conn_data{serial = Serial1}, + {ok, ConnData2}; + Serial2 -> + %% No, someone got there before we did + ConnData2 = ConnData#conn_data{serial = Serial2}, + {ok, ConnData2} + end + end. + +%% For backward compatibillity (during code upgrade) +reset_trans_id_counter(ConnHandle, Item, Serial) -> + LocalMid = ConnHandle#megaco_conn_handle.local_mid, + case megaco_config:lookup_local_conn(ConnHandle) of + [] -> + {error, {no_such_connection, ConnHandle}}; + [ConnData] -> + do_reset_trans_id_counter(ConnData, LocalMid, + Item, Serial) + end. + +do_reset_trans_id_counter(ConnData, LocalMid, Item, Serial) + when is_integer(Serial) -> + Max = ConnData#conn_data.max_serial, + Overflow = + if + (Max == infinity) -> + Serial - 4294967295; + + is_integer(Max) -> + Serial - Max + end, + NewSerial = user_info(LocalMid, min_trans_id) + (Overflow-1), + ConnData2 = ConnData#conn_data{serial = NewSerial}, + ets:insert(megaco_config, {Item, NewSerial}), + {ok, ConnData2}. + + +trans_sender_exit(Reason, CH) -> + ?d("trans_sender_exit -> entry with" + "~n Reason: ~p" + "~n CH: ~p", [Reason, CH]), + cast({trans_sender_exit, Reason, CH}). + + +call(Request) -> + case (catch gen_server:call(?SERVER, Request, infinity)) of + {'EXIT', _} -> + {error, megaco_not_started}; + Res -> + Res + end. + + +cast(Msg) -> + case (catch gen_server:cast(?SERVER, Msg)) of + {'EXIT', _} -> + {error, megaco_not_started}; + Res -> + Res + end. + + +%%%---------------------------------------------------------------------- +%%% Callback functions from gen_server +%%%---------------------------------------------------------------------- + +%%---------------------------------------------------------------------- +%% Func: init/1 +%% Returns: {ok, State} | +%% {ok, State, Timeout} | +%% ignore | +%% {stop, Reason} +%%---------------------------------------------------------------------- + +init([Parent]) -> + ?d("init -> entry with " + "~n Parent: ~p", [Parent]), + process_flag(trap_exit, true), + case (catch do_init()) of + ok -> + ?d("init -> init ok", []), + {ok, #state{parent_pid = Parent}}; + Else -> + ?d("init -> init error: " + "~n ~p", [Else]), + {stop, Else} + end. + +do_init() -> + ?megaco_test_init(), + ets:new(megaco_config, [public, named_table, {keypos, 1}]), + ets:new(megaco_local_conn, [public, named_table, {keypos, 2}]), + ets:new(megaco_remote_conn, [public, named_table, {keypos, 2}, bag]), + megaco_stats:init(megaco_stats, global_snmp_counters()), + init_scanner(), + init_user_defaults(), + init_users(). + + + +init_scanner() -> + case get_env(scanner, undefined) of + undefined -> + Key = text_config, + Data = [], + ets:insert(megaco_config, {Key, Data}); + flex -> + start_scanner(megaco_flex_scanner_handler, + start_link, [], [gen_server]); + {flex, Opts} when is_list(Opts) -> % For future use + start_scanner(megaco_flex_scanner_handler, + start_link, [Opts], [gen_server]); + {M, F, A, Mods} when is_atom(M) andalso + is_atom(F) andalso + is_list(A) andalso + is_list(Mods) -> + start_scanner(M, F, A, Mods) + end. + +start_scanner(M, F, A, Mods) -> + case megaco_misc_sup:start_permanent_worker(M, F, A, Mods) of + {ok, Pid, Conf} when is_pid(Pid) -> + Key = text_config, + Data = [Conf], + ets:insert(megaco_config, {Key, Data}); + Else -> + throw({scanner_start_failed, Else}) + end. + +init_user_defaults() -> + init_user_default(min_trans_id, 1), + init_user_default(max_trans_id, infinity), + init_user_default(request_timer, #megaco_incr_timer{}), + init_user_default(long_request_timer, timer:seconds(60)), + + init_user_default(auto_ack, false), + + init_user_default(trans_ack, false), + init_user_default(trans_ack_maxcount, 10), + + init_user_default(trans_req, false), + init_user_default(trans_req_maxcount, 10), + init_user_default(trans_req_maxsize, 2048), + + init_user_default(trans_timer, 0), + init_user_default(trans_sender, undefined), + + init_user_default(pending_timer, timer:seconds(30)), + init_user_default(sent_pending_limit, infinity), + init_user_default(recv_pending_limit, infinity), + init_user_default(reply_timer, timer:seconds(30)), + init_user_default(send_mod, megaco_tcp), + init_user_default(encoding_mod, megaco_pretty_text_encoder), + init_user_default(protocol_version, 1), + init_user_default(auth_data, asn1_NOVALUE), + init_user_default(encoding_config, []), + init_user_default(user_mod, megaco_user_default), + init_user_default(user_args, []), + init_user_default(reply_data, undefined), + init_user_default(threaded, false), + init_user_default(strict_version, true), + init_user_default(long_request_resend, false), + init_user_default(call_proxy_gc_timeout, timer:seconds(5)), + init_user_default(cancel, false), + init_user_default(resend_indication, false), + init_user_default(segment_reply_ind, false), + init_user_default(segment_recv_acc, false), + init_user_default(segment_recv_timer, timer:seconds(10)), + init_user_default(segment_send, none), + init_user_default(segment_send_timer, timer:seconds(5)), + init_user_default(max_pdu_size, infinity), + init_user_default(request_keep_alive_timeout, plain). + +init_user_default(Item, Default) when Item /= mid -> + Val = get_env(Item, Default), + case do_update_user(default, Item, Val) of + ok -> + ok; + {error, Reason} -> + throw(Reason) + end. + +init_users() -> + Users = get_env(users, []), + init_users(Users). + +init_users([]) -> + ok; +init_users([{UserMid, Config} | Rest]) -> + case handle_start_user(UserMid, Config) of + ok -> + init_users(Rest); + Else -> + throw({bad_user, UserMid, Else}) + end; +init_users(BadConfig) -> + throw({bad_config, users, BadConfig}). + +%%---------------------------------------------------------------------- +%% Func: handle_call/3 +%% Returns: {reply, Reply, State} | +%% {reply, Reply, State, Timeout} | +%% {noreply, State} | +%% {noreply, State, Timeout} | +%% {stop, Reason, Reply, State} | (terminate/2 is called) +%% {stop, Reason, State} (terminate/2 is called) +%%---------------------------------------------------------------------- + +handle_call({cre_counter, Item, Incr}, _From, S) -> + Reply = cre_counter(Item, Incr), + {reply, Reply, S}; + +handle_call({del_counter, Item, Incr}, _From, S) -> + Reply = cre_counter(Item, Incr), + {reply, Reply, S}; + +%% For backward compatibillity (code upgrade) +handle_call({incr_trans_id_counter, ConnHandle}, _From, S) -> + Reply = incr_trans_id_counter(ConnHandle), + {reply, Reply, S}; + +handle_call({init_trans_id_counter, ConnHandle, Item, Incr}, _From, S) -> + Reply = do_init_trans_id_counter(ConnHandle, Item, Incr), + {reply, Reply, S}; + +%% For backward compatibillity (code upgrade) +handle_call({reset_trans_id_counter, ConnHandle, Item, Serial}, _From, S) -> + Reply = reset_trans_id_counter(ConnHandle, Item, Serial), + {reply, Reply, S}; + +handle_call({receive_handle, UserMid}, _From, S) -> + case catch make_receive_handle(UserMid) of + {'EXIT', _} -> + {reply, {error, {no_receive_handle, UserMid}}, S}; + RH -> + {reply, {ok, RH}, S} + end; +handle_call({connect, RH, RemoteMid, SendHandle, ControlPid}, _From, S) -> + Reply = handle_connect(RH, RemoteMid, SendHandle, ControlPid, auto), + {reply, Reply, S}; +handle_call({connect, RH, RemoteMid, SendHandle, ControlPid, Auto}, _From, S) -> + Reply = handle_connect(RH, RemoteMid, SendHandle, ControlPid, Auto), + {reply, Reply, S}; + +handle_call({finish_connect, ConnHandle, SendHandle, ControlPid, MFA}, + _From, S) -> + Reply = handle_finish_connect(ConnHandle, SendHandle, ControlPid, MFA), + {reply, Reply, S}; + +handle_call({connect_remote, CH, UserNode, Ref}, _From, S) -> + Reply = handle_connect_remote(CH, UserNode, Ref), + {reply, Reply, S}; + +handle_call({disconnect, ConnHandle}, _From, S) -> + Reply = handle_disconnect(ConnHandle), + {reply, Reply, S}; +handle_call({disconnect_remote, CH, UserNode}, _From, S) -> + Reply = handle_disconnect_remote(CH, UserNode), + {reply, Reply, S}; + +handle_call({start_user, UserMid, Config}, _From, S) -> + Reply = handle_start_user(UserMid, Config), + {reply, Reply, S}; +handle_call({stop_user, UserMid}, _From, S) -> + Reply = handle_stop_user(UserMid), + {reply, Reply, S}; +handle_call({update_conn_data, CH, Item, Val}, _From, S) -> + case lookup_local_conn(CH) of + [] -> + {reply, {error, {no_such_connection, CH}}, S}; + [CD] -> + Reply = handle_update_conn_data(CD, Item, Val), + {reply, Reply, S} + end; +handle_call({update_user_info, UserMid, Item, Val}, _From, S) -> + case catch user_info(UserMid, mid) of + {'EXIT', _} -> + {reply, {error, {no_such_user, UserMid}}, S}; + _ -> + Reply = do_update_user(UserMid, Item, Val), + {reply, Reply, S} + end; + +handle_call({stop, ParentPid}, _From, #state{parent_pid = ParentPid} = S) -> + Reason = normal, + Reply = ok, + {stop, Reason, Reply, S}; + +handle_call(Req, From, S) -> + warning_msg("received unexpected request from ~p: " + "~n~w", [From, Req]), + {reply, {error, {bad_request, Req}}, S}. + + +%%---------------------------------------------------------------------- +%% Func: handle_cast/2 +%% Returns: {noreply, State} | +%% {noreply, State, Timeout} | +%% {stop, Reason, State} (terminate/2 is called) +%%---------------------------------------------------------------------- + +handle_cast({trans_sender_exit, Reason, CH}, S) -> + warning_msg("transaction sender [~p] restarting: " + "~n~p", [CH, Reason]), + case lookup_local_conn(CH) of + [] -> + error_msg("connection data not found for ~p~n" + "when restarting transaction sender", [CH]); + [CD] -> + CD2 = trans_sender_start(CD#conn_data{trans_sender = undefined}), + ets:insert(megaco_local_conn, CD2) + end, + {noreply, S}; + +handle_cast(Msg, S) -> + warning_msg("received unexpected message: " + "~n~w", [Msg]), + {noreply, S}. + + + +%%---------------------------------------------------------------------- +%% Func: handle_info/2 +%% Returns: {noreply, State} | +%% {noreply, State, Timeout} | +%% {stop, Reason, State} (terminate/2 is called) +%%---------------------------------------------------------------------- + +handle_info({'EXIT', Pid, Reason}, S) when Pid =:= S#state.parent_pid -> + {stop, Reason, S}; + +handle_info(Info, S) -> + warning_msg("received unknown info: " + "~n~w", [Info]), + {noreply, S}. + + + +%%---------------------------------------------------------------------- +%% Func: terminate/2 +%% Purpose: Shutdown the server +%% Returns: any (ignored by gen_server) +%%---------------------------------------------------------------------- + +terminate(_Reason, _State) -> + ok. + + +%%---------------------------------------------------------------------- +%% Func: code_change/3 +%% Purpose: Convert process state when code is changed +%% Returns: {ok, NewState} +%%---------------------------------------------------------------------- + +code_change(_Vsn, S, upgrade_from_pre_3_12) -> + upgrade_user_info_from_pre_3_12(), + upgrade_conn_data_from_pre_3_12(), + {ok, S}; + +code_change(_Vsn, S, downgrade_to_pre_3_12) -> + downgrade_user_info_to_pre_3_12(), + downgrade_conn_data_to_pre_3_12(), + {ok, S}; + +code_change(_Vsn, S, _Extra) -> + {ok, S}. + + +%% -- Upgrade user info -- + +upgrade_user_info_from_pre_3_12() -> + NewValues = [{request_keep_alive_timeout, plain}], + upgrade_user_info(NewValues). + +%% upgrade_user_info_from_pre_3_7() -> +%% NewValues = [{segment_reply_ind, false}, +%% {segment_recv_acc, false}, +%% {segment_recv_timer, #megaco_incr_timer{}}, +%% {segment_send, none}, +%% {segment_send_timer, infinity}, +%% {max_pdu_size, infinity}], +%% upgrade_user_info(NewValues). + +upgrade_user_info(NewValues) -> + Users = [default|system_info(users)], + F = fun({Item, Val}) -> + upgrade_user_info(Users, Item, Val) + end, + lists:foreach(F, NewValues), + ok. + +upgrade_user_info(Users, Item, Val) -> + F = fun(User) -> do_update_user(User, Item, Val) end, + lists:foreach(F, Users), + ok. + + +%% %% -- Downgrade user info -- + +downgrade_user_info_to_pre_3_12() -> + NewItems = [ + request_keep_alive_timeout + ], + downgrade_user_info(NewItems). + +%% downgrade_user_info_to_pre_3_7() -> +%% NewItems = [ +%% segment_reply_ind, +%% segment_recv_acc, +%% segment_recv_timer, +%% segment_send, +%% segment_send_timer, +%% max_pdu_size +%% ], +%% downgrade_user_info(NewItems). + +downgrade_user_info(NewItems) -> + Users = [default|system_info(users)], + F = fun(Item) -> + downgrade_user_info(Users, Item) + end, + lists:foreach(F, NewItems), + ok. + +downgrade_user_info(Users, Item) -> + F = fun(User) -> do_downgrade_user_info(User, Item) end, + lists:foreach(F, Users), + ok. + +do_downgrade_user_info(User, Item) -> + ets:delete(megaco_config, {User, Item}). + + +%% %% -- Upgrade conn data -- + +upgrade_conn_data_from_pre_3_12() -> + Conns = system_info(connections), + Defaults = [{request_keep_alive_timeout, plain}], + upgrade_conn_data(Conns, Defaults). + +%% upgrade_conn_data_from_pre_3_7() -> +%% Conns = system_info(connections), +%% Defaults = [{segment_reply_ind, false}, +%% {segment_recv_acc, false}, +%% {segment_recv_timer, #megaco_incr_timer{}}, +%% {segment_send, false}, +%% {segment_send_timer, #megaco_incr_timer{}}, +%% {max_pdu_size, infinity}], +%% upgrade_conn_data(Conns, Defaults). + +upgrade_conn_data(Conns, Defaults) -> + F = fun(CH) -> + case lookup_local_conn(CH) of + [] -> + ok; + [CD] -> + do_upgrade_conn_data(CD, Defaults) + end + end, + lists:foreach(F, Conns), + ok. + +do_upgrade_conn_data(OldStyleCD, Defaults) -> + NewStyleCD = new_conn_data(OldStyleCD, Defaults), + ets:insert(megaco_local_conn, NewStyleCD). + +%% Pre 3.12 +new_conn_data({conn_data, CH, Serial, MaxSerial, ReqTmr, LongReqTmr, + AutoAck, + TransAck, TransAckMaxCnt, + TransReq, TransReqMaxCnt, TransReqMaxSz, + TransTmr, TransSndr, + + PendingTmr, + SentPendingLimit, + RecvPendingLimit, + ReplyTmr, CtrPid, MonRef, + Sendmod, SendHandle, + EncodeMod, EncodeConf, + ProtV, AuthData, + UserMod, UserArgs, ReplyAction, ReplyData, + Threaded, + StrictVersion, + LongReqResend, + Cancel, + ResendIndication, + SegmentReplyInd, + SegmentRecvAcc, + SegmentRecvTimer, + SegmentSend, + SegmentSendTimer, + MaxPDUSize + %% RequestKeepAliveTimerDefault - New values + }, + Defaults) -> + #conn_data{conn_handle = CH, + serial = Serial, + max_serial = MaxSerial, + request_timer = ReqTmr, + long_request_timer = LongReqTmr, + + auto_ack = AutoAck, + + trans_ack = TransAck, + trans_ack_maxcount = TransAckMaxCnt, + + trans_req = TransReq, + trans_req_maxcount = TransReqMaxCnt, + trans_req_maxsize = TransReqMaxSz, + + trans_timer = TransTmr, + trans_sender = TransSndr, + + pending_timer = PendingTmr, + sent_pending_limit = SentPendingLimit, + recv_pending_limit = RecvPendingLimit, + + reply_timer = ReplyTmr, + control_pid = CtrPid, + monitor_ref = MonRef, + send_mod = Sendmod, + send_handle = SendHandle, + encoding_mod = EncodeMod, + encoding_config = EncodeConf, + protocol_version = ProtV, + auth_data = AuthData, + user_mod = UserMod, + user_args = UserArgs, + reply_action = ReplyAction, + reply_data = ReplyData, + threaded = Threaded, + strict_version = StrictVersion, + long_request_resend = LongReqResend, + cancel = Cancel, + resend_indication = ResendIndication, + segment_reply_ind = SegmentReplyInd, + segment_recv_acc = SegmentRecvAcc, + segment_recv_timer = SegmentRecvTimer, + segment_send = SegmentSend, + segment_send_timer = SegmentSendTimer, + max_pdu_size = MaxPDUSize, + request_keep_alive_timeout = get_default(request_keep_alive_timeout, Defaults) + }. + + +get_default(Key, Defaults) -> + {value, {Key, Default}} = lists:keysearch(Key, 1, Defaults), + Default. + + +%% %% -- Downgrade conn data -- + +downgrade_conn_data_to_pre_3_12() -> + Conns = system_info(connections), + Downgrade = fun(NewCD) -> old_conn_data_to_pre_3_12(NewCD) end, + downgrade_conn_data(Downgrade, Conns). + +downgrade_conn_data(Downgrade, Conns) -> + F = fun(CH) -> + case lookup_local_conn(CH) of + [] -> + ok; + [CD] -> + do_downgrade_conn_data(Downgrade, CD) + end + end, + lists:foreach(F, Conns). + +do_downgrade_conn_data(Downgrade, NewStyleCD) -> + OldStyleCD = Downgrade(NewStyleCD), + ets:insert(megaco_local_conn, OldStyleCD). + +old_conn_data_to_pre_3_12( + #conn_data{conn_handle = CH, + serial = Serial, + max_serial = MaxSerial, + request_timer = ReqTmr, + long_request_timer = LongReqTmr, + + auto_ack = AutoAck, + + trans_ack = TransAck, + trans_ack_maxcount = TransAckMaxCnt, + + trans_req = TransReq, + trans_req_maxcount = TransReqMaxCnt, + trans_req_maxsize = TransReqMaxSz, + + trans_timer = TransTmr, + trans_sender = TransSndr, + + pending_timer = PendingTmr, + sent_pending_limit = SentPendingLimit, + recv_pending_limit = RecvPendingLimit, + + reply_timer = ReplyTmr, + control_pid = CtrPid, + monitor_ref = MonRef, + send_mod = Sendmod, + send_handle = SendHandle, + encoding_mod = EncodeMod, + encoding_config = EncodeConf, + protocol_version = ProtV, + auth_data = AuthData, + user_mod = UserMod, + user_args = UserArgs, + reply_action = ReplyAction, + reply_data = ReplyData, + threaded = Threaded, + strict_version = StrictVersion, + long_request_resend = LongReqResend, + cancel = Cancel, + resend_indication = ResendIndication, + segment_reply_ind = SegmentRecvAcc, + segment_recv_acc = SegmentRecvAcc, + segment_recv_timer = SegmentRecvTimer, + segment_send = SegmentSend, + segment_send_timer = SegmentSendTimer, + max_pdu_size = MaxPDUSize + %% request_keep_alive_timeout = RequestKeepAliveTimeout + }) -> + {conn_data, CH, Serial, MaxSerial, ReqTmr, LongReqTmr, + AutoAck, + TransAck, TransAckMaxCnt, + TransReq, TransReqMaxCnt, TransReqMaxSz, + TransTmr, TransSndr, + PendingTmr, + SentPendingLimit, + RecvPendingLimit, + ReplyTmr, CtrPid, MonRef, + Sendmod, SendHandle, + EncodeMod, EncodeConf, + ProtV, AuthData, + UserMod, UserArgs, ReplyAction, ReplyData, + Threaded, + StrictVersion, + LongReqResend, + Cancel, + ResendIndication, + SegmentRecvAcc, + SegmentRecvAcc, + SegmentRecvTimer, + SegmentSend, + SegmentSendTimer, + MaxPDUSize}. + + + +%%%---------------------------------------------------------------------- +%%% Internal functions +%%%---------------------------------------------------------------------- + +handle_start_user(default, _Config) -> + {error, bad_user_mid}; +handle_start_user(Mid, Config) -> + case catch user_info(Mid, mid) of + {'EXIT', _} -> + DefaultConfig = user_info(default, all), + do_handle_start_user(Mid, DefaultConfig), + do_handle_start_user(Mid, Config); + _LocalMid -> + {error, {user_already_exists, Mid}} + end. + +do_handle_start_user(UserMid, [{Item, Val} | Rest]) -> + case do_update_user(UserMid, Item, Val) of + ok -> + do_handle_start_user(UserMid, Rest); + {error, Reason} -> + ets:match_delete(megaco_config, {{UserMid, '_'}, '_'}), + {error, Reason} + end; +do_handle_start_user(UserMid, []) -> + do_update_user(UserMid, mid, UserMid), + ok; +do_handle_start_user(UserMid, BadConfig) -> + ets:match_delete(megaco_config, {{UserMid, '_'}, '_'}), + {error, {bad_user_config, UserMid, BadConfig}}. + +do_update_user(UserMid, Item, Val) -> + case verify_val(Item, Val) of + true -> + ets:insert(megaco_config, {{UserMid, Item}, Val}), + ok; + false -> + {error, {bad_user_val, UserMid, Item, Val}} + end. + +verify_val(Item, Val) -> + case Item of + mid -> true; + local_mid -> true; + remote_mid -> true; + min_trans_id -> verify_strict_uint(Val, 4294967295); % uint32 + max_trans_id -> verify_uint(Val, 4294967295); % uint32 + request_timer -> verify_timer(Val); + long_request_timer -> verify_timer(Val); + + auto_ack -> verify_bool(Val); + + trans_ack -> verify_bool(Val); + trans_ack_maxcount -> verify_uint(Val); + + trans_req -> verify_bool(Val); + trans_req_maxcount -> verify_uint(Val); + trans_req_maxsize -> verify_uint(Val); + + trans_timer -> verify_timer(Val) and (Val >= 0); + trans_sender when Val == undefined -> true; + + pending_timer -> verify_timer(Val); + sent_pending_limit -> verify_uint(Val) andalso + (Val > 0); + recv_pending_limit -> verify_uint(Val) andalso + (Val > 0); + reply_timer -> verify_timer(Val); + control_pid when is_pid(Val) -> true; + monitor_ref -> true; % Internal usage only + send_mod when is_atom(Val) -> true; + send_handle -> true; + encoding_mod when is_atom(Val) -> true; + encoding_config when is_list(Val) -> true; + protocol_version -> verify_strict_uint(Val); + auth_data -> true; + user_mod when is_atom(Val) -> true; + user_args when is_list(Val) -> true; + reply_data -> true; + threaded -> verify_bool(Val); + strict_version -> verify_bool(Val); + long_request_resend -> verify_bool(Val); + call_proxy_gc_timeout -> verify_strict_uint(Val); + cancel -> verify_bool(Val); + resend_indication -> verify_resend_indication(Val); + + segment_reply_ind -> verify_bool(Val); + segment_recv_acc -> verify_bool(Val); + segment_recv_timer -> verify_timer(Val); + segment_send -> verify_segmentation_window(Val); + segment_send_timer -> verify_timer(Val); + max_pdu_size -> verify_int(Val) andalso (Val > 0); + request_keep_alive_timeout -> + (verify_int(Val) andalso (Val >= 0)) orelse (Val =:= plain); + + _ -> false + end. + + + +verify_bool(true) -> true; +verify_bool(false) -> true; +verify_bool(_) -> false. + +verify_resend_indication(flag) -> true; +verify_resend_indication(Val) -> verify_bool(Val). + +-spec verify_strict_int(Int :: integer()) -> boolean(). +verify_strict_int(Int) when is_integer(Int) -> true; +verify_strict_int(_) -> false. + +-spec verify_strict_int(Int :: integer(), + Max :: integer() | 'infinity') -> boolean(). +verify_strict_int(Int, infinity) -> + verify_strict_int(Int); +verify_strict_int(Int, Max) -> + verify_strict_int(Int) andalso verify_strict_int(Max) andalso (Int =< Max). + +-spec verify_strict_uint(Int :: non_neg_integer()) -> boolean(). +verify_strict_uint(Int) when is_integer(Int) andalso (Int >= 0) -> true; +verify_strict_uint(_) -> false. + +-spec verify_strict_uint(Int :: non_neg_integer(), + Max :: non_neg_integer() | 'infinity') -> boolean(). +verify_strict_uint(Int, infinity) -> + verify_strict_uint(Int); +verify_strict_uint(Int, Max) -> + verify_strict_int(Int, 0, Max). + +-spec verify_uint(Val :: non_neg_integer() | 'infinity') -> boolean(). +verify_uint(infinity) -> true; +verify_uint(Val) -> verify_strict_uint(Val). + +-spec verify_int(Val :: integer() | 'infinity') -> boolean(). +verify_int(infinity) -> true; +verify_int(Val) -> verify_strict_int(Val). + +-spec verify_int(Int :: integer() | 'infinity', + Max :: integer() | 'infinity') -> boolean(). +verify_int(Int, infinity) -> + verify_int(Int); +verify_int(infinity, _Max) -> + true; +verify_int(Int, Max) -> + verify_strict_int(Int) andalso verify_strict_int(Max) andalso (Int =< Max). + +-spec verify_uint(Int :: non_neg_integer() | 'infinity', + Max :: non_neg_integer() | 'infinity') -> boolean(). +verify_uint(Int, infinity) -> + verify_uint(Int); +verify_uint(infinity, _Max) -> + true; +verify_uint(Int, Max) -> + verify_strict_int(Int, 0, Max). + +-spec verify_strict_int(Int :: integer(), + Min :: integer(), + Max :: integer()) -> boolean(). +verify_strict_int(Val, Min, Max) + when (is_integer(Val) andalso + is_integer(Min) andalso + is_integer(Max) andalso + (Val >= Min) andalso + (Val =< Max)) -> + true; +verify_strict_int(_Val, _Min, _Max) -> + false. + +-spec verify_int(Val :: integer() | 'infinity', + Min :: integer(), + Max :: integer() | 'infinity') -> boolean(). +verify_int(infinity, Min, infinity) -> + verify_strict_int(Min); +verify_int(Val, Min, infinity) -> + verify_strict_int(Val) andalso + verify_strict_int(Min) andalso (Val >= Min); +verify_int(Int, Min, Max) -> + verify_strict_int(Int, Min, Max). + +verify_timer(Timer) -> + megaco_timer:verify(Timer). + +verify_segmentation_window(none) -> + true; +verify_segmentation_window(K) -> + verify_int(K, 1, infinity). + +handle_stop_user(UserMid) -> + case catch user_info(UserMid, mid) of + {'EXIT', _} -> + {error, {no_such_user, UserMid}}; + _ -> + case catch user_info(UserMid, connections) of + [] -> + ets:match_delete(megaco_config, {{UserMid, '_'}, '_'}), + ok; + {'EXIT', _} -> + {error, {no_such_user, UserMid}}; + _Else -> + {error, {active_connections, UserMid}} + end + end. + +handle_update_conn_data(CD, Item = receive_handle, RH) -> + UserMid = (CD#conn_data.conn_handle)#megaco_conn_handle.local_mid, + if + is_record(RH, megaco_receive_handle) andalso + is_atom(RH#megaco_receive_handle.encoding_mod) andalso + is_list(RH#megaco_receive_handle.encoding_config) andalso + is_atom(RH#megaco_receive_handle.send_mod) andalso + (RH#megaco_receive_handle.local_mid /= UserMid) -> + CD2 = CD#conn_data{ + encoding_mod = RH#megaco_receive_handle.encoding_mod, + encoding_config = RH#megaco_receive_handle.encoding_config, + send_mod = RH#megaco_receive_handle.send_mod}, + ets:insert(megaco_local_conn, CD2), + ok; + true -> + {error, {bad_user_val, UserMid, Item, RH}} + end; +handle_update_conn_data(CD, Item, Val) -> + case verify_val(Item, Val) of + true -> + CD2 = replace_conn_data(CD, Item, Val), + ets:insert(megaco_local_conn, CD2), + ok; + false -> + UserMid = (CD#conn_data.conn_handle)#megaco_conn_handle.local_mid, + {error, {bad_user_val, UserMid, Item, Val}} + end. + +replace_conn_data(CD, Item, Val) -> + case Item of + trans_id -> CD#conn_data{serial = Val}; + max_trans_id -> CD#conn_data{max_serial = Val}; + request_timer -> CD#conn_data{request_timer = Val}; + long_request_timer -> CD#conn_data{long_request_timer = Val}; + + auto_ack -> update_auto_ack(CD, Val); + + %% Accumulate trans ack before sending + trans_ack -> update_trans_ack(CD, Val); + trans_ack_maxcount -> update_trans_ack_maxcount(CD, Val); + + %% Accumulate trans req before sending + trans_req -> update_trans_req(CD, Val); + trans_req_maxcount -> update_trans_req_maxcount(CD, Val); + trans_req_maxsize -> update_trans_req_maxsize(CD, Val); + + trans_timer -> update_trans_timer(CD, Val); + %% trans_sender - Automagically updated by + %% update_auto_ack & update_trans_timer & + %% update_trans_ack & update_trans_req + + pending_timer -> CD#conn_data{pending_timer = Val}; + sent_pending_limit -> CD#conn_data{sent_pending_limit = Val}; + recv_pending_limit -> CD#conn_data{recv_pending_limit = Val}; + reply_timer -> CD#conn_data{reply_timer = Val}; + control_pid -> CD#conn_data{control_pid = Val}; + monitor_ref -> CD#conn_data{monitor_ref = Val}; + send_mod -> CD#conn_data{send_mod = Val}; + send_handle -> CD#conn_data{send_handle = Val}; + encoding_mod -> CD#conn_data{encoding_mod = Val}; + encoding_config -> CD#conn_data{encoding_config = Val}; + protocol_version -> CD#conn_data{protocol_version = Val}; + auth_data -> CD#conn_data{auth_data = Val}; + user_mod -> CD#conn_data{user_mod = Val}; + user_args -> CD#conn_data{user_args = Val}; + reply_action -> CD#conn_data{reply_action = Val}; + reply_data -> CD#conn_data{reply_data = Val}; + threaded -> CD#conn_data{threaded = Val}; + strict_version -> CD#conn_data{strict_version = Val}; + long_request_resend -> CD#conn_data{long_request_resend = Val}; + call_proxy_gc_timeout -> CD#conn_data{call_proxy_gc_timeout = Val}; + cancel -> CD#conn_data{cancel = Val}; + resend_indication -> CD#conn_data{resend_indication = Val}; + segment_reply_ind -> CD#conn_data{segment_reply_ind = Val}; + segment_recv_acc -> CD#conn_data{segment_recv_acc = Val}; + segment_recv_timer -> CD#conn_data{segment_recv_timer = Val}; + segment_send -> CD#conn_data{segment_send = Val}; + segment_send_timer -> CD#conn_data{segment_send_timer = Val}; + max_pdu_size -> CD#conn_data{max_pdu_size = Val}; + request_keep_alive_timeout -> CD#conn_data{request_keep_alive_timeout = Val} + end. + +%% update auto_ack +update_auto_ack(#conn_data{trans_sender = Pid, + trans_req = false} = CD, + false) when is_pid(Pid) -> + megaco_trans_sender:stop(Pid), + CD#conn_data{auto_ack = false, trans_sender = undefined}; + +update_auto_ack(#conn_data{trans_timer = To, + trans_ack = true, + trans_sender = undefined} = CD, + true) when To > 0 -> + #conn_data{conn_handle = CH, + trans_ack_maxcount = AcksMax, + trans_req_maxcount = ReqsMax, + trans_req_maxsize = ReqsMaxSz} = CD, + {ok, Pid} = megaco_trans_sup:start_trans_sender(CH, To, ReqsMaxSz, + ReqsMax, AcksMax), + + %% Make sure we are notified when/if the transaction + %% sender goes down. + %% Do we need to store the ref? Will we ever need to + %% cancel this (apply_at_exit)? + megaco_monitor:apply_at_exit(?MODULE, trans_sender_exit, [CH], Pid), + + CD#conn_data{auto_ack = true, trans_sender = Pid}; + +update_auto_ack(CD, Val) -> + ?d("update_auto_ack -> entry with ~p", [Val]), + CD#conn_data{auto_ack = Val}. + +%% update trans_ack +update_trans_ack(#conn_data{auto_ack = true, + trans_req = false, + trans_sender = Pid} = CD, + false) when is_pid(Pid) -> + megaco_trans_sender:stop(Pid), + CD#conn_data{trans_ack = false, trans_sender = undefined}; + +update_trans_ack(#conn_data{trans_timer = To, + auto_ack = true, + trans_sender = undefined} = CD, + true) when To > 0 -> + #conn_data{conn_handle = CH, + trans_ack_maxcount = AcksMax, + trans_req_maxcount = ReqsMax, + trans_req_maxsize = ReqsMaxSz} = CD, + {ok, Pid} = megaco_trans_sup:start_trans_sender(CH, To, ReqsMaxSz, + ReqsMax, AcksMax), + + %% Make sure we are notified when/if the transaction + %% sender goes down. + %% Do we need to store the ref? Will we ever need to + %% cancel this (apply_at_exit)? + megaco_monitor:apply_at_exit(?MODULE, trans_sender_exit, [CH], Pid), + + CD#conn_data{trans_ack = true, trans_sender = Pid}; + +update_trans_ack(CD, Val) -> + ?d("update_trans_ack -> entry with ~p", [Val]), + CD#conn_data{trans_ack = Val}. + +%% update trans_req +update_trans_req(#conn_data{trans_ack = false, + trans_sender = Pid} = CD, + false) when is_pid(Pid) -> + megaco_trans_sender:stop(Pid), + CD#conn_data{trans_req = false, trans_sender = undefined}; + +update_trans_req(#conn_data{trans_timer = To, + trans_sender = undefined} = CD, + true) when To > 0 -> + #conn_data{conn_handle = CH, + trans_ack_maxcount = AcksMax, + trans_req_maxcount = ReqsMax, + trans_req_maxsize = ReqsMaxSz} = CD, + {ok, Pid} = megaco_trans_sup:start_trans_sender(CH, To, ReqsMaxSz, + ReqsMax, AcksMax), + + %% Make sure we are notified when/if the transaction + %% sender goes down. + %% Do we need to store the ref? Will we ever need to + %% cancel this (apply_at_exit)? + megaco_monitor:apply_at_exit(?MODULE, trans_sender_exit, [CH], Pid), + + CD#conn_data{trans_req = true, trans_sender = Pid}; + +update_trans_req(CD, Val) -> + ?d("update_trans_req -> entry with ~p", [Val]), + CD#conn_data{trans_req = Val}. + +%% update trans_timer +update_trans_timer(#conn_data{auto_ack = true, + trans_ack = true, + trans_sender = undefined} = CD, + To) when To > 0 -> + #conn_data{conn_handle = CH, + trans_ack_maxcount = AcksMax, + trans_req_maxcount = ReqsMax, + trans_req_maxsize = ReqsMaxSz} = CD, + {ok, Pid} = megaco_trans_sup:start_trans_sender(CH, To, ReqsMaxSz, + ReqsMax, AcksMax), + + %% Make sure we are notified when/if the transaction + %% sender goes down. + %% Do we need to store the ref? Will we ever need to + %% cancel this (apply_at_exit)? + megaco_monitor:apply_at_exit(?MODULE, trans_sender_exit, [CH], Pid), + + CD#conn_data{trans_timer = To, trans_sender = Pid}; + +update_trans_timer(#conn_data{trans_req = true, + trans_sender = undefined} = CD, + To) when To > 0 -> + #conn_data{conn_handle = CH, + trans_ack_maxcount = AcksMax, + trans_req_maxcount = ReqsMax, + trans_req_maxsize = ReqsMaxSz} = CD, + {ok, Pid} = megaco_trans_sup:start_trans_sender(CH, To, ReqsMaxSz, + ReqsMax, AcksMax), + + %% Make sure we are notified when/if the transaction + %% sender goes down. + %% Do we need to store the ref? Will we ever need to + %% cancel this (apply_at_exit)? + megaco_monitor:apply_at_exit(?MODULE, trans_sender_exit, [CH], Pid), + + CD#conn_data{trans_timer = To, trans_sender = Pid}; + +update_trans_timer(#conn_data{trans_sender = Pid} = CD, 0) when is_pid(Pid) -> + megaco_trans_sender:stop(Pid), + CD#conn_data{trans_timer = 0, trans_sender = undefined}; + +update_trans_timer(#conn_data{trans_sender = Pid} = CD, To) + when is_pid(Pid) and (To > 0) -> + megaco_trans_sender:timeout(Pid, To), + CD#conn_data{trans_timer = To}; + +update_trans_timer(CD, To) when To > 0 -> + CD#conn_data{trans_timer = To}. + +%% update trans_ack_maxcount +update_trans_ack_maxcount(#conn_data{trans_sender = Pid} = CD, Max) + when is_pid(Pid) and (Max > 0) -> + megaco_trans_sender:ack_maxcount(Pid, Max), + CD#conn_data{trans_ack_maxcount = Max}; + +update_trans_ack_maxcount(CD, Max) + when Max > 0 -> + ?d("update_trans_ack_maxcount -> entry with ~p", [Max]), + CD#conn_data{trans_ack_maxcount = Max}. + +%% update trans_req_maxcount +update_trans_req_maxcount(#conn_data{trans_sender = Pid} = CD, Max) + when is_pid(Pid) and (Max > 0) -> + megaco_trans_sender:req_maxcount(Pid, Max), + CD#conn_data{trans_req_maxcount = Max}; + +update_trans_req_maxcount(CD, Max) + when Max > 0 -> + ?d("update_trans_req_maxcount -> entry with ~p", [Max]), + CD#conn_data{trans_req_maxcount = Max}. + +%% update trans_req_maxsize +update_trans_req_maxsize(#conn_data{trans_sender = Pid} = CD, Max) + when is_pid(Pid) and (Max > 0) -> + megaco_trans_sender:req_maxsize(Pid, Max), + CD#conn_data{trans_req_maxsize = Max}; + +update_trans_req_maxsize(CD, Max) + when Max > 0 -> + ?d("update_trans_req_maxsize -> entry with ~p", [Max]), + CD#conn_data{trans_req_maxsize = Max}. + + + +handle_connect(RH, RemoteMid, SendHandle, ControlPid, Auto) -> + LocalMid = RH#megaco_receive_handle.local_mid, + ConnHandle = #megaco_conn_handle{local_mid = LocalMid, + remote_mid = RemoteMid}, + ?d("handle_connect -> entry with" + "~n ConnHandle: ~p", [ConnHandle]), + case ets:lookup(megaco_local_conn, ConnHandle) of + [] -> + PrelMid = preliminary_mid, + PrelHandle = ConnHandle#megaco_conn_handle{remote_mid = PrelMid}, + case ets:lookup(megaco_local_conn, PrelHandle) of + [] -> + case (catch init_conn_data(RH, + RemoteMid, SendHandle, + ControlPid, Auto)) of + {'EXIT', _Reason} -> + ?d("handle_connect -> init conn data failed: " + "~n ~p",[_Reason]), + {error, {no_such_user, LocalMid}}; + ConnData -> + ?d("handle_connect -> new connection" + "~n ConnData: ~p", [ConnData]), + %% Brand new connection, use + %% When is the preliminary_mid used? + create_snmp_counters(ConnHandle), + %% Maybe start transaction sender + ConnData2 = trans_sender_start(ConnData), + ets:insert(megaco_local_conn, ConnData2), + {ok, ConnData2} + end; + [PrelData] -> + ?d("handle_connect -> connection upgrade" + "~n PrelData: ~p", [PrelData]), + %% OK, we need to fix the snmp counters. Used + %% with the temporary (preliminary_mid) conn_handle. + create_snmp_counters(ConnHandle), + ConnData = PrelData#conn_data{conn_handle = ConnHandle}, + trans_sender_upgrade(ConnData), + ets:insert(megaco_local_conn, ConnData), + ets:delete(megaco_local_conn, PrelHandle), + update_snmp_counters(ConnHandle, PrelHandle), + TH = ConnHandle#megaco_conn_handle{local_mid = PrelMid, + remote_mid = RemoteMid}, + TD = ConnData#conn_data{conn_handle = TH}, + ?report_debug(TD, + "Upgrade preliminary_mid to " + "actual remote_mid", + [{preliminary_mid, preliminary_mid}, + {local_mid, LocalMid}, + {remote_mid, RemoteMid}]), + {ok, ConnData} + end; + [_ConnData] -> + {error, {already_connected, ConnHandle}} + end. + +handle_finish_connect(ConnHandle, SendHandle, ControlPid, MFA) -> + case (catch ets:lookup(megaco_local_conn, ConnHandle)) of + [#conn_data{monitor_ref = connected} = CD] -> + {M, F, A} = MFA, + Ref = megaco_monitor:apply_at_exit(M, F, A, ControlPid), + ConnData2 = CD#conn_data{monitor_ref = Ref, + control_pid = ControlPid, + send_handle = SendHandle}, + ets:insert(megaco_local_conn, ConnData2), + {ok, Ref}; + [#conn_data{monitor_ref = Ref}] -> + {ok, Ref}; + [] -> + {error, {no_such_connection, ConnHandle}} + end. + + +%% also trans_req == true +trans_sender_start(#conn_data{conn_handle = CH, + auto_ack = true, + trans_ack = true, + trans_ack_maxcount = AcksMax, + trans_req_maxcount = ReqsMax, + trans_req_maxsize = ReqsMaxSz, + trans_timer = To, + trans_sender = undefined} = CD) + when To > 0 -> + + ?d("trans_sender_start(ack) -> entry when" + "~n CH: ~p" + "~n To: ~p" + "~n AcksMax: ~p" + "~n ReqsMax: ~p" + "~n ReqsMaxSz: ~p", [CH, To, ReqsMaxSz, ReqsMax, AcksMax]), + + {ok, Pid} = megaco_trans_sup:start_trans_sender(CH, To, ReqsMaxSz, + ReqsMax, AcksMax), + + ?d("trans_sender_start(ack) -> Pid: ~p", [Pid]), + + %% Make sure we are notified when/if the transaction + %% sender goes down. + %% Do we need to store the ref? Will we ever need to + %% cancel this (apply_at_exit)? + megaco_monitor:apply_at_exit(?MODULE, trans_sender_exit, [CH], Pid), + + CD#conn_data{trans_sender = Pid}; + +trans_sender_start(#conn_data{conn_handle = CH, + trans_req = true, + trans_ack_maxcount = AcksMax, + trans_req_maxcount = ReqsMax, + trans_req_maxsize = ReqsMaxSz, + trans_timer = To, + trans_sender = undefined} = CD) + when To > 0 -> + + ?d("trans_sender_start(req) -> entry when" + "~n CH: ~p" + "~n To: ~p" + "~n AcksMax: ~p" + "~n ReqsMax: ~p" + "~n ReqsMaxSz: ~p", [CH, To, ReqsMaxSz, ReqsMax, AcksMax]), + + {ok, Pid} = megaco_trans_sup:start_trans_sender(CH, To, ReqsMaxSz, + ReqsMax, AcksMax), + + ?d("trans_sender_start(req) -> Pid: ~p", [Pid]), + + %% Make sure we are notified when/if the transaction + %% sender goes down. + %% Do we need to store the ref? Will we ever need to + %% cancel this (apply_at_exit)? + megaco_monitor:apply_at_exit(?MODULE, trans_sender_exit, [CH], Pid), + + CD#conn_data{trans_sender = Pid}; + +trans_sender_start(CD) -> + ?d("trans_sender_start -> undefined", []), + CD#conn_data{trans_sender = undefined}. + +trans_sender_upgrade(#conn_data{conn_handle = CH, + trans_sender = Pid}) + when is_pid(Pid) -> + ?d("trans_sende_upgrade -> entry when" + "~n CH: ~p" + "~n Pid: ~p", [CH, Pid]), + megaco_trans_sender:upgrade(Pid, CH); +trans_sender_upgrade(_CD) -> + ok. + + +handle_connect_remote(ConnHandle, UserNode, Ref) -> + Pat = #remote_conn_data{conn_handle = ConnHandle, + user_node = UserNode, + monitor_ref = '_'}, + case ets:match_object(megaco_remote_conn, Pat) of + [] -> + RCD = #remote_conn_data{conn_handle = ConnHandle, + user_node = UserNode, + monitor_ref = Ref}, + ets:insert(megaco_remote_conn, RCD), + ok; + _ -> + {error, {already_connected, ConnHandle, UserNode}} + end. + +init_conn_data(RH, RemoteMid, SendHandle, ControlPid) -> + init_conn_data(RH, RemoteMid, SendHandle, ControlPid, auto). +init_conn_data(RH, RemoteMid, SendHandle, ControlPid, Auto) -> + Mid = RH#megaco_receive_handle.local_mid, + ConnHandle = #megaco_conn_handle{local_mid = Mid, + remote_mid = RemoteMid}, + EncodingMod = RH#megaco_receive_handle.encoding_mod, + EncodingConfig = RH#megaco_receive_handle.encoding_config, + SendMod = RH#megaco_receive_handle.send_mod, + MonitorRef = + case Auto of + auto -> + undefined_auto_monitor_ref; + {plain, ConnectorPid} -> + {connecting, ConnectorPid} + end, + #conn_data{conn_handle = ConnHandle, + serial = undefined_serial, + max_serial = user_info(Mid, max_trans_id), + request_timer = user_info(Mid, request_timer), + long_request_timer = user_info(Mid, long_request_timer), + + auto_ack = user_info(Mid, auto_ack), + trans_ack = user_info(Mid, trans_req), + trans_req = user_info(Mid, trans_req), + + trans_timer = user_info(Mid, trans_timer), + trans_req_maxsize = user_info(Mid, trans_req_maxsize), + trans_req_maxcount = user_info(Mid, trans_req_maxcount), + trans_ack_maxcount = user_info(Mid, trans_ack_maxcount), + + pending_timer = user_info(Mid, pending_timer), + sent_pending_limit = user_info(Mid, sent_pending_limit), + recv_pending_limit = user_info(Mid, recv_pending_limit), + reply_timer = user_info(Mid, reply_timer), + control_pid = ControlPid, + monitor_ref = MonitorRef, + send_mod = SendMod, + send_handle = SendHandle, + encoding_mod = EncodingMod, + encoding_config = EncodingConfig, + protocol_version = user_info(Mid, protocol_version), + auth_data = user_info(Mid, auth_data), + user_mod = user_info(Mid, user_mod), + user_args = user_info(Mid, user_args), + reply_action = undefined, + reply_data = user_info(Mid, reply_data), + threaded = user_info(Mid, threaded), + strict_version = user_info(Mid, strict_version), + long_request_resend = user_info(Mid, long_request_resend), + call_proxy_gc_timeout = user_info(Mid, call_proxy_gc_timeout), + cancel = false, + resend_indication = user_info(Mid, resend_indication), + segment_reply_ind = user_info(Mid, segment_reply_ind), + segment_recv_acc = user_info(Mid, segment_recv_acc), + segment_recv_timer = user_info(Mid, segment_recv_timer), + segment_send = user_info(Mid, segment_send), + segment_send_timer = user_info(Mid, segment_send_timer), + max_pdu_size = user_info(Mid, max_pdu_size), + request_keep_alive_timeout = user_info(Mid, request_keep_alive_timeout) + }. + +handle_disconnect(ConnHandle) when is_record(ConnHandle, megaco_conn_handle) -> + case ets:lookup(megaco_local_conn, ConnHandle) of + [ConnData] -> + ets:delete(megaco_local_conn, ConnHandle), + RemoteConnData = handle_disconnect_remote(ConnHandle, '_'), + {ok, ConnData, RemoteConnData}; + [] -> + {error, {already_disconnected, ConnHandle}} + end. + +handle_disconnect_remote(ConnHandle, UserNode) -> + Pat = #remote_conn_data{conn_handle = ConnHandle, + user_node = UserNode, + monitor_ref = '_'}, + RemoteConnData = ets:match_object(megaco_remote_conn, Pat), + ets:match_delete(megaco_remote_conn, Pat), + RemoteConnData. + +make_receive_handle(UserMid) -> + #megaco_receive_handle{local_mid = UserMid, + encoding_mod = user_info(UserMid, encoding_mod), + encoding_config = user_info(UserMid, encoding_config), + send_mod = user_info(UserMid, send_mod)}. + + +%%----------------------------------------------------------------- +%% Func: create_snmp_counters/1, update_snmp_counters/2 +%% Description: create/update all the SNMP statistic counters +%%----------------------------------------------------------------- + +create_snmp_counters(CH) -> + create_snmp_counters(CH, snmp_counters()). + +% create_snmp_counters(CH, []) -> +% ok; +% create_snmp_counters(CH, [Counter|Counters]) -> +% Key = {CH, Counter}, +% ets:insert(megaco_stats, {Key, 0}), +% create_snmp_counters(CH, Counters). + +create_snmp_counters(CH, Counters) -> + F = fun(Counter) -> + Key = {CH, Counter}, + ets:insert(megaco_stats, {Key, 0}) + end, + lists:foreach(F, Counters). + + +update_snmp_counters(CH, PrelCH) -> + update_snmp_counters(CH, PrelCH, snmp_counters()). + +update_snmp_counters(_CH, _PrelCH, []) -> + ok; +update_snmp_counters(CH, PrelCH, [Counter|Counters]) -> + PrelKey = {PrelCH, Counter}, + Key = {CH, Counter}, + [{PrelKey,PrelVal}] = ets:lookup(megaco_stats, PrelKey), + ets:update_counter(megaco_stats, Key, PrelVal), + ets:delete(megaco_stats, PrelKey), + update_snmp_counters(CH, PrelCH, Counters). + + +global_snmp_counters() -> + [medGwyGatewayNumErrors]. + +snmp_counters() -> + [medGwyGatewayNumTimerRecovery, + medGwyGatewayNumErrors]. + + + +%%----------------------------------------------------------------- + +%% Time in milli seconds +%% t() -> +%% {A,B,C} = erlang:now(), +%% A*1000000000+B*1000+(C div 1000). + + +%%----------------------------------------------------------------- + +warning_msg(F, A) -> + ?megaco_warning("Config server: " ++ F, A). + +error_msg(F, A) -> + ?megaco_error("Config server: " ++ F, A). + |