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

   1 package org.asamk.signal.jsonrpc;
   2
   3 import com.fasterxml.jackson.core.JsonParseException;
   4 import com.fasterxml.jackson.databind.JsonMappingException;
   5 import com.fasterxml.jackson.databind.JsonNode;
   6 import com.fasterxml.jackson.databind.ObjectMapper;
   7 import com.fasterxml.jackson.databind.node.ContainerNode;
   8 import com.fasterxml.jackson.databind.node.ValueNode;
   9
  10 import org.asamk.signal.util.Util;
  11 import org.slf4j.Logger;
  12 import org.slf4j.LoggerFactory;
  13
  14 import java.io.IOException;
  15 import java.util.Objects;
  16 import java.util.function.Consumer;
  17 import java.util.function.Supplier;
  18 import java.util.stream.Collectors;
  19 import java.util.stream.StreamSupport;
  20
  21 public class JsonRpcReader {
  22
  23     private final static Logger logger = LoggerFactory.getLogger(JsonRpcReader.class);
  24
  25     private final JsonRpcSender jsonRpcSender;
  26     private final ObjectMapper objectMapper;
  27     private final Supplier<String> lineSupplier;
  28
  29     public JsonRpcReader(
  30             final JsonRpcSender jsonRpcSender, final Supplier<String> lineSupplier
  31     ) {
  32         this.jsonRpcSender = jsonRpcSender;
  33         this.lineSupplier = lineSupplier;
  34         this.objectMapper = Util.createJsonObjectMapper();
  35     }
  36
  37     public void readMessages(final RequestHandler requestHandler, final Consumer<JsonRpcResponse> responseHandler) {
  38         while (!Thread.interrupted()) {
  39             JsonRpcMessage message = readMessage();
  40             if (message == null) break;
  41
  42             if (message instanceof final JsonRpcRequest jsonRpcRequest) {
  43                 logger.debug("Received json rpc request, method: " + jsonRpcRequest.method);
  44                 final var response = handleRequest(requestHandler, jsonRpcRequest);
  45                 if (response != null) {
  46                     jsonRpcSender.sendResponse(response);
  47                 }
  48             } else if (message instanceof JsonRpcResponse jsonRpcResponse) {
  49                 responseHandler.accept(jsonRpcResponse);
  50             } else {
  51                 final var responseList = ((JsonRpcBatchMessage) message).getMessages().stream().map(jsonNode -> {
  52                     final JsonRpcRequest request;
  53                     try {
  54                         request = parseJsonRpcRequest(jsonNode);
  55                     } catch (JsonRpcException e) {
  56                         return JsonRpcResponse.forError(e.getError(), getId(jsonNode));
  57                     }
  58
  59                     return handleRequest(requestHandler, request);
  60                 }).filter(Objects::nonNull).collect(Collectors.toList());
  61
  62                 jsonRpcSender.sendBatchResponses(responseList);
  63             }
  64         }
  65     }
  66
  67     private JsonRpcResponse handleRequest(final RequestHandler requestHandler, final JsonRpcRequest request) {
  68         try {
  69             final var result = requestHandler.apply(request.getMethod(), request.getParams());
  70             if (request.getId() != null) {
  71                 return JsonRpcResponse.forSuccess(result, request.getId());
  72             } else {
  73                 logger.debug("Command '{}' succeeded but client didn't specify an id, dropping response",
  74                         request.getMethod());
  75             }
  76         } catch (JsonRpcException e) {
  77             if (request.getId() != null) {
  78                 return JsonRpcResponse.forError(e.getError(), request.getId());
  79             } else {
  80                 logger.debug("Command '{}' failed but client didn't specify an id, dropping error: {}",
  81                         request.getMethod(),
  82                         e.getMessage());
  83             }
  84         }
  85         return null;
  86     }
  87
  88     private JsonRpcMessage readMessage() {
  89         while (!Thread.interrupted()) {
  90             String input = lineSupplier.get();
  91
  92             if (input == null) {
  93                 // Reached end of input stream
  94                 break;
  95             }
  96
  97             JsonRpcMessage message = parseJsonRpcMessage(input);
  98             if (message == null) continue;
  99
 100             return message;
 101         }
 102
 103         return null;
 104     }
 105
 106     private JsonRpcMessage parseJsonRpcMessage(final String input) {
 107         final JsonNode jsonNode;
 108         try {
 109             jsonNode = objectMapper.readTree(input);
 110         } catch (JsonParseException e) {
 111             jsonRpcSender.sendResponse(JsonRpcResponse.forError(new JsonRpcResponse.Error(JsonRpcResponse.Error.PARSE_ERROR,
 112                     e.getMessage(),
 113                     null), null));
 114             return null;
 115         } catch (IOException e) {
 116             throw new AssertionError(e);
 117         }
 118
 119         if (jsonNode == null) {
 120             jsonRpcSender.sendResponse(JsonRpcResponse.forError(new JsonRpcResponse.Error(JsonRpcResponse.Error.INVALID_REQUEST,
 121                     "invalid request",
 122                     null), null));
 123             return null;
 124         } else if (jsonNode.isArray()) {
 125             if (jsonNode.size() == 0) {
 126                 jsonRpcSender.sendResponse(JsonRpcResponse.forError(new JsonRpcResponse.Error(JsonRpcResponse.Error.INVALID_REQUEST,
 127                         "invalid request",
 128                         null), null));
 129                 return null;
 130             }
 131             return new JsonRpcBatchMessage(StreamSupport.stream(jsonNode.spliterator(), false)
 132                     .collect(Collectors.toList()));
 133         } else if (jsonNode.isObject()) {
 134             if (jsonNode.has("result") || jsonNode.has("error")) {
 135                 return parseJsonRpcResponse(jsonNode);
 136             } else {
 137                 try {
 138                     return parseJsonRpcRequest(jsonNode);
 139                 } catch (JsonRpcException e) {
 140                     jsonRpcSender.sendResponse(JsonRpcResponse.forError(e.getError(), getId(jsonNode)));
 141                     return null;
 142                 }
 143             }
 144         } else {
 145             jsonRpcSender.sendResponse(JsonRpcResponse.forError(new JsonRpcResponse.Error(JsonRpcResponse.Error.INVALID_REQUEST,
 146                     "unexpected type: " + jsonNode.getNodeType().name(),
 147                     null), null));
 148             return null;
 149         }
 150     }
 151
 152     private ValueNode getId(JsonNode jsonNode) {
 153         final var id = jsonNode.get("id");
 154         return id instanceof ValueNode ? (ValueNode) id : null;
 155     }
 156
 157     private JsonRpcRequest parseJsonRpcRequest(final JsonNode input) throws JsonRpcException {
 158         JsonRpcRequest request;
 159         try {
 160             request = objectMapper.treeToValue(input, JsonRpcRequest.class);
 161         } catch (JsonMappingException e) {
 162             throw new JsonRpcException(new JsonRpcResponse.Error(JsonRpcResponse.Error.INVALID_REQUEST,
 163                     e.getMessage(),
 164                     null));
 165         } catch (IOException e) {
 166             throw new AssertionError(e);
 167         }
 168
 169         if (!"2.0".equals(request.getJsonrpc())) {
 170             throw new JsonRpcException(new JsonRpcResponse.Error(JsonRpcResponse.Error.INVALID_REQUEST,
 171                     "only jsonrpc version 2.0 is supported",
 172                     null));
 173         }
 174
 175         if (request.getMethod() == null) {
 176             throw new JsonRpcException(new JsonRpcResponse.Error(JsonRpcResponse.Error.INVALID_REQUEST,
 177                     "method field must be set",
 178                     null));
 179         }
 180
 181         return request;
 182     }
 183
 184     private JsonRpcResponse parseJsonRpcResponse(final JsonNode input) {
 185         JsonRpcResponse response;
 186         try {
 187             response = objectMapper.treeToValue(input, JsonRpcResponse.class);
 188         } catch (JsonParseException | JsonMappingException e) {
 189             logger.debug("Received invalid jsonrpc response {}", e.getMessage());
 190             return null;
 191         } catch (IOException e) {
 192             throw new AssertionError(e);
 193         }
 194
 195         if (!"2.0".equals(response.getJsonrpc())) {
 196             logger.debug("Received invalid jsonrpc response with invalid version {}", response.getJsonrpc());
 197             return null;
 198         }
 199
 200         if (response.getResult() != null && response.getError() != null) {
 201             logger.debug("Received invalid jsonrpc response with both result and error");
 202             return null;
 203         }
 204
 205         if (response.getResult() == null && response.getError() == null) {
 206             logger.debug("Received invalid jsonrpc response without result and error");
 207             return null;
 208         }
 209
 210         if (response.getId() == null || response.getId().isNull()) {
 211             logger.debug("Received invalid jsonrpc response without id");
 212             return null;
 213         }
 214
 215         return response;
 216     }
 217
 218     public interface RequestHandler {
 219
 220         JsonNode apply(String method, ContainerNode<?> params) throws JsonRpcException;
 221     }
 222 }