aboutsummaryrefslogblamecommitdiffstats
path: root/lib/diameter/src/base/diameter_peer.erl
blob: 1ae8b567b1afbc30949ebc4f0637986d39df03fe (plain) (tree)
1
2
3
4


                   
                                                        















                                                                         




                                          
              

                   

                     
                 


                 
                    
























                                              




                                    


                                                                              
 

                                                     
 


                                                                              
 






                                                         
                                           


                                                               










                                                               

                     



















                                                                         
                                                            




                                                     
                   

                                                      





                                                                      


                                                       
                                                         






















                                                          
                        
                  



















                                                              
 

















                                                                              
                                                                      

                  
                          





                                                                              






                                               


                                                       


                                                                              



                               


                                                                              
 

                                      
 












                                                  
 


                                                                              



                                   


                                                                              



















                                                                              


                                                             



                   


                                                             







                                                    
                             

                        


                                                             

                          
                       

                     


                                                             


                                            
                                        


                           
                        
















                                                             








                                                            



                                                
%%
%% %CopyrightBegin%
%%
%% Copyright Ericsson AB 2010-2015. 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%
%%

-module(diameter_peer).
-behaviour(gen_server).

%% Interface towards transport modules ...
-export([recv/2,
         up/1,
         up/2,
         up/3,
         match/2]).

%% ... and the stack.
-export([start/1,
         send/2,
         close/1,
         abort/1,
         notify/3]).

%% Server start.
-export([start_link/0]).

%% gen_server callbacks
-export([init/1,
         terminate/2,
         handle_call/3,
         handle_cast/2,
         handle_info/2,
         code_change/3]).

%% debug
-export([state/0,
         uptime/0]).

-include_lib("diameter/include/diameter.hrl").
-include("diameter_internal.hrl").

%% Registered name of the server.
-define(SERVER, ?MODULE).

%% Server state.
-record(state, {id = now()}).

%% Default transport_module/config.
-define(DEFAULT_TMOD, diameter_tcp).
-define(DEFAULT_TCFG, []).
-define(DEFAULT_TTMO, infinity).

%% ---------------------------------------------------------------------------
%% # notify/3
%% ---------------------------------------------------------------------------

notify(Nodes, SvcName, T) ->
    rpc:abcast(Nodes, ?SERVER, {notify, SvcName, T}).

%% ---------------------------------------------------------------------------
%% # start/1
%% ---------------------------------------------------------------------------

-spec start({T, [Opt], #diameter_service{}})
   -> {TPid, [Addr], Tmo, Data}
    | {error, [term()]}
 when T    :: {connect|accept, diameter:transport_ref()},
      Opt  :: diameter:transport_opt(),
      TPid :: pid(),
      Addr :: inet:ip_address(),
      Tmo  :: non_neg_integer() | infinity,
      Data :: {{T, Mod, Cfg}, [Mod], [{T, [Mod], Cfg}], [Err]},
      Mod  :: module(),
      Cfg  :: term(),
      Err  :: term()
    ; ({#diameter_service{}, Tmo, Data})
   -> {TPid, [Addr], Tmo, Data}
    | {error, [term()]}
 when TPid :: pid(),
      Addr :: inet:ip_address(),
      Tmo  :: non_neg_integer() | infinity,
      Data :: {{T, Mod, Cfg}, [Mod], [{T, [Mod], Cfg}], [Err]},
      T    :: {connect|accept, diameter:transport_ref()},
      Mod  :: module(),
      Cfg  :: term(),
      Err  :: term().

%% Initial start.
start({T, Opts, #diameter_service{} = Svc}) ->
    start(T, Svc, pair(Opts, [], []), []);

%% Subsequent start.
start({#diameter_service{} = Svc, Tmo, {{T, _, Cfg}, Ms, Rest, Errs}}) ->
    start(T, Ms, Cfg, Svc, Tmo, Rest, Errs).

%% pair/3
%%
%% Pair transport modules with config.

%% Another transport_module: accumulate it.
pair([{transport_module, M} | Rest], Mods, Acc) ->
    pair(Rest, [M|Mods], Acc);

%% Another transport_config: accumulate another tuple.
pair([{transport_config = T, C} | Rest], Mods, Acc) ->
    pair([{T, C, ?DEFAULT_TTMO} | Rest], Mods, Acc);
pair([{transport_config, C, Tmo} | Rest], Mods, Acc) ->
    pair(Rest, [], acc({lists:reverse(Mods), C, Tmo}, Acc));

pair([_ | Rest], Mods, Acc) ->
    pair(Rest, Mods, Acc);

%% No transport_module or transport_config: defaults.
pair([], [], []) ->
    [{[?DEFAULT_TMOD], ?DEFAULT_TCFG, ?DEFAULT_TTMO}];

%% One transport_module, one transport_config: ignore option order.
%% That is, interpret [{transport_config, _}, {transport_module, _}]
%% as if the order was reversed, not as config with default module and
%% module with default config.
pair([], [_] = Mods, [{[], Cfg, Tmo}]) ->
    [{Mods, Cfg, Tmo}];

%% Trailing transport_module: default transport_config.
pair([], [_|_] = Mods, Acc) ->
    pair([{transport_config, ?DEFAULT_TCFG}], Mods, Acc);

pair([], [], Acc) ->
    lists:reverse(def(Acc)).

%% acc/2

acc(T, Acc) ->
    [T | def(Acc)].

%% def/1
%%
%% Default module of previous pair if none were specified.

def([{[], Cfg, Tmo} | Acc]) ->
    [{[?DEFAULT_TMOD], Cfg, Tmo} | Acc];
def(Acc) ->
    Acc.

%% start/4

start(T, Svc, [{Ms, Cfg, Tmo} | Rest], Errs) ->
    start(T, Ms, Cfg, Svc, Tmo, Rest, Errs);

start(_, _, [], Errs) ->
    {error, Errs}.

%% start/7

start(T, [], _, Svc, _, Rest, Errs) ->
    start(T, Svc, Rest, Errs);

start(T, [M|Ms], Cfg, Svc, Tmo, Rest, Errs) ->
    case start(M, [T, Svc, Cfg]) of
        {ok, TPid} ->
            {TPid, [], Tmo, {{T, M, Cfg}, Ms, Rest, Errs}};
        {ok, TPid, [_|_] = Addrs} ->
            {TPid, Addrs, Tmo, {{T, M, Cfg}, Ms, Rest, Errs}};
        E ->
            start(T, Ms, Cfg, Svc, Tmo, Rest, [E|Errs])
    end.

%% start/2

start(Mod, Args) ->
    apply(Mod, start, Args).

%% ---------------------------------------------------------------------------
%% # match/2
%% ---------------------------------------------------------------------------

match(Addrs, Matches)
  when is_list(Addrs) ->
    lists:all(fun(A) -> match1(A, Matches) end, Addrs).

match1(Addr, Matches)
  when not is_integer(hd(Matches)) ->
    lists:any(fun(M) -> match1(Addr, M) end, Matches);

match1(Addr, Match) ->
    match(Addr, addr(Match), Match).

match(Addr, {ok, A}, _) ->
    Addr == A;
match(Addr, {error, _}, RE) ->
    match == re:run(inet:ntoa(Addr), RE, [{capture, none}, caseless]).

addr([_|_] = A) ->
    inet:parse_address(A);
addr(A) ->
    {ok, A}.

%% ---------------------------------------------------------------------------
%% # up/1-3
%% ---------------------------------------------------------------------------

up(Pid) ->  %% accepting transport
    ifc_send(Pid, {self(), connected}).

up(Pid, Remote) ->  %% connecting transport
    ifc_send(Pid, {self(), connected, Remote}).

up(Pid, Remote, LAddrs) -> %% connecting transport
    ifc_send(Pid, {self(), connected, Remote, LAddrs}).

%% ---------------------------------------------------------------------------
%% # recv/2
%% ---------------------------------------------------------------------------

recv(Pid, Pkt) ->
    ifc_send(Pid, {recv, Pkt}).

%% ---------------------------------------------------------------------------
%% # send/2
%% ---------------------------------------------------------------------------

send(Pid, Msg) ->
    ifc_send(Pid, {send, strip(Msg)}).

%% Send only binary when possible.
strip(#diameter_packet{transport_data = undefined,
                       bin = Bin}) ->
    Bin;

%% Strip potentially large message terms.
strip(#diameter_packet{transport_data = T,
                       bin = Bin}) ->
    #diameter_packet{transport_data = T,
                     bin = Bin};

strip(Msg) ->
    Msg.

%% ---------------------------------------------------------------------------
%% # close/1
%% ---------------------------------------------------------------------------

close(Pid) ->
    ifc_send(Pid, {close, self()}).

%% ---------------------------------------------------------------------------
%% # abort/1
%% ---------------------------------------------------------------------------

abort(Pid) ->
    exit(Pid, shutdown).

%% ---------------------------------------------------------------------------
%% ---------------------------------------------------------------------------

start_link() ->
    ServerName = {local, ?SERVER},
    Module     = ?MODULE,
    Args       = [],
    Options    = [{spawn_opt, diameter_lib:spawn_opts(server, [])}],
    gen_server:start_link(ServerName, Module, Args, Options).

state() ->
    call(state).

uptime() ->
    call(uptime).

%% ----------------------------------------------------------
%% # init(Role)
%% ----------------------------------------------------------

init([]) ->
    {ok, #state{}}.

%% ----------------------------------------------------------
%% # handle_call(Request, From, State)
%% ----------------------------------------------------------

handle_call(state, _, State) ->
    {reply, State, State};

handle_call(uptime, _, #state{id = Time} = State) ->
    {reply, diameter_lib:now_diff(Time), State};

handle_call(Req, From, State) ->
    ?UNEXPECTED([Req, From]),
    {reply, nok, State}.

%% ----------------------------------------------------------
%% # handle_cast(Request, State)
%% ----------------------------------------------------------

handle_cast(Msg, State) ->
    ?UNEXPECTED([Msg]),
    {noreply, State}.

%% ----------------------------------------------------------
%% # handle_info(Request, State)
%% ----------------------------------------------------------

%% Remote service is distributing a message.
handle_info({notify, SvcName, T}, S) ->
    diameter_service:notify(SvcName, T),
    {noreply, S};

handle_info(Info, State) ->
    ?UNEXPECTED([Info]),
    {noreply, State}.

%% ----------------------------------------------------------
%% terminate(Reason, State)
%% ----------------------------------------------------------

terminate(_Reason, _State) ->
    ok.

%% ----------------------------------------------------------
%% code_change(OldVsn, State, Extra)
%% ----------------------------------------------------------

code_change(_OldVsn, State, _Extra) ->
    {ok, State}.

%% ---------------------------------------------------------
%% ---------------------------------------------------------

%% ifc_send/2
%%
%% Send something over the transport interface.

ifc_send(Pid, T) ->
    Pid ! {diameter, T}.

%% call/1

call(Request) ->
    gen_server:call(?SERVER, Request, infinity).