mthomson/webserver.c
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

big ol' update

Browse Source
This commit is contained in:
Michael Thomson 2024-02-12 16:57:40 -05:00
parent bdafb30b0a
commit f81c911898
No known key found for this signature in database
12 changed files with 159 additions and 74 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

44
Makefile
View File

@ -1,26 +1,22 @@
all: server
# ----- Variables for customization -----
CC = gcc # Compiler (you can change to clang if desired)
CFLAGS = -g3 -Wall -Wextra -fsanitize=address,undefined # Standard flags + debugging & warnings
LDFLAGS = # Linker flags, if any
# ----- Automatic dependency tracking -----
SRCS := $(wildcard *.c) # Find all .c source files
OBJS := $(SRCS:.c=.o) # Corresponding object files (.o)
HDRS := $(SRCS:.c=.h)
# ----- Targets -----
server: $(OBJS)
$(CC) $(CFLAGS) $(OBJS) -o server $(LDFLAGS)
# Create object files from source files
%.o: %.c %.h
$(CC) $(CFLAGS) -c $< -o $@
# Phony target for cleaning
.PHONY: clean
clean:
@rm -rf *.o
@rm -rf server
server: main.o server.o request.o header.o utils.o response.o
gcc -g3 -fsanitize=address,undefined -o server $^
main.o: main.c
gcc -g3 -fsanitize=address,undefined -c -o main.o main.c
server.o: server.c server.h
gcc -g3 -fsanitize=address,undefined -c -o server.o server.c
request.o: request.c request.h
gcc -g3 -fsanitize=address,undefined -c -o request.o request.c
response.o: response.c response.h
gcc -g3 -fsanitize=address,undefined -c -o response.o response.c
header.o: header.c header.h
gcc -g3 -fsanitize=address,undefined -c -o header.o header.c
utils.o: utils.c utils.h
gcc -g3 -fsanitize=address,undefined -c -o utils.o utils.c
rm -f $(OBJS) server

2
clicked.html
View File

@ -1 +1 @@
<p>It works!</p>
<p>see?</p>

5
header.c
View File

@ -1,8 +1,9 @@
#include "header.h"
#include <string.h>
struct Header header_constructor(char *key, char *value) {
struct Header header;
header.key = key;
header.value = value;
header.key = strdup(key);
header.value = strdup(value);
return header;
}

20
index.html
View File

@ -1,7 +1,23 @@
<div>
<!DOCTYPE html>
<html lang="en">
<head>
<title>Michael Thomson</title>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<script src="https://unpkg.com/htmx.org@1.9.10"></script>
</head>
<body>
<h1>Michael Thomson</h1>
<p>Welcome to my site! doesn't it have so much content? I know, right?</p>
<p>It even has reactivity!</p>
<div>
<!-- have a button POST a click via AJAX -->
<button hx-post="/clicked" hx-swap="outerHTML">
Click Me
</button>
</div>
</div>
</body>
</html>

11
main.c
View File

@ -1,8 +1,19 @@
#include "request.h"
#include "server.h"
#include <stdlib.h>
char *home(struct Request request) {
return read_file("index.html");
}
char *clicked(struct Request request) {
return read_file("clicked.html");
}
int main(void) {
struct Server server = server_constructor("3000");
add_route(&server, "GET", "/", home);
add_route(&server, "POST", "/clicked", clicked);
launch(&server);
return EXIT_SUCCESS;
}

23
response.c
View File

@ -1,23 +1,31 @@
#include "response.h"
#include "header.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX_BUFFER_SIZE 2048
struct Response response_constructor(char *version, char *status, char *body,
int num_headers, struct Header *headers) {
struct Response response_constructor(char *version, char *status, char *body) {
struct Response response;
response.version = version;
response.status = status;
response.body = body;
response.num_headers = num_headers;
response.headers = headers;
response.version = strdup(version);
response.status = strdup(status);
response.body = strdup(body);
response.num_headers = 0;
response.headers = NULL;
return response;
}
void add_header(struct Response *response, char *key, char *value) {
struct Header header = header_constructor(key, value);
response->headers = realloc(
response->headers, sizeof(struct Header) * (response->num_headers + 1));
response->headers[response->num_headers++] = header;
}
void response_to_string(char *buf, struct Response *response) {
char headers[MAX_BUFFER_SIZE];
headers[0] = '\0';
for (int i = 0; i < response->num_headers; i++) {
strcat(headers, response->headers[i].key);
@ -26,6 +34,7 @@ void response_to_string(char *buf, struct Response *response) {
strcat(headers, "\r\n");
}
snprintf(buf, MAX_BUFFER_SIZE, "%s %s\r\n%s\r\n%s", response->version,
response->status, headers, response->body);
}

5
response.h
View File

@ -13,9 +13,10 @@ struct Response {
struct Header *headers;
};
struct Response response_constructor(char *version, char *status, char *body,
int num_headers, struct Header *headers);
struct Response response_constructor(char *version, char *status, char *body);
void response_to_string(char *buf, struct Response *response);
void add_header(struct Response *response, char *key, char *value);
#endif // !RESPONSE_H

12
route.c Normal file
View File

@ -0,0 +1,12 @@
#include <string.h>
#include "route.h"
struct Route route_constructor(char *target, char *method,
Route_Callback route_callback) {
struct Route route;
route.target = strdup(target);
route.method = strdup(method);
route.route_callback = route_callback;
return route;
}

17
route.h Normal file
View File

@ -0,0 +1,17 @@
#ifndef ROUTE_H
#define ROUTE_H
#include "request.h"
typedef char *(*Route_Callback)(struct Request request);
struct Route {
char *target;
char *method;
Route_Callback route_callback;
};
struct Route route_constructor(char *target, char *method,
Route_Callback route_callback);
#endif // !ROUTE_H

BIN
server
View File

Binary file not shown.

76
server.c
View File

@ -8,9 +8,9 @@
#include <sys/types.h>
#include <unistd.h>
#include "header.h"
#include "request.h"
#include "response.h"
#include "route.h"
#include "server.h"
#define MAX_BUFFER_SIZE 2048
@ -18,12 +18,32 @@
int sockfd;
struct Server server_constructor(char *PORT) {
struct Server server_constructor(const char *PORT) {
struct Server server;
server.PORT = PORT;
server.num_routes = 0;
server.routes = NULL;
return server;
}
void add_route(struct Server *server, char *method, char *target,
Route_Callback route_callback) {
struct Route route = route_constructor(target, method, route_callback);
server->routes =
realloc(server->routes, sizeof(struct Route) * (server->num_routes + 1));
server->routes[server->num_routes++] = route;
}
struct Route *match_route(struct Server *server, char *method, char *target) {
for (int i = 0; i < server->num_routes; i++) {
if (strcmp(server->routes[i].target, target) == 0 &&
strcmp(server->routes[i].method, method) == 0) {
return &server->routes[i];
}
}
return NULL;
}
void sigchld_handler(int s) {
// waitpid() might overwrite errno, so we save and restore it:
int saved_errno = errno;
@ -90,7 +110,7 @@ static void start(const char *PORT) {
}
}
char *read_file(char *filename, size_t *file_size) {
char *read_file(char *filename) {
// read in file
FILE *fp = fopen(filename, "r");
if (fp == NULL) {
@ -100,11 +120,11 @@ char *read_file(char *filename, size_t *file_size) {
// Calculate the content length
fseek(fp, 0, SEEK_END);
*file_size = ftell(fp);
size_t file_size = ftell(fp);
rewind(fp);
// allocate memory for file contents
char *buffer = malloc(*file_size + 1);
char *buffer = malloc(file_size + 1);
if (buffer == NULL) {
fprintf(stderr, "read_file: memory allocation failed.\n");
fclose(fp);
@ -112,8 +132,8 @@ char *read_file(char *filename, size_t *file_size) {
}
// Read the file contents into buffer
size_t bytes_read = fread(buffer, 1, *file_size, fp);
if (bytes_read != *file_size) {
size_t bytes_read = fread(buffer, 1, file_size, fp);
if (bytes_read != file_size) {
fprintf(stderr, "read_file: error reading file.\n");
free(buffer);
fclose(fp);
@ -121,41 +141,37 @@ char *read_file(char *filename, size_t *file_size) {
}
fclose(fp);
buffer[*file_size] = '\0';
buffer[file_size] = '\0';
return buffer;
}
void respond(int *client_fd) {
void respond(struct Server *server, int *client_fd) {
// Recieve request
char buf[MAX_BUFFER_SIZE];
recv(*client_fd, buf, MAX_BUFFER_SIZE, 0);
// Parse request
struct Request request = request_constructor(buf);
printf("%s %s %s\n", request.method, request.target, request.version);
// Match route and get body content
struct Route *matched_route =
match_route(server, request.method, request.target);
char *filename;
if (strcmp(request.target, "/") == 0) {
filename = "index.html";
} else if (strcmp(request.target, "/clicked") == 0) {
filename = "clicked.html";
struct Response response;
if (matched_route == NULL) {
response = response_constructor("HTTP/1.1", NOT_FOUND, "Not found");
} else {
filename = "404.html";
char *body = matched_route->route_callback(request);
response = response_constructor("HTTP/1.1", OK, body);
}
size_t body_length;
char *body = read_file(filename, &body_length);
// calculate content length
char body_length[12];
snprintf(body_length, sizeof(body_length), "%lu", strlen(response.body));
add_header(&response, "Content-Length", body_length);
// Create the Content-Length header
struct Header headers[MAX_HEADER_NUM];
char contentLength[MAX_BUFFER_SIZE];
snprintf(contentLength, sizeof(contentLength), "%zu", body_length);
headers[0] = header_constructor("Content-Length", contentLength);
// construct response
struct Response response =
response_constructor("HTTP/1.1", OK, body, 1, headers);
printf("%s %s -> %s\n", request.method, request.target, response.status);
// send response string
char response_string[MAX_BUFFER_SIZE];
@ -165,8 +181,6 @@ void respond(int *client_fd) {
perror("send content");
exit(1);
}
free(body);
}
void launch(struct Server *server) {
@ -185,7 +199,7 @@ void launch(struct Server *server) {
if (!fork()) {
close(sockfd);
respond(&client_fd);
respond(server, &client_fd);
close(client_fd);
exit(0);
}

10
server.h
View File

@ -2,15 +2,23 @@
#define SERVER_H
#include "header.h"
#include "route.h"
#define BACKLOG 128
struct Server {
const char *PORT;
struct Route *routes;
int num_routes;
};
struct Server server_constructor(char *PORT);
struct Server server_constructor(const char *PORT);
void add_route(struct Server *server, char *method, char *target,
Route_Callback route_callback);
void launch(struct Server *server);
char *read_file(char *filename);
#endif // !SERVER_H