MeexReay/bRAC
1
0
Fork 0
mirror of https://github.com/MeexReay/bRAC.git synced 2025-05-06 21:48:03 +03:00
Code Issues Actions Packages Projects Releases Wiki Activity

view users ip param

Browse Source
This commit is contained in:
MeexReay 2025-02-10 18:19:14 +03:00
parent 10974674c5
commit a84018fd17
4 changed files with 175 additions and 158 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

42
src/config.rs
View File

@ -1,4 +1,4 @@
use std::{fs, path::{Path, PathBuf}}; use std::{fs, path::{Path, PathBuf}, thread, time::Duration};
use homedir::my_home; use homedir::my_home;
use serde_yml; use serde_yml;
@ -8,45 +8,59 @@ const MESSAGE_FORMAT: &str = "\u{B9AC}\u{3E70}<{name}> {text}";
#[derive(serde::Serialize, serde::Deserialize)] #[derive(serde::Serialize, serde::Deserialize)]
pub struct Config { pub struct Config {
#[serde(default = "default_host")]
pub host: String, pub host: String,
#[serde(default)]
pub name: Option<String>, pub name: Option<String>,
#[serde(default = "default_message_format")]
pub message_format: String, pub message_format: String,
#[serde(default = "default_update_time")]
pub update_time: usize, pub update_time: usize,
pub max_messages: usize #[serde(default = "default_max_messages")]
pub max_messages: usize,
#[serde(default)]
pub enable_ip_viewing: bool,
#[serde(default)]
pub disable_ip_hiding: bool,
} }
pub fn load_config(path: PathBuf) -> Config { fn default_max_messages() -> usize { 100 }
// println!("Config path: {}", path.to_string_lossy()); fn default_update_time() -> usize { 50 }
// println!("Loading config..."); fn default_host() -> String { "meex.lol:11234".to_string() }
fn default_message_format() -> String { MESSAGE_FORMAT.to_string() }
let config = if !fs::exists(&path).unwrap_or_default() { pub fn load_config(path: PathBuf) -> Config {
if !fs::exists(&path).unwrap_or_default() {
let host = get_input("Host (default: meex.lol:11234) > ").unwrap_or("meex.lol:11234".to_string()); let host = get_input("Host (default: meex.lol:11234) > ").unwrap_or("meex.lol:11234".to_string());
let name = get_input("Name (default: ask every time) > "); let name = get_input("Name (default: ask every time) > ");
let update_time = get_input("Update Interval (default: 50) > ").map(|o| o.parse().ok()).flatten().unwrap_or(50); let update_time = get_input("Update interval (default: 50) > ").map(|o| o.parse().ok()).flatten().unwrap_or(50);
let max_messages = get_input("Max Messages (default: 100) > ").map(|o| o.parse().ok()).flatten().unwrap_or(100); let max_messages = get_input("Max messages (default: 100) > ").map(|o| o.parse().ok()).flatten().unwrap_or(100);
let enable_ip_viewing = get_input("Enable users IP viewing? (Y/N, default: N) > ").map(|o| o.to_lowercase() != "n").unwrap_or(false);
let disable_ip_hiding = get_input("Enable your IP viewing? (Y/N, default: N) > ").map(|o| o.to_lowercase() != "n").unwrap_or(false);
let config = Config { let config = Config {
host, host,
name, name,
message_format: MESSAGE_FORMAT.to_string(), message_format: MESSAGE_FORMAT.to_string(),
update_time, update_time,
max_messages max_messages,
enable_ip_viewing,
disable_ip_hiding
}; };
let config_text = serde_yml::to_string(&config).expect("Config save error"); let config_text = serde_yml::to_string(&config).expect("Config save error");
fs::create_dir_all(&path.parent().expect("Config save error")).expect("Config save error"); fs::create_dir_all(&path.parent().expect("Config save error")).expect("Config save error");
fs::write(&path, config_text).expect("Config save error"); fs::write(&path, config_text).expect("Config save error");
println!("Config saved! You can edit it in the path got with `bRAC --config-path`");
thread::sleep(Duration::from_secs(4));
config config
} else { } else {
let config = &fs::read_to_string(&path).expect("Config load error"); let config = &fs::read_to_string(&path).expect("Config load error");
serde_yml::from_str(config).expect("Config load error") serde_yml::from_str(config).expect("Config load error")
}; }
// println!("Config loaded successfully!");
config
} }
pub fn get_config_path() -> PathBuf { pub fn get_config_path() -> PathBuf {
#[allow(unused_variables)]
let config_path = Path::new("config.yml").to_path_buf(); let config_path = Path::new("config.yml").to_path_buf();
#[cfg(target_os = "linux")] #[cfg(target_os = "linux")]

117
src/main.rs
View File

@ -1,9 +1,9 @@
use std::{ use std::{
error::Error, io::{stdin, stdout, BufRead, Write}, sync::{atomic::AtomicUsize, Arc, RwLock} error::Error, io::{stdin, stdout, BufRead, Write}, sync::{atomic::{AtomicUsize, Ordering}, Arc, RwLock}, time::SystemTime
}; };
use colored::Color; use colored::Color;
use config::{get_config_path, load_config, Config}; use config::{get_config_path, load_config};
use rac::{read_messages, run_recv_loop, send_message}; use rac::{read_messages, run_recv_loop, send_message};
use rand::random; use rand::random;
use regex::Regex; use regex::Regex;
@ -16,7 +16,7 @@ const ADVERTISEMENT: &str = "\r\x1B[1A use bRAC client! https://github.com/MeexR
const ADVERTISEMENT_ENABLED: bool = false; const ADVERTISEMENT_ENABLED: bool = false;
lazy_static! { lazy_static! {
static ref DATE_REGEX: Regex = Regex::new(r"\[(.*?)\] (.*)").unwrap(); static ref DATE_REGEX: Regex = Regex::new(r"\[(.*?)\] \{(.*?)\} (.*)").unwrap();
static ref COLORED_USERNAMES: Vec<(Regex, Color)> = vec![ static ref COLORED_USERNAMES: Vec<(Regex, Color)> = vec![
(Regex::new(r"\u{B9AC}\u{3E70}<(.*?)> (.*)").unwrap(), Color::Green), (Regex::new(r"\u{B9AC}\u{3E70}<(.*?)> (.*)").unwrap(), Color::Green),
(Regex::new(r"\u{2550}\u{2550}\u{2550}<(.*?)> (.*)").unwrap(), Color::BrightRed), (Regex::new(r"\u{2550}\u{2550}\u{2550}<(.*?)> (.*)").unwrap(), Color::BrightRed),
@ -46,17 +46,15 @@ fn get_input(prompt: &str) -> Option<String> {
} }
} }
fn on_command(config: Arc<Config>, host: &str, disable_hiding_ip: bool, command: &str) -> Result<(), Box<dyn Error>> { fn on_command(ctx: Arc<Context>, command: &str) -> Result<(), Box<dyn Error>> {
let command = command.trim_start_matches("/"); let command = command.trim_start_matches("/");
let (command, args) = command.split_once(" ").unwrap_or((&command, "")); let (command, args) = command.split_once(" ").unwrap_or((&command, ""));
let args = args.split(" ").collect::<Vec<&str>>(); let args = args.split(" ").collect::<Vec<&str>>();
if command == "clear" { if command == "clear" {
send_message(host, &format!("\r\x1B[1A{}", " ".repeat(64)).repeat(config.max_messages), disable_hiding_ip)?; send_message(ctx.clone(), &format!("\r\x1B[1A{}", " ".repeat(64)).repeat(ctx.max_messages))?;
// *input.write().unwrap() = "/ заспамлено)))".to_string();
} else if command == "spam" { } else if command == "spam" {
send_message(host, &format!("\r\x1B[1A{}{}", args.join(" "), " ".repeat(10)).repeat(config.max_messages), disable_hiding_ip)?; send_message(ctx.clone(), &format!("\r\x1B[1A{}{}", args.join(" "), " ".repeat(10)).repeat(ctx.max_messages))?;
// *input.write().unwrap() = "/ заспамлено)))".to_string();
} else if command == "help" { } else if command == "help" {
write!(stdout(), "Help message:\r write!(stdout(), "Help message:\r
/clear - clear console\r /clear - clear console\r
@ -65,6 +63,28 @@ fn on_command(config: Arc<Config>, host: &str, disable_hiding_ip: bool, command:
\r \r
Press enter to close")?; Press enter to close")?;
stdout().flush()?; stdout().flush()?;
} else if command == "ping" {
let mut before = ctx.messages.1.load(Ordering::SeqCst);
let start = SystemTime::now();
let message = format!("Checking ping... {:X}", random::<u16>());
send_message(ctx.clone(), &message)?;
loop {
let data = read_messages(ctx.clone(), before).ok().flatten();
if let Some((data, size)) = data {
if let Some(last) = data.iter().rev().find(|o| o.contains(&message)) {
println!("{}", last);
if last.contains(&message) {
break;
} else {
before = size;
}
} else {
before = size;
}
}
}
send_message(ctx.clone(), &format!("Ping = {}ms", start.elapsed().unwrap().as_millis()))?;
} }
Ok(()) Ok(())
@ -109,12 +129,32 @@ struct Args {
/// Disable ip hiding /// Disable ip hiding
#[arg(short='i', long)] #[arg(short='i', long)]
disable_ip_hiding: bool, disable_ip_hiding: bool,
/// Enable users IP viewing
#[arg(short='v', long)]
enable_users_ip_viewing: bool,
}
struct Context {
messages: Arc<(RwLock<Vec<String>>, AtomicUsize)>,
input: Arc<RwLock<String>>,
host: String,
name: String,
disable_formatting: bool,
disable_commands: bool,
disable_hiding_ip: bool,
message_format: String,
update_time: usize,
max_messages: usize,
enable_ip_viewing: bool
} }
fn main() { fn main() {
let args = Args::parse(); let args = Args::parse();
let context = {
let config_path = get_config_path(); let config_path = get_config_path();
if args.config_path { if args.config_path {
@ -122,51 +162,44 @@ fn main() {
return; return;
} }
// let start_time = SystemTime::now(); let config = load_config(config_path);
let mut config = load_config(config_path);
let name = match args.name.clone().or(config.name.clone()) { Context {
messages: Arc::new((RwLock::new(Vec::new()), AtomicUsize::new(0))),
input: Arc::new(RwLock::new(String::new())),
message_format: args.message_format.clone().unwrap_or(config.message_format.clone()),
host: args.host.clone().unwrap_or(config.host.clone()),
name: match args.name.clone().or(config.name.clone()) {
Some(i) => i, Some(i) => i,
None => { None => {
let anon_name = format!("Anon#{:X}", random::<u16>()); let anon_name = format!("Anon#{:X}", random::<u16>());
get_input(&format!("Name (default: {}) > ", anon_name)).unwrap_or(anon_name) get_input(&format!("Name (default: {}) > ", anon_name)).unwrap_or(anon_name)
}, },
},
disable_formatting: args.disable_formatting,
disable_commands: args.disable_commands,
disable_hiding_ip: args.disable_ip_hiding,
update_time: config.update_time,
max_messages: config.max_messages,
enable_ip_viewing: args.enable_users_ip_viewing || config.enable_ip_viewing
}
}; };
if let Some(host) = args.host { let context = Arc::new(context);
config.host = host;
}
if let Some(message_format) = args.message_format {
config.message_format = message_format;
}
let disable_hiding_ip = args.disable_ip_hiding;
if let Some(message) = args.send_message {
send_message(&config.host, &message, disable_hiding_ip).expect("Error sending message");
return;
}
if args.read_messages { if args.read_messages {
print!("{}", read_messages(&config.host, config.max_messages, 0).ok().flatten().expect("Error reading messages").0.join("\n")); print!("{}", read_messages(context.clone(), 0).ok().flatten().expect("Error reading messages").0.join("\n"));
}
if let Some(message) = &args.send_message {
send_message(context.clone(), message).expect("Error sending message");
}
if args.send_message.is_some() || args.read_messages {
return; return;
} }
let disable_formatting = args.disable_formatting; run_recv_loop(context.clone());
let disable_commands = args.disable_commands; run_main_loop(context.clone());
let messages = Arc::new((RwLock::new(Vec::new()), AtomicUsize::new(0)));
let input = Arc::new(RwLock::new(String::new()));
let config = Arc::new(config);
// let elapsed = start_time.elapsed().unwrap().as_millis();
// if elapsed < 1500 {
// thread::sleep(Duration::from_millis((1500 - elapsed) as u64));
// }
run_recv_loop(config.clone(), config.host.clone(), messages.clone(), input.clone(), disable_formatting);
run_main_loop(config.clone(), messages.clone(), input.clone(), config.host.clone(), name.clone(), disable_formatting, disable_commands, disable_hiding_ip);
} }

42
src/rac.rs
View File

@ -1,18 +1,18 @@
use std::{error::Error, io::{Read, Write}, net::TcpStream, sync::{atomic::{AtomicUsize, Ordering}, Arc, RwLock}, thread, time::Duration}; use std::{error::Error, io::{Read, Write}, net::TcpStream, sync::{atomic::Ordering, Arc}, thread, time::Duration};
use crate::{config::Config, term::print_console, ADVERTISEMENT, ADVERTISEMENT_ENABLED}; use super::{term::print_console, Context, ADVERTISEMENT, ADVERTISEMENT_ENABLED};
pub fn send_message(host: &str, message: &str, disable_hiding_ip: bool) -> Result<(), Box<dyn Error>> { pub fn send_message(context: Arc<Context>, message: &str) -> Result<(), Box<dyn Error>> {
let mut stream = TcpStream::connect(host)?; let mut stream = TcpStream::connect(&context.host)?;
stream.write_all(&[0x01])?; stream.write_all(&[0x01])?;
let data = format!("{}{}{}{}", let data = format!("{}{}{}{}",
if !disable_hiding_ip { if !context.disable_hiding_ip {
"\r\x07" "\r\x07"
} else { } else {
"" ""
}, },
message, message,
if !disable_hiding_ip && message.chars().count() < 39 { if !context.disable_hiding_ip && message.chars().count() < 39 {
" ".repeat(39-message.chars().count()) " ".repeat(39-message.chars().count())
} else { } else {
String::new() String::new()
@ -33,8 +33,8 @@ fn skip_null(stream: &mut TcpStream) -> Result<Vec<u8>, Box<dyn Error>> {
} }
} }
pub fn read_messages(host: &str, max_messages: usize, last_size: usize) -> Result<Option<(Vec<String>, usize)>, Box<dyn Error>> { pub fn read_messages(context: Arc<Context>, last_size: usize) -> Result<Option<(Vec<String>, usize)>, Box<dyn Error>> {
let mut stream = TcpStream::connect(host)?; let mut stream = TcpStream::connect(&context.host)?;
stream.write_all(&[0x00])?; stream.write_all(&[0x00])?;
@ -75,30 +75,28 @@ pub fn read_messages(host: &str, max_messages: usize, last_size: usize) -> Resul
let lines: Vec<&str> = packet_data.split("\n").collect(); let lines: Vec<&str> = packet_data.split("\n").collect();
let lines: Vec<String> = lines.clone().into_iter() let lines: Vec<String> = lines.clone().into_iter()
.skip(lines.len() - max_messages) .skip(lines.len() - context.max_messages)
.map(|o| o.to_string()) .map(|o| o.to_string())
.collect(); .collect();
Ok(Some((lines, packet_size))) Ok(Some((lines, packet_size)))
} }
fn recv_loop(config: Arc<Config>, host: &str, cache: Arc<(RwLock<Vec<String>>, AtomicUsize)>, input: Arc<RwLock<String>>, disable_formatting: bool) -> Result<(), Box<dyn Error>> { pub fn run_recv_loop(context: Arc<Context>) {
while let Ok(data) = read_messages(host, config.max_messages, cache.1.load(Ordering::SeqCst)) { thread::spawn({
if let Some(data) = data { let cache = context.messages.clone();
let update_time = context.update_time;
let input = context.input.clone();
move || {
loop {
if let Ok(Some(data)) = read_messages(context.clone(), cache.1.load(Ordering::SeqCst)) {
*cache.0.write().unwrap() = data.0.clone(); *cache.0.write().unwrap() = data.0.clone();
cache.1.store(data.1, Ordering::SeqCst); cache.1.store(data.1, Ordering::SeqCst);
print_console(config.clone(), data.0, &input.read().unwrap(), disable_formatting)?; print_console(context.clone(), data.0, &input.read().unwrap()).expect("Error printing console");
thread::sleep(Duration::from_millis(config.update_time as u64)); thread::sleep(Duration::from_millis(update_time as u64));
} }
} }
Ok(())
}
pub fn run_recv_loop(config: Arc<Config>, host: String, messages: Arc<(RwLock<Vec<String>>, AtomicUsize)>, input: Arc<RwLock<String>>, disable_formatting: bool) {
thread::spawn({
move || {
let _ = recv_loop(config.clone(), &host, messages, input, disable_formatting);
println!("Connection closed");
} }
}); });
} }

102
src/term.rs
View File

@ -1,21 +1,20 @@
use std::{error::Error, io::{stdout, Write}, sync::{atomic::AtomicUsize, Arc, RwLock}, time::Duration}; use std::{error::Error, io::{stdout, Write}, sync::Arc, time::Duration};
use colored::{Color, Colorize}; use colored::{Color, Colorize};
use crossterm::{cursor::MoveLeft, event::{self, Event, KeyCode, KeyModifiers, ModifierKeyCode}, terminal::{disable_raw_mode, enable_raw_mode}, ExecutableCommand}; use crossterm::{cursor::MoveLeft, event::{self, Event, KeyCode, KeyModifiers}, terminal::{disable_raw_mode, enable_raw_mode}, ExecutableCommand};
use regex::Regex; use regex::Regex;
use crate::{config::Config, on_command, rac::send_message, ADVERTISEMENT, COLORED_USERNAMES, DATE_REGEX}; use super::{on_command, rac::send_message, Context, ADVERTISEMENT, COLORED_USERNAMES, DATE_REGEX};
pub fn print_console(config: Arc<Config>, messages: Vec<String>, input: &str, disable_formatting: bool) -> Result<(), Box<dyn Error>> { pub fn print_console(context: Arc<Context>, messages: Vec<String>, input: &str) -> Result<(), Box<dyn Error>> {
let text = format!( let text = format!(
"{}{}\n> {}", "{}{}\n> {}",
"\n".repeat(config.max_messages - messages.len()), "\n".repeat(context.max_messages - messages.len()),
if disable_formatting { if context.disable_formatting {
messages messages
} else { } else {
messages.into_iter().filter_map(format_message).collect() messages.into_iter().filter_map(|o| format_message(context.clone(), o)).collect()
}.join("\n"), }.join("\n"),
// if sound { "\x07" } else { "" },
input input
); );
for line in text.lines() { for line in text.lines() {
@ -25,9 +24,8 @@ pub fn print_console(config: Arc<Config>, messages: Vec<String>, input: &str, di
Ok(()) Ok(())
} }
fn format_message(message: String) -> Option<String> { fn format_message(ctx: Arc<Context>, message: String) -> Option<String> {
let message = message.trim_end_matches(ADVERTISEMENT); let message = message.trim_end_matches(ADVERTISEMENT);
let message = Regex::new(r"\{[^}]*\}\ ").unwrap().replace(&message, "").to_string();
let message = sanitize_text(&message); let message = sanitize_text(&message);
if ADVERTISEMENT.len() > 0 && if ADVERTISEMENT.len() > 0 &&
message.starts_with(ADVERTISEMENT message.starts_with(ADVERTISEMENT
@ -37,7 +35,17 @@ fn format_message(message: String) -> Option<String> {
} }
let date = DATE_REGEX.captures(&message)?; let date = DATE_REGEX.captures(&message)?;
let (date, message) = (date.get(1)?.as_str().to_string(), date.get(2)?.as_str().to_string()); let (date, ip, message) = (
date.get(1)?.as_str().to_string(),
date.get(2)?.as_str().to_string(),
date.get(3)?.as_str().to_string()
);
let prefix = if ctx.enable_ip_viewing {
format!("{}{} [{}]", ip, " ".repeat(15-ip.len()), date)
} else {
format!("[{}]", date)
};
Some(if let Some(captures) = find_username_color(&message) { Some(if let Some(captures) = find_username_color(&message) {
let nick = captures.0; let nick = captures.0;
@ -46,14 +54,14 @@ fn format_message(message: String) -> Option<String> {
format!( format!(
"{} {} {}", "{} {} {}",
format!("[{}]", date).white().dimmed(), prefix.white().dimmed(),
format!("<{}>", nick).color(color).bold(), format!("<{}>", nick).color(color).bold(),
content.white().blink() content.white().blink()
) )
} else { } else {
format!( format!(
"{} {}", "{} {}",
format!("[{}]", date).white().dimmed(), prefix.white().dimmed(),
message.white().blink() message.white().blink()
) )
}) })
@ -67,7 +75,6 @@ fn sanitize_text(input: &str) -> String {
cleaned_text.into_owned() cleaned_text.into_owned()
} }
/// nick content nick_color
fn find_username_color(message: &str) -> Option<(String, String, Color)> { fn find_username_color(message: &str) -> Option<(String, String, Color)> {
for (re, color) in COLORED_USERNAMES.iter() { for (re, color) in COLORED_USERNAMES.iter() {
if let Some(captures) = re.captures(message) { if let Some(captures) = re.captures(message) {
@ -77,16 +84,7 @@ fn find_username_color(message: &str) -> Option<(String, String, Color)> {
None None
} }
fn poll_events( fn poll_events(ctx: Arc<Context>) {
config: Arc<Config>,
input: Arc<RwLock<String>>,
messages: Arc<(RwLock<Vec<String>>, AtomicUsize)>,
host: String,
name: String,
disable_formatting: bool,
disable_commands: bool,
disable_hiding_ip: bool
) {
loop { loop {
if !event::poll(Duration::from_millis(50)).unwrap_or(false) { continue } if !event::poll(Duration::from_millis(50)).unwrap_or(false) { continue }
@ -99,10 +97,10 @@ fn poll_events(
Event::Key(event) => { Event::Key(event) => {
match event.code { match event.code {
KeyCode::Enter => { KeyCode::Enter => {
let message = input.read().unwrap().clone(); let message = ctx.input.read().unwrap().clone();
if !message.is_empty() { if !message.is_empty() {
let input_len = input.read().unwrap().chars().count(); let input_len = ctx.input.read().unwrap().chars().count();
write!(stdout(), write!(stdout(),
"{}{}{}", "{}{}{}",
MoveLeft(1).to_string().repeat(input_len), MoveLeft(1).to_string().repeat(input_len),
@ -110,25 +108,24 @@ fn poll_events(
MoveLeft(1).to_string().repeat(input_len) MoveLeft(1).to_string().repeat(input_len)
).unwrap(); ).unwrap();
stdout().lock().flush().unwrap(); stdout().lock().flush().unwrap();
input.write().unwrap().clear(); ctx.input.write().unwrap().clear();
if message.starts_with("/") && !disable_commands { if message.starts_with("/") && !ctx.disable_commands {
on_command(config.clone(), &host, disable_hiding_ip, &message).expect("Error on command"); on_command(ctx.clone(), &message).expect("Error on command");
} else { } else {
let message = config.message_format.replace("{name}", &name).replace("{text}", &message); let message = ctx.message_format.replace("{name}", &ctx.name).replace("{text}", &message);
send_message(&host, &message, disable_hiding_ip).expect("Error sending message"); send_message(ctx.clone(), &message).expect("Error sending message");
} }
} else { } else {
print_console( print_console(
config.clone(), ctx.clone(),
messages.0.read().unwrap().clone(), ctx.messages.0.read().unwrap().clone(),
&input.read().unwrap(), &ctx.input.read().unwrap()
disable_formatting
).expect("Error printing console"); ).expect("Error printing console");
} }
} }
KeyCode::Backspace => { KeyCode::Backspace => {
if input.write().unwrap().pop().is_some() { if ctx.input.write().unwrap().pop().is_some() {
stdout().lock().execute(MoveLeft(1)).unwrap(); stdout().lock().execute(MoveLeft(1)).unwrap();
write!(stdout(), " {}", MoveLeft(1).to_string()).unwrap(); write!(stdout(), " {}", MoveLeft(1).to_string()).unwrap();
stdout().lock().flush().unwrap(); stdout().lock().flush().unwrap();
@ -143,7 +140,7 @@ fn poll_events(
disable_raw_mode().unwrap(); disable_raw_mode().unwrap();
break; break;
} }
input.write().unwrap().push(c); ctx.input.write().unwrap().push(c);
write!(stdout(), "{}", c).unwrap(); write!(stdout(), "{}", c).unwrap();
stdout().lock().flush().unwrap(); stdout().lock().flush().unwrap();
} }
@ -151,7 +148,7 @@ fn poll_events(
} }
}, },
Event::Paste(data) => { Event::Paste(data) => {
input.write().unwrap().push_str(&data); ctx.input.write().unwrap().push_str(&data);
write!(stdout(), "{}", &data).unwrap(); write!(stdout(), "{}", &data).unwrap();
stdout().lock().flush().unwrap(); stdout().lock().flush().unwrap();
} }
@ -160,32 +157,7 @@ fn poll_events(
} }
} }
pub fn run_main_loop( pub fn run_main_loop(ctx: Arc<Context>) {
config: Arc<Config>,
messages: Arc<(RwLock<Vec<String>>, AtomicUsize)>,
input: Arc<RwLock<String>>,
host: String,
name: String,
disable_formatting: bool,
disable_commands: bool,
disable_hiding_ip: bool
) {
enable_raw_mode().unwrap(); enable_raw_mode().unwrap();
poll_events(ctx);
// thread::spawn({
// let messages = messages.clone();
// let input = input.clone();
// move || {
// loop {
// print_console(
// &messages.read().unwrap(),
// &input.read().unwrap()
// ).expect("Error printing console");
// thread::sleep(Duration::from_secs(5));
// }
// }
// });
poll_events(config, input.clone(), messages.clone(), host, name, disable_formatting, disable_commands, disable_hiding_ip);
} }