Compare commits
16 Commits
| Author | SHA1 | Date |
|---|---|---|
 Travis Burtrum
|
5b36300054 | |
|
Travis Burtrum
|
7aff2080df | |
|
Travis Burtrum
|
294da89d22 | |
|
Travis Burtrum
|
f1aae8e3c2 | |
|
Travis Burtrum
|
c8ce4bb629 | |
Maxime “pep” Buquet
|
3b36852749 | |
|
Maxime “pep” Buquet
|
06ecb97f4c | |
|
pteromys
|
b643665354 | |
|
Travis Burtrum
|
d2ee6168fb | |
|
Travis Burtrum
|
062571c3a4 | |
|
Travis Burtrum
|
b86c277c8b | |
|
Travis Burtrum
|
209a0ae2a3 | |
|
Travis Burtrum
|
d12a548793 | |
|
Travis Burtrum
|
5a71229c50 | |
|
Travis Burtrum
|
37b5efd4b6 | |
|
Travis Burtrum
|
12ea8c5531 |
|
|
@ -0,0 +1,46 @@
|
|||
properties(
|
||||
[
|
||||
disableConcurrentBuilds()
|
||||
]
|
||||
)
|
||||
|
||||
node('linux && docker') {
|
||||
try {
|
||||
stage('Checkout') {
|
||||
//branch name from Jenkins environment variables
|
||||
echo "My branch is: ${env.BRANCH_NAME}"
|
||||
|
||||
// this doesn't grab tags pointing to this branch
|
||||
//checkout scm
|
||||
// this hack does... https://issues.jenkins.io/browse/JENKINS-45164
|
||||
checkout([
|
||||
$class: 'GitSCM',
|
||||
branches: [[name: 'refs/heads/'+env.BRANCH_NAME]],
|
||||
extensions: [[$class: 'CloneOption', noTags: false, shallow: false, depth: 0, reference: '']],
|
||||
userRemoteConfigs: scm.userRemoteConfigs,
|
||||
])
|
||||
sh '''
|
||||
set -euxo pipefail
|
||||
git checkout "$BRANCH_NAME" --
|
||||
git reset --hard "origin/$BRANCH_NAME"
|
||||
'''
|
||||
}
|
||||
|
||||
stage('Build + Deploy') {
|
||||
sh '''
|
||||
mkdir -p release
|
||||
cp sendxmpp.toml release
|
||||
curl --compressed -sL https://code.moparisthebest.com/moparisthebest/self-ci/raw/branch/master/build-ci.sh | bash
|
||||
'''
|
||||
}
|
||||
|
||||
currentBuild.result = 'SUCCESS'
|
||||
} catch (Exception err) {
|
||||
currentBuild.result = 'FAILURE'
|
||||
} finally {
|
||||
stage('Email') {
|
||||
step([$class: 'Mailer', notifyEveryUnstableBuild: true, recipients: 'admin.jenkins@moparisthebest.com', sendToIndividuals: true])
|
||||
}
|
||||
deleteDir()
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,24 @@
|
|||
#!/bin/bash
|
||||
set -exo pipefail
|
||||
|
||||
echo "starting build for TARGET $TARGET"
|
||||
|
||||
export CRATE_NAME=sendxmpp
|
||||
|
||||
SUFFIX=""
|
||||
|
||||
echo "$TARGET" | grep -E '^x86_64-pc-windows-gnu$' >/dev/null && SUFFIX=".exe"
|
||||
|
||||
# build binary
|
||||
cross build --target $TARGET --release
|
||||
|
||||
# to check how they are built
|
||||
file "target/$TARGET/release/${CRATE_NAME}$SUFFIX"
|
||||
|
||||
# if this commit has a tag, upload artifact to release
|
||||
strip "target/$TARGET/release/${CRATE_NAME}$SUFFIX" || true # if strip fails, it's fine
|
||||
mkdir -p release
|
||||
cp "target/$TARGET/release/${CRATE_NAME}$SUFFIX" "release/${CRATE_NAME}-$TARGET$SUFFIX"
|
||||
|
||||
echo 'build success!'
|
||||
exit 0
|
||||
|
|
@ -0,0 +1 @@
|
|||
max_width = 200
|
||||
File diff suppressed because it is too large
Load Diff
33
Cargo.toml
33
Cargo.toml
|
|
@ -1,25 +1,34 @@
|
|||
[package]
|
||||
name = "sendxmpp"
|
||||
version = "0.1.0"
|
||||
version = "3.0.1"
|
||||
authors = ["moparisthebest <admin@moparisthebest.com>"]
|
||||
|
||||
description = "Send XMPP messages from the command line."
|
||||
repository = "https://code.moparisthebest.com/moparisthebest/sendxmpp-rs"
|
||||
keywords = ["xmpp"]
|
||||
|
||||
license = "GPL-3.0+"
|
||||
license = "AGPL-3.0-or-later"
|
||||
readme = "README.md"
|
||||
|
||||
edition = "2018"
|
||||
|
||||
include = [
|
||||
"**/*.rs",
|
||||
"Cargo.toml",
|
||||
"*.md",
|
||||
"sendxmpp.toml",
|
||||
]
|
||||
|
||||
[dependencies]
|
||||
toml = "0.4.10"
|
||||
serde_derive = "1.0.85"
|
||||
serde = "1.0.85"
|
||||
gumdrop = "0.5.0"
|
||||
gumdrop_derive = "0.5.0"
|
||||
dirs = "1.0.4"
|
||||
tokio-xmpp = "0.2.3"
|
||||
futures = "0.1"
|
||||
tokio = "0.1"
|
||||
xmpp-parsers = "0.12.2"
|
||||
toml = "0.5"
|
||||
serde_derive = "1.0"
|
||||
serde = { version = "1.0", features = ["derive"] }
|
||||
gumdrop = "0.8.0"
|
||||
gumdrop_derive = "0.8.0"
|
||||
dirs = "4.0.0"
|
||||
tokio-xmpp = { version = "3.2.0", default-features = false, features = ["tls-rust"] }
|
||||
tokio = { version = "1", features = ["net", "rt", "rt-multi-thread", "macros", "io-util", "io-std"] }
|
||||
xmpp-parsers = "0.19"
|
||||
die = "0.2.0"
|
||||
anyhow = "1.0"
|
||||
env_logger = "0.9"
|
||||
|
|
|
|||
171
LICENSE.md
171
LICENSE.md
|
|
@ -1,26 +1,24 @@
|
|||
### GNU GENERAL PUBLIC LICENSE
|
||||
### GNU AFFERO GENERAL PUBLIC LICENSE
|
||||
|
||||
Version 3, 29 June 2007
|
||||
Version 3, 19 November 2007
|
||||
|
||||
Copyright (C) 2007 Free Software Foundation, Inc.
|
||||
<http://fsf.org/>
|
||||
<https://fsf.org/>
|
||||
|
||||
Everyone is permitted to copy and distribute verbatim copies of this
|
||||
license document, but changing it is not allowed.
|
||||
|
||||
### Preamble
|
||||
|
||||
The GNU General Public License is a free, copyleft license for
|
||||
software and other kinds of works.
|
||||
The GNU Affero General Public License is a free, copyleft license for
|
||||
software and other kinds of works, specifically designed to ensure
|
||||
cooperation with the community in the case of network server software.
|
||||
|
||||
The licenses for most software and other practical works are designed
|
||||
to take away your freedom to share and change the works. By contrast,
|
||||
the GNU General Public License is intended to guarantee your freedom
|
||||
to share and change all versions of a program--to make sure it remains
|
||||
free software for all its users. We, the Free Software Foundation, use
|
||||
the GNU General Public License for most of our software; it applies
|
||||
also to any other work released this way by its authors. You can apply
|
||||
it to your programs, too.
|
||||
our General Public Licenses are intended to guarantee your freedom to
|
||||
share and change all versions of a program--to make sure it remains
|
||||
free software for all its users.
|
||||
|
||||
When we speak of free software, we are referring to freedom, not
|
||||
price. Our General Public Licenses are designed to make sure that you
|
||||
|
|
@ -29,46 +27,34 @@ them if you wish), that you receive source code or can get it if you
|
|||
want it, that you can change the software or use pieces of it in new
|
||||
free programs, and that you know you can do these things.
|
||||
|
||||
To protect your rights, we need to prevent others from denying you
|
||||
these rights or asking you to surrender the rights. Therefore, you
|
||||
have certain responsibilities if you distribute copies of the
|
||||
software, or if you modify it: responsibilities to respect the freedom
|
||||
of others.
|
||||
Developers that use our General Public Licenses protect your rights
|
||||
with two steps: (1) assert copyright on the software, and (2) offer
|
||||
you this License which gives you legal permission to copy, distribute
|
||||
and/or modify the software.
|
||||
|
||||
For example, if you distribute copies of such a program, whether
|
||||
gratis or for a fee, you must pass on to the recipients the same
|
||||
freedoms that you received. You must make sure that they, too, receive
|
||||
or can get the source code. And you must show them these terms so they
|
||||
know their rights.
|
||||
A secondary benefit of defending all users' freedom is that
|
||||
improvements made in alternate versions of the program, if they
|
||||
receive widespread use, become available for other developers to
|
||||
incorporate. Many developers of free software are heartened and
|
||||
encouraged by the resulting cooperation. However, in the case of
|
||||
software used on network servers, this result may fail to come about.
|
||||
The GNU General Public License permits making a modified version and
|
||||
letting the public access it on a server without ever releasing its
|
||||
source code to the public.
|
||||
|
||||
Developers that use the GNU GPL protect your rights with two steps:
|
||||
(1) assert copyright on the software, and (2) offer you this License
|
||||
giving you legal permission to copy, distribute and/or modify it.
|
||||
The GNU Affero General Public License is designed specifically to
|
||||
ensure that, in such cases, the modified source code becomes available
|
||||
to the community. It requires the operator of a network server to
|
||||
provide the source code of the modified version running there to the
|
||||
users of that server. Therefore, public use of a modified version, on
|
||||
a publicly accessible server, gives the public access to the source
|
||||
code of the modified version.
|
||||
|
||||
For the developers' and authors' protection, the GPL clearly explains
|
||||
that there is no warranty for this free software. For both users' and
|
||||
authors' sake, the GPL requires that modified versions be marked as
|
||||
changed, so that their problems will not be attributed erroneously to
|
||||
authors of previous versions.
|
||||
|
||||
Some devices are designed to deny users access to install or run
|
||||
modified versions of the software inside them, although the
|
||||
manufacturer can do so. This is fundamentally incompatible with the
|
||||
aim of protecting users' freedom to change the software. The
|
||||
systematic pattern of such abuse occurs in the area of products for
|
||||
individuals to use, which is precisely where it is most unacceptable.
|
||||
Therefore, we have designed this version of the GPL to prohibit the
|
||||
practice for those products. If such problems arise substantially in
|
||||
other domains, we stand ready to extend this provision to those
|
||||
domains in future versions of the GPL, as needed to protect the
|
||||
freedom of users.
|
||||
|
||||
Finally, every program is threatened constantly by software patents.
|
||||
States should not allow patents to restrict development and use of
|
||||
software on general-purpose computers, but in those that do, we wish
|
||||
to avoid the special danger that patents applied to a free program
|
||||
could make it effectively proprietary. To prevent this, the GPL
|
||||
assures that patents cannot be used to render the program non-free.
|
||||
An older license, called the Affero General Public License and
|
||||
published by Affero, was designed to accomplish similar goals. This is
|
||||
a different license, not a version of the Affero GPL, but Affero has
|
||||
released a new version of the Affero GPL which permits relicensing
|
||||
under this license.
|
||||
|
||||
The precise terms and conditions for copying, distribution and
|
||||
modification follow.
|
||||
|
|
@ -77,7 +63,8 @@ modification follow.
|
|||
|
||||
#### 0. Definitions.
|
||||
|
||||
"This License" refers to version 3 of the GNU General Public License.
|
||||
"This License" refers to version 3 of the GNU Affero General Public
|
||||
License.
|
||||
|
||||
"Copyright" also means copyright-like laws that apply to other kinds
|
||||
of works, such as semiconductor masks.
|
||||
|
|
@ -546,37 +533,47 @@ from those to whom you convey the Program, the only way you could
|
|||
satisfy both those terms and this License would be to refrain entirely
|
||||
from conveying the Program.
|
||||
|
||||
#### 13. Use with the GNU Affero General Public License.
|
||||
#### 13. Remote Network Interaction; Use with the GNU General Public License.
|
||||
|
||||
Notwithstanding any other provision of this License, if you modify the
|
||||
Program, your modified version must prominently offer all users
|
||||
interacting with it remotely through a computer network (if your
|
||||
version supports such interaction) an opportunity to receive the
|
||||
Corresponding Source of your version by providing access to the
|
||||
Corresponding Source from a network server at no charge, through some
|
||||
standard or customary means of facilitating copying of software. This
|
||||
Corresponding Source shall include the Corresponding Source for any
|
||||
work covered by version 3 of the GNU General Public License that is
|
||||
incorporated pursuant to the following paragraph.
|
||||
|
||||
Notwithstanding any other provision of this License, you have
|
||||
permission to link or combine any covered work with a work licensed
|
||||
under version 3 of the GNU Affero General Public License into a single
|
||||
under version 3 of the GNU General Public License into a single
|
||||
combined work, and to convey the resulting work. The terms of this
|
||||
License will continue to apply to the part which is the covered work,
|
||||
but the special requirements of the GNU Affero General Public License,
|
||||
section 13, concerning interaction through a network will apply to the
|
||||
combination as such.
|
||||
but the work with which it is combined will remain governed by version
|
||||
3 of the GNU General Public License.
|
||||
|
||||
#### 14. Revised Versions of this License.
|
||||
|
||||
The Free Software Foundation may publish revised and/or new versions
|
||||
of the GNU General Public License from time to time. Such new versions
|
||||
will be similar in spirit to the present version, but may differ in
|
||||
detail to address new problems or concerns.
|
||||
of the GNU Affero General Public License from time to time. Such new
|
||||
versions will be similar in spirit to the present version, but may
|
||||
differ in detail to address new problems or concerns.
|
||||
|
||||
Each version is given a distinguishing version number. If the Program
|
||||
specifies that a certain numbered version of the GNU General Public
|
||||
License "or any later version" applies to it, you have the option of
|
||||
following the terms and conditions either of that numbered version or
|
||||
of any later version published by the Free Software Foundation. If the
|
||||
Program does not specify a version number of the GNU General Public
|
||||
License, you may choose any version ever published by the Free
|
||||
Software Foundation.
|
||||
specifies that a certain numbered version of the GNU Affero General
|
||||
Public License "or any later version" applies to it, you have the
|
||||
option of following the terms and conditions either of that numbered
|
||||
version or of any later version published by the Free Software
|
||||
Foundation. If the Program does not specify a version number of the
|
||||
GNU Affero General Public License, you may choose any version ever
|
||||
published by the Free Software Foundation.
|
||||
|
||||
If the Program specifies that a proxy can decide which future versions
|
||||
of the GNU General Public License can be used, that proxy's public
|
||||
statement of acceptance of a version permanently authorizes you to
|
||||
choose that version for the Program.
|
||||
of the GNU Affero General Public License can be used, that proxy's
|
||||
public statement of acceptance of a version permanently authorizes you
|
||||
to choose that version for the Program.
|
||||
|
||||
Later license versions may give you additional or different
|
||||
permissions. However, no additional obligations are imposed on any
|
||||
|
|
@ -634,42 +631,30 @@ the exclusion of warranty; and each file should have at least the
|
|||
Copyright (C) <year> <name of author>
|
||||
|
||||
This program is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
it under the terms of the GNU Affero General Public License as
|
||||
published by the Free Software Foundation, either version 3 of the
|
||||
License, or (at your option) any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
GNU Affero General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
You should have received a copy of the GNU Affero General Public License
|
||||
along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
|
||||
Also add information on how to contact you by electronic and paper
|
||||
mail.
|
||||
|
||||
If the program does terminal interaction, make it output a short
|
||||
notice like this when it starts in an interactive mode:
|
||||
|
||||
<program> Copyright (C) <year> <name of author>
|
||||
This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
|
||||
This is free software, and you are welcome to redistribute it
|
||||
under certain conditions; type `show c' for details.
|
||||
|
||||
The hypothetical commands \`show w' and \`show c' should show the
|
||||
appropriate parts of the General Public License. Of course, your
|
||||
program's commands might be different; for a GUI interface, you would
|
||||
use an "about box".
|
||||
If your software can interact with users remotely through a computer
|
||||
network, you should also make sure that it provides a way for users to
|
||||
get its source. For example, if your program is a web application, its
|
||||
interface could display a "Source" link that leads users to an archive
|
||||
of the code. There are many ways you could offer source, and different
|
||||
solutions will be better for different programs; see section 13 for
|
||||
the specific requirements.
|
||||
|
||||
You should also get your employer (if you work as a programmer) or
|
||||
school, if any, to sign a "copyright disclaimer" for the program, if
|
||||
necessary. For more information on this, and how to apply and follow
|
||||
the GNU GPL, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
The GNU General Public License does not permit incorporating your
|
||||
program into proprietary programs. If your program is a subroutine
|
||||
library, you may consider it more useful to permit linking proprietary
|
||||
applications with the library. If this is what you want to do, use the
|
||||
GNU Lesser General Public License instead of this License. But first,
|
||||
please read <http://www.gnu.org/philosophy/why-not-lgpl.html>.
|
||||
the GNU AGPL, see <https://www.gnu.org/licenses/>.
|
||||
|
|
|
|||
23
README.md
23
README.md
|
|
@ -2,11 +2,28 @@
|
|||
|
||||
`sendxmpp` is the XMPP equivalent of sendmail. It is an alternative to the old sendxmpp written in Perl, or the newer [sendxmpp-py](https://github.com/moparisthebest/sendxmpp-py).
|
||||
|
||||
Installation:
|
||||
`cargo install`
|
||||
Installation:
|
||||
`cargo install sendxmpp`
|
||||
|
||||
Configuration: `cp sendxmpp.toml ~/.config/` and edit `~/.config/sendxmpp.toml` with your XMPP credentials
|
||||
|
||||
```
|
||||
Usage: sendxmpp [OPTIONS] [ARGUMENTS]
|
||||
|
||||
Positional arguments:
|
||||
recipients
|
||||
|
||||
Optional arguments:
|
||||
-h, --help show this help message and exit
|
||||
-c, --config CONFIG path to config file. default: ~/.config/sendxmpp.toml with fallback to /etc/sendxmpp/sendxmpp.toml
|
||||
-e, --force-pgp Force OpenPGP encryption for all recipients
|
||||
-a, --attempt-pgp Attempt OpenPGP encryption for all recipients
|
||||
-r, --raw Send raw XML stream, cannot be used with recipients or PGP
|
||||
-p, --presence Send a <presence/> after connecting before sending messages, required for receiving for --raw
|
||||
-m, --muc Recipients are Multi-User Chats
|
||||
-n, --nick NICK Nickname to use in Multi-User Chats
|
||||
```
|
||||
|
||||
Usage examples:
|
||||
|
||||
- `echo "This is a test" | sendxmpp user@host`
|
||||
|
|
@ -14,4 +31,4 @@ Usage examples:
|
|||
|
||||
License
|
||||
-------
|
||||
GNU/GPLv3 - Check LICENSE.md for details
|
||||
GNU/AGPLv3 - Check LICENSE.md for details
|
||||
|
|
|
|||
|
|
@ -1,4 +1,5 @@
|
|||
# jid and password exactly like this, nothing else
|
||||
# jid and password exactly like this
|
||||
|
||||
jid = "jid@example.org"
|
||||
password = "sOmePa55W0rD"
|
||||
# nick = "foobar" # optional nick for Multi-User Chat
|
||||
|
|
|
|||
314
src/main.rs
314
src/main.rs
|
|
@ -1,40 +1,37 @@
|
|||
use std::env::args;
|
||||
use std::fs::File;
|
||||
use std::io::{stdin, Read};
|
||||
use std::io::{stdin, Read, Write};
|
||||
use std::iter::Iterator;
|
||||
use std::path::Path;
|
||||
use std::thread;
|
||||
use std::time::Duration;
|
||||
use std::str::FromStr;
|
||||
|
||||
use die::{die, Die};
|
||||
use gumdrop::Options;
|
||||
use serde_derive::Deserialize;
|
||||
|
||||
use futures::{future, Sink, Stream};
|
||||
use tokio::runtime::current_thread::Runtime;
|
||||
use tokio_xmpp::Client;
|
||||
use xmpp_parsers::message::{Body, Message};
|
||||
use xmpp_parsers::{Element, Jid};
|
||||
use std::process::{Command, Stdio};
|
||||
use tokio_xmpp::{SimpleClient as Client};
|
||||
use xmpp_parsers::message::{Body, Message, MessageType};
|
||||
use xmpp_parsers::muc::Muc;
|
||||
use xmpp_parsers::presence::{Presence, Show as PresenceShow, Type as PresenceType};
|
||||
use xmpp_parsers::{BareJid, Element, FullJid, Jid};
|
||||
|
||||
use tokio::io::{AsyncReadExt, AsyncWriteExt};
|
||||
|
||||
use anyhow::{anyhow, bail, Result};
|
||||
|
||||
#[derive(Deserialize)]
|
||||
struct Config {
|
||||
jid: String,
|
||||
password: String,
|
||||
nick: Option<String>,
|
||||
}
|
||||
|
||||
fn parse_cfg<P: AsRef<Path>>(path: P) -> Option<Config> {
|
||||
match File::open(path) {
|
||||
Ok(mut f) => {
|
||||
let mut input = String::new();
|
||||
match f.read_to_string(&mut input) {
|
||||
Ok(_) => match toml::from_str(&input) {
|
||||
Ok(toml) => Some(toml),
|
||||
Err(_) => None,
|
||||
},
|
||||
Err(_) => None,
|
||||
}
|
||||
}
|
||||
Err(_) => None,
|
||||
}
|
||||
fn parse_cfg<P: AsRef<Path>>(path: P) -> Result<Config> {
|
||||
let mut f = File::open(path)?;
|
||||
let mut input = String::new();
|
||||
f.read_to_string(&mut input)?;
|
||||
Ok(toml::from_str(&input)?)
|
||||
}
|
||||
|
||||
#[derive(Default, Options)]
|
||||
|
|
@ -45,9 +42,7 @@ struct MyOptions {
|
|||
#[options(help = "show this help message and exit")]
|
||||
help: bool,
|
||||
|
||||
#[options(
|
||||
help = "path to config file. default: ~/.config/sendxmpp.toml with fallback to /etc/sendxmpp/sendxmpp.toml"
|
||||
)]
|
||||
#[options(help = "path to config file. default: ~/.config/sendxmpp.toml with fallback to /etc/sendxmpp/sendxmpp.toml")]
|
||||
config: Option<String>,
|
||||
|
||||
#[options(help = "Force OpenPGP encryption for all recipients", short = "e")]
|
||||
|
|
@ -55,101 +50,236 @@ struct MyOptions {
|
|||
|
||||
#[options(help = "Attempt OpenPGP encryption for all recipients")]
|
||||
attempt_pgp: bool,
|
||||
|
||||
#[options(help = "Send raw XML stream, cannot be used with recipients or PGP")]
|
||||
raw: bool,
|
||||
|
||||
#[options(help = "Send a <presence/> after connecting before sending messages, required for receiving for --raw")]
|
||||
presence: bool,
|
||||
|
||||
#[options(help = "Recipients are Multi-User Chats")]
|
||||
muc: bool,
|
||||
|
||||
#[options(help = "Nickname to use in Multi-User Chats")]
|
||||
nick: Option<String>,
|
||||
}
|
||||
|
||||
fn main() {
|
||||
#[tokio::main]
|
||||
async fn main() {
|
||||
env_logger::init();
|
||||
|
||||
let args: Vec<String> = args().collect();
|
||||
|
||||
// Remember to skip the first argument. That's the program name.
|
||||
let opts = match MyOptions::parse_args_default(&args[1..]) {
|
||||
Ok(opts) => opts,
|
||||
Err(e) => {
|
||||
println!("{}: {}", args[0], e);
|
||||
println!("Usage: {} [OPTIONS] [ARGUMENTS]", args[0]);
|
||||
println!();
|
||||
println!("{}", MyOptions::usage());
|
||||
return;
|
||||
}
|
||||
Err(e) => die!("{}: {}\nUsage: {} [OPTIONS] [ARGUMENTS]\n\n{}", args[0], e, args[0], MyOptions::usage()),
|
||||
};
|
||||
|
||||
if opts.help {
|
||||
println!("Usage: {} [OPTIONS] [ARGUMENTS]", args[0]);
|
||||
println!();
|
||||
println!("{}", MyOptions::usage());
|
||||
return;
|
||||
die!("Usage: {} [OPTIONS] [ARGUMENTS]\n\n{}", args[0], MyOptions::usage());
|
||||
}
|
||||
|
||||
let recipients: Vec<Jid> = opts.recipients.iter().map(|s| s.parse::<Jid>().die("invalid recipient jid")).collect();
|
||||
|
||||
if opts.raw {
|
||||
if opts.force_pgp || opts.attempt_pgp {
|
||||
die!("--raw is incompatible with --force-pgp and --attempt-pgp");
|
||||
}
|
||||
if !recipients.is_empty() {
|
||||
die!("--raw is incompatible with recipients");
|
||||
}
|
||||
if opts.muc {
|
||||
die!("--raw is incompatible with --muc");
|
||||
}
|
||||
} else if recipients.is_empty() {
|
||||
die!("no recipients specified!");
|
||||
}
|
||||
|
||||
if opts.muc {
|
||||
if opts.force_pgp || opts.attempt_pgp {
|
||||
die!("--force-pgp and --attempt-pgp isn't implemented with --muc");
|
||||
}
|
||||
}
|
||||
|
||||
let recipients: Vec<Jid> = opts
|
||||
.recipients
|
||||
.iter()
|
||||
.map(|s| s.parse::<Jid>().expect("invalid recipient jid"))
|
||||
.collect();
|
||||
let recipients = &recipients;
|
||||
|
||||
let cfg = match opts.config {
|
||||
Some(config) => parse_cfg(&config).expect("provided config cannot be found/parsed"),
|
||||
None => parse_cfg(
|
||||
dirs::config_dir()
|
||||
.expect("cannot find home directory")
|
||||
.join("sendxmpp.toml"),
|
||||
)
|
||||
.or_else(|| parse_cfg("/etc/sendxmpp/sendxmpp.toml"))
|
||||
.expect("valid config file not found"),
|
||||
Some(config) => parse_cfg(&config).die("provided config cannot be found/parsed"),
|
||||
None => parse_cfg(dirs::config_dir().die("cannot find home directory").join("sendxmpp.toml"))
|
||||
.or_else(|_| parse_cfg("/etc/sendxmpp/sendxmpp.toml"))
|
||||
.die("valid config file not found"),
|
||||
};
|
||||
|
||||
let mut data = String::new();
|
||||
stdin()
|
||||
.read_to_string(&mut data)
|
||||
.expect("error reading from stdin");
|
||||
let data = data.trim();
|
||||
if opts.raw {
|
||||
let mut client = Client::new(&cfg.jid, &cfg.password).await.die("could not connect to xmpp server");
|
||||
|
||||
// tokio_core context
|
||||
let mut rt = Runtime::new().unwrap();
|
||||
// Client instance
|
||||
let client = Client::new(&cfg.jid, &cfg.password).expect("could not connect to xmpp server");
|
||||
if opts.presence {
|
||||
client.send_stanza(make_presence()).await.die("could not send presence");
|
||||
}
|
||||
|
||||
// Make the two interfaces for sending and receiving independent
|
||||
// of each other so we can move one into a closure.
|
||||
let (mut sink, stream) = client.split();
|
||||
// Wrap sink in Option so that we can take() it for the send(self)
|
||||
// to consume and return it back when ready.
|
||||
let mut send = move |stanza| {
|
||||
sink.start_send(stanza).expect("start_send");
|
||||
};
|
||||
// Main loop, processes events
|
||||
let done = stream.for_each(|event| {
|
||||
if event.is_online() {
|
||||
for recipient in recipients {
|
||||
let reply = make_reply(recipient.clone(), &data);
|
||||
send(reply);
|
||||
// can paste this to test: <message xmlns="jabber:client" to="travis@burtrum.org" type="chat"><body>woot</body></message>
|
||||
|
||||
let mut open_client = client.into_inner().into_inner();
|
||||
|
||||
let mut rd_buf = [0u8; 256]; // todo: proper buffer size?
|
||||
let mut stdin_buf = rd_buf.clone();
|
||||
|
||||
let mut stdin = tokio::io::stdin();
|
||||
let mut stdout = tokio::io::stdout();
|
||||
loop {
|
||||
tokio::select! {
|
||||
n = open_client.read(&mut rd_buf) => {
|
||||
let n = n.unwrap_or(0);
|
||||
if n == 0 {
|
||||
break;
|
||||
}
|
||||
stdout.write_all(&rd_buf[0..n]).await.die("could not send bytes");
|
||||
stdout.flush().await.die("could not flush");
|
||||
},
|
||||
n = stdin.read(&mut stdin_buf) => {
|
||||
let n = n.unwrap_or(0);
|
||||
if n == 0 {
|
||||
break;
|
||||
}
|
||||
open_client.write_all(&stdin_buf[0..n]).await.die("could not send bytes");
|
||||
open_client.flush().await.die("could not flush");
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
Box::new(future::ok(()))
|
||||
});
|
||||
|
||||
thread::spawn(|| {
|
||||
thread::sleep(Duration::from_millis(4000));
|
||||
std::process::exit(0);
|
||||
});
|
||||
|
||||
// Start polling `done`
|
||||
match rt.block_on(done) {
|
||||
Ok(_) => {
|
||||
println!("successful exiting");
|
||||
std::process::exit(0);
|
||||
//()
|
||||
// Close client connection, ignoring errors
|
||||
open_client.write_all("</stream:stream>".as_bytes()).await.ok();
|
||||
open_client.flush().await.ok();
|
||||
open_client.read(&mut rd_buf).await.ok();
|
||||
} else {
|
||||
let mut data = String::new();
|
||||
stdin().lock().read_to_string(&mut data).die("error reading from stdin");
|
||||
let data = data.trim();
|
||||
if data.is_empty() {
|
||||
// don't send empty stanzas
|
||||
return;
|
||||
}
|
||||
Err(e) => {
|
||||
println!("Fatal: {}", e);
|
||||
()
|
||||
|
||||
let mut client = Client::new(&cfg.jid, &cfg.password).await.die("could not connect to xmpp server");
|
||||
|
||||
if opts.presence {
|
||||
client.send_stanza(make_presence()).await.die("could not send presence");
|
||||
}
|
||||
};
|
||||
|
||||
for recipient in recipients {
|
||||
if opts.muc {
|
||||
let nick = opts
|
||||
.nick
|
||||
.clone()
|
||||
.or(cfg.nick.clone())
|
||||
.or_else(|| BareJid::from_str(cfg.jid.as_str()).unwrap().node)
|
||||
.die("couldn't find a nick to use");
|
||||
let participant = match recipient.clone() {
|
||||
Jid::Full(_) => die!("Invalid room address"),
|
||||
Jid::Bare(bare) => bare.with_resource(nick.clone()),
|
||||
};
|
||||
let join = make_join(participant.clone());
|
||||
client.send_stanza(join).await.die("failed to join MUC");
|
||||
|
||||
let reply = make_reply(recipient.clone(), &data, opts.muc);
|
||||
client.send_stanza(reply).await.die("sending message failed");
|
||||
} else {
|
||||
let reply = if opts.force_pgp || opts.attempt_pgp {
|
||||
let encrypted = gpg_encrypt(recipient.clone(), &data);
|
||||
if encrypted.is_err() {
|
||||
if opts.force_pgp {
|
||||
die!("pgp encryption to jid '{}' failed!", recipient);
|
||||
} else {
|
||||
make_reply(recipient.clone(), &data, opts.muc)
|
||||
}
|
||||
} else {
|
||||
let encrypted = encrypted.unwrap();
|
||||
let encrypted = encrypted.trim();
|
||||
let mut reply = make_reply(recipient.clone(), "pgp", opts.muc);
|
||||
let mut x = Element::bare("x", "jabber:x:encrypted");
|
||||
x.append_text_node(encrypted);
|
||||
reply.append_child(x);
|
||||
reply
|
||||
}
|
||||
} else {
|
||||
make_reply(recipient.clone(), &data, opts.muc)
|
||||
};
|
||||
client.send_stanza(reply).await.die("sending message failed");
|
||||
}
|
||||
}
|
||||
|
||||
// Close client connection
|
||||
client.end().await.ok(); // ignore errors here, I guess
|
||||
}
|
||||
}
|
||||
|
||||
// Construct a <presence/>
|
||||
fn make_presence() -> Element {
|
||||
let mut presence = Presence::new(PresenceType::None);
|
||||
presence.show = Some(PresenceShow::Chat);
|
||||
presence.into()
|
||||
}
|
||||
|
||||
fn make_join(to: FullJid) -> Element {
|
||||
Presence::new(PresenceType::None).with_to(Jid::Full(to)).with_payloads(vec![Muc::new().into()]).into()
|
||||
}
|
||||
|
||||
// Construct a chat <message/>
|
||||
fn make_reply(to: Jid, body: &str) -> Element {
|
||||
fn make_reply(to: Jid, body: &str, groupchat: bool) -> Element {
|
||||
let mut message = Message::new(Some(to));
|
||||
if groupchat {
|
||||
message.type_ = MessageType::Groupchat;
|
||||
}
|
||||
message.bodies.insert(String::new(), Body(body.to_owned()));
|
||||
message.into()
|
||||
}
|
||||
|
||||
fn gpg_encrypt(to: Jid, body: &str) -> Result<String> {
|
||||
let to: String = std::convert::From::from(to);
|
||||
let mut gpg_cmd = Command::new("gpg")
|
||||
.arg("--encrypt")
|
||||
.arg("--armor")
|
||||
.arg("-r")
|
||||
.arg(to)
|
||||
.stdin(Stdio::piped())
|
||||
.stdout(Stdio::piped())
|
||||
.spawn()?;
|
||||
|
||||
{
|
||||
let stdin = gpg_cmd.stdin.as_mut().ok_or_else(|| anyhow!("no gpg stdin"))?;
|
||||
stdin.write_all(body.as_bytes())?;
|
||||
}
|
||||
|
||||
let output = gpg_cmd.wait_with_output()?;
|
||||
|
||||
if !output.status.success() {
|
||||
bail!("gpg exited with non-zero status code");
|
||||
}
|
||||
|
||||
let output = output.stdout;
|
||||
|
||||
// strip off headers per https://xmpp.org/extensions/xep-0027.html
|
||||
// header spec: https://tools.ietf.org/html/rfc4880#section-6.2
|
||||
|
||||
// find index of leading blank line (2 newlines in a row)
|
||||
let start = first_index_of(0, &output, &[10, 10])? + 2;
|
||||
|
||||
if output.len() <= start {
|
||||
bail!("length {} returned by gpg too short to be valid", output.len());
|
||||
}
|
||||
|
||||
// find first newline+dash after the start
|
||||
let end = first_index_of(start, &output, &[10, 45])?;
|
||||
|
||||
Ok(String::from_utf8((&output[start..end]).to_vec())?)
|
||||
}
|
||||
|
||||
fn first_index_of(start_index: usize, haystack: &[u8], needle: &[u8]) -> Result<usize> {
|
||||
for i in start_index..haystack.len() - needle.len() + 1 {
|
||||
if haystack[i..i + needle.len()] == needle[..] {
|
||||
return Ok(i);
|
||||
}
|
||||
}
|
||||
Err(anyhow!("not found"))
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in New Issue