ascii-chat
Binary v0.16.50-198-g78f51665f
Library lib/v0.3.2-2240-g78f51665f
Video chat in your terminal
Loading...
Searching...
No Matches
http_server.cpp
Go to the documentation of this file.
1
5
6/* Storage capacities in elements; text buffers include the terminating NUL. */
7#define TOOLING_QUERY_HTTP_SERVER_BUFFER_BUFFER_SIZE 65536
8
9#include "http_server.h"
10
11#include <algorithm>
12#include <cctype>
13#include <cstring>
14#include <sstream>
15
16// Platform-specific includes
17#if defined(_WIN32)
18#define WIN32_LEAN_AND_MEAN
19#include <winsock2.h>
20#include <ws2tcpip.h>
21#pragma comment(lib, "ws2_32.lib")
22using socket_t = SOCKET;
23using ssize_t = ptrdiff_t; // Windows doesn't define ssize_t
24#define INVALID_SOCKET_VAL INVALID_SOCKET
25#define SOCKET_ERROR_VAL SOCKET_ERROR
26#define close_socket closesocket
27#else
28#include <arpa/inet.h>
29#include <netinet/in.h>
30#include <sys/socket.h>
31#include <unistd.h>
32using socket_t = int;
33#define INVALID_SOCKET_VAL (-1)
34#define SOCKET_ERROR_VAL (-1)
35#define close_socket close
36#endif
37
38namespace ascii_query {
39
40// =============================================================================
41// HttpRequest
42// =============================================================================
43
44std::string HttpRequest::header(const std::string &name, const std::string &default_value) const {
45 // Case-insensitive header lookup
46 std::string lower_name = name;
47 std::transform(lower_name.begin(), lower_name.end(), lower_name.begin(), [](unsigned char c) { return std::tolower(c); });
48
49 for (const auto &[key, value] : headers) {
50 std::string lower_key = key;
51 std::transform(lower_key.begin(), lower_key.end(), lower_key.begin(), [](unsigned char c) { return std::tolower(c); });
52 if (lower_key == lower_name) {
53 return value;
54 }
55 }
56 return default_value;
57}
58
59// =============================================================================
60// HttpResponse
61// =============================================================================
62
63std::string HttpResponse::serialize() const {
64 std::ostringstream oss;
65
66 // Status line
67 oss << "HTTP/1.1 " << status_code << " " << status_text << "\r\n";
68
69 // Headers
70 bool has_content_length = false;
71 bool has_connection = false;
72
73 for (const auto &[key, value] : headers) {
74 oss << key << ": " << value << "\r\n";
75 std::string lower_key = key;
76 std::transform(lower_key.begin(), lower_key.end(), lower_key.begin(), [](unsigned char c) { return std::tolower(c); });
77 if (lower_key == "content-length")
78 has_content_length = true;
79 if (lower_key == "connection")
80 has_connection = true;
81 }
82
83 // Add Content-Length if not present
84 if (!has_content_length) {
85 oss << "Content-Length: " << body.size() << "\r\n";
86 }
87
88 // Add Connection: close if not present
89 if (!has_connection) {
90 oss << "Connection: close\r\n";
91 }
92
93 // CORS headers for browser access
94 oss << "Access-Control-Allow-Origin: *\r\n";
95 oss << "Access-Control-Allow-Methods: GET, POST, DELETE, OPTIONS\r\n";
96 oss << "Access-Control-Allow-Headers: Content-Type\r\n";
97
98 // End headers
99 oss << "\r\n";
100
101 // Body
102 oss << body;
103
104 return oss.str();
105}
106
107// =============================================================================
108// HttpServer
109// =============================================================================
110
112#if defined(_WIN32)
113 // Initialize Winsock
114 WSADATA wsa_data;
115 WSAStartup(MAKEWORD(2, 2), &wsa_data);
116#endif
117
118 // Default 404 handler
119 default_handler_ = [](const HttpRequest &) { return HttpResponse::notFound(); };
120}
121
123 stop();
124
125#if defined(_WIN32)
126 WSACleanup();
127#endif
128}
129
130void HttpServer::addRoute(const std::string &method, const std::string &path, RouteHandler handler) {
131 routes_.push_back({method, path, std::move(handler)});
132}
133
135 default_handler_ = std::move(handler);
136}
137
139 if (running_) {
140 last_error_ = "Server already running";
141 return false;
142 }
143
144 // Create socket
145 server_socket_ = static_cast<int>(socket(AF_INET, SOCK_STREAM, 0));
146 if (server_socket_ == INVALID_SOCKET_VAL) {
147 last_error_ = "Failed to create socket";
148 return false;
149 }
150
151 // Set SO_REUSEADDR
152 int opt = 1;
153#if defined(_WIN32)
154 setsockopt(server_socket_, SOL_SOCKET, SO_REUSEADDR, reinterpret_cast<const char *>(&opt), sizeof(opt));
155#else
156 setsockopt(server_socket_, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
157#endif
158
159 // Bind
160 struct sockaddr_in addr{};
161 addr.sin_family = AF_INET;
162 addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK); // localhost only for security
163 addr.sin_port = htons(port);
164
165 if (bind(server_socket_, reinterpret_cast<struct sockaddr *>(&addr), sizeof(addr)) < 0) {
166 last_error_ = "Failed to bind to port " + std::to_string(port);
167 close_socket(server_socket_);
168 server_socket_ = -1;
169 return false;
170 }
171
172 // Listen
173 if (listen(server_socket_, 10) < 0) {
174 last_error_ = "Failed to listen on socket";
175 close_socket(server_socket_);
176 server_socket_ = -1;
177 return false;
178 }
179
180 port_ = port;
181 running_ = true;
182
183 // Start server thread
184 server_thread_ = std::thread(&HttpServer::serverLoop, this);
185
186 return true;
187}
188
190 if (!running_) {
191 return;
192 }
193
194 running_ = false;
195
196 // Close server socket to unblock accept()
197 if (server_socket_ >= 0) {
198#if defined(_WIN32)
199 shutdown(server_socket_, SD_BOTH);
200#else
201 shutdown(server_socket_, SHUT_RDWR);
202#endif
203 close_socket(server_socket_);
204 server_socket_ = -1;
205 }
206
207 // Wait for server thread
208 if (server_thread_.joinable()) {
209 server_thread_.join();
210 }
211}
212
213void HttpServer::serverLoop() {
214 while (running_) {
215 struct sockaddr_in client_addr{};
216 socklen_t client_len = sizeof(client_addr);
217
218 socket_t client_socket = accept(server_socket_, reinterpret_cast<struct sockaddr *>(&client_addr), &client_len);
219
220 if (client_socket == INVALID_SOCKET_VAL) {
221 if (running_) {
222 // Real error, not just shutdown
223 // Continue anyway
224 }
225 continue;
226 }
227
228 handleClient(static_cast<int>(client_socket));
229 }
230}
231
233 if (server_socket_ < 0) {
234 return false;
235 }
236
237 struct sockaddr_in client_addr{};
238 socklen_t client_len = sizeof(client_addr);
239
240 socket_t client_socket = accept(server_socket_, reinterpret_cast<struct sockaddr *>(&client_addr), &client_len);
241
242 if (client_socket == INVALID_SOCKET_VAL) {
243 return false;
244 }
245
246 handleClient(static_cast<int>(client_socket));
247 return true;
248}
249
250void HttpServer::handleClient(int client_socket) {
251 // Read request (up to 64KB)
253 ssize_t bytes_read;
254
255#if defined(_WIN32)
256 bytes_read = recv(client_socket, buffer, sizeof(buffer) - 1, 0);
257#else
258 bytes_read = read(client_socket, buffer, sizeof(buffer) - 1);
259#endif
260
261 if (bytes_read <= 0) {
262 close_socket(client_socket);
263 return;
264 }
265 buffer[bytes_read] = '\0';
266
267 // Parse request
268 HttpRequest request;
269 if (!parseRequest(buffer, request)) {
270 HttpResponse response = HttpResponse::badRequest("Invalid HTTP request");
271 std::string raw = response.serialize();
272 send(client_socket, raw.c_str(), static_cast<int>(raw.size()), 0);
273 close_socket(client_socket);
274 return;
275 }
276
277 // Handle CORS preflight
278 if (request.method == "OPTIONS") {
279 HttpResponse response = HttpResponse::noContent();
280 std::string raw = response.serialize();
281 send(client_socket, raw.c_str(), static_cast<int>(raw.size()), 0);
282 close_socket(client_socket);
283 return;
284 }
285
286 // Find handler
287 RouteHandler handler = findHandler(request.method, request.path);
288
289 // Call handler
290 HttpResponse response;
291 try {
292 response = handler(request);
293 } catch (const std::exception &e) {
294 response = HttpResponse::serverError(e.what());
295 } catch (...) {
296 response = HttpResponse::serverError("Unknown error");
297 }
298
299 // Send response
300 std::string raw = response.serialize();
301 send(client_socket, raw.c_str(), static_cast<int>(raw.size()), 0);
302
303 close_socket(client_socket);
304}
305
306bool HttpServer::parseRequest(const std::string &raw, HttpRequest &request) {
307 // Find end of request line
308 size_t line_end = raw.find("\r\n");
309 if (line_end == std::string::npos) {
310 return false;
311 }
312
313 // Parse request line: METHOD PATH HTTP/1.x
314 std::string request_line = raw.substr(0, line_end);
315 std::istringstream iss(request_line);
316 std::string http_version;
317 std::string full_path;
318
319 if (!(iss >> request.method >> full_path >> http_version)) {
320 return false;
321 }
322
323 // Split path and query string
324 size_t query_pos = full_path.find('?');
325 if (query_pos != std::string::npos) {
326 request.path = full_path.substr(0, query_pos);
327 request.query_string = full_path.substr(query_pos + 1);
328 parseQueryString(request.query_string, request.params);
329 } else {
330 request.path = full_path;
331 }
332
333 // Parse headers
334 size_t pos = line_end + 2;
335 while (pos < raw.size()) {
336 size_t next_line = raw.find("\r\n", pos);
337 if (next_line == std::string::npos) {
338 break;
339 }
340
341 std::string header_line = raw.substr(pos, next_line - pos);
342 if (header_line.empty()) {
343 // Empty line = end of headers
344 pos = next_line + 2;
345 break;
346 }
347
348 size_t colon = header_line.find(':');
349 if (colon != std::string::npos) {
350 std::string name = header_line.substr(0, colon);
351 std::string value = header_line.substr(colon + 1);
352
353 // Trim leading whitespace from value
354 size_t value_start = value.find_first_not_of(" \t");
355 if (value_start != std::string::npos) {
356 value = value.substr(value_start);
357 }
358
359 request.headers[name] = value;
360 }
361
362 pos = next_line + 2;
363 }
364
365 // Body is everything after headers
366 if (pos < raw.size()) {
367 request.body = raw.substr(pos);
368 }
369
370 return true;
371}
372
373void HttpServer::parseQueryString(const std::string &query, std::unordered_map<std::string, std::string> &params) {
374 size_t pos = 0;
375 while (pos < query.size()) {
376 // Find next parameter
377 size_t amp = query.find('&', pos);
378 if (amp == std::string::npos) {
379 amp = query.size();
380 }
381
382 std::string param = query.substr(pos, amp - pos);
383
384 // Split key=value
385 size_t eq = param.find('=');
386 if (eq != std::string::npos) {
387 std::string key = urlDecode(param.substr(0, eq));
388 std::string value = urlDecode(param.substr(eq + 1));
389 params[key] = value;
390 } else {
391 // Flag parameter (no value)
392 std::string key = urlDecode(param);
393 if (!key.empty()) {
394 params[key] = "";
395 }
396 }
397
398 pos = amp + 1;
399 }
400}
401
402std::string HttpServer::urlDecode(const std::string &str) {
403 std::string result;
404 result.reserve(str.size());
405
406 for (size_t i = 0; i < str.size(); i++) {
407 if (str[i] == '%' && i + 2 < str.size()) {
408 int val = 0;
409 char hex[3] = {str[i + 1], str[i + 2], '\0'};
410 if (sscanf(hex, "%2x", &val) == 1) {
411 result += static_cast<char>(val);
412 i += 2;
413 } else {
414 result += str[i];
415 }
416 } else if (str[i] == '+') {
417 result += ' ';
418 } else {
419 result += str[i];
420 }
421 }
422
423 return result;
424}
425
426RouteHandler HttpServer::findHandler(const std::string &method, const std::string &path) {
427 for (const auto &route : routes_) {
428 if (route.method == method && route.path == path) {
429 return route.handler;
430 }
431 }
432 return default_handler_;
433}
434
435} // namespace ascii_query
uint16_t port() const
Get the port the server is listening on.
void addRoute(const std::string &method, const std::string &path, RouteHandler handler)
Add a route handler.
void setDefaultHandler(RouteHandler handler)
Set a default handler for unmatched routes.
bool processOneRequest()
Process one request (blocking).
bool start(uint16_t port)
Start the server.
void stop()
Stop the server.
unsigned short uint16_t
#define TOOLING_QUERY_HTTP_SERVER_BUFFER_BUFFER_SIZE
#define INVALID_SOCKET_VAL
int socket_t
#define close_socket
Minimal single-threaded HTTP/1.1 server.
std::function< HttpResponse(const HttpRequest &)> RouteHandler
Route handler function type.
Parsed HTTP request.
Definition http_server.h:39
std::unordered_map< std::string, std::string > headers
Request headers.
Definition http_server.h:43
std::string header(const std::string &name, const std::string &default_value="") const
Get a header value.
std::unordered_map< std::string, std::string > headers
Definition http_server.h:99
std::string serialize() const
Serialize response to HTTP/1.1 format.
static HttpResponse noContent()
static HttpResponse notFound(const std::string &message="Not Found")
static HttpResponse serverError(const std::string &message="Internal Server Error")
static HttpResponse badRequest(const std::string &message="Bad Request")