Initial commit: split VNOX monorepo into VNOX-Server

Unified server binary (vnox-serverd) combining:
- Gateway (TCP, auth, channels, sessions, SQLite)
- Voice-node (UDP relay, Opus, jitter buffer)

Standalone gateway (vnox-gateway) and voice-node (vnox-voice-node) preserved as sub-crates.
This commit is contained in:
Loki 2026-07-09 11:52:56 +02:00
commit e751e0bf5b
94 changed files with 9771 additions and 0 deletions

View file

@ -0,0 +1,37 @@
use anyhow::Result;
use tokio::net::TcpStream;
use crate::{
domain::session,
net::io,
proto::{FriendDeclinePayload, PacketId, SessionCrypto, to_payload},
};
pub async fn handle_friend_decline(
stream: &mut TcpStream,
seq: &mut u32,
session_id: &str,
payload: &[u8],
crypto: &SessionCrypto,
state: &crate::net::state::State,
) -> Result<()> {
let req: FriendDeclinePayload = serde_json::from_slice(payload)?;
let sess = session::get(&state.sessions, session_id)
.await
.ok_or_else(|| anyhow::anyhow!("session not found"))?;
state
.storage
.decline_friend_request(&req.from_user_id, &sess.user_id)
.await?;
io::send_encrypted(
stream,
PacketId::FriendDecline,
seq,
&to_payload(&serde_json::json!({"status": "DECLINED"})),
crypto,
)
.await?;
Ok(())
}

View file

@ -0,0 +1,47 @@
use anyhow::Result;
use tokio::net::TcpStream;
use crate::{
domain::session,
net::{io, state::State},
proto::{FriendInfo, FriendListPayload, PacketId, SessionCrypto, to_payload},
};
pub async fn handle_friend_list(
stream: &mut TcpStream,
seq: &mut u32,
session_id: &str,
crypto: &SessionCrypto,
state: &State,
) -> Result<()> {
let sess = session::get(&state.sessions, session_id)
.await
.ok_or_else(|| anyhow::anyhow!("session not found"))?;
let friend_ids = state.storage.list_friends(&sess.user_id).await?;
let mut friends = Vec::new();
let presences = state.presences.read().await;
for fid in &friend_ids {
let nick = state.storage.get_nickname(fid).await?.unwrap_or_default();
let presence = presences.get(fid);
friends.push(FriendInfo {
user_id: fid.clone(),
nickname: nick,
status: presence
.map(|p| p.status.clone())
.unwrap_or_else(|| "OFFLINE".into()),
since: 0,
});
}
io::send_encrypted(
stream,
PacketId::FriendList,
seq,
&to_payload(&FriendListPayload { friends }),
crypto,
)
.await?;
Ok(())
}

View file

@ -0,0 +1,122 @@
use anyhow::Result;
use tokio::net::TcpStream;
use crate::{
domain::session,
net::{io, state::State},
proto::{
BlockListPayload, BlockUserPayload, FriendRemovePayload, PacketId, SessionCrypto,
UnblockUserPayload, to_payload,
},
};
pub async fn handle_friend_remove(
stream: &mut TcpStream,
seq: &mut u32,
session_id: &str,
payload: &[u8],
crypto: &SessionCrypto,
state: &State,
) -> Result<()> {
let req: FriendRemovePayload = serde_json::from_slice(payload)?;
let sess = session::get(&state.sessions, session_id)
.await
.ok_or_else(|| anyhow::anyhow!("session not found"))?;
state
.storage
.remove_friend(&sess.user_id, &req.user_id)
.await?;
io::send_encrypted(
stream,
PacketId::FriendRemove,
seq,
&to_payload(&serde_json::json!({"removed": true})),
crypto,
)
.await?;
Ok(())
}
pub async fn handle_block_user(
stream: &mut TcpStream,
seq: &mut u32,
session_id: &str,
payload: &[u8],
crypto: &SessionCrypto,
state: &State,
) -> Result<()> {
let req: BlockUserPayload = serde_json::from_slice(payload)?;
let sess = session::get(&state.sessions, session_id)
.await
.ok_or_else(|| anyhow::anyhow!("session not found"))?;
state
.storage
.block_user(&sess.user_id, &req.user_id)
.await?;
io::send_encrypted(
stream,
PacketId::BlockUser,
seq,
&to_payload(&serde_json::json!({"blocked": true})),
crypto,
)
.await?;
Ok(())
}
pub async fn handle_unblock_user(
stream: &mut TcpStream,
seq: &mut u32,
session_id: &str,
payload: &[u8],
crypto: &SessionCrypto,
state: &State,
) -> Result<()> {
let req: UnblockUserPayload = serde_json::from_slice(payload)?;
let sess = session::get(&state.sessions, session_id)
.await
.ok_or_else(|| anyhow::anyhow!("session not found"))?;
state
.storage
.unblock_user(&sess.user_id, &req.user_id)
.await?;
io::send_encrypted(
stream,
PacketId::UnblockUser,
seq,
&to_payload(&serde_json::json!({"unblocked": true})),
crypto,
)
.await?;
Ok(())
}
pub async fn handle_block_list(
stream: &mut TcpStream,
seq: &mut u32,
session_id: &str,
crypto: &SessionCrypto,
state: &State,
) -> Result<()> {
let sess = session::get(&state.sessions, session_id)
.await
.ok_or_else(|| anyhow::anyhow!("session not found"))?;
let blocked = state.storage.list_blocks(&sess.user_id).await?;
io::send_encrypted(
stream,
PacketId::BlockList,
seq,
&to_payload(&BlockListPayload { blocked }),
crypto,
)
.await?;
Ok(())
}

View file

@ -0,0 +1,37 @@
mod decline;
mod list;
mod manage;
mod requests;
use anyhow::Result;
use tokio::net::TcpStream;
use crate::{
net::io,
proto::{ErrorPayload, PacketId, SessionCrypto, to_payload},
};
async fn send_err(
stream: &mut TcpStream,
seq: &mut u32,
code: crate::proto::ErrorCode,
msg: &str,
crypto: &SessionCrypto,
) -> Result<()> {
io::send_encrypted(
stream,
PacketId::Error,
seq,
&to_payload(&ErrorPayload {
code: code as u32,
message: msg.into(),
}),
crypto,
)
.await
}
pub use decline::handle_friend_decline;
pub use list::handle_friend_list;
pub use manage::{handle_block_list, handle_block_user, handle_friend_remove, handle_unblock_user};
pub use requests::{handle_friend_accept, handle_friend_request};

View file

@ -0,0 +1,152 @@
use anyhow::Result;
use tokio::net::TcpStream;
use crate::{
domain::session,
net::{
io,
state::{BroadcastMsg, State},
},
proto::{
FriendAcceptPayload, FriendEventPayload, FriendRequestPayload, PacketId, SessionCrypto,
encode_packet, to_payload,
},
};
use super::send_err;
pub async fn handle_friend_request(
stream: &mut TcpStream,
seq: &mut u32,
session_id: &str,
payload: &[u8],
crypto: &SessionCrypto,
state: &State,
) -> Result<()> {
let req: FriendRequestPayload = serde_json::from_slice(payload)?;
let sess = session::get(&state.sessions, session_id)
.await
.ok_or_else(|| anyhow::anyhow!("session not found"))?;
if state
.storage
.is_blocked(&req.to_user_id, &sess.user_id)
.await?
{
send_err(
stream,
seq,
crate::proto::ErrorCode::Blocked,
"you are blocked by this user",
crypto,
)
.await?;
return Ok(());
}
if state
.storage
.is_friend(&sess.user_id, &req.to_user_id)
.await?
{
send_err(
stream,
seq,
crate::proto::ErrorCode::InvalidPacket,
"already friends",
crypto,
)
.await?;
return Ok(());
}
let ok = state
.storage
.create_friend_request(&sess.user_id, &req.to_user_id)
.await?;
if !ok {
send_err(
stream,
seq,
crate::proto::ErrorCode::InvalidPacket,
"already friends or request pending",
crypto,
)
.await?;
return Ok(());
}
let ev = FriendEventPayload {
event: "REQUEST_RECEIVED".into(),
user_id: sess.user_id.clone(),
nickname: Some(sess.nickname.clone()),
};
let _ = state.broadcast.send(BroadcastMsg {
channel_id: None,
exclude_session: None,
target_session_id: Some(req.to_user_id.clone()),
data: encode_packet(PacketId::FriendRequest, *seq, &to_payload(&ev)),
});
io::send_encrypted(
stream,
PacketId::FriendRequest,
seq,
&to_payload(&serde_json::json!({"status": "PENDING", "to_user_id": req.to_user_id})),
crypto,
)
.await?;
Ok(())
}
pub async fn handle_friend_accept(
stream: &mut TcpStream,
seq: &mut u32,
session_id: &str,
payload: &[u8],
crypto: &SessionCrypto,
state: &State,
) -> Result<()> {
let req: FriendAcceptPayload = serde_json::from_slice(payload)?;
let sess = session::get(&state.sessions, session_id)
.await
.ok_or_else(|| anyhow::anyhow!("session not found"))?;
let ok = state
.storage
.accept_friend_request(&req.from_user_id, &sess.user_id)
.await?;
if !ok {
send_err(
stream,
seq,
crate::proto::ErrorCode::InvalidPacket,
"no pending request",
crypto,
)
.await?;
return Ok(());
}
let ev = FriendEventPayload {
event: "REQUEST_ACCEPTED".into(),
user_id: sess.user_id.clone(),
nickname: Some(sess.nickname.clone()),
};
let _ = state.broadcast.send(BroadcastMsg {
channel_id: None,
exclude_session: None,
target_session_id: Some(req.from_user_id.clone()),
data: encode_packet(PacketId::FriendAccept, *seq, &to_payload(&ev)),
});
io::send_encrypted(
stream,
PacketId::FriendAccept,
seq,
&to_payload(&serde_json::json!({"status": "ACCEPTED", "from_user_id": req.from_user_id})),
crypto,
)
.await?;
Ok(())
}