153 lines
5.5 KiB
Rust
153 lines
5.5 KiB
Rust
use std::net::TcpStream;
|
|
use tungstenite::{Error, WebSocket};
|
|
use crate::{protocol};
|
|
|
|
mod ui_messages {
|
|
use std::str::from_utf8;
|
|
use tungstenite::Message;
|
|
use uuid::Uuid;
|
|
use crate::{print_error, session_manager::protocol, utils::to_uuid_bytes};
|
|
|
|
pub fn on_connected(index: usize) -> Message {
|
|
Message::from(format!("connected {}", index))
|
|
}
|
|
pub fn on_disconnected(index: usize) -> Message {
|
|
Message::from(format!("disconnected {}", index))
|
|
}
|
|
pub fn on_new_session(index: usize) -> Message {
|
|
Message::from(format!("new_session {}", index))
|
|
}
|
|
pub fn on_new_message(index: &usize, raw_message: &[u8]) -> Option<Message> {
|
|
match from_utf8(raw_message) {
|
|
Ok(msg) => Some(Message::from(format!("new_message {} {}", index, msg))),
|
|
Err(e) => {
|
|
print_error(e);
|
|
None
|
|
}
|
|
}
|
|
}
|
|
pub fn on_file_received(index: &usize, buffer: &[u8]) -> Option<Message> {
|
|
let uuid = Uuid::from_bytes(to_uuid_bytes(&buffer[..16])?);
|
|
match from_utf8(&buffer[16..]) {
|
|
Ok(file_name) => Some(Message::from(format!("file {} {} {}", index, uuid.to_string(), file_name))),
|
|
Err(e) => {
|
|
print_error(e);
|
|
None
|
|
}
|
|
}
|
|
}
|
|
pub fn load_sent_msg(index: &usize, buffer: &[u8]) -> Option<Message> {
|
|
match buffer[0] {
|
|
protocol::Headers::MESSAGE => {
|
|
match from_utf8(&buffer[1..]) {
|
|
Ok(msg) => Some(Message::from(format!("load_sent_msg {} {}", index, msg))),
|
|
Err(e) => {
|
|
print_error(e);
|
|
None
|
|
}
|
|
}
|
|
}
|
|
protocol::Headers::FILE => {
|
|
let uuid = Uuid::from_bytes(to_uuid_bytes(&buffer[1..17])?);
|
|
match from_utf8(&buffer[17..]) {
|
|
Ok(file_name) => Some(Message::from(format!("load_sent_file {} {} {}", index, uuid.to_string(), file_name))),
|
|
Err(e) => {
|
|
print_error(e);
|
|
None
|
|
}
|
|
}
|
|
}
|
|
_ => None
|
|
}
|
|
}
|
|
pub fn on_name_told(index: &usize, raw_name: &[u8]) -> Option<Message> {
|
|
match from_utf8(raw_name) {
|
|
Ok(name) => Some(Message::from(format!("name_told {} {}", index, name))),
|
|
Err(e) => {
|
|
print_error(e);
|
|
None
|
|
}
|
|
}
|
|
}
|
|
pub fn set_as_contact(index: usize, name: &str, verified: bool) -> Message {
|
|
Message::from(format!("is_contact {} {} {}", index, verified, name))
|
|
}
|
|
pub fn fingerprints(local: &str, peer: &str) -> Message {
|
|
Message::from(format!("fingerprints {} {}", local, peer))
|
|
}
|
|
pub fn file_sent(index: usize, file_name: &str, uuid: Option<String>) -> Message {
|
|
Message::from(format!("file_sent {} {} {}", index, match uuid {
|
|
Some(uuid) => uuid,
|
|
None => "None".to_owned()
|
|
}, file_name))
|
|
}
|
|
}
|
|
|
|
pub struct UiConnection{
|
|
pub websocket: WebSocket<TcpStream>,
|
|
pub is_valid: bool
|
|
}
|
|
|
|
impl UiConnection {
|
|
pub fn new(websocket: WebSocket<TcpStream>) -> UiConnection {
|
|
UiConnection {
|
|
websocket: websocket,
|
|
is_valid: true
|
|
}
|
|
}
|
|
|
|
pub fn on_received(&mut self, index: &usize, buffer: &[u8]) {
|
|
let ui_message = match buffer[0] {
|
|
protocol::Headers::MESSAGE => {
|
|
ui_messages::on_new_message(index, &buffer[1..])
|
|
}
|
|
protocol::Headers::TELL_NAME => {
|
|
ui_messages::on_name_told(index, &buffer[1..])
|
|
}
|
|
protocol::Headers::FILE => {
|
|
ui_messages::on_file_received(index, &buffer[1..])
|
|
}
|
|
_ => None
|
|
};
|
|
if ui_message.is_some() {
|
|
self.websocket.write_message(ui_message.unwrap()).unwrap();
|
|
}
|
|
}
|
|
pub fn on_new_session(&mut self, index: usize) {
|
|
self.websocket.write_message(ui_messages::on_new_session(index)).unwrap();
|
|
}
|
|
pub fn on_disconnected(&mut self, index: usize) {
|
|
self.websocket.write_message(ui_messages::on_disconnected(index)).unwrap();
|
|
}
|
|
pub fn on_connected(&mut self, index: usize) {
|
|
self.websocket.write_message(ui_messages::on_connected(index)).unwrap();
|
|
}
|
|
|
|
pub fn read_message(&mut self) -> Result<String, Error> {
|
|
Ok(self.websocket.read_message()?.into_text()?)
|
|
}
|
|
pub fn read_binary(&mut self) -> Result<Vec<u8>, Error> {
|
|
Ok(self.websocket.read_message()?.into_data())
|
|
}
|
|
pub fn set_as_contact(&mut self, index: usize, name: &str, verified: bool) {
|
|
self.websocket.write_message(ui_messages::set_as_contact(index, name, verified)).unwrap();
|
|
}
|
|
pub fn load_msgs(&mut self, index: &usize, msgs: Vec<(bool, Vec<u8>)>) {
|
|
msgs.into_iter().for_each(|msg| {
|
|
if msg.0 { //outgoing
|
|
match ui_messages::load_sent_msg(index, &msg.1) {
|
|
Some(msg) => self.websocket.write_message(msg).unwrap(),
|
|
None => {}
|
|
}
|
|
} else {
|
|
self.on_received(index, &msg.1)
|
|
}
|
|
})
|
|
}
|
|
pub fn fingerprints(&mut self, local: &str, peer: &str) {
|
|
self.websocket.write_message(ui_messages::fingerprints(local, peer)).unwrap();
|
|
}
|
|
pub fn file_sent(&mut self, index: usize, name: &str, uuid: Option<String>) {
|
|
self.websocket.write_message(ui_messages::file_sent(index, name, uuid)).unwrap()
|
|
}
|
|
} |