nmode's Git Repositories - signal-cli/blob - src/main/java/org/asamk/signal/jsonrpc/SignalJsonRpcCommandHandler.java

   1 package org.asamk.signal.jsonrpc;
   2
   3 import com.fasterxml.jackson.core.TreeNode;
   4 import com.fasterxml.jackson.core.type.TypeReference;
   5 import com.fasterxml.jackson.databind.JsonMappingException;
   6 import com.fasterxml.jackson.databind.JsonNode;
   7 import com.fasterxml.jackson.databind.ObjectMapper;
   8 import com.fasterxml.jackson.databind.node.ContainerNode;
   9 import com.fasterxml.jackson.databind.node.ObjectNode;
  10
  11 import org.asamk.signal.commands.Command;
  12 import org.asamk.signal.commands.JsonRpcMultiCommand;
  13 import org.asamk.signal.commands.JsonRpcRegistrationCommand;
  14 import org.asamk.signal.commands.JsonRpcSingleCommand;
  15 import org.asamk.signal.commands.exceptions.CommandException;
  16 import org.asamk.signal.commands.exceptions.IOErrorException;
  17 import org.asamk.signal.commands.exceptions.UntrustedKeyErrorException;
  18 import org.asamk.signal.commands.exceptions.UserErrorException;
  19 import org.asamk.signal.manager.Manager;
  20 import org.asamk.signal.manager.MultiAccountManager;
  21 import org.asamk.signal.manager.RegistrationManager;
  22 import org.asamk.signal.output.JsonWriter;
  23 import org.slf4j.Logger;
  24 import org.slf4j.LoggerFactory;
  25
  26 import java.io.IOException;
  27 import java.nio.channels.OverlappingFileLockException;
  28 import java.util.Map;
  29 import java.util.function.Function;
  30
  31 public class SignalJsonRpcCommandHandler {
  32
  33     private final static Logger logger = LoggerFactory.getLogger(SignalJsonRpcDispatcherHandler.class);
  34
  35     private static final int USER_ERROR = -1;
  36     private static final int IO_ERROR = -3;
  37     private static final int UNTRUSTED_KEY_ERROR = -4;
  38
  39     private final Manager m;
  40     private final MultiAccountManager c;
  41     private final Function<String, Command> commandProvider;
  42
  43     public SignalJsonRpcCommandHandler(final Manager m, final Function<String, Command> commandProvider) {
  44         this.c = null;
  45         this.m = m;
  46         this.commandProvider = commandProvider;
  47     }
  48
  49     public SignalJsonRpcCommandHandler(final MultiAccountManager c, final Function<String, Command> commandProvider) {
  50         this.c = c;
  51         this.m = null;
  52         this.commandProvider = commandProvider;
  53     }
  54
  55     public JsonNode handleRequest(
  56             final ObjectMapper objectMapper, final String method, ContainerNode<?> params
  57     ) throws JsonRpcException {
  58         var command = getCommand(method);
  59         if (c != null) {
  60             if (command instanceof JsonRpcSingleCommand<?> jsonRpcCommand) {
  61                 final var manager = getManagerFromParams(params);
  62                 if (manager != null) {
  63                     return runCommand(objectMapper, params, new CommandRunnerImpl<>(manager, jsonRpcCommand));
  64                 }
  65             }
  66             if (command instanceof JsonRpcMultiCommand<?> jsonRpcCommand) {
  67                 return runCommand(objectMapper, params, new MultiCommandRunnerImpl<>(c, jsonRpcCommand));
  68             }
  69             if (command instanceof JsonRpcRegistrationCommand<?> jsonRpcCommand) {
  70                 try (var manager = getRegistrationManagerFromParams(params)) {
  71                     if (manager != null) {
  72                         return runCommand(objectMapper,
  73                                 params,
  74                                 new RegistrationCommandRunnerImpl<>(manager, c, jsonRpcCommand));
  75                     } else {
  76                         throw new JsonRpcException(new JsonRpcResponse.Error(JsonRpcResponse.Error.INVALID_PARAMS,
  77                                 "Method requires valid account parameter",
  78                                 null));
  79                     }
  80                 } catch (IOException e) {
  81                     logger.warn("Failed to close registration manager", e);
  82                 }
  83             }
  84         }
  85         if (command instanceof JsonRpcSingleCommand<?> jsonRpcCommand) {
  86             if (m != null) {
  87                 return runCommand(objectMapper, params, new CommandRunnerImpl<>(m, jsonRpcCommand));
  88             }
  89
  90             var manager = getManagerFromParams(params);
  91             if (manager == null) {
  92                 final var managers = c.getManagers();
  93                 if (managers.size() == 1) {
  94                     manager = managers.get(0);
  95                 }
  96             }
  97             if (manager != null) {
  98                 return runCommand(objectMapper, params, new CommandRunnerImpl<>(manager, jsonRpcCommand));
  99             } else {
 100                 throw new JsonRpcException(new JsonRpcResponse.Error(JsonRpcResponse.Error.INVALID_PARAMS,
 101                         "Method requires valid account parameter",
 102                         null));
 103             }
 104         }
 105
 106         throw new JsonRpcException(new JsonRpcResponse.Error(JsonRpcResponse.Error.METHOD_NOT_FOUND,
 107                 "Method not implemented",
 108                 null));
 109     }
 110
 111     private Manager getManagerFromParams(final ContainerNode<?> params) throws JsonRpcException {
 112         if (params != null && params.hasNonNull("account")) {
 113             final var manager = c.getManager(params.get("account").asText());
 114             ((ObjectNode) params).remove("account");
 115             if (manager == null) {
 116                 throw new JsonRpcException(new JsonRpcResponse.Error(JsonRpcResponse.Error.INVALID_PARAMS,
 117                         "Specified account does not exist",
 118                         null));
 119             }
 120             return manager;
 121         }
 122         return null;
 123     }
 124
 125     private RegistrationManager getRegistrationManagerFromParams(final ContainerNode<?> params) {
 126         if (params != null && params.has("account")) {
 127             try {
 128                 final var registrationManager = c.getNewRegistrationManager(params.get("account").asText());
 129                 ((ObjectNode) params).remove("account");
 130                 return registrationManager;
 131             } catch (OverlappingFileLockException e) {
 132                 logger.warn("Account is already in use");
 133                 return null;
 134             } catch (IOException | IllegalStateException e) {
 135                 logger.warn("Failed to load registration manager", e);
 136                 return null;
 137             }
 138         }
 139         return null;
 140     }
 141
 142     private Command getCommand(final String method) {
 143         return commandProvider.apply(method);
 144     }
 145
 146     private record CommandRunnerImpl<T>(Manager m, JsonRpcSingleCommand<T> command) implements CommandRunner<T> {
 147
 148         @Override
 149         public void handleCommand(final T request, final JsonWriter jsonWriter) throws CommandException {
 150             command.handleCommand(request, m, jsonWriter);
 151         }
 152
 153         @Override
 154         public TypeReference<T> getRequestType() {
 155             return command.getRequestType();
 156         }
 157     }
 158
 159     private record RegistrationCommandRunnerImpl<T>(
 160             RegistrationManager m, MultiAccountManager c, JsonRpcRegistrationCommand<T> command
 161     ) implements CommandRunner<T> {
 162
 163         @Override
 164         public void handleCommand(final T request, final JsonWriter jsonWriter) throws CommandException {
 165             command.handleCommand(request, m, jsonWriter);
 166         }
 167
 168         @Override
 169         public TypeReference<T> getRequestType() {
 170             return command.getRequestType();
 171         }
 172     }
 173
 174     private record MultiCommandRunnerImpl<T>(
 175             MultiAccountManager c, JsonRpcMultiCommand<T> command
 176     ) implements CommandRunner<T> {
 177
 178         @Override
 179         public void handleCommand(final T request, final JsonWriter jsonWriter) throws CommandException {
 180             command.handleCommand(request, c, jsonWriter);
 181         }
 182
 183         @Override
 184         public TypeReference<T> getRequestType() {
 185             return command.getRequestType();
 186         }
 187     }
 188
 189     interface CommandRunner<T> {
 190
 191         void handleCommand(T request, JsonWriter jsonWriter) throws CommandException;
 192
 193         TypeReference<T> getRequestType();
 194     }
 195
 196     private JsonNode runCommand(
 197             final ObjectMapper objectMapper, final ContainerNode<?> params, final CommandRunner<?> command
 198     ) throws JsonRpcException {
 199         final Object[] result = {null};
 200         final JsonWriter commandJsonWriter = s -> {
 201             if (result[0] != null) {
 202                 throw new AssertionError("Command may only write one json result");
 203             }
 204
 205             result[0] = s;
 206         };
 207
 208         try {
 209             parseParamsAndRunCommand(objectMapper, params, commandJsonWriter, command);
 210         } catch (JsonMappingException e) {
 211             throw new JsonRpcException(new JsonRpcResponse.Error(JsonRpcResponse.Error.INVALID_REQUEST,
 212                     e.getMessage(),
 213                     null));
 214         } catch (UserErrorException e) {
 215             throw new JsonRpcException(new JsonRpcResponse.Error(USER_ERROR,
 216                     e.getMessage(),
 217                     getErrorDataNode(objectMapper, result)));
 218         } catch (IOErrorException e) {
 219             throw new JsonRpcException(new JsonRpcResponse.Error(IO_ERROR,
 220                     e.getMessage(),
 221                     getErrorDataNode(objectMapper, result)));
 222         } catch (UntrustedKeyErrorException e) {
 223             throw new JsonRpcException(new JsonRpcResponse.Error(UNTRUSTED_KEY_ERROR,
 224                     e.getMessage(),
 225                     getErrorDataNode(objectMapper, result)));
 226         } catch (Throwable e) {
 227             logger.error("Command execution failed", e);
 228             throw new JsonRpcException(new JsonRpcResponse.Error(JsonRpcResponse.Error.INTERNAL_ERROR,
 229                     e.getMessage(),
 230                     getErrorDataNode(objectMapper, result)));
 231         }
 232
 233         Object output = result[0] == null ? Map.of() : result[0];
 234         return objectMapper.valueToTree(output);
 235     }
 236
 237     private JsonNode getErrorDataNode(final ObjectMapper objectMapper, final Object[] result) {
 238         if (result[0] == null) {
 239             return null;
 240         }
 241         return objectMapper.valueToTree(Map.of("response", result[0]));
 242     }
 243
 244     private <T> void parseParamsAndRunCommand(
 245             final ObjectMapper objectMapper,
 246             final TreeNode params,
 247             final JsonWriter jsonWriter,
 248             final CommandRunner<T> command
 249     ) throws CommandException, JsonMappingException {
 250         T requestParams = null;
 251         final var requestType = command.getRequestType();
 252         if (params != null && requestType != null) {
 253             try {
 254                 requestParams = objectMapper.readValue(objectMapper.treeAsTokens(params), requestType);
 255             } catch (JsonMappingException e) {
 256                 throw e;
 257             } catch (IOException e) {
 258                 throw new AssertionError(e);
 259             }
 260         }
 261         command.handleCommand(requestParams, jsonWriter);
 262     }
 263 }