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};
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) {
@ -18,7 +18,7 @@ fn one_param_op(opcode: u8, stream: &mut TcpStream, param: &str) {
for i in 1..param.len() + 1 {
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) {
@ -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();
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>>) {
@ -94,8 +94,8 @@ fn process_message(msg_bytes: &[u8], nick: &str) {
}
codes::MESSAGE_ROOM => {
let params = String::from_utf8(msg_bytes[1..msg_bytes.len()].to_vec()).unwrap();
match params.split_once(" ") {
Some((room, remainder)) => match remainder.split_once(" ") {
match params.split_once(' ') {
Some((room, remainder)) => match remainder.split_once(' ') {
Some((user, msg)) => {
if user != nick {
println!("[{}]:[{}]: {}", room, user, msg);
@ -150,7 +150,7 @@ pub fn start() {
let mut nick: String;
loop {
nick = input!("Enter your nickname : ");
if nick.contains(" ") {
if nick.contains(' ') {
println!("May not contain spaces . Try again");
} else if nick.is_empty() {
println!("May not be empty . Try again");
@ -196,9 +196,9 @@ pub fn start() {
loop {
let inp: String = input!("");
match inp.split_once(" ") {
match inp.split_once(' ') {
Some((cmd, param)) => match cmd {
"/list" => match param.split_once(" ") {
"/list" => match param.split_once(' ') {
Some((_, _)) => {
eprintln!("Malformaed. Try /list [room-name]");
}
@ -206,7 +206,7 @@ pub fn start() {
one_param_op(codes::LIST_USERS_IN_ROOM, &mut stream, param);
}
},
"/join" => match param.split_once(" ") {
"/join" => match param.split_once(' ') {
Some((_, _)) => {
eprintln!("Malformed. Try /join [room-name]");
}
@ -215,7 +215,7 @@ pub fn start() {
}
},
"/leave" => match param.split_once(" ") {
"/leave" => match param.split_once(' ') {
Some((_, _)) => {
eprintln!("Malformed. Try /leave [room-name]");
}
@ -223,7 +223,7 @@ pub fn start() {
one_param_op(codes::LEAVE_ROOM, &mut stream, param);
}
},
"/msg" => match param.split_once(" ") {
"/msg" => match param.split_once(' ') {
Some((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 {
Some(str) => {
println!("Sending msg {:?}", out_buf.to_ascii_lowercase());
str.write_all(&out_buf).unwrap();
str.write_all(out_buf).unwrap();
}
None => {
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> =
guard.users.values_mut();
users.for_each(|user: &mut TcpStream| {
user.write(&[codes::QUIT]).unwrap();
user.write_all(&[codes::QUIT]).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 mut buf_out: Vec<u8> = Vec::new();
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(SPACE_BYTES);
}
stream.write(&buf_out).unwrap();
stream.write_all(&buf_out).unwrap();
}
codes::LIST_USERS => {
let unlocked_server: std::sync::MutexGuard<'_, Server> = server.lock().unwrap();
let mut buf_out: Vec<u8> = Vec::new();
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(SPACE_BYTES);
}
stream.write(&buf_out).unwrap();
stream.write_all(&buf_out).unwrap();
}
codes::LIST_USERS_IN_ROOM => {
@ -188,22 +188,22 @@ fn handle_client(
codes::JOIN_ROOM => {
let p: String = String::from_utf8_lossy(param_bytes).to_string();
let params: Vec<&str> = p.split_whitespace().collect();
let room = params.get(0).unwrap();
join_room(server, &nickname, room, stream);
let room = params.first().unwrap();
join_room(server, nickname, room, stream);
}
codes::LEAVE_ROOM => {
let p: String = String::from_utf8_lossy(param_bytes).to_string();
let params: Vec<&str> = p.split_whitespace().collect();
let room = params.get(0).unwrap();
leave_room(server, &nickname, room, stream);
let room = params.first().unwrap();
leave_room(server, nickname, room, stream);
}
//Generic message sent to all users of all rooms the clients nickname is in, except the client nickname
codes::MESSAGE => {
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();
}
@ -214,20 +214,20 @@ fn handle_client(
//A message sent just to the users of the room passed in, except the client nickname
codes::MESSAGE_ROOM => {
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 {
Some((room, msg)) => {
message_room(room, msg, nickname, server);
}
_ => {
stream
.write(&[codes::ERROR, codes::error::MALFORMED])
.write_all(&[codes::ERROR, codes::error::MALFORMED])
.unwrap();
}
}
}
codes::QUIT => {
remove_user(server, nickname, stream);
remove_user(server, nickname);
}
_ => {
#[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(
server: &Arc<Mutex<Server>>,
sender: &str,
@ -265,7 +266,7 @@ fn message_all_senders_rooms(
for user in users {
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();
}
}
@ -274,10 +275,10 @@ fn message_all_senders_rooms(
}
/// 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 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>| {
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) {
Some(l) => {
for ele in l.into_iter() {
for ele in l.iter_mut() {
if ele == user {
stream
.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) => {
let before_len: usize = l.len();
l.retain(|item: &String| item != user);
if l.len() == 0 {
if l.is_empty() {
unlocked_server.rooms.remove(room);
drop(unlocked_server);
let rooms: Vec<String> = get_rooms_of_user(server, user);
@ -413,15 +414,12 @@ pub fn start() {
thread::spawn(move || {
let nickname: String;
println!(
"IP {} has connected",
stream.peer_addr().unwrap().to_string()
);
println!("IP {} has connected", stream.peer_addr().unwrap());
match stream.read(&mut buf_in) {
Ok(0) => {
println!(
"IP {} has closed the connection",
stream.peer_addr().unwrap().to_string()
stream.peer_addr().unwrap()
);
}
Ok(size) => {
@ -434,12 +432,8 @@ pub fn start() {
loop {
match stream.read(&mut buf_in) {
Ok(0) => {
println!("IP {} with nickname {} has closed the connection", stream.peer_addr().unwrap().to_string(), nickname);
remove_user(
&server_inner,
&nickname,
&mut stream,
);
println!("IP {} with nickname {} has closed the connection", stream.peer_addr().unwrap(), nickname);
remove_user(&server_inner, &nickname);
break;
}
Ok(size) => {
@ -456,7 +450,7 @@ pub fn start() {
}
Err(_) => {
eprintln!("Error parsing client");
stream.write(&[codes::QUIT]).unwrap();
stream.write_all(&[codes::QUIT]).unwrap();
break;
}
}
@ -472,7 +466,7 @@ pub fn start() {
}
Err(_) => {
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);
}
4 => {
let s1 = server.lock().unwrap();
let s2 = server.lock().unwrap();
let _s1: std::sync::MutexGuard<'_, Server> = server.lock().unwrap();
let _s2: std::sync::MutexGuard<'_, Server> = server.lock().unwrap();
}
_ => println!("Invalid Input"),
},