1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
|
#![allow(unused)]
use itertools::Itertools;
use std::collections::HashMap;
use std::io::{self, Read, Write};
use std::net::{TcpListener, TcpStream};
use std::{str, thread};
use http_server_starter_rust::http_types::*;
use http_server_starter_rust::request::*;
use http_server_starter_rust::response::*;
fn handle_client(mut stream: TcpStream) {
// Buffer to store the data received from the client
let mut buffer = [0; 512];
// Read data from the stream
match stream.read(&mut buffer) {
Ok(_) => {
// Convert buffer to a string and print the received data
if let Ok(request) = str::from_utf8(&buffer) {
println!("Received request: {}", request);
let request = Request::from(request);
println!("Request after parsing: {:?}", request);
let succses: String =
Response::new("1.1".to_string(), StatusCode::Ok, None, None).into();
let succses = succses.as_bytes();
let not_found: String =
Response::new("1.1".to_string(), StatusCode::NotFound, None, None).into();
let not_found = not_found.as_bytes();
match request.method {
HTTPMethod::Get((endpoint, target)) => {
match (endpoint.as_str(), target.as_str()) {
("", "") => match stream.write(succses) {
Ok(_) => {
println!("Response sent successfully");
}
Err(e) => eprintln!("Failed to send response: {}", e),
},
("echo", target) => {
let mut headers = HashMap::new();
headers
.insert("Content-Type".to_string(), "text/plain".to_string());
headers.insert(
"Content-Length".to_string(),
(target.len() - 1).to_string(),
);
let body = target[0..target.len() - 1].to_string();
let response: String = Response::new(
"1.1".to_string(),
StatusCode::Ok,
Some(Headers(headers)),
Some(body),
)
.into();
dbg!(&response);
let response = response.as_bytes();
match stream.write(response) {
Ok(_) => {
println!("Response sent successfully");
println!("Hello echo");
}
Err(e) => eprintln!("Failed to send response: {}", e),
}
}
("user-agent", _) => {
let mut headers = HashMap::new();
let user_agent: String =
request.headers.unwrap().0.get("User-Agent").unwrap().into();
headers
.insert("Content-Type".to_string(), "text/plain".to_string());
headers.insert(
"Content-Length".to_string(),
user_agent.len().to_string(),
);
let body = user_agent;
let response: String = Response::new(
"1.1".to_string(),
StatusCode::Ok,
Some(Headers(headers)),
Some(body),
)
.into();
dbg!(&response);
let response = response.as_bytes();
match stream.write(response) {
Ok(_) => {
println!("Response sent successfully");
println!("Hello user-agent");
}
Err(e) => eprintln!("Failed to send response: {}", e),
}
}
_ => match stream.write(not_found) {
Ok(_) => println!("Response sent successfully"),
Err(e) => eprintln!("Failed to send response: {}", e),
},
}
}
HTTPMethod::Post(_target) => todo!(),
HTTPMethod::Put(_target) => todo!(),
}
}
}
Err(e) => {
eprintln!("Failed to read from stream: {}", e);
}
}
}
fn main() -> io::Result<()> {
let listener = TcpListener::bind("127.0.0.1:4221").unwrap();
for stream in listener.incoming() {
match stream {
Ok(stream) => {
thread::spawn(move || handle_client(stream));
}
Err(e) => {
eprintln!("error: {}", e);
}
}
}
Ok(())
}
|
