aboutsummaryrefslogtreecommitdiffstats
path: root/mumd
diff options
context:
space:
mode:
Diffstat (limited to 'mumd')
-rw-r--r--mumd/Cargo.toml1
-rw-r--r--mumd/src/network/tcp.rs41
-rw-r--r--mumd/src/state.rs143
3 files changed, 140 insertions, 45 deletions
diff --git a/mumd/Cargo.toml b/mumd/Cargo.toml
index d8e2635..1e8e63f 100644
--- a/mumd/Cargo.toml
+++ b/mumd/Cargo.toml
@@ -42,6 +42,7 @@ tokio-stream = "0.1.0"
tokio-native-tls = "0.3"
tokio-util = { version = "0.6", features = ["codec", "net"] }
bincode = "1.3.2"
+chrono = "0.4"
libnotify = { version = "1.0", optional = true }
diff --git a/mumd/src/network/tcp.rs b/mumd/src/network/tcp.rs
index 5cc2bf7..4a753bf 100644
--- a/mumd/src/network/tcp.rs
+++ b/mumd/src/network/tcp.rs
@@ -13,6 +13,7 @@ use mumble_protocol::control::{msgs, ClientControlCodec, ControlCodec, ControlPa
use mumble_protocol::crypt::ClientCryptState;
use mumble_protocol::voice::VoicePacket;
use mumble_protocol::{Clientbound, Serverbound};
+use mumlib::command::MumbleEventKind;
use std::collections::HashMap;
use std::convert::{Into, TryInto};
use std::net::SocketAddr;
@@ -309,6 +310,10 @@ async fn listen(
let mut crypt_state = None;
let mut crypt_state_sender = Some(crypt_state_sender);
+ let mut last_late = 0;
+ let mut last_lost = 0;
+ let mut last_resync = 0;
+
loop {
let packet = match stream.next().await {
Some(Ok(packet)) => packet,
@@ -337,6 +342,8 @@ async fn listen(
if let Some(user) = user {
notifications::send(format!("{}: {}", user, msg.get_message()));
//TODO: probably want a config flag for this
+ let user = user.to_string();
+ state.push_event(MumbleEventKind::TextMessageReceived(user)) //TODO also include message target
}
state.register_message((msg.get_message().to_owned(), msg.get_actor()));
drop(state);
@@ -435,6 +442,40 @@ async fn listen(
}
}
}
+ ControlPacket::Ping(msg) => {
+ trace!("Received Ping {:?}", *msg);
+
+ let late = msg.get_late();
+ let lost = msg.get_lost();
+ let resync = msg.get_resync();
+
+ let late = late - last_late;
+ let lost = lost - last_lost;
+ let resync = resync - last_resync;
+
+ last_late += late;
+ last_lost += lost;
+ last_resync += resync;
+
+ macro_rules! format_if_nonzero {
+ ($value:expr) => {
+ if $value != 0 {
+ format!("\n {}: {}", stringify!($value), $value)
+ } else {
+ String::new()
+ }
+ }
+ }
+
+ if late != 0 || lost != 0 || resync != 0 {
+ debug!(
+ "Ping:{}{}{}",
+ format_if_nonzero!(late),
+ format_if_nonzero!(lost),
+ format_if_nonzero!(resync),
+ );
+ }
+ }
packet => {
debug!("Received unhandled ControlPacket {:#?}", packet);
}
diff --git a/mumd/src/state.rs b/mumd/src/state.rs
index 942d320..d12b5b6 100644
--- a/mumd/src/state.rs
+++ b/mumd/src/state.rs
@@ -8,14 +8,15 @@ use crate::network::tcp::{TcpEvent, TcpEventData};
use crate::network::{ConnectionInfo, VoiceStreamType};
use crate::notifications;
use crate::state::server::Server;
-
use crate::state::user::UserDiff;
+
+use chrono::NaiveDateTime;
use log::*;
use mumble_protocol::control::msgs;
use mumble_protocol::control::ControlPacket;
use mumble_protocol::ping::PongPacket;
use mumble_protocol::voice::Serverbound;
-use mumlib::command::{ChannelTarget, Command, CommandResponse, MessageTarget};
+use mumlib::command::{ChannelTarget, Command, CommandResponse, MessageTarget, MumbleEvent, MumbleEventKind};
use mumlib::config::Config;
use mumlib::Error;
use std::{
@@ -72,9 +73,11 @@ pub struct State {
server: Option<Server>,
audio_input: AudioInput,
audio_output: AudioOutput,
- message_buffer: Vec<(String, u32)>,
+ message_buffer: Vec<(NaiveDateTime, String, u32)>,
phase_watcher: (watch::Sender<StatePhase>, watch::Receiver<StatePhase>),
+
+ events: Vec<MumbleEvent>,
}
impl State {
@@ -95,6 +98,7 @@ impl State {
audio_output,
message_buffer: Vec::new(),
phase_watcher,
+ events: Vec::new(),
};
state.reload_config();
Ok(state)
@@ -129,21 +133,25 @@ impl State {
// this is someone else
// send notification only if we've passed the connecting phase
if matches!(*self.phase_receiver().borrow(), StatePhase::Connected(_)) {
- let channel_id = msg.get_channel_id();
-
- if channel_id
- == self.get_users_channel(self.server().unwrap().session_id().unwrap())
- {
- if let Some(channel) = self.server().unwrap().channels().get(&channel_id) {
- notifications::send(format!(
- "{} connected and joined {}",
- &msg.get_name(),
- channel.name()
- ));
- }
-
- self.audio_output
- .play_effect(NotificationEvents::UserConnected);
+ let this_channel = msg.get_channel_id();
+ let other_channel = self.get_users_channel(self.server().unwrap().session_id().unwrap());
+ let this_channel_name = self
+ .server()
+ .unwrap()
+ .channels()
+ .get(&this_channel)
+ .map(|c| c.name())
+ .unwrap_or("<unnamed channel>")
+ .to_string();
+
+ if this_channel == other_channel {
+ notifications::send(format!(
+ "{} connected and joined {}",
+ msg.get_name(),
+ this_channel_name,
+ ));
+ self.push_event(MumbleEventKind::UserConnected(msg.get_name().to_string(), this_channel_name));
+ self.audio_output.play_effect(NotificationEvents::UserConnected);
}
}
}
@@ -165,6 +173,7 @@ impl State {
.users_mut()
.get_mut(&session)
.unwrap();
+ let username = user.name().to_string();
let mute = if msg.has_self_mute() && user.self_mute() != msg.get_self_mute() {
Some(msg.get_self_mute())
@@ -180,35 +189,43 @@ impl State {
let diff = UserDiff::from(msg);
user.apply_user_diff(&diff);
- let user = self.server().unwrap().users().get(&session).unwrap();
if Some(session) != self.server().unwrap().session_id() {
- //send notification if the user moved to or from any channel
+ // Send notification if the user moved either to or from our channel
if let Some(to_channel) = diff.channel_id {
let this_channel =
self.get_users_channel(self.server().unwrap().session_id().unwrap());
- if from_channel == this_channel || to_channel == this_channel {
+
+ if from_channel == this_channel {
+ // User moved from our channel to somewhere else
if let Some(channel) = self.server().unwrap().channels().get(&to_channel) {
+ let channel = channel.name().to_string();
notifications::send(format!(
"{} moved to channel {}",
- user.name(),
- channel.name()
+ &username,
+ &channel,
));
- } else {
- warn!("{} moved to invalid channel {}", user.name(), to_channel);
+ self.push_event(MumbleEventKind::UserLeftChannel(username.clone(), channel));
}
- self.audio_output
- .play_effect(if from_channel == this_channel {
- NotificationEvents::UserJoinedChannel
- } else {
- NotificationEvents::UserLeftChannel
- });
+ self.audio_output.play_effect(NotificationEvents::UserLeftChannel);
+ } else if to_channel == this_channel {
+ // User moved from somewhere else to our channel
+ if let Some(channel) = self.server().unwrap().channels().get(&from_channel) {
+ let channel = channel.name().to_string();
+ notifications::send(format!(
+ "{} moved to your channel from {}",
+ &username,
+ &channel,
+ ));
+ self.push_event(MumbleEventKind::UserJoinedChannel(username.clone(), channel));
+ }
+ self.audio_output.play_effect(NotificationEvents::UserJoinedChannel);
}
}
//send notification if a user muted/unmuted
if mute != None || deaf != None {
- let mut s = user.name().to_string();
+ let mut s = username;
if let Some(mute) = mute {
s += if mute { " muted" } else { " unmuted" };
}
@@ -219,7 +236,8 @@ impl State {
s += if deaf { " deafened" } else { " undeafened" };
}
s += " themselves";
- notifications::send(s);
+ notifications::send(s.clone());
+ self.push_event(MumbleEventKind::UserMuteStateChanged(s));
}
}
}
@@ -233,11 +251,25 @@ impl State {
let this_channel = self.get_users_channel(self.server().unwrap().session_id().unwrap());
let other_channel = self.get_users_channel(msg.get_session());
if this_channel == other_channel {
- self.audio_output
- .play_effect(NotificationEvents::UserDisconnected);
- if let Some(user) = self.server().unwrap().users().get(&msg.get_session()) {
- notifications::send(format!("{} disconnected", &user.name()));
- }
+ let channel_name = self
+ .server()
+ .unwrap()
+ .channels()
+ .get(&this_channel)
+ .map(|c| c.name())
+ .unwrap_or("<unnamed channel>")
+ .to_string();
+ let user_name = self
+ .server()
+ .unwrap()
+ .users()
+ .get(&msg.get_session())
+ .map(|u| u.name())
+ .unwrap_or("<unknown user>")
+ .to_string();
+ notifications::send(format!("{} disconnected", &user_name));
+ self.push_event(MumbleEventKind::UserDisconnected(user_name, channel_name));
+ self.audio_output.play_effect(NotificationEvents::UserDisconnected);
}
self.server_mut()
@@ -266,7 +298,7 @@ impl State {
}
pub fn register_message(&mut self, msg: (String, u32)) {
- self.message_buffer.push(msg);
+ self.message_buffer.push((chrono::Local::now().naive_local(), msg.0, msg.1));
}
pub fn broadcast_phase(&self, phase: StatePhase) {
@@ -279,6 +311,11 @@ impl State {
.play_effect(NotificationEvents::ServerConnect);
}
+ /// Store a new event
+ pub fn push_event(&mut self, kind: MumbleEventKind) {
+ self.events.push(MumbleEvent { timestamp: chrono::Local::now().naive_local(), kind });
+ }
+
pub fn audio_input(&self) -> &AudioInput {
&self.audio_input
}
@@ -418,6 +455,19 @@ pub fn handle_command(
new_deaf.map(|b| CommandResponse::DeafenStatus { is_deafened: b })
))
}
+ Command::Events { block } => {
+ if block {
+ warn!("Blocking event list is unimplemented");
+ now!(Err(Error::Unimplemented))
+ } else {
+ let events: Vec<_> = state
+ .events
+ .iter()
+ .map(|event| Ok(Some(CommandResponse::Event { event: event.clone() })))
+ .collect();
+ ExecutionContext::Now(Box::new(move || Box::new(events.into_iter())))
+ }
+ }
Command::InputVolumeSet(volume) => {
state.audio_input.set_volume(volume);
now!(Ok(None))
@@ -555,7 +605,8 @@ pub fn handle_command(
accept_invalid_cert,
)))
.unwrap();
- at!(TcpEvent::Connected, |res| {
+ let state = Arc::clone(&og_state);
+ at!(TcpEvent::Connected, move |res| {
//runs the closure when the client is connected
if let TcpEventData::Connected(res) = res {
Box::new(iter::once(res.map(|msg| {
@@ -565,6 +616,7 @@ pub fn handle_command(
} else {
None
},
+ server_state: state.read().unwrap().server.as_ref().unwrap().into(),
})
})))
} else {
@@ -601,12 +653,12 @@ pub fn handle_command(
}),
Box::new(move |pong| {
Ok(pong.map(|pong| {
- (CommandResponse::ServerStatus {
+ CommandResponse::ServerStatus {
version: pong.version,
users: pong.users,
max_users: pong.max_users,
bandwidth: pong.bandwidth,
- })
+ }
}))
}),
),
@@ -650,6 +702,7 @@ pub fn handle_command(
Box::new(move |data, sender| {
if let TcpEventData::TextMessage(a) = data {
let message = (
+ chrono::Local::now().naive_local(),
a.get_message().to_owned(),
ref_state
.read()
@@ -669,14 +722,14 @@ pub fn handle_command(
let messages = std::mem::take(&mut state.message_buffer);
let messages: Vec<_> = messages
.into_iter()
- .map(|(msg, user)| (msg, state.get_user_name(user).unwrap()))
+ .map(|(timestamp, msg, user)| (timestamp, msg, state.get_user_name(user).unwrap()))
.map(|e| Ok(Some(CommandResponse::PastMessage { message: e })))
.collect();
ExecutionContext::Now(Box::new(move || Box::new(messages.into_iter())))
}
}
- Command::SendMessage { message, target } => {
+ Command::SendMessage { message, targets } => {
if !matches!(*state.phase_receiver().borrow(), StatePhase::Connected(_)) {
return now!(Err(Error::Disconnected));
}
@@ -685,7 +738,7 @@ pub fn handle_command(
msg.set_message(message);
- match target {
+ match targets {
MessageTarget::Channel(channels) => for (channel, recursive) in channels {
let channel_id = if let ChannelTarget::Named(name) = channel {
let channel = state.server().unwrap().channel_name(&name);
generated by cgit v1.2.1 (git 2.18.0) at 2025-12-14 07:34:59 +0100