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

   1 package org.asamk.signal;
   2
   3 import net.sourceforge.argparse4j.ArgumentParsers;
   4 import net.sourceforge.argparse4j.impl.Arguments;
   5 import net.sourceforge.argparse4j.inf.ArgumentParser;
   6 import net.sourceforge.argparse4j.inf.Namespace;
   7
   8 import org.asamk.Signal;
   9 import org.asamk.signal.commands.Command;
  10 import org.asamk.signal.commands.Commands;
  11 import org.asamk.signal.commands.LocalCommand;
  12 import org.asamk.signal.commands.MultiLocalCommand;
  13 import org.asamk.signal.commands.ProvisioningCommand;
  14 import org.asamk.signal.commands.RegistrationCommand;
  15 import org.asamk.signal.commands.exceptions.CommandException;
  16 import org.asamk.signal.commands.exceptions.IOErrorException;
  17 import org.asamk.signal.commands.exceptions.UnexpectedErrorException;
  18 import org.asamk.signal.commands.exceptions.UserErrorException;
  19 import org.asamk.signal.dbus.DbusManagerImpl;
  20 import org.asamk.signal.manager.Manager;
  21 import org.asamk.signal.manager.MultiAccountManagerImpl;
  22 import org.asamk.signal.manager.NotRegisteredException;
  23 import org.asamk.signal.manager.ProvisioningManager;
  24 import org.asamk.signal.manager.RegistrationManager;
  25 import org.asamk.signal.manager.config.ServiceConfig;
  26 import org.asamk.signal.manager.config.ServiceEnvironment;
  27 import org.asamk.signal.manager.storage.identities.TrustNewIdentity;
  28 import org.asamk.signal.output.JsonWriterImpl;
  29 import org.asamk.signal.output.OutputWriter;
  30 import org.asamk.signal.output.PlainTextWriterImpl;
  31 import org.asamk.signal.util.IOUtils;
  32 import org.freedesktop.dbus.connections.impl.DBusConnection;
  33 import org.freedesktop.dbus.exceptions.DBusException;
  34 import org.freedesktop.dbus.exceptions.DBusExecutionException;
  35 import org.slf4j.Logger;
  36 import org.slf4j.LoggerFactory;
  37
  38 import java.io.BufferedWriter;
  39 import java.io.File;
  40 import java.io.IOException;
  41 import java.io.OutputStreamWriter;
  42 import java.nio.charset.Charset;
  43 import java.util.ArrayList;
  44 import java.util.List;
  45
  46 import static net.sourceforge.argparse4j.DefaultSettings.VERSION_0_9_0_DEFAULT_SETTINGS;
  47
  48 public class App {
  49
  50     private final static Logger logger = LoggerFactory.getLogger(App.class);
  51
  52     private final Namespace ns;
  53
  54     static ArgumentParser buildArgumentParser() {
  55         var parser = ArgumentParsers.newFor("signal-cli", VERSION_0_9_0_DEFAULT_SETTINGS)
  56                 .includeArgumentNamesAsKeysInResult(true)
  57                 .build()
  58                 .defaultHelp(true)
  59                 .description("Commandline interface for Signal.")
  60                 .version(BaseConfig.PROJECT_NAME + " " + BaseConfig.PROJECT_VERSION);
  61
  62         parser.addArgument("-v", "--version").help("Show package version.").action(Arguments.version());
  63         parser.addArgument("--verbose")
  64                 .help("Raise log level and include lib signal logs.")
  65                 .action(Arguments.storeTrue());
  66         parser.addArgument("-c", "--config")
  67                 .help("Set the path, where to store the config (Default: $XDG_DATA_HOME/signal-cli , $HOME/.local/share/signal-cli).");
  68
  69         parser.addArgument("-a", "--account", "-u", "--username")
  70                 .help("Specify your phone number, that will be your identifier.");
  71
  72         var mut = parser.addMutuallyExclusiveGroup();
  73         mut.addArgument("--dbus").dest("global-dbus").help("Make request via user dbus.").action(Arguments.storeTrue());
  74         mut.addArgument("--dbus-system")
  75                 .dest("global-dbus-system")
  76                 .help("Make request via system dbus.")
  77                 .action(Arguments.storeTrue());
  78
  79         parser.addArgument("-o", "--output")
  80                 .help("Choose to output in plain text or JSON")
  81                 .type(Arguments.enumStringType(OutputType.class));
  82
  83         parser.addArgument("--service-environment")
  84                 .help("Choose the server environment to use.")
  85                 .type(Arguments.enumStringType(ServiceEnvironmentCli.class))
  86                 .setDefault(ServiceEnvironmentCli.LIVE);
  87
  88         parser.addArgument("--trust-new-identities")
  89                 .help("Choose when to trust new identities.")
  90                 .type(Arguments.enumStringType(TrustNewIdentityCli.class))
  91                 .setDefault(TrustNewIdentityCli.ON_FIRST_USE);
  92
  93         var subparsers = parser.addSubparsers().title("subcommands").dest("command");
  94
  95         Commands.getCommandSubparserAttachers().forEach((key, value) -> {
  96             var subparser = subparsers.addParser(key);
  97             value.attachToSubparser(subparser);
  98         });
  99
 100         return parser;
 101     }
 102
 103     public App(final Namespace ns) {
 104         this.ns = ns;
 105     }
 106
 107     public void init() throws CommandException {
 108         var commandKey = ns.getString("command");
 109         var command = Commands.getCommand(commandKey);
 110         if (command == null) {
 111             throw new UserErrorException("Command not implemented!");
 112         }
 113
 114         var outputTypeInput = ns.<OutputType>get("output");
 115         var outputType = outputTypeInput == null
 116                 ? command.getSupportedOutputTypes().stream().findFirst().orElse(null)
 117                 : outputTypeInput;
 118         var writer = new BufferedWriter(new OutputStreamWriter(System.out, Charset.defaultCharset()));
 119         var outputWriter = outputType == null
 120                 ? null
 121                 : outputType == OutputType.JSON ? new JsonWriterImpl(writer) : new PlainTextWriterImpl(writer);
 122
 123         if (outputWriter != null && !command.getSupportedOutputTypes().contains(outputType)) {
 124             throw new UserErrorException("Command doesn't support output type " + outputType);
 125         }
 126
 127         var account = ns.getString("account");
 128
 129         final var useDbus = Boolean.TRUE.equals(ns.getBoolean("global-dbus"));
 130         final var useDbusSystem = Boolean.TRUE.equals(ns.getBoolean("global-dbus-system"));
 131         if (useDbus || useDbusSystem) {
 132             // If account is null, it will connect to the default object path
 133             initDbusClient(command, account, useDbusSystem, outputWriter);
 134             return;
 135         }
 136
 137         final File dataPath;
 138         var config = ns.getString("config");
 139         if (config != null) {
 140             dataPath = new File(config);
 141         } else {
 142             dataPath = getDefaultDataPath();
 143         }
 144
 145         if (!ServiceConfig.isSignalClientAvailable()) {
 146             throw new UserErrorException("Missing required native library dependency: libsignal-client");
 147         }
 148
 149         final var serviceEnvironmentCli = ns.<ServiceEnvironmentCli>get("service-environment");
 150         final var serviceEnvironment = serviceEnvironmentCli == ServiceEnvironmentCli.LIVE
 151                 ? ServiceEnvironment.LIVE
 152                 : ServiceEnvironment.SANDBOX;
 153
 154         final var trustNewIdentityCli = ns.<TrustNewIdentityCli>get("trust-new-identities");
 155         final var trustNewIdentity = trustNewIdentityCli == TrustNewIdentityCli.ON_FIRST_USE
 156                 ? TrustNewIdentity.ON_FIRST_USE
 157                 : trustNewIdentityCli == TrustNewIdentityCli.ALWAYS ? TrustNewIdentity.ALWAYS : TrustNewIdentity.NEVER;
 158
 159         if (command instanceof ProvisioningCommand provisioningCommand) {
 160             if (account != null) {
 161                 throw new UserErrorException("You cannot specify a account (phone number) when linking");
 162             }
 163
 164             handleProvisioningCommand(provisioningCommand, dataPath, serviceEnvironment, outputWriter);
 165             return;
 166         }
 167
 168         if (account == null) {
 169             var accounts = Manager.getAllLocalAccountNumbers(dataPath);
 170
 171             if (command instanceof MultiLocalCommand multiLocalCommand) {
 172                 handleMultiLocalCommand(multiLocalCommand,
 173                         dataPath,
 174                         serviceEnvironment,
 175                         accounts,
 176                         outputWriter,
 177                         trustNewIdentity);
 178                 return;
 179             }
 180
 181             if (accounts.size() == 0) {
 182                 throw new UserErrorException("No local users found, you first need to register or link an account");
 183             } else if (accounts.size() > 1) {
 184                 throw new UserErrorException(
 185                         "Multiple users found, you need to specify an account (phone number) with -a");
 186             }
 187
 188             account = accounts.get(0);
 189         } else if (!Manager.isValidNumber(account, null)) {
 190             throw new UserErrorException("Invalid account (phone number), make sure you include the country code.");
 191         }
 192
 193         if (command instanceof RegistrationCommand registrationCommand) {
 194             handleRegistrationCommand(registrationCommand, account, dataPath, serviceEnvironment);
 195             return;
 196         }
 197
 198         if (!(command instanceof LocalCommand)) {
 199             throw new UserErrorException("Command only works via dbus");
 200         }
 201
 202         handleLocalCommand((LocalCommand) command,
 203                 account,
 204                 dataPath,
 205                 serviceEnvironment,
 206                 outputWriter,
 207                 trustNewIdentity);
 208     }
 209
 210     private void handleProvisioningCommand(
 211             final ProvisioningCommand command,
 212             final File dataPath,
 213             final ServiceEnvironment serviceEnvironment,
 214             final OutputWriter outputWriter
 215     ) throws CommandException {
 216         var pm = ProvisioningManager.init(dataPath, serviceEnvironment, BaseConfig.USER_AGENT);
 217         command.handleCommand(ns, pm, outputWriter);
 218     }
 219
 220     private void handleRegistrationCommand(
 221             final RegistrationCommand command,
 222             final String account,
 223             final File dataPath,
 224             final ServiceEnvironment serviceEnvironment
 225     ) throws CommandException {
 226         final RegistrationManager manager;
 227         try {
 228             manager = RegistrationManager.init(account, dataPath, serviceEnvironment, BaseConfig.USER_AGENT);
 229         } catch (Throwable e) {
 230             throw new UnexpectedErrorException("Error loading or creating state file: "
 231                     + e.getMessage()
 232                     + " ("
 233                     + e.getClass().getSimpleName()
 234                     + ")", e);
 235         }
 236         try (manager) {
 237             command.handleCommand(ns, manager);
 238         } catch (IOException e) {
 239             logger.warn("Cleanup failed", e);
 240         }
 241     }
 242
 243     private void handleLocalCommand(
 244             final LocalCommand command,
 245             final String account,
 246             final File dataPath,
 247             final ServiceEnvironment serviceEnvironment,
 248             final OutputWriter outputWriter,
 249             final TrustNewIdentity trustNewIdentity
 250     ) throws CommandException {
 251         try (var m = loadManager(account, dataPath, serviceEnvironment, trustNewIdentity)) {
 252             command.handleCommand(ns, m, outputWriter);
 253         } catch (IOException e) {
 254             logger.warn("Cleanup failed", e);
 255         }
 256     }
 257
 258     private void handleMultiLocalCommand(
 259             final MultiLocalCommand command,
 260             final File dataPath,
 261             final ServiceEnvironment serviceEnvironment,
 262             final List<String> accounts,
 263             final OutputWriter outputWriter,
 264             final TrustNewIdentity trustNewIdentity
 265     ) throws CommandException {
 266         final var managers = new ArrayList<Manager>();
 267         for (String a : accounts) {
 268             try {
 269                 managers.add(loadManager(a, dataPath, serviceEnvironment, trustNewIdentity));
 270             } catch (CommandException e) {
 271                 logger.warn("Ignoring {}: {}", a, e.getMessage());
 272             }
 273         }
 274
 275         try (var multiAccountManager = new MultiAccountManagerImpl(managers,
 276                 dataPath,
 277                 serviceEnvironment,
 278                 BaseConfig.USER_AGENT)) {
 279             command.handleCommand(ns, multiAccountManager, outputWriter);
 280         }
 281     }
 282
 283     private Manager loadManager(
 284             final String account,
 285             final File dataPath,
 286             final ServiceEnvironment serviceEnvironment,
 287             final TrustNewIdentity trustNewIdentity
 288     ) throws CommandException {
 289         Manager manager;
 290         try {
 291             manager = Manager.init(account, dataPath, serviceEnvironment, BaseConfig.USER_AGENT, trustNewIdentity);
 292         } catch (NotRegisteredException e) {
 293             throw new UserErrorException("User " + account + " is not registered.");
 294         } catch (Throwable e) {
 295             throw new UnexpectedErrorException("Error loading state file for user "
 296                     + account
 297                     + ": "
 298                     + e.getMessage()
 299                     + " ("
 300                     + e.getClass().getSimpleName()
 301                     + ")", e);
 302         }
 303
 304         try {
 305             manager.checkAccountState();
 306         } catch (IOException e) {
 307             try {
 308                 manager.close();
 309             } catch (IOException ie) {
 310                 logger.warn("Failed to close broken account", ie);
 311             }
 312             throw new IOErrorException("Error while checking account " + account + ": " + e.getMessage(), e);
 313         }
 314
 315         return manager;
 316     }
 317
 318     private void initDbusClient(
 319             final Command command, final String account, final boolean systemBus, final OutputWriter outputWriter
 320     ) throws CommandException {
 321         try {
 322             DBusConnection.DBusBusType busType;
 323             if (systemBus) {
 324                 busType = DBusConnection.DBusBusType.SYSTEM;
 325             } else {
 326                 busType = DBusConnection.DBusBusType.SESSION;
 327             }
 328             try (var dBusConn = DBusConnection.getConnection(busType)) {
 329                 var ts = dBusConn.getRemoteObject(DbusConfig.getBusname(),
 330                         DbusConfig.getObjectPath(account),
 331                         Signal.class);
 332
 333                 handleCommand(command, ts, dBusConn, outputWriter);
 334             }
 335         } catch (DBusException | IOException e) {
 336             logger.error("Dbus client failed", e);
 337             throw new UnexpectedErrorException("Dbus client failed", e);
 338         }
 339     }
 340
 341     private void handleCommand(
 342             Command command, Signal ts, DBusConnection dBusConn, OutputWriter outputWriter
 343     ) throws CommandException {
 344         if (command instanceof LocalCommand localCommand) {
 345             try (final var m = new DbusManagerImpl(ts, dBusConn)) {
 346                 localCommand.handleCommand(ns, m, outputWriter);
 347             } catch (UnsupportedOperationException e) {
 348                 throw new UserErrorException("Command is not yet implemented via dbus", e);
 349             } catch (IOException | DBusExecutionException e) {
 350                 throw new UnexpectedErrorException(e.getMessage(), e);
 351             }
 352         } else {
 353             throw new UserErrorException("Command is not yet implemented via dbus");
 354         }
 355     }
 356
 357     /**
 358      * @return the default data directory to be used by signal-cli.
 359      */
 360     private static File getDefaultDataPath() {
 361         return new File(IOUtils.getDataHomeDir(), "signal-cli");
 362     }
 363 }