The R13B03 release.OTP_R13B03

1 files changed, 1226 insertions, 0 deletions

diff --git a/lib/snmp/src/agent/snmpa_local_db.erl b/lib/snmp/src/agent/snmpa_local_db.erl
new file mode 100644
index 0000000000..d9d6e633de
--- /dev/null
+++ b/lib/snmp/src/agent/snmpa_local_db.erl
@@ -0,0 +1,1226 @@
+%%
+%% %CopyrightBegin%
+%% 
+%% Copyright Ericsson AB 1996-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(snmpa_local_db).
+
+-include_lib("kernel/include/file.hrl").
+-include("snmpa_internal.hrl").
+-include("snmp_types.hrl").
+-include("STANDARD-MIB.hrl").
+
+%% -define(VMODULE, "LDB").
+-include("snmp_verbosity.hrl").
+
+
+%% External exports
+-export([start_link/3, start_link/4, stop/0, info/0, verbosity/1]).
+-export([dump/0, backup/1, 
+	 register_notify_client/2, unregister_notify_client/1]).
+-export([table_func/2, table_func/4,
+	 variable_get/1, variable_set/2, variable_delete/1, variable_inc/2,
+	 table_create/1, table_exists/1, table_delete/1,
+         table_create_row/3, table_create_row/4, table_construct_row/4,
+	 table_delete_row/2,
+	 table_get_row/2,
+         table_get_element/3, table_get_elements/4,
+	 table_set_elements/3, table_set_status/7,
+         table_next/2,
+	 table_max_col/2,
+	 table_get/1]).
+
+-export([get_elements/2]).
+
+-export([match/2]).
+
+%% Debug exports
+-export([print/0, print/1, print/2]).
+
+%% Internal exports
+-export([init/1, handle_call/3, handle_cast/2, handle_info/2, terminate/2, 
+	 code_change/3]).
+
+
+-define(BACKUP_TAB, snmpa_local_backup).
+-define(DETS_TAB,   snmpa_local_db1).
+-define(ETS_TAB,    snmpa_local_db2).
+-define(SERVER,     ?MODULE).
+
+-record(state, {dets, ets, notify_clients = [], backup}).
+-record(dets,  {tab, shadow}).
+
+%% -define(snmp_debug,true).
+-include("snmp_debug.hrl").
+
+
+-ifdef(snmp_debug).
+-define(GS_START_LINK(Prio, Dir, DbInitError, Opts),
+        gen_server:start_link({local, ?SERVER}, ?MODULE, 
+			      [Prio, Dir, DbInitError, Opts],
+                              [{debug,[trace]}])).
+-else.
+-define(GS_START_LINK(Prio, Dir, DbInitError, Opts),
+        gen_server:start_link({local, ?SERVER}, ?MODULE, 
+			      [Prio, Dir, DbInitError, Opts], 
+			      [])).
+-endif.
+ 
+
+%%%-----------------------------------------------------------------
+%%% Implements a general database in which its possible
+%%% to store variables and tables. Provide functions for
+%%% tableaccess by row or by element, and for next.
+%%%
+%%% Opts = [Opt]
+%%% Opt = {auto_repair, false | true | true_verbose} |
+%%%       {verbosity,silence | log | debug}
+%%%-----------------------------------------------------------------
+start_link(Prio, DbDir, Opts) when is_list(Opts) ->
+    start_link(Prio, DbDir, terminate, Opts).
+
+start_link(Prio, DbDir, DbInitError, Opts) when is_list(Opts) ->
+    ?d("start_link -> entry with"
+	"~n   Prio:        ~p"
+	"~n   DbDir:       ~p"
+	"~n   DbInitError: ~p"
+	"~n   Opts:        ~p", [Prio, DbDir, DbInitError, Opts]),
+    ?GS_START_LINK(Prio, DbDir, DbInitError, Opts).
+
+stop() ->
+    call(stop).
+
+register_notify_client(Client,Module) ->
+    call({register_notify_client,Client,Module}).
+
+
+unregister_notify_client(Client) ->
+    call({unregister_notify_client,Client}).
+
+backup(BackupDir) ->
+    call({backup, BackupDir}).
+
+dump() ->
+    call(dump).
+
+info() ->
+    call(info).
+
+verbosity(Verbosity) ->
+    cast({verbosity,Verbosity}).
+
+
+%%%-----------------------------------------------------------------
+
+init([Prio, DbDir, DbInitError, Opts]) ->
+    ?d("init -> entry with"
+	"~n   Prio:        ~p"
+	"~n   DbDir:       ~p"
+	"~n   DbInitError: ~p"
+	"~n   Opts:        ~p", [Prio, DbDir, DbInitError, Opts]),
+    case (catch do_init(Prio, DbDir, DbInitError, Opts)) of
+	{ok, State} ->
+	    ?vdebug("started",[]),
+	    {ok, State};
+	{error, Reason} ->
+	    config_err("failed starting local-db: ~n~p", [Reason]),
+	    {stop, {error, Reason}};
+	Error ->
+	    config_err("failed starting local-db: ~n~p", [Error]),
+	    {stop, {error, Error}}
+    end.
+
+do_init(Prio, DbDir, DbInitError, Opts) ->
+    process_flag(priority, Prio),
+    process_flag(trap_exit, true),
+    put(sname,ldb),
+    put(verbosity,get_opt(verbosity, Opts, ?default_verbosity)),
+    ?vlog("starting",[]),
+    Dets = dets_open(DbDir, DbInitError, Opts),
+    Ets  = ets:new(?ETS_TAB, [set, protected]),
+    ?vdebug("started",[]),
+    {ok, #state{dets = Dets, ets = Ets}}.
+
+dets_open(DbDir, DbInitError, Opts) ->
+    Name     = ?DETS_TAB, 
+    Filename = dets_filename(Name, DbDir),
+    case file:read_file_info(Filename) of
+	{ok, _} ->
+	    %% File exists
+	    case do_dets_open(Name, Filename, Opts) of
+		{ok, Dets} ->
+		    ?vdebug("dets open done",[]),
+		    Shadow = ets:new(snmp_local_db1_shadow, [set, protected]),
+		    dets:to_ets(Dets, Shadow),
+		    ?vtrace("shadow table created and populated",[]),
+		    #dets{tab = Dets, shadow = Shadow};
+		{error, Reason1} ->
+                    user_err("Corrupt local database: ~p", [Filename]),
+		    case DbInitError of
+			terminate ->
+			    throw({error, {failed_open_dets, Reason1}});
+			_ ->
+			    Saved = Filename ++ ".saved",
+			    file:rename(Filename, Saved),
+			    case do_dets_open(Name, Filename, Opts) of
+				{ok, Dets} ->
+				    Shadow = ets:new(snmp_local_db1_shadow, 
+						     [set, protected]),
+				    #dets{tab = Dets, shadow = Shadow};
+				{error, Reason2} ->
+				    user_err("Could not create local "
+					     "database: ~p"
+					     "~n   ~p"
+					     "~n   ~p", 
+					     [Filename, Reason1, Reason2]),
+				    throw({error, {failed_open_dets, Reason2}})
+			    end
+		    end
+	    end;
+	_ ->
+	    case do_dets_open(Name, Filename, Opts) of
+		{ok, Dets} ->
+		    ?vdebug("dets open done",[]),
+		    Shadow = ets:new(snmp_local_db1_shadow, [set, protected]),
+		    ?vtrace("shadow table created",[]),
+		    #dets{tab = Dets, shadow = Shadow};
+		{error, Reason} ->
+		    user_err("Could not create local database ~p"
+			     "~n   ~p", [Filename, Reason]),
+		    throw({error, {failed_open_dets, Reason}})
+	    end
+    end.
+
+do_dets_open(Name, Filename, Opts) ->
+    Repair   = get_opt(repair, Opts, true),
+    AutoSave = get_opt(auto_save, Opts, 5000),
+    Args = [{auto_save, AutoSave},
+	    {file,      Filename},
+	    {repair,    Repair}],
+    dets:open_file(Name, Args).
+
+    
+dets_filename(Name, Dir) when is_atom(Name) ->
+    dets_filename(atom_to_list(Name), Dir);
+dets_filename(Name, Dir) ->
+    filename:join(dets_filename1(Dir), Name).
+    
+dets_filename1([])  -> ".";
+dets_filename1(Dir) -> Dir.
+
+
+%%-----------------------------------------------------------------
+%% Interface functions.
+%%-----------------------------------------------------------------
+
+%%-----------------------------------------------------------------
+%% Functions for debugging.
+%%-----------------------------------------------------------------
+print()          -> call(print).
+print(Table)     -> call({print,Table,volatile}).
+print(Table, Db) -> call({print,Table,Db}).
+
+variable_get({Name, Db}) ->
+    call({variable_get, Name, Db});
+variable_get(Name) ->
+    call({variable_get, Name, volatile}).
+
+variable_set({Name, Db}, Val) ->
+    call({variable_set, Name, Db, Val});
+variable_set(Name, Val) ->
+    call({variable_set, Name, volatile, Val}).
+
+variable_inc({Name, Db}, N) ->
+    cast({variable_inc, Name, Db, N});
+variable_inc(Name, N) ->
+    cast({variable_inc, Name, volatile, N}).
+
+variable_delete({Name, Db}) ->
+    call({variable_delete, Name, Db});
+variable_delete(Name) ->
+    call({variable_delete, Name, volatile}).
+
+
+table_create({Name, Db}) ->
+    call({table_create, Name, Db});
+table_create(Name) ->
+    call({table_create, Name, volatile}).
+
+table_exists({Name, Db}) ->
+    call({table_exists, Name, Db});
+table_exists(Name) ->
+    call({table_exists, Name, volatile}).
+
+table_delete({Name, Db}) ->
+    call({table_delete, Name, Db});
+table_delete(Name) ->
+    call({table_delete, Name, volatile}).
+
+table_delete_row({Name, Db}, RowIndex) ->
+    call({table_delete_row, Name, Db, RowIndex});
+table_delete_row(Name, RowIndex) ->
+    call({table_delete_row, Name, volatile, RowIndex}).
+
+table_get_row({Name, Db}, RowIndex) ->
+    call({table_get_row, Name, Db, RowIndex});
+table_get_row(Name, RowIndex) ->
+    call({table_get_row, Name, volatile, RowIndex}).
+
+table_get_element({Name, Db}, RowIndex, Col) ->
+    call({table_get_element, Name, Db, RowIndex, Col});
+table_get_element(Name, RowIndex, Col) ->
+    call({table_get_element, Name, volatile, RowIndex, Col}).
+
+table_set_elements({Name, Db}, RowIndex, Cols) ->
+    call({table_set_elements, Name, Db, RowIndex, Cols});
+table_set_elements(Name, RowIndex, Cols) ->
+    call({table_set_elements, Name, volatile, RowIndex, Cols}).
+
+table_next({Name, Db}, RestOid) ->
+    call({table_next, Name, Db, RestOid});
+table_next(Name, RestOid) ->
+    call({table_next, Name, volatile, RestOid}).
+
+table_max_col({Name, Db}, Col) ->
+    call({table_max_col, Name, Db, Col});
+table_max_col(Name, Col) ->
+    call({table_max_col, Name, volatile, Col}).
+
+table_create_row({Name, Db}, RowIndex, Row) ->
+    call({table_create_row, Name, Db,RowIndex, Row});
+table_create_row(Name, RowIndex, Row) ->
+    call({table_create_row, Name, volatile, RowIndex, Row}).
+table_create_row(NameDb, RowIndex, Status, Cols) ->
+    Row = table_construct_row(NameDb, RowIndex, Status, Cols),
+    table_create_row(NameDb, RowIndex, Row).
+
+match({Name, Db}, Pattern) ->
+    call({match, Name, Db, Pattern});    
+match(Name, Pattern) ->
+    call({match, Name, volatile, Pattern}).
+
+
+table_get(Table) ->
+    table_get(Table, [], []).
+
+table_get(Table, Idx, Acc) ->
+    case table_next(Table, Idx) of
+	endOfTable ->
+            lists:reverse(Acc);
+	NextIdx ->
+	    case table_get_row(Table, NextIdx) of
+		undefined ->
+		    {error, {failed_get_row, NextIdx, lists:reverse(Acc)}};
+		Row ->
+		    NewAcc = [{NextIdx, Row}|Acc],
+		    table_get(Table, NextIdx, NewAcc)
+	    end
+    end.
+
+
+%%-----------------------------------------------------------------
+%% Implements the variable functions.
+%%-----------------------------------------------------------------
+handle_call({variable_get, Name, Db}, _From, State) -> 
+    ?vlog("variable get: ~p [~p]",[Name, Db]),
+    {reply, lookup(Db, Name, State), State};
+
+handle_call({variable_set, Name, Db, Val}, _From, State) -> 
+    ?vlog("variable ~p set [~p]: "
+	  "~n   Val:  ~p",[Name, Db, Val]),
+    {reply, insert(Db, Name, Val, State), State};
+
+handle_call({variable_delete, Name, Db}, _From, State) -> 
+    ?vlog("variable delete: ~p [~p]",[Name, Db]),
+    {reply, delete(Db, Name, State), State};
+
+
+%%-----------------------------------------------------------------
+%% Implements the table functions.
+%%-----------------------------------------------------------------
+%% Entry in ets for a tablerow:
+%% Key = {<tableName>, <(flat) list of indexes>}
+%% Val = {{Row}, <Prev>, <Next>}
+%% Where Prev and Next = <list of indexes>; "pointer to prev/next"
+%% Each table is a double linked list, with a head-element, with
+%% direct access to each individual element.
+%% Head-el: Key = {<tableName>, first}
+%% Operations:
+%% table_create_row(<tableName>, <list of indexes>, <row>)   O(n)
+%% table_delete_row(<tableName>, <list of indexes>)          O(1)
+%% get(<tableName>, <list of indexes>, Col)            O(1)
+%% set(<tableName>, <list of indexes>, Col, Val)       O(1)
+%% next(<tableName>, <list of indexes>)   if Row exist O(1), else O(n)
+%%-----------------------------------------------------------------
+handle_call({table_create, Name, Db}, _From, State) ->
+    ?vlog("table create: ~p [~p]",[Name, Db]),
+    catch handle_delete(Db, Name, State),
+    {reply, insert(Db, {Name, first}, {undef, first, first}, State), State};
+
+handle_call({table_exists, Name, Db}, _From, State) ->
+    ?vlog("table exist: ~p [~p]",[Name, Db]),
+    Res =
+	case lookup(Db, {Name, first}, State) of
+	    {value, _} -> true;
+	    undefined -> false
+	end,
+    ?vdebug("table exist result: "
+	    "~n   ~p",[Res]),
+    {reply, Res, State};
+
+handle_call({table_delete, Name, Db}, _From, State) ->
+    ?vlog("table delete: ~p [~p]",[Name, Db]),
+    catch handle_delete(Db, Name, State),
+    {reply, true, State};
+
+handle_call({table_create_row, Name, Db, Indexes, Row}, _From, State) ->
+    ?vlog("table create row [~p]: "
+	  "~n   Name:    ~p"
+	  "~n   Indexes: ~p"
+	  "~n   Row:     ~p",[Db, Name, Indexes, Row]),
+    Res = 
+	case catch handle_create_row(Db, Name, Indexes, Row, State) of
+	    {'EXIT', _} -> false;
+	    _ -> true
+	end,
+    ?vdebug("table create row result: "
+	    "~n   ~p",[Res]),
+    {reply, Res, State};
+
+handle_call({table_delete_row, Name, Db, Indexes}, _From, State) ->
+    ?vlog("table delete row [~p]: "
+	  "~n   Name:    ~p"
+	  "~n   Indexes: ~p", [Db, Name, Indexes]),
+    Res = 
+	case catch handle_delete_row(Db, Name, Indexes, State) of
+	    {'EXIT', _} -> false;
+	    _ -> true
+	end,
+    ?vdebug("table delete row result: "
+	    "~n   ~p",[Res]),
+    {reply, Res, State};
+
+handle_call({table_get_row, Name, Db, Indexes}, _From, State) -> 
+    ?vlog("table get row [~p]: "
+	  "~n   Name:    ~p"
+	  "~n   Indexes: ~p",[Db, Name, Indexes]),
+    Res = case lookup(Db, {Name, Indexes}, State) of
+	      undefined -> 
+		  undefined;
+	      {value, {Row, _Prev, _Next}} -> 
+		  Row
+	  end,
+    ?vdebug("table get row result: "
+	    "~n   ~p",[Res]),
+    {reply, Res, State};
+
+handle_call({table_get_element, Name, Db, Indexes, Col}, _From, State) ->
+    ?vlog("table ~p get element [~p]: "
+	  "~n   Indexes: ~p"
+	  "~n   Col:     ~p", [Name, Db, Indexes, Col]),
+    Res = case lookup(Db, {Name, Indexes}, State) of
+	      undefined -> undefined;
+	      {value, {Row, _Prev, _Next}} -> {value, element(Col, Row)}
+	  end,
+    ?vdebug("table get element result: "
+	    "~n   ~p",[Res]),
+    {reply, Res, State};
+
+handle_call({table_set_elements, Name, Db, Indexes, Cols}, _From, State) ->
+    ?vlog("table ~p set element [~p]: "
+	  "~n   Indexes: ~p"
+	  "~n   Cols:    ~p", [Name, Db, Indexes, Cols]),
+    Res = 
+	case catch handle_set_elements(Db, Name, Indexes, Cols, State) of
+	    {'EXIT', _} -> false;
+	    _ -> true
+	end,
+    ?vdebug("table set element result: "
+	    "~n   ~p",[Res]),
+    {reply, Res, State};
+
+handle_call({table_next, Name, Db, []}, From, State) ->
+    ?vlog("table next: ~p [~p]",[Name, Db]),
+    handle_call({table_next, Name, Db, first}, From, State);
+    
+handle_call({table_next, Name, Db, Indexes}, _From, State) ->
+    ?vlog("table ~p next [~p]: "
+	  "~n   Indexes: ~p",[Name, Db, Indexes]),
+    Res = case lookup(Db, {Name, Indexes}, State) of
+	      {value, {_Row, _Prev, Next}} -> 
+		  if 
+		      Next =:= first -> endOfTable;
+		      true -> Next
+		  end;
+	      undefined -> 
+		  table_search_next(Db, Name, Indexes, State)
+	  end,
+    ?vdebug("table next result: "
+	    "~n   ~p",[Res]),
+    {reply, Res, State};
+
+handle_call({table_max_col, Name, Db, Col}, _From, State) ->
+    ?vlog("table ~p max col [~p]: "
+	  "~n   Col: ~p",[Name, Db, Col]),
+    Res = table_max_col(Db, Name, Col, 0, first, State),
+    ?vdebug("table max col result: "
+	    "~n   ~p",[Res]),
+    {reply, Res, State};
+
+handle_call({match, Name, Db, Pattern}, _From, State) ->
+    ?vlog("match ~p [~p]:"
+	"~n   Pat: ~p", [Name, Db, Pattern]),
+    L1 = match(Db, Name, Pattern, State),
+    {reply, lists:delete([undef], L1), State};
+
+handle_call({backup, BackupDir}, From, #state{dets = Dets} = State) ->
+    ?vlog("backup: ~p",[BackupDir]),
+    Pid = self(),
+    V   = get(verbosity),
+    case file:read_file_info(BackupDir) of
+	{ok, #file_info{type = directory}} ->
+	    BackupServer = 
+		erlang:spawn_link(
+		  fun() ->
+			  put(sname, albs),
+			  put(verbosity, V),
+			  Dir   = filename:join([BackupDir]), 
+			  #dets{tab = Tab} = Dets, 
+			  Reply = handle_backup(Tab, Dir),
+			  Pid ! {backup_done, Reply},
+			  unlink(Pid)
+		  end),	
+	    ?vtrace("backup server: ~p", [BackupServer]),
+	    {noreply, State#state{backup = {BackupServer, From}}};
+	{ok, _} ->
+	    {reply, {error, not_a_directory}, State};
+	Error ->
+	    {reply, Error, State}
+    end;
+
+handle_call(dump, _From, #state{dets = Dets} = State) ->
+    ?vlog("dump",[]),
+    dets_sync(Dets),
+    {reply, ok, State};
+
+handle_call(info, _From, #state{dets = Dets, ets = Ets} = State) ->
+    ?vlog("info",[]),
+    Info = get_info(Dets, Ets),
+    {reply, Info, State};
+
+handle_call(print, _From, #state{dets = Dets, ets = Ets} = State) ->
+    ?vlog("print",[]),
+    L1 = ets:tab2list(Ets),
+    L2 = dets_match_object(Dets, '_'),
+    {reply, {{ets, L1}, {dets, L2}}, State};
+
+handle_call({print, Table, Db}, _From, State) ->
+    ?vlog("print: ~p [~p]", [Table, Db]),
+    L = match(Db, Table, '$1', State),
+    {reply, lists:delete([undef], L), State};
+
+handle_call({register_notify_client, Client, Module}, _From, State) ->
+    ?vlog("register_notify_client: "
+	"~n   Client: ~p"
+	"~n   Module: ~p", [Client, Module]),
+    Nc = State#state.notify_clients,
+    case lists:keysearch(Client,1,Nc) of
+	{value,{Client,Mod}} ->
+	    ?vlog("register_notify_client: already registered to: ~p",
+		  [Module]),
+	    {reply, {error,{already_registered,Mod}}, State};
+	false ->
+	    {reply, ok, State#state{notify_clients = [{Client,Module}|Nc]}}
+    end;
+
+handle_call({unregister_notify_client, Client}, _From, State) ->
+    ?vlog("unregister_notify_client: ~p",[Client]),
+    Nc = State#state.notify_clients,
+    case lists:keysearch(Client,1,Nc) of
+	{value,{Client,_Module}} ->
+	    Nc1 = lists:keydelete(Client,1,Nc),
+	    {reply, ok, State#state{notify_clients = Nc1}};
+	false ->
+	    ?vlog("unregister_notify_client: not registered",[]),
+	    {reply, {error,not_registered}, State}
+    end;
+
+handle_call(stop, _From, State) ->
+    ?vlog("stop",[]),
+    {stop, normal, stopped, State};
+
+handle_call(Req, _From, State) ->
+    warning_msg("received unknown request: ~n~p", [Req]),
+    Reply = {error, {unknown, Req}}, 
+    {reply, Reply, State}.
+
+
+handle_cast({variable_inc, Name, Db, N}, State) ->
+    ?vlog("variable ~p inc"
+	  "~n   N: ~p", [Name, N]),
+    M = case lookup(Db, Name, State) of
+	    {value, Val} -> Val;
+	    _ -> 0 
+	end,
+    insert(Db, Name, M+N rem 4294967296, State),
+    {noreply, State};
+    
+handle_cast({verbosity,Verbosity}, State) ->
+    ?vlog("verbosity: ~p -> ~p",[get(verbosity),Verbosity]),
+    put(verbosity,?vvalidate(Verbosity)),
+    {noreply, State};
+    
+handle_cast(Msg, State) ->
+    warning_msg("received unknown message: ~n~p", [Msg]),
+    {noreply, State}.
+    
+
+handle_info({'EXIT', Pid, Reason}, #state{backup = {Pid, From}} = S) ->
+    ?vlog("backup server (~p) exited for reason ~n~p", [Pid, Reason]),
+    gen_server:reply(From, {error, Reason}),
+    {noreply, S#state{backup = undefined}};
+
+handle_info({'EXIT', Pid, Reason}, S) ->
+    %% The only other processes we should be linked to are
+    %% either the master agent or our supervisor, so die...
+    {stop, {received_exit, Pid, Reason}, S};
+
+handle_info({backup_done, Reply}, #state{backup = {_, From}} = S) ->
+    ?vlog("backup done:"
+	  "~n   Reply: ~p", [Reply]),
+    gen_server:reply(From, Reply),
+    {noreply, S#state{backup = undefined}};
+
+handle_info(Info, State) ->
+    warning_msg("received unknown info: ~n~p", [Info]),
+    {noreply, State}.
+
+
+terminate(Reason, State) ->
+    ?vlog("terminate: ~p",[Reason]),
+    close(State).
+
+
+%%----------------------------------------------------------
+%% Code change
+%%----------------------------------------------------------
+
+%% downgrade
+%% 
+code_change({down, _Vsn}, S1, downgrade_to_pre_4_11) ->
+    #state{dets = D} = S1,
+    #dets{tab = Dets, shadow = Shadow} = D, 
+    ets:delete(Shadow), 
+    S2 = S1#state{dets = Dets},
+    {ok, S2};
+
+%% upgrade
+%% 
+code_change(_Vsn, S1, upgrade_from_pre_4_11) ->
+    #state{dets = D} = S1,
+    Shadow = ets:new(snmp_local_db1_shadow, [set, protected]),
+    dets:to_ets(D, Shadow),
+    Dets =  #dets{tab = D, shadow = Shadow}, 
+    S2 = S1#state{dets = Dets},
+    {ok, S2};
+
+code_change(_Vsn, State, _Extra) ->
+    {ok, State}.
+
+
+
+%%----------------------------------------------------------
+%% Backup
+%%----------------------------------------------------------
+
+handle_backup(D, BackupDir) ->
+    %% First check that we do not wrote to the corrent db-dir...
+    ?vtrace("handle_backup -> entry with"
+	"~n   D:         ~p"
+	"~n   BackupDir: ~p", [D, BackupDir]),
+    case dets:info(D, filename) of
+	undefined ->
+	    ?vinfo("handle_backup -> no file to backup", []),
+	    {error, no_file};
+	Filename ->
+	    ?vinfo("handle_backup -> file to backup: ~n   ~p", [Filename]),
+	    case filename:dirname(Filename) of
+		BackupDir ->
+		    ?vinfo("handle_backup -> backup dir and db dir the same", 
+			   []),
+		    {error, db_dir};
+		_ ->
+		    case file:read_file_info(BackupDir) of
+			{ok, #file_info{type = directory}} ->
+			    ?vdebug("handle_backup -> backup dir ok", []),
+			    %% All well so far...
+			    Type = dets:info(D, type),
+			    KP   = dets:info(D, keypos),
+			    dets_backup(D, 
+					filename:basename(Filename), 
+					BackupDir, Type, KP);
+			{ok, _} ->
+			    ?vinfo("handle_backup -> backup dir not a dir", 
+				   []),
+			    {error, not_a_directory};
+			Error ->
+			    ?vinfo("handle_backup -> Error: ~p", [Error]),
+			    Error
+		    end
+	    end
+    end.
+
+dets_backup(D, Filename, BackupDir, Type, KP) ->
+    ?vtrace("dets_backup -> entry with"
+	    "~n   D:         ~p"
+	    "~n   Filename:  ~p"
+	    "~n   BackupDir: ~p", [D, Filename, BackupDir]),
+    BackupFile = filename:join(BackupDir, Filename),
+    ?vtrace("dets_backup -> "
+	    "~n   BackupFile: ~p", [BackupFile]),
+    Opts = [{file, BackupFile}, {type, Type}, {keypos, KP}], 
+    case dets:open_file(?BACKUP_TAB, Opts) of
+	{ok, B} ->
+	    F = fun(Arg) -> 
+			dets_backup(Arg, start, D, B)
+		end,
+	    ?vtrace("dets_backup -> fix table", []),
+	    dets:safe_fixtable(D, true),
+	    ?vtrace("dets_backup -> copy table", []),
+	    Res = dets:init_table(?BACKUP_TAB, F, [{format, bchunk}]),
+	    ?vtrace("dets_backup -> unfix table", []),
+	    dets:safe_fixtable(D, false),
+	    ?vtrace("dets_backup -> Res: ~p", [Res]),
+	    Res;
+	Error ->
+	    ?vinfo("dets_backup -> open_file failed: "
+		   "~n   ~p", [Error]),
+	    Error
+    end.
+
+
+dets_backup(close, _Cont, _D, B) ->
+    dets:close(B),
+    ok;
+dets_backup(read, Cont1, D, B) ->
+    case dets:bchunk(D, Cont1) of
+	{Cont2, Data} ->
+	    F = fun(Arg) ->
+			dets_backup(Arg, Cont2, D, B)
+		end,
+	    {Data, F};
+	'$end_of_table' ->
+	    dets:close(B),
+	    end_of_input;
+	Error ->
+	    Error
+    end.
+
+
+%%-----------------------------------------------------------------
+%% All handle_ functions exists so we can catch the call to
+%% them, because we don't want to crash the server if a user
+%% forgets to call e.g. table_create.
+%%-----------------------------------------------------------------
+%% Find larger element and insert before.
+handle_create_row(Db, Name, Indexes, Row, State) ->		
+    case table_find_first_after_maybe_same(Db, Name, Indexes, State) of
+	{{Name, Next}, {NRow, NPrev, NNext}} ->
+	    {value, {PRow, PPrev, _PNext}} = lookup(Db, {Name, NPrev}, State),
+	    if 
+		Next =:= NPrev ->
+		    % Insert before first
+		    insert(Db, {Name, NPrev}, {PRow, Indexes, Indexes}, State);
+		true ->
+		    insert(Db, {Name, NPrev}, {PRow, PPrev, Indexes}, State),
+		    insert(Db, {Name, Next}, {NRow, Indexes, NNext}, State)
+	    end,
+	    insert(Db, {Name, Indexes}, {Row, NPrev, Next}, State);
+	{same_row, {Prev, Next}} ->
+	    insert(Db, {Name, Indexes}, {Row, Prev, Next}, State)
+    end.
+
+handle_delete_row(Db, Name, Indexes, State) ->
+    {value, {_, Prev, Next}} = lookup(Db, {Name, Indexes}, State),
+    {value, {PRow, PPrev, Indexes}} = lookup(Db, {Name, Prev}, State),
+    insert(Db, {Name, Prev}, {PRow, PPrev, Next}, State),
+    {value, {NRow, Indexes, NNext}} = lookup(Db, {Name, Next}, State),
+    insert(Db, {Name, Next}, {NRow, Prev, NNext}, State),
+    delete(Db, {Name, Indexes}, State).
+
+handle_set_elements(Db, Name, Indexes, Cols, State) ->
+    {value, {Row, Prev, Next}} = lookup(Db, {Name, Indexes}, State),
+    NewRow = set_new_row(Cols, Row),
+    insert(Db, {Name, Indexes}, {NewRow, Prev, Next}, State).
+
+set_new_row([{Col, Val} | Cols], Row) ->
+    set_new_row(Cols, setelement(Col, Row, Val));
+set_new_row([], Row) ->
+    Row.
+
+handle_delete(Db, Name, State) ->
+    {value, {_, _, Next}} = lookup(Db, {Name, first}, State),
+    delete(Db, {Name, first}, State),
+    handle_delete(Db, Name, Next, State).
+handle_delete(_Db, _Name, first, _State) -> true;
+handle_delete(Db, Name, Indexes, State) ->
+    {value, {_, _, Next}} = lookup(Db, {Name, Indexes}, State),
+    delete(Db, {Name, Indexes}, State),
+    handle_delete(Db, Name, Next, State).
+
+%%-----------------------------------------------------------------
+%% Implementation of next.
+%%-----------------------------------------------------------------
+table_search_next(Db, Name, Indexes, State) ->
+    case catch table_find_first_after(Db, Name, Indexes, State) of
+	{{Name, Key}, {_, _, _Next}} ->
+	    case Key of
+		first -> endOfTable;
+		_ -> Key
+	    end;
+	{'EXIT', _} -> endOfTable
+    end.
+
+table_find_first_after(Db, Name, Indexes, State) ->
+    {value, {_Row, _Prev, Next}} = lookup(Db, {Name, first}, State),
+    table_loop(Db, Name, Indexes, Next, State).
+
+table_loop(Db, Name, _Indexes, first, State) -> 
+    {value, FirstVal} = lookup(Db, {Name, first}, State),
+    {{Name, first}, FirstVal};
+
+table_loop(Db, Name, Indexes, Cur, State) -> 
+    {value, {Row, Prev, Next}} = lookup(Db, {Name, Cur}, State),
+    if
+	Cur > Indexes ->
+	    {{Name, Cur}, {Row, Prev, Next}};
+	true ->
+	    table_loop(Db, Name, Indexes, Next, State)
+    end.
+    
+table_find_first_after_maybe_same(Db, Name, Indexes, State) ->
+    {value, {_Row, _Prev, Next}} = lookup(Db, {Name, first}, State),
+    table_loop2(Db, Name, Indexes, Next, State).
+
+table_loop2(Db, Name, _Indexes, first, State) -> 
+    {value, FirstVal} = lookup(Db, {Name, first}, State),
+    {{Name, first}, FirstVal};
+
+table_loop2(Db, Name, Indexes, Cur, State) -> 
+    {value, {Row, Prev, Next}} = lookup(Db, {Name, Cur}, State),
+    if
+	Cur > Indexes ->
+	    {{Name, Cur}, {Row, Prev, Next}};
+	Cur =:= Indexes ->
+	    {same_row, {Prev, Next}};
+	true ->
+	    table_loop2(Db, Name, Indexes, Next, State)
+    end.
+    
+%%-----------------------------------------------------------------
+%% Implementation of max.
+%% The value in a column could be noinit or undefined,
+%% so we must check only those with an integer.
+%%-----------------------------------------------------------------
+table_max_col(Db, Name, Col, Max, Indexes, State) ->
+    case lookup(Db, {Name, Indexes}, State) of
+	{value, {Row, _Prev, Next}} -> 
+	    if 
+		Next =:= first -> 
+		    if 
+			is_integer(element(Col, Row)) andalso 
+			(element(Col, Row) > Max) -> 
+			    element(Col, Row);
+			true ->
+			    Max
+		    end;
+		is_integer(element(Col, Row)) andalso 
+		(element(Col, Row) > Max) -> 
+		    table_max_col(Db,Name, Col,element(Col, Row),Next, State);
+		true -> 
+		    table_max_col(Db, Name, Col, Max, Next, State)
+	    end;
+	undefined -> table_search_next(Db, Name, Indexes, State)
+    end.
+    
+%%-----------------------------------------------------------------
+%% Interface to Pets.
+%%-----------------------------------------------------------------
+insert(volatile, Key, Val, #state{ets = Ets}) -> 
+    ?vtrace("insert(volatile) -> entry with"
+	    "~n   Key: ~p"
+	    "~n   Val: ~p",
+	    [Key,Val]),
+    ets:insert(Ets, {Key, Val}),
+    true;
+insert(persistent, Key, Val, #state{dets = Dets, notify_clients = NC}) -> 
+    ?vtrace("insert(persistent) -> entry with"
+	    "~n   Key: ~p"
+	    "~n   Val: ~p",
+	    [Key,Val]),
+    case dets_insert(Dets, {Key, Val}) of
+	ok ->
+	    notify_clients(insert,NC),
+	    true;
+	{error, Reason} ->
+	    error_msg("DETS (persistent) insert failed for {~w,~w}: ~n~w", 
+		      [Key, Val, Reason]),
+	    false
+    end;
+insert(permanent, Key, Val, #state{dets = Dets, notify_clients = NC}) -> 
+    ?vtrace("insert(permanent) -> entry with"
+	    "~n   Key: ~p"
+	    "~n   Val: ~p",
+	    [Key,Val]),
+    case dets_insert(Dets, {Key, Val}) of
+	ok ->
+	    notify_clients(insert,NC),
+	    true;
+	{error, Reason} ->
+	    error_msg("DETS (permanent) insert failed for {~w,~w}: ~n~w", 
+		      [Key, Val, Reason]),
+	    false
+    end;
+insert(UnknownDb, Key, Val, _) ->
+    error_msg("Tried to insert ~w = ~w into unknown db ~w", 
+	      [Key, Val, UnknownDb]),
+    false.
+
+delete(volatile, Key, State) -> 
+    ets:delete(State#state.ets, Key),
+    true;
+delete(persistent, Key, #state{dets = Dets, notify_clients = NC}) -> 
+    case dets_delete(Dets, Key) of
+	ok ->
+	    notify_clients(delete,NC),
+	    true;
+	{error, Reason} ->
+	    error_msg("DETS (persistent) delete failed for ~w: ~n~w", 
+		      [Key, Reason]),
+	    false
+    end;
+delete(permanent, Key, #state{dets = Dets, notify_clients = NC}) -> 
+    case dets_delete(Dets, Key) of
+	ok ->
+	    notify_clients(delete,NC),
+	    true;
+	{error, Reason} ->
+	    error_msg("DETS (permanent) delete failed for ~w: ~n~w", 
+		      [Key, Reason]),
+	    false
+    end;
+delete(UnknownDb, Key, _) ->
+    error_msg("Tried to delete ~w from unknown db ~w", 
+	      [Key, UnknownDb]),
+    false.
+
+
+match(volatile, Name, Pattern, #state{ets = Ets}) ->
+    ets:match(Ets, {{Name,'_'},{Pattern,'_','_'}});
+match(persistent, Name, Pattern, #state{dets = Dets}) ->
+    dets_match(Dets, {{Name,'_'},{Pattern,'_','_'}});
+match(permanent, Name, Pattern, #state{dets = Dets}) ->
+    dets_match(Dets, {{Name,'_'},{Pattern,'_','_'}});
+match(UnknownDb, Name, Pattern, _) ->
+    error_msg("Tried to match [~p,~p] from unknown db ~w", 
+	      [Name, Pattern, UnknownDb]),
+    [].
+
+lookup(volatile, Key, #state{ets = Ets}) ->
+    case ets:lookup(Ets, Key) of
+	[{_, Val}] -> 
+	    {value, Val};
+	[] -> 
+	    undefined
+    end;
+lookup(persistent, Key, #state{dets = Dets}) ->
+    case dets_lookup(Dets, Key) of
+	[{_, Val}] -> 
+	    {value, Val};
+	[] -> 
+	    undefined
+    end;
+lookup(permanent, Key, #state{dets = Dets}) ->
+    case dets_lookup(Dets, Key) of
+	[{_, Val}] -> 
+	    {value, Val};
+	[] -> 
+	    undefined
+    end;
+lookup(UnknownDb, Key, _) ->
+    error_msg("Tried to lookup ~w in unknown db ~w", [Key, UnknownDb]),
+    false.
+
+close(#state{dets = Dets, ets = Ets}) -> 
+    ets:delete(Ets),
+    dets_close(Dets).
+
+
+%%-----------------------------------------------------------------
+%% Notify clients interface
+%%-----------------------------------------------------------------
+notify_clients(Event, Clients) ->
+    F = fun(Client) -> notify_client(Client, Event) end,
+    lists:foreach(F, Clients).
+
+notify_client({Client,Module}, Event) ->
+    (catch Module:notify(Client,Event)).
+
+
+%%------------------------------------------------------------------
+%%  Constructs a row with first elements the own part of RowIndex,
+%%  and last element RowStatus. All values are stored "as is", i.e.
+%%  dynamic key values are stored without length first.
+%%  RowIndex is a list of the
+%%  first elements. RowStatus is needed, because the
+%%  provided value may not be stored, e.g. createAndGo
+%%  should be active.
+%%  Returns a tuple of values for the row. If a value
+%%  isn't specified in the Col list, then the
+%%  corresponding value will be noinit.
+%%------------------------------------------------------------------
+table_construct_row(Name, RowIndex, Status, Cols) ->
+    #table_info{nbr_of_cols = LastCol, index_types = Indexes,
+		defvals = Defs, status_col = StatusCol,
+		first_own_index = FirstOwnIndex, not_accessible = NoAccs} =
+	snmp_generic:table_info(Name),
+    Keys = snmp_generic:split_index_to_keys(Indexes, RowIndex),
+    OwnKeys = snmp_generic:get_own_indexes(FirstOwnIndex, Keys),
+    Row = OwnKeys ++ snmp_generic:table_create_rest(length(OwnKeys) + 1,
+						    LastCol, StatusCol,
+						    Status, Cols, NoAccs),
+    L = snmp_generic:init_defaults(Defs, Row),
+    list_to_tuple(L).
+
+
+table_get_elements(NameDb, RowIndex, Cols, _FirstOwnIndex) ->
+    get_elements(Cols, table_get_row(NameDb, RowIndex)).
+
+get_elements(_Cols, undefined) -> 
+    undefined;
+get_elements([Col | Cols], Row) when is_tuple(Row) and (size(Row) >= Col) ->
+    [element(Col, Row) | get_elements(Cols, Row)];
+get_elements([], _Row) -> 
+    [];
+get_elements(Cols, Row) ->
+    erlang:error({bad_arguments, Cols, Row}).
+
+
+%%----------------------------------------------------------------------
+%% This should/could be a generic function, but since Mnesia implements
+%% its own and this version still is local_db dependent, it's not generic yet.
+%%----------------------------------------------------------------------
+%% createAndGo
+table_set_status(NameDb, RowIndex, ?'RowStatus_createAndGo', StatusCol, Cols, 
+		 ChangedStatusFunc, _ConsFunc) ->
+    case table_create_row(NameDb, RowIndex, ?'RowStatus_active', Cols) of
+	true -> snmp_generic:try_apply(ChangedStatusFunc,
+				       [NameDb, ?'RowStatus_createAndGo',
+					RowIndex, Cols]);
+	_ -> {commitFailed, StatusCol}
+    end;
+
+%%------------------------------------------------------------------
+%% createAndWait - set status to notReady, and try to 
+%% make row consistent.
+%%------------------------------------------------------------------
+table_set_status(NameDb, RowIndex, ?'RowStatus_createAndWait', StatusCol, Cols, 
+		 ChangedStatusFunc, ConsFunc) ->
+    case table_create_row(NameDb, RowIndex, ?'RowStatus_notReady', Cols) of
+	true -> 
+	    case snmp_generic:try_apply(ConsFunc, [NameDb, RowIndex, Cols]) of
+		{noError, 0} ->
+		    snmp_generic:try_apply(ChangedStatusFunc, 
+					   [NameDb, ?'RowStatus_createAndWait',
+					    RowIndex, Cols]);
+		Error -> Error
+	    end;
+	_ -> {commitFailed, StatusCol}
+    end;
+    
+%% destroy
+table_set_status(NameDb, RowIndex, ?'RowStatus_destroy', _StatusCol, Cols,
+		 ChangedStatusFunc, _ConsFunc) ->
+    case snmp_generic:try_apply(ChangedStatusFunc,
+				[NameDb, ?'RowStatus_destroy',
+				 RowIndex, Cols]) of
+	{noError, 0} ->
+	    table_delete_row(NameDb, RowIndex),
+	    {noError, 0};
+	Error -> Error
+    end;
+
+%% Otherwise, active or notInService
+table_set_status(NameDb, RowIndex, Val, _StatusCol, Cols,
+		 ChangedStatusFunc, ConsFunc) ->
+    snmp_generic:table_set_cols(NameDb, RowIndex, Cols, ConsFunc),
+    snmp_generic:try_apply(ChangedStatusFunc, [NameDb, Val, RowIndex, Cols]).
+
+table_func(new, NameDb) ->
+    case table_exists(NameDb) of
+	true -> ok;
+	_ -> table_create(NameDb)
+    end;
+
+table_func(delete, _NameDb) ->
+    ok.
+
+table_func(get, RowIndex, Cols, NameDb) ->
+    TableInfo = snmp_generic:table_info(NameDb),
+    snmp_generic:handle_table_get(NameDb, RowIndex, Cols,
+				  TableInfo#table_info.first_own_index);
+
+%%------------------------------------------------------------------
+%% Returns: List of endOfTable | {NextOid, Value}.
+%% Implements the next operation, with the function
+%% handle_table_next. Next should return the next accessible
+%% instance, which cannot be a key.
+%%------------------------------------------------------------------
+table_func(get_next, RowIndex, Cols, NameDb) ->
+    #table_info{first_accessible = FirstCol, first_own_index = FOI,
+		nbr_of_cols = LastCol} = snmp_generic:table_info(NameDb),
+    snmp_generic:handle_table_next(NameDb, RowIndex, Cols,
+				   FirstCol, FOI, LastCol);
+
+%%-----------------------------------------------------------------
+%% This function must only be used by tables with a RowStatus col!
+%% Other tables must check if row exist themselves.
+%%-----------------------------------------------------------------
+table_func(is_set_ok, RowIndex, Cols, NameDb) ->
+    snmp_generic:table_try_row(NameDb, nofunc, RowIndex, Cols);
+
+%%------------------------------------------------------------------
+%% Cols is here a list of {ColumnNumber, NewValue}
+%% This function must only be used by tables with a RowStatus col!
+%% Other tables should use table_set_cols/3,4.
+%%------------------------------------------------------------------
+table_func(set, RowIndex, Cols, NameDb) ->
+    snmp_generic:table_set_row(NameDb,
+			       nofunc,
+			       {snmp_generic, table_try_make_consistent},
+			       RowIndex,
+			       Cols);
+
+table_func(undo, _RowIndex, _Cols, _NameDb) ->
+    {noError, 0}.
+
+
+
+%%------------------------------------------------------------------
+%% This functions retrieves option values from the Options list.
+%%------------------------------------------------------------------
+get_opt(Key, Opts, Def) ->
+    snmp_misc:get_option(Key, Opts, Def).
+
+
+%%------------------------------------------------------------------
+
+get_info(Dets, Ets) ->
+    ProcSize = proc_mem(self()),
+    DetsSz   = dets_size(Dets),
+    EtsSz    = ets_size(Ets),
+    [{process_memory, ProcSize},
+     {db_memory, [{persistent, DetsSz}, {volatile, EtsSz}]}].
+
+proc_mem(P) when is_pid(P) ->
+    case (catch erlang:process_info(P, memory)) of
+	{memory, Sz} ->
+	    Sz;
+	_ ->
+	    undefined
+    end.
+%% proc_mem(_) ->
+%%     undefined.
+
+dets_size(#dets{tab = Tab, shadow = Shadow}) ->
+    TabSz = 
+	case (catch dets:info(Tab, file_size)) of
+	    Sz when is_integer(Sz) ->
+		Sz;
+	    _ ->
+		undefined
+	end,
+    ShadowSz = ets_size(Shadow),
+    [{tab, TabSz}, {shadow, ShadowSz}].
+
+ets_size(T) ->
+    case (catch ets:info(T, memory)) of
+	Sz when is_integer(Sz) ->
+	    Sz;
+	_ ->
+	    undefined
+    end.
+
+%%------------------------------------------------------------------
+
+%% info_msg(F, A) ->
+%%     ?snmpa_info("Local DB server: " ++ F, A).
+
+warning_msg(F, A) ->
+    ?snmpa_warning("Local DB server: " ++ F, A).
+
+error_msg(F, A) ->
+    ?snmpa_error("Local DB server: " ++ F, A).
+
+%% --- 
+
+user_err(F, A) ->
+    snmpa_error:user_err(F, A).
+
+config_err(F, A) ->
+    snmpa_error:config_err(F, A).
+
+
+%% ----------------------------------------------------------------
+
+call(Req) ->
+    gen_server:call(?SERVER, Req, infinity).
+
+cast(Msg) ->
+    gen_server:cast(?SERVER, Msg).
+
+
+%% ----------------------------------------------------------------
+%% DETS wrapper functions
+%% The purpose of these fuctions is basically to hide the shadow 
+%% table.
+%% Changes are made both in dets and in the shadow table.
+%% Reads are made from the shadow table.
+%% ----------------------------------------------------------------
+
+dets_sync(#dets{tab = Dets}) ->
+    dets:sync(Dets).
+    
+dets_insert(#dets{tab = Tab, shadow = Shadow}, Data) ->
+    ets:insert(Shadow, Data),
+    dets:insert(Tab, Data).
+
+dets_delete(#dets{tab = Tab, shadow = Shadow}, Key) ->
+    ets:delete(Shadow, Key),
+    dets:delete(Tab, Key).
+
+dets_match(#dets{shadow = Shadow}, Pat) ->
+    ets:match(Shadow, Pat).
+
+dets_match_object(#dets{shadow = Shadow}, Pat) ->
+    ets:match_object(Shadow, Pat).
+
+dets_lookup(#dets{shadow = Shadow}, Key) ->
+    ets:lookup(Shadow, Key).
+
+dets_close(#dets{tab = Tab, shadow = Shadow}) ->
+    ets:delete(Shadow),
+    dets:close(Tab).