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

   1 /*
   2   Copyright (C) 2015-2020 AsamK and contributors
   3
   4   This program is free software: you can redistribute it and/or modify
   5   it under the terms of the GNU General Public License as published by
   6   the Free Software Foundation, either version 3 of the License, or
   7   (at your option) any later version.
   8
   9   This program is distributed in the hope that it will be useful,
  10   but WITHOUT ANY WARRANTY; without even the implied warranty of
  11   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12   GNU General Public License for more details.
  13
  14   You should have received a copy of the GNU General Public License
  15   along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16  */
  17 package org.asamk.signal;
  18
  19 import net.sourceforge.argparse4j.ArgumentParsers;
  20 import net.sourceforge.argparse4j.impl.Arguments;
  21 import net.sourceforge.argparse4j.inf.ArgumentParser;
  22 import net.sourceforge.argparse4j.inf.ArgumentParserException;
  23 import net.sourceforge.argparse4j.inf.MutuallyExclusiveGroup;
  24 import net.sourceforge.argparse4j.inf.Namespace;
  25 import net.sourceforge.argparse4j.inf.Subparser;
  26 import net.sourceforge.argparse4j.inf.Subparsers;
  27
  28 import org.asamk.Signal;
  29 import org.asamk.signal.commands.Command;
  30 import org.asamk.signal.commands.Commands;
  31 import org.asamk.signal.commands.DbusCommand;
  32 import org.asamk.signal.commands.ExtendedDbusCommand;
  33 import org.asamk.signal.commands.LocalCommand;
  34 import org.asamk.signal.commands.ProvisioningCommand;
  35 import org.asamk.signal.dbus.DbusSignalImpl;
  36 import org.asamk.signal.manager.Manager;
  37 import org.asamk.signal.manager.ProvisioningManager;
  38 import org.asamk.signal.manager.ServiceConfig;
  39 import org.asamk.signal.util.IOUtils;
  40 import org.asamk.signal.util.SecurityProvider;
  41 import org.bouncycastle.jce.provider.BouncyCastleProvider;
  42 import org.freedesktop.dbus.connections.impl.DBusConnection;
  43 import org.freedesktop.dbus.exceptions.DBusException;
  44 import org.whispersystems.signalservice.api.push.exceptions.AuthorizationFailedException;
  45 import org.whispersystems.signalservice.api.util.PhoneNumberFormatter;
  46 import org.whispersystems.signalservice.internal.configuration.SignalServiceConfiguration;
  47
  48 import java.io.File;
  49 import java.io.IOException;
  50 import java.security.Security;
  51 import java.util.Map;
  52
  53 import static org.whispersystems.signalservice.internal.util.Util.isEmpty;
  54
  55 public class Main {
  56
  57     public static void main(String[] args) {
  58         installSecurityProviderWorkaround();
  59
  60         Namespace ns = parseArgs(args);
  61         if (ns == null) {
  62             System.exit(1);
  63         }
  64
  65         int res = handleCommands(ns);
  66         System.exit(res);
  67     }
  68
  69     public static void installSecurityProviderWorkaround() {
  70         // Register our own security provider
  71         Security.insertProviderAt(new SecurityProvider(), 1);
  72         Security.addProvider(new BouncyCastleProvider());
  73     }
  74
  75     private static int handleCommands(Namespace ns) {
  76         final String username = ns.getString("username");
  77
  78         if (ns.getBoolean("dbus") || ns.getBoolean("dbus_system")) {
  79             try {
  80                 DBusConnection.DBusBusType busType;
  81                 if (ns.getBoolean("dbus_system")) {
  82                     busType = DBusConnection.DBusBusType.SYSTEM;
  83                 } else {
  84                     busType = DBusConnection.DBusBusType.SESSION;
  85                 }
  86                 try (DBusConnection dBusConn = DBusConnection.getConnection(busType)) {
  87                     Signal ts = dBusConn.getRemoteObject(DbusConfig.SIGNAL_BUSNAME,
  88                             DbusConfig.SIGNAL_OBJECTPATH,
  89                             Signal.class);
  90
  91                     return handleCommands(ns, ts, dBusConn);
  92                 }
  93             } catch (UnsatisfiedLinkError e) {
  94                 System.err.println("Missing native library dependency for dbus service: " + e.getMessage());
  95                 return 1;
  96             } catch (DBusException | IOException e) {
  97                 e.printStackTrace();
  98                 return 3;
  99             }
 100         } else {
 101             String dataPath = ns.getString("config");
 102             if (isEmpty(dataPath)) {
 103                 dataPath = getDefaultDataPath();
 104             }
 105
 106             final SignalServiceConfiguration serviceConfiguration = ServiceConfig.createDefaultServiceConfiguration(
 107                     BaseConfig.USER_AGENT);
 108
 109             if (!ServiceConfig.getCapabilities().isGv2()) {
 110                 System.err.println("WARNING: Support for new group V2 is disabled,"
 111                         + " because the required native library dependency is missing: libzkgroup");
 112             }
 113
 114             if (username == null) {
 115                 ProvisioningManager pm = new ProvisioningManager(dataPath, serviceConfiguration, BaseConfig.USER_AGENT);
 116                 return handleCommands(ns, pm);
 117             }
 118
 119             Manager manager;
 120             try {
 121                 manager = Manager.init(username, dataPath, serviceConfiguration, BaseConfig.USER_AGENT);
 122             } catch (Throwable e) {
 123                 System.err.println("Error loading state file: " + e.getMessage());
 124                 return 2;
 125             }
 126
 127             try (Manager m = manager) {
 128                 try {
 129                     m.checkAccountState();
 130                 } catch (AuthorizationFailedException e) {
 131                     if (!"register".equals(ns.getString("command"))) {
 132                         // Register command should still be possible, if current authorization fails
 133                         System.err.println("Authorization failed, was the number registered elsewhere?");
 134                         return 2;
 135                     }
 136                 } catch (IOException e) {
 137                     System.err.println("Error while checking account: " + e.getMessage());
 138                     return 2;
 139                 }
 140
 141                 return handleCommands(ns, m);
 142             } catch (IOException e) {
 143                 e.printStackTrace();
 144                 return 3;
 145             }
 146         }
 147     }
 148
 149     private static int handleCommands(Namespace ns, Signal ts, DBusConnection dBusConn) {
 150         String commandKey = ns.getString("command");
 151         final Map<String, Command> commands = Commands.getCommands();
 152         if (commands.containsKey(commandKey)) {
 153             Command command = commands.get(commandKey);
 154
 155             if (command instanceof ExtendedDbusCommand) {
 156                 return ((ExtendedDbusCommand) command).handleCommand(ns, ts, dBusConn);
 157             } else if (command instanceof DbusCommand) {
 158                 return ((DbusCommand) command).handleCommand(ns, ts);
 159             } else {
 160                 System.err.println(commandKey + " is not yet implemented via dbus");
 161                 return 1;
 162             }
 163         }
 164         return 0;
 165     }
 166
 167     private static int handleCommands(Namespace ns, ProvisioningManager pm) {
 168         String commandKey = ns.getString("command");
 169         final Map<String, Command> commands = Commands.getCommands();
 170         if (commands.containsKey(commandKey)) {
 171             Command command = commands.get(commandKey);
 172
 173             if (command instanceof ProvisioningCommand) {
 174                 return ((ProvisioningCommand) command).handleCommand(ns, pm);
 175             } else {
 176                 System.err.println(commandKey + " only works with a username");
 177                 return 1;
 178             }
 179         }
 180         return 0;
 181     }
 182
 183     private static int handleCommands(Namespace ns, Manager m) {
 184         String commandKey = ns.getString("command");
 185         final Map<String, Command> commands = Commands.getCommands();
 186         if (commands.containsKey(commandKey)) {
 187             Command command = commands.get(commandKey);
 188
 189             if (command instanceof LocalCommand) {
 190                 return ((LocalCommand) command).handleCommand(ns, m);
 191             } else if (command instanceof DbusCommand) {
 192                 return ((DbusCommand) command).handleCommand(ns, new DbusSignalImpl(m));
 193             } else if (command instanceof ExtendedDbusCommand) {
 194                 System.err.println(commandKey + " only works via dbus");
 195             }
 196             return 1;
 197         }
 198         return 0;
 199     }
 200
 201     /**
 202      * Uses $XDG_DATA_HOME/signal-cli if it exists, or if none of the legacy directories exist:
 203      * - $HOME/.config/signal
 204      * - $HOME/.config/textsecure
 205      *
 206      * @return the data directory to be used by signal-cli.
 207      */
 208     private static String getDefaultDataPath() {
 209         String dataPath = IOUtils.getDataHomeDir() + "/signal-cli";
 210         if (new File(dataPath).exists()) {
 211             return dataPath;
 212         }
 213
 214         String legacySettingsPath = System.getProperty("user.home") + "/.config/signal";
 215         if (new File(legacySettingsPath).exists()) {
 216             return legacySettingsPath;
 217         }
 218
 219         legacySettingsPath = System.getProperty("user.home") + "/.config/textsecure";
 220         if (new File(legacySettingsPath).exists()) {
 221             return legacySettingsPath;
 222         }
 223
 224         return dataPath;
 225     }
 226
 227     private static Namespace parseArgs(String[] args) {
 228         ArgumentParser parser = ArgumentParsers.newFor("signal-cli")
 229                 .build()
 230                 .defaultHelp(true)
 231                 .description("Commandline interface for Signal.")
 232                 .version(BaseConfig.PROJECT_NAME + " " + BaseConfig.PROJECT_VERSION);
 233
 234         parser.addArgument("-v", "--version").help("Show package version.").action(Arguments.version());
 235         parser.addArgument("--config")
 236                 .help("Set the path, where to store the config (Default: $XDG_DATA_HOME/signal-cli , $HOME/.local/share/signal-cli).");
 237
 238         MutuallyExclusiveGroup mut = parser.addMutuallyExclusiveGroup();
 239         mut.addArgument("-u", "--username").help("Specify your phone number, that will be used for verification.");
 240         mut.addArgument("--dbus").help("Make request via user dbus.").action(Arguments.storeTrue());
 241         mut.addArgument("--dbus-system").help("Make request via system dbus.").action(Arguments.storeTrue());
 242
 243         Subparsers subparsers = parser.addSubparsers()
 244                 .title("subcommands")
 245                 .dest("command")
 246                 .description("valid subcommands")
 247                 .help("additional help");
 248
 249         final Map<String, Command> commands = Commands.getCommands();
 250         for (Map.Entry<String, Command> entry : commands.entrySet()) {
 251             Subparser subparser = subparsers.addParser(entry.getKey());
 252             entry.getValue().attachToSubparser(subparser);
 253         }
 254
 255         Namespace ns;
 256         try {
 257             ns = parser.parseArgs(args);
 258         } catch (ArgumentParserException e) {
 259             parser.handleError(e);
 260             return null;
 261         }
 262
 263         if ("link".equals(ns.getString("command"))) {
 264             if (ns.getString("username") != null) {
 265                 parser.printUsage();
 266                 System.err.println("You cannot specify a username (phone number) when linking");
 267                 System.exit(2);
 268             }
 269         } else if (!ns.getBoolean("dbus") && !ns.getBoolean("dbus_system")) {
 270             if (ns.getString("username") == null) {
 271                 parser.printUsage();
 272                 System.err.println("You need to specify a username (phone number)");
 273                 System.exit(2);
 274             }
 275             if (!PhoneNumberFormatter.isValidNumber(ns.getString("username"), null)) {
 276                 System.err.println("Invalid username (phone number), make sure you include the country code.");
 277                 System.exit(2);
 278             }
 279         }
 280         if (ns.getList("recipient") != null && !ns.getList("recipient").isEmpty() && ns.getString("group") != null) {
 281             System.err.println("You cannot specify recipients by phone number and groups at the same time");
 282             System.exit(2);
 283         }
 284         return ns;
 285     }
 286 }