remove duplicate settings + remove remove_null arg

src/chat/config.rs

@@ -27,11 +27,9 @@ pub struct Config {
     #[serde(default = "default_true")] pub hide_my_ip: bool,
     #[serde(default)] pub show_other_ip: bool,
     #[serde(default)] pub auth_enabled: bool,
-    #[serde(default)] pub ssl_enabled: bool,
     #[serde(default = "default_true")] pub chunked_enabled: bool,
     #[serde(default = "default_true")] pub formatting_enabled: bool,
     #[serde(default = "default_true")] pub commands_enabled: bool,
-    #[serde(default)] pub wrac_enabled: bool,
     #[serde(default)] pub proxy: Option<String>,
     #[serde(default = "default_true")] pub notifications_enabled: bool,
     #[serde(default)] pub debug_logs: bool,
@@ -121,13 +119,11 @@ pub struct Args {
     #[arg(long)] pub hide_my_ip: Option<bool>,
     #[arg(long)] pub show_other_ip: Option<bool>,
     #[arg(long)] pub auth_enabled:Option <bool>,
-    #[arg(long)] pub ssl_enabled: Option<bool>,
     #[arg(long)] pub remove_gui_shit: Option<bool>,
     #[arg(long)] pub chunked_enabled: Option<bool>,
     #[arg(long)] pub formatting_enabled: Option<bool>,
     #[arg(long)] pub commands_enabled: Option<bool>,
     #[arg(long)] pub notifications_enabled: Option<bool>,
-    #[arg(long)] pub wrac_enabled: Option<bool>,
     #[arg(long)] pub proxy: Option<String>,
     #[arg(long)] pub debug_logs: bool,
 }
@@ -146,12 +142,10 @@ impl Args {
         if let Some(v) = self.show_other_ip { config.show_other_ip = v }
         if let Some(v) = self.remove_gui_shit { config.remove_gui_shit = v }
         if let Some(v) = self.auth_enabled { config.auth_enabled = v }
-        if let Some(v) = self.ssl_enabled { config.ssl_enabled = v }
         if let Some(v) = self.chunked_enabled { config.chunked_enabled = v }
         if let Some(v) = self.formatting_enabled { config.formatting_enabled = v }
         if let Some(v) = self.commands_enabled { config.commands_enabled = v }
         if let Some(v) = self.notifications_enabled { config.notifications_enabled = v }
-        if let Some(v) = self.wrac_enabled { config.wrac_enabled = v }
         if self.debug_logs { config.debug_logs = true }
     }
 }

src/chat/ctx.rs

@@ -78,9 +78,7 @@ macro_rules! connect_rac {
     ($ctx:ident) => { 
         &mut connect(
             &$ctx.config(|o| o.host.clone()), 
-            $ctx.config(|o| o.ssl_enabled), 
+            $ctx.config(|o| o.proxy.clone())
-            $ctx.config(|o| o.proxy.clone()), 
-            $ctx.config(|o| o.wrac_enabled)
         )? 
     };
 }

src/chat/gui.rs

@@ -27,9 +27,7 @@ use gtk::{
     Justification, Label, ListBox, Orientation, Overlay, Picture, ScrolledWindow, Settings, Window
 };
 
-use crate::{chat::config::{default_konata_size, default_oof_update_time}, proto::parse_rac_url};
+use super::{config::{default_max_messages, default_update_time, default_konata_size, default_oof_update_time, get_config_path, save_config, Config}, 
-
-use super::{config::{default_max_messages, default_update_time, get_config_path, save_config, Config}, 
 ctx::Context, on_send_message, parse_message, print_message, recv_tick, sanitize_message, SERVER_LIST};
 
 struct UiModel {
@@ -171,8 +169,6 @@ fn open_settings(ctx: Arc<Context>, app: &Application) {
     let hide_my_ip_entry = gui_checkbox_setting!("Hide My IP", hide_my_ip, ctx, settings_vbox);
     let show_other_ip_entry = gui_checkbox_setting!("Show Other IP", show_other_ip, ctx, settings_vbox);
     let auth_enabled_entry = gui_checkbox_setting!("Fake Auth Enabled", auth_enabled, ctx, settings_vbox);
-    let ssl_enabled_entry = gui_checkbox_setting!("SSL Enabled", ssl_enabled, ctx, settings_vbox);
-    let wrac_enabled_entry = gui_checkbox_setting!("WRAC Enabled", wrac_enabled, ctx, settings_vbox);
     let chunked_enabled_entry = gui_checkbox_setting!("Chunked Enabled", chunked_enabled, ctx, settings_vbox);
     let formatting_enabled_entry = gui_checkbox_setting!("Formatting Enabled", formatting_enabled, ctx, settings_vbox);
     let commands_enabled_entry = gui_checkbox_setting!("Commands Enabled", commands_enabled, ctx, settings_vbox);
@@ -205,12 +201,10 @@ fn open_settings(ctx: Arc<Context>, app: &Application) {
         #[weak] hide_my_ip_entry,
         #[weak] show_other_ip_entry,
         #[weak] auth_enabled_entry,
-        #[weak] ssl_enabled_entry,
         #[weak] chunked_enabled_entry,
         #[weak] formatting_enabled_entry,
         #[weak] commands_enabled_entry,
         #[weak] notifications_enabled_entry,
-        #[weak] wrac_enabled_entry,
         #[weak] proxy_entry,
         #[weak] debug_logs_entry,
         #[weak] oof_update_time_entry,
@@ -277,8 +271,6 @@ fn open_settings(ctx: Arc<Context>, app: &Application) {
                 remove_gui_shit: remove_gui_shit_entry.is_active(),
                 show_other_ip: show_other_ip_entry.is_active(),
                 auth_enabled: auth_enabled_entry.is_active(),
-                ssl_enabled: ssl_enabled_entry.is_active(),
-                wrac_enabled: wrac_enabled_entry.is_active(),
                 chunked_enabled: chunked_enabled_entry.is_active(),
                 formatting_enabled: formatting_enabled_entry.is_active(),
                 commands_enabled: commands_enabled_entry.is_active(),
@@ -315,8 +307,6 @@ fn open_settings(ctx: Arc<Context>, app: &Application) {
         #[weak] hide_my_ip_entry,
         #[weak] show_other_ip_entry,
         #[weak] auth_enabled_entry,
-        #[weak] ssl_enabled_entry,
-        #[weak] wrac_enabled_entry,
         #[weak] chunked_enabled_entry,
         #[weak] formatting_enabled_entry,
         #[weak] commands_enabled_entry,
@@ -335,8 +325,6 @@ fn open_settings(ctx: Arc<Context>, app: &Application) {
             hide_my_ip_entry.set_active(config.hide_my_ip);
             show_other_ip_entry.set_active(config.show_other_ip);
             auth_enabled_entry.set_active(config.auth_enabled);
-            ssl_enabled_entry.set_active(config.ssl_enabled);
-            wrac_enabled_entry.set_active(config.wrac_enabled);
             chunked_enabled_entry.set_active(config.chunked_enabled);
             formatting_enabled_entry.set_active(config.formatting_enabled);
             commands_enabled_entry.set_active(config.commands_enabled);
@@ -480,11 +468,7 @@ fn build_ui(ctx: Arc<Context>, app: &Application) -> UiModel {
             #[weak] ctx,
             move |_, _, _, _| {
                 let mut config = ctx.config.read().unwrap().clone();
-                if let Some((_, ssl, wrac)) = parse_rac_url(&url) {
+                config.host = url.clone();
-                    config.host = url.clone();
-                    config.wrac_enabled = wrac;
-                    config.ssl_enabled = ssl;
-                }
                 ctx.set_config(&config);
                 save_config(get_config_path(), &config);
             }

src/chat/mod.rs

@@ -89,7 +89,7 @@ pub fn on_command(ctx: Arc<Context>, command: &str) -> Result<(), Box<dyn Error>
             return Ok(()) 
         };
 
-        match register_user(connect_rac!(ctx), &ctx.name(), pass, !ctx.config(|o| o.ssl_enabled)) {
+        match register_user(connect_rac!(ctx), &ctx.name(), pass) {
             Ok(true) => {
                 add_message(ctx.clone(), "you was registered successfully bro")?;
                 *ctx.registered.write().unwrap() = Some(pass.to_string());
@@ -118,7 +118,6 @@ pub fn on_command(ctx: Arc<Context>, command: &str) -> Result<(), Box<dyn Error>
                 connect_rac!(ctx), 
                 ctx.config(|o| o.max_messages), 
                 before, 
-                !ctx.config(|o| o.ssl_enabled),
                 ctx.config(|o| o.chunked_enabled)
             ).ok().flatten();
 
@@ -182,7 +181,6 @@ pub fn recv_tick(ctx: Arc<Context>) -> Result<(), Box<dyn Error>> {
         connect_rac!(ctx), 
         ctx.config(|o| o.max_messages), 
         ctx.packet_size(), 
-        !ctx.config(|o| o.ssl_enabled),
         ctx.config(|o| o.chunked_enabled)
     ) {
         Ok(Some((messages, size))) => {
@@ -223,9 +221,9 @@ pub fn on_send_message(ctx: Arc<Context>, message: &str) -> Result<(), Box<dyn E
         );
 
         if let Some(password) = ctx.registered.read().unwrap().clone() {
-            send_message_auth(connect_rac!(ctx), &ctx.name(), &password, &message, !ctx.config(|o| o.ssl_enabled))?;
+            send_message_auth(connect_rac!(ctx), &ctx.name(), &password, &message)?;
         } else if ctx.config(|o| o.auth_enabled) {
-            send_message_spoof_auth(connect_rac!(ctx), &message, !ctx.config(|o| o.ssl_enabled))?;
+            send_message_spoof_auth(connect_rac!(ctx), &message)?;
         } else {
             send_message(connect_rac!(ctx), &message)?;
         }

src/main.rs

@@ -20,13 +20,12 @@ fn main() {
     let mut config = load_config(config_path);
 
     if args.read_messages {
-        let mut stream = connect(&config.host, config.ssl_enabled, config.proxy.clone(), config.wrac_enabled).expect("Error reading message");
+        let mut stream = connect(&config.host, config.proxy.clone()).expect("Error reading message");
 
         print!("{}", read_messages(
                 &mut stream, 
                 config.max_messages, 
                 0,
-                !config.ssl_enabled,
                 false
             )
             .ok().flatten()
@@ -35,7 +34,7 @@ fn main() {
     }
 
     if let Some(message) = &args.send_message {
-        let mut stream = connect(&config.host, config.ssl_enabled, config.proxy.clone(), config.wrac_enabled).expect("Error sending message");
+        let mut stream = connect(&config.host, config.proxy.clone()).expect("Error sending message");
 
         send_message(
             &mut stream, 

src/proto/mod.rs

@@ -114,9 +114,8 @@ pub fn parse_rac_url(url: &str) -> Option<(String, bool, bool)> {
 /// ssl - wrap with ssl client, write false if you dont know what it is
 /// proxy - socks5 proxy (host, (user, pass))
 /// wrac - to use wrac protocol
-pub fn connect(host: &str, ssl: bool, proxy: Option<String>, wrac: bool) -> Result<RacStream, Box<dyn Error>> {
+pub fn connect(host: &str, proxy: Option<String>) -> Result<RacStream, Box<dyn Error>> {
-    let (host, ssl_, wrac_) = parse_rac_url(host).ok_or::<Box<dyn Error>>("url parse error".into())?;
+    let (host, ssl, wrac) = parse_rac_url(host).ok_or::<Box<dyn Error>>("url parse error".into())?;
-    let (ssl, wrac) = (ssl_ || ssl, wrac_ || wrac);
 
     let stream: Box<dyn Stream> = if let Some(proxy) = proxy {
         if let Some((proxy, auth)) = parse_socks5_url(&proxy) {
@@ -172,14 +171,14 @@ pub fn connect(host: &str, ssl: bool, proxy: Option<String>, wrac: bool) -> Resu
 ///     register_user(stream, name, name)
 ///     send_message_spoof_auth(stream, name + "> " + message)
 /// }
-pub fn send_message_spoof_auth(stream: &mut RacStream, message: &str, remove_null: bool) -> Result<(), Box<dyn Error>> {
+pub fn send_message_spoof_auth(stream: &mut RacStream, message: &str) -> Result<(), Box<dyn Error>> {
     let Some((name, message)) = message.split_once("> ") else { return send_message(stream, message) };
 
-    if let Ok(f) = send_message_auth(stream, &name, &message, &message, remove_null) {
+    if let Ok(f) = send_message_auth(stream, &name, &message, &message) {
         if f != 0 {
             let name = format!("\x1f{name}");
-            register_user(stream, &name, &name, remove_null)?;
+            register_user(stream, &name, &name)?;
-            send_message_spoof_auth(stream, &format!("{name}>  {message}"), remove_null)?;
+            send_message_spoof_auth(stream, &format!("{name}>  {message}"))?;
         }
     }
 
@@ -212,12 +211,11 @@ pub fn send_message(
 pub fn register_user(
     stream: &mut RacStream, 
     name: &str, 
-    password: &str, 
+    password: &str
-    remove_null: bool
 ) -> Result<bool, Box<dyn Error>> {
     match stream {
         RacStream::WRAC(websocket) => wrac::register_user(websocket, name, password),
-        RacStream::RAC(stream) => rac::register_user(stream, name, password, remove_null)
+        RacStream::RAC(stream) => rac::register_user(stream, name, password)
     }
 }
 
@@ -236,12 +234,11 @@ pub fn send_message_auth(
     stream: &mut RacStream, 
     name: &str, 
     password: &str, 
-    message: &str, 
+    message: &str
-    remove_null: bool
 ) -> Result<u8, Box<dyn Error>> {
     match stream {
         RacStream::WRAC(websocket) => wrac::send_message_auth(websocket, name, password, message),
-        RacStream::RAC(stream) => rac::send_message_auth(stream, name, password, message, remove_null)
+        RacStream::RAC(stream) => rac::send_message_auth(stream, name, password, message)
     }
 }
 
@@ -256,12 +253,11 @@ pub fn send_message_auth(
 pub fn read_messages(
     stream: &mut RacStream, 
     max_messages: usize, 
-    last_size: usize, 
+    last_size: usize,
-    remove_null: bool, 
     chunked: bool
 ) -> Result<Option<(Vec<String>, usize)>, Box<dyn Error>> {
     match stream {
         RacStream::WRAC(websocket) => wrac::read_messages(websocket, max_messages, last_size, chunked),
-        RacStream::RAC(stream) => rac::read_messages(stream, max_messages, last_size, remove_null, chunked)
+        RacStream::RAC(stream) => rac::read_messages(stream, max_messages, last_size, chunked)
     }
 }

src/proto/rac.rs

@@ -20,23 +20,13 @@ pub fn send_message(stream: &mut impl Write, message: &str) -> Result<(), Box<dy
 pub fn register_user(
     stream: &mut (impl Write + Read), 
     name: &str, 
-    password: &str, 
+    password: &str
-    remove_null: bool
 ) -> Result<bool, Box<dyn Error>> {
     stream.write_all(format!("\x03{name}\n{password}").as_bytes())?;
-    if remove_null {
+    if let Ok(out) = skip_null(stream) {
-        if let Ok(out) = skip_null(stream) {
+        Ok(out[0] == 0)
-            Ok(out[0] == 0)
-        } else {
-            Ok(true)
-        }
     } else {
-        let mut buf = vec![0];
+        Ok(true)
-        if let Ok(1) = stream.read(&mut buf) {
-            Ok(buf[0] == 0)
-        } else {
-            Ok(true)
-        }
     }
 }
 
@@ -55,24 +45,13 @@ pub fn send_message_auth(
     stream: &mut (impl Write + Read), 
     name: &str, 
     password: &str, 
-    message: &str, 
+    message: &str,
-    remove_null: bool
 ) -> Result<u8, Box<dyn Error>> {
     stream.write_all(format!("\x02{name}\n{password}\n{message}").as_bytes())?;
-
+    if let Ok(out) = skip_null(stream) {
-    if remove_null {
+        Ok(out[0])
-        if let Ok(out) = skip_null(stream) {
-            Ok(out[0])
-        } else {
-            Ok(0)
-        }
     } else {
-        let mut buf = vec![0];
+        Ok(0)
-        if let Ok(1) = stream.read(&mut buf) {
-            Ok(buf[0])
-        } else {
-            Ok(0)
-        }
     }
 }
 
@@ -107,26 +86,17 @@ pub fn read_messages(
     stream: &mut (impl Read + Write), 
     max_messages: usize, 
     last_size: usize, 
-    remove_null: bool, 
     chunked: bool
 ) -> Result<Option<(Vec<String>, usize)>, Box<dyn Error>> {
     stream.write_all(&[0x00])?;
 
     let packet_size = {
-        let data = if remove_null {
+        let mut data = skip_null(stream)?;
-            let mut data = skip_null(stream)?;
+        let mut buf = vec![0; 10];
-            let mut buf = vec![0; 10];
+        let len = stream.read(&mut buf)?;
-            let len = stream.read(&mut buf)?;
+        buf.truncate(len);
-            buf.truncate(len);
+        data.append(&mut buf);
-            data.append(&mut buf);
+        remove_trailing_null(&mut data)?;
-            remove_trailing_null(&mut data)?;
-            data
-        } else {
-            let mut data = vec![0; 10];
-            let len = stream.read(&mut data)?;
-            data.truncate(len);
-            data
-        };
 
         String::from_utf8(data)?
             .trim_matches(char::from(0))
@@ -145,17 +115,10 @@ pub fn read_messages(
         packet_size - last_size
     };
 
-    let packet_data = if remove_null {
+    let mut packet_data = skip_null(stream)?;
-        let mut data = skip_null(stream)?;
+    let mut buf = vec![0; to_read - 1];
-        let mut buf = vec![0; to_read - 1];
+    stream.read_exact(&mut buf)?;
-        stream.read_exact(&mut buf)?;
+    packet_data.append(&mut buf);
-        data.append(&mut buf);
-        data
-    } else {
-        let mut data = vec![0; to_read];
-        stream.read_exact(&mut data)?;
-        data
-    };
 
     let packet_data = String::from_utf8_lossy(&packet_data).to_string();