vel
/
VelNet-Server
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

moved timeout to config

asyncversion
Kyle Johnsen 2022-03-18 16:33:35 -04:00
parent 792054749f
commit 85cc1d5a39
2 changed files with 38 additions and 39 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
config.txt
View File

@ -1,5 +1,4 @@
{ {
"port":5000, "port":5000,
"tcp_timeout":30, "tcp_timeout":30
"tcp_send_buffer":100000
} }

74
src/main.rs
View File

@ -160,8 +160,8 @@ async fn process_client(socket: TcpStream, udp_socket: Rc<RefCell<UdpSocket>>, c
} }
let read_async = client_read(client.clone(), socket.clone(), clients.clone(), rooms.clone()).fuse(); let read_async = client_read(client.clone(), socket.clone(), clients.clone(), rooms.clone(), config.tcp_timeout*1000).fuse();
let write_async = client_write(client.clone(), socket, client_notify.clone()).fuse(); let write_async = client_write(client.clone(), socket, client_notify.clone(), config.tcp_timeout*1000).fuse();
let write_async_udp = client_write_udp(client.clone(), udp_socket.clone(), client_notify_udp.clone()).fuse(); let write_async_udp = client_write_udp(client.clone(), udp_socket.clone(), client_notify_udp.clone()).fuse();
pin_mut!(read_async,write_async,write_async_udp); //not sure why this is necessary, since select pin_mut!(read_async,write_async,write_async_udp); //not sure why this is necessary, since select
@ -208,19 +208,19 @@ async fn read_timeout(mut socket: &TcpStream, buf: &mut [u8], duration: u64) ->
} }
async fn client_read(client: Rc<RefCell<Client>>, mut socket: TcpStream, clients: Rc<RefCell<HashMap<u32, Rc<RefCell<Client>>>>>, rooms: Rc<RefCell<HashMap<String, Rc<RefCell<Room>>>>>){ async fn client_read(client: Rc<RefCell<Client>>, mut socket: TcpStream, clients: Rc<RefCell<HashMap<u32, Rc<RefCell<Client>>>>>, rooms: Rc<RefCell<HashMap<String, Rc<RefCell<Room>>>>>, duration: u64){
let mut buf = [0; 1]; let mut buf = [0; 1];
loop { loop {
match read_timeout(&mut socket, &mut buf, 5000).await { match read_timeout(&mut socket, &mut buf, duration).await {
Ok(_) => { Ok(_) => {
let t = buf[0]; let t = buf[0];
if t == FromClientTCPMessageType::LogIn as u8 { //[0:u8][username.length():u8][username:shortstring][password.length():u8][password:shortstring] if t == FromClientTCPMessageType::LogIn as u8 { //[0:u8][username.length():u8][username:shortstring][password.length():u8][password:shortstring]
match read_login_message(socket.clone(), client.clone()).await{ match read_login_message(socket.clone(), client.clone(), duration).await{
Ok(_)=>(), Ok(_)=>(),
Err(_)=>{eprintln!("failed to read from socket"); return;} Err(_)=>{eprintln!("failed to read from socket"); return;}
}; };
@ -230,12 +230,12 @@ async fn client_read(client: Rc<RefCell<Client>>, mut socket: TcpStream, clients
Err(_)=>{eprintln!("failed to read from socket"); return;} Err(_)=>{eprintln!("failed to read from socket"); return;}
}; };
} else if t == FromClientTCPMessageType::GetRoomData as u8 { } else if t == FromClientTCPMessageType::GetRoomData as u8 {
match read_roomdata_message(socket.clone(), client.clone(), rooms.clone()).await{ match read_roomdata_message(socket.clone(), client.clone(), rooms.clone(), duration).await{
Ok(_)=>(), Ok(_)=>(),
Err(_)=>{eprintln!("failed to read from socket"); return;} Err(_)=>{eprintln!("failed to read from socket"); return;}
}; };
} else if t == FromClientTCPMessageType::JoinRoom as u8 {//[2:u8][roomname.length():u8][roomname:shortstring] } else if t == FromClientTCPMessageType::JoinRoom as u8 {//[2:u8][roomname.length():u8][roomname:shortstring]
match read_join_message(socket.clone(), client.clone(), rooms.clone()).await{ match read_join_message(socket.clone(), client.clone(), rooms.clone(), duration).await{
Ok(_)=>(), Ok(_)=>(),
Err(_)=>{eprintln!("failed to read from socket"); return;} Err(_)=>{eprintln!("failed to read from socket"); return;}
}; };
@ -244,12 +244,12 @@ async fn client_read(client: Rc<RefCell<Client>>, mut socket: TcpStream, clients
t == FromClientTCPMessageType::SendMessageGroupUnbuffered as u8 || t == FromClientTCPMessageType::SendMessageGroupUnbuffered as u8 ||
t == FromClientTCPMessageType::SendMessageOthersBuffered as u8 || t == FromClientTCPMessageType::SendMessageOthersBuffered as u8 ||
t == FromClientTCPMessageType::SendMessageAllBuffered as u8 { //others,all,group[t:u8][message.length():i32][message:u8array] t == FromClientTCPMessageType::SendMessageAllBuffered as u8 { //others,all,group[t:u8][message.length():i32][message:u8array]
match read_send_message(socket.clone(), client.clone(), rooms.clone(), t).await{ match read_send_message(socket.clone(), client.clone(), rooms.clone(), t, duration).await{
Ok(_)=>(), Ok(_)=>(),
Err(_)=>{eprintln!("failed to read from socket"); return;} Err(_)=>{eprintln!("failed to read from socket"); return;}
}; };
} else if t == FromClientTCPMessageType::CreateGroup as u8 { //[t:u8][list.lengthbytes:i32][clients:i32array] } else if t == FromClientTCPMessageType::CreateGroup as u8 { //[t:u8][list.lengthbytes:i32][clients:i32array]
match read_group_message(socket.clone(), client.clone(), clients.clone()).await{ match read_group_message(socket.clone(), client.clone(), clients.clone(),duration).await{
Ok(_)=>(), Ok(_)=>(),
Err(_)=>{eprintln!("failed to read from socket"); return;} Err(_)=>{eprintln!("failed to read from socket"); return;}
}; };
@ -296,7 +296,7 @@ async fn write_timeout(mut socket: &TcpStream, buf: &[u8], duration: u64) -> Res
} }
async fn client_write(client: Rc<RefCell<Client>>, mut socket: TcpStream, notify: Rc<Notify>){ async fn client_write(client: Rc<RefCell<Client>>, mut socket: TcpStream, notify: Rc<Notify>,duration:u64){
//wait on messages in my queue //wait on messages in my queue
loop { loop {
@ -314,7 +314,7 @@ async fn client_write(client: Rc<RefCell<Client>>, mut socket: TcpStream, notify
client_ref.message_queue.clear(); client_ref.message_queue.clear();
} }
match write_timeout(&mut socket, &to_write, 5000).await { match write_timeout(&mut socket, &to_write, duration).await {
Ok(_) => (), Ok(_) => (),
Err(_) => {eprintln!("failed to write to the tcp socket"); return;} Err(_) => {eprintln!("failed to write to the tcp socket"); return;}
} }
@ -498,11 +498,11 @@ async fn process_udp(socket: Rc<RefCell<UdpSocket>>,clients: Rc<RefCell<HashMap<
} }
//this is in response to someone asking to login (this is where usernames and passwords would be processed, in theory) //this is in response to someone asking to login (this is where usernames and passwords would be processed, in theory)
async fn read_login_message(mut stream: TcpStream, client: Rc<RefCell<Client>>) -> Result<(),Box<dyn Error>>{ async fn read_login_message(mut stream: TcpStream, client: Rc<RefCell<Client>>, duration: u64) -> Result<(),Box<dyn Error>>{
//byte,shortstring,byte,shortstring //byte,shortstring,byte,shortstring
let username = read_short_string(&mut stream).await?; let username = read_short_string(&mut stream, duration).await?;
let application = read_short_string(&mut stream).await?; let application = read_short_string(&mut stream, duration).await?;
println!("{}: Got application {} and userid {}",Local::now().format("%Y-%m-%d %H:%M:%S"),application,username); println!("{}: Got application {} and userid {}",Local::now().format("%Y-%m-%d %H:%M:%S"),application,username);
{ {
let mut client = client.borrow_mut(); let mut client = client.borrow_mut();
@ -558,10 +558,10 @@ async fn read_rooms_message(mut stream: TcpStream, client: Rc<RefCell<Client>>,
return Ok(()); return Ok(());
} }
async fn read_join_message(mut stream: TcpStream, client: Rc<RefCell<Client>>, rooms: Rc<RefCell<HashMap<String, Rc<RefCell<Room>>>>>)-> Result<(),Box<dyn Error>>{ async fn read_join_message(mut stream: TcpStream, client: Rc<RefCell<Client>>, rooms: Rc<RefCell<HashMap<String, Rc<RefCell<Room>>>>>, duration: u64)-> Result<(),Box<dyn Error>>{
//byte,shortstring //byte,shortstring
let short_room_name = read_short_string(&mut stream).await?; let short_room_name = read_short_string(&mut stream, duration).await?;
let extended_room_name; let extended_room_name;
let mut leave_room = false; let mut leave_room = false;
{ {
@ -629,7 +629,7 @@ async fn read_join_message(mut stream: TcpStream, client: Rc<RefCell<Client>>, r
return Ok(()); return Ok(());
} }
async fn read_roomdata_message(mut stream: TcpStream, client: Rc<RefCell<Client>>, rooms: Rc<RefCell<HashMap<String, Rc<RefCell<Room>>>>>)-> Result<(),Box<dyn Error>>{ async fn read_roomdata_message(mut stream: TcpStream, client: Rc<RefCell<Client>>, rooms: Rc<RefCell<HashMap<String, Rc<RefCell<Room>>>>>, duration: u64)-> Result<(),Box<dyn Error>>{
//type, room_name //type, room_name
//will respond with type, numclients u32, id1 u32, name_len u8, name_bytes ... //will respond with type, numclients u32, id1 u32, name_len u8, name_bytes ...
@ -637,7 +637,7 @@ async fn read_roomdata_message(mut stream: TcpStream, client: Rc<RefCell<Client>
let short_room_name = read_short_string(&mut stream).await?; let short_room_name = read_short_string(&mut stream, duration).await?;
let mut client_ref = client.borrow_mut(); let mut client_ref = client.borrow_mut();
let room_name = format!("{}_{}", client_ref.application, short_room_name); let room_name = format!("{}_{}", client_ref.application, short_room_name);
@ -681,10 +681,10 @@ async fn read_roomdata_message(mut stream: TcpStream, client: Rc<RefCell<Client>
} }
async fn read_send_message(mut stream: TcpStream, client: Rc<RefCell<Client>>, rooms: Rc<RefCell<HashMap<String, Rc<RefCell<Room>>>>>, message_type: u8)-> Result<(),Box<dyn Error>>{ async fn read_send_message(mut stream: TcpStream, client: Rc<RefCell<Client>>, rooms: Rc<RefCell<HashMap<String, Rc<RefCell<Room>>>>>, message_type: u8, duration: u64)-> Result<(),Box<dyn Error>>{
//4 byte length, array //4 byte length, array
//this is a message for everyone in the room (maybe) //this is a message for everyone in the room (maybe)
let to_send = read_vec(&mut stream).await?; let to_send = read_vec(&mut stream, duration).await?;
if message_type == FromClientTCPMessageType::SendMessageOthersUnbuffered as u8 { if message_type == FromClientTCPMessageType::SendMessageOthersUnbuffered as u8 {
send_room_message(client,&to_send,rooms.clone(),false,false); send_room_message(client,&to_send,rooms.clone(),false,false);
}else if message_type == FromClientTCPMessageType::SendMessageAllUnbuffered as u8 { }else if message_type == FromClientTCPMessageType::SendMessageAllUnbuffered as u8 {
@ -694,16 +694,16 @@ async fn read_send_message(mut stream: TcpStream, client: Rc<RefCell<Client>>, r
}else if message_type == FromClientTCPMessageType::SendMessageAllBuffered as u8 { //ordered }else if message_type == FromClientTCPMessageType::SendMessageAllBuffered as u8 { //ordered
send_room_message(client,&to_send,rooms.clone(),true,true); send_room_message(client,&to_send,rooms.clone(),true,true);
}else if message_type == FromClientTCPMessageType::SendMessageGroupUnbuffered as u8 { }else if message_type == FromClientTCPMessageType::SendMessageGroupUnbuffered as u8 {
let group = read_short_string(&mut stream).await?; let group = read_short_string(&mut stream, duration).await?;
send_group_message(client,&to_send, &group); send_group_message(client,&to_send, &group);
} }
return Ok(()); return Ok(());
} }
async fn read_group_message(mut stream: TcpStream, client: Rc<RefCell<Client>>, clients: Rc<RefCell<HashMap<u32, Rc<RefCell<Client>>>>>)-> Result<(),Box<dyn Error>>{ async fn read_group_message(mut stream: TcpStream, client: Rc<RefCell<Client>>, clients: Rc<RefCell<HashMap<u32, Rc<RefCell<Client>>>>>, duration: u64)-> Result<(),Box<dyn Error>>{
let group = read_short_string(&mut stream).await?; let group = read_short_string(&mut stream, duration).await?;
let id_bytes = read_vec(&mut stream).await?; let id_bytes = read_vec(&mut stream, duration).await?;
let num = id_bytes.len(); let num = id_bytes.len();
let mut client_ref = client.borrow_mut(); let mut client_ref = client.borrow_mut();
@ -933,35 +933,35 @@ fn send_group_message(sender: Rc<RefCell<Client>>, message: &Vec<u8>, group: &St
} }
async fn read_u8(stream: &mut TcpStream) -> Result<u8,Box<dyn Error>> { async fn read_u8(stream: &mut TcpStream,duration: u64) -> Result<u8,Box<dyn Error>> {
let mut buf = [0; 1]; let mut buf = [0; 1];
read_timeout(stream, &mut buf, 5000).await?; read_timeout(stream, &mut buf, duration).await?;
return Ok(buf[0]); return Ok(buf[0]);
} }
async fn read_u32(stream: &mut TcpStream) -> Result<u32,Box<dyn Error>> { async fn read_u32(stream: &mut TcpStream,duration: u64) -> Result<u32,Box<dyn Error>> {
let mut buf:[u8;4] = [0; 4]; let mut buf:[u8;4] = [0; 4];
read_timeout(stream, &mut buf, 5000).await?; read_timeout(stream, &mut buf, duration).await?;
let size = u32::from_be_bytes(buf); let size = u32::from_be_bytes(buf);
return Ok(size); return Ok(size);
} }
async fn _read_string(stream: &mut TcpStream) -> Result<String,Box<dyn Error>> { async fn _read_string(stream: &mut TcpStream,duration: u64) -> Result<String,Box<dyn Error>> {
let size = read_u32(stream).await?; let size = read_u32(stream,duration).await?;
let mut string_bytes = vec![0;size as usize]; let mut string_bytes = vec![0;size as usize];
read_timeout(stream, &mut string_bytes, 5000).await?; read_timeout(stream, &mut string_bytes, duration).await?;
return Ok(String::from_utf8(string_bytes).unwrap()); return Ok(String::from_utf8(string_bytes).unwrap());
} }
async fn read_short_string(stream: &mut TcpStream) -> Result<String,Box<dyn Error>> { async fn read_short_string(stream: &mut TcpStream,duration: u64) -> Result<String,Box<dyn Error>> {
let size = read_u8(stream).await?; let size = read_u8(stream,duration).await?;
let mut string_bytes = vec![0;size as usize]; let mut string_bytes = vec![0;size as usize];
read_timeout(stream, &mut string_bytes, 5000).await?; read_timeout(stream, &mut string_bytes, duration).await?;
return Ok(String::from_utf8(string_bytes).unwrap()); return Ok(String::from_utf8(string_bytes).unwrap());
} }
async fn read_vec(stream: &mut TcpStream) -> Result<Vec<u8>,Box<dyn Error>> { async fn read_vec(stream: &mut TcpStream,duration: u64) -> Result<Vec<u8>,Box<dyn Error>> {
let message_size = read_u32(stream).await?; let message_size = read_u32(stream,duration).await?;
let mut message = vec![0u8;message_size as usize]; let mut message = vec![0u8;message_size as usize];
read_timeout(stream, &mut message, 5000).await?; read_timeout(stream, &mut message, duration).await?;
return Ok(message); return Ok(message);
} }