X-Git-Url: https://git.nmode.ca/signal-cli/blobdiff_plain/510965589b9d33b14958b2034fb087aeff65c134..06e93b84da2718c31111e820cd35a3354f22bae2:/src/main/java/org/asamk/signal/jsonrpc/SignalJsonRpcDispatcherHandler.java diff --git a/src/main/java/org/asamk/signal/jsonrpc/SignalJsonRpcDispatcherHandler.java b/src/main/java/org/asamk/signal/jsonrpc/SignalJsonRpcDispatcherHandler.java index 9085609c..8d13ad28 100644 --- a/src/main/java/org/asamk/signal/jsonrpc/SignalJsonRpcDispatcherHandler.java +++ b/src/main/java/org/asamk/signal/jsonrpc/SignalJsonRpcDispatcherHandler.java @@ -1,27 +1,36 @@ package org.asamk.signal.jsonrpc; import com.fasterxml.jackson.core.TreeNode; +import com.fasterxml.jackson.core.type.TypeReference; import com.fasterxml.jackson.databind.JsonMappingException; import com.fasterxml.jackson.databind.JsonNode; import com.fasterxml.jackson.databind.ObjectMapper; import com.fasterxml.jackson.databind.node.ContainerNode; +import com.fasterxml.jackson.databind.node.ObjectNode; -import org.asamk.signal.JsonReceiveMessageHandler; -import org.asamk.signal.JsonWriter; -import org.asamk.signal.OutputWriter; +import org.asamk.signal.commands.Command; import org.asamk.signal.commands.Commands; -import org.asamk.signal.commands.JsonRpcCommand; +import org.asamk.signal.commands.JsonRpcMultiCommand; +import org.asamk.signal.commands.JsonRpcRegistrationCommand; +import org.asamk.signal.commands.JsonRpcSingleCommand; import org.asamk.signal.commands.exceptions.CommandException; import org.asamk.signal.commands.exceptions.IOErrorException; import org.asamk.signal.commands.exceptions.UntrustedKeyErrorException; import org.asamk.signal.commands.exceptions.UserErrorException; +import org.asamk.signal.json.JsonReceiveMessageHandler; import org.asamk.signal.manager.Manager; +import org.asamk.signal.manager.MultiAccountManager; +import org.asamk.signal.manager.RegistrationManager; +import org.asamk.signal.output.JsonWriter; import org.asamk.signal.util.Util; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import java.io.IOException; +import java.nio.channels.OverlappingFileLockException; +import java.util.HashMap; import java.util.Map; +import java.util.Objects; import java.util.function.Supplier; public class SignalJsonRpcDispatcherHandler { @@ -32,52 +41,224 @@ public class SignalJsonRpcDispatcherHandler { private static final int IO_ERROR = -3; private static final int UNTRUSTED_KEY_ERROR = -4; - private final Manager m; - private final JsonWriter outputWriter; - private final Supplier lineSupplier; + private final ObjectMapper objectMapper; + private final JsonRpcSender jsonRpcSender; + private final JsonRpcReader jsonRpcReader; + private final boolean noReceiveOnStart; + + private MultiAccountManager c; + private final Map receiveHandlers = new HashMap<>(); + + private Manager m; public SignalJsonRpcDispatcherHandler( - final Manager m, final JsonWriter outputWriter, final Supplier lineSupplier + final JsonWriter jsonWriter, final Supplier lineSupplier, final boolean noReceiveOnStart ) { + this.noReceiveOnStart = noReceiveOnStart; + this.objectMapper = Util.createJsonObjectMapper(); + this.jsonRpcSender = new JsonRpcSender(jsonWriter); + this.jsonRpcReader = new JsonRpcReader(jsonRpcSender, lineSupplier); + } + + public void handleConnection(final MultiAccountManager c) { + this.c = c; + + if (!noReceiveOnStart) { + c.getAccountNumbers().stream().map(c::getManager).filter(Objects::nonNull).forEach(this::subscribeReceive); + c.addOnManagerAddedHandler(this::subscribeReceive); + c.addOnManagerRemovedHandler(this::unsubscribeReceive); + } + + handleConnection(); + } + + public void handleConnection(final Manager m) { this.m = m; - this.outputWriter = outputWriter; - this.lineSupplier = lineSupplier; + + if (!noReceiveOnStart) { + subscribeReceive(m); + } + + final var currentThread = Thread.currentThread(); + m.addClosedListener(currentThread::interrupt); + + handleConnection(); } - public void handleConnection() { - final var objectMapper = Util.createJsonObjectMapper(); - final var jsonRpcSender = new JsonRpcSender(outputWriter); + private void subscribeReceive(final Manager m) { + if (receiveHandlers.containsKey(m)) { + return; + } final var receiveMessageHandler = new JsonReceiveMessageHandler(m, s -> jsonRpcSender.sendRequest(JsonRpcRequest.forNotification("receive", objectMapper.valueToTree(s), null))); - try { - m.addReceiveHandler(receiveMessageHandler); + m.addReceiveHandler(receiveMessageHandler); + receiveHandlers.put(m, receiveMessageHandler); - // Maybe this should be handled inside the Manager - while (!m.hasCaughtUpWithOldMessages()) { - try { - synchronized (m) { - m.wait(); - } - } catch (InterruptedException ignored) { + while (!m.hasCaughtUpWithOldMessages()) { + try { + synchronized (m) { + m.wait(); } + } catch (InterruptedException ignored) { } + } + } + + void unsubscribeReceive(final Manager m) { + final var receiveMessageHandler = receiveHandlers.remove(m); + if (receiveMessageHandler != null) { + m.removeReceiveHandler(receiveMessageHandler); + } + } - final var jsonRpcReader = new JsonRpcReader(jsonRpcSender, lineSupplier); - jsonRpcReader.readRequests((method, params) -> handleRequest(m, objectMapper, method, params), + private void handleConnection() { + try { + jsonRpcReader.readMessages((method, params) -> handleRequest(objectMapper, method, params), response -> logger.debug("Received unexpected response for id {}", response.getId())); } finally { - m.removeReceiveHandler(receiveMessageHandler); + receiveHandlers.forEach(Manager::removeReceiveHandler); + receiveHandlers.clear(); } } private JsonNode handleRequest( - final Manager m, final ObjectMapper objectMapper, final String method, ContainerNode params + final ObjectMapper objectMapper, final String method, ContainerNode params + ) throws JsonRpcException { + var command = getCommand(method); + if (c != null) { + if (command instanceof JsonRpcMultiCommand jsonRpcCommand) { + return runCommand(objectMapper, params, new MultiCommandRunnerImpl<>(c, jsonRpcCommand)); + } + if (command instanceof JsonRpcRegistrationCommand jsonRpcCommand) { + try (var manager = getRegistrationManagerFromParams(params)) { + if (manager != null) { + return runCommand(objectMapper, + params, + new RegistrationCommandRunnerImpl<>(manager, c, jsonRpcCommand)); + } else { + throw new JsonRpcException(new JsonRpcResponse.Error(JsonRpcResponse.Error.INVALID_PARAMS, + "Method requires valid account parameter", + null)); + } + } catch (IOException e) { + logger.warn("Failed to close registration manager", e); + } + } + } + if (command instanceof JsonRpcSingleCommand jsonRpcCommand) { + if (m != null) { + return runCommand(objectMapper, params, new CommandRunnerImpl<>(m, jsonRpcCommand)); + } + + final var manager = getManagerFromParams(params); + if (manager != null) { + return runCommand(objectMapper, params, new CommandRunnerImpl<>(manager, jsonRpcCommand)); + } else { + throw new JsonRpcException(new JsonRpcResponse.Error(JsonRpcResponse.Error.INVALID_PARAMS, + "Method requires valid account parameter", + null)); + } + } + + throw new JsonRpcException(new JsonRpcResponse.Error(JsonRpcResponse.Error.METHOD_NOT_FOUND, + "Method not implemented", + null)); + } + + private Manager getManagerFromParams(final ContainerNode params) { + if (params != null && params.has("account")) { + final var manager = c.getManager(params.get("account").asText()); + ((ObjectNode) params).remove("account"); + return manager; + } + return null; + } + + private RegistrationManager getRegistrationManagerFromParams(final ContainerNode params) { + if (params != null && params.has("account")) { + try { + final var registrationManager = c.getNewRegistrationManager(params.get("account").asText()); + ((ObjectNode) params).remove("account"); + return registrationManager; + } catch (OverlappingFileLockException e) { + logger.warn("Account is already in use"); + return null; + } catch (IOException | IllegalStateException e) { + logger.warn("Failed to load registration manager", e); + return null; + } + } + return null; + } + + private Command getCommand(final String method) { + if ("subscribeReceive".equals(method)) { + return new SubscribeReceiveCommand(); + } + if ("unsubscribeReceive".equals(method)) { + return new UnsubscribeReceiveCommand(); + } + return Commands.getCommand(method); + } + + private record CommandRunnerImpl(Manager m, JsonRpcSingleCommand command) implements CommandRunner { + + @Override + public void handleCommand(final T request, final JsonWriter jsonWriter) throws CommandException { + command.handleCommand(request, m, jsonWriter); + } + + @Override + public TypeReference getRequestType() { + return command.getRequestType(); + } + } + + private record RegistrationCommandRunnerImpl( + RegistrationManager m, MultiAccountManager c, JsonRpcRegistrationCommand command + ) implements CommandRunner { + + @Override + public void handleCommand(final T request, final JsonWriter jsonWriter) throws CommandException { + command.handleCommand(request, m, jsonWriter); + } + + @Override + public TypeReference getRequestType() { + return command.getRequestType(); + } + } + + private record MultiCommandRunnerImpl( + MultiAccountManager c, JsonRpcMultiCommand command + ) implements CommandRunner { + + @Override + public void handleCommand(final T request, final JsonWriter jsonWriter) throws CommandException { + command.handleCommand(request, c, jsonWriter); + } + + @Override + public TypeReference getRequestType() { + return command.getRequestType(); + } + } + + interface CommandRunner { + + void handleCommand(T request, JsonWriter jsonWriter) throws CommandException; + + TypeReference getRequestType(); + } + + private JsonNode runCommand( + final ObjectMapper objectMapper, final ContainerNode params, final CommandRunner command ) throws JsonRpcException { final Object[] result = {null}; - final JsonWriter commandOutputWriter = s -> { + final JsonWriter commandJsonWriter = s -> { if (result[0] != null) { throw new AssertionError("Command may only write one json result"); } @@ -85,42 +266,47 @@ public class SignalJsonRpcDispatcherHandler { result[0] = s; }; - var command = Commands.getCommand(method); - if (!(command instanceof JsonRpcCommand)) { - throw new JsonRpcException(new JsonRpcResponse.Error(JsonRpcResponse.Error.METHOD_NOT_FOUND, - "Method not implemented", - null)); - } - try { - parseParamsAndRunCommand(m, objectMapper, params, commandOutputWriter, (JsonRpcCommand) command); + parseParamsAndRunCommand(objectMapper, params, commandJsonWriter, command); } catch (JsonMappingException e) { throw new JsonRpcException(new JsonRpcResponse.Error(JsonRpcResponse.Error.INVALID_REQUEST, e.getMessage(), null)); } catch (UserErrorException e) { - throw new JsonRpcException(new JsonRpcResponse.Error(USER_ERROR, e.getMessage(), null)); + throw new JsonRpcException(new JsonRpcResponse.Error(USER_ERROR, + e.getMessage(), + getErrorDataNode(objectMapper, result))); } catch (IOErrorException e) { - throw new JsonRpcException(new JsonRpcResponse.Error(IO_ERROR, e.getMessage(), null)); + throw new JsonRpcException(new JsonRpcResponse.Error(IO_ERROR, + e.getMessage(), + getErrorDataNode(objectMapper, result))); } catch (UntrustedKeyErrorException e) { - throw new JsonRpcException(new JsonRpcResponse.Error(UNTRUSTED_KEY_ERROR, e.getMessage(), null)); + throw new JsonRpcException(new JsonRpcResponse.Error(UNTRUSTED_KEY_ERROR, + e.getMessage(), + getErrorDataNode(objectMapper, result))); } catch (Throwable e) { logger.error("Command execution failed", e); throw new JsonRpcException(new JsonRpcResponse.Error(JsonRpcResponse.Error.INTERNAL_ERROR, e.getMessage(), - null)); + getErrorDataNode(objectMapper, result))); } Object output = result[0] == null ? Map.of() : result[0]; return objectMapper.valueToTree(output); } + private JsonNode getErrorDataNode(final ObjectMapper objectMapper, final Object[] result) { + if (result[0] == null) { + return null; + } + return objectMapper.valueToTree(Map.of("response", result[0])); + } + private void parseParamsAndRunCommand( - final Manager m, final ObjectMapper objectMapper, final TreeNode params, - final OutputWriter outputWriter, - final JsonRpcCommand command + final JsonWriter jsonWriter, + final CommandRunner command ) throws CommandException, JsonMappingException { T requestParams = null; final var requestType = command.getRequestType(); @@ -133,6 +319,36 @@ public class SignalJsonRpcDispatcherHandler { throw new AssertionError(e); } } - command.handleCommand(requestParams, m, outputWriter); + command.handleCommand(requestParams, jsonWriter); + } + + private class SubscribeReceiveCommand implements JsonRpcSingleCommand { + + @Override + public String getName() { + return "subscribeReceive"; + } + + @Override + public void handleCommand( + final Void request, final Manager m, final JsonWriter jsonWriter + ) throws CommandException { + subscribeReceive(m); + } + } + + private class UnsubscribeReceiveCommand implements JsonRpcSingleCommand { + + @Override + public String getName() { + return "unsubscribeReceive"; + } + + @Override + public void handleCommand( + final Void request, final Manager m, final JsonWriter jsonWriter + ) throws CommandException { + unsubscribeReceive(m); + } } }