%%
%% %CopyrightBegin%
%%
%% Copyright Ericsson AB 2004-2014. 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(snmpa_net_if).
-behaviour(snmpa_network_interface).
-export([start_link/4,
info/1,
verbosity/2]).
-export([get_log_type/1, set_log_type/2]).
-export([get_request_limit/1, set_request_limit/2]).
-export([system_continue/3, system_terminate/4, system_code_change/4]).
-export([init/5]).
-export([filter_reset/1]).
-include("snmp_types.hrl").
-include("snmpa_internal.hrl").
-include("snmpa_atl.hrl").
-include("snmp_debug.hrl").
-include("snmp_verbosity.hrl").
-record(state, {parent,
note_store,
master_agent,
usock,
usock_opts,
mpd_state,
log,
reqs = [],
debug = false,
limit = infinity,
rcnt = [],
filter}).
-ifndef(default_verbosity).
-define(default_verbosity,silence).
-endif.
-define(DEFAULT_FILTER_MODULE, snmpa_net_if_filter).
-define(DEFAULT_FILTER_OPTS, [{module, ?DEFAULT_FILTER_MODULE}]).
-define(ATL_SEQNO_INITIAL, 1).
-define(ATL_SEQNO_MAX, 2147483647).
%%%-----------------------------------------------------------------
%%% This module implements the default Network Interface part
%%% of the SNMP agent. It uses UDP, and read the agent.conf to find
%%% the UDP port.
%%%
%%% Opts = [Opt]
%%% Opt = {verbosity,silence | log | debug} |
%%% {bind_to, bool()} |
%%% {recbuf,integer()} |
%%% {no_reuse, bool()} |
%%% {req_limit, integer() | infinity}
%%%-----------------------------------------------------------------
start_link(Prio, NoteStore, MasterAgent, Opts) ->
?d("start_link -> entry with"
"~n Prio: ~p"
"~n NoteStore: ~p"
"~n MasterAgent: ~p"
"~n Opts: ~p", [Prio, NoteStore, MasterAgent, Opts]),
Args = [Prio, NoteStore, MasterAgent, self(), Opts],
proc_lib:start_link(?MODULE, init, Args).
info(Pid) ->
case call(Pid, info) of
Info when is_list(Info) ->
Info;
_ ->
[]
end.
verbosity(Pid, Verbosity) ->
Pid ! {verbosity, Verbosity}.
get_log_type(Pid) ->
call(Pid, get_log_type).
set_log_type(Pid, NewType) ->
call(Pid, {set_log_type, NewType}).
get_request_limit(Pid) ->
call(Pid, get_request_limit).
set_request_limit(Pid, NewLimit) ->
call(Pid, {set_request_limit, NewLimit}).
get_port() ->
{value, UDPPort} = snmp_framework_mib:intAgentUDPPort(get),
UDPPort.
get_address() ->
{value, IPAddress} = snmp_framework_mib:intAgentIpAddress(get),
IPAddress.
filter_reset(Pid) ->
Pid ! filter_reset.
%%-----------------------------------------------------------------
%%-----------------------------------------------------------------
init(Prio, NoteStore, MasterAgent, Parent, Opts) ->
?d("init -> entry with"
"~n Prio: ~p"
"~n NoteStore: ~p"
"~n MasterAgent: ~p"
"~n Parent: ~p"
"~n Opts: ~p", [Prio, NoteStore, MasterAgent, Parent, Opts]),
case (catch do_init(Prio, NoteStore, MasterAgent, Parent, Opts)) of
{ok, State} ->
proc_lib:init_ack({ok, self()}),
try loop(State)
catch C:E ->
S = erlang:get_stacktrace(),
error_msg(
"loop/1 EXCEPTION ~w:~w~n"
" ~p", [C,E,S]),
erlang:raise(C, E, S)
end;
{error, Reason} ->
config_err("failed starting net-if: ~n~p", [Reason]),
proc_lib:init_ack({error, Reason});
Error ->
config_err("failed starting net-if: ~n~p", [Error]),
proc_lib:init_ack({error, Error})
end.
do_init(Prio, NoteStore, MasterAgent, Parent, Opts) ->
process_flag(trap_exit, true),
process_flag(priority, Prio),
%% -- Verbosity --
put(sname,nif),
put(verbosity,get_verbosity(Opts)),
?vlog("starting",[]),
%% -- Port and address --
UDPPort = get_port(),
?vdebug("port: ~w",[UDPPort]),
IPAddress = get_address(),
?vdebug("addr: ~w",[IPAddress]),
%% -- Versions --
Vsns = get_vsns(Opts),
?vdebug("vsns: ~w",[Vsns]),
%% Flow control --
Limit = get_req_limit(Opts),
?vdebug("Limit: ~w", [Limit]),
FilterOpts = get_filter_opts(Opts),
FilterMod = create_filter(FilterOpts),
?vdebug("FilterMod: ~w", [FilterMod]),
%% -- Audit trail log
Log = create_log(),
?vdebug("Log: ~w",[Log]),
%% -- Socket --
IPOpts1 = ip_opt_bind_to_ip_address(Opts, IPAddress),
IPOpts2 = ip_opt_no_reuse_address(Opts),
IPOpts3 = ip_opt_recbuf(Opts),
IPOpts4 = ip_opt_sndbuf(Opts),
IPOpts = [binary | IPOpts1 ++ IPOpts2 ++ IPOpts3 ++ IPOpts4],
?vdebug("open socket with options: ~w",[IPOpts]),
case gen_udp_open(UDPPort, IPOpts) of
{ok, Sock} ->
MpdState = snmpa_mpd:init(Vsns),
init_counters(),
active_once(Sock),
S = #state{parent = Parent,
note_store = NoteStore,
master_agent = MasterAgent,
mpd_state = MpdState,
usock = Sock,
usock_opts = IPOpts,
log = Log,
limit = Limit,
filter = FilterMod},
?vdebug("started with MpdState: ~p", [MpdState]),
{ok, S};
{error, Reason} ->
?vinfo("Failed to open UDP socket: ~p", [Reason]),
{error, {udp_open, UDPPort, Reason}}
end.
create_log() ->
case ets:lookup(snmp_agent_table, audit_trail_log) of
[] ->
{undefined, []};
[{audit_trail_log, AtlOpts}] ->
?vtrace("AtlOpts: ~p", [AtlOpts]),
Type = get_atl_type(AtlOpts),
Dir = get_atl_dir(AtlOpts),
Size = get_atl_size(AtlOpts),
Repair = get_atl_repair(AtlOpts),
Name = ?audit_trail_log_name,
File = filename:absname(?audit_trail_log_file, Dir),
case get_atl_seqno(AtlOpts) of
true ->
Initial = ?ATL_SEQNO_INITIAL,
Max = ?ATL_SEQNO_MAX,
Module = snmpa_agent,
Function = increment_counter,
Args = [atl_seqno, Initial, Max],
SeqNoGen = {Module, Function, Args},
case snmp_log:create(Name, File,
SeqNoGen, Size, Repair, true) of
{ok, Log} ->
?vdebug("log created: ~w", [Log]),
{Log, Type};
{error, Reason} ->
throw({error, {create_log, Reason}})
end;
_ ->
case snmp_log:create(Name, File, Size, Repair, true) of
{ok, Log} ->
?vdebug("log created: ~w", [Log]),
{Log, Type};
{error, Reason} ->
throw({error, {create_log, Reason}})
end
end
end.
create_filter(Opts) when is_list(Opts) ->
case get_filter_module(Opts) of
?DEFAULT_FILTER_MODULE = Mod ->
Mod;
Module ->
snmpa_network_interface_filter:verify(Module),
Module
end;
create_filter(BadOpts) ->
throw({error, {bad_filter_opts, BadOpts}}).
log({_, []}, _, _, _, _) ->
ok;
log({Log, Types}, 'set-request', Packet, Domain, Address) ->
case lists:member(write, Types) of
true ->
snmp_log:log(Log, Packet, Domain, Address);
false ->
ok
end;
log({Log, Types}, _, Packet, Domain, Address) ->
case lists:member(read, Types) of
true ->
snmp_log:log(Log, Packet, Domain, Address);
false ->
ok
end;
log(_, _, _, _, _) ->
ok.
gen_udp_open(Port, Opts) ->
case init:get_argument(snmp_fd) of
{ok, [[FdStr]]} ->
Fd = list_to_integer(FdStr),
gen_udp:open(0, [{fd, Fd}|Opts]);
error ->
case init:get_argument(snmpa_fd) of
{ok, [[FdStr]]} ->
Fd = list_to_integer(FdStr),
gen_udp:open(0, [{fd, Fd}|Opts]);
error ->
gen_udp:open(Port, Opts)
end
end.
loop(S) ->
receive
{udp, _UdpId, Ip, Port, Packet} ->
?vlog("got paket from ~w:~w",[Ip,Port]),
{Domain, Address} = snmp_conf:fix_domain_address(Ip, Port),
NewS = maybe_handle_recv(S, Domain, Address, Packet),
loop(NewS);
{info, ReplyRef, Pid} ->
Info = get_info(S),
Pid ! {ReplyRef, Info, self()},
loop(S);
%% response (to get/get_next/get_bulk/set requests)
{snmp_response, Vsn, RePdu, Type, ACMData, Dest, []} ->
?vlog("reply pdu: "
"~n ~s",
[?vapply(snmp_misc, format, [256, "~w", [RePdu]])]),
NewS = maybe_handle_reply_pdu(S, Vsn, RePdu, Type, ACMData, Dest),
loop(NewS);
%% Traps/notification
{send_pdu, Vsn, Pdu, MsgData, To} ->
?vdebug("send pdu: "
"~n Pdu: ~p"
"~n To: ~p", [Pdu, To]),
NewS = maybe_handle_send_pdu(S, Vsn, Pdu, MsgData, To, undefined),
loop(NewS);
%% We dont use the extra-info at this time, ...
{send_pdu, Vsn, Pdu, MsgData, To, _ExtraInfo} ->
?vdebug("send pdu: "
"~n Pdu: ~p"
"~n To: ~p", [Pdu, To]),
NewS = maybe_handle_send_pdu(S, Vsn, Pdu, MsgData, To, undefined),
loop(NewS);
%% Informs
{send_pdu_req, Vsn, Pdu, MsgData, To, From} ->
?vdebug("send pdu request: "
"~n Pdu: ~p"
"~n To: ~p"
"~n From: ~p",
[Pdu, To, toname(From)]),
NewS = maybe_handle_send_pdu(S, Vsn, Pdu, MsgData, To, From),
loop(NewS);
%% We dont use the extra-info at this time, ...
{send_pdu_req, Vsn, Pdu, MsgData, To, From, _ExtraInfo} ->
?vdebug("send pdu request: "
"~n Pdu: ~p"
"~n To: ~p"
"~n From: ~p",
[Pdu, To, toname(From)]),
NewS = maybe_handle_send_pdu(S, Vsn, Pdu, MsgData, To, From),
loop(NewS);
%% Discovery Inform
%% <BACKWARD-COMPAT>
{send_discovery, Pdu, MsgData, To, From} ->
?vdebug("received send discovery request: "
"~n Pdu: ~p"
"~n To: ~p"
"~n From: ~p",
[Pdu, To, toname(From)]),
NewS = handle_send_discovery(S, Pdu, MsgData, To, From),
loop(NewS);
%% </BACKWARD-COMPAT>
%% Discovery Inform
{send_discovery, Pdu, MsgData, To, From, ExtraInfo} ->
?vdebug("received send discovery request: "
"~n Pdu: ~p"
"~n To: ~p"
"~n From: ~p"
"~n ExtraInfo: ~p",
[Pdu, To, toname(From), ExtraInfo]),
NewS = handle_send_discovery(S, Pdu, MsgData, To, From),
loop(NewS);
{discarded_pdu, _Vsn, ReqId, _ACMData, Variable, _Extra} ->
?vdebug("discard PDU: ~p", [Variable]),
snmpa_mpd:discarded_pdu(Variable),
NewS = update_req_counter_outgoing(S, ReqId),
loop(NewS);
{get_log_type, ReplyRef, Pid} ->
?vdebug("get log type: ~p", []),
#state{log = {_, LogType}} = S,
Pid ! {ReplyRef, {ok, LogType}, self()},
loop(S);
{{set_log_type, NewType}, ReplyRef, Pid} ->
?vdebug("set log type: ~p", [NewType]),
{NewState, Reply} = (catch handle_set_log_type(S, NewType)),
Pid ! {ReplyRef, Reply, self()},
loop(NewState);
{get_request_limit, ReplyRef, Pid} ->
?vdebug("get request limit: ~p", []),
#state{limit = Limit} = S,
Pid ! {ReplyRef, {ok, Limit}, self()},
loop(S);
{{set_request_limit, NewLimit}, ReplyRef, Pid} ->
?vdebug("set request limit: ~p", [NewLimit]),
{NewState, Reply} = (catch handle_set_request_limit(S, NewLimit)),
Pid ! {ReplyRef, Reply, self()},
loop(NewState);
{disk_log, _Node, Log, Info} ->
?vdebug("disk log event: ~p, ~p", [Log, Info]),
NewS = handle_disk_log(Log, Info, S),
loop(NewS);
{verbosity, Verbosity} ->
?vlog("verbosity: ~p -> ~p", [get(verbosity), Verbosity]),
put(verbosity, snmp_verbosity:validate(Verbosity)),
loop(S);
filter_reset ->
reset_counters(),
loop(S);
{'EXIT', Parent, Reason} when Parent == S#state.parent ->
?vlog("parent (~p) exited: "
"~n ~p", [Parent, Reason]),
exit(Reason);
{'EXIT', Port, Reason} when Port == S#state.usock ->
UDPPort = get_port(),
NewS =
case gen_udp_open(UDPPort, S#state.usock_opts) of
{ok, Id} ->
error_msg("Port ~p exited for reason"
"~n ~p"
"~n Re-opened (~p)", [Port, Reason, Id]),
S#state{usock = Id};
{error, ReopenReason} ->
error_msg("Port ~p exited for reason"
"~n ~p"
"~n Re-open failed with reason"
"~n ~p",
[Port, Reason, ReopenReason]),
ok
end,
loop(NewS);
{'EXIT', Port, Reason} when is_port(Port) ->
error_msg("Exit message from port ~p for reason ~p~n",
[Port, Reason]),
loop(S);
{'EXIT', Pid, Reason} ->
?vlog("~p exited: "
"~n ~p", [Pid, Reason]),
NewS = clear_reqs(Pid, S),
loop(NewS);
{system, From, Msg} ->
?vdebug("system event ~p from ~p", [Msg, From]),
sys:handle_system_msg(Msg, From, S#state.parent, ?MODULE, [], S);
_ ->
loop(S)
end.
update_req_counter_incomming(#state{limit = infinity, usock = Sock} = S, _) ->
active_once(Sock), %% No limit so activate directly
S;
update_req_counter_incomming(#state{limit = Limit,
rcnt = RCnt,
usock = Sock} = S, Rid)
when length(RCnt) + 1 == Limit ->
%% Ok, one more and we are at the limit.
%% Just make sure we are not already processing this one...
case lists:member(Rid, RCnt) of
false ->
%% We are at the limit, do _not_ activate socket
S#state{rcnt = [Rid|RCnt]};
true ->
active_once(Sock),
S
end;
update_req_counter_incomming(#state{rcnt = RCnt,
usock = Sock} = S, Rid) ->
active_once(Sock),
case lists:member(Rid, RCnt) of
false ->
S#state{rcnt = [Rid|RCnt]};
true ->
S
end.
update_req_counter_outgoing(#state{limit = infinity} = S, _Rid) ->
%% Already activated (in the incoming function)
S;
update_req_counter_outgoing(#state{limit = Limit,
rcnt = RCnt,
usock = Sock} = S, Rid)
when length(RCnt) == Limit ->
?vtrace("handle_req_counter_outgoing(~w) -> entry with"
"~n Rid: ~w"
"~n length(RCnt): ~w", [Limit, Rid, length(RCnt)]),
case lists:delete(Rid, RCnt) of
NewRCnt when length(NewRCnt) < Limit ->
?vtrace("update_req_counter_outgoing -> "
"passed below limit: activate", []),
active_once(Sock),
S#state{rcnt = NewRCnt};
_ ->
S
end;
update_req_counter_outgoing(#state{limit = Limit, rcnt = RCnt} = S,
Rid) ->
?vtrace("handle_req_counter_outgoing(~w) -> entry with"
"~n Rid: ~w"
"~n length(RCnt): ~w", [Limit, Rid, length(RCnt)]),
NewRCnt = lists:delete(Rid, RCnt),
S#state{rcnt = NewRCnt}.
maybe_handle_recv(#state{usock = Sock, filter = FilterMod} = S,
Domain, Address, Packet) ->
case (catch FilterMod:accept_recv(Domain, Address)) of
false ->
%% Drop the received packet
inc(netIfMsgInDrops),
active_once(Sock),
S;
_ ->
handle_recv(S, Domain, Address, Packet)
end.
handle_discovery_response(_Domain, _Address, #pdu{request_id = ReqId} = Pdu,
ManagerEngineId,
#state{usock = Sock, reqs = Reqs} = S) ->
case lists:keysearch(ReqId, 1, S#state.reqs) of
{value, {_, Pid}} ->
active_once(Sock),
Pid ! {snmp_discovery_response_received, Pdu, ManagerEngineId},
NReqs = lists:keydelete(ReqId, 1, Reqs),
S#state{reqs = NReqs};
_ ->
%% Ouch, timeout? resend?
S
end.
handle_recv(#state{usock = Sock,
mpd_state = MpdState,
note_store = NS,
log = Log} = S, Domain, Address, Packet) ->
put(n1, erlang:now()),
LogF = fun(Type, Data) ->
log(Log, Type, Data, Domain, Address)
end,
case (catch snmpa_mpd:process_packet(
Packet, Domain, Address, MpdState, NS, LogF)) of
{ok, _Vsn, Pdu, _PduMS, {discovery, ManagerEngineId}} ->
handle_discovery_response(Domain, Address, Pdu, ManagerEngineId, S);
{ok, _Vsn, Pdu, _PduMS, discovery} ->
handle_discovery_response(Domain, Address, Pdu, undefined, S);
{ok, Vsn, Pdu, PduMS, ACMData} ->
?vlog("got pdu ~s",
[?vapply(snmp_misc, format, [256, "~w", [Pdu]])]),
%% handle_recv_pdu(Domain, Address, Vsn, Pdu, PduMS, ACMData, S);
maybe_handle_recv_pdu(Domain, Address, Vsn, Pdu, PduMS, ACMData, S);
{discarded, Reason} ->
?vlog("packet discarded for reason: ~s",
[?vapply(snmp_misc, format, [256, "~w", [Reason]])]),
active_once(Sock),
S;
{discarded, Reason, ReportPacket} ->
?vlog("sending report for reason: "
"~n ~s",
[?vapply(snmp_misc, format, [256, "~w", [Reason]])]),
{Ip, Port} = Address,
(catch udp_send(S#state.usock, Ip, Port, ReportPacket)),
active_once(Sock),
S;
{discovery, ReportPacket} ->
?vlog("sending discovery report", []),
{Ip, Port} = Address,
(catch udp_send(S#state.usock, Ip, Port, ReportPacket)),
active_once(Sock),
S;
Error ->
error_msg("processing of received message failed: "
"~n ~p", [Error]),
active_once(Sock),
S
end.
maybe_handle_recv_pdu(
Domain, Address, Vsn,
#pdu{type = Type} = Pdu, PduMS, ACMData,
#state{usock = Sock, filter = FilterMod} = S) ->
case (catch FilterMod:accept_recv_pdu(Domain, Address, Type)) of
false ->
inc(netIfPduInDrops),
active_once(Sock),
ok;
_ ->
handle_recv_pdu(Domain, Address, Vsn, Pdu, PduMS, ACMData, S)
end;
maybe_handle_recv_pdu(Domain, Address, Vsn, Pdu, PduMS, ACMData, S) ->
handle_recv_pdu(Domain, Address, Vsn, Pdu, PduMS, ACMData, S).
handle_recv_pdu(
Domain, Address, Vsn,
#pdu{type = 'get-response'} = Pdu, _PduMS, _ACMData,
#state{usock = Sock} = S) ->
active_once(Sock),
handle_response(Vsn, Pdu, {Domain, Address}, S),
S;
handle_recv_pdu(Domain, Address, Vsn, #pdu{request_id = Rid, type = Type} = Pdu,
PduMS, ACMData, #state{master_agent = Pid} = S)
when ((Type =:= 'get-request') orelse
(Type =:= 'get-next-request') orelse
(Type =:= 'get-bulk-request')) ->
?vtrace("handle_recv_pdu -> received get (~w)", [Type]),
SourceAddress = {Domain, Address},
Pid ! {snmp_pdu, Vsn, Pdu, PduMS, ACMData, SourceAddress, []},
update_req_counter_incomming(S, Rid);
handle_recv_pdu(Domain, Address, Vsn, Pdu, PduMS, ACMData,
#state{usock = Sock, master_agent = Pid} = S) ->
?vtrace("handle_recv_pdu -> received other request", []),
active_once(Sock),
SourceAddress = {Domain, Address},
Pid ! {snmp_pdu, Vsn, Pdu, PduMS, ACMData, SourceAddress, []},
S.
maybe_handle_reply_pdu(
#state{filter = FilterMod} = S, Vsn,
#pdu{request_id = Rid} = Pdu,
Type, ACMData, DestinationAddress) ->
S1 = update_req_counter_outgoing(S, Rid),
case (catch FilterMod:accept_send_pdu([DestinationAddress], Type)) of
false ->
inc(netIfPduOutDrops),
ok;
_ ->
handle_reply_pdu(S1, Vsn, Pdu, Type, ACMData, DestinationAddress)
end,
S1.
handle_reply_pdu(#state{log = Log,
usock = Sock,
filter = FilterMod},
Vsn, Pdu, Type, ACMData, {Domain, Address}) ->
LogF = fun(Type2, Data) ->
log(Log, Type2, Data, Domain, Address)
end,
case (catch snmpa_mpd:generate_response_msg(Vsn, Pdu, Type,
ACMData, LogF)) of
{ok, Packet} ->
?vinfo("time in agent: ~w mysec", [time_in_agent()]),
maybe_udp_send(FilterMod, Sock, Domain, Address, Packet);
{discarded, Reason} ->
?vlog("handle_reply_pdu -> "
"~n reply discarded for reason: ~s",
[?vapply(snmp_misc, format, [256, "~w", [Reason]])]),
ok;
{'EXIT', Reason} ->
user_err("failed generating response message: "
"~nPDU: ~p~n~p", [Pdu, Reason])
end.
maybe_handle_send_pdu(
#state{filter = FilterMod} = S,
Vsn, Pdu, MsgData, To0, From) ->
?vtrace("maybe_handle_send_pdu -> entry with~n"
" FilterMod: ~p~n"
" To0: ~p", [FilterMod, To0]),
To = snmpa_mpd:process_taddrs(To0),
Destinations =
[case T of
{{Domain, _Address} = Destination, _SecData}
when is_atom(Domain) -> % v3
Destination;
{Domain, _Address} = Destination
when is_atom(Domain) -> % v1 & v2
Destination
end || T <- To],
case (catch FilterMod:accept_send_pdu(
Destinations, pdu_type_of(Pdu))) of
false ->
inc(netIfPduOutDrops),
ok;
true ->
handle_send_pdu(S, Vsn, Pdu, MsgData, To, From);
FilteredDestinations when is_list(FilteredDestinations) ->
MergedTo =
[T || T <- To,
case T of
{{Dom, _Addr} = Dest, _SData}
when is_atom(Dom) -> % v3
lists:member(
Dest, FilteredDestinations);
{Dom, _Addr} = Dest
when is_atom(Dom) -> % v1 & v2
lists:member(
Dest, FilteredDestinations)
end],
?vtrace("maybe_handle_send_pdu -> MergedTo:~n"
" ~p", [MergedTo]),
handle_send_pdu(S, Vsn, Pdu, MsgData, MergedTo, From);
Other ->
error_msg(
"FilterMod:accept_send_pdu/2 returned: ~p", [Other]),
handle_send_pdu(S, Vsn, Pdu, MsgData, To, From)
end.
handle_send_pdu(
#state{note_store = NS} = S, Vsn, Pdu, MsgData, To, From) ->
?vtrace("handle_send_pdu -> entry with~n"
" Pdu: ~p~n"
" To: ~p", [Pdu, To]),
case (catch snmpa_mpd:generate_msg(
Vsn, NS, Pdu, MsgData, To)) of
{ok, Addresses} ->
handle_send_pdu(S, Pdu, Addresses);
{discarded, Reason} ->
?vlog("handle_send_pdu -> "
"~n PDU ~p not sent due to ~p", [Pdu, Reason]),
ok;
{'EXIT', Reason} ->
user_err("failed generating message: "
"~nPDU: ~p~n~p", [Pdu, Reason]),
ok
end,
case From of
undefined ->
S;
Pid ->
?vtrace("link to ~p and add to request list", [Pid]),
link(Pid),
NReqs = snmp_misc:keyreplaceadd(
Pid, 2, S#state.reqs, {Pdu#pdu.request_id, From}),
S#state{reqs = NReqs}
end.
handle_send_discovery(
#state{note_store = NS,
log = Log,
usock = Sock,
reqs = Reqs} = S,
#pdu{type = Type,
request_id = ReqId} = Pdu,
MsgData, To, From) ->
?vtrace("handle_send_discovery -> entry with"
"~n Pdu: ~p"
"~n MsgData: ~p"
"~n To: ~p"
"~n From: ~p", [Pdu, MsgData, To, From]),
case (catch snmpa_mpd:generate_discovery_msg(NS, Pdu, MsgData, To)) of
{ok, {Domain, Address, Packet}} ->
log(Log, Type, Packet, Domain, Address),
{Ip, Port} = Address,
udp_send(Sock, Ip, Port, Packet),
?vtrace("handle_send_discovery -> sent (~w)", [ReqId]),
NReqs = snmp_misc:keyreplaceadd(From, 2, Reqs, {ReqId, From}),
S#state{reqs = NReqs};
{discarded, Reason} ->
?vlog("handle_send_discovery -> "
"~n Discovery PDU ~p not sent due to ~p", [Pdu, Reason]),
ok;
{'EXIT', Reason} ->
user_err("failed generating discovery message: "
"~n PDU: ~p"
"~n Reason: ~p", [Pdu, Reason]),
ok
end.
handle_send_pdu(S, #pdu{type = Type} = Pdu, Addresses) ->
handle_send_pdu(S, Type, Pdu, Addresses);
handle_send_pdu(S, Trap, Addresses) ->
handle_send_pdu(S, trappdu, Trap, Addresses).
handle_send_pdu(S, Type, Pdu, Addresses) ->
case (catch handle_send_pdu1(S, Type, Addresses)) of
{Reason, Sz} ->
error_msg("Cannot send message "
"~n size: ~p"
"~n reason: ~p"
"~n pdu: ~p",
[Sz, Reason, Pdu]);
_ ->
ok
end.
handle_send_pdu1(#state{log = Log,
usock = Sock,
filter = FilterMod}, Type, Addresses) ->
lists:foreach(
fun ({Domain, Address, Packet}) when is_binary(Packet) ->
?vdebug(
"[~w] sending packet:~n"
" size: ~p~n"
" to: ~p", [Domain, sz(Packet), Address]),
maybe_udp_send(
FilterMod, Log, Type, Sock, Domain, Address, Packet);
({Domain, Address, {Packet, _LogData}}) when is_binary(Packet) ->
?vdebug(
"[~w] sending encrypted packet:~n"
" size: ~p~n"
" to: ~p", [Domain, sz(Packet), Address]),
maybe_udp_send(
FilterMod, Log, Type, Sock, Domain, Address, Packet)
end,
Addresses).
handle_response(Vsn, Pdu, From, S) ->
case lists:keysearch(Pdu#pdu.request_id, 1, S#state.reqs) of
{value, {_, Pid}} ->
?vdebug("handle_response -> "
"~n send response to receiver ~p", [Pid]),
Pid ! {snmp_response_received, Vsn, Pdu, From};
_ ->
?vdebug("handle_response -> "
"~n No receiver available for response pdu", [])
end.
maybe_udp_send(FilterMod, Sock, Domain, Address, Packet) ->
case (catch FilterMod:accept_send(Domain, Address)) of
false ->
inc(netIfMsgOutDrops),
ok;
_ ->
{Ip, Port} = Address,
(catch udp_send(Sock, Ip, Port, Packet))
end.
maybe_udp_send(FilterMod, AtLog, Type, Sock, Domain, Address, Packet) ->
case (catch FilterMod:accept_send(Domain, Address)) of
false ->
inc(netIfMsgOutDrops),
ok;
_ ->
log(AtLog, Type, Packet, Domain, Address),
{Ip, Port} = Address,
(catch udp_send(Sock, Ip, Port, Packet))
end.
udp_send(UdpId, AgentIp, UdpPort, B) ->
case (catch gen_udp:send(UdpId, AgentIp, UdpPort, B)) of
{error, emsgsize} ->
%% From this message we cannot recover, so exit sending loop
throw({emsgsize, sz(B)});
{error, ErrorReason} ->
error_msg("[error] cannot send message "
"(destination: ~p:~p, size: ~p, reason: ~p)",
[AgentIp, UdpPort, sz(B), ErrorReason]);
{'EXIT', ExitReason} ->
error_msg("[exit] cannot send message "
"(destination: ~p:~p, size: ~p, reason: ~p)",
[AgentIp, UdpPort, sz(B), ExitReason]);
_ ->
ok
end.
sz(L) when is_list(L) -> length(L);
sz(B) when is_binary(B) -> size(B);
sz(_) -> undefined.
handle_disk_log(_Log, {wrap, NoLostItems}, State) ->
?vlog("Audit Trail Log - wrapped: ~w previously logged items where lost",
[NoLostItems]),
State;
handle_disk_log(_Log, {truncated, NoLostItems}, State) ->
?vlog("Audit Trail Log - truncated: ~w items where lost when truncating",
[NoLostItems]),
State;
handle_disk_log(_Log, full, State) ->
error_msg("Failure to write to Audit Trail Log (full)", []),
State;
handle_disk_log(_Log, {error_status, ok}, State) ->
State;
handle_disk_log(_Log, {error_status, {error, Reason}}, State) ->
error_msg("Error status received from Audit Trail Log: "
"~n~p", [Reason]),
State;
handle_disk_log(_Log, _Info, State) ->
State.
clear_reqs(Pid, S) ->
NReqs = lists:keydelete(Pid, 2, S#state.reqs),
S#state{reqs = NReqs}.
toname(P) when is_pid(P) ->
case process_info(P, registered_name) of
{registered_name, Name} ->
Name;
_ ->
P
end;
toname(Else) ->
Else.
active_once(Sock) ->
?vtrace("activate once", []),
inet:setopts(Sock, [{active, once}]).
%%%-----------------------------------------------------------------
handle_set_log_type(#state{log = {Log, OldValue}} = State, NewType)
when (Log /= undefined) ->
NewValue =
case NewType of
read ->
[read];
write ->
[write];
read_write ->
[read,write];
_ ->
throw({State, {error, {bad_atl_type, NewType}}})
end,
NewState = State#state{log = {Log, NewValue}},
OldType =
case {lists:member(read, OldValue),
lists:member(write, OldValue)} of
{true, true} ->
read_write;
{true, false} ->
read;
{false, true} ->
write;
{false, false} ->
throw({State, {error, {bad_atl_type, OldValue}}})
end,
{NewState, {ok, OldType}};
handle_set_log_type(State, _NewType) ->
{State, {error, not_enabled}}.
handle_set_request_limit(#state{limit = OldLimit} = State, NewLimit)
when ((is_integer(NewLimit) andalso (NewLimit >= 0)) orelse
(NewLimit == infinity)) ->
NewState = State#state{limit = NewLimit},
{NewState, {ok, OldLimit}};
handle_set_request_limit(State, BadLimit) ->
{State, {error, {bad_request_limit, BadLimit}}}.
%%%-----------------------------------------------------------------
%%% System messages
%%%-----------------------------------------------------------------
system_continue(_Parent, _Dbg, S) ->
loop(S).
system_terminate(Reason, _Parent, _Dbg, #state{log = Log}) ->
?vlog("system-terminate -> entry with"
"~n Reason: ~p", [Reason]),
do_close_log(Log),
exit(Reason).
system_code_change(OldState, _Module, _OldVsn, downgrade_to_pre_4_16) ->
{OldLog, Type} = OldState#state.log,
NewLog = snmp_log:downgrade(OldLog),
NewState = OldState#state{log = {NewLog, Type}},
{ok, NewState};
system_code_change(OldState, _Module, _OldVsn, upgrade_from_pre_4_16) ->
Initial = ?ATL_SEQNO_INITIAL,
Max = ?ATL_SEQNO_MAX,
Module = snmpa_agent,
Function = increment_counter,
Args = [atl_seqno, Initial, Max],
SeqNoGen = {Module, Function, Args},
{OldLog, Type} = OldState#state.log,
NewLog = snmp_log:upgrade(OldLog, SeqNoGen),
NewState = OldState#state{log = {NewLog, Type}},
{ok, NewState};
system_code_change(S, _Module, _OldVsn, _Extra) ->
{ok, S}.
do_close_log({undefined, []}) ->
ok;
do_close_log({Log, _}) ->
(catch snmp_log:sync(Log)),
(catch snmp_log:close(Log)),
ok;
do_close_log(_) ->
ok.
%%%-----------------------------------------------------------------
%%% DEBUG FUNCTIONS
%%%-----------------------------------------------------------------
time_in_agent() ->
subtr(erlang:now(), get(n1)).
subtr({X1,Y1,Z1}, {X1,Y1,Z2}) ->
Z1 - Z2;
subtr({X1,Y1,Z1}, {X1,Y2,Z2}) ->
((Y1-Y2) * 1000000) + (Z1 - Z2);
subtr({X1,Y1,Z1}, {X2,Y2,Z2}) ->
((X1 - X2) * 1000000000000) + ((Y1 - Y2) * 1000000) + (Z1 - Z2).
%% ----------------------------------------------------------------
pdu_type_of(#pdu{type = Type}) ->
Type;
pdu_type_of(TrapPdu) when is_record(TrapPdu, trappdu) ->
trap.
%%-----------------------------------------------------------------
%% Counter functions
%%-----------------------------------------------------------------
init_counters() ->
F = fun(Counter) -> maybe_create_counter(Counter) end,
lists:map(F, counters()).
reset_counters() ->
F = fun(Counter) -> init_counter(Counter) end,
lists:map(F, counters()).
maybe_create_counter(Counter) ->
case ets:lookup(snmp_agent_table, Counter) of
[_] -> ok;
_ -> init_counter(Counter)
end.
init_counter(Counter) ->
ets:insert(snmp_agent_table, {Counter, 0}).
counters() ->
[
netIfMsgOutDrops,
netIfMsgInDrops,
netIfPduOutDrops,
netIfPduInDrops
].
inc(Name) ->
ets:update_counter(snmp_agent_table, Name, 1).
get_counters() ->
Counters = counters(),
get_counters(Counters, []).
get_counters([], Acc) ->
lists:reverse(Acc);
get_counters([Counter|Counters], Acc) ->
case ets:lookup(snmp_agent_table, Counter) of
[CounterVal] ->
get_counters(Counters, [CounterVal|Acc]);
_ ->
get_counters(Counters, Acc)
end.
%% ----------------------------------------------------------------
ip_opt_bind_to_ip_address(Opts, Ip) ->
case get_bind_to_ip_address(Opts) of
true ->
[{ip, list_to_tuple(Ip)}];
_ ->
[]
end.
ip_opt_no_reuse_address(Opts) ->
case get_no_reuse_address(Opts) of
false ->
[{reuseaddr, true}];
_ ->
[]
end.
ip_opt_recbuf(Opts) ->
case get_recbuf(Opts) of
use_default ->
[];
Sz ->
[{recbuf, Sz}]
end.
ip_opt_sndbuf(Opts) ->
case get_sndbuf(Opts) of
use_default ->
[];
Sz ->
[{sndbuf, Sz}]
end.
%% ----------------------------------------------------------------
get_atl_type(Opts) ->
case snmp_misc:get_option(type, Opts, read_write) of
read_write ->
[read,write];
write ->
[write];
read ->
[read]
end.
get_atl_dir(Opts) ->
snmp_misc:get_option(dir, Opts).
get_atl_size(Opts) ->
snmp_misc:get_option(size, Opts).
get_atl_repair(Opts) ->
snmp_misc:get_option(repair, Opts, true).
get_atl_seqno(Opts) ->
snmp_misc:get_option(seqno, Opts, false).
get_verbosity(Opts) ->
snmp_misc:get_option(verbosity, Opts, ?default_verbosity).
get_vsns(Opts) ->
snmp_misc:get_option(versions, Opts, [v1, v2, v3]).
get_req_limit(O) ->
snmp_misc:get_option(req_limit, O, infinity).
get_filter_opts(O) ->
snmp_misc:get_option(filter, O, []).
get_filter_module(O) ->
snmp_misc:get_option(module, O, ?DEFAULT_FILTER_MODULE).
get_recbuf(Opts) ->
snmp_misc:get_option(recbuf, Opts, use_default).
get_sndbuf(Opts) ->
snmp_misc:get_option(sndbuf, Opts, use_default).
get_no_reuse_address(Opts) ->
snmp_misc:get_option(no_reuse, Opts, false).
get_bind_to_ip_address(Opts) ->
snmp_misc:get_option(bind_to, Opts, false).
%% ----------------------------------------------------------------
error_msg(F,A) ->
?snmpa_error("NET-IF server: " ++ F, A).
%% ---
user_err(F, A) ->
snmpa_error:user_err(F, A).
config_err(F, A) ->
snmpa_error:config_err(F, A).
%% ----------------------------------------------------------------
call(Pid, Req) ->
ReplyRef = make_ref(),
Pid ! {Req, ReplyRef, self()},
receive
{ReplyRef, Reply, Pid} ->
Reply
after 5000 ->
{error, timeout}
end.
%% ----------------------------------------------------------------
get_info(#state{usock = Id, reqs = Reqs}) ->
ProcSize = proc_mem(self()),
PortInfo = get_port_info(Id),
Counters = get_counters(),
[{reqs, Reqs},
{counters, Counters},
{process_memory, ProcSize},
{port_info, PortInfo}].
proc_mem(P) when is_pid(P) ->
case (catch erlang:process_info(P, memory)) of
{memory, Sz} when is_integer(Sz) ->
Sz;
_ ->
undefined
end.
%% proc_mem(_) ->
%% undefined.
get_port_info(Id) ->
PortInfo =
case (catch erlang:port_info(Id)) of
PI when is_list(PI) ->
[{port_info, PI}];
_ ->
[]
end,
PortStatus =
case (catch prim_inet:getstatus(Id)) of
{ok, PS} ->
[{port_status, PS}];
_ ->
[]
end,
PortAct =
case (catch inet:getopts(Id, [active])) of
{ok, PA} ->
[{port_act, PA}];
_ ->
[]
end,
PortStats =
case (catch inet:getstat(Id)) of
{ok, Stat} ->
[{port_stats, Stat}];
_ ->
[]
end,
IfList =
case (catch inet:getif(Id)) of
{ok, IFs} ->
[{interfaces, IFs}];
_ ->
[]
end,
BufSz =
case (catch inet:getopts(Id, [recbuf, sndbuf])) of
{ok, Sz} ->
[{buffer_size, Sz}];
_ ->
[]
end,
[{socket, Id}] ++
IfList ++
PortStats ++
PortInfo ++
PortStatus ++
PortAct ++
BufSz.
%% ----------------------------------------------------------------
% i(F) ->
% i(F, []).
% i(F, A) ->
% io:format("~p: " ++ F ++ "~n", [?MODULE|A]).
