Add field 'mtlhash' to the database, for get-proof-by-hash.

Also, in db:
Add field 'mtlhash' to record 'plop'. Rename 'hash' -> 'entryhash'.
Add leaf_hash(), calculating a leaf hash from data.
Fix a bug where print_tree() print half a byte of the hashes.
Rename tree_hash() -> root().

Closes CATLFISH-3.

1 files changed, 22 insertions, 20 deletions

diff --git a/src/ht.erl b/src/ht.erl
index 4150721..b6570a0 100644
--- a/src/ht.erl
+++ b/src/ht.erl
@@ -22,8 +22,8 @@
 -module(ht).
 -behaviour(gen_server).
 
--export([reset_tree/1, size/0, add/1, tree_hash/0, tree_hash/1]).
--export([path/2, consistency/2]).
+-export([reset_tree/1, size/0, leaf_hash/1]).
+-export([add/1, root/0, root/1, path/2, consistency/2]).
 -export([start_link/0, start_link/1, stop/0]).
 -export([init/1, handle_call/3, terminate/2, handle_cast/2, handle_info/2,
          code_change/3]).
@@ -53,19 +53,21 @@ size() ->
     gen_server:call(?MODULE, size).
 add(Entry) ->
     gen_server:call(?MODULE, {add, Entry}).
-tree_hash() ->
-    gen_server:call(?MODULE, tree_hash).
-tree_hash(Version) ->
-    gen_server:call(?MODULE, {tree_hash, Version}).
+root() ->
+    gen_server:call(?MODULE, root).
+root(Version) ->
+    gen_server:call(?MODULE, {root, Version}).
 path(I, V) ->
     gen_server:call(?MODULE, {path, I, V}).
 consistency(V1, V2) ->
     gen_server:call(?MODULE, {consistency, V1, V2}).
+leaf_hash(Data) ->
+    gen_server:call(?MODULE, {leaf_hash, Data}).
 %% Testing and debugging.
 testing_get_state() ->
     gen_server:call(?MODULE, testing_get_state).
 print_tree() ->
-    gen_server:call(?MODULE, print_tree).
+    gen_server:call(?MODULE, {print_tree, 4}).
 print_tree(HashOutputLen) ->
     gen_server:call(?MODULE, {print_tree, HashOutputLen}).
 
@@ -91,12 +93,14 @@ handle_call(size, _From, State) ->
     {reply, State#tree.version + 1, State};
 handle_call({add, Entry}, _From, State) ->
     {reply, ok, add(State, Entry)};
-handle_call(tree_hash, _From, State) ->
+handle_call(root, _From, State) ->
     {NewState, Hash} = head(State, State#tree.version),
     {reply, Hash, NewState};
-handle_call({tree_hash, Version}, _From, State) ->
+handle_call({root, Version}, _From, State) ->
     {NewState, Hash} = head(State, Version),
     {reply, Hash, NewState};
+handle_call({leaf_hash, Data}, _From, State) ->
+    {reply, mkleafhash(Data), State};
 handle_call({path, Index, Version}, _From, State) ->
     {NewState, Path} = path(State, Index, Version),
     {reply, Path, NewState};
@@ -106,8 +110,6 @@ handle_call({consistency, Version1, Version2}, _From, State) ->
 % testing and debugging
 handle_call(testing_get_state, _From, State) ->
     {reply, State, State};
-handle_call(print_tree, _From, State) ->
-    {reply, print_tree(State, 4), State};
 handle_call({print_tree, HashOutputLen}, _From, State) ->
     {reply, print_tree(State, HashOutputLen), State}.
 
@@ -392,10 +394,10 @@ print_tree(Tree, HashOutputLen, Layer, ILast, LayersLeft) ->
 
 print_layer(Tree, HashOutputLen, Layer, ILast) ->
     foreach(
-      fun(I) -> io:format("~s ",
-                          [string:substr(
-                             hex:bin_to_hexstr(
-                               get_hash(Tree, {I, Layer})), HashOutputLen, 1)])
+      fun(I) -> io:format(
+                  "~s ", [string:substr(
+                            hex:bin_to_hexstr(get_hash(Tree, {Layer, I})),
+                            1, HashOutputLen)])
       end,
       lists:seq(0, ILast)),
     io:format("~n").
@@ -418,24 +420,24 @@ add_test() ->
     lists:foreach(
       fun(X) -> L = lists:sublist(?TEST_VECTOR_LEAVES, X),
                 test_init(L),
-                ?assertEqual(mth(L), tree_hash()) end,
+                ?assertEqual(mth(L), root()) end,
       random_entries(length(?TEST_VECTOR_LEAVES))).
 
 old_versions_test() ->
     test_init(?TEST_VECTOR_LEAVES),
-    ?assertEqual(mth(?TEST_VECTOR_LEAVES), tree_hash()),
+    ?assertEqual(mth(?TEST_VECTOR_LEAVES), root()),
     lists:foreach(
       fun(X) -> ?assertEqual(mth(lists:sublist(?TEST_VECTOR_LEAVES, X)),
-                             tree_hash(X - 1)) end,
+                             root(X - 1)) end,
       random_entries(length(?TEST_VECTOR_LEAVES))).
 
 old_versions_bigger_test() ->
     LEAVES = [<<X:32>> || X <- lists:seq(0, 64)], % 1024 is not unreasonable
     test_init(LEAVES),
-    ?assertEqual(mth(LEAVES), tree_hash()),
+    ?assertEqual(mth(LEAVES), root()),
     lists:foreach(
       fun(X) -> ?assertEqual(mth(lists:sublist(LEAVES, X)),
-                             tree_hash(X - 1)) end,
+                             root(X - 1)) end,
       random_entries(length(LEAVES))).
 
 %% Test vector from Googles C++ implementation, "Generated from