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             final var manager = getManagerFromParams(params);
  91             if (manager != null) {
  92                 return runCommand(objectMapper, params, new CommandRunnerImpl<>(manager, jsonRpcCommand));
  93             } else {
  94                 throw new JsonRpcException(new JsonRpcResponse.Error(JsonRpcResponse.Error.INVALID_PARAMS,
  95                         "Method requires valid account parameter",
  96                         null));
  97             }
  98         }
  99
 100         throw new JsonRpcException(new JsonRpcResponse.Error(JsonRpcResponse.Error.METHOD_NOT_FOUND,
 101                 "Method not implemented",
 102                 null));
 103     }
 104
 105     private Manager getManagerFromParams(final ContainerNode<?> params) throws JsonRpcException {
 106         if (params != null && params.hasNonNull("account")) {
 107             final var manager = c.getManager(params.get("account").asText());
 108             ((ObjectNode) params).remove("account");
 109             if (manager == null) {
 110                 throw new JsonRpcException(new JsonRpcResponse.Error(JsonRpcResponse.Error.INVALID_PARAMS,
 111                         "Specified account does not exist",
 112                         null));
 113             }
 114             return manager;
 115         }
 116         return null;
 117     }
 118
 119     private RegistrationManager getRegistrationManagerFromParams(final ContainerNode<?> params) {
 120         if (params != null && params.has("account")) {
 121             try {
 122                 final var registrationManager = c.getNewRegistrationManager(params.get("account").asText());
 123                 ((ObjectNode) params).remove("account");
 124                 return registrationManager;
 125             } catch (OverlappingFileLockException e) {
 126                 logger.warn("Account is already in use");
 127                 return null;
 128             } catch (IOException | IllegalStateException e) {
 129                 logger.warn("Failed to load registration manager", e);
 130                 return null;
 131             }
 132         }
 133         return null;
 134     }
 135
 136     private Command getCommand(final String method) {
 137         return commandProvider.apply(method);
 138     }
 139
 140     private record CommandRunnerImpl<T>(Manager m, JsonRpcSingleCommand<T> command) implements CommandRunner<T> {
 141
 142         @Override
 143         public void handleCommand(final T request, final JsonWriter jsonWriter) throws CommandException {
 144             command.handleCommand(request, m, jsonWriter);
 145         }
 146
 147         @Override
 148         public TypeReference<T> getRequestType() {
 149             return command.getRequestType();
 150         }
 151     }
 152
 153     private record RegistrationCommandRunnerImpl<T>(
 154             RegistrationManager m, MultiAccountManager c, JsonRpcRegistrationCommand<T> command
 155     ) implements CommandRunner<T> {
 156
 157         @Override
 158         public void handleCommand(final T request, final JsonWriter jsonWriter) throws CommandException {
 159             command.handleCommand(request, m, jsonWriter);
 160         }
 161
 162         @Override
 163         public TypeReference<T> getRequestType() {
 164             return command.getRequestType();
 165         }
 166     }
 167
 168     private record MultiCommandRunnerImpl<T>(
 169             MultiAccountManager c, JsonRpcMultiCommand<T> command
 170     ) implements CommandRunner<T> {
 171
 172         @Override
 173         public void handleCommand(final T request, final JsonWriter jsonWriter) throws CommandException {
 174             command.handleCommand(request, c, jsonWriter);
 175         }
 176
 177         @Override
 178         public TypeReference<T> getRequestType() {
 179             return command.getRequestType();
 180         }
 181     }
 182
 183     interface CommandRunner<T> {
 184
 185         void handleCommand(T request, JsonWriter jsonWriter) throws CommandException;
 186
 187         TypeReference<T> getRequestType();
 188     }
 189
 190     private JsonNode runCommand(
 191             final ObjectMapper objectMapper, final ContainerNode<?> params, final CommandRunner<?> command
 192     ) throws JsonRpcException {
 193         final Object[] result = {null};
 194         final JsonWriter commandJsonWriter = s -> {
 195             if (result[0] != null) {
 196                 throw new AssertionError("Command may only write one json result");
 197             }
 198
 199             result[0] = s;
 200         };
 201
 202         try {
 203             parseParamsAndRunCommand(objectMapper, params, commandJsonWriter, command);
 204         } catch (JsonMappingException e) {
 205             throw new JsonRpcException(new JsonRpcResponse.Error(JsonRpcResponse.Error.INVALID_REQUEST,
 206                     e.getMessage(),
 207                     null));
 208         } catch (UserErrorException e) {
 209             throw new JsonRpcException(new JsonRpcResponse.Error(USER_ERROR,
 210                     e.getMessage(),
 211                     getErrorDataNode(objectMapper, result)));
 212         } catch (IOErrorException e) {
 213             throw new JsonRpcException(new JsonRpcResponse.Error(IO_ERROR,
 214                     e.getMessage(),
 215                     getErrorDataNode(objectMapper, result)));
 216         } catch (UntrustedKeyErrorException e) {
 217             throw new JsonRpcException(new JsonRpcResponse.Error(UNTRUSTED_KEY_ERROR,
 218                     e.getMessage(),
 219                     getErrorDataNode(objectMapper, result)));
 220         } catch (Throwable e) {
 221             logger.error("Command execution failed", e);
 222             throw new JsonRpcException(new JsonRpcResponse.Error(JsonRpcResponse.Error.INTERNAL_ERROR,
 223                     e.getMessage(),
 224                     getErrorDataNode(objectMapper, result)));
 225         }
 226
 227         Object output = result[0] == null ? Map.of() : result[0];
 228         return objectMapper.valueToTree(output);
 229     }
 230
 231     private JsonNode getErrorDataNode(final ObjectMapper objectMapper, final Object[] result) {
 232         if (result[0] == null) {
 233             return null;
 234         }
 235         return objectMapper.valueToTree(Map.of("response", result[0]));
 236     }
 237
 238     private <T> void parseParamsAndRunCommand(
 239             final ObjectMapper objectMapper,
 240             final TreeNode params,
 241             final JsonWriter jsonWriter,
 242             final CommandRunner<T> command
 243     ) throws CommandException, JsonMappingException {
 244         T requestParams = null;
 245         final var requestType = command.getRequestType();
 246         if (params != null && requestType != null) {
 247             try {
 248                 requestParams = objectMapper.readValue(objectMapper.treeAsTokens(params), requestType);
 249             } catch (JsonMappingException e) {
 250                 throw e;
 251             } catch (IOException e) {
 252                 throw new AssertionError(e);
 253             }
 254         }
 255         command.handleCommand(requestParams, jsonWriter);
 256     }
 257 }