nmode's Git Repositories - signal-cli/blob - client/src/main.rs

   1 use clap::StructOpt;
   2 use jsonrpc_client_transports::{RpcError, TypedSubscriptionStream};
   3 use jsonrpc_core::{futures_util::StreamExt, Value};
   4 use std::{path::PathBuf, time::Duration};
   5 use tokio::{select, time::sleep};
   6
   7 use crate::cli::{GroupPermission, LinkState};
   8
   9 mod cli;
  10 #[allow(clippy::too_many_arguments)]
  11 mod jsonrpc;
  12 mod tcp;
  13
  14 const DEFAULT_TCP: &str = "127.0.0.1:7583";
  15 const DEFAULT_SOCKET_SUFFIX: &str = "signal-cli/socket";
  16
  17 #[tokio::main]
  18 async fn main() -> Result<(), anyhow::Error> {
  19     let cli = cli::Cli::parse();
  20
  21     let client = connect(&cli)
  22         .await
  23         .map_err(|e| anyhow::anyhow!("Failed to connect to socket: {e}"))?;
  24
  25     let result = match cli.command {
  26         cli::CliCommands::Receive { timeout } => {
  27             let mut stream = client
  28                 .subscribe_receive(cli.account)
  29                 .map_err(|e| anyhow::anyhow!("JSON-RPC command failed: {:?}", e))?;
  30
  31             {
  32                 while let Some(v) = stream_next(timeout, &mut stream).await {
  33                     let v = v.map_err(|e| anyhow::anyhow!("JSON-RPC command failed: {:?}", e))?;
  34                     println!("{v}");
  35                 }
  36             }
  37             return Ok(());
  38         }
  39         cli::CliCommands::AddDevice { uri } => client.add_device(cli.account, uri).await,
  40         cli::CliCommands::Block {
  41             recipient,
  42             group_id,
  43         } => client.block(cli.account, recipient, group_id).await,
  44         cli::CliCommands::DeleteLocalAccountData { ignore_registered } => {
  45             client
  46                 .delete_local_account_data(cli.account, ignore_registered)
  47                 .await
  48         }
  49         cli::CliCommands::GetUserStatus { recipient } => {
  50             client.get_user_status(cli.account, recipient).await
  51         }
  52         cli::CliCommands::JoinGroup { uri } => client.join_group(cli.account, uri).await,
  53         cli::CliCommands::Link { name } => {
  54             let url = client
  55                 .start_link(cli.account)
  56                 .await
  57                 .map_err(|e| anyhow::anyhow!("JSON-RPC command startLink failed: {e:?}",))?
  58                 .device_link_uri;
  59             println!("{}", url);
  60             client.finish_link(url, name).await
  61         }
  62         cli::CliCommands::ListAccounts => client.list_accounts().await,
  63         cli::CliCommands::ListContacts {
  64             recipient,
  65             all_recipients,
  66             blocked,
  67             name,
  68         } => {
  69             client
  70                 .list_contacts(cli.account, recipient, all_recipients, blocked, name)
  71                 .await
  72         }
  73         cli::CliCommands::ListDevices => client.list_devices(cli.account).await,
  74         cli::CliCommands::ListGroups {
  75             detailed: _,
  76             group_id,
  77         } => client.list_groups(cli.account, group_id).await,
  78         cli::CliCommands::ListIdentities { number } => {
  79             client.list_identities(cli.account, number).await
  80         }
  81         cli::CliCommands::ListStickerPacks => client.list_sticker_packs(cli.account).await,
  82         cli::CliCommands::QuitGroup {
  83             group_id,
  84             delete,
  85             admin,
  86         } => {
  87             client
  88                 .quit_group(cli.account, group_id, delete, admin)
  89                 .await
  90         }
  91         cli::CliCommands::Register { voice, captcha } => {
  92             client.register(cli.account, voice, captcha).await
  93         }
  94         cli::CliCommands::RemoveContact { recipient, forget } => {
  95             client.remove_contact(cli.account, recipient, forget).await
  96         }
  97         cli::CliCommands::RemoveDevice { device_id } => {
  98             client.remove_device(cli.account, device_id).await
  99         }
 100         cli::CliCommands::RemovePin => client.remove_pin(cli.account).await,
 101         cli::CliCommands::RemoteDelete {
 102             target_timestamp,
 103             recipient,
 104             group_id,
 105             note_to_self,
 106         } => {
 107             client
 108                 .remote_delete(
 109                     cli.account,
 110                     target_timestamp,
 111                     recipient,
 112                     group_id,
 113                     note_to_self,
 114                 )
 115                 .await
 116         }
 117         cli::CliCommands::Send {
 118             recipient,
 119             group_id,
 120             note_to_self,
 121             end_session,
 122             message,
 123             attachment,
 124             mention,
 125             quote_timestamp,
 126             quote_author,
 127             quote_message,
 128             quote_mention,
 129             sticker,
 130         } => {
 131             client
 132                 .send(
 133                     cli.account,
 134                     recipient,
 135                     group_id,
 136                     note_to_self,
 137                     end_session,
 138                     message.unwrap_or_default(),
 139                     attachment,
 140                     mention,
 141                     quote_timestamp,
 142                     quote_author,
 143                     quote_message,
 144                     quote_mention,
 145                     sticker,
 146                 )
 147                 .await
 148         }
 149         cli::CliCommands::SendContacts => client.send_contacts(cli.account).await,
 150         cli::CliCommands::SendPaymentNotification {
 151             recipient,
 152             receipt,
 153             note,
 154         } => {
 155             client
 156                 .send_payment_notification(cli.account, recipient, receipt, note)
 157                 .await
 158         }
 159         cli::CliCommands::SendReaction {
 160             recipient,
 161             group_id,
 162             note_to_self,
 163             emoji,
 164             target_author,
 165             target_timestamp,
 166             remove,
 167         } => {
 168             client
 169                 .send_reaction(
 170                     cli.account,
 171                     recipient,
 172                     group_id,
 173                     note_to_self,
 174                     emoji,
 175                     target_author,
 176                     target_timestamp,
 177                     remove,
 178                 )
 179                 .await
 180         }
 181         cli::CliCommands::SendReceipt {
 182             recipient,
 183             target_timestamp,
 184             r#type,
 185         } => {
 186             client
 187                 .send_receipt(
 188                     cli.account,
 189                     recipient,
 190                     target_timestamp,
 191                     match r#type {
 192                         cli::ReceiptType::Read => "read".to_owned(),
 193                         cli::ReceiptType::Viewed => "viewed".to_owned(),
 194                     },
 195                 )
 196                 .await
 197         }
 198         cli::CliCommands::SendSyncRequest => client.send_sync_request(cli.account).await,
 199         cli::CliCommands::SendTyping {
 200             recipient,
 201             group_id,
 202             stop,
 203         } => {
 204             client
 205                 .send_typing(cli.account, recipient, group_id, stop)
 206                 .await
 207         }
 208         cli::CliCommands::SetPin { pin } => client.set_pin(cli.account, pin).await,
 209         cli::CliCommands::SubmitRateLimitChallenge { challenge, captcha } => {
 210             client
 211                 .submit_rate_limit_challenge(cli.account, challenge, captcha)
 212                 .await
 213         }
 214         cli::CliCommands::Trust {
 215             recipient,
 216             trust_all_known_keys,
 217             verified_safety_number,
 218         } => {
 219             client
 220                 .trust(
 221                     cli.account,
 222                     recipient,
 223                     trust_all_known_keys,
 224                     verified_safety_number,
 225                 )
 226                 .await
 227         }
 228         cli::CliCommands::Unblock {
 229             recipient,
 230             group_id,
 231         } => client.unblock(cli.account, recipient, group_id).await,
 232         cli::CliCommands::Unregister { delete_account } => {
 233             client.unregister(cli.account, delete_account).await
 234         }
 235         cli::CliCommands::UpdateAccount { device_name } => {
 236             client.update_account(cli.account, device_name).await
 237         }
 238         cli::CliCommands::UpdateConfiguration {
 239             read_receipts,
 240             unidentified_delivery_indicators,
 241             typing_indicators,
 242             link_previews,
 243         } => {
 244             client
 245                 .update_configuration(
 246                     cli.account,
 247                     read_receipts,
 248                     unidentified_delivery_indicators,
 249                     typing_indicators,
 250                     link_previews,
 251                 )
 252                 .await
 253         }
 254         cli::CliCommands::UpdateContact {
 255             recipient,
 256             expiration,
 257             name,
 258         } => {
 259             client
 260                 .update_contact(cli.account, recipient, name, expiration)
 261                 .await
 262         }
 263         cli::CliCommands::UpdateGroup {
 264             group_id,
 265             name,
 266             description,
 267             avatar,
 268             member,
 269             remove_member,
 270             admin,
 271             remove_admin,
 272             ban,
 273             unban,
 274             reset_link,
 275             link,
 276             set_permission_add_member,
 277             set_permission_edit_details,
 278             set_permission_send_messages,
 279             expiration,
 280         } => {
 281             client
 282                 .update_group(
 283                     cli.account,
 284                     group_id,
 285                     name,
 286                     description,
 287                     avatar,
 288                     member,
 289                     remove_member,
 290                     admin,
 291                     remove_admin,
 292                     ban,
 293                     unban,
 294                     reset_link,
 295                     link.map(|link| match link {
 296                         LinkState::Enabled => "enabled".to_owned(),
 297                         LinkState::EnabledWithApproval => "enabledWithApproval".to_owned(),
 298                         LinkState::Disabled => "disabled".to_owned(),
 299                     }),
 300                     set_permission_add_member.map(|p| match p {
 301                         GroupPermission::EveryMember => "everyMember".to_owned(),
 302                         GroupPermission::OnlyAdmins => "onlyAdmins".to_owned(),
 303                     }),
 304                     set_permission_edit_details.map(|p| match p {
 305                         GroupPermission::EveryMember => "everyMember".to_owned(),
 306                         GroupPermission::OnlyAdmins => "onlyAdmins".to_owned(),
 307                     }),
 308                     set_permission_send_messages.map(|p| match p {
 309                         GroupPermission::EveryMember => "everyMember".to_owned(),
 310                         GroupPermission::OnlyAdmins => "onlyAdmins".to_owned(),
 311                     }),
 312                     expiration,
 313                 )
 314                 .await
 315         }
 316         cli::CliCommands::UpdateProfile {
 317             given_name,
 318             family_name,
 319             about,
 320             about_emoji,
 321             mobile_coin_address,
 322             avatar,
 323             remove_avatar,
 324         } => {
 325             client
 326                 .update_profile(
 327                     cli.account,
 328                     given_name,
 329                     family_name,
 330                     about,
 331                     about_emoji,
 332                     mobile_coin_address,
 333                     avatar,
 334                     remove_avatar,
 335                 )
 336                 .await
 337         }
 338         cli::CliCommands::UploadStickerPack { path } => {
 339             client.upload_sticker_pack(cli.account, path).await
 340         }
 341         cli::CliCommands::Verify {
 342             verification_code,
 343             pin,
 344         } => client.verify(cli.account, verification_code, pin).await,
 345         cli::CliCommands::Version => client.version().await,
 346     };
 347
 348     result
 349         .map(|v| println!("{v}"))
 350         .map_err(|e| anyhow::anyhow!("JSON-RPC command failed: {e:?}",))?;
 351     Ok(())
 352 }
 353
 354 async fn connect(cli: &cli::Cli) -> Result<jsonrpc::SignalCliClient, RpcError> {
 355     if let Some(tcp) = cli.json_rpc_tcp {
 356         let socket_addr = tcp.unwrap_or_else(|| DEFAULT_TCP.parse().unwrap());
 357         jsonrpc::connect_tcp(socket_addr).await
 358     } else {
 359         let socket_path = cli
 360             .json_rpc_socket
 361             .clone()
 362             .unwrap_or(None)
 363             .or_else(|| {
 364                 std::env::var_os("XDG_RUNTIME_DIR").map(|runtime_dir| {
 365                     PathBuf::from(runtime_dir)
 366                         .join(DEFAULT_SOCKET_SUFFIX)
 367                         .into()
 368                 })
 369             })
 370             .unwrap_or_else(|| ("/run".to_owned() + DEFAULT_SOCKET_SUFFIX).into());
 371         jsonrpc::connect_unix(socket_path).await
 372     }
 373 }
 374
 375 async fn stream_next(
 376     timeout: f64,
 377     stream: &mut TypedSubscriptionStream<Value>,
 378 ) -> Option<Result<Value, RpcError>> {
 379     if timeout < 0.0 {
 380         stream.next().await
 381     } else {
 382         select! {
 383             v = stream.next() => v,
 384             _= sleep(Duration::from_millis((timeout * 1000.0) as u64)) => None,
 385         }
 386     }
 387 }