X-Git-Url: https://git.nmode.ca/signal-cli/blobdiff_plain/425e45123773a506c5ff9b75d5fae4591b34a383..3e981d66e9534db61953078b3ca8faf16ed9dd2d:/src/main/java/org/asamk/signal/commands/DaemonCommand.java diff --git a/src/main/java/org/asamk/signal/commands/DaemonCommand.java b/src/main/java/org/asamk/signal/commands/DaemonCommand.java index e6fb1d81..6790c65d 100644 --- a/src/main/java/org/asamk/signal/commands/DaemonCommand.java +++ b/src/main/java/org/asamk/signal/commands/DaemonCommand.java @@ -7,42 +7,36 @@ import net.sourceforge.argparse4j.inf.Subparser; import org.asamk.signal.DbusConfig; import org.asamk.signal.OutputType; import org.asamk.signal.ReceiveMessageHandler; +import org.asamk.signal.Shutdown; import org.asamk.signal.commands.exceptions.CommandException; import org.asamk.signal.commands.exceptions.IOErrorException; -import org.asamk.signal.commands.exceptions.UnexpectedErrorException; -import org.asamk.signal.commands.exceptions.UserErrorException; -import org.asamk.signal.dbus.DbusSignalControlImpl; -import org.asamk.signal.dbus.DbusSignalImpl; +import org.asamk.signal.dbus.DbusHandler; +import org.asamk.signal.http.HttpServerHandler; import org.asamk.signal.json.JsonReceiveMessageHandler; -import org.asamk.signal.jsonrpc.SignalJsonRpcDispatcherHandler; +import org.asamk.signal.jsonrpc.SocketHandler; import org.asamk.signal.manager.Manager; import org.asamk.signal.manager.MultiAccountManager; import org.asamk.signal.output.JsonWriter; -import org.asamk.signal.output.JsonWriterImpl; import org.asamk.signal.output.OutputWriter; import org.asamk.signal.output.PlainTextWriter; import org.asamk.signal.util.IOUtils; -import org.freedesktop.dbus.connections.impl.DBusConnection; -import org.freedesktop.dbus.connections.impl.DBusConnectionBuilder; -import org.freedesktop.dbus.exceptions.DBusException; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import java.io.File; import java.io.IOException; +import java.net.InetSocketAddress; import java.net.UnixDomainSocketAddress; import java.nio.channels.Channel; -import java.nio.channels.Channels; import java.nio.channels.ServerSocketChannel; -import java.nio.channels.SocketChannel; -import java.nio.charset.StandardCharsets; +import java.util.ArrayList; import java.util.List; -import java.util.concurrent.atomic.AtomicInteger; -import java.util.function.Consumer; + +import static org.asamk.signal.util.CommandUtil.getReceiveConfig; public class DaemonCommand implements MultiLocalCommand, LocalCommand { - private final static Logger logger = LoggerFactory.getLogger(DaemonCommand.class); + private static final Logger logger = LoggerFactory.getLogger(DaemonCommand.class); @Override public String getName() { @@ -52,13 +46,14 @@ public class DaemonCommand implements MultiLocalCommand, LocalCommand { @Override public void attachToSubparser(final Subparser subparser) { final var defaultSocketPath = new File(new File(IOUtils.getRuntimeDir(), "signal-cli"), "socket"); - subparser.help("Run in daemon mode and provide an experimental dbus or JSON-RPC interface."); - subparser.addArgument("--dbus") - .action(Arguments.storeTrue()) - .help("Expose a DBus interface on the user bus (the default, if no other options are given)."); + subparser.help("Run in daemon mode and provide a JSON-RPC or an experimental dbus interface."); + subparser.addArgument("--dbus").action(Arguments.storeTrue()).help("Expose a DBus interface on the user bus."); subparser.addArgument("--dbus-system", "--system") .action(Arguments.storeTrue()) .help("Expose a DBus interface on the system bus."); + subparser.addArgument("--bus-name") + .setDefault(DbusConfig.getBusname()) + .help("Specify the D-Bus bus name to connect to."); subparser.addArgument("--socket") .nargs("?") .type(File.class) @@ -68,6 +63,10 @@ public class DaemonCommand implements MultiLocalCommand, LocalCommand { .nargs("?") .setConst("localhost:7583") .help("Expose a JSON-RPC interface on a TCP socket (default localhost:7583)."); + subparser.addArgument("--http") + .nargs("?") + .setConst("localhost:8080") + .help("Expose a JSON-RPC interface as http endpoint (default localhost:8080)."); subparser.addArgument("--no-receive-stdout") .help("Don’t print received messages to stdout.") .action(Arguments.storeTrue()); @@ -78,6 +77,12 @@ public class DaemonCommand implements MultiLocalCommand, LocalCommand { subparser.addArgument("--ignore-attachments") .help("Don’t download attachments of received messages.") .action(Arguments.storeTrue()); + subparser.addArgument("--ignore-stories") + .help("Don’t receive story messages from the server.") + .action(Arguments.storeTrue()); + subparser.addArgument("--send-read-receipts") + .help("Send read receipts for all incoming data messages (in addition to the default delivery receipts)") + .action(Arguments.storeTrue()); } @Override @@ -87,61 +92,26 @@ public class DaemonCommand implements MultiLocalCommand, LocalCommand { @Override public void handleCommand( - final Namespace ns, final Manager m, final OutputWriter outputWriter + final Namespace ns, + final Manager m, + final OutputWriter outputWriter ) throws CommandException { - logger.info("Starting daemon in single-account mode for " + m.getSelfNumber()); + Shutdown.installHandler(); + logger.info("Starting daemon in single-account mode for {}", m.getSelfNumber()); final var noReceiveStdOut = Boolean.TRUE.equals(ns.getBoolean("no-receive-stdout")); final var receiveMode = ns.get("receive-mode"); - final var ignoreAttachments = Boolean.TRUE.equals(ns.getBoolean("ignore-attachments")); + final var receiveConfig = getReceiveConfig(ns); - m.setIgnoreAttachments(ignoreAttachments); + m.setReceiveConfig(receiveConfig); addDefaultReceiveHandler(m, noReceiveStdOut ? null : outputWriter, receiveMode != ReceiveMode.ON_START); - final Channel inheritedChannel; - try { - inheritedChannel = System.inheritedChannel(); - if (inheritedChannel instanceof ServerSocketChannel serverChannel) { - logger.info("Using inherited socket: " + serverChannel.getLocalAddress()); - runSocketSingleAccount(m, serverChannel, receiveMode == ReceiveMode.MANUAL); - } - } catch (IOException e) { - throw new IOErrorException("Failed to use inherited socket", e); - } - final var socketFile = ns.get("socket"); - if (socketFile != null) { - final var address = UnixDomainSocketAddress.of(socketFile.toPath()); - final var serverChannel = IOUtils.bindSocket(address); - runSocketSingleAccount(m, serverChannel, receiveMode == ReceiveMode.MANUAL); - } - final var tcpAddress = ns.getString("tcp"); - if (tcpAddress != null) { - final var address = IOUtils.parseInetSocketAddress(tcpAddress); - final var serverChannel = IOUtils.bindSocket(address); - runSocketSingleAccount(m, serverChannel, receiveMode == ReceiveMode.MANUAL); - } - final var isDbusSystem = Boolean.TRUE.equals(ns.getBoolean("dbus-system")); - if (isDbusSystem) { - runDbusSingleAccount(m, true, receiveMode != ReceiveMode.ON_START); - } - final var isDbusSession = Boolean.TRUE.equals(ns.getBoolean("dbus")); - if (isDbusSession || ( - !isDbusSystem - && socketFile == null - && tcpAddress == null - && !(inheritedChannel instanceof ServerSocketChannel) - )) { - runDbusSingleAccount(m, false, receiveMode != ReceiveMode.ON_START); - } + try (final var daemonHandler = new SingleAccountDaemonHandler(m, receiveMode)) { + setup(ns, daemonHandler); - m.addClosedListener(() -> { - synchronized (this) { - notifyAll(); - } - }); + m.addClosedListener(Shutdown::triggerShutdown); - synchronized (this) { try { - wait(); + Shutdown.waitForShutdown(); } catch (InterruptedException ignored) { } } @@ -149,238 +119,199 @@ public class DaemonCommand implements MultiLocalCommand, LocalCommand { @Override public void handleCommand( - final Namespace ns, final MultiAccountManager c, final OutputWriter outputWriter + final Namespace ns, + final MultiAccountManager c, + final OutputWriter outputWriter ) throws CommandException { + Shutdown.installHandler(); logger.info("Starting daemon in multi-account mode"); final var noReceiveStdOut = Boolean.TRUE.equals(ns.getBoolean("no-receive-stdout")); final var receiveMode = ns.get("receive-mode"); - final var ignoreAttachments = Boolean.TRUE.equals(ns.getBoolean("ignore-attachments")); - + final var receiveConfig = getReceiveConfig(ns); c.getManagers().forEach(m -> { - m.setIgnoreAttachments(ignoreAttachments); + m.setReceiveConfig(receiveConfig); addDefaultReceiveHandler(m, noReceiveStdOut ? null : outputWriter, receiveMode != ReceiveMode.ON_START); }); c.addOnManagerAddedHandler(m -> { - m.setIgnoreAttachments(ignoreAttachments); + m.setReceiveConfig(receiveConfig); addDefaultReceiveHandler(m, noReceiveStdOut ? null : outputWriter, receiveMode != ReceiveMode.ON_START); }); + try (final var daemonHandler = new MultiAccountDaemonHandler(c, receiveMode)) { + setup(ns, daemonHandler); + + synchronized (this) { + try { + Shutdown.waitForShutdown(); + } catch (InterruptedException ignored) { + } + } + } + } + + private static void setup(final Namespace ns, final DaemonHandler daemonHandler) throws CommandException { final Channel inheritedChannel; try { - inheritedChannel = System.inheritedChannel(); - if (inheritedChannel instanceof ServerSocketChannel serverChannel) { + if (System.inheritedChannel() instanceof ServerSocketChannel serverChannel) { + inheritedChannel = serverChannel; logger.info("Using inherited socket: " + serverChannel.getLocalAddress()); - runSocketMultiAccount(c, serverChannel, receiveMode == ReceiveMode.MANUAL); + daemonHandler.runSocket(serverChannel); + } else { + inheritedChannel = null; } } catch (IOException e) { throw new IOErrorException("Failed to use inherited socket", e); } + final var socketFile = ns.get("socket"); if (socketFile != null) { final var address = UnixDomainSocketAddress.of(socketFile.toPath()); final var serverChannel = IOUtils.bindSocket(address); - runSocketMultiAccount(c, serverChannel, receiveMode == ReceiveMode.MANUAL); + daemonHandler.runSocket(serverChannel); } + final var tcpAddress = ns.getString("tcp"); if (tcpAddress != null) { final var address = IOUtils.parseInetSocketAddress(tcpAddress); final var serverChannel = IOUtils.bindSocket(address); - runSocketMultiAccount(c, serverChannel, receiveMode == ReceiveMode.MANUAL); + daemonHandler.runSocket(serverChannel); } + + final var httpAddress = ns.getString("http"); + if (httpAddress != null) { + final var address = IOUtils.parseInetSocketAddress(httpAddress); + daemonHandler.runHttp(address); + } + final var isDbusSystem = Boolean.TRUE.equals(ns.getBoolean("dbus-system")); if (isDbusSystem) { - runDbusMultiAccount(c, receiveMode != ReceiveMode.ON_START, true); + final var busName = ns.getString("bus-name"); + daemonHandler.runDbus(true, busName); } + final var isDbusSession = Boolean.TRUE.equals(ns.getBoolean("dbus")); - if (isDbusSession || ( - !isDbusSystem - && socketFile == null - && tcpAddress == null - && !(inheritedChannel instanceof ServerSocketChannel) - )) { - runDbusMultiAccount(c, receiveMode != ReceiveMode.ON_START, false); + if (isDbusSession) { + final var busName = ns.getString("bus-name"); + daemonHandler.runDbus(false, busName); } - synchronized (this) { - try { - wait(); - } catch (InterruptedException ignored) { - } + if (!isDbusSystem + && !isDbusSession + && socketFile == null + && tcpAddress == null + && httpAddress == null + && inheritedChannel == null) { + logger.warn( + "Running daemon command without explicit mode is deprecated. Use 'daemon --dbus' to use the dbus interface."); + daemonHandler.runDbus(false, DbusConfig.getBusname()); } } private void addDefaultReceiveHandler(Manager m, OutputWriter outputWriter, final boolean isWeakListener) { - final var handler = outputWriter instanceof JsonWriter o - ? new JsonReceiveMessageHandler(m, o) - : outputWriter instanceof PlainTextWriter o - ? new ReceiveMessageHandler(m, o) - : Manager.ReceiveMessageHandler.EMPTY; + final var handler = switch (outputWriter) { + case PlainTextWriter writer -> new ReceiveMessageHandler(m, writer); + case JsonWriter writer -> new JsonReceiveMessageHandler(m, writer); + case null -> Manager.ReceiveMessageHandler.EMPTY; + }; m.addReceiveHandler(handler, isWeakListener); } - private void runSocketSingleAccount( - final Manager m, final ServerSocketChannel serverChannel, final boolean noReceiveOnStart - ) { - runSocket(serverChannel, channel -> { - final var handler = getSignalJsonRpcDispatcherHandler(channel, noReceiveOnStart); - handler.handleConnection(m); - }); - } - - private void runSocketMultiAccount( - final MultiAccountManager c, final ServerSocketChannel serverChannel, final boolean noReceiveOnStart - ) { - runSocket(serverChannel, channel -> { - final var handler = getSignalJsonRpcDispatcherHandler(channel, noReceiveOnStart); - handler.handleConnection(c); - }); - } + private static abstract class DaemonHandler implements AutoCloseable { - private static final AtomicInteger threadNumber = new AtomicInteger(0); + protected final ReceiveMode receiveMode; + protected final List closeables = new ArrayList<>(); - private void runSocket(final ServerSocketChannel serverChannel, Consumer socketHandler) { - final var thread = new Thread(() -> { - while (true) { - final var connectionId = threadNumber.getAndIncrement(); - final SocketChannel channel; - final String clientString; - try { - channel = serverChannel.accept(); - clientString = channel.getRemoteAddress() + " " + IOUtils.getUnixDomainPrincipal(channel); - logger.info("Accepted new client connection {}: {}", connectionId, clientString); - } catch (IOException e) { - logger.error("Failed to accept new socket connection", e); - synchronized (this) { - notifyAll(); - } - break; - } - final var connectionThread = new Thread(() -> { - try (final var c = channel) { - socketHandler.accept(c); - } catch (IOException e) { - logger.warn("Failed to close channel", e); - } catch (Throwable e) { - logger.warn("Connection handler failed, closing connection", e); - } - logger.info("Connection {} closed: {}", connectionId, clientString); - }); - connectionThread.setName("daemon-connection-" + connectionId); - connectionThread.start(); - } - }); - thread.setName("daemon-listener"); - thread.start(); - } + protected DaemonHandler(final ReceiveMode receiveMode) { + this.receiveMode = receiveMode; + } - private SignalJsonRpcDispatcherHandler getSignalJsonRpcDispatcherHandler( - final SocketChannel c, final boolean noReceiveOnStart - ) { - final var lineSupplier = IOUtils.getLineSupplier(Channels.newReader(c, StandardCharsets.UTF_8)); - final var jsonOutputWriter = new JsonWriterImpl(Channels.newWriter(c, StandardCharsets.UTF_8)); + public abstract void runSocket(ServerSocketChannel serverChannel) throws CommandException; - return new SignalJsonRpcDispatcherHandler(jsonOutputWriter, lineSupplier, noReceiveOnStart); - } + public abstract void runDbus(boolean isDbusSystem, final String busname) throws CommandException; - private void runDbusSingleAccount( - final Manager m, final boolean isDbusSystem, final boolean noReceiveOnStart - ) throws CommandException { - runDbus(isDbusSystem, (conn, objectPath) -> { - try { - exportDbusObject(conn, objectPath, m, noReceiveOnStart).join(); - } catch (InterruptedException ignored) { - } - }); - } + public abstract void runHttp(InetSocketAddress address) throws CommandException; - private void runDbusMultiAccount( - final MultiAccountManager c, final boolean noReceiveOnStart, final boolean isDbusSystem - ) throws CommandException { - runDbus(isDbusSystem, (connection, objectPath) -> { - final var signalControl = new DbusSignalControlImpl(c, objectPath); - connection.exportObject(signalControl); + protected final void runSocket(final SocketHandler socketHandler) { + socketHandler.init(); + this.closeables.add(socketHandler); + } - c.addOnManagerAddedHandler(m -> { - final var thread = exportMultiAccountManager(connection, m, noReceiveOnStart); - try { - thread.join(); - } catch (InterruptedException ignored) { - } - }); - c.addOnManagerRemovedHandler(m -> { - final var path = DbusConfig.getObjectPath(m.getSelfNumber()); - try { - final var object = connection.getExportedObject(null, path); - if (object instanceof DbusSignalImpl dbusSignal) { - dbusSignal.close(); - } - } catch (DBusException ignored) { - } - }); + protected final void runDbus( + DbusHandler dbusHandler + ) throws CommandException { + dbusHandler.init(); + this.closeables.add(dbusHandler); + } - final var initThreads = c.getManagers() - .stream() - .map(m -> exportMultiAccountManager(connection, m, noReceiveOnStart)) - .toList(); + protected final void runHttp(final HttpServerHandler handler) throws CommandException { + try { + handler.init(); + } catch (IOException ex) { + throw new IOErrorException("Failed to initialize HTTP Server", ex); + } + this.closeables.add(handler); + } - for (var t : initThreads) { + @Override + public void close() { + for (final var closeable : new ArrayList<>(this.closeables)) { try { - t.join(); - } catch (InterruptedException ignored) { + closeable.close(); + } catch (Exception e) { + logger.warn("Failed to close daemon handler", e); } } - }); + this.closeables.clear(); + } } - private void runDbus( - final boolean isDbusSystem, DbusRunner dbusRunner - ) throws CommandException { - DBusConnection.DBusBusType busType; - if (isDbusSystem) { - busType = DBusConnection.DBusBusType.SYSTEM; - } else { - busType = DBusConnection.DBusBusType.SESSION; + private static final class SingleAccountDaemonHandler extends DaemonHandler { + + private final Manager m; + + public SingleAccountDaemonHandler(final Manager m, final ReceiveMode receiveMode) { + super(receiveMode); + this.m = m; } - DBusConnection conn; - try { - conn = DBusConnectionBuilder.forType(busType).build(); - dbusRunner.run(conn, DbusConfig.getObjectPath()); - } catch (DBusException e) { - throw new UnexpectedErrorException("Dbus command failed: " + e.getMessage(), e); - } catch (UnsupportedOperationException e) { - throw new UserErrorException("Failed to connect to Dbus: " + e.getMessage(), e); + + @Override + public void runSocket(final ServerSocketChannel serverChannel) { + runSocket(new SocketHandler(serverChannel, m, receiveMode == ReceiveMode.MANUAL)); } - try { - conn.requestBusName(DbusConfig.getBusname()); - } catch (DBusException e) { - throw new UnexpectedErrorException("Dbus command failed, maybe signal-cli dbus daemon is already running: " - + e.getMessage(), e); + @Override + public void runDbus(final boolean isDbusSystem, final String busname) throws CommandException { + runDbus(new DbusHandler(isDbusSystem, busname, m, receiveMode != ReceiveMode.ON_START)); } - logger.info("DBus daemon running on {} bus: {}", busType, DbusConfig.getBusname()); + @Override + public void runHttp(InetSocketAddress address) throws CommandException { + runHttp(new HttpServerHandler(address, m)); + } } - private Thread exportMultiAccountManager( - final DBusConnection conn, final Manager m, final boolean noReceiveOnStart - ) { - final var objectPath = DbusConfig.getObjectPath(m.getSelfNumber()); - return exportDbusObject(conn, objectPath, m, noReceiveOnStart); - } + private static final class MultiAccountDaemonHandler extends DaemonHandler { - private Thread exportDbusObject( - final DBusConnection conn, final String objectPath, final Manager m, final boolean noReceiveOnStart - ) { - final var signal = new DbusSignalImpl(m, conn, objectPath, noReceiveOnStart); - final var initThread = new Thread(signal::initObjects); - initThread.setName("dbus-init"); - initThread.start(); + private final MultiAccountManager c; - return initThread; - } + public MultiAccountDaemonHandler(final MultiAccountManager c, final ReceiveMode receiveMode) { + super(receiveMode); + this.c = c; + } + + @Override + public void runSocket(final ServerSocketChannel serverChannel) { + runSocket(new SocketHandler(serverChannel, c, receiveMode == ReceiveMode.MANUAL)); + } - interface DbusRunner { + @Override + public void runDbus(final boolean isDbusSystem, final String busname) throws CommandException { + runDbus(new DbusHandler(isDbusSystem, busname, c, receiveMode != ReceiveMode.ON_START)); + } - void run(DBusConnection connection, String objectPath) throws DBusException; + @Override + public void runHttp(final InetSocketAddress address) throws CommandException { + runHttp(new HttpServerHandler(address, c)); + } } }