nikita
/
lavina
forked from lavina/lavina
1
0
Fork 0
Code Pull Requests Activity

implement irc client registration

This commit is contained in:
Nikita Vilunov 2023-02-10 19:47:58 +01:00
parent e0135a8ea6
commit 69406cb33b
2 changed files with 245 additions and 4 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

178
src/projections/irc.rs
View File

@ -3,6 +3,7 @@ use std::net::SocketAddr;
use prometheus::{IntCounter, IntGauge, Registry as MetricsRegistry};
use serde::Deserialize;
use tokio::io::{AsyncBufReadExt, AsyncWriteExt, BufReader, BufWriter};
use tokio::net::tcp::{ReadHalf, WriteHalf};
use tokio::net::{TcpListener, TcpStream};
use tokio::sync::oneshot::channel;
@ -18,6 +19,13 @@ pub struct ServerConfig {
pub server_name: String,
}
#[derive(Debug)]
struct RegisteredUser {
nickname: Vec<u8>,
username: Vec<u8>,
realname: Vec<u8>,
}
async fn handle_socket(
config: ServerConfig,
mut stream: TcpStream,
@ -26,14 +34,180 @@ async fn handle_socket(
current_connections: IntGauge,
) {
let (reader, writer) = stream.split();
let mut reader = BufReader::new(reader);
let mut reader: BufReader<ReadHalf> = BufReader::new(reader);
let mut writer = BufWriter::new(writer);
{
let notice = ServerMessage {
tags: vec![],
sender: Some(config.server_name.as_bytes().to_vec()),
body: ServerMessageBody::Notice {
first_target: b"*".to_vec(),
rest_targets: vec![],
text: b"Welcome to my server!".to_vec(),
},
};
let mut buffer = vec![];
notice.write(&mut buffer).unwrap();
writer.write_all(buffer.as_slice()).await;
writer.flush().await;
}
let mut buffer = vec![];
// let (player_id, mut player_handle) = players.create_player().await;
// let mut sub = player_handle.subscribe().await;
let mut future_nickname: Option<Vec<u8>> = None;
let mut future_username: Option<(Vec<u8>, Vec<u8>)> = None;
let registered_user: Result<RegisteredUser> = loop {
let res = reader.read_until(b'\n', &mut buffer).await;
match res {
Ok(len) => {
if len == 0 {
log::info!("Terminating socket");
break Err(anyhow::Error::msg("EOF"));
}
}
Err(err) => {
log::warn!("Failed to read from socket: {err}");
break Err(err.into());
}
}
let parsed = client_message(&buffer[..]);
match parsed {
Ok((rest, msg)) => {
log::info!("Incoming IRC message: {msg:?}");
match msg {
ClientMessage::Nick { nickname } => {
if let Some((username, realname)) = future_username {
break Ok(RegisteredUser {
nickname,
username,
realname,
});
} else {
future_nickname = Some(nickname);
}
}
ClientMessage::User { username, realname } => {
if let Some(nickname) = future_nickname {
break Ok(RegisteredUser {
nickname,
username,
realname,
});
} else {
future_username = Some((username, realname));
}
}
_ => {}
}
}
Err(err) => {
log::warn!("Failed to parse IRC message: {err}");
}
}
buffer.clear();
};
match registered_user {
Ok(user) => {
handle_registered_socket(config, socket_addr, players, reader, writer, user).await
}
Err(_) => {}
}
current_connections.dec();
}
async fn handle_registered_socket<'a>(
config: ServerConfig,
socket_addr: SocketAddr,
mut players: PlayerRegistry,
mut reader: BufReader<ReadHalf<'a>>,
mut writer: BufWriter<WriteHalf<'a>>,
user: RegisteredUser,
) {
let mut buffer = vec![];
log::info!("Handling registered user: {user:?}");
{
let notice = ServerMessage {
tags: vec![],
sender: Some(config.server_name.as_bytes().to_vec()),
body: ServerMessageBody::N001Welcome {
client: user.nickname.clone(),
text: b"Welcome to Kek Server".to_vec(),
},
};
let mut buffer = vec![];
notice.write(&mut buffer).unwrap();
writer.write_all(buffer.as_slice()).await;
writer.flush().await;
}
{
let notice = ServerMessage {
tags: vec![],
sender: Some(config.server_name.as_bytes().to_vec()),
body: ServerMessageBody::N002YourHost {
client: user.nickname.clone(),
text: b"Welcome to Kek Server".to_vec(),
},
};
let mut buffer = vec![];
notice.write(&mut buffer).unwrap();
writer.write_all(buffer.as_slice()).await;
writer.flush().await;
}
{
let notice = ServerMessage {
tags: vec![],
sender: Some(config.server_name.as_bytes().to_vec()),
body: ServerMessageBody::N003Created {
client: user.nickname.clone(),
text: b"Welcome to Kek Server".to_vec(),
},
};
let mut buffer = vec![];
notice.write(&mut buffer).unwrap();
writer.write_all(buffer.as_slice()).await;
writer.flush().await;
}
{
let notice = ServerMessage {
tags: vec![],
sender: Some(config.server_name.as_bytes().to_vec()),
body: ServerMessageBody::N004MyInfo {
client: user.nickname.clone(),
hostname: config.server_name.as_bytes().to_vec(),
softname: b"kek-0.1.alpha.3".to_vec(),
},
};
let mut buffer = vec![];
notice.write(&mut buffer).unwrap();
writer.write_all(buffer.as_slice()).await;
writer.flush().await;
}
{
let notice = ServerMessage {
tags: vec![],
sender: Some(config.server_name.as_bytes().to_vec()),
body: ServerMessageBody::N005ISupport {
client: user.nickname.clone(),
params: b"CHANTYPES=#".to_vec(),
},
};
let mut buffer = vec![];
notice.write(&mut buffer).unwrap();
writer.write_all(buffer.as_slice()).await;
writer.flush().await;
}
loop {
select! {
biased;
@ -48,7 +222,6 @@ async fn handle_socket(
let parsed = client_message(&buffer[..]);
match parsed {
Ok((rest, msg)) => {
log::info!("Incoming IRC message: {msg:?}");
match msg {
ClientMessage::Ping { token } => {
let response = ServerMessage {
@ -75,7 +248,6 @@ async fn handle_socket(
},
}
}
current_connections.dec();
}
pub async fn launch(

71
src/protos/irc/server.rs
View File

@ -6,12 +6,20 @@ pub struct ServerMessage {
/// Optional tags section, prefixed with `@`
pub tags: Vec<Tag>,
/// Optional server name, prefixed with `:`.
pub sender: Option<String>,
pub sender: Option<ByteVec>,
pub body: ServerMessageBody,
}
impl ServerMessage {
pub fn write(&self, writer: &mut impl Write) -> std::io::Result<()> {
match &self.sender {
Some(ref sender) => {
writer.write(b":")?;
writer.write(sender.as_slice())?;
writer.write(b" ")?;
}
None => {}
}
self.body.write(writer)?;
writer.write(b"\n")?;
Ok(())
@ -44,6 +52,28 @@ pub enum ServerMessageBody {
from: ByteVec,
token: ByteVec,
},
N001Welcome {
client: ByteVec,
text: ByteVec,
},
N002YourHost {
client: ByteVec,
text: ByteVec,
},
N003Created {
client: ByteVec,
text: ByteVec,
},
N004MyInfo {
client: ByteVec,
hostname: ByteVec,
softname: ByteVec,
// TODO user modes, channel modes, channel modes with a parameter
},
N005ISupport {
client: ByteVec,
params: ByteVec, // TODO make this a datatype
},
}
impl ServerMessageBody {
@ -69,6 +99,45 @@ impl ServerMessageBody {
writer.write(b" :")?;
writer.write(&token)?;
}
ServerMessageBody::N001Welcome { client, text } => {
writer.write(b"001 ")?;
writer.write(&client)?;
writer.write(b" :")?;
writer.write(text)?;
}
ServerMessageBody::N002YourHost { client, text } => {
writer.write(b"002 ")?;
writer.write(&client)?;
writer.write(b" :")?;
writer.write(text)?;
}
ServerMessageBody::N003Created { client, text } => {
writer.write(b"003 ")?;
writer.write(&client)?;
writer.write(b" :")?;
writer.write(text)?;
}
ServerMessageBody::N004MyInfo {
client,
hostname,
softname,
} => {
writer.write(b"004 ")?;
writer.write(&client)?;
writer.write(b" ")?;
writer.write(&hostname)?;
writer.write(b" ")?;
writer.write(&softname)?;
writer.write(b" DGMQRSZagiloswz CFILPQbcefgijklmnopqrstvz bkloveqjfI")?;
// TODO remove hardcoded modes
}
ServerMessageBody::N005ISupport { client, params } => {
writer.write(b"005 ")?;
writer.write(&client)?;
writer.write(b" ")?;
writer.write(&params)?;
writer.write(b" :are supported by this server")?;
}
}
Ok(())
}