summaryrefslogtreecommitdiff
path: root/src/server
diff options
context:
space:
mode:
Diffstat (limited to 'src/server')
-rw-r--r--src/server/gameserver.rs1
-rw-r--r--src/server/mod.rs22
-rw-r--r--src/server/streamconnection.rs68
-rw-r--r--src/server/tcpserver.rs89
-rw-r--r--src/server/unixserver.rs109
5 files changed, 289 insertions, 0 deletions
diff --git a/src/server/gameserver.rs b/src/server/gameserver.rs
new file mode 100644
index 0000000..8b13789
--- /dev/null
+++ b/src/server/gameserver.rs
@@ -0,0 +1 @@
+
diff --git a/src/server/mod.rs b/src/server/mod.rs
new file mode 100644
index 0000000..131eb19
--- /dev/null
+++ b/src/server/mod.rs
@@ -0,0 +1,22 @@
+use std::io;
+
+pub mod tcpserver;
+pub mod unixserver;
+
+mod streamconnection;
+
+
+pub trait Server {
+
+ fn accept_pending_connections(&mut self) -> Vec<usize>;
+
+ fn recv_pending_messages(&mut self) -> (Vec<(usize, String)>, Vec<usize>);
+
+ fn send(&mut self, id: usize, text: &str) -> Result<(), io::Error>;
+
+ fn broadcast(&mut self, text: &str);
+
+ fn get_name(&self, _id: usize) -> Option<String> {
+ None
+ }
+}
diff --git a/src/server/streamconnection.rs b/src/server/streamconnection.rs
new file mode 100644
index 0000000..2bb111a
--- /dev/null
+++ b/src/server/streamconnection.rs
@@ -0,0 +1,68 @@
+
+
+use std::io;
+use std::io::{Read, Write};
+use std::mem::transmute;
+
+
+pub struct StreamConnection<T: Read+Write> {
+ pub stream: T,
+ buffer: Vec<u8>
+}
+
+impl <T: Read+Write> StreamConnection<T> {
+
+ pub fn new(stream: T) -> StreamConnection<T> {
+ StreamConnection {
+ stream,
+ buffer: Vec::new()
+ }
+ }
+
+ pub fn read(&mut self) -> Result<(Vec<String>, bool), io::Error> {
+ let mut buf = [0; 2048];
+ let mut closed = false;
+ loop {
+ match self.stream.read(&mut buf) {
+ Err(e) => {
+ if e.kind() == io::ErrorKind::WouldBlock {
+ break;
+ } else {
+ return Err(e);
+ }
+ }
+ Ok(0) => {
+ closed = true;
+ break;
+ }
+ Ok(i) => {
+ self.buffer.extend_from_slice(&buf[..i]);
+// messages.push(String::from_utf8_lossy(&buf[..i]).to_string());
+ }
+ }
+ }
+ let mut messages = Vec::new();
+ while self.buffer.len() >= 4 {
+ let mut header: [u8; 4] = [0;4];
+ header.copy_from_slice(&self.buffer[..4]);
+ let mlen: usize = u32::from_be(unsafe { transmute(header) }) as usize;
+ if self.buffer.len() - 4 < mlen {
+ break;
+ }
+ let rest = self.buffer.split_off(4+mlen);
+ let message = String::from_utf8_lossy(&self.buffer[4..]).to_string();
+ messages.push(message);
+ self.buffer = rest;
+ }
+ return Ok((messages, closed));
+ }
+
+ pub fn send(&mut self, text: &str) -> Result<(), io::Error> {
+ let bytes: &[u8] = text.as_bytes();
+ let len: u32 = bytes.len() as u32;
+ let header: [u8; 4] = unsafe { transmute(len.to_be()) };
+ self.stream.write_all(&header)?;
+ self.stream.write_all(bytes)
+ }
+
+}
diff --git a/src/server/tcpserver.rs b/src/server/tcpserver.rs
new file mode 100644
index 0000000..b411634
--- /dev/null
+++ b/src/server/tcpserver.rs
@@ -0,0 +1,89 @@
+
+
+use std::io;
+use std::net::SocketAddr;
+use mio::net::{TcpListener, TcpStream};
+use slab::Slab;
+
+use self::super::streamconnection::StreamConnection;
+
+
+pub struct TcpServer {
+ listener: TcpListener,
+ connections: Slab<StreamConnection<TcpStream>>
+}
+
+impl TcpServer {
+
+ pub fn new(addr: &SocketAddr) -> Result<TcpServer, io::Error> {
+ let listener = TcpListener::bind(addr)?;
+ Ok( TcpServer {
+ listener,
+ connections: Slab::new()
+ })
+ }
+}
+
+impl super::Server for TcpServer {
+
+ fn accept_pending_connections(&mut self) -> Vec<usize> {
+ let mut new_connections = Vec::new();
+ loop {
+ match self.listener.accept() {
+ Err(_e) => {
+ break;
+ }
+ Ok((stream, _address)) => {
+ let con = StreamConnection::new(stream);
+ let id = self.connections.insert(con);
+ new_connections.push(id);
+ }
+ }
+ }
+ new_connections
+ }
+
+
+ fn recv_pending_messages(&mut self) -> (Vec<(usize, String)>, Vec<usize>){
+ // let mut buf = [0; 2048];
+ let mut messages: Vec<(usize, String)> = Vec::new();
+ let mut to_remove = Vec::new();
+ for (key, connection) in self.connections.iter_mut(){
+ match connection.read() {
+ Err(_e) => {
+ to_remove.push(key);
+ }
+ Ok((con_messages, closed)) => {
+ for message in con_messages {
+ messages.push((key, message));
+ }
+ if closed {
+ to_remove.push(key);
+ }
+ }
+ }
+ }
+ for key in to_remove.iter() {
+ self.connections.remove(*key);
+ }
+ (messages, to_remove)
+ }
+
+ fn broadcast(&mut self, text: &str) {
+ for (_id, conn) in self.connections.iter_mut() {
+ conn.send(text).expect("BroadCast Failed");
+ }
+ }
+
+ fn send(&mut self, id: usize, text: &str) -> Result<(), io::Error> {
+ match self.connections.get_mut(id){
+ Some(conn) => {
+ conn.send(text)
+ }
+ None => Err(io::Error::new(io::ErrorKind::Other, "index is empty"))
+ }
+ }
+
+
+}
+
diff --git a/src/server/unixserver.rs b/src/server/unixserver.rs
new file mode 100644
index 0000000..dc9feab
--- /dev/null
+++ b/src/server/unixserver.rs
@@ -0,0 +1,109 @@
+
+
+use std::io;
+use std::path::Path;
+use std::os::unix::io::AsRawFd;
+use mio_uds::{UnixListener, UnixStream};
+use slab::Slab;
+use nix::sys::socket::getsockopt;
+use nix::sys::socket::sockopt;
+use users;
+
+use self::super::streamconnection::StreamConnection;
+
+
+pub struct UnixServer {
+ listener: UnixListener,
+ connections: Slab<StreamConnection<UnixStream>>
+}
+
+impl UnixServer {
+
+ pub fn new(addr: &Path) -> Result<UnixServer, io::Error> {
+ let listener = UnixListener::bind(addr)?;
+ Ok( UnixServer {
+ listener,
+ connections: Slab::new()
+ })
+ }
+
+
+}
+
+impl super::Server for UnixServer {
+
+ fn accept_pending_connections(&mut self) -> Vec<usize> {
+ let mut new_connections = Vec::new();
+ loop {
+ match self.listener.accept() {
+ Ok(Some((stream, _address))) => {
+ let con = StreamConnection::new(stream);
+ let id = self.connections.insert(con);
+ new_connections.push(id);
+ }
+ Ok(None) => {
+ break;
+ }
+ Err(_e) => {
+ break;
+ }
+ }
+ }
+ new_connections
+ }
+
+
+ fn recv_pending_messages(&mut self) -> (Vec<(usize, String)>, Vec<usize>){
+ // let mut buf = [0; 2048];
+ let mut messages: Vec<(usize, String)> = Vec::new();
+ let mut to_remove = Vec::new();
+ for (key, connection) in self.connections.iter_mut(){
+ match connection.read() {
+ Err(_e) => {
+ to_remove.push(key);
+ }
+ Ok((con_messages, closed)) => {
+ for message in con_messages {
+ messages.push((key, message));
+ }
+ if closed {
+ to_remove.push(key);
+ }
+ }
+ }
+ }
+ for key in to_remove.iter() {
+ self.connections.remove(*key);
+ }
+ (messages, to_remove)
+ }
+
+ fn broadcast(&mut self, text: &str) {
+ for (_id, conn) in self.connections.iter_mut() {
+ let _ = conn.send(text);
+ }
+ }
+
+ fn send(&mut self, id: usize, text: &str) -> Result<(), io::Error> {
+ match self.connections.get_mut(id){
+ Some(conn) => {
+ conn.send(text)
+ }
+ None => Err(io::Error::new(io::ErrorKind::Other, "index is empty"))
+ }
+ }
+
+
+ fn get_name(&self, id: usize) -> Option<String> {
+ let connection = self.connections.get(id)?;
+ let fd = connection.stream.as_raw_fd();
+ if let Ok(peercred) = getsockopt(fd, sockopt::PeerCredentials) {
+ let uid = peercred.uid();
+ let user = users::get_user_by_uid(uid)?;
+ let name = user.name();
+ Some(name.to_string_lossy().to_string())
+ } else { None }
+ }
+
+}
+
generated by cgit (git 2.34.1) at 2026-06-01 01:22:59 +0000