?

src/data.rs

@@ -0,0 +1,46 @@
+use std::io::{Read, Write};
+
+#[derive(Debug)]
+pub enum ProtocolError {
+	ReadError,
+	ConnectionClosed,
+	WriteError
+}
+
+pub trait DataReader {
+	fn read_bytes(&mut self, size: usize) -> Result<Vec<u8>, ProtocolError>;
+
+	fn read_byte(&mut self) -> Result<u8, ProtocolError> {
+		Ok(self.read_bytes(1)?[0])
+	}
+}
+
+impl <R: Read> DataReader for R {
+	fn read_bytes(&mut self, size: usize) -> Result<Vec<u8>, ProtocolError> {
+		let mut buf = vec![0; size];
+		match self.read(&mut buf) {
+			Ok(n) => if n == 0 {
+				return Err(ProtocolError::ConnectionClosed);
+			} else if n < size {
+				buf.truncate(n);
+				buf.append(&mut self.read_bytes(size - n)?);
+			}, Err(_) => return Err(ProtocolError::ReadError)
+		}; Ok(buf)
+	}
+}
+
+
+
+pub trait DataWriter {
+	fn write_bytes(&mut self, buf: &mut Vec<u8>) -> Result<(), ProtocolError>;
+
+	fn write_byte(&mut self, byte: u8) -> Result<(), ProtocolError> {
+		self.write_bytes(&mut vec![byte])
+	}
+}
+
+impl <W: Write> DataWriter for W {
+	fn write_bytes(&mut self, buf: &mut Vec<u8>) -> Result<(), ProtocolError> {
+		self.write_all(buf).map_err(|_| ProtocolError::WriteError)
+	}
+}

src/inet.rs

@@ -0,0 +1,35 @@
+use std::net::{TcpListener, TcpStream};
+
+
+
+pub enum InetError {
+	BindError,
+	ConnectionClosed
+}
+
+
+
+pub struct Server {
+	host: String,
+	port: u16,
+	listener: TcpListener
+}
+
+impl Server {
+	pub fn new(host: &str, port: u16) -> Result<Self, InetError> {
+		Ok(Server {
+			host: host.to_string(),
+			port,
+			listener: TcpListener::bind(format!("{host}:{port}")).map_err(|_| InetError::BindError)?
+		})
+	}
+
+	pub fn accept(&self) -> TcpStream {
+		loop {
+			match self.listener.accept() {
+				Ok((stream, _)) => return stream,
+				Err(_) => continue
+			}
+		}
+	}
+}

src/main.rs

@@ -1,4 +1,29 @@
 
+use data::DataReader;
+use inet::Server;
+
+mod data;
+mod inet;
+
 pub fn main() {
+	let Ok(server) = Server::new("127.0.0.1", 25565) else {
+		println!("Не удалось забиндить сервер"); return;
+	};
+
+	loop {
+		let mut stream = server.accept();
+		let addr = stream.peer_addr().unwrap();
+		println!("Подключение: {addr}");
+		let data = match stream.read_bytes(4) {
+			Ok(data) => data,
+			Err(e) => {
+				println!("Ошибка чтения: {e:?}"); continue;
+			}
+		};
+		println!("Данные получены: {}", String::from_utf8_lossy(&data));
+		println!("Отключение: {addr}");
+	}
+}
+
+
 
-}