david/rust-irc
Archived
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

clippy fixes

Browse Source
This commit is contained in:
David Westgate 2023-12-03 15:57:51 -08:00
parent 2dea995c5d
commit c1d3f48fa3
2 changed files with 39 additions and 45 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
src/client.rs
View File

@ -7,7 +7,7 @@ use std::thread;
use std::time::{Duration, Instant}; use std::time::{Duration, Instant};
fn no_param_op(opcode: u8, stream: &mut TcpStream) { fn no_param_op(opcode: u8, stream: &mut TcpStream) {
stream.write(&[opcode]).unwrap(); stream.write_all(&[opcode]).unwrap();
} }
fn one_param_op(opcode: u8, stream: &mut TcpStream, param: &str) { fn one_param_op(opcode: u8, stream: &mut TcpStream, param: &str) {
@ -18,7 +18,7 @@ fn one_param_op(opcode: u8, stream: &mut TcpStream, param: &str) {
for i in 1..param.len() + 1 { for i in 1..param.len() + 1 {
out_buf[i] = *param.as_bytes().get(i - 1).unwrap(); out_buf[i] = *param.as_bytes().get(i - 1).unwrap();
} }
stream.write(&out_buf).unwrap(); stream.write_all(&out_buf).unwrap();
} }
fn two_param_op(opcode: u8, stream: &mut TcpStream, param0: &str, param1: &str) { fn two_param_op(opcode: u8, stream: &mut TcpStream, param0: &str, param1: &str) {
@ -37,7 +37,7 @@ fn two_param_op(opcode: u8, stream: &mut TcpStream, param0: &str, param1: &str)
out_buf[byte] = *param1.as_bytes().get(i).unwrap(); out_buf[byte] = *param1.as_bytes().get(i).unwrap();
byte += 1; byte += 1;
} }
stream.write(&out_buf).unwrap(); stream.write_all(&out_buf).unwrap();
} }
fn read_messages(mut stream: TcpStream, nick: &str, timestamp: &mut Arc<Mutex<Instant>>) { fn read_messages(mut stream: TcpStream, nick: &str, timestamp: &mut Arc<Mutex<Instant>>) {
@ -94,8 +94,8 @@ fn process_message(msg_bytes: &[u8], nick: &str) {
} }
codes::MESSAGE_ROOM => { codes::MESSAGE_ROOM => {
let params = String::from_utf8(msg_bytes[1..msg_bytes.len()].to_vec()).unwrap(); let params = String::from_utf8(msg_bytes[1..msg_bytes.len()].to_vec()).unwrap();
match params.split_once(" ") { match params.split_once(' ') {
Some((room, remainder)) => match remainder.split_once(" ") { Some((room, remainder)) => match remainder.split_once(' ') {
Some((user, msg)) => { Some((user, msg)) => {
if user != nick { if user != nick {
println!("[{}]:[{}]: {}", room, user, msg); println!("[{}]:[{}]: {}", room, user, msg);
@ -150,7 +150,7 @@ pub fn start() {
let mut nick: String; let mut nick: String;
loop { loop {
nick = input!("Enter your nickname : "); nick = input!("Enter your nickname : ");
if nick.contains(" ") { if nick.contains(' ') {
println!("May not contain spaces . Try again"); println!("May not contain spaces . Try again");
} else if nick.is_empty() { } else if nick.is_empty() {
println!("May not be empty . Try again"); println!("May not be empty . Try again");
@ -196,9 +196,9 @@ pub fn start() {
loop { loop {
let inp: String = input!(""); let inp: String = input!("");
match inp.split_once(" ") { match inp.split_once(' ') {
Some((cmd, param)) => match cmd { Some((cmd, param)) => match cmd {
"/list" => match param.split_once(" ") { "/list" => match param.split_once(' ') {
Some((_, _)) => { Some((_, _)) => {
eprintln!("Malformaed. Try /list [room-name]"); eprintln!("Malformaed. Try /list [room-name]");
} }
@ -206,7 +206,7 @@ pub fn start() {
one_param_op(codes::LIST_USERS_IN_ROOM, &mut stream, param); one_param_op(codes::LIST_USERS_IN_ROOM, &mut stream, param);
} }
}, },
"/join" => match param.split_once(" ") { "/join" => match param.split_once(' ') {
Some((_, _)) => { Some((_, _)) => {
eprintln!("Malformed. Try /join [room-name]"); eprintln!("Malformed. Try /join [room-name]");
} }
@ -215,7 +215,7 @@ pub fn start() {
} }
}, },
"/leave" => match param.split_once(" ") { "/leave" => match param.split_once(' ') {
Some((_, _)) => { Some((_, _)) => {
eprintln!("Malformed. Try /leave [room-name]"); eprintln!("Malformed. Try /leave [room-name]");
} }
@ -223,7 +223,7 @@ pub fn start() {
one_param_op(codes::LEAVE_ROOM, &mut stream, param); one_param_op(codes::LEAVE_ROOM, &mut stream, param);
} }
}, },
"/msg" => match param.split_once(" ") { "/msg" => match param.split_once(' ') {
Some((room, msg)) => { Some((room, msg)) => {
two_param_op(codes::MESSAGE_ROOM, &mut stream, room, msg); two_param_op(codes::MESSAGE_ROOM, &mut stream, room, msg);
} }

62
src/server.rs
View File

@ -79,7 +79,7 @@ fn message_room(room: &str, msg: &str, sender: &str, server: &Arc<Mutex<Server>>
match recipient_stream { match recipient_stream {
Some(str) => { Some(str) => {
println!("Sending msg {:?}", out_buf.to_ascii_lowercase()); println!("Sending msg {:?}", out_buf.to_ascii_lowercase());
str.write_all(&out_buf).unwrap(); str.write_all(out_buf).unwrap();
} }
None => { None => {
eprintln!("Server error: could not find user"); eprintln!("Server error: could not find user");
@ -123,7 +123,7 @@ fn disconnect_all(server: &Arc<Mutex<Server>>) {
let users: std::collections::hash_map::ValuesMut<'_, String, TcpStream> = let users: std::collections::hash_map::ValuesMut<'_, String, TcpStream> =
guard.users.values_mut(); guard.users.values_mut();
users.for_each(|user: &mut TcpStream| { users.for_each(|user: &mut TcpStream| {
user.write(&[codes::QUIT]).unwrap(); user.write_all(&[codes::QUIT]).unwrap();
user.shutdown(std::net::Shutdown::Both).unwrap(); user.shutdown(std::net::Shutdown::Both).unwrap();
}) })
} }
@ -146,22 +146,22 @@ fn handle_client(
let unlocked_server: std::sync::MutexGuard<'_, Server> = server.lock().unwrap(); let unlocked_server: std::sync::MutexGuard<'_, Server> = server.lock().unwrap();
let mut buf_out: Vec<u8> = Vec::new(); let mut buf_out: Vec<u8> = Vec::new();
buf_out.extend_from_slice(&[codes::RESPONSE]); buf_out.extend_from_slice(&[codes::RESPONSE]);
for (room, _user) in &unlocked_server.rooms { for room in unlocked_server.rooms.keys() {
buf_out.extend_from_slice(room.as_bytes()); buf_out.extend_from_slice(room.as_bytes());
buf_out.extend_from_slice(SPACE_BYTES); buf_out.extend_from_slice(SPACE_BYTES);
} }
stream.write(&buf_out).unwrap(); stream.write_all(&buf_out).unwrap();
} }
codes::LIST_USERS => { codes::LIST_USERS => {
let unlocked_server: std::sync::MutexGuard<'_, Server> = server.lock().unwrap(); let unlocked_server: std::sync::MutexGuard<'_, Server> = server.lock().unwrap();
let mut buf_out: Vec<u8> = Vec::new(); let mut buf_out: Vec<u8> = Vec::new();
buf_out.extend_from_slice(&[codes::RESPONSE]); buf_out.extend_from_slice(&[codes::RESPONSE]);
for (user, _) in &unlocked_server.users { for user in unlocked_server.users.keys() {
buf_out.extend_from_slice(user.as_bytes()); buf_out.extend_from_slice(user.as_bytes());
buf_out.extend_from_slice(SPACE_BYTES); buf_out.extend_from_slice(SPACE_BYTES);
} }
stream.write(&buf_out).unwrap(); stream.write_all(&buf_out).unwrap();
} }
codes::LIST_USERS_IN_ROOM => { codes::LIST_USERS_IN_ROOM => {
@ -188,22 +188,22 @@ fn handle_client(
codes::JOIN_ROOM => { codes::JOIN_ROOM => {
let p: String = String::from_utf8_lossy(param_bytes).to_string(); let p: String = String::from_utf8_lossy(param_bytes).to_string();
let params: Vec<&str> = p.split_whitespace().collect(); let params: Vec<&str> = p.split_whitespace().collect();
let room = params.get(0).unwrap(); let room = params.first().unwrap();
join_room(server, &nickname, room, stream); join_room(server, nickname, room, stream);
} }
codes::LEAVE_ROOM => { codes::LEAVE_ROOM => {
let p: String = String::from_utf8_lossy(param_bytes).to_string(); let p: String = String::from_utf8_lossy(param_bytes).to_string();
let params: Vec<&str> = p.split_whitespace().collect(); let params: Vec<&str> = p.split_whitespace().collect();
let room = params.get(0).unwrap(); let room = params.first().unwrap();
leave_room(server, &nickname, room, stream); leave_room(server, nickname, room, stream);
} }
//Generic message sent to all users of all rooms the clients nickname is in, except the client nickname //Generic message sent to all users of all rooms the clients nickname is in, except the client nickname
codes::MESSAGE => { codes::MESSAGE => {
let p: String = String::from_utf8_lossy(param_bytes).to_string(); let p: String = String::from_utf8_lossy(param_bytes).to_string();
message_all_senders_rooms(server, &nickname, &p, stream); message_all_senders_rooms(server, nickname, &p, stream);
stream.write_all(&[codes::RESPONSE_OK]).unwrap(); stream.write_all(&[codes::RESPONSE_OK]).unwrap();
} }
@ -214,20 +214,20 @@ fn handle_client(
//A message sent just to the users of the room passed in, except the client nickname //A message sent just to the users of the room passed in, except the client nickname
codes::MESSAGE_ROOM => { codes::MESSAGE_ROOM => {
let p: String = String::from_utf8_lossy(param_bytes).to_string(); let p: String = String::from_utf8_lossy(param_bytes).to_string();
let params: Option<(&str, &str)> = p.split_once(" "); let params: Option<(&str, &str)> = p.split_once(' ');
match params { match params {
Some((room, msg)) => { Some((room, msg)) => {
message_room(room, msg, nickname, server); message_room(room, msg, nickname, server);
} }
_ => { _ => {
stream stream
.write(&[codes::ERROR, codes::error::MALFORMED]) .write_all(&[codes::ERROR, codes::error::MALFORMED])
.unwrap(); .unwrap();
} }
} }
} }
codes::QUIT => { codes::QUIT => {
remove_user(server, nickname, stream); remove_user(server, nickname);
} }
_ => { _ => {
#[cfg(debug_assertions)] #[cfg(debug_assertions)]
@ -238,6 +238,7 @@ fn handle_client(
// } // }
} }
/// Send a message to all of the rooms the given sender has joined.
fn message_all_senders_rooms( fn message_all_senders_rooms(
server: &Arc<Mutex<Server>>, server: &Arc<Mutex<Server>>,
sender: &str, sender: &str,
@ -265,7 +266,7 @@ fn message_all_senders_rooms(
for user in users { for user in users {
if !user.eq(sender) { if !user.eq(sender) {
let stream = guard.users.get_mut(&user); let stream: Option<&mut TcpStream> = guard.users.get_mut(&user);
stream.unwrap().write_all(out_buf).unwrap(); stream.unwrap().write_all(out_buf).unwrap();
} }
} }
@ -274,10 +275,10 @@ fn message_all_senders_rooms(
} }
/// Remove a user from any rooms they may be in, then drop the user /// Remove a user from any rooms they may be in, then drop the user
fn remove_user(server: &Arc<Mutex<Server>>, nickname: &str, stream: &mut TcpStream) { fn remove_user(server: &Arc<Mutex<Server>>, nickname: &str) {
let mut guard: std::sync::MutexGuard<'_, Server> = server.lock().unwrap(); let mut guard: std::sync::MutexGuard<'_, Server> = server.lock().unwrap();
let server: &mut Server = guard.deref_mut(); let server: &mut Server = guard.deref_mut();
let mut rooms: &mut HashMap<String, Vec<String>> = &mut server.rooms; let rooms: &mut HashMap<String, Vec<String>> = &mut server.rooms;
rooms.values_mut().for_each(|room: &mut Vec<String>| { rooms.values_mut().for_each(|room: &mut Vec<String>| {
room.retain(|u: &String| !u.eq(nickname)); room.retain(|u: &String| !u.eq(nickname));
}); });
@ -311,7 +312,7 @@ fn join_room(server: &Arc<Mutex<Server>>, user: &str, room: &str, stream: &mut T
match unlocked_server.rooms.get_mut(room) { match unlocked_server.rooms.get_mut(room) {
Some(l) => { Some(l) => {
for ele in l.into_iter() { for ele in l.iter_mut() {
if ele == user { if ele == user {
stream stream
.write_all(&[codes::ERROR, codes::error::ALREADY_IN_ROOM]) .write_all(&[codes::ERROR, codes::error::ALREADY_IN_ROOM])
@ -344,7 +345,7 @@ fn leave_room(server: &Arc<Mutex<Server>>, user: &str, room: &str, stream: &mut
Some(l) => { Some(l) => {
let before_len: usize = l.len(); let before_len: usize = l.len();
l.retain(|item: &String| item != user); l.retain(|item: &String| item != user);
if l.len() == 0 { if l.is_empty() {
unlocked_server.rooms.remove(room); unlocked_server.rooms.remove(room);
drop(unlocked_server); drop(unlocked_server);
let rooms: Vec<String> = get_rooms_of_user(server, user); let rooms: Vec<String> = get_rooms_of_user(server, user);
@ -413,15 +414,12 @@ pub fn start() {
thread::spawn(move || { thread::spawn(move || {
let nickname: String; let nickname: String;
println!( println!("IP {} has connected", stream.peer_addr().unwrap());
"IP {} has connected",
stream.peer_addr().unwrap().to_string()
);
match stream.read(&mut buf_in) { match stream.read(&mut buf_in) {
Ok(0) => { Ok(0) => {
println!( println!(
"IP {} has closed the connection", "IP {} has closed the connection",
stream.peer_addr().unwrap().to_string() stream.peer_addr().unwrap()
); );
} }
Ok(size) => { Ok(size) => {
@ -434,12 +432,8 @@ pub fn start() {
loop { loop {
match stream.read(&mut buf_in) { match stream.read(&mut buf_in) {
Ok(0) => { Ok(0) => {
println!("IP {} with nickname {} has closed the connection", stream.peer_addr().unwrap().to_string(), nickname); println!("IP {} with nickname {} has closed the connection", stream.peer_addr().unwrap(), nickname);
remove_user( remove_user(&server_inner, &nickname);
&server_inner,
&nickname,
&mut stream,
);
break; break;
} }
Ok(size) => { Ok(size) => {
@ -456,7 +450,7 @@ pub fn start() {
} }
Err(_) => { Err(_) => {
eprintln!("Error parsing client"); eprintln!("Error parsing client");
stream.write(&[codes::QUIT]).unwrap(); stream.write_all(&[codes::QUIT]).unwrap();
break; break;
} }
} }
@ -472,7 +466,7 @@ pub fn start() {
} }
Err(_) => { Err(_) => {
eprintln!("Error parsing client"); eprintln!("Error parsing client");
stream.write(&[codes::QUIT]).unwrap(); stream.write_all(&[codes::QUIT]).unwrap();
} }
} }
}); });
@ -506,8 +500,8 @@ pub fn start() {
broadcast(codes::MESSAGE, &server, &inp2); broadcast(codes::MESSAGE, &server, &inp2);
} }
4 => { 4 => {
let s1 = server.lock().unwrap(); let _s1: std::sync::MutexGuard<'_, Server> = server.lock().unwrap();
let s2 = server.lock().unwrap(); let _s2: std::sync::MutexGuard<'_, Server> = server.lock().unwrap();
} }
_ => println!("Invalid Input"), _ => println!("Invalid Input"),
}, },