add a genserver for handling remotes and start forwarding data

Current status is that p11tool successfully performs a --list-tokens
request over p11p, yay! Only once though -- the next request
hangs. heh.

Also, the timeout logic is wrong and should move to the server,
measuring the time it takes to get a full p11 response. This reqires
parsing of the p11-kit rpc protocol, which we need anyway.

1 files changed, 35 insertions, 26 deletions

diff --git a/p11p-daemon/src/p11p_remote_manager.erl b/p11p-daemon/src/p11p_remote_manager.erl
index 281ae2b..3b3013b 100644
--- a/p11p-daemon/src/p11p_remote_manager.erl
+++ b/p11p-daemon/src/p11p_remote_manager.erl
@@ -12,8 +12,9 @@
 
 %% API.
 -export([start_link/0]).
--export([port_for_token/1]).			% For servers.
--export([p11init_done/1, timeout/0]).		% For remotes.
+-export([remote_for_token/1]).			% For servers.
+-export([p11init_done/1, timeout/1]).		% For remotes.
+-export([send/2]).				% Experiment
 
 %% Genserver callbacks.
 -export([init/1, handle_call/3, handle_cast/2, handle_info/2, terminate/2,
@@ -22,35 +23,45 @@
 %% Records and types.
 -record(token, {
 	  p11init_done = false :: boolean(),
-	  remotes :: [port()]		      % Active remote in hd().
+	  remotes :: [pid()]		      % Active remote in hd().
 	 }).
 
 -record(state, {
 	  tokens :: #{string() => #token{}}
 	 }).
 
--define(P11KITREMOTE_PATH, "/home/linus/usr/libexec/p11-kit/p11-kit-remote").
-
 %% API implementation.
 -spec start_link() -> {ok, pid()} | {error, term()}.
 start_link() ->
     gen_server:start_link({local, ?MODULE}, ?MODULE, [], []).
 
-port_for_token(_Token) ->
-    todo.
+-spec remote_for_token(string()) -> pid().
+remote_for_token(TokName) ->
+    gen_server:call(?MODULE, {remote_for_token, TokName}).
 p11init_done(_Done) ->
     todo.
-timeout() ->
+timeout(_TokName) ->
     todo.
 
+send(TokName, Data) ->
+    gen_server:cast(?MODULE, {send, TokName, Data}).
+
 %% Genserver callbacks.
 init([]) ->
     {ok, #state{tokens = init_tokens(p11p_config:tokens())}}.
 
+handle_call({remote_for_token, TokName}, _From, State) ->
+    #{TokName := Token} = State#state.tokens,
+    {reply, hd(Token#token.remotes), State};
 handle_call(Request, _From, State) ->
     lager:debug("Unhandled call: ~p~n", [Request]),
     {reply, unhandled, State}.
 
+handle_cast({send, TokName, Data}, State) ->
+    #{TokName := Token} = State#state.tokens,
+    ServerPort = hd(Token#token.remotes),
+    ServerPort ! {self(), {command, Data}}, % TODO: Use synchronous port_command()?
+    {noreply, State};
 handle_cast(Request, State) ->
     lager:debug("Unhandled cast: ~p~n", [Request]),
     {noreply, State}.
@@ -59,7 +70,7 @@ handle_info({Port, {exit_status, Status}}, State) ->
     lager:info("~p: process exited with ~p", [Port, Status]),
     {stop, child_exit, State};
 handle_info(Info, State) ->
-    lager:debug("Unhandled info: ~p~n", [Info]),
+    lager:debug("~p: Unhandled info: ~p~n", [self(), Info]),
     {noreply, State}.
 
 terminate(_Reason, _State) ->
@@ -69,29 +80,27 @@ code_change(_OldVersion, State, _Extra) ->
     {ok, State}.
 
 %% Private functions
--spec init_tokens([any()]) -> #{string() => #token{}}.
+-spec init_tokens([p11p_config:token()]) -> #{string() => #token{}}.
 init_tokens(ConfTokens) ->
     init_tokens(ConfTokens, #{}).
 init_tokens([], Acc)->
     Acc;
 init_tokens([H|T], Acc)->
-    init_tokens(T, Acc#{p11p_config:nameof(H) => new_token(H)}).
+    TokName = p11p_config:nameof(H),
+    init_tokens(T, Acc#{TokName => new_token(TokName, H)}).
 
-new_token(ConfToken) ->
-    Remotes = start_remotes(p11p_config:modules_for_token(p11p_config:nameof(ConfToken))),
+new_token(TokName, ConfToken) ->
+    Remotes = start_remotes(TokName, p11p_config:modules_for_token(p11p_config:nameof(ConfToken))),
     #token{remotes = Remotes}.
 
-start_remotes(ConfModules) ->
-    start_remotes(ConfModules, []).
-start_remotes([], Acc) ->
-    lists:reverse(Acc);
-start_remotes([H|T], Acc) ->
+start_remotes(TokName, ConfModules) ->
+    start_remotes(TokName, ConfModules, []).
+start_remotes(_, [], Acc) ->
+    %%lists:reverse(Acc);
+    Acc;
+start_remotes(TokName, [H|T], Acc) ->
+    ModName = p11p_config:nameof(H),
+    ServName = "p11p_remote:" ++ TokName ++ ":" ++ ModName,
     ModPath = p11p_config:module_path(H),
-    Port = start_remote(ModPath),
-    start_remotes(T, [Port | Acc]).
-
-start_remote(ModPath) ->
-    Port = open_port({spawn_executable, ?P11KITREMOTE_PATH},
-		     [stream, exit_status, {args, [ModPath, "-v"]}]),
-    lager:debug("~s: New port: ~p", [?P11KITREMOTE_PATH, Port]),
-    Port.
+    {ok, Pid} = p11p_remote:start_link(list_to_atom(ServName), TokName, ModPath),
+    start_remotes(TokName, T, [Pid | Acc]).