The R13B03 release.OTP_R13B03

1 files changed, 888 insertions, 0 deletions

diff --git a/lib/snmp/src/agent/snmp_target_mib.erl b/lib/snmp/src/agent/snmp_target_mib.erl
new file mode 100644
index 0000000000..a3ac67b533
--- /dev/null
+++ b/lib/snmp/src/agent/snmp_target_mib.erl
@@ -0,0 +1,888 @@
+%% 
+%% %CopyrightBegin%
+%% 
+%% Copyright Ericsson AB 1998-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%
+%% 
+-module(snmp_target_mib).
+
+-export([configure/1, reconfigure/1,
+	 snmpTargetSpinLock/1, snmpTargetSpinLock/2,
+	 snmpTargetAddrTable/1, snmpTargetAddrTable/3,
+	 snmpTargetParamsTable/1, snmpTargetParamsTable/3,
+	 get_target_addrs/0, get_target_engine_id/1, set_target_engine_id/2,
+	 is_valid_tag/3, get/3, table_next/2]).
+-export([add_addr/10,  delete_addr/1,
+	 add_params/5, delete_params/1]).
+-export([check_target_addr/1, check_target_params/1]).
+
+-include("snmp_types.hrl").
+-include("snmp_tables.hrl").
+-include("SNMP-TARGET-MIB.hrl").
+-include("SNMPv2-TC.hrl").
+-include("SNMPv2-TM.hrl").
+-include("SNMP-FRAMEWORK-MIB.hrl").
+
+-define(VMODULE,"TARGET-MIB").
+-include("snmp_verbosity.hrl").
+
+
+%% Column not accessible via SNMP - needed when the agent sends informs
+-define(snmpTargetAddrEngineId, 10).
+%% Extra comlumns for the augmented table snmpTargetAddrExtTable
+-define(snmpTargetAddrTMask, 11).
+-define(snmpTargetAddrMMS, 12).
+
+
+%%-----------------------------------------------------------------
+%% Func: configure/1
+%% Args: Dir is the directory where the configuration files are found.
+%% Purpose: If the tables doesn't exist, this function reads
+%%          the config-files for the target tables, and
+%%          inserts the data.  This means that the data in the tables
+%%          survive a reboot.  However, the StorageType column is
+%%          checked for each row.  If volatile, the row is deleted.
+%% Returns: ok
+%% Fails: exit(configuration_error)
+%%-----------------------------------------------------------------
+configure(Dir) ->
+    set_sname(),
+    case db(snmpTargetParamsTable) of
+        {_, mnesia} ->
+            ?vdebug("tables in mnesia: init vars & cleanup",[]),
+            init_vars(),
+            gc_tabs();
+	TabDb ->
+	    case snmpa_local_db:table_exists(TabDb) of
+		true ->
+		    ?vdebug("tables already exist: init vars & cleanup",[]),
+		    init_vars(),
+		    gc_tabs();
+		false ->
+		    ?vdebug("no tables: reconfigure",[]),
+		    reconfigure(Dir)
+	    end
+    end.
+
+
+%%-----------------------------------------------------------------
+%% Func: reconfigure/1
+%% Args: Dir is the directory where the configuration files are found.
+%% Purpose: Reads the config-files for the target tables, and
+%%          inserts the data.  Makes sure that all old data in
+%%          the tables are deleted, and the new data inserted.
+%%          This function makes sure that all (and only) 
+%%          config-file-data are in the tables. 
+%% Returns: ok
+%% Fails: exit(configuration_error)
+%%-----------------------------------------------------------------
+reconfigure(Dir) ->
+    set_sname(),
+    case (catch do_reconfigure(Dir)) of
+	ok ->
+	    ok;
+	{error, Reason} ->
+	    ?vinfo("reconfigure error: ~p", [Reason]),
+	    config_err("reconfigure failed: ~p", [Reason]),
+	    exit(configuration_error);
+	Error ->
+	    ?vinfo("reconfigure failed: ~p", [Error]),
+	    config_err("reconfigure failed: ~p", [Error]),
+	    exit(configuration_error)
+    end.
+
+do_reconfigure(Dir) ->
+    ?vdebug("read target configuration files",[]),
+    {Addrs, Params} = read_target_config_files(Dir),
+    ?vdebug("initiate tables",[]),
+    init_tabs(Addrs, Params),
+    ?vdebug("initiate vars",[]),
+    init_vars(),
+    ?vdebug("invalidate cache for notification mib",[]),
+    snmp_notification_mib:invalidate_cache(),
+    ok.
+
+
+read_target_config_files(Dir) ->
+    ?vdebug("check target address config file",[]),
+    TAGen    = fun(_D) -> ok end,
+    TAFilter = fun(Addr) -> Addr end,
+    TACheck  = fun(Entry) -> check_target_addr(Entry) end,
+
+    TPGen    = fun(_D) -> ok end,
+    TPFilter = fun(Params) -> Params end,
+    TPCheck  = fun(Entry) -> check_target_params(Entry) end,
+
+    [Addrs, Params] = 
+        snmp_conf:read_files(Dir, 
+			     [{TAGen, TAFilter, TACheck, "target_addr.conf"},
+			      {TPGen, TPFilter, TPCheck, "target_params.conf"}]),
+    {Addrs, Params}.
+
+
+%%-----------------------------------------------------------------
+%%  TargetAddr
+%%  {Name, Ip, Udp, Timeout, RetryCount, TagList, Params, EngineId,
+%%   TMask, MMS}
+%%-----------------------------------------------------------------
+check_target_addr({Name, Ip, Udp, Timeout, RetryCount, TagList,
+                   Params, EngineId, TMask, MMS}) ->
+    ?vtrace("check target address with:"
+	"~n   Name:       ~s"
+	"~n   Ip:         ~p"
+	"~n   Udp:        ~p"
+	"~n   Timeout:    ~p"
+	"~n   RetryCount: ~p"
+	"~n   TagList:    ~p"
+	"~n   Params:     ~p"
+	"~n   EngineId:   ~p"
+	"~n   TMask:      ~p"
+	"~n   MMS:        ~p",
+    [Name,Ip,Udp,Timeout,RetryCount,
+     TagList,Params,EngineId,TMask,MMS]),
+    snmp_conf:check_string(Name,{gt,0}),
+    snmp_conf:check_ip(Ip),
+    snmp_conf:check_integer(Udp, {gt, 0}),
+    snmp_conf:check_integer(Timeout, {gte, 0}),
+    snmp_conf:check_integer(RetryCount, {gte,0}),
+    snmp_conf:check_string(TagList),
+    snmp_conf:check_string(Params),
+    check_engine_id(EngineId),
+    TAddr = Ip ++ [Udp div 256, Udp rem 256],
+    check_mask(TMask, TAddr),
+    snmp_conf:check_packet_size(MMS),
+    ?vtrace("check target address done",[]),
+    
+    Addr = {Name, ?snmpUDPDomain, TAddr, Timeout,
+	    RetryCount, TagList, Params,
+	    ?'StorageType_nonVolatile', ?'RowStatus_active', EngineId,
+            TMask, MMS}, % Values for Augmenting table in SNMP-COMMUNITY-MIB
+    {ok, Addr};
+check_target_addr({Name, Ip, Udp, Timeout, RetryCount, TagList, Params, 
+                   EngineId}) ->
+    check_target_addr({Name, Ip, Udp, Timeout, RetryCount, TagList,
+                       Params, EngineId, [], 2048});
+%% Use dummy engine id if the old style is found
+check_target_addr({Name, Ip, Udp, Timeout, RetryCount, TagList, Params}) ->
+    check_target_addr({Name, Ip, Udp, Timeout, RetryCount, TagList,
+                       Params, "dummy", [], 2048});
+%% Use dummy engine id if the old style is found
+check_target_addr({Name, Ip, Udp, Timeout, RetryCount, TagList, Params, 
+		   TMask, MMS}) ->
+    check_target_addr({Name, Ip, Udp, Timeout, RetryCount, TagList,
+                       Params, "dummy", TMask, MMS});
+check_target_addr(X) ->
+    error({invalid_target_addr, X}).
+
+
+check_engine_id(discovery) ->
+    ok;
+check_engine_id(EngineId) ->
+    snmp_conf:check_string(EngineId).
+
+check_mask([], _TAddr) ->
+    ok;
+check_mask(TMask, TAddr) when length(TMask) == length(TAddr) ->
+    snmp_conf:check_taddress(TMask);
+check_mask(TMask, _TAddr) ->
+    throw({error, {invalid_mask, TMask}}).
+
+
+%%-----------------------------------------------------------------
+%%  TargetParams
+%%  {Name, MPModel, SecurityModel, SecurityName, SecurityLevel}
+%%-----------------------------------------------------------------
+check_target_params({Name, MPModel, SecModel, SecName, SecLevel}) ->
+    snmp_conf:check_string(Name,{gt,0}),
+    {ok, MP} = snmp_conf:check_atom(MPModel, [{v1,  ?MP_V1},
+					      {v2c, ?MP_V2C},
+					      {v3,  ?MP_V3}]),
+    {ok, SecM} = snmp_conf:check_sec_model(SecModel, [any]),
+    snmp_conf:check_string(SecName),
+    {ok, SecL} = snmp_conf:check_sec_level(SecLevel),
+    Params = {Name, MP, SecM, SecName, SecL, 
+	      ?'StorageType_nonVolatile', ?'RowStatus_active'},
+    {ok, Params};
+check_target_params(X) ->
+    error({invalid_target_params, X}).
+
+
+
+%% maybe_create_table(Name) ->
+%%     case snmpa_local_db:table_exists(db(Name)) of
+%% 	true -> ok;
+%% 	_ -> snmpa_local_db:table_create(db(Name))
+%%     end.
+
+init_tabs(Addrs, Params) ->
+    ?vdebug("create target address table",[]),
+    AddrDB = db(snmpTargetAddrTable),
+    snmpa_local_db:table_delete(AddrDB),
+    snmpa_local_db:table_create(AddrDB),
+    init_addr_table(Addrs),
+    ?vdebug("create target params table",[]),
+    ParmDB = db(snmpTargetParamsTable),
+    snmpa_local_db:table_delete(ParmDB),
+    snmpa_local_db:table_create(ParmDB),
+    init_params_table(Params).
+
+init_addr_table([Row | T]) ->
+    Key = element(1, Row),
+    snmpa_local_db:table_create_row(db(snmpTargetAddrTable), Key, Row),
+    init_addr_table(T);
+init_addr_table([]) -> true.
+
+init_params_table([Row | T]) ->
+    Key = element(1, Row),
+    snmpa_local_db:table_create_row(db(snmpTargetParamsTable), Key, Row),
+    init_params_table(T);
+init_params_table([]) -> true.
+
+table_cre_row(Tab, Key, Row) ->
+    snmpa_mib_lib:table_cre_row(db(Tab), Key, Row).
+
+table_del_row(Tab, Key) ->
+    snmpa_mib_lib:table_del_row(db(Tab), Key).
+
+
+add_addr(Name, Ip, Port, Timeout, Retry, TagList, 
+	 Params, EngineId, TMask, MMS) ->
+    Addr = {Name, Ip, Port, Timeout, Retry, TagList, 
+	    Params, EngineId, TMask, MMS},
+    case (catch check_target_addr(Addr)) of
+	{ok, Row} ->
+	    Key = element(1, Row),
+	    case table_cre_row(snmpTargetAddrTable, Key, Row) of
+		true ->
+		    {ok, Key};
+		false ->
+		    {error, create_failed}
+	    end;
+	{error, Reason} ->
+	    {error, Reason};
+	Error ->
+	    {error, Error}
+    end.
+
+delete_addr(Key) ->
+    case table_del_row(snmpTargetAddrTable, Key) of
+	true ->
+	    ok;
+	false ->
+	    {error, delete_failed}
+    end.
+
+
+add_params(Name, MPModel, SecModel, SecName, SecLevel) ->
+    Params = {Name, MPModel, SecModel, SecName, SecLevel},
+    case (catch check_target_params(Params)) of
+	{ok, Row} ->
+	    Key = element(1, Row),
+	    case table_cre_row(snmpTargetParamsTable, Key, Row) of
+		true ->
+		    {ok, Key};
+		false ->
+		    {create_failed}
+	    end;
+	{error, Reason} ->
+	    {error, Reason};
+	Error ->
+	    {error, Error}
+    end.
+
+delete_params(Key) ->
+    case table_del_row(snmpTargetParamsTable, Key) of
+	true ->
+	    ok;
+	false ->
+	    {error, delete_failed}
+    end.
+
+    
+gc_tabs() ->
+    AddrDB  = db(snmpTargetAddrTable),
+    AddrSTC = stc(snmpTargetAddrTable),
+    AddrFOI = foi(snmpTargetAddrTable),
+    snmpa_mib_lib:gc_tab(AddrDB, AddrSTC, AddrFOI),
+    ParmDB  = db(snmpTargetParamsTable),
+    ParmSTC = stc(snmpTargetParamsTable),
+    ParmFOI = foi(snmpTargetParamsTable),
+    snmpa_mib_lib:gc_tab(ParmDB, ParmSTC, ParmFOI),
+    ok.
+
+
+%%-----------------------------------------------------------------
+%% Counter functions
+%%-----------------------------------------------------------------
+init_vars() -> 
+    ?vtrace("initiate vars",[]),
+    lists:map(fun maybe_create_var/1, vars()).
+
+maybe_create_var(Var) ->
+    case ets:lookup(snmp_agent_table, Var) of
+	[_] -> ok;
+	_ -> init_var(Var)
+    end.
+
+init_var(Var) -> ets:insert(snmp_agent_table, {Var, 0}).
+
+vars() ->
+    [snmpUnavailableContexts,
+     snmpUnknownContexts].
+
+%%-----------------------------------------------------------------
+%% API functions
+%%-----------------------------------------------------------------
+is_valid_tag("", _TDomain, _TAddress) ->
+    true;
+is_valid_tag(Tag, TDomain, TAddress) ->
+    is_valid_tag(TDomain, TAddress, Tag, []).
+
+is_valid_tag(TDomain, TAddress, Tag, Key) ->
+    case table_next(snmpTargetAddrTable, Key) of
+	endOfTable -> 
+	    false;
+	NextKey -> 
+	    case get(snmpTargetAddrTable, NextKey, [?snmpTargetAddrTDomain,
+						    ?snmpTargetAddrTAddress,
+						    ?snmpTargetAddrTagList,
+						    ?snmpTargetAddrTMask]) of
+		[{value, TDomain},  % must match exactly
+		 {value, TAddress}, % RFC2576: chapters 5.2.1 & 5.3
+		 {value, TagList}, 
+		 {value, []}] ->
+		    case snmp_misc:is_tag_member(Tag, TagList) of
+			true ->
+			    ?vtrace("is_valid_tag -> exact: "
+				    "tag IS member of taglist", []),
+			    true;
+			false ->
+			    ?vtrace("is_valid_tag -> exact: "
+				    "tag is NOT member of taglist", []),
+			    is_valid_tag(TDomain, TAddress,
+					 Tag, NextKey)
+		    end;
+		[{value, TDomain},   % must match exactly
+		 {value, TAddress2},
+		 {value, TagList}, 
+		 {value, TMask}] when TMask =/= [] ->
+		    case snmp_misc:is_tmask_match(TAddress, TAddress2, 
+						  TMask) of
+			true ->
+			    case snmp_misc:is_tag_member(Tag, TagList) of
+				true ->
+				    ?vtrace("is_valid_tag -> masked: "
+					    "tag IS member of taglist", []),
+				    true;
+				false ->
+				    ?vtrace("is_valid_tag -> masked: "
+					    "tag is NOT member of taglist",[]),
+				    is_valid_tag(TDomain, TAddress,
+						 Tag, NextKey)
+			    end;
+			false ->
+			    is_valid_tag(TDomain, TAddress,
+					 Tag, NextKey)
+		    end;
+		_ ->
+		    is_valid_tag(TDomain, TAddress, Tag, NextKey)
+	    end
+    end.
+    
+
+%% TargAddrs =
+%%     [{TagList, TargetAddr, TargetAddrName, TargetParams, Timeout, Retry}]
+%%   TargetAddr = {TDomain, TAddr}; e.g. {?snmpUDPDomain, IpAndUdpPortAsList}
+get_target_addrs() ->
+    get_target_addrs([], db(snmpTargetAddrTable), []).
+
+
+get_target_addrs(Key, {Tab, _} = TabDb, Acc) ->
+    case table_next(Tab, Key) of
+	endOfTable -> 
+	    Acc;
+	NextKey ->
+	    case get_target_addr(TabDb, NextKey) of
+		{ok, Targ} ->
+		    get_target_addrs(NextKey, TabDb, [Targ| Acc]);
+		{error, Reason} ->
+		    ?vlog("failed getting target address: "
+			  "~n   Reason: ~p", [Reason]),
+		    get_target_addrs(NextKey, TabDb, Acc)
+	    end
+    end.
+
+get_target_addr({Tab, mnesia}, Key) ->
+    case mnesia:snmp_get_row(Tab, Key) of
+	{ok, #snmpTargetAddrTable{
+	   snmpTargetAddrTDomain    = TDomain,
+	   snmpTargetAddrTAddress   = TAddress,
+	   snmpTargetAddrTimeout    = Timeout,
+	   snmpTargetAddrRetryCount = RetryCount,
+	   snmpTargetAddrTagList    = TagList,
+	   snmpTargetAddrParams     = Params,
+	   snmpTargetAddrRowStatus  = ?'RowStatus_active'}} ->
+	    case get_target_params(Params) of
+		undefined ->
+		    config_err("Failed retreiving target params [~p]"
+			       "~n   for ~p [~p]", [Params, Key, TAddress]),
+		    {error, {not_found, {target_params, Key, Params}}};
+		TargetParams ->
+		    Targ = {TagList, {TDomain, TAddress}, Key,
+			    TargetParams, Timeout, RetryCount},
+		    {ok, Targ}
+	    end;
+	_ ->
+	    {error, {not_found, {target_addr, Key}}}
+    end;
+get_target_addr(TabDb, Key) ->
+    case snmpa_local_db:table_get_row(TabDb, Key) of
+	{_Key, TDomain, TAddress, Timeout, RetryCount, TagList, Params,
+	 _Storage, ?'RowStatus_active', _TargetEngineId,_TMask,_MMS} ->
+	    case get_target_params(Params) of
+		undefined ->
+		    config_err("Failed retreiving target params [~p]"
+			       "~n   for target ~p [~p]", 
+			       [Params, Key, TAddress]),
+		    {error, {not_found, {target_params, Key, Params}}};
+		TargetParams ->
+		    Targ = {TagList, {TDomain, TAddress}, Key,
+			    TargetParams, Timeout, RetryCount},
+		    {ok, Targ}
+	    end;
+	_ ->
+	    {error, {not_found, {target_addr, Key}}}
+     end.
+    
+
+get_target_params(Params) ->
+    case snmpTargetParamsTable(get, Params, [?snmpTargetParamsMPModel,
+					     ?snmpTargetParamsSecurityModel,
+					     ?snmpTargetParamsSecurityName,
+					     ?snmpTargetParamsSecurityLevel,
+					     ?snmpTargetParamsRowStatus]) of
+	[{value, MpModel}, 
+	 {value, SecModel}, {value, SecName}, {value, SecLevel},
+	 {value, ?'RowStatus_active'}] ->
+	    {MpModel, SecModel, SecName, SecLevel};
+	_ ->
+	    undefined
+    end.
+
+get_target_engine_id(TargetAddrName) ->
+    case db(snmpTargetAddrTable) of
+        {_, mnesia} ->
+            case mnesia:snmp_get_row(snmpTargetAddrTable, TargetAddrName) of
+                {ok, T} -> 
+		    {ok, T#snmpTargetAddrTable.snmpTargetAddrEngineId};
+                _ -> 
+		    undefined
+            end;
+        TabDb ->
+	    case snmpa_local_db:table_get_element(TabDb,
+						  TargetAddrName,
+						  ?snmpTargetAddrEngineId) of
+		{value, Val} -> 
+		    {ok, Val};
+		_ ->
+		    undefined
+	    end
+    end.
+				    
+set_target_engine_id(TargetAddrName, EngineId) ->
+    snmp_generic:table_set_elements(db(snmpTargetAddrTable),
+				    TargetAddrName,
+				    [{?snmpTargetAddrEngineId, EngineId}]).
+
+%%-----------------------------------------------------------------
+%% Instrumentation Functions
+%%-----------------------------------------------------------------
+snmpTargetSpinLock(new) ->
+    snmp_generic:variable_func(new, {snmpTargetSpinLock, volatile}),
+    {A1,A2,A3} = erlang:now(),
+    random:seed(A1,A2,A3),
+    Val = random:uniform(2147483648) - 1,
+    snmp_generic:variable_func(set, Val, {snmpTargetSpinLock, volatile});
+
+snmpTargetSpinLock(delete) ->
+    ok;
+
+snmpTargetSpinLock(get) ->
+    snmp_generic:variable_func(get, {snmpTargetSpinLock, volatile}).
+
+snmpTargetSpinLock(is_set_ok, NewVal) ->
+    case snmp_generic:variable_func(get, {snmpTargetSpinLock, volatile}) of
+	{value, NewVal} -> noError;
+	_ -> inconsistentValue
+    end;
+snmpTargetSpinLock(set, NewVal) ->
+    snmp_generic:variable_func(set, (NewVal + 1) rem 2147483648,
+			       {snmpTargetSpinLock, volatile}).
+
+
+%% Op = print - Used for debugging purposes
+snmpTargetAddrTable(print) ->
+    Table = snmpTargetAddrTable, 
+    DB    = db(Table),
+    FOI   = foi(Table),
+    PrintRow = 
+	fun(Prefix, Row) ->
+		lists:flatten(
+		  io_lib:format("~sName:              ~p"
+				"~n~sTDomain:           ~p (~w)"
+				"~n~sTAddress:          ~p (~s)"
+				"~n~sTimeout:           ~p"
+				"~n~sRetryCount:        ~p"
+				"~n~sTagList:           ~p"
+				"~n~sParams:            ~p"
+				"~n~sStorageType:       ~p (~w)"
+				"~n~sStatus:            ~p (~w)"
+				"~n~s[NonAcc] EngineID: ~p"
+				"~n~s[Ext] TMask:       ~p"
+				"~n~s[Ext] MMS:         ~p", 
+				[Prefix, element(?snmpTargetAddrName, Row),
+				 Prefix, element(?snmpTargetAddrTDomain, Row),
+				 case element(?snmpTargetAddrTDomain, Row) of
+				     ?snmpUDPDomain -> udp;
+				     _ -> undefined
+				 end,
+				 Prefix, element(?snmpTargetAddrTAddress, Row),
+				 case element(?snmpTargetAddrTAddress, Row) of
+				     [A,B,C,D,U1,U2] ->
+					 lists:flatten(
+					   io_lib:format("~w.~w.~w.~w:~w", 
+							 [A, B, C, D, U1 bsl 8 + U2]));
+				     _ -> "-"
+				 end,
+				 Prefix, element(?snmpTargetAddrTimeout, Row),
+				 Prefix, element(?snmpTargetAddrRetryCount, Row),
+				 Prefix, element(?snmpTargetAddrTagList, Row),
+				 Prefix, element(?snmpTargetAddrParams, Row),
+				 Prefix, element(?snmpTargetAddrStorageType, Row),
+				 case element(?snmpTargetAddrStorageType, Row) of
+				     ?'snmpTargetAddrStorageType_readOnly' -> readOnly;
+				     ?'snmpTargetAddrStorageType_permanent' -> permanent;
+				     ?'snmpTargetAddrStorageType_nonVolatile' -> nonVolatile;
+				     ?'snmpTargetAddrStorageType_volatile' -> volatile;
+				     ?'snmpTargetAddrStorageType_other' -> other;
+				     _ -> undefined
+				 end,
+				 Prefix, element(?snmpTargetAddrRowStatus, Row),
+				 case element(?snmpTargetAddrRowStatus, Row) of
+				     ?'snmpTargetAddrRowStatus_destroy' -> destroy;
+				     ?'snmpTargetAddrRowStatus_createAndWait' -> createAndWait;
+				     ?'snmpTargetAddrRowStatus_createAndGo' -> createAndGo;
+				     ?'snmpTargetAddrRowStatus_notReady' -> notReady;
+				     ?'snmpTargetAddrRowStatus_notInService' -> notInService;
+				     ?'snmpTargetAddrRowStatus_active' -> active;
+				     _ -> undefined
+				 end,
+				 Prefix,
+				 element(?snmpTargetAddrEngineId, Row),
+				 Prefix,
+				 element(?snmpTargetAddrTMask, Row),
+				 Prefix,
+				 element(?snmpTargetAddrMMS, Row)]))
+	end,
+    snmpa_mib_lib:print_table(Table, DB, FOI, PrintRow);
+%% Op == new | delete
+snmpTargetAddrTable(Op) ->
+    snmp_generic:table_func(Op, db(snmpTargetAddrTable)).
+
+%% Op == get | is_set_ok | set | get_next
+snmpTargetAddrTable(get, RowIndex, Cols) ->
+    get(snmpTargetAddrTable, RowIndex, Cols);
+snmpTargetAddrTable(get_next, RowIndex, Cols) ->
+    next(snmpTargetAddrTable, RowIndex, Cols);
+snmpTargetAddrTable(set, RowIndex, Cols0) ->
+    %% BMK BMK BMK
+    case (catch verify_targetAddrTable_cols(Cols0, [])) of
+	{ok, Cols} ->
+	    snmp_notification_mib:invalidate_cache(),
+	    %% Add columns for augmenting table snmpTargetAddrExtTable and for
+	    %% target engine ID.  Target engine ID is set to "".  The function
+	    %% get_target_engine_id will return "" unless a value is set using
+	    %% set_target_engine_id.  If it is "" Informs can't be sent to the
+	    %% target.
+	    NCols = Cols ++ [{?snmpTargetAddrEngineId, ""},
+			     {?snmpTargetAddrTMask, []},
+			     {?snmpTargetAddrMMS, 2048}],
+	    Db = db(snmpTargetAddrTable), 
+	    snmp_generic:table_func(set, RowIndex, NCols, Db);
+	Error ->
+	    Error
+    end;
+snmpTargetAddrTable(is_set_ok, RowIndex, Cols0) ->
+    case (catch verify_targetAddrTable_cols(Cols0, [])) of
+	{ok, Cols} ->
+	    %% Add columns for augmenting table snmpTargetAddrExtTable and for
+	    %% target engine ID.  Target engine ID is set to "".  The function
+	    %% get_target_engine_id will return "" unless a value is set using
+	    %% set_target_engine_id.  If it is "" Informs can't be sent to the
+	    %% target.
+	    NCols = Cols ++ [{?snmpTargetAddrEngineId, ""},
+			     {?snmpTargetAddrTMask, []},
+			     {?snmpTargetAddrMMS, 2048}],
+	    Db = db(snmpTargetAddrTable), 
+	    snmp_generic:table_func(is_set_ok, RowIndex, NCols, Db);
+	Error ->
+	    Error
+    end;
+snmpTargetAddrTable(Op, Arg1, Arg2) ->
+    Db = db(snmpTargetAddrTable), 
+    snmp_generic:table_func(Op, Arg1, Arg2, Db).
+
+verify_targetAddrTable_cols([], Cols) ->
+    {ok, lists:reverse(Cols)};
+verify_targetAddrTable_cols([{Col, Val0}|Cols], Acc) ->
+    Val = verify_targetAddrTable_col(Col, Val0),
+    verify_targetAddrTable_cols(Cols, [{Col, Val}|Acc]).
+
+verify_targetAddrTable_col(?snmpTargetAddrName, Name) ->
+    case (catch snmp_conf:check_string(Name)) of
+	ok ->
+	    Name;
+	_ ->
+	    wrongValue(?snmpTargetAddrName)
+    end;
+verify_targetAddrTable_col(?snmpTargetAddrTAddress, TAddr) ->
+    case (catch snmp_conf:check_taddress(TAddr)) of
+	ok ->
+	    TAddr;
+	_ ->
+	    wrongValue(?snmpTargetAddrTAddress)
+    end;
+verify_targetAddrTable_col(?snmpTargetAddrTimeout, Timeout) ->
+    case (catch snmp_conf:check_integer(Timeout)) of
+	ok when Timeout >= 0 ->
+	    Timeout;
+	_ ->
+	    wrongValue(?snmpTargetAddrTimeout)
+    end;
+verify_targetAddrTable_col(?snmpTargetAddrRetryCount, Retry) ->
+    case (catch snmp_conf:check_integer(Retry)) of
+	ok when Retry >= 0 ->
+	    Retry;
+	_ ->
+	    wrongValue(?snmpTargetAddrRetryCount)
+    end;
+verify_targetAddrTable_col(?snmpTargetAddrTagList, TagList) ->
+    case (catch snmp_conf:check_string(TagList)) of
+	ok ->
+	    TagList;
+	_ ->
+	    wrongValue(?snmpTargetAddrTagList)
+    end;
+verify_targetAddrTable_col(?snmpTargetAddrParams, Params) ->
+    case (catch snmp_conf:check_string(Params)) of
+	ok ->
+	    Params;	
+	_ ->
+	    wrongValue(?snmpTargetAddrParams)
+    end;
+verify_targetAddrTable_col(_, Val) ->
+    Val.
+    
+
+%% Op = print - Used for debugging purposes
+snmpTargetParamsTable(print) ->
+    Table = snmpTargetParamsTable, 
+    DB    = db(Table),
+    FOI   = foi(Table),
+    PrintRow = 
+	fun(Prefix, Row) ->
+		lists:flatten(
+		  io_lib:format("~sName:          ~p"
+				"~n~sMPModel:       ~p (~w)"
+				"~n~sSecurityModel: ~p (~w)"
+				"~n~sSecurityName:  ~p"
+				"~n~sSecurityLevel: ~p (~w)"
+				"~n~sStorageType:   ~p (~w)"
+				"~n~sStatus:        ~p (~w)", 
+				[Prefix, 
+				 element(?snmpTargetParamsName, Row),
+				 Prefix, 
+				 element(?snmpTargetParamsMPModel, Row),
+				 case element(?snmpTargetParamsMPModel, Row) of
+				     ?MP_V1 -> v1;
+				     ?MP_V2C -> v2c;
+				     ?MP_V3 -> v3;
+				     _ -> undefined
+				 end,
+				 Prefix, 
+				 element(?snmpTargetParamsSecurityModel, Row),
+				 case element(?snmpTargetParamsSecurityModel, Row) of
+				     ?SEC_ANY -> any;
+				     ?SEC_V1 -> v1;
+				     ?SEC_V2C -> v2c;
+				     ?SEC_USM -> usm;
+				     _ -> undefined
+				 end,
+				 Prefix, 
+				 element(?snmpTargetParamsSecurityName, Row),
+				 Prefix, 
+				 element(?snmpTargetParamsSecurityLevel, Row),
+				 case element(?snmpTargetParamsSecurityLevel, Row) of
+				     ?'SnmpSecurityLevel_noAuthNoPriv' -> noAuthNoPriv;
+				     ?'SnmpSecurityLevel_authNoPriv' -> authNoPriv;
+				     ?'SnmpSecurityLevel_authPriv' -> authPriv;
+				     _ -> undefined
+				 end,
+				 Prefix, 
+				 element(?snmpTargetParamsStorageType, Row),
+				 case element(?snmpTargetParamsStorageType, Row) of
+				     ?'snmpTargetParamsStorageType_readOnly' -> readOnly;
+				     ?'snmpTargetParamsStorageType_permanent' -> permanent;
+				     ?'snmpTargetParamsStorageType_nonVolatile' -> nonVolatile;
+				     ?'snmpTargetParamsStorageType_volatile' -> volatile;
+				     ?'snmpTargetParamsStorageType_other' -> other;
+				     _ -> undefined
+				 end,
+				 Prefix, 
+				 element(?snmpTargetParamsRowStatus, Row),
+				 case element(?snmpTargetParamsRowStatus, Row) of
+				     ?'snmpTargetParamsRowStatus_destroy' -> destroy;
+				     ?'snmpTargetParamsRowStatus_createAndWait' -> createAndWait;
+				     ?'snmpTargetParamsRowStatus_createAndGo' -> createAndGo;
+				     ?'snmpTargetParamsRowStatus_notReady' -> notReady;
+				     ?'snmpTargetParamsRowStatus_notInService' -> notInService;
+				     ?'snmpTargetParamsRowStatus_active' -> active;
+				     _ -> undefined
+				 end]))
+	end,
+    snmpa_mib_lib:print_table(Table, DB, FOI, PrintRow);
+%% Op == new | delete
+snmpTargetParamsTable(Op) ->
+    snmp_generic:table_func(Op, db(snmpTargetParamsTable)).
+
+%% Op == get | is_set_ok | set | get_next
+snmpTargetParamsTable(get, RowIndex, Cols) ->
+    %% BMK BMK BMK
+    get(snmpTargetParamsTable, RowIndex, Cols);
+snmpTargetParamsTable(get_next, RowIndex, Cols) ->
+    %% BMK BMK BMK
+    next(snmpTargetParamsTable, RowIndex, Cols);
+snmpTargetParamsTable(set, RowIndex, Cols0) ->
+    %% BMK BMK BMK
+    case (catch verify_snmpTargetParamsTable_cols(Cols0, [])) of
+	{ok, Cols} ->
+	    snmp_notification_mib:invalidate_cache(),
+	    snmp_generic:table_func(set, RowIndex, Cols, 
+				    db(snmpTargetParamsTable));
+	Error ->
+	    Error
+    end;
+snmpTargetParamsTable(Op, Arg1, Arg2) ->
+    snmp_generic:table_func(Op, Arg1, Arg2, db(snmpTargetParamsTable)).
+
+verify_snmpTargetParamsTable_cols([], Cols) ->
+    {ok, lists:reverse(Cols)};
+verify_snmpTargetParamsTable_cols([{Col, Val0}|Cols], Acc) ->
+    Val = verify_snmpTargetParamsTable_col(Col, Val0),
+    verify_snmpTargetParamsTable_cols(Cols, [{Col, Val}|Acc]).
+
+verify_snmpTargetParamsTable_col(?snmpTargetParamsName, Name) ->
+    case (catch snmp_conf:check_string(Name)) of
+	ok ->
+	    Name;
+	_ ->
+	    wrongValue(?snmpTargetParamsName)
+    end;
+verify_snmpTargetParamsTable_col(?snmpTargetParamsMPModel, Model) ->
+    case Model of
+	v1      -> ?MP_V1;
+	v2c     -> ?MP_V2C;
+	v3      -> ?MP_V3;
+	?MP_V1  -> ?MP_V1;
+	?MP_V2C -> ?MP_V2C;
+	?MP_V3  -> ?MP_V3;
+	_       -> wrongValue(?snmpTargetParamsMPModel)
+    end;
+verify_snmpTargetParamsTable_col(?snmpTargetParamsSecurityModel, Model) ->
+    case Model of
+	v1       -> ?SEC_V1;
+	v2c      -> ?SEC_V2C;
+	usm      -> ?SEC_USM;
+	?SEC_V1  -> ?SEC_V1;
+	?SEC_V2C -> ?SEC_V2C;
+	?SEC_USM -> ?SEC_USM;
+	_        -> wrongValue(?snmpTargetParamsSecurityModel)
+    end;
+verify_snmpTargetParamsTable_col(?snmpTargetParamsSecurityName, Name) ->
+    case (catch snmp_conf:check_string(Name)) of
+	ok ->
+	    Name;
+	_ ->
+	    wrongValue(?snmpTargetParamsSecurityName)
+    end;
+verify_snmpTargetParamsTable_col(?snmpTargetParamsSecurityLevel, Level) ->
+    case Level of
+	noAuthNoPriv -> 1;
+	authNoPriv   -> 2;
+	authPriv     -> 3;
+	1            -> 1;
+	2            -> 2;
+	3            -> 3;
+	_            -> wrongValue(?snmpTargetParamsSecurityLevel)
+    end;
+verify_snmpTargetParamsTable_col(_, Val) ->
+    Val.
+
+db(X) -> snmpa_agent:db(X).
+
+fa(snmpTargetAddrTable) -> ?snmpTargetAddrTDomain;
+fa(snmpTargetParamsTable) -> ?snmpTargetParamsMPModel.
+ 
+foi(snmpTargetAddrTable) -> ?snmpTargetAddrName;
+foi(snmpTargetParamsTable) -> ?snmpTargetParamsName.
+ 
+noc(snmpTargetAddrTable) -> 9;
+noc(snmpTargetParamsTable) -> 7.
+
+stc(snmpTargetAddrTable) -> ?snmpTargetAddrStorageType;
+stc(snmpTargetParamsTable) -> ?snmpTargetParamsStorageType.
+ 
+next(Name, RowIndex, Cols) ->
+    snmp_generic:handle_table_next(db(Name), RowIndex, Cols,
+                                   fa(Name), foi(Name), noc(Name)).
+
+table_next(Name, RestOid) ->
+    snmp_generic:table_next(db(Name), RestOid).
+
+ 
+get(Name, RowIndex, Cols) ->
+    snmp_generic:handle_table_get(db(Name), RowIndex, Cols, foi(Name)).
+
+
+wrongValue(V) -> throw({wrongValue, V}).
+
+
+%% -----
+
+set_sname() ->
+    set_sname(get(sname)).
+
+set_sname(undefined) ->
+    put(sname,conf);
+set_sname(_) -> %% Keep it, if already set.
+    ok.
+    
+error(Reason) ->
+    throw({error, Reason}).
+
+config_err(F, A) ->
+    snmpa_error:config_err("[TARGET-MIB]: " ++ F, A).
+
+