mirror of https://github.com/dani/patrix.git
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
562 lines
18 KiB
562 lines
18 KiB
#!/usr/bin/perl -w
|
|
|
|
use strict;
|
|
use warnings;
|
|
use LWP::UserAgent;
|
|
use HTTP::Request;
|
|
use JSON qw(from_json to_json);
|
|
use Getopt::Long;
|
|
use Config::Simple;
|
|
use File::HomeDir;
|
|
use File::MimeInfo;
|
|
use File::Basename;
|
|
use File::Spec;
|
|
use URI::Escape;
|
|
use Term::ReadKey;
|
|
use Hash::Merge::Simple qw(merge);
|
|
use Scalar::Util qw(looks_like_number);
|
|
|
|
our $opt;
|
|
|
|
GetOptions(
|
|
"user=s" => \$opt->{user},
|
|
"password=s" => \$opt->{password},
|
|
"access_token|access-token|token=s" => \$opt->{access_token},
|
|
"server=s" => \$opt->{server},
|
|
"room=s" => \$opt->{room},
|
|
"message|msg=s" => \$opt->{message},
|
|
"files=s@" => \$opt->{file},
|
|
"debug" => \$opt->{debug},
|
|
"action=s" => \$opt->{action},
|
|
"send-msg|send-message" => \$opt->{'send-msg'},
|
|
"send-notice" => \$opt->{'send-notice'},
|
|
"send-file" => \$opt->{'send-file'},
|
|
"create-room" => \$opt->{'create-room'},
|
|
"modify-room" => \$opt->{'modify-room'},
|
|
"delete-room-alias" => \$opt->{'delete-room-alias'},
|
|
"get-access-token" => \$opt->{'get-access-token'},
|
|
"get-room-list" => \$opt->{'get-room-list'},
|
|
"get-room-id" => \$opt->{'get-room-id'},
|
|
"setup" => \$opt->{setup},
|
|
"config=s" => \$opt->{conf},
|
|
"invite=s@" => \$opt->{invite},
|
|
"name=s" => \$opt->{name},
|
|
"alias=s" => \$opt->{alias},
|
|
"topic=s" => \$opt->{topic},
|
|
"join_rules|join-rules=s" => \$opt->{join_rules},
|
|
"permision=s@" => \$opt->{perm},
|
|
"perm_user|user-permission=s@" => \$opt->{perm_user},
|
|
"perm_event|event-permission=s@" => \$opt->{perm_user},
|
|
"perm_reset|reset-permission" => \$opt->{perm_reset}
|
|
);
|
|
|
|
if (-e File::HomeDir->my_home . "/.patrixrc" && !$opt->{conf}){
|
|
$opt->{conf} = File::HomeDir->my_home . "/.patrixrc";
|
|
debug("Using default config file $opt->{conf}");
|
|
}
|
|
if ($opt->{conf} && -e $opt->{conf}){
|
|
read_conf();
|
|
}
|
|
|
|
# alias for --action=foo is --foo
|
|
foreach my $action (qw(send-msg send-notice send-file create-room modify-room
|
|
delete-room-alias get-access-token get-room-list get-room-id
|
|
setup)){
|
|
if ($opt->{$action}){
|
|
$opt->{action} = $action;
|
|
last;
|
|
}
|
|
}
|
|
|
|
my $lwp = LWP::UserAgent->new;
|
|
|
|
my $stdin = 0;
|
|
if (!-t STDIN){
|
|
debug("Reading data from stdin");
|
|
$stdin = 1;
|
|
}
|
|
|
|
# If the given room starts with #, then it's an alias
|
|
# Lets resolve this to the room ID
|
|
if ($opt->{room} && $opt->{room} =~ m/^#/){
|
|
$opt->{room} = room_alias_to_id($opt->{room});
|
|
debug('Room ID is ' . $opt->{room});
|
|
}
|
|
|
|
foreach (@{$opt->{file}}){
|
|
# Handle ~
|
|
$_ =~ s/^~(\w*)/(getpwnam( $1 || $ENV{USER}))[7]/e;
|
|
# Convert to absolute path
|
|
$_ = File::Spec->rel2abs($_);
|
|
}
|
|
|
|
# Set defaults
|
|
sub set_defaults {
|
|
$opt->{action} //= 'send-msg';
|
|
$opt->{server} = 'https://' . $opt->{server} unless ($opt->{server} =~ m|https?://|);
|
|
}
|
|
|
|
# Print debug info if debug is enabled
|
|
sub debug {
|
|
my $msg = shift;
|
|
print "$msg\n\n" if $opt->{debug};
|
|
}
|
|
|
|
# Resolve a room alias to a room ID
|
|
sub room_alias_to_id {
|
|
my $alias = shift;
|
|
debug("Looking $opt->{room} room ID");
|
|
my $uri = $opt->{server} . '/_matrix/client/r0/directory/room/' . uri_escape($alias);
|
|
my $resp = send_request({
|
|
method => 'GET',
|
|
uri => $uri,
|
|
});
|
|
die "Error during room ID lookup\n" unless ($resp->is_success);
|
|
return from_json($resp->decoded_content)->{room_id};
|
|
}
|
|
|
|
# Send a request to Matrix server and return the raw response
|
|
sub send_request {
|
|
my $param = shift;
|
|
$param->{method} ||= 'POST';
|
|
$param->{content_type} ||= 'application/json';
|
|
$param->{content} ||= to_json({});
|
|
die "Missing an URI" unless $param->{uri};
|
|
my $req = HTTP::Request->new( $param->{method}, $param->{uri} );
|
|
$req->header('Content-Type' => $param->{content_type});
|
|
$req->content($param->{content});
|
|
my $resp = $lwp->request( $req );
|
|
debug("Server responded:\n" . to_json(from_json($resp->decoded_content), { pretty => 1 }));
|
|
return $resp;
|
|
}
|
|
|
|
# Read the content of a file
|
|
sub slurp {
|
|
my $file = shift;
|
|
open my $f, '<', $file or die;
|
|
local $/ = undef;
|
|
my $bytes = <$f>;
|
|
close $f;
|
|
return $bytes;
|
|
}
|
|
|
|
# Load values from the config file if it exists
|
|
sub read_conf {
|
|
my $cfg = Config::Simple->new;
|
|
$cfg->read($opt->{conf});
|
|
foreach my $param(keys %{$opt}){
|
|
if ($cfg->param('default.' . $param) && !$opt->{$param}){
|
|
$opt->{$param} = $cfg->param('default.' . $param)
|
|
}
|
|
}
|
|
}
|
|
|
|
# Submit user and password the the HS and obtain an access_token
|
|
sub login {
|
|
debug("Trying to login on $opt->{server} as $opt->{user}");
|
|
my $uri = $opt->{server} . '/_matrix/client/r0/login';
|
|
my $json = {
|
|
type => 'm.login.password',
|
|
user => $opt->{user},
|
|
password => $opt->{password}
|
|
};
|
|
my $resp = send_request({
|
|
uri => $uri,
|
|
content => to_json($json)
|
|
});
|
|
die "Error login in, please check your credentials\n" unless ($resp->is_success);
|
|
# Set the access token
|
|
$opt->{access_token} = from_json($resp->decoded_content)->{access_token};
|
|
die "No access token in server response\n" if !$opt->{access_token};
|
|
}
|
|
|
|
# Invalidate the access_token
|
|
sub logout {
|
|
debug("Trying to logout");
|
|
my $uri = $opt->{server} . '/_matrix/client/r0/logout?access_token=' . $opt->{access_token};
|
|
my $resp = send_request({
|
|
uri => $uri
|
|
});
|
|
die "Error login out\n" unless ($resp->is_success);
|
|
}
|
|
|
|
# Join the specified room, before we can send anything
|
|
sub join_room {
|
|
debug("Trying to join room $opt->{room}");
|
|
# Room must be escaped. if not and room is an alias, it'll start with # so the access_token won't be sent
|
|
my $uri = $opt->{server} . '/_matrix/client/r0/join/' . uri_escape( $opt->{room} ) . '?access_token=' . $opt->{access_token};
|
|
my $resp = send_request({
|
|
uri => $uri
|
|
});
|
|
die "Error joining room $opt->{room}\n" unless ($resp->is_success);
|
|
}
|
|
|
|
# Retrieve the actual permissions for a room
|
|
sub get_room_permissions {
|
|
debug('Getting actual room state');
|
|
my $uri = $opt->{server} . '/_matrix/client/r0/rooms/' . $opt->{room} . '/state/m.room.power_levels?access_token=' . $opt->{access_token};
|
|
my $resp = send_request({
|
|
method => 'GET',
|
|
uri => $uri
|
|
});
|
|
die "Error joining room $opt->{room}\n" unless ($resp->is_success);
|
|
return from_json($resp->decoded_content);
|
|
}
|
|
|
|
# Return the user ID of the operator
|
|
sub who_am_i {
|
|
# We could get user_id if we login with user/pass but what if we use an access token ?
|
|
# Lets just build it manually for now
|
|
my $server = $opt->{server};
|
|
$server =~ s|^https?://||;
|
|
$server =~ s|/$||;
|
|
return '@' . $opt->{user} .':' . $server;
|
|
}
|
|
|
|
# Send a text message (either message or notice as both are similar)
|
|
sub send_msg {
|
|
my $uri = $opt->{server} . '/_matrix/client/r0/rooms/' . $opt->{room} . '/send/m.room.message?access_token=' . $opt->{access_token};
|
|
# Ignore --message if reading from stdin
|
|
if ($stdin){
|
|
$opt->{message} = '';
|
|
$opt->{message} .= $_ while (<STDIN>);
|
|
}
|
|
my $json = {
|
|
msgtype => ($opt->{action} eq 'send-notice') ? 'm.notice' : 'm.text',
|
|
body => $opt->{message}
|
|
};
|
|
my $resp = send_request({
|
|
uri => $uri,
|
|
content => to_json($json)
|
|
});
|
|
die "Error sending message to $opt->{room}\n" unless ($resp->is_success);
|
|
}
|
|
|
|
# Send a file to the room
|
|
sub send_file {
|
|
my $file = shift;
|
|
# Sending a file is a 2 steps operation. First we need to upload the file to the media store
|
|
# And then we post the uri on the room
|
|
debug("Uploading file $file to the media store");
|
|
my $uri = $opt->{server} . '/_matrix/media/v1/upload?access_token=' . $opt->{access_token} . '&filename=' . basename($file);
|
|
my $mime = mimetype($file);
|
|
my $resp = send_request({
|
|
uri => $uri,
|
|
content_type => $mime,
|
|
content => slurp($file)
|
|
});
|
|
die "Error uploading file\n" unless ($resp->is_success);
|
|
# If everything went well, the server replied with the URI of our file, which we can
|
|
# now post on the room
|
|
my $file_uri = from_json($resp->decoded_content)->{content_uri};
|
|
die "Server did not sent the file URI\n" unless ($file_uri);
|
|
debug("File uploaded, with the URI $file_uri\nNow Sending the file link to the room $opt->{room}");
|
|
# Now lets post a new message with the URI of the file
|
|
$uri = $opt->{server} . '/_matrix/client/r0/rooms/' . $opt->{room} . '/send/m.room.message?access_token=' . $opt->{access_token};
|
|
my $json = {
|
|
msgtype => 'm.file',
|
|
body => basename($file),
|
|
filename => basename($file),
|
|
info => {
|
|
mimetype => mimetype $file,
|
|
size => (stat $file)[7]
|
|
},
|
|
url => $file_uri
|
|
};
|
|
# If the file is an image, audio or video, send it as such
|
|
if ($mime =~ m/^image/){
|
|
$json->{msgtype} = 'm.image';
|
|
}
|
|
elsif ($mime =~ /^audio/){
|
|
$json->{msgtype} = 'm.audio';
|
|
}
|
|
elsif ($mime =~ /^video/){
|
|
$json->{msgtype} = 'm.video';
|
|
}
|
|
$resp = send_request({
|
|
uri => $uri,
|
|
content => to_json($json)
|
|
});
|
|
die "Error posting file link on room $opt->{room}\n" unless ($resp->is_success);
|
|
}
|
|
|
|
# List public rooms
|
|
# Note that there's no pagination handling yet, so you might not have all the results
|
|
sub list_room {
|
|
debug("Fetching list of public rooms on $opt->{server}");
|
|
my $uri = $opt->{server} . '/_matrix/client/r0/publicRooms?access_token=' . $opt->{access_token};
|
|
my $resp = send_request({
|
|
uri => $uri,
|
|
});
|
|
die "Error joining room $opt->{room}\n" unless ($resp->is_success);
|
|
# TODO: Handle pagination
|
|
debug("List rooms response is\n" . to_json(from_json($resp->decoded_content), { pretty => 1 }));
|
|
print "Existing Rooms:\n";
|
|
foreach (@{from_json($resp->decoded_content)->{chunk}}){
|
|
print " * " . $_->{room_id};
|
|
print ' (' . $_->{canonical_alias} . ')' if (defined $_->{canonical_alias});
|
|
print "\n";
|
|
}
|
|
}
|
|
|
|
# Create a new room
|
|
sub create_room {
|
|
debug("Creating a new room on $opt->{server}");
|
|
my $uri = $opt->{server} . '/_matrix/client/r0/createRoom?access_token=' . $opt->{access_token};
|
|
my $json = {};
|
|
my $resp = send_request({
|
|
uri => $uri,
|
|
content => to_json($json)
|
|
});
|
|
die "Error creating room on $opt->{server}\n" unless ($resp->is_success);
|
|
$opt->{room} = from_json($resp->decoded_content)->{room_id};
|
|
# Now configure the room
|
|
modify_room();
|
|
print "$opt->{room}\n";
|
|
}
|
|
|
|
# Modify an existing room
|
|
sub modify_room {
|
|
debug("Modifying room $opt->{room} on $opt->{server}");
|
|
my ($uri,$req,$json,$resp);
|
|
# A new alias should be added
|
|
if ($opt->{alias}){
|
|
debug('Adding ' . $opt->{alias} . ' as a room alias');
|
|
$uri = $opt->{server} . '/_matrix/client/r0/directory/room/' . uri_escape($opt->{alias}) . '?access_token=' . $opt->{access_token};
|
|
$json = {
|
|
room_id => $opt->{room}
|
|
};
|
|
$resp = send_request({
|
|
method => 'PUT',
|
|
uri => $uri,
|
|
content => to_json($json)
|
|
});
|
|
die "Error adding new alias $opt->{alias} for room $opt->{room} on server $opt->{server}\n"
|
|
unless ($resp->is_success);
|
|
}
|
|
# The name of the room is being updated
|
|
if ($opt->{name}){
|
|
debug('Changing the room name to ' . $opt->{name});
|
|
$uri = $opt->{server} . '/_matrix/client/r0/rooms/' . $opt->{room} . '/state/m.room.name?access_token=' . $opt->{access_token};
|
|
$json = {
|
|
name => $opt->{name}
|
|
};
|
|
$resp = send_request({
|
|
method => 'PUT',
|
|
uri => $uri,
|
|
content => to_json($json)
|
|
});
|
|
die "Error changing name of room $opt->{room}\n"
|
|
unless ($resp->is_success);
|
|
}
|
|
# The topic is being updated
|
|
if ($opt->{topic}){
|
|
debug('Changing the room topic to ' . $opt->{topic});
|
|
$uri = $opt->{server} . '/_matrix/client/r0/rooms/' . $opt->{room} . '/state/m.room.topic?access_token=' . $opt->{access_token};
|
|
$json = {
|
|
topic => $opt->{topic}
|
|
};
|
|
$resp = send_request({
|
|
method => 'PUT',
|
|
uri => $uri,
|
|
content => to_json($json)
|
|
});
|
|
die "Error changing topic of room $opt->{room}\n"
|
|
unless ($resp->is_success);
|
|
}
|
|
# Changing joining rules
|
|
if ($opt->{join_rules}){
|
|
debug('Changing the joining rules to '. $opt->{join_rules});
|
|
$uri = $opt->{server} . '/_matrix/client/r0/rooms/' . $opt->{room} . '/state/m.room.join_rules?access_token=' . $opt->{access_token};
|
|
$json = {
|
|
join_rules => $opt->{join_rules}
|
|
};
|
|
$resp = send_request({
|
|
method => 'PUT',
|
|
uri => $uri,
|
|
content => to_json($json)
|
|
});
|
|
die "Error changing joining rules of room $opt->{room}\n"
|
|
unless ($resp->is_success);
|
|
}
|
|
# Permissions modification
|
|
if ($opt->{perm} || $opt->{perm_user} || $opt->{perm_event} || $opt->{perm_reset}){
|
|
debug('Changing permissions for the room');
|
|
my $current_perm = get_room_permissions();
|
|
# If we asked to reset the permission
|
|
if ($opt->{perm_reset}){
|
|
my $operator = who_am_i();
|
|
my $reset_perm = {
|
|
events => {
|
|
"m.room.avatar" => 50,
|
|
"m.room.canonical_alias" => 50,
|
|
"m.room.name" => 50,
|
|
"m.room.power_levels" => 100,
|
|
"m.room.history_visibility" => 100
|
|
},
|
|
};
|
|
# Ensure we keep at least the permission of the operating user
|
|
# Note that we must also keep the permission of anyone who has at least the same level
|
|
# of privilege, or the operation will be forbidden
|
|
foreach my $user (keys %{$current_perm->{users}}){
|
|
if (looks_like_number($current_perm->{users}->{$user}) &&
|
|
$current_perm->{users}->{$user} >= $current_perm->{users}->{$operator}){
|
|
debug("Keeping permission of $user because it has at least the same privileges " .
|
|
"($current_perm->{users}->{$user} vs $current_perm->{users}->{$operator})");
|
|
$reset_perm->{users}->{$user} = $current_perm->{users}->{$user};
|
|
}
|
|
}
|
|
$current_perm = $reset_perm;
|
|
}
|
|
my $new_perm = {};
|
|
if ($opt->{perm}){
|
|
foreach my $perm (@{$opt->{perm}}){
|
|
my ($key,$val) = split (/\s*=\s*/, $perm);
|
|
$new_perm->{$key} = $val;
|
|
}
|
|
}
|
|
if ($opt->{perm_user}){
|
|
foreach my $perm (@{$opt->{perm_user}}){
|
|
my ($key,$val) = split (/\s*=\s*/, $perm);
|
|
# Prevent the operating user to downgrade its own permissions
|
|
next if ($key eq $opt->{user});
|
|
$new_perm->{users}->{$key} = $val;
|
|
}
|
|
}
|
|
if ($opt->{perm_event}){
|
|
foreach my $perm (@{$opt->{perm_event}}){
|
|
my ($key,$val) = split (/\s*=\s*/, $perm);
|
|
$new_perm->{events}->{$key} = $val;
|
|
}
|
|
}
|
|
my $perm = merge($current_perm, $new_perm);
|
|
debug("New permissions for this room will be:\n" . to_json($perm, { pretty => 1 }));
|
|
$uri = $opt->{server} . '/_matrix/client/r0/rooms/' . $opt->{room} . '/state/m.room.power_levels?access_token=' . $opt->{access_token};
|
|
$resp = send_request({
|
|
method => 'PUT',
|
|
uri => $uri,
|
|
content => to_json($perm)
|
|
});
|
|
die "Error changing permissions for room $opt->{room}\n"
|
|
unless ($resp->is_success);
|
|
}
|
|
# New invitees should be added
|
|
if ($opt->{invite}){
|
|
debug('Inviting ' . join(',', @{$opt->{invite}}) . ' to join the room');
|
|
$uri = $opt->{server} . '/_matrix/client/r0/rooms/' . $opt->{room} . '/invite?access_token=' . $opt->{access_token};
|
|
foreach my $invite (@{$opt->{invite}}){
|
|
$json = {
|
|
user_id => $invite
|
|
};
|
|
$resp = send_request({
|
|
uri => $uri,
|
|
content => to_json($json)
|
|
});
|
|
unless ($resp->is_success){
|
|
my $error = from_json($resp->decoded_content);
|
|
if ($error->{error} eq $invite . ' is already in the room.' && $error->{errcode} eq 'M_FORBIDDEN'){
|
|
debug($invite . ' has already been invited in this room, ignoring');
|
|
}
|
|
else{
|
|
die "Error inviting user $invite in room $opt->{room}\n";
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
sub del_room_alias {
|
|
debug("Removing room alias $opt->{alias}");
|
|
my $uri = $opt->{server} . "/_matrix/client/r0/directory/room/" . uri_escape($opt->{alias}) . '?access_token=' . $opt->{access_token};
|
|
my $resp = send_request({
|
|
method => 'DELETE',
|
|
uri => $uri
|
|
});
|
|
die "Error removing the alias\n" unless ($resp->is_success);
|
|
}
|
|
|
|
# Write settings in a config file
|
|
sub setup {
|
|
$opt->{conf} //= File::HomeDir->my_home . "/.patrixrc";
|
|
my $cfg = Config::Simple->new(syntax => 'ini');
|
|
foreach my $param (qw(access_token server room)){
|
|
$cfg->param($param, $opt->{$param}) if ($opt->{$param});
|
|
}
|
|
debug("Writing config file $opt->{conf}");
|
|
$cfg->save($opt->{conf});
|
|
}
|
|
|
|
# If server is not specified, ask for it
|
|
if (!$opt->{server}){
|
|
print "Matrix server: ";
|
|
$opt->{server} = ReadLine(0);
|
|
$opt->{server} =~ s/\R\z//;
|
|
}
|
|
# If not using an access token
|
|
# Prompt for the user ID and password
|
|
# if not provided on the command line or the config file
|
|
if (!$opt->{access_token}){
|
|
if (!$opt->{user}){
|
|
print "Matrix ID: ";
|
|
$opt->{user} = ReadLine(0);
|
|
$opt->{user} =~ s/\R\z//;
|
|
}
|
|
if (!$opt->{password}){
|
|
ReadMode('noecho');
|
|
print "Password: ";
|
|
$opt->{password} = ReadLine(0);
|
|
$opt->{password} =~ s/\R\z//;
|
|
ReadMode('restore');
|
|
print "\n";
|
|
}
|
|
}
|
|
|
|
# Set defaults values
|
|
set_defaults();
|
|
|
|
# If we ask for a new access token, then we must login, and ignore any
|
|
# access_token from the config file
|
|
$opt->{access_token} = undef if ($opt->{action} eq 'get-access-token');
|
|
|
|
# Should we logout at the end ? Only if we used login and pass
|
|
# If we used an access_token, we don't want it to be invalidated
|
|
my $must_logout = ($opt->{access_token} || ($opt->{action} eq 'get-access-token' ||
|
|
$opt->{action} eq 'setup')) ? 0 : 1;
|
|
|
|
# If we don't have an access token, we must get one now
|
|
if (!$opt->{access_token}){
|
|
login();
|
|
}
|
|
if ($opt->{action} eq 'setup'){
|
|
setup();
|
|
}
|
|
if ($opt->{action} eq 'get-access-token'){
|
|
print $opt->{access_token} . "\n";
|
|
}
|
|
elsif ($opt->{action} eq 'get-room-list'){
|
|
list_room();
|
|
}
|
|
elsif ($opt->{action} eq 'get-room-id'){
|
|
print room_alias_to_id($opt->{room}) . "\n";
|
|
}
|
|
elsif ($opt->{action} =~ m/^send\-(msg|message|notice)$/){
|
|
join_room();
|
|
send_msg();
|
|
}
|
|
elsif ($opt->{action} eq 'send-file'){
|
|
join_room();
|
|
send_file($_) foreach (@{$opt->{file}});
|
|
}
|
|
elsif ($opt->{action} eq 'create-room'){
|
|
create_room();
|
|
}
|
|
elsif ($opt->{action} eq 'modify-room'){
|
|
modify_room();
|
|
}
|
|
elsif ($opt->{action} =~ m/^(remove|delete|del)\-room\-alias$/){
|
|
del_room_alias();
|
|
}
|
|
|
|
logout() if $must_logout;
|
|
|
|
exit(0);
|
|
|