webmaster/signal-cli
1
0
Fork 0
mirror of https://github.com/AsamK/signal-cli synced 2025-09-02 04:20:38 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Merge branch 'AsamK:master' into dev-http

Browse source
This commit is contained in:
ced-b 2022-11-01 14:50:17 -04:00 • committed by GitHub
commit 11179c672f
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
11 changed files with 483 additions and 309 deletions
Download patch file Download diff file Expand all files Collapse all files

28
graalvm-config-dir/proxy-config.json
View file

@ -1,23 +1,23 @@
[
{
"interfaces":["java.sql.Connection"]}
,
"interfaces":["java.sql.Connection"]
},
{
"interfaces":["org.asamk.Signal"]}
,
"interfaces":["org.asamk.Signal"]
},
{
"interfaces":["org.asamk.Signal$Configuration"]}
,
"interfaces":["org.asamk.Signal$Configuration"]
},
{
"interfaces":["org.asamk.Signal$Device"]}
,
"interfaces":["org.asamk.Signal$Device"]
},
{
"interfaces":["org.asamk.Signal$Group"]}
,
"interfaces":["org.asamk.Signal$Group"]
},
{
"interfaces":["org.asamk.SignalControl"]}
,
"interfaces":["org.asamk.SignalControl"]
},
{
"interfaces":["org.freedesktop.dbus.interfaces.DBus"]}
"interfaces":["org.freedesktop.dbus.interfaces.DBus"]
}
]

67
graalvm-config-dir/reflect-config.json
View file

@ -78,10 +78,22 @@
"allDeclaredFields":true,
"allDeclaredMethods":true
},
{
"name":"com.google.protobuf.DescriptorMessageInfoFactory"
},
{
"name":"com.google.protobuf.ExtensionRegistry"
},
{
"name":"com.google.protobuf.ExtensionSchemaFull"
},
{
"name":"com.google.protobuf.GeneratedMessageLite",
"fields":[{"name":"unknownFields"}]
},
{
"name":"com.google.protobuf.GeneratedMessageV3"
},
{
"name":"com.google.protobuf.Internal$LongList",
"allDeclaredMethods":true
@ -96,10 +108,19 @@
"allDeclaredMethods":true,
"allDeclaredConstructors":true
},
{
"name":"com.google.protobuf.MapFieldSchemaFull"
},
{
"name":"com.google.protobuf.NewInstanceSchemaFull"
},
{
"name":"com.google.protobuf.PrimitiveNonBoxingCollection",
"allDeclaredMethods":true
},
{
"name":"com.google.protobuf.UnknownFieldSetSchema"
},
{
"name":"com.sun.crypto.provider.AESCipher$General",
"methods":[{"name":"<init>","parameterTypes":[] }]
@ -187,7 +208,42 @@
{"name":"isAutoCommit","parameterTypes":[] },
{"name":"isIsolateInternalQueries","parameterTypes":[] },
{"name":"isReadOnly","parameterTypes":[] },
{"name":"isRegisterMbeans","parameterTypes":[] }
{"name":"isRegisterMbeans","parameterTypes":[] },
{"name":"setAllowPoolSuspension","parameterTypes":["boolean"] },
{"name":"setAutoCommit","parameterTypes":["boolean"] },
{"name":"setCatalog","parameterTypes":["java.lang.String"] },
{"name":"setConnectionInitSql","parameterTypes":["java.lang.String"] },
{"name":"setConnectionTestQuery","parameterTypes":["java.lang.String"] },
{"name":"setConnectionTimeout","parameterTypes":["long"] },
{"name":"setDataSource","parameterTypes":["javax.sql.DataSource"] },
{"name":"setDataSourceClassName","parameterTypes":["java.lang.String"] },
{"name":"setDataSourceJNDI","parameterTypes":["java.lang.String"] },
{"name":"setDataSourceProperties","parameterTypes":["java.util.Properties"] },
{"name":"setDriverClassName","parameterTypes":["java.lang.String"] },
{"name":"setExceptionOverrideClassName","parameterTypes":["java.lang.String"] },
{"name":"setHealthCheckProperties","parameterTypes":["java.util.Properties"] },
{"name":"setHealthCheckRegistry","parameterTypes":["java.lang.Object"] },
{"name":"setIdleTimeout","parameterTypes":["long"] },
{"name":"setInitializationFailTimeout","parameterTypes":["long"] },
{"name":"setIsolateInternalQueries","parameterTypes":["boolean"] },
{"name":"setJdbcUrl","parameterTypes":["java.lang.String"] },
{"name":"setKeepaliveTime","parameterTypes":["long"] },
{"name":"setLeakDetectionThreshold","parameterTypes":["long"] },
{"name":"setMaxLifetime","parameterTypes":["long"] },
{"name":"setMaximumPoolSize","parameterTypes":["int"] },
{"name":"setMetricRegistry","parameterTypes":["java.lang.Object"] },
{"name":"setMetricsTrackerFactory","parameterTypes":["com.zaxxer.hikari.metrics.MetricsTrackerFactory"] },
{"name":"setMinimumIdle","parameterTypes":["int"] },
{"name":"setPassword","parameterTypes":["java.lang.String"] },
{"name":"setPoolName","parameterTypes":["java.lang.String"] },
{"name":"setReadOnly","parameterTypes":["boolean"] },
{"name":"setRegisterMbeans","parameterTypes":["boolean"] },
{"name":"setScheduledExecutor","parameterTypes":["java.util.concurrent.ScheduledExecutorService"] },
{"name":"setSchema","parameterTypes":["java.lang.String"] },
{"name":"setThreadFactory","parameterTypes":["java.util.concurrent.ThreadFactory"] },
{"name":"setTransactionIsolation","parameterTypes":["java.lang.String"] },
{"name":"setUsername","parameterTypes":["java.lang.String"] },
{"name":"setValidationTimeout","parameterTypes":["long"] }
]
},
{
@ -406,6 +462,12 @@
"name":"javax.security.auth.x500.X500Principal",
"methods":[{"name":"<init>","parameterTypes":["sun.security.x509.X500Name"] }]
},
{
"name":"javax.smartcardio.CardPermission"
},
{
"name":"libcore.io.Memory"
},
{
"name":"long",
"allDeclaredMethods":true,
@ -1746,6 +1808,9 @@
"name":"org.freedesktop.dbus.interfaces.Properties$PropertiesChanged",
"allPublicConstructors":true
},
{
"name":"org.robolectric.Robolectric"
},
{
"name":"org.signal.cdsi.proto.ClientRequest",
"fields":[

2
graalvm-config-dir/serialization-config.json
View file

@ -2,5 +2,7 @@
"types":[
],
"lambdaCapturingTypes":[
],
"proxies":[
]
}

2
lib/build.gradle.kts
View file

@ -14,7 +14,7 @@ repositories {
}
dependencies {
implementation("com.github.turasa", "signal-service-java", "2.15.3_unofficial_62")
implementation("com.github.turasa", "signal-service-java", "2.15.3_unofficial_63")
implementation("com.fasterxml.jackson.core", "jackson-databind", "2.13.4.2")
implementation("com.google.protobuf", "protobuf-javalite", "3.21.6")
implementation("org.bouncycastle", "bcprov-jdk15on", "1.70")

3
lib/src/main/java/org/asamk/signal/manager/Manager.java
View file

@ -1,5 +1,6 @@
package org.asamk.signal.manager;
import org.asamk.signal.manager.api.AlreadyReceivingException;
import org.asamk.signal.manager.api.AttachmentInvalidException;
import org.asamk.signal.manager.api.Configuration;
import org.asamk.signal.manager.api.Device;
@ -204,7 +205,7 @@ public interface Manager extends Closeable {
*/
public void receiveMessages(
Optional<Duration> timeout, Optional<Integer> maxMessages, ReceiveMessageHandler handler
) throws IOException;
) throws IOException, AlreadyReceivingException;
void setReceiveConfig(ReceiveConfig receiveConfig);

64
lib/src/main/java/org/asamk/signal/manager/ManagerImpl.java
View file

@ -16,6 +16,7 @@
*/
package org.asamk.signal.manager;
import org.asamk.signal.manager.api.AlreadyReceivingException;
import org.asamk.signal.manager.api.AttachmentInvalidException;
import org.asamk.signal.manager.api.Configuration;
import org.asamk.signal.manager.api.Device;
@ -25,6 +26,7 @@ import org.asamk.signal.manager.api.InactiveGroupLinkException;
import org.asamk.signal.manager.api.InvalidDeviceLinkException;
import org.asamk.signal.manager.api.InvalidStickerException;
import org.asamk.signal.manager.api.Message;
import org.asamk.signal.manager.api.MessageEnvelope;
import org.asamk.signal.manager.api.NotPrimaryDeviceException;
import org.asamk.signal.manager.api.Pair;
import org.asamk.signal.manager.api.PendingAdminApprovalException;
@ -874,9 +876,6 @@ class ManagerImpl implements Manager {
@Override
public void addReceiveHandler(final ReceiveMessageHandler handler, final boolean isWeakListener) {
if (isReceivingSynchronous) {
throw new IllegalStateException("Already receiving message synchronously.");
}
synchronized (messageHandlers) {
if (isWeakListener) {
weakHandlers.add(handler);
@ -890,23 +889,12 @@ class ManagerImpl implements Manager {
private static final AtomicInteger threadNumber = new AtomicInteger(0);
private void startReceiveThreadIfRequired() {
if (receiveThread != null) {
if (receiveThread != null || isReceivingSynchronous) {
return;
}
receiveThread = new Thread(() -> {
logger.debug("Starting receiving messages");
context.getReceiveHelper().receiveMessagesContinuously((envelope, e) -> {
synchronized (messageHandlers) {
final var handlers = Stream.concat(messageHandlers.stream(), weakHandlers.stream()).toList();
handlers.forEach(h -> {
try {
h.handleMessage(envelope, e);
} catch (Throwable ex) {
logger.warn("Message handler failed, ignoring", ex);
}
});
}
});
context.getReceiveHelper().receiveMessagesContinuously(this::passReceivedMessageToHandlers);
logger.debug("Finished receiving messages");
synchronized (messageHandlers) {
receiveThread = null;
@ -923,6 +911,18 @@ class ManagerImpl implements Manager {
receiveThread.start();
}
private void passReceivedMessageToHandlers(MessageEnvelope envelope, Throwable e) {
synchronized (messageHandlers) {
Stream.concat(messageHandlers.stream(), weakHandlers.stream()).forEach(h -> {
try {
h.handleMessage(envelope, e);
} catch (Throwable ex) {
logger.warn("Message handler failed, ignoring", ex);
}
});
}
}
@Override
public void removeReceiveHandler(final ReceiveMessageHandler handler) {
final Thread thread;
@ -962,26 +962,34 @@ class ManagerImpl implements Manager {
@Override
public void receiveMessages(
Optional<Duration> timeout,
Optional<Integer> maxMessages,
ReceiveMessageHandler handler
) throws IOException {
Optional<Duration> timeout, Optional<Integer> maxMessages, ReceiveMessageHandler handler
) throws IOException, AlreadyReceivingException {
receiveMessages(timeout.orElse(Duration.ofMinutes(1)), timeout.isPresent(), maxMessages.orElse(null), handler);
}
private void receiveMessages(
Duration timeout, boolean returnOnTimeout, Integer maxMessages, ReceiveMessageHandler handler
) throws IOException {
if (isReceiving()) {
throw new IllegalStateException("Already receiving message.");
) throws IOException, AlreadyReceivingException {
synchronized (messageHandlers) {
if (isReceiving()) {
throw new AlreadyReceivingException("Already receiving message.");
}
isReceivingSynchronous = true;
receiveThread = Thread.currentThread();
}
isReceivingSynchronous = true;
receiveThread = Thread.currentThread();
try {
context.getReceiveHelper().receiveMessages(timeout, returnOnTimeout, maxMessages, handler);
context.getReceiveHelper().receiveMessages(timeout, returnOnTimeout, maxMessages, (envelope, e) -> {
passReceivedMessageToHandlers(envelope, e);
handler.handleMessage(envelope, e);
});
} finally {
receiveThread = null;
isReceivingSynchronous = false;
synchronized (messageHandlers) {
receiveThread = null;
isReceivingSynchronous = false;
if (messageHandlers.size() > 0) {
startReceiveThreadIfRequired();
}
}
}
}

12
lib/src/main/java/org/asamk/signal/manager/api/AlreadyReceivingException.java Normal file
View file

@ -0,0 +1,12 @@
package org.asamk.signal.manager.api;
public class AlreadyReceivingException extends Exception {
public AlreadyReceivingException(String message) {
super(message);
}
public AlreadyReceivingException(String message, Exception e) {
super(message, e);
}
}

6
src/main/java/org/asamk/signal/commands/ReceiveCommand.java
View file

@ -10,8 +10,10 @@ import org.asamk.signal.OutputType;
import org.asamk.signal.ReceiveMessageHandler;
import org.asamk.signal.commands.exceptions.CommandException;
import org.asamk.signal.commands.exceptions.IOErrorException;
import org.asamk.signal.commands.exceptions.UserErrorException;
import org.asamk.signal.json.JsonReceiveMessageHandler;
import org.asamk.signal.manager.Manager;
import org.asamk.signal.manager.api.AlreadyReceivingException;
import org.asamk.signal.manager.api.ReceiveConfig;
import org.asamk.signal.output.JsonWriter;
import org.asamk.signal.output.OutputWriter;
@ -79,6 +81,8 @@ public class ReceiveCommand implements LocalCommand, JsonRpcSingleCommand<Receiv
m.receiveMessages(Optional.ofNullable(duration), Optional.ofNullable(maxMessages), handler);
} catch (IOException e) {
throw new IOErrorException("Error while receiving messages: " + e.getMessage(), e);
} catch (AlreadyReceivingException e) {
throw new UserErrorException("Receive command cannot be used if messages are already being received.", e);
}
}
@ -103,6 +107,8 @@ public class ReceiveCommand implements LocalCommand, JsonRpcSingleCommand<Receiv
jsonWriter.write(messages);
} catch (IOException e) {
throw new IOErrorException("Error while receiving messages: " + e.getMessage(), e);
} catch (AlreadyReceivingException e) {
throw new UserErrorException("Receive command cannot be used if messages are already being received.", e);
}
}

130
src/main/java/org/asamk/signal/jsonrpc/JsonRpcReader.java
View file

@ -13,6 +13,7 @@ import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.IOException;
import java.io.InputStream;
import java.util.Objects;
import java.util.function.Consumer;
import java.util.function.Supplier;
@ -24,43 +25,77 @@ public class JsonRpcReader {
private final JsonRpcSender jsonRpcSender;
private final ObjectMapper objectMapper;
private final InputStream input;
private final Supplier<String> lineSupplier;
public JsonRpcReader(
final JsonRpcSender jsonRpcSender, final Supplier<String> lineSupplier
) {
public JsonRpcReader(final JsonRpcSender jsonRpcSender, final Supplier<String> lineSupplier) {
this.jsonRpcSender = jsonRpcSender;
this.input = null;
this.lineSupplier = lineSupplier;
this.objectMapper = Util.createJsonObjectMapper();
}
public JsonRpcReader(final JsonRpcSender jsonRpcSender, final InputStream input) {
this.jsonRpcSender = jsonRpcSender;
this.input = input;
this.lineSupplier = null;
this.objectMapper = Util.createJsonObjectMapper();
}
public void readMessages(final RequestHandler requestHandler, final Consumer<JsonRpcResponse> responseHandler) {
while (!Thread.interrupted()) {
JsonRpcMessage message = readMessage();
if (message == null) break;
if (message instanceof final JsonRpcRequest jsonRpcRequest) {
logger.debug("Received json rpc request, method: " + jsonRpcRequest.getMethod());
final var response = handleRequest(requestHandler, jsonRpcRequest);
if (response != null) {
jsonRpcSender.sendResponse(response);
}
} else if (message instanceof JsonRpcResponse jsonRpcResponse) {
responseHandler.accept(jsonRpcResponse);
} else {
final var responseList = ((JsonRpcBatchMessage) message).getMessages().stream().map(jsonNode -> {
final JsonRpcRequest request;
try {
request = parseJsonRpcRequest(jsonNode);
} catch (JsonRpcException e) {
return JsonRpcResponse.forError(e.getError(), getId(jsonNode));
}
return handleRequest(requestHandler, request);
}).filter(Objects::nonNull).toList();
jsonRpcSender.sendBatchResponses(responseList);
if (input != null) {
JsonRpcMessage message = parseJsonRpcMessage(input);
if (message == null) {
return;
}
handleMessage(message, requestHandler, responseHandler);
return;
}
while (!Thread.interrupted()) {
String input = lineSupplier.get();
if (input == null) {
logger.trace("Reached end of JSON-RPC input stream.");
break;
}
logger.trace("Incoming JSON-RPC message: {}", input);
JsonRpcMessage message = parseJsonRpcMessage(input);
if (message == null) {
continue;
}
handleMessage(message, requestHandler, responseHandler);
}
}
private void handleMessage(
final JsonRpcMessage message,
final RequestHandler requestHandler,
final Consumer<JsonRpcResponse> responseHandler
) {
if (message instanceof final JsonRpcRequest jsonRpcRequest) {
logger.debug("Received json rpc request, method: " + jsonRpcRequest.getMethod());
final var response = handleRequest(requestHandler, jsonRpcRequest);
if (response != null) {
jsonRpcSender.sendResponse(response);
}
} else if (message instanceof JsonRpcResponse jsonRpcResponse) {
responseHandler.accept(jsonRpcResponse);
} else {
final var responseList = ((JsonRpcBatchMessage) message).getMessages().stream().map(jsonNode -> {
final JsonRpcRequest request;
try {
request = parseJsonRpcRequest(jsonNode);
} catch (JsonRpcException e) {
return JsonRpcResponse.forError(e.getError(), getId(jsonNode));
}
return handleRequest(requestHandler, request);
}).filter(Objects::nonNull).toList();
jsonRpcSender.sendBatchResponses(responseList);
}
}
@ -85,25 +120,6 @@ public class JsonRpcReader {
return null;
}
private JsonRpcMessage readMessage() {
while (!Thread.interrupted()) {
String input = lineSupplier.get();
if (input == null) {
logger.trace("Reached end of JSON-RPC input stream.");
break;
}
logger.trace("Incoming JSON-RPC message: {}", input);
JsonRpcMessage message = parseJsonRpcMessage(input);
if (message == null) continue;
return message;
}
return null;
}
private JsonRpcMessage parseJsonRpcMessage(final String input) {
final JsonNode jsonNode;
try {
@ -117,6 +133,26 @@ public class JsonRpcReader {
throw new AssertionError(e);
}
return parseJsonRpcMessage(jsonNode);
}
private JsonRpcMessage parseJsonRpcMessage(final InputStream input) {
final JsonNode jsonNode;
try {
jsonNode = objectMapper.readTree(input);
} catch (JsonParseException e) {
jsonRpcSender.sendResponse(JsonRpcResponse.forError(new JsonRpcResponse.Error(JsonRpcResponse.Error.PARSE_ERROR,
e.getMessage(),
null), null));
return null;
} catch (IOException e) {
throw new AssertionError(e);
}
return parseJsonRpcMessage(jsonNode);
}
private JsonRpcMessage parseJsonRpcMessage(final JsonNode jsonNode) {
if (jsonNode == null) {
jsonRpcSender.sendResponse(JsonRpcResponse.forError(new JsonRpcResponse.Error(JsonRpcResponse.Error.INVALID_REQUEST,
"invalid request",

257
src/main/java/org/asamk/signal/jsonrpc/SignalJsonRpcCommandHandler.java Normal file
View file

@ -0,0 +1,257 @@
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.commands.Command;
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.manager.Manager;
import org.asamk.signal.manager.MultiAccountManager;
import org.asamk.signal.manager.RegistrationManager;
import org.asamk.signal.output.JsonWriter;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.IOException;
import java.nio.channels.OverlappingFileLockException;
import java.util.Map;
import java.util.function.Function;
public class SignalJsonRpcCommandHandler {
private final static Logger logger = LoggerFactory.getLogger(SignalJsonRpcDispatcherHandler.class);
private static final int USER_ERROR = -1;
private static final int IO_ERROR = -3;
private static final int UNTRUSTED_KEY_ERROR = -4;
private final Manager m;
private final MultiAccountManager c;
private final Function<String, Command> commandProvider;
public SignalJsonRpcCommandHandler(final Manager m, final Function<String, Command> commandProvider) {
this.c = null;
this.m = m;
this.commandProvider = commandProvider;
}
public SignalJsonRpcCommandHandler(final MultiAccountManager c, final Function<String, Command> commandProvider) {
this.c = c;
this.m = null;
this.commandProvider = commandProvider;
}
JsonNode handleRequest(
final ObjectMapper objectMapper, final String method, ContainerNode<?> params
) throws JsonRpcException {
var command = getCommand(method);
if (c != null) {
if (command instanceof JsonRpcSingleCommand<?> jsonRpcCommand) {
final var manager = getManagerFromParams(params);
if (manager != null) {
return runCommand(objectMapper, params, new CommandRunnerImpl<>(manager, jsonRpcCommand));
}
}
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) throws JsonRpcException {
if (params != null && params.hasNonNull("account")) {
final var manager = c.getManager(params.get("account").asText());
((ObjectNode) params).remove("account");
if (manager == null) {
throw new JsonRpcException(new JsonRpcResponse.Error(JsonRpcResponse.Error.INVALID_PARAMS,
"Specified account does not exist",
null));
}
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) {
return commandProvider.apply(method);
}
private record CommandRunnerImpl<T>(Manager m, JsonRpcSingleCommand<T> command) implements CommandRunner<T> {
@Override
public void handleCommand(final T request, final JsonWriter jsonWriter) throws CommandException {
command.handleCommand(request, m, jsonWriter);
}
@Override
public TypeReference<T> getRequestType() {
return command.getRequestType();
}
}
private record RegistrationCommandRunnerImpl<T>(
RegistrationManager m, MultiAccountManager c, JsonRpcRegistrationCommand<T> command
) implements CommandRunner<T> {
@Override
public void handleCommand(final T request, final JsonWriter jsonWriter) throws CommandException {
command.handleCommand(request, m, jsonWriter);
}
@Override
public TypeReference<T> getRequestType() {
return command.getRequestType();
}
}
private record MultiCommandRunnerImpl<T>(
MultiAccountManager c, JsonRpcMultiCommand<T> command
) implements CommandRunner<T> {
@Override
public void handleCommand(final T request, final JsonWriter jsonWriter) throws CommandException {
command.handleCommand(request, c, jsonWriter);
}
@Override
public TypeReference<T> getRequestType() {
return command.getRequestType();
}
}
interface CommandRunner<T> {
void handleCommand(T request, JsonWriter jsonWriter) throws CommandException;
TypeReference<T> getRequestType();
}
private JsonNode runCommand(
final ObjectMapper objectMapper, final ContainerNode<?> params, final CommandRunner<?> command
) throws JsonRpcException {
final Object[] result = {null};
final JsonWriter commandJsonWriter = s -> {
if (result[0] != null) {
throw new AssertionError("Command may only write one json result");
}
result[0] = s;
};
try {
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(),
getErrorDataNode(objectMapper, result)));
} catch (IOErrorException e) {
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(),
getErrorDataNode(objectMapper, result)));
} catch (Throwable e) {
logger.error("Command execution failed", e);
throw new JsonRpcException(new JsonRpcResponse.Error(JsonRpcResponse.Error.INTERNAL_ERROR,
e.getMessage(),
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 <T> void parseParamsAndRunCommand(
final ObjectMapper objectMapper,
final TreeNode params,
final JsonWriter jsonWriter,
final CommandRunner<T> command
) throws CommandException, JsonMappingException {
T requestParams = null;
final var requestType = command.getRequestType();
if (params != null && requestType != null) {
try {
requestParams = objectMapper.readValue(objectMapper.treeAsTokens(params), requestType);
} catch (JsonMappingException e) {
throw e;
} catch (IOException e) {
throw new AssertionError(e);
}
}
command.handleCommand(requestParams, jsonWriter);
}
}

221
src/main/java/org/asamk/signal/jsonrpc/SignalJsonRpcDispatcherHandler.java
View file

@ -1,8 +1,6 @@
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.ArrayNode;
@ -13,25 +11,19 @@ import com.fasterxml.jackson.databind.node.ObjectNode;
import org.asamk.signal.commands.Command;
import org.asamk.signal.commands.Commands;
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.manager.api.Pair;
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.ClosedChannelException;
import java.nio.channels.OverlappingFileLockException;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
@ -42,19 +34,13 @@ public class SignalJsonRpcDispatcherHandler {
private final static Logger logger = LoggerFactory.getLogger(SignalJsonRpcDispatcherHandler.class);
private static final int USER_ERROR = -1;
private static final int IO_ERROR = -3;
private static final int UNTRUSTED_KEY_ERROR = -4;
private final ObjectMapper objectMapper;
private final JsonRpcSender jsonRpcSender;
private final JsonRpcReader jsonRpcReader;
private final boolean noReceiveOnStart;
private MultiAccountManager c;
private final Map<Integer, List<Pair<Manager, Manager.ReceiveMessageHandler>>> receiveHandlers = new HashMap<>();
private Manager m;
private SignalJsonRpcCommandHandler commandHandler;
public SignalJsonRpcDispatcherHandler(
final JsonWriter jsonWriter, final Supplier<String> lineSupplier, final boolean noReceiveOnStart
@ -66,7 +52,7 @@ public class SignalJsonRpcDispatcherHandler {
}
public void handleConnection(final MultiAccountManager c) {
this.c = c;
this.commandHandler = new SignalJsonRpcCommandHandler(c, this::getCommand);
if (!noReceiveOnStart) {
this.subscribeReceive(c.getManagers());
@ -78,7 +64,7 @@ public class SignalJsonRpcDispatcherHandler {
}
public void handleConnection(final Manager m) {
this.m = m;
this.commandHandler = new SignalJsonRpcCommandHandler(m, this::getCommand);
if (!noReceiveOnStart) {
subscribeReceive(m);
@ -141,7 +127,7 @@ public class SignalJsonRpcDispatcherHandler {
private void handleConnection() {
try {
jsonRpcReader.readMessages((method, params) -> handleRequest(objectMapper, method, params),
jsonRpcReader.readMessages((method, params) -> commandHandler.handleRequest(objectMapper, method, params),
response -> logger.debug("Received unexpected response for id {}", response.getId()));
} finally {
receiveHandlers.forEach((_subscriptionId, handlers) -> handlers.forEach(this::unsubscribeReceiveHandler));
@ -155,87 +141,6 @@ public class SignalJsonRpcDispatcherHandler {
m.removeReceiveHandler(handler);
}
private JsonNode handleRequest(
final ObjectMapper objectMapper, final String method, ContainerNode<?> params
) throws JsonRpcException {
var command = getCommand(method);
if (c != null) {
if (command instanceof JsonRpcSingleCommand<?> jsonRpcCommand) {
final var manager = getManagerFromParams(params);
if (manager != null) {
return runCommand(objectMapper, params, new CommandRunnerImpl<>(manager, jsonRpcCommand));
}
}
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) throws JsonRpcException {
if (params != null && params.hasNonNull("account")) {
final var manager = c.getManager(params.get("account").asText());
((ObjectNode) params).remove("account");
if (manager == null) {
throw new JsonRpcException(new JsonRpcResponse.Error(JsonRpcResponse.Error.INVALID_PARAMS,
"Specified account does not exist",
null));
}
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();
@ -246,124 +151,6 @@ public class SignalJsonRpcDispatcherHandler {
return Commands.getCommand(method);
}
private record CommandRunnerImpl<T>(Manager m, JsonRpcSingleCommand<T> command) implements CommandRunner<T> {
@Override
public void handleCommand(final T request, final JsonWriter jsonWriter) throws CommandException {
command.handleCommand(request, m, jsonWriter);
}
@Override
public TypeReference<T> getRequestType() {
return command.getRequestType();
}
}
private record RegistrationCommandRunnerImpl<T>(
RegistrationManager m, MultiAccountManager c, JsonRpcRegistrationCommand<T> command
) implements CommandRunner<T> {
@Override
public void handleCommand(final T request, final JsonWriter jsonWriter) throws CommandException {
command.handleCommand(request, m, jsonWriter);
}
@Override
public TypeReference<T> getRequestType() {
return command.getRequestType();
}
}
private record MultiCommandRunnerImpl<T>(
MultiAccountManager c, JsonRpcMultiCommand<T> command
) implements CommandRunner<T> {
@Override
public void handleCommand(final T request, final JsonWriter jsonWriter) throws CommandException {
command.handleCommand(request, c, jsonWriter);
}
@Override
public TypeReference<T> getRequestType() {
return command.getRequestType();
}
}
interface CommandRunner<T> {
void handleCommand(T request, JsonWriter jsonWriter) throws CommandException;
TypeReference<T> getRequestType();
}
private JsonNode runCommand(
final ObjectMapper objectMapper, final ContainerNode<?> params, final CommandRunner<?> command
) throws JsonRpcException {
final Object[] result = {null};
final JsonWriter commandJsonWriter = s -> {
if (result[0] != null) {
throw new AssertionError("Command may only write one json result");
}
result[0] = s;
};
try {
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(),
getErrorDataNode(objectMapper, result)));
} catch (IOErrorException e) {
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(),
getErrorDataNode(objectMapper, result)));
} catch (Throwable e) {
logger.error("Command execution failed", e);
throw new JsonRpcException(new JsonRpcResponse.Error(JsonRpcResponse.Error.INTERNAL_ERROR,
e.getMessage(),
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 <T> void parseParamsAndRunCommand(
final ObjectMapper objectMapper,
final TreeNode params,
final JsonWriter jsonWriter,
final CommandRunner<T> command
) throws CommandException, JsonMappingException {
T requestParams = null;
final var requestType = command.getRequestType();
if (params != null && requestType != null) {
try {
requestParams = objectMapper.readValue(objectMapper.treeAsTokens(params), requestType);
} catch (JsonMappingException e) {
throw e;
} catch (IOException e) {
throw new AssertionError(e);
}
}
command.handleCommand(requestParams, jsonWriter);
}
private class SubscribeReceiveCommand implements JsonRpcSingleCommand<Void>, JsonRpcMultiCommand<Void> {
@Override