Fix last commit
This commit is contained in:
@@ -0,0 +1,244 @@
|
||||
#include "http.h"
|
||||
|
||||
#include <assert.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <unistd.h>
|
||||
|
||||
static const char* EMPTY_STRING = "";
|
||||
|
||||
HTTPHeaderList* http_header_list_push(HTTPHeaderList* list, const char* key,
|
||||
const char* value)
|
||||
{
|
||||
HTTPHeaderList* new = malloc(sizeof(HTTPHeaderList));
|
||||
if (!new) {
|
||||
return NULL;
|
||||
}
|
||||
new->key_length = strlen(key);
|
||||
new->key = malloc(new->key_length + 1);
|
||||
if (!new->key) {
|
||||
free(new);
|
||||
return NULL;
|
||||
}
|
||||
memcpy(new->key, key, new->key_length + 1);
|
||||
new->value_length = strlen(value);
|
||||
new->value = malloc(new->value_length + 1);
|
||||
if (!new->value) {
|
||||
free(new->key);
|
||||
free(new);
|
||||
return NULL;
|
||||
}
|
||||
memcpy(new->value, value, new->value_length + 1);
|
||||
new->next = list;
|
||||
return new;
|
||||
}
|
||||
|
||||
void free_http_header_list(HTTPHeaderList* list)
|
||||
{
|
||||
while (list) {
|
||||
HTTPHeaderList* next = list->next;
|
||||
free(list->key);
|
||||
free(list->value);
|
||||
free(list);
|
||||
list = next;
|
||||
}
|
||||
}
|
||||
|
||||
const char* http_header_list_search(HTTPHeaderList* list, const char* key,
|
||||
const char* def)
|
||||
{
|
||||
while (list) {
|
||||
if (strcmp(list->key, key) == 0) {
|
||||
return list->value;
|
||||
}
|
||||
list = list->next;
|
||||
}
|
||||
return def;
|
||||
}
|
||||
|
||||
#define MAX_REQUEST_LENGTH 16384
|
||||
#define MAX_METHOD_LENGTH 16
|
||||
#define MAX_URI_LENGTH 256
|
||||
#define MAX_VERSION_LENGTH 3
|
||||
#define MAX_HEADER_KEY_LENGTH 2048
|
||||
#define MAX_HEADER_VALUE_LENGTH 2048
|
||||
|
||||
#define RETURN_IF_READ_ERROR(s) \
|
||||
if (ferror((s))) { \
|
||||
return HRPR_READ_FAILED; \
|
||||
}
|
||||
|
||||
// if an error occured, req->uri is not allocated
|
||||
static HTTPRequestParseResult parse_method_uri_line(FILE* stream,
|
||||
size_t* restrict bytes_read,
|
||||
HTTPRequest* restrict req)
|
||||
{
|
||||
// allow for some leeway in passing incorrect methods
|
||||
char method[MAX_METHOD_LENGTH + 1];
|
||||
char uri[MAX_URI_LENGTH + 1];
|
||||
char version_str[MAX_VERSION_LENGTH + 1];
|
||||
char whitespace[4];
|
||||
ssize_t signed_bytes_read;
|
||||
#define S1(s) #s
|
||||
#define S(s) S1(s)
|
||||
int nconv = fscanf(
|
||||
stream,
|
||||
// clang-format off
|
||||
"%" S(MAX_METHOD_LENGTH) "[A-Z]"
|
||||
"%c"
|
||||
"%" S(MAX_URI_LENGTH) "[^ \n\r]"
|
||||
"%c"
|
||||
"HTTP/%" S(MAX_VERSION_LENGTH) "[0-9.]"
|
||||
"%c%c"
|
||||
"%zn",
|
||||
// clang-format on
|
||||
method, &whitespace[0], uri, &whitespace[1], version_str,
|
||||
&whitespace[2], &whitespace[3], &signed_bytes_read);
|
||||
#undef S
|
||||
*bytes_read = signed_bytes_read;
|
||||
RETURN_IF_READ_ERROR(stream);
|
||||
if (nconv != 7 || memcmp(whitespace, " \r\n", 4) != 0) {
|
||||
return HRPR_BAD_FORMAT;
|
||||
}
|
||||
req->method = strdup(method);
|
||||
if (!req->method) {
|
||||
return HRPR_NO_MEM;
|
||||
}
|
||||
req->uri = strdup(uri);
|
||||
if (!req->uri) {
|
||||
return HRPR_NO_MEM;
|
||||
}
|
||||
req->path = req->uri;
|
||||
while (*req->path == '/') {
|
||||
++req->path;
|
||||
}
|
||||
return strcmp(version_str, "1.1") == 0 ? HRPR_OK : HRPR_BAD_VERSION;
|
||||
}
|
||||
|
||||
// return true if there are more headers and no error occurred, false otherwise
|
||||
// this will *not* free LIST if an error occurs
|
||||
static bool next_header(FILE* stream, size_t* restrict bytes_read,
|
||||
HTTPRequestParseResult* restrict res,
|
||||
HTTPHeaderList* restrict* restrict list)
|
||||
{
|
||||
char c = fgetc(stream);
|
||||
RETURN_IF_READ_ERROR(stream);
|
||||
if (c == '\r') {
|
||||
c = fgetc(stream);
|
||||
RETURN_IF_READ_ERROR(stream);
|
||||
if (c != '\n') {
|
||||
*res = HRPR_BAD_FORMAT;
|
||||
return false;
|
||||
}
|
||||
*bytes_read = 2;
|
||||
*res = HRPR_OK;
|
||||
return false;
|
||||
}
|
||||
ungetc(c, stream);
|
||||
char key[MAX_HEADER_KEY_LENGTH + 1];
|
||||
char value[MAX_HEADER_VALUE_LENGTH + 1];
|
||||
char whitespace[3];
|
||||
ssize_t signed_bytes_read;
|
||||
#define S1(s) #s
|
||||
#define S(s) S1(s)
|
||||
int nconv = fscanf(stream,
|
||||
// clang-format off
|
||||
"%" S(MAX_HEADER_KEY_LENGTH) "[a-zA-Z0-9.-]"
|
||||
":%c"
|
||||
"%" S(MAX_HEADER_VALUE_LENGTH) "[ -~]"
|
||||
"%c%c"
|
||||
"%zn",
|
||||
// clang-format on
|
||||
key, &whitespace[0], value, &whitespace[1], &whitespace[2],
|
||||
&signed_bytes_read);
|
||||
#undef S
|
||||
*bytes_read = signed_bytes_read;
|
||||
RETURN_IF_READ_ERROR(stream);
|
||||
if (nconv != 5 || memcmp(whitespace, " \r\n", 3) != 0) {
|
||||
return HRPR_BAD_FORMAT;
|
||||
}
|
||||
*list = http_header_list_push(*list, key, value);
|
||||
if (!*list) {
|
||||
*res = HRPR_NO_MEM;
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
HTTPRequestParseResult parse_http_request(FILE* stream,
|
||||
HTTPRequest* restrict out)
|
||||
{
|
||||
out->uri = EMPTY_STRING;
|
||||
out->path = EMPTY_STRING;
|
||||
out->method = EMPTY_STRING;
|
||||
size_t total_bytes;
|
||||
HTTPRequestParseResult res;
|
||||
if ((res = parse_method_uri_line(stream, &total_bytes, out)) != HRPR_OK) {
|
||||
return res;
|
||||
}
|
||||
out->headers = NULL;
|
||||
size_t bytes_read;
|
||||
while (next_header(stream, &bytes_read, &res, &out->headers)) {
|
||||
if ((total_bytes += bytes_read) > MAX_REQUEST_LENGTH) {
|
||||
res = HRPR_BAD_FORMAT;
|
||||
break;
|
||||
}
|
||||
}
|
||||
return res;
|
||||
}
|
||||
|
||||
void free_http_request(HTTPRequest* restrict req)
|
||||
{
|
||||
if (req->method != EMPTY_STRING) {
|
||||
free((char*)req->method);
|
||||
}
|
||||
if (req->uri != EMPTY_STRING) {
|
||||
free((char*)req->uri);
|
||||
}
|
||||
free_http_header_list(req->headers);
|
||||
}
|
||||
|
||||
const char* status_code_to_message(int status, size_t* restrict length)
|
||||
{
|
||||
static const struct {
|
||||
int code;
|
||||
const char* msg;
|
||||
size_t size;
|
||||
} CODES[] = {
|
||||
#define P(s, m) { s, m, sizeof(m) - 1 }
|
||||
P(200, "OK"),
|
||||
P(201, "Created"),
|
||||
P(400, "Bad Request"),
|
||||
P(403, "Forbidden"),
|
||||
P(404, "Not Found"),
|
||||
P(500, "Internal Server Error"),
|
||||
P(501, "Not Implemented"),
|
||||
P(505, "Version Not Supported"),
|
||||
#undef P
|
||||
};
|
||||
static const size_t NCODES = sizeof(CODES) / sizeof(CODES[0]);
|
||||
for (size_t i = 0; i < NCODES; ++i) {
|
||||
if (status == CODES[i].code) {
|
||||
if (length) {
|
||||
*length = CODES[i].size;
|
||||
}
|
||||
return CODES[i].msg;
|
||||
}
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
void format_http_response(FILE* stream, HTTPResponse* restrict resp)
|
||||
{
|
||||
assert(status_code_to_message(resp->status, NULL));
|
||||
fprintf(stream, "HTTP/1.1 %d %s\r\n", resp->status,
|
||||
status_code_to_message(resp->status, NULL));
|
||||
fprintf(stream, "Content-Length: %zu\r\n", resp->body_length);
|
||||
for (HTTPHeaderList* h = resp->headers; h; h = h->next) {
|
||||
fwrite(h->key, 1, h->key_length, stream);
|
||||
fwrite(": ", 1, 2, stream);
|
||||
fwrite(h->value, 1, h->value_length, stream);
|
||||
fwrite("\r\n", 1, 2, stream);
|
||||
}
|
||||
fwrite("\r\n", 1, 2, stream);
|
||||
}
|
||||
Reference in New Issue
Block a user