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