build.rs

@@ -1,7 +1,4 @@
 fn main() {
-    prost_build::compile_protos(
+    prost_build::compile_protos(&["src/protos/Mumble.proto", "src/protos/MumbleUDP.proto"], &["src/protos"])
-        &["src/protos/Mumble.proto", "src/protos/MumbleUDP.proto"],
+        .expect("Could not build protobuf files")
-        &["src/protos"],
-    )
-    .expect("Could not build protobuf files")
 }

src/codec.rs

@@ -1,9 +1,9 @@
-use crate::proto::*;
-use crate::MumbleMessage;
 use anyhow::bail;
 use bytes::{Buf, BufMut, BytesMut};
 use prost::Message;
 use tokio_util::codec::{Decoder, Encoder};
+use crate::MumbleMessage;
+use crate::proto::{Authenticate, Version, Ping, CryptSetup, CodecVersion, ChannelState, PermissionQuery, UserState, ServerSync, ServerConfig, UdpTunnel, UserRemove};
 
 pub struct MumbleTcpCodec {}
 
@@ -27,8 +27,8 @@ impl Decoder for MumbleTcpCodec {
         let message_type = u16::from_be_bytes(message_type.try_into()?) as usize;
         let message_length = u32::from_be_bytes(message_length.try_into()?) as usize;
 
-        if message_length + 6 > src.len() {
+        if message_length+6 > src.len() {
-            src.reserve(message_length + 6 - src.len());
+            src.reserve(message_length+6-src.len());
             return Ok(None);
         }
 
@@ -37,139 +37,44 @@ impl Decoder for MumbleTcpCodec {
 
         match message_type {
             0 => {
-                mumble_message = Some(MumbleMessage::Version {
+                mumble_message = Some(MumbleMessage::Version { data: Version::decode(message_data)? });
-                    data: Version::decode(message_data)?,
-                });
             }
             1 => {
-                mumble_message = Some(MumbleMessage::UdpTunnel {
+                mumble_message = Some(MumbleMessage::UDPTunnel { data: UdpTunnel::decode(message_data)? });
-                    data: UdpTunnel::decode(message_data)?,
-                });
-            }
-            2 => {
-                bail!("The server should never send Authenticate")
             }
             3 => {
-                mumble_message = Some(MumbleMessage::Ping {
+                mumble_message = Some(MumbleMessage::Ping { data: Ping::decode(message_data)? });
-                    data: Ping::decode(message_data)?,
+            },
-                });
-            }
-            4 => {
-                mumble_message = Some(MumbleMessage::Reject {
-                    data: Reject::decode(message_data)?,
-                });
-            }
             5 => {
-                mumble_message = Some(MumbleMessage::ServerSync {
+                mumble_message = Some(MumbleMessage::ServerSync { data: ServerSync::decode(message_data)? });
-                    data: ServerSync::decode(message_data)?,
-                });
-            }
-            6 => {
-                mumble_message = Some(MumbleMessage::ChannelRemove {
-                    data: ChannelRemove::decode(message_data)?,
-                });
             }
             7 => {
-                mumble_message = Some(MumbleMessage::ChannelState {
+                mumble_message = Some(MumbleMessage::ChannelState { data: ChannelState::decode(message_data)? });
-                    data: ChannelState::decode(message_data)?,
-                });
             }
             8 => {
-                mumble_message = Some(MumbleMessage::UserRemove {
+                mumble_message = Some(MumbleMessage::UserRemove { data: UserRemove::decode(message_data)? });
-                    data: UserRemove::decode(message_data)?,
-                });
             }
             9 => {
-                mumble_message = Some(MumbleMessage::UserState {
+                mumble_message = Some(MumbleMessage::UserState { data: UserState::decode(message_data)? });
-                    data: UserState::decode(message_data)?,
+            },
-                });
-            }
-            10 => {
-                mumble_message = Some(MumbleMessage::BanList {
-                    data: BanList::decode(message_data)?,
-                });
-            }
-            11 => {
-                mumble_message = Some(MumbleMessage::TextMessage {
-                    data: TextMessage::decode(message_data)?,
-                });
-            }
-            12 => {
-                mumble_message = Some(MumbleMessage::PermissionDenied {
-                    data: PermissionDenied::decode(message_data)?,
-                });
-            }
-            13 => {
-                mumble_message = Some(MumbleMessage::Acl {
-                    data: Acl::decode(message_data)?,
-                });
-            }
-            14 => {
-                mumble_message = Some(MumbleMessage::QueryUsers {
-                    data: QueryUsers::decode(message_data)?,
-                });
-            }
             15 => {
-                mumble_message = Some(MumbleMessage::CryptSetup {
+                mumble_message = Some(MumbleMessage::CryptSetup { data: CryptSetup::decode(message_data)? });
-                    data: CryptSetup::decode(message_data)?,
-                });
-            }
-            16 => {
-                mumble_message = Some(MumbleMessage::ContextActionModify {
-                    data: ContextActionModify::decode(message_data)?,
-                });
-            }
-            17 => {
-                mumble_message = Some(MumbleMessage::ContextAction {
-                    data: ContextAction::decode(message_data)?,
-                });
-            }
-            18 => {
-                mumble_message = Some(MumbleMessage::UserList {
-                    data: UserList::decode(message_data)?,
-                });
-            }
-            19 => {
-                mumble_message = Some(MumbleMessage::VoiceTarget {
-                    data: VoiceTarget::decode(message_data)?,
-                });
             }
             20 => {
-                mumble_message = Some(MumbleMessage::PermissionQuery {
+                mumble_message = Some(MumbleMessage::PermissionQuery {data: PermissionQuery::decode(message_data)?});
-                    data: PermissionQuery::decode(message_data)?,
-                });
             }
             21 => {
-                mumble_message = Some(MumbleMessage::CodecVersion {
+                mumble_message = Some(MumbleMessage::CodecVersion {data: CodecVersion::decode(message_data)?});
-                    data: CodecVersion::decode(message_data)?,
+            },
-                });
-            }
-            22 => {
-                mumble_message = Some(MumbleMessage::UserStats {
-                    data: UserStats::decode(message_data)?,
-                });
-            }
-            23 => {
-                mumble_message = Some(MumbleMessage::RequestBlob {
-                    data: RequestBlob::decode(message_data)?,
-                });
-            }
             24 => {
-                mumble_message = Some(MumbleMessage::ServerConfig {
+                mumble_message = Some(MumbleMessage::ServerConfig {data: ServerConfig::decode(message_data)?});
-                    data: ServerConfig::decode(message_data)?,
-                });
-            }
-            25 => {
-                mumble_message = Some(MumbleMessage::SuggestConfig {
-                    data: SuggestConfig::decode(message_data)?,
-                });
             }
             _ => {
                 eprintln!("Unknown message type {:?}", message_type);
             }
         }
 
-        src.advance(message_length + 6);
+        src.advance(message_length+6);
         Ok(mumble_message)
     }
 }
@@ -187,7 +92,7 @@ impl Encoder<MumbleMessage> for MumbleTcpCodec {
             MumbleMessage::Authenticate { data } => {
                 Authenticate::encode(&data, &mut message)?;
                 dst.put_u16(2);
-            }
+            },
             MumbleMessage::Ping { data } => {
                 Ping::encode(&data, &mut message)?;
                 dst.put_u16(3);

src/lib.rs

@@ -9,95 +9,63 @@ pub mod udp {
     include!(concat!(env!("OUT_DIR"), "/mumble_udp.rs"));
 }
 
-use crate::codec::MumbleTcpCodec;
-use crate::proto::*;
-use rustls_pki_types::{CertificateDer, ServerName, UnixTime};
 use std::fmt::{Debug, Formatter};
-use std::net::Ipv4Addr;
+use std::net::{Ipv4Addr, SocketAddr};
-use std::sync::Arc;
 use tokio::net::{TcpStream, UdpSocket};
+use tokio::io::AsyncWriteExt;
+use tokio_stream::StreamExt;
+use prost::Message;
+use tokio_rustls::rustls::{ClientConfig, DigitallySignedStruct, Error, RootCertStore, SignatureScheme};
 use tokio_rustls::client::TlsStream;
-use tokio_rustls::rustls::client::danger::{
+use tokio_rustls::{TlsConnector};
-    HandshakeSignatureValid, ServerCertVerified, ServerCertVerifier,
+use std::sync::Arc;
-};
+use std::time::SystemTime;
-use tokio_rustls::rustls::{
+use rustls_pki_types::{CertificateDer, ServerName, UnixTime};
-    ClientConfig, DigitallySignedStruct, Error, RootCertStore, SignatureScheme,
-};
-use tokio_rustls::TlsConnector;
 use tokio_util::codec::Framed;
+use crate::codec::MumbleTcpCodec;
+use tokio_rustls::rustls::client::danger::{HandshakeSignatureValid, ServerCertVerified, ServerCertVerifier};
+use crate::proto::{Authenticate, Version, Ping, CryptSetup, CodecVersion, ChannelState, PermissionQuery, UserState, ServerSync, ServerConfig, UdpTunnel, UserRemove};
 
 #[derive(Debug)]
 pub enum MumbleMessage {
-    Version { data: Version },
+    Version {data: Version},
-    UdpTunnel { data: UdpTunnel },
+    UDPTunnel { data: UdpTunnel },
+    Authenticate {data: Authenticate},
     Ping { data: Ping },
-    Reject { data: Reject },
-    Authenticate { data: Authenticate },
     ServerSync { data: ServerSync },
-    ChannelRemove { data: ChannelRemove },
     ChannelState { data: ChannelState },
     UserRemove { data: UserRemove },
     UserState { data: UserState },
-    BanList { data: BanList },
-    TextMessage { data: TextMessage },
-    PermissionDenied { data: PermissionDenied },
-    Acl { data: Acl },
-    QueryUsers { data: QueryUsers },
     CryptSetup { data: CryptSetup },
-    ContextActionModify { data: ContextActionModify },
-    ContextAction { data: ContextAction },
-    UserList { data: UserList },
-    VoiceTarget { data: VoiceTarget },
     PermissionQuery { data: PermissionQuery },
     CodecVersion { data: CodecVersion },
-    UserStats { data: UserStats },
-    RequestBlob { data: RequestBlob },
     ServerConfig { data: ServerConfig },
-    SuggestConfig { data: SuggestConfig },
+    UnknownMessage
 }
 
 pub struct MumbleClient {
-    host: String,
+    host: SocketAddr,
-    name: String,
+
-    port: u16,
-    password: Option<String>,
 }
 
 pub(crate) struct NoVerifier;
 
 impl Debug for NoVerifier {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        write!(f, "NoVerifier")
+        todo!()
     }
 }
 
 impl ServerCertVerifier for NoVerifier {
-    fn verify_server_cert(
+    fn verify_server_cert(&self, end_entity: &CertificateDer<'_>, intermediates: &[CertificateDer<'_>], server_name: &ServerName<'_>, ocsp_response: &[u8], now: UnixTime) -> Result<ServerCertVerified, Error> {
-        &self,
-        _end_entity: &CertificateDer<'_>,
-        _intermediates: &[CertificateDer<'_>],
-        _server_name: &ServerName<'_>,
-        _ocsp_response: &[u8],
-        _now: UnixTime,
-    ) -> Result<ServerCertVerified, Error> {
         Ok(ServerCertVerified::assertion())
     }
 
-    fn verify_tls12_signature(
+    fn verify_tls12_signature(&self, message: &[u8], cert: &CertificateDer<'_>, dss: &DigitallySignedStruct) -> Result<HandshakeSignatureValid, Error> {
-        &self,
-        _message: &[u8],
-        _cert: &CertificateDer<'_>,
-        _dss: &DigitallySignedStruct,
-    ) -> Result<HandshakeSignatureValid, Error> {
         Ok(HandshakeSignatureValid::assertion())
     }
 
-    fn verify_tls13_signature(
+    fn verify_tls13_signature(&self, message: &[u8], cert: &CertificateDer<'_>, dss: &DigitallySignedStruct) -> Result<HandshakeSignatureValid, Error> {
-        &self,
-        _message: &[u8],
-        _cert: &CertificateDer<'_>,
-        _dss: &DigitallySignedStruct,
-    ) -> Result<HandshakeSignatureValid, Error> {
         Ok(HandshakeSignatureValid::assertion())
     }
 
@@ -121,12 +89,9 @@ impl ServerCertVerifier for NoVerifier {
 }
 
 impl MumbleClient {
-    pub fn new(host: String, port: Option<u16>, name: String, password: Option<String>) -> Self {
+    pub fn new(host: SocketAddr) -> Self {
         Self {
-            host,
+           host
-            port: port.unwrap_or(64738),
-            name,
-            password,
         }
     }
 
@@ -143,8 +108,8 @@ impl MumbleClient {
             .set_certificate_verifier(Arc::new(NoVerifier));
 
         let connector = TlsConnector::from(Arc::new(config));
-        let dnsname = ServerName::try_from(self.host.clone())?;
+        let dnsname = ServerName::try_from("127.0.0.1")?;
-        let stream = TcpStream::connect((self.host.clone(), self.port)).await?;
+        let stream = TcpStream::connect(&self.host).await?;
         Ok(connector.connect(dnsname, stream).await?)
     }
 
@@ -155,36 +120,26 @@ impl MumbleClient {
         Ok(sock)
     }
 
-    pub async fn connect(
+    pub async fn connect(&mut self) -> anyhow::Result<Framed<TlsStream<TcpStream>, MumbleTcpCodec>> {
-        &mut self,
-    ) -> anyhow::Result<Framed<TlsStream<TcpStream>, MumbleTcpCodec>> {
         let mut framed = Framed::new(self.create_tcp_connection().await?, MumbleTcpCodec::new());
         let version_v1 = (1u16 as u32) << 16 | (5u8 as u32) << 8 | (1u8 as u32);
         let version_v2 = 1u64 << 48 | 5u64 << 32 | 0u64 << 16 | 1u64;
-        framed
+        framed.send(MumbleMessage::Version { data: Version {
-            .send(MumbleMessage::Version {
+            os: Some(String::from("Linux")),
-                data: Version {
+            os_version: Some(String::from("os version")),
-                    os: Some(String::from("Linux")),
+            release: Some(String::from("release")),
-                    os_version: Some(String::from("os version")),
+            version_v1: Some(version_v1),
-                    release: Some(String::from("release")),
+            version_v2: Some(version_v2)
-                    version_v1: Some(version_v1),
+        }}).await?;
-                    version_v2: Some(version_v2),
-                },
-            })
-            .await?;
 
-        framed
+        framed.send(MumbleMessage::Authenticate { data: Authenticate {
-            .send(MumbleMessage::Authenticate {
+            username:Some(String::from("Botty")),
-                data: Authenticate {
+            password: Some(String::new()),
-                    username: Some(self.name.clone()),
+            tokens: vec![],
-                    password: self.password.clone(),
+            celt_versions: vec![],
-                    tokens: vec![],
+            opus: Some(true),
-                    celt_versions: vec![],
+            client_type: Some(1),
-                    opus: Some(true),
+        }}).await?;
-                    client_type: Some(1),
-                },
-            })
-            .await?;
 
         Ok(framed)
     }