Clean up handling of .asn1db files

There is (differenct) code for reading .asn1db files both in
asn1ct and asn1_db. Consolidate the reading into one routine
in asn1db.

Another problem is that the encoding rule that the .asn1db
file was created for is not in the .asn1db, but only in the
generated Erlang module. It is much easier and safer to put
the encoding rule in the .asn1db file itself. We will also
put the version number of the asn1 application into the file,
to ensure that we don't use an old .asn1db file that could
potentially be incompatible.

4 files changed, 111 insertions, 84 deletions

diff --git a/lib/asn1/src/asn1_db.erl b/lib/asn1/src/asn1_db.erl
index 869b36ddbd..48d9dd16d7 100644
--- a/lib/asn1/src/asn1_db.erl
+++ b/lib/asn1/src/asn1_db.erl
@@ -19,25 +19,37 @@
 %%
 -module(asn1_db).
 
--export([dbstart/1,dbnew/1,dbsave/2,dbput/3,dbget/2]).
+-export([dbstart/1,dbnew/2,dbload/1,dbload/3,dbsave/2,dbput/3,dbget/2]).
 -export([dbstop/0]).
 
 -record(state, {parent, monitor, includes, table}).
 
 %% Interface
-dbstart(Includes) ->
+dbstart(Includes0) ->
+    Includes = case Includes0 of
+		   [] -> ["."];
+		   [_|_] -> Includes0
+	       end,
     Parent = self(),
     undefined = get(?MODULE),			%Assertion.
     put(?MODULE, spawn_link(fun() -> init(Parent, Includes) end)),
     ok.
 
-dbnew(Module)              -> req({new, Module}).
+dbload(Module, Erule, Mtime) ->
+    req({load, Module, Erule, Mtime}).
+
+dbload(Module) ->
+    req({load, Module, any, {{0,0,0},{0,0,0}}}).
+
+dbnew(Module, Erule)       -> req({new, Module, Erule}).
 dbsave(OutFile, Module)    -> cast({save, OutFile, Module}).
 dbput(Module, K, V)        -> cast({set, Module, K, V}).
 dbget(Module, K)           -> req({get, Module, K}).
 dbstop()                   -> Resp = req(stop), erase(?MODULE), Resp.
 
 %% Internal functions
+-define(MAGIC_KEY, '__version_and_erule__').
+
 req(Request) ->
     DbPid = get(?MODULE),
     Ref = erlang:monitor(process,DbPid),
@@ -71,47 +83,57 @@ loop(#state{parent = Parent, monitor = MRef, table = Table,
             ets:insert(Modtab, {K2, V}),
             loop(State);
         {From, {get, Mod, K2}} ->
-            Result = case ets:lookup(Table, Mod) of
-                         []            -> opentab(Table, Mod, Includes);
-                         [{_, Modtab}] -> {ok, Modtab}
-                     end,
-            case Result of
-                {ok, Newtab} -> reply(From, lookup(Newtab, K2));
-                _Error       -> reply(From, undefined)
+	    %% XXX If there is no information for Mod, get_table/3
+	    %% will attempt to load information from an .asn1db
+	    %% file, without comparing its timestamp against the
+	    %% source file. This is known to happen when check_*
+	    %% functions for DER are generated, but it could possibly
+	    %% happen in other circumstances. Ideally, this issue should
+	    %% be rectified in some way, perhaps by ensuring that
+	    %% the module has been loaded (using dbload/4) prior
+	    %% to calling dbget/2.
+            case get_table(Table, Mod, Includes) of
+                {ok,Tab} -> reply(From, lookup(Tab, K2));
+                error -> reply(From, undefined)
             end,
             loop(State);
         {save, OutFile, Mod} ->
             [{_,Mtab}] = ets:lookup(Table, Mod),
             ok = ets:tab2file(Mtab, OutFile),
             loop(State);
-        {From, {new, Mod}} ->
+        {From, {new, Mod, Erule}} ->
             [] = ets:lookup(Table, Mod),	%Assertion.
             ModTableId = ets:new(list_to_atom(lists:concat(["asn1_",Mod])), []),
             ets:insert(Table, {Mod, ModTableId}),
+	    ets:insert(ModTableId, {?MAGIC_KEY, info(Erule)}),
             reply(From, ok),
             loop(State);
+	{From, {load, Mod, Erule, Mtime}} ->
+	    case ets:member(Table, Mod) of
+		true ->
+		    reply(From, ok);
+		false ->
+		    case load_table(Mod, Erule, Mtime, Includes) of
+			{ok, ModTableId} ->
+			    ets:insert(Table, {Mod, ModTableId}),
+			    reply(From, ok);
+			error ->
+			    reply(From, error)
+		    end
+	    end,
+	    loop(State);
         {From, stop} ->
             reply(From, stopped); %% Nothing to store
         {'DOWN', MRef, process, Parent, Reason} ->
             exit(Reason)
     end.
 
-opentab(Tab, Mod, []) ->
-    opentab(Tab, Mod, ["."]);
-opentab(Tab, Mod, Includes) ->
-    Base = lists:concat([Mod, ".asn1db"]),
-    opentab2(Tab, Base, Mod, Includes, ok).
-
-opentab2(_Tab, _Base, _Mod, [], Error) ->
-    Error;
-opentab2(Tab, Base, Mod, [Ih|It], _Error) ->
-    File = filename:join(Ih, Base),
-    case ets:file2tab(File) of
-        {ok, Modtab} ->
-            ets:insert(Tab, {Mod, Modtab}),
-            {ok, Modtab};
-        NewErr ->
-            opentab2(Tab, Base, Mod, It, NewErr)
+get_table(Table, Mod, Includes) ->
+    case ets:lookup(Table, Mod) of
+	[{Mod,Tab}] ->
+	    {ok,Tab};
+	[] ->
+	    load_table(Mod, any, {{0,0,0},{0,0,0}}, Includes)
     end.
 
 lookup(Tab, K) ->
@@ -119,3 +141,43 @@ lookup(Tab, K) ->
         []      -> undefined;
         [{K,V}] -> V
     end.
+
+info(Erule) ->
+    {asn1ct:vsn(),Erule}.
+
+load_table(Mod, Erule, Mtime, Includes) ->
+    Base = lists:concat([Mod, ".asn1db"]),
+    case path_find(Includes, Mtime, Base) of
+	error ->
+	    error;
+	{ok,ModTab} when Erule =:= any ->
+	    {ok,ModTab};
+	{ok,ModTab} ->
+	    Vsn = asn1ct:vsn(),
+	    case ets:lookup(ModTab, ?MAGIC_KEY) of
+		[{_,{Vsn,Erule}}] ->
+		    %% Correct version and encoding rule.
+		    {ok,ModTab};
+		_ ->
+		    %% Missing key or wrong version/encoding rule.
+		    ets:delete(ModTab),
+		    error
+	    end
+    end.
+
+path_find([H|T], Mtime, Base) ->
+    File = filename:join(H, Base),
+    case filelib:last_modified(File) of
+	0 ->
+	    path_find(T, Mtime, Base);
+	DbMtime when DbMtime >= Mtime ->
+	    case ets:file2tab(File) of
+		{ok,_}=Ret ->
+		    Ret;
+		_ ->
+		    path_find(T, Mtime, Base)
+	    end;
+	_ ->
+	    path_find(T, Mtime, Base)
+    end;
+path_find([], _, _) -> error.
diff --git a/lib/asn1/src/asn1ct.erl b/lib/asn1/src/asn1ct.erl
index 8e71a5697c..f2ccf5f212 100644
--- a/lib/asn1/src/asn1ct.erl
+++ b/lib/asn1/src/asn1ct.erl
@@ -893,17 +893,23 @@ parse_and_save(Module,S) ->
     Options = S#state.options,
     SourceDir = S#state.sourcedir,
     Includes = [I || {i,I} <- Options],
+    Erule = S#state.erule,
     case get_input_file(Module, [SourceDir|Includes]) of
 	%% search for asn1 source
 	{file,SuffixedASN1source} ->
-	    case dbfile_uptodate(SuffixedASN1source,Options) of
-		false ->
-		    parse_and_save1(S, SuffixedASN1source, Options);
-		_ -> ok
+	    Mtime = filelib:last_modified(SuffixedASN1source),
+	    case asn1_db:dbload(Module, Erule, Mtime) of
+		ok -> ok;
+		error -> parse_and_save1(S, SuffixedASN1source, Options)
 	    end;
 	Err ->
-	    warning("could not do a consistency check of the ~p file: no asn1 source file was found.~n",
-		    [lists:concat([Module,".asn1db"])],Options),
+	    case asn1_db:dbload(Module) of
+		ok ->
+		    warning("could not do a consistency check of the ~p file: no asn1 source file was found.~n",
+			    [lists:concat([Module,".asn1db"])],Options);
+		error ->
+		    ok
+	    end,
 	    {error,{asn1,input_file_error,Err}}
     end.
 
@@ -929,48 +935,6 @@ get_input_file(Module,[I|Includes]) ->
 	    get_input_file(Module,Includes)
     end.
 
-dbfile_uptodate(File,Options) ->
-    EncodingRule = get_rule(Options),
-    Ext = filename:extension(File),
-    Base = filename:basename(File,Ext),
-    DbFile = outfile(Base,"asn1db",Options),
-    case file:read_file_info(DbFile) of
-	{error,enoent} ->
-	    false;
-	{ok,FileInfoDb} ->
-	    %% file exists, check date and finally encodingrule
-	    {ok,FileInfoAsn} = file:read_file_info(File),
-	    case FileInfoDb#file_info.mtime < FileInfoAsn#file_info.mtime of
-		true ->
-		    %% date of asn1 spec newer than db file
-		    false;
-		_ -> 
-		    %% date ok,check that same erule was used
-		    Obase = case lists:keysearch(outdir, 1, Options) of
-				{value, {outdir, Odir}} -> 
-				    Odir;
-				_NotFound -> ""
-			    end,
-		    BeamFileName = outfile(Base,"beam",Options),
-		    case file:read_file_info(BeamFileName) of
-			{ok,_} ->
-			    code:add_path(Obase),
-			    BeamFile = list_to_atom(Base),
-			    BeamInfo = (catch BeamFile:info()),
-			    case catch lists:keysearch(options,1,BeamInfo) of
-				{value,{options,OldOptions}} ->
-				    case get_rule(OldOptions) of
-					EncodingRule -> true;
-					_ -> false
-				    end;
-				_ -> false
-			    end;
-			_ -> false
-		    end
-	    end
-    end.
-
-
 input_file_type(Name,I) ->
    case input_file_type(Name) of
        {error,_} -> input_file_type2(filename:basename(Name),I);
@@ -1374,10 +1338,11 @@ get_value(Module, Type) ->
     end.
 
 check(Module, Includes) ->
-    case asn1_db:dbget(Module,'MODULE') of
-        undefined ->
-            {error, {file_not_found, lists:concat([Module, ".asn1db"])}};
-        M ->
+    case asn1_db:dbload(Module) of
+	error ->
+            {error,asn1db_missing_or_out_of_date};
+	ok ->
+	    M = asn1_db:dbget(Module, 'MODULE'),
             TypeOrVal =  M#module.typeorval,
             State = #state{mname = M#module.name,
                            module = M#module{typeorval=[]},
diff --git a/lib/asn1/src/asn1ct_check.erl b/lib/asn1/src/asn1ct_check.erl
index 669d5734de..eddcda0018 100644
--- a/lib/asn1/src/asn1ct_check.erl
+++ b/lib/asn1/src/asn1ct_check.erl
@@ -6826,7 +6826,7 @@ merge_tags2([], Acc) ->
 storeindb(S,M) when is_record(M,module) ->
     TVlist = M#module.typeorval,
     NewM = M#module{typeorval=findtypes_and_values(TVlist)},
-    asn1_db:dbnew(NewM#module.name),
+    asn1_db:dbnew(NewM#module.name, S#state.erule),
     asn1_db:dbput(NewM#module.name,'MODULE',  NewM),
     Res = storeindb(#state{mname=NewM#module.name}, TVlist, []),
     include_default_class(S,NewM#module.name),
diff --git a/lib/asn1/src/asn1ct_value.erl b/lib/asn1/src/asn1ct_value.erl
index ecdfa3f645..992210232f 100644
--- a/lib/asn1/src/asn1ct_value.erl
+++ b/lib/asn1/src/asn1ct_value.erl
@@ -32,11 +32,11 @@
 
 
 from_type(M,Typename) ->
-    case asn1_db:dbget(M,Typename) of
-	undefined -> 
+    case asn1_db:dbload(M) of
+	error ->
 	    {error,{not_found,{M,Typename}}};
-	Tdef when is_record(Tdef,typedef) ->
-	    Type = Tdef#typedef.typespec,
+	ok ->
+	    #typedef{typespec=Type} = asn1_db:dbget(M, Typename),
 	    from_type(M,[Typename],Type);
     Vdef when is_record(Vdef,valuedef) ->
         from_value(Vdef);