playground/suckless-quark
1
0
Fork 0
Code Issues Pull requests Releases Wiki Activity
suckless-quark/http.c

747 lines
17 KiB
C
Raw Normal View History

Refactor the single source file into multiple modules And many other things, too many to list here. For example, it now properly logs uds instead of erroring out. Separating concerns in many places definitely improves the readability.
2018-02-04 20:27:33 +00:00
/* See LICENSE file for copyright and license details. */
#include <arpa/inet.h>
#include <ctype.h>
#include <errno.h>
#include <limits.h>
add headers to make it compile under OpenBSD - 'struct in6_addr' is defined in <netinet/in.h> - 'AF_INET6' is defined in <sys/socket.h>
2018-02-12 19:29:51 +00:00
#include <netinet/in.h>
Refactor the single source file into multiple modules And many other things, too many to list here. For example, it now properly logs uds instead of erroring out. Separating concerns in many places definitely improves the readability.
2018-02-04 20:27:33 +00:00
#include <regex.h>
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>
Add some missing headers and interface visibility macro strings.h for strncasecmp time.h for strptime
2018-03-01 14:18:20 +00:00
#include <strings.h>
add headers to make it compile under OpenBSD - 'struct in6_addr' is defined in <netinet/in.h> - 'AF_INET6' is defined in <sys/socket.h>
2018-02-12 19:29:51 +00:00
#include <sys/socket.h>
Refactor the single source file into multiple modules And many other things, too many to list here. For example, it now properly logs uds instead of erroring out. Separating concerns in many places definitely improves the readability.
2018-02-04 20:27:33 +00:00
#include <sys/stat.h>
#include <sys/types.h>
Add some missing headers and interface visibility macro strings.h for strncasecmp time.h for strptime
2018-03-01 14:18:20 +00:00
#include <time.h>
Refactor the single source file into multiple modules And many other things, too many to list here. For example, it now properly logs uds instead of erroring out. Separating concerns in many places definitely improves the readability.
2018-02-04 20:27:33 +00:00
#include <unistd.h>
#include "config.h"
#include "http.h"
#include "resp.h"
#include "util.h"
const char *req_field_str[] = {
Rename REQ_MOD to REQ_IF_MODIFIED_SINCE The named constants for header fields of the response struct all pretty much matched the actual header name, which I think improves readability for everyone familiar with the HTTP-spec. The request header fields named constants followed the rule, except the "If-Modified-Since"-header, which is addressed in this commit. Signed-off-by: Laslo Hunhold <dev@frign.de>
2020-08-05 13:46:03 +00:00
[REQ_HOST] = "Host",
[REQ_RANGE] = "Range",
[REQ_IF_MODIFIED_SINCE] = "If-Modified-Since",
Refactor the single source file into multiple modules And many other things, too many to list here. For example, it now properly logs uds instead of erroring out. Separating concerns in many places definitely improves the readability.
2018-02-04 20:27:33 +00:00
};
const char *req_method_str[] = {
[M_GET] = "GET",
[M_HEAD] = "HEAD",
};
const char *status_str[] = {
[S_OK] = "OK",
[S_PARTIAL_CONTENT] = "Partial Content",
[S_MOVED_PERMANENTLY] = "Moved Permanently",
[S_NOT_MODIFIED] = "Not Modified",
[S_BAD_REQUEST] = "Bad Request",
[S_FORBIDDEN] = "Forbidden",
[S_NOT_FOUND] = "Not Found",
[S_METHOD_NOT_ALLOWED] = "Method Not Allowed",
[S_REQUEST_TIMEOUT] = "Request Time-out",
[S_RANGE_NOT_SATISFIABLE] = "Range Not Satisfiable",
[S_REQUEST_TOO_LARGE] = "Request Header Fields Too Large",
[S_INTERNAL_SERVER_ERROR] = "Internal Server Error",
[S_VERSION_NOT_SUPPORTED] = "HTTP Version not supported",
};
Refactor response-generation I wasn't happy with how responses were generated. HTTP-headers were handled by hand and it was duplicated in multiple parts of the code. Due to the duplication, some functions like timestamp() had really ugly semantics. The HTTP requests are parsed much better: We have an enum of fields we care about that are automatically read into our request struct. This commit adapts this idea to the response: We have an enum of fields we might put into our response, and a response-struct holds the content of these fields. A function http_send_header() automatically sends a header based on the entries in response. In case we don't use a field, we just leave the field in the response-struct empty. With this commit, some logical changes came with it: - timestamp() now has a sane signature, TIMESTAMP_LEN is no more and it can now return proper errors and is also reentrant by using gmtime_r() instead of gmtime() - No more use of a static timestamp-array, making all the methods also reentrant - Better internal-error-reporting: Because the fields are filled before and not during sending the response-headers, we can better report any internal errors as status 500 instead of sending a partial non-500-header and then dying. These improved data structures make it easier to read and hack the code and implement new features, if desired. Signed-off-by: Laslo Hunhold <dev@frign.de>
2020-08-05 11:41:44 +00:00
const char *res_field_str[] = {
[RES_ACCEPT_RANGES] = "Accept-Ranges",
[RES_ALLOW] = "Allow",
[RES_LOCATION] = "Location",
[RES_LAST_MODIFIED] = "Last-Modified",
[RES_CONTENT_LENGTH] = "Content-Length",
[RES_CONTENT_RANGE] = "Content-Range",
[RES_CONTENT_TYPE] = "Content-Type",
};
Refactor the single source file into multiple modules And many other things, too many to list here. For example, it now properly logs uds instead of erroring out. Separating concerns in many places definitely improves the readability.
2018-02-04 20:27:33 +00:00
enum status
Refactor response-generation I wasn't happy with how responses were generated. HTTP-headers were handled by hand and it was duplicated in multiple parts of the code. Due to the duplication, some functions like timestamp() had really ugly semantics. The HTTP requests are parsed much better: We have an enum of fields we care about that are automatically read into our request struct. This commit adapts this idea to the response: We have an enum of fields we might put into our response, and a response-struct holds the content of these fields. A function http_send_header() automatically sends a header based on the entries in response. In case we don't use a field, we just leave the field in the response-struct empty. With this commit, some logical changes came with it: - timestamp() now has a sane signature, TIMESTAMP_LEN is no more and it can now return proper errors and is also reentrant by using gmtime_r() instead of gmtime() - No more use of a static timestamp-array, making all the methods also reentrant - Better internal-error-reporting: Because the fields are filled before and not during sending the response-headers, we can better report any internal errors as status 500 instead of sending a partial non-500-header and then dying. These improved data structures make it easier to read and hack the code and implement new features, if desired. Signed-off-by: Laslo Hunhold <dev@frign.de>
2020-08-05 11:41:44 +00:00
http_send_header(int fd, const struct response *res)
Refactor the single source file into multiple modules And many other things, too many to list here. For example, it now properly logs uds instead of erroring out. Separating concerns in many places definitely improves the readability.
2018-02-04 20:27:33 +00:00
{
Refactor response-generation I wasn't happy with how responses were generated. HTTP-headers were handled by hand and it was duplicated in multiple parts of the code. Due to the duplication, some functions like timestamp() had really ugly semantics. The HTTP requests are parsed much better: We have an enum of fields we care about that are automatically read into our request struct. This commit adapts this idea to the response: We have an enum of fields we might put into our response, and a response-struct holds the content of these fields. A function http_send_header() automatically sends a header based on the entries in response. In case we don't use a field, we just leave the field in the response-struct empty. With this commit, some logical changes came with it: - timestamp() now has a sane signature, TIMESTAMP_LEN is no more and it can now return proper errors and is also reentrant by using gmtime_r() instead of gmtime() - No more use of a static timestamp-array, making all the methods also reentrant - Better internal-error-reporting: Because the fields are filled before and not during sending the response-headers, we can better report any internal errors as status 500 instead of sending a partial non-500-header and then dying. These improved data structures make it easier to read and hack the code and implement new features, if desired. Signed-off-by: Laslo Hunhold <dev@frign.de>
2020-08-05 11:41:44 +00:00
char t[FIELD_MAX];
size_t i;
if (timestamp(t, sizeof(t), time(NULL))) {
return S_INTERNAL_SERVER_ERROR;
}
Refactor the single source file into multiple modules And many other things, too many to list here. For example, it now properly logs uds instead of erroring out. Separating concerns in many places definitely improves the readability.
2018-02-04 20:27:33 +00:00
if (dprintf(fd,
"HTTP/1.1 %d %s\r\n"
"Date: %s\r\n"
Refactor response-generation I wasn't happy with how responses were generated. HTTP-headers were handled by hand and it was duplicated in multiple parts of the code. Due to the duplication, some functions like timestamp() had really ugly semantics. The HTTP requests are parsed much better: We have an enum of fields we care about that are automatically read into our request struct. This commit adapts this idea to the response: We have an enum of fields we might put into our response, and a response-struct holds the content of these fields. A function http_send_header() automatically sends a header based on the entries in response. In case we don't use a field, we just leave the field in the response-struct empty. With this commit, some logical changes came with it: - timestamp() now has a sane signature, TIMESTAMP_LEN is no more and it can now return proper errors and is also reentrant by using gmtime_r() instead of gmtime() - No more use of a static timestamp-array, making all the methods also reentrant - Better internal-error-reporting: Because the fields are filled before and not during sending the response-headers, we can better report any internal errors as status 500 instead of sending a partial non-500-header and then dying. These improved data structures make it easier to read and hack the code and implement new features, if desired. Signed-off-by: Laslo Hunhold <dev@frign.de>
2020-08-05 11:41:44 +00:00
"Connection: close\r\n",
res->status, status_str[res->status], t) < 0) {
return S_REQUEST_TIMEOUT;
}
for (i = 0; i < NUM_RES_FIELDS; i++) {
if (res->field[i][0] != '\0') {
if (dprintf(fd, "%s: %s\r\n", res_field_str[i],
res->field[i]) < 0) {
return S_REQUEST_TIMEOUT;
}
}
}
if (dprintf(fd, "\r\n") < 0) {
return S_REQUEST_TIMEOUT;
}
return res->status;
}
enum status
http_send_status(int fd, enum status s)
{
enum status sendstatus;
struct response res = {
.status = s,
.field[RES_CONTENT_TYPE] = "text/html; charset=utf-8",
};
if (s == S_METHOD_NOT_ALLOWED) {
if (esnprintf(res.field[RES_ALLOW],
sizeof(res.field[RES_ALLOW]), "%s",
"Allow: GET, HEAD")) {
return S_INTERNAL_SERVER_ERROR;
}
}
if ((sendstatus = http_send_header(fd, &res)) != s) {
return sendstatus;
}
if (dprintf(fd,
Refactor the single source file into multiple modules And many other things, too many to list here. For example, it now properly logs uds instead of erroring out. Separating concerns in many places definitely improves the readability.
2018-02-04 20:27:33 +00:00
"<!DOCTYPE html>\n<html>\n\t<head>\n"
"\t\t<title>%d %s</title>\n\t</head>\n\t<body>\n"
"\t\t<h1>%d %s</h1>\n\t</body>\n</html>\n",
s, status_str[s], s, status_str[s]) < 0) {
return S_REQUEST_TIMEOUT;
}
return s;
}
static void
Ensure const-correctness where possible and refactor parse_range() I know that the effect of 'const' on compiler optimizations is smaller than many believe, but it provides a good insight to the caller which parameters are not modified and simplifies parallelization, in case that is desired at a later point. Throughout processing, the big structs mostly remained unmodified, with the exception of parse_range(), which added a null-byte in the "Range"- header to simplify its parsing. This commit refactors parse_range() such that it won't modify this string anymore. Additionally, the parser was made even stricter: Usually, strtoll() (which is wrapped by strtonum()) allows whitespace and plus and minus signs before the number, which is not part of the specification. The stricter parser also better differentiates now between invalid requests and range-lists. In that context, the switch in http_send_response() was replaced for better readability. Signed-off-by: Laslo Hunhold <dev@frign.de>
2020-08-05 16:28:21 +00:00
decode(const char src[PATH_MAX], char dest[PATH_MAX])
Refactor the single source file into multiple modules And many other things, too many to list here. For example, it now properly logs uds instead of erroring out. Separating concerns in many places definitely improves the readability.
2018-02-04 20:27:33 +00:00
{
size_t i;
uint8_t n;
Ensure const-correctness where possible and refactor parse_range() I know that the effect of 'const' on compiler optimizations is smaller than many believe, but it provides a good insight to the caller which parameters are not modified and simplifies parallelization, in case that is desired at a later point. Throughout processing, the big structs mostly remained unmodified, with the exception of parse_range(), which added a null-byte in the "Range"- header to simplify its parsing. This commit refactors parse_range() such that it won't modify this string anymore. Additionally, the parser was made even stricter: Usually, strtoll() (which is wrapped by strtonum()) allows whitespace and plus and minus signs before the number, which is not part of the specification. The stricter parser also better differentiates now between invalid requests and range-lists. In that context, the switch in http_send_response() was replaced for better readability. Signed-off-by: Laslo Hunhold <dev@frign.de>
2020-08-05 16:28:21 +00:00
const char *s;
Refactor the single source file into multiple modules And many other things, too many to list here. For example, it now properly logs uds instead of erroring out. Separating concerns in many places definitely improves the readability.
2018-02-04 20:27:33 +00:00
for (s = src, i = 0; *s; s++, i++) {
Don't replace '+' with ' ' when decoding URLs After the initial report by Platon Ryzhikov, I couldn't validate this behaviour with the given RFC 3986[0], which only speaks of percent encoding for reserved characters. [0]:https://tools.ietf.org/html/rfc3986 Signed-off-by: Laslo Hunhold <dev@frign.de>
2019-01-10 21:02:23 +00:00
if (*s == '%' && (sscanf(s + 1, "%2hhx", &n) == 1)) {
Refactor the single source file into multiple modules And many other things, too many to list here. For example, it now properly logs uds instead of erroring out. Separating concerns in many places definitely improves the readability.
2018-02-04 20:27:33 +00:00
dest[i] = n;
s += 2;
} else {
dest[i] = *s;
}
}
dest[i] = '\0';
}
int
Rename request "r" to "req" Now that we have response-structs called "res", the naming "r" is a bit ambiguous. Signed-off-by: Laslo Hunhold <dev@frign.de>
2020-08-05 13:43:29 +00:00
http_get_request(int fd, struct request *req)
Refactor the single source file into multiple modules And many other things, too many to list here. For example, it now properly logs uds instead of erroring out. Separating concerns in many places definitely improves the readability.
2018-02-04 20:27:33 +00:00
{
Refactor response-generation I wasn't happy with how responses were generated. HTTP-headers were handled by hand and it was duplicated in multiple parts of the code. Due to the duplication, some functions like timestamp() had really ugly semantics. The HTTP requests are parsed much better: We have an enum of fields we care about that are automatically read into our request struct. This commit adapts this idea to the response: We have an enum of fields we might put into our response, and a response-struct holds the content of these fields. A function http_send_header() automatically sends a header based on the entries in response. In case we don't use a field, we just leave the field in the response-struct empty. With this commit, some logical changes came with it: - timestamp() now has a sane signature, TIMESTAMP_LEN is no more and it can now return proper errors and is also reentrant by using gmtime_r() instead of gmtime() - No more use of a static timestamp-array, making all the methods also reentrant - Better internal-error-reporting: Because the fields are filled before and not during sending the response-headers, we can better report any internal errors as status 500 instead of sending a partial non-500-header and then dying. These improved data structures make it easier to read and hack the code and implement new features, if desired. Signed-off-by: Laslo Hunhold <dev@frign.de>
2020-08-05 11:41:44 +00:00
struct in6_addr addr;
Refactor the single source file into multiple modules And many other things, too many to list here. For example, it now properly logs uds instead of erroring out. Separating concerns in many places definitely improves the readability.
2018-02-04 20:27:33 +00:00
size_t hlen, i, mlen;
ssize_t off;
char h[HEADER_MAX], *p, *q;
/* empty all fields */
Rename request "r" to "req" Now that we have response-structs called "res", the naming "r" is a bit ambiguous. Signed-off-by: Laslo Hunhold <dev@frign.de>
2020-08-05 13:43:29 +00:00
memset(req, 0, sizeof(*req));
Refactor the single source file into multiple modules And many other things, too many to list here. For example, it now properly logs uds instead of erroring out. Separating concerns in many places definitely improves the readability.
2018-02-04 20:27:33 +00:00
/*
* receive header
*/
for (hlen = 0; ;) {
if ((off = read(fd, h + hlen, sizeof(h) - hlen)) < 0) {
return http_send_status(fd, S_REQUEST_TIMEOUT);
} else if (off == 0) {
break;
}
hlen += off;
if (hlen >= 4 && !memcmp(h + hlen - 4, "\r\n\r\n", 4)) {
break;
}
if (hlen == sizeof(h)) {
return http_send_status(fd, S_REQUEST_TOO_LARGE);
}
}
/* remove terminating empty line */
if (hlen < 2) {
return http_send_status(fd, S_BAD_REQUEST);
}
hlen -= 2;
/* null-terminate the header */
h[hlen] = '\0';
/*
* parse request line
*/
/* METHOD */
for (i = 0; i < NUM_REQ_METHODS; i++) {
mlen = strlen(req_method_str[i]);
if (!strncmp(req_method_str[i], h, mlen)) {
Rename request "r" to "req" Now that we have response-structs called "res", the naming "r" is a bit ambiguous. Signed-off-by: Laslo Hunhold <dev@frign.de>
2020-08-05 13:43:29 +00:00
req->method = i;
Refactor the single source file into multiple modules And many other things, too many to list here. For example, it now properly logs uds instead of erroring out. Separating concerns in many places definitely improves the readability.
2018-02-04 20:27:33 +00:00
break;
}
}
if (i == NUM_REQ_METHODS) {
return http_send_status(fd, S_METHOD_NOT_ALLOWED);
}
/* a single space must follow the method */
if (h[mlen] != ' ') {
return http_send_status(fd, S_BAD_REQUEST);
}
/* basis for next step */
p = h + mlen + 1;
/* TARGET */
if (!(q = strchr(p, ' '))) {
return http_send_status(fd, S_BAD_REQUEST);
}
*q = '\0';
if (q - p + 1 > PATH_MAX) {
return http_send_status(fd, S_REQUEST_TOO_LARGE);
}
Rename request "r" to "req" Now that we have response-structs called "res", the naming "r" is a bit ambiguous. Signed-off-by: Laslo Hunhold <dev@frign.de>
2020-08-05 13:43:29 +00:00
memcpy(req->target, p, q - p + 1);
decode(req->target, req->target);
Refactor the single source file into multiple modules And many other things, too many to list here. For example, it now properly logs uds instead of erroring out. Separating concerns in many places definitely improves the readability.
2018-02-04 20:27:33 +00:00
/* basis for next step */
p = q + 1;
/* HTTP-VERSION */
if (strncmp(p, "HTTP/", sizeof("HTTP/") - 1)) {
return http_send_status(fd, S_BAD_REQUEST);
}
p += sizeof("HTTP/") - 1;
if (strncmp(p, "1.0", sizeof("1.0") - 1) &&
strncmp(p, "1.1", sizeof("1.1") - 1)) {
return http_send_status(fd, S_VERSION_NOT_SUPPORTED);
}
p += sizeof("1.*") - 1;
/* check terminator */
if (strncmp(p, "\r\n", sizeof("\r\n") - 1)) {
return http_send_status(fd, S_BAD_REQUEST);
}
/* basis for next step */
p += sizeof("\r\n") - 1;
/*
* parse request-fields
*/
/* match field type */
for (; *p != '\0';) {
for (i = 0; i < NUM_REQ_FIELDS; i++) {
if (!strncasecmp(p, req_field_str[i],
strlen(req_field_str[i]))) {
break;
}
}
if (i == NUM_REQ_FIELDS) {
/* unmatched field, skip this line */
if (!(q = strstr(p, "\r\n"))) {
return http_send_status(fd, S_BAD_REQUEST);
}
p = q + (sizeof("\r\n") - 1);
continue;
}
p += strlen(req_field_str[i]);
/* a single colon must follow the field name */
if (*p != ':') {
return http_send_status(fd, S_BAD_REQUEST);
}
/* skip whitespace */
for (++p; *p == ' ' || *p == '\t'; p++)
;
/* extract field content */
if (!(q = strstr(p, "\r\n"))) {
return http_send_status(fd, S_BAD_REQUEST);
}
*q = '\0';
if (q - p + 1 > FIELD_MAX) {
return http_send_status(fd, S_REQUEST_TOO_LARGE);
}
Rename request "r" to "req" Now that we have response-structs called "res", the naming "r" is a bit ambiguous. Signed-off-by: Laslo Hunhold <dev@frign.de>
2020-08-05 13:43:29 +00:00
memcpy(req->field[i], p, q - p + 1);
Refactor the single source file into multiple modules And many other things, too many to list here. For example, it now properly logs uds instead of erroring out. Separating concerns in many places definitely improves the readability.
2018-02-04 20:27:33 +00:00
/* go to next line */
p = q + (sizeof("\r\n") - 1);
}
Clean up request host properly We all agree that the IPv6 address format is a big clusterfuck and only an insane person would've come up with it given the double colons interfere with the way one actually appends a port to a normal IPv4 address. To counteract in this issue, the RFC specifies that one should enclose IPv6-addresses in square brackets to make the disctinction possible, i.e. host: ::1 port: 80 --> [::1]:80 The host field can contain both a port suffix and, of course by the RFC, have the address enclosed in square brackets. Given I personally see this as a "transport enclosure" I'd rather like to see it gone as soon as possible and thus implement this cleanup in the http-header-parser so the output is nice and clean and we don't have to deal with this garbage later on. Thanks to Josuah Demangeon <mail@josuah.net> for his wonderful input and his dedication to read the RFCs 3986 and 2732 in such great detail.
2018-04-02 22:55:52 +00:00
/*
* clean up host
*/
Rename request "r" to "req" Now that we have response-structs called "res", the naming "r" is a bit ambiguous. Signed-off-by: Laslo Hunhold <dev@frign.de>
2020-08-05 13:43:29 +00:00
p = strrchr(req->field[REQ_HOST], ':');
q = strrchr(req->field[REQ_HOST], ']');
Clean up request host properly We all agree that the IPv6 address format is a big clusterfuck and only an insane person would've come up with it given the double colons interfere with the way one actually appends a port to a normal IPv4 address. To counteract in this issue, the RFC specifies that one should enclose IPv6-addresses in square brackets to make the disctinction possible, i.e. host: ::1 port: 80 --> [::1]:80 The host field can contain both a port suffix and, of course by the RFC, have the address enclosed in square brackets. Given I personally see this as a "transport enclosure" I'd rather like to see it gone as soon as possible and thus implement this cleanup in the http-header-parser so the output is nice and clean and we don't have to deal with this garbage later on. Thanks to Josuah Demangeon <mail@josuah.net> for his wonderful input and his dedication to read the RFCs 3986 and 2732 in such great detail.
2018-04-02 22:55:52 +00:00
/* strip port suffix but don't interfere with IPv6 bracket notation
* as per RFC 2732 */
if (p && (!q || p > q)) {
/* port suffix must not be empty */
if (*(p + 1) == '\0') {
return http_send_status(fd, S_BAD_REQUEST);
}
*p = '\0';
}
/* strip the brackets from the IPv6 notation and validate the address */
if (q) {
/* brackets must be on the outside */
Rename request "r" to "req" Now that we have response-structs called "res", the naming "r" is a bit ambiguous. Signed-off-by: Laslo Hunhold <dev@frign.de>
2020-08-05 13:43:29 +00:00
if (req->field[REQ_HOST][0] != '[' || *(q + 1) != '\0') {
Clean up request host properly We all agree that the IPv6 address format is a big clusterfuck and only an insane person would've come up with it given the double colons interfere with the way one actually appends a port to a normal IPv4 address. To counteract in this issue, the RFC specifies that one should enclose IPv6-addresses in square brackets to make the disctinction possible, i.e. host: ::1 port: 80 --> [::1]:80 The host field can contain both a port suffix and, of course by the RFC, have the address enclosed in square brackets. Given I personally see this as a "transport enclosure" I'd rather like to see it gone as soon as possible and thus implement this cleanup in the http-header-parser so the output is nice and clean and we don't have to deal with this garbage later on. Thanks to Josuah Demangeon <mail@josuah.net> for his wonderful input and his dedication to read the RFCs 3986 and 2732 in such great detail.
2018-04-02 22:55:52 +00:00
return http_send_status(fd, S_BAD_REQUEST);
}
/* remove the right bracket */
*q = '\0';
Rename request "r" to "req" Now that we have response-structs called "res", the naming "r" is a bit ambiguous. Signed-off-by: Laslo Hunhold <dev@frign.de>
2020-08-05 13:43:29 +00:00
p = req->field[REQ_HOST] + 1;
Clean up request host properly We all agree that the IPv6 address format is a big clusterfuck and only an insane person would've come up with it given the double colons interfere with the way one actually appends a port to a normal IPv4 address. To counteract in this issue, the RFC specifies that one should enclose IPv6-addresses in square brackets to make the disctinction possible, i.e. host: ::1 port: 80 --> [::1]:80 The host field can contain both a port suffix and, of course by the RFC, have the address enclosed in square brackets. Given I personally see this as a "transport enclosure" I'd rather like to see it gone as soon as possible and thus implement this cleanup in the http-header-parser so the output is nice and clean and we don't have to deal with this garbage later on. Thanks to Josuah Demangeon <mail@josuah.net> for his wonderful input and his dedication to read the RFCs 3986 and 2732 in such great detail.
2018-04-02 22:55:52 +00:00
/* validate the contained IPv6 address */
Refactor response-generation I wasn't happy with how responses were generated. HTTP-headers were handled by hand and it was duplicated in multiple parts of the code. Due to the duplication, some functions like timestamp() had really ugly semantics. The HTTP requests are parsed much better: We have an enum of fields we care about that are automatically read into our request struct. This commit adapts this idea to the response: We have an enum of fields we might put into our response, and a response-struct holds the content of these fields. A function http_send_header() automatically sends a header based on the entries in response. In case we don't use a field, we just leave the field in the response-struct empty. With this commit, some logical changes came with it: - timestamp() now has a sane signature, TIMESTAMP_LEN is no more and it can now return proper errors and is also reentrant by using gmtime_r() instead of gmtime() - No more use of a static timestamp-array, making all the methods also reentrant - Better internal-error-reporting: Because the fields are filled before and not during sending the response-headers, we can better report any internal errors as status 500 instead of sending a partial non-500-header and then dying. These improved data structures make it easier to read and hack the code and implement new features, if desired. Signed-off-by: Laslo Hunhold <dev@frign.de>
2020-08-05 11:41:44 +00:00
if (inet_pton(AF_INET6, p, &addr) != 1) {
Clean up request host properly We all agree that the IPv6 address format is a big clusterfuck and only an insane person would've come up with it given the double colons interfere with the way one actually appends a port to a normal IPv4 address. To counteract in this issue, the RFC specifies that one should enclose IPv6-addresses in square brackets to make the disctinction possible, i.e. host: ::1 port: 80 --> [::1]:80 The host field can contain both a port suffix and, of course by the RFC, have the address enclosed in square brackets. Given I personally see this as a "transport enclosure" I'd rather like to see it gone as soon as possible and thus implement this cleanup in the http-header-parser so the output is nice and clean and we don't have to deal with this garbage later on. Thanks to Josuah Demangeon <mail@josuah.net> for his wonderful input and his dedication to read the RFCs 3986 and 2732 in such great detail.
2018-04-02 22:55:52 +00:00
return http_send_status(fd, S_BAD_REQUEST);
}
/* copy it into the host field */
Rename request "r" to "req" Now that we have response-structs called "res", the naming "r" is a bit ambiguous. Signed-off-by: Laslo Hunhold <dev@frign.de>
2020-08-05 13:43:29 +00:00
memmove(req->field[REQ_HOST], p, q - p + 1);
Clean up request host properly We all agree that the IPv6 address format is a big clusterfuck and only an insane person would've come up with it given the double colons interfere with the way one actually appends a port to a normal IPv4 address. To counteract in this issue, the RFC specifies that one should enclose IPv6-addresses in square brackets to make the disctinction possible, i.e. host: ::1 port: 80 --> [::1]:80 The host field can contain both a port suffix and, of course by the RFC, have the address enclosed in square brackets. Given I personally see this as a "transport enclosure" I'd rather like to see it gone as soon as possible and thus implement this cleanup in the http-header-parser so the output is nice and clean and we don't have to deal with this garbage later on. Thanks to Josuah Demangeon <mail@josuah.net> for his wonderful input and his dedication to read the RFCs 3986 and 2732 in such great detail.
2018-04-02 22:55:52 +00:00
}
Refactor the single source file into multiple modules And many other things, too many to list here. For example, it now properly logs uds instead of erroring out. Separating concerns in many places definitely improves the readability.
2018-02-04 20:27:33 +00:00
return 0;
}
static void
Ensure const-correctness where possible and refactor parse_range() I know that the effect of 'const' on compiler optimizations is smaller than many believe, but it provides a good insight to the caller which parameters are not modified and simplifies parallelization, in case that is desired at a later point. Throughout processing, the big structs mostly remained unmodified, with the exception of parse_range(), which added a null-byte in the "Range"- header to simplify its parsing. This commit refactors parse_range() such that it won't modify this string anymore. Additionally, the parser was made even stricter: Usually, strtoll() (which is wrapped by strtonum()) allows whitespace and plus and minus signs before the number, which is not part of the specification. The stricter parser also better differentiates now between invalid requests and range-lists. In that context, the switch in http_send_response() was replaced for better readability. Signed-off-by: Laslo Hunhold <dev@frign.de>
2020-08-05 16:28:21 +00:00
encode(const char src[PATH_MAX], char dest[PATH_MAX])
Refactor the single source file into multiple modules And many other things, too many to list here. For example, it now properly logs uds instead of erroring out. Separating concerns in many places definitely improves the readability.
2018-02-04 20:27:33 +00:00
{
size_t i;
Ensure const-correctness where possible and refactor parse_range() I know that the effect of 'const' on compiler optimizations is smaller than many believe, but it provides a good insight to the caller which parameters are not modified and simplifies parallelization, in case that is desired at a later point. Throughout processing, the big structs mostly remained unmodified, with the exception of parse_range(), which added a null-byte in the "Range"- header to simplify its parsing. This commit refactors parse_range() such that it won't modify this string anymore. Additionally, the parser was made even stricter: Usually, strtoll() (which is wrapped by strtonum()) allows whitespace and plus and minus signs before the number, which is not part of the specification. The stricter parser also better differentiates now between invalid requests and range-lists. In that context, the switch in http_send_response() was replaced for better readability. Signed-off-by: Laslo Hunhold <dev@frign.de>
2020-08-05 16:28:21 +00:00
const char *s;
Refactor the single source file into multiple modules And many other things, too many to list here. For example, it now properly logs uds instead of erroring out. Separating concerns in many places definitely improves the readability.
2018-02-04 20:27:33 +00:00
for (s = src, i = 0; *s && i < (PATH_MAX - 4); s++) {
if (iscntrl(*s) || (unsigned char)*s > 127) {
i += snprintf(dest + i, PATH_MAX - i, "%%%02X",
(unsigned char)*s);
} else {
dest[i] = *s;
i++;
}
}
dest[i] = '\0';
}
static int
normabspath(char *path)
{
size_t len;
int last = 0;
char *p, *q;
/* require and skip first slash */
if (path[0] != '/') {
return 1;
}
p = path + 1;
/* get length of path */
len = strlen(p);
for (; !last; ) {
/* bound path component within (p,q) */
if (!(q = strchr(p, '/'))) {
q = strchr(p, '\0');
last = 1;
}
if (p == q || (q - p == 1 && p[0] == '.')) {
/* "/" or "./" */
goto squash;
} else if (q - p == 2 && p[0] == '.' && p[1] == '.') {
/* "../" */
if (p != path + 1) {
/* place p right after the previous / */
for (p -= 2; p > path && *p != '/'; p--);
p++;
}
goto squash;
} else {
/* move on */
p = q + 1;
continue;
}
squash:
/* squash (p,q) into void */
if (last) {
*p = '\0';
len = p - path;
} else {
memmove(p, q + 1, len - ((q + 1) - path) + 2);
len -= (q + 1) - p;
}
}
return 0;
}
Refactor range-parsing into a separate function The method http_send_response() is already long enough and this separation of concerns both helps shorten it a bit, improves readability and reduces the chance of programming errors. Signed-off-by: Laslo Hunhold <dev@frign.de>
2020-08-04 14:31:08 +00:00
static enum status
Replace off_t with size_t While off_t might be better suited for file-offsets and -sizes, the IEEE Computer Society was unable to mandate limits (min, max) for it in the POSIX specification in the last 32 years. Because it's impossible to portably determine these numbers for signed integers, I decided to switch to size_t for the offsets to be able to pass proper values to strtonum(), because C99 is sane and has defined limits for size_t (i.e. SIZE_MIN and SIZE_MAX). On my system, long long and off_t have the same size, so it didn't trigger any bugs, but strtonum() could pass a bigger number to lower and upper than they can handle and make them overflow. The rationale for switching to size_t is actually given by the fact that functions like mmap() blur the border between memory and filesystem. Another point is that glibc has a horrible define _FILE_OFFSET_BITS you need to set to 64 to actually get decent values for off_t, which was a huge headache in sbase until we found that out. Signed-off-by: Laslo Hunhold <dev@frign.de>
2020-08-05 16:59:55 +00:00
parse_range(const char *str, size_t size, size_t *lower, size_t *upper)
Refactor range-parsing into a separate function The method http_send_response() is already long enough and this separation of concerns both helps shorten it a bit, improves readability and reduces the chance of programming errors. Signed-off-by: Laslo Hunhold <dev@frign.de>
2020-08-04 14:31:08 +00:00
{
Ensure const-correctness where possible and refactor parse_range() I know that the effect of 'const' on compiler optimizations is smaller than many believe, but it provides a good insight to the caller which parameters are not modified and simplifies parallelization, in case that is desired at a later point. Throughout processing, the big structs mostly remained unmodified, with the exception of parse_range(), which added a null-byte in the "Range"- header to simplify its parsing. This commit refactors parse_range() such that it won't modify this string anymore. Additionally, the parser was made even stricter: Usually, strtoll() (which is wrapped by strtonum()) allows whitespace and plus and minus signs before the number, which is not part of the specification. The stricter parser also better differentiates now between invalid requests and range-lists. In that context, the switch in http_send_response() was replaced for better readability. Signed-off-by: Laslo Hunhold <dev@frign.de>
2020-08-05 16:28:21 +00:00
char first[FIELD_MAX], last[FIELD_MAX];
const char *p, *q, *r, *err;
Refactor range-parsing into a separate function The method http_send_response() is already long enough and this separation of concerns both helps shorten it a bit, improves readability and reduces the chance of programming errors. Signed-off-by: Laslo Hunhold <dev@frign.de>
2020-08-04 14:31:08 +00:00
/* default to the complete range */
*lower = 0;
*upper = size - 1;
/* done if no range-string is given */
Ensure const-correctness where possible and refactor parse_range() I know that the effect of 'const' on compiler optimizations is smaller than many believe, but it provides a good insight to the caller which parameters are not modified and simplifies parallelization, in case that is desired at a later point. Throughout processing, the big structs mostly remained unmodified, with the exception of parse_range(), which added a null-byte in the "Range"- header to simplify its parsing. This commit refactors parse_range() such that it won't modify this string anymore. Additionally, the parser was made even stricter: Usually, strtoll() (which is wrapped by strtonum()) allows whitespace and plus and minus signs before the number, which is not part of the specification. The stricter parser also better differentiates now between invalid requests and range-lists. In that context, the switch in http_send_response() was replaced for better readability. Signed-off-by: Laslo Hunhold <dev@frign.de>
2020-08-05 16:28:21 +00:00
if (str == NULL || *str == '\0') {
Refactor range-parsing into a separate function The method http_send_response() is already long enough and this separation of concerns both helps shorten it a bit, improves readability and reduces the chance of programming errors. Signed-off-by: Laslo Hunhold <dev@frign.de>
2020-08-04 14:31:08 +00:00
return 0;
}
/* skip opening statement */
Ensure const-correctness where possible and refactor parse_range() I know that the effect of 'const' on compiler optimizations is smaller than many believe, but it provides a good insight to the caller which parameters are not modified and simplifies parallelization, in case that is desired at a later point. Throughout processing, the big structs mostly remained unmodified, with the exception of parse_range(), which added a null-byte in the "Range"- header to simplify its parsing. This commit refactors parse_range() such that it won't modify this string anymore. Additionally, the parser was made even stricter: Usually, strtoll() (which is wrapped by strtonum()) allows whitespace and plus and minus signs before the number, which is not part of the specification. The stricter parser also better differentiates now between invalid requests and range-lists. In that context, the switch in http_send_response() was replaced for better readability. Signed-off-by: Laslo Hunhold <dev@frign.de>
2020-08-05 16:28:21 +00:00
if (strncmp(str, "bytes=", sizeof("bytes=") - 1)) {
Refactor range-parsing into a separate function The method http_send_response() is already long enough and this separation of concerns both helps shorten it a bit, improves readability and reduces the chance of programming errors. Signed-off-by: Laslo Hunhold <dev@frign.de>
2020-08-04 14:31:08 +00:00
return S_BAD_REQUEST;
}
Ensure const-correctness where possible and refactor parse_range() I know that the effect of 'const' on compiler optimizations is smaller than many believe, but it provides a good insight to the caller which parameters are not modified and simplifies parallelization, in case that is desired at a later point. Throughout processing, the big structs mostly remained unmodified, with the exception of parse_range(), which added a null-byte in the "Range"- header to simplify its parsing. This commit refactors parse_range() such that it won't modify this string anymore. Additionally, the parser was made even stricter: Usually, strtoll() (which is wrapped by strtonum()) allows whitespace and plus and minus signs before the number, which is not part of the specification. The stricter parser also better differentiates now between invalid requests and range-lists. In that context, the switch in http_send_response() was replaced for better readability. Signed-off-by: Laslo Hunhold <dev@frign.de>
2020-08-05 16:28:21 +00:00
p = str + (sizeof("bytes=") - 1);
Refactor range-parsing into a separate function The method http_send_response() is already long enough and this separation of concerns both helps shorten it a bit, improves readability and reduces the chance of programming errors. Signed-off-by: Laslo Hunhold <dev@frign.de>
2020-08-04 14:31:08 +00:00
Ensure const-correctness where possible and refactor parse_range() I know that the effect of 'const' on compiler optimizations is smaller than many believe, but it provides a good insight to the caller which parameters are not modified and simplifies parallelization, in case that is desired at a later point. Throughout processing, the big structs mostly remained unmodified, with the exception of parse_range(), which added a null-byte in the "Range"- header to simplify its parsing. This commit refactors parse_range() such that it won't modify this string anymore. Additionally, the parser was made even stricter: Usually, strtoll() (which is wrapped by strtonum()) allows whitespace and plus and minus signs before the number, which is not part of the specification. The stricter parser also better differentiates now between invalid requests and range-lists. In that context, the switch in http_send_response() was replaced for better readability. Signed-off-by: Laslo Hunhold <dev@frign.de>
2020-08-05 16:28:21 +00:00
/* check string (should only contain numbers and a hyphen) */
for (r = p, q = NULL; *r != '\0'; r++) {
if (*r < '0' || *r > '9') {
if (*r == '-') {
if (q != NULL) {
/* we have already seen a hyphen */
return S_BAD_REQUEST;
} else {
/* place q after the hyphen */
q = r + 1;
}
} else if (*r == ',' && r > p) {
/*
* we refuse to accept range-lists out
* of spite towards this horrible part
* of the spec
*/
return S_RANGE_NOT_SATISFIABLE;
} else {
return S_BAD_REQUEST;
}
}
}
if (q == NULL) {
/* the input string must contain a hyphen */
Refactor range-parsing into a separate function The method http_send_response() is already long enough and this separation of concerns both helps shorten it a bit, improves readability and reduces the chance of programming errors. Signed-off-by: Laslo Hunhold <dev@frign.de>
2020-08-04 14:31:08 +00:00
return S_BAD_REQUEST;
}
Ensure const-correctness where possible and refactor parse_range() I know that the effect of 'const' on compiler optimizations is smaller than many believe, but it provides a good insight to the caller which parameters are not modified and simplifies parallelization, in case that is desired at a later point. Throughout processing, the big structs mostly remained unmodified, with the exception of parse_range(), which added a null-byte in the "Range"- header to simplify its parsing. This commit refactors parse_range() such that it won't modify this string anymore. Additionally, the parser was made even stricter: Usually, strtoll() (which is wrapped by strtonum()) allows whitespace and plus and minus signs before the number, which is not part of the specification. The stricter parser also better differentiates now between invalid requests and range-lists. In that context, the switch in http_send_response() was replaced for better readability. Signed-off-by: Laslo Hunhold <dev@frign.de>
2020-08-05 16:28:21 +00:00
r = q + strlen(q);
Refactor range-parsing into a separate function The method http_send_response() is already long enough and this separation of concerns both helps shorten it a bit, improves readability and reduces the chance of programming errors. Signed-off-by: Laslo Hunhold <dev@frign.de>
2020-08-04 14:31:08 +00:00
/*
Ensure const-correctness where possible and refactor parse_range() I know that the effect of 'const' on compiler optimizations is smaller than many believe, but it provides a good insight to the caller which parameters are not modified and simplifies parallelization, in case that is desired at a later point. Throughout processing, the big structs mostly remained unmodified, with the exception of parse_range(), which added a null-byte in the "Range"- header to simplify its parsing. This commit refactors parse_range() such that it won't modify this string anymore. Additionally, the parser was made even stricter: Usually, strtoll() (which is wrapped by strtonum()) allows whitespace and plus and minus signs before the number, which is not part of the specification. The stricter parser also better differentiates now between invalid requests and range-lists. In that context, the switch in http_send_response() was replaced for better readability. Signed-off-by: Laslo Hunhold <dev@frign.de>
2020-08-05 16:28:21 +00:00
* byte-range=first-last\0
* ^ ^ ^
* | | |
* p q r
Refactor range-parsing into a separate function The method http_send_response() is already long enough and this separation of concerns both helps shorten it a bit, improves readability and reduces the chance of programming errors. Signed-off-by: Laslo Hunhold <dev@frign.de>
2020-08-04 14:31:08 +00:00
*/
Ensure const-correctness where possible and refactor parse_range() I know that the effect of 'const' on compiler optimizations is smaller than many believe, but it provides a good insight to the caller which parameters are not modified and simplifies parallelization, in case that is desired at a later point. Throughout processing, the big structs mostly remained unmodified, with the exception of parse_range(), which added a null-byte in the "Range"- header to simplify its parsing. This commit refactors parse_range() such that it won't modify this string anymore. Additionally, the parser was made even stricter: Usually, strtoll() (which is wrapped by strtonum()) allows whitespace and plus and minus signs before the number, which is not part of the specification. The stricter parser also better differentiates now between invalid requests and range-lists. In that context, the switch in http_send_response() was replaced for better readability. Signed-off-by: Laslo Hunhold <dev@frign.de>
2020-08-05 16:28:21 +00:00
/* copy 'first' and 'last' to their respective arrays */
if ((size_t)((q - 1) - p + 1) > sizeof(first) ||
(size_t)(r - q + 1) > sizeof(last)) {
return S_REQUEST_TOO_LARGE;
Refactor range-parsing into a separate function The method http_send_response() is already long enough and this separation of concerns both helps shorten it a bit, improves readability and reduces the chance of programming errors. Signed-off-by: Laslo Hunhold <dev@frign.de>
2020-08-04 14:31:08 +00:00
}
Ensure const-correctness where possible and refactor parse_range() I know that the effect of 'const' on compiler optimizations is smaller than many believe, but it provides a good insight to the caller which parameters are not modified and simplifies parallelization, in case that is desired at a later point. Throughout processing, the big structs mostly remained unmodified, with the exception of parse_range(), which added a null-byte in the "Range"- header to simplify its parsing. This commit refactors parse_range() such that it won't modify this string anymore. Additionally, the parser was made even stricter: Usually, strtoll() (which is wrapped by strtonum()) allows whitespace and plus and minus signs before the number, which is not part of the specification. The stricter parser also better differentiates now between invalid requests and range-lists. In that context, the switch in http_send_response() was replaced for better readability. Signed-off-by: Laslo Hunhold <dev@frign.de>
2020-08-05 16:28:21 +00:00
memcpy(first, p, (q - 1) - p);
first[(q - 1) - p] = '\0';
memcpy(last, q, r - q);
last[r - q] = '\0';
Refactor range-parsing into a separate function The method http_send_response() is already long enough and this separation of concerns both helps shorten it a bit, improves readability and reduces the chance of programming errors. Signed-off-by: Laslo Hunhold <dev@frign.de>
2020-08-04 14:31:08 +00:00
Ensure const-correctness where possible and refactor parse_range() I know that the effect of 'const' on compiler optimizations is smaller than many believe, but it provides a good insight to the caller which parameters are not modified and simplifies parallelization, in case that is desired at a later point. Throughout processing, the big structs mostly remained unmodified, with the exception of parse_range(), which added a null-byte in the "Range"- header to simplify its parsing. This commit refactors parse_range() such that it won't modify this string anymore. Additionally, the parser was made even stricter: Usually, strtoll() (which is wrapped by strtonum()) allows whitespace and plus and minus signs before the number, which is not part of the specification. The stricter parser also better differentiates now between invalid requests and range-lists. In that context, the switch in http_send_response() was replaced for better readability. Signed-off-by: Laslo Hunhold <dev@frign.de>
2020-08-05 16:28:21 +00:00
if (first[0] != '\0') {
Refactor range-parsing into a separate function The method http_send_response() is already long enough and this separation of concerns both helps shorten it a bit, improves readability and reduces the chance of programming errors. Signed-off-by: Laslo Hunhold <dev@frign.de>
2020-08-04 14:31:08 +00:00
/*
Ensure const-correctness where possible and refactor parse_range() I know that the effect of 'const' on compiler optimizations is smaller than many believe, but it provides a good insight to the caller which parameters are not modified and simplifies parallelization, in case that is desired at a later point. Throughout processing, the big structs mostly remained unmodified, with the exception of parse_range(), which added a null-byte in the "Range"- header to simplify its parsing. This commit refactors parse_range() such that it won't modify this string anymore. Additionally, the parser was made even stricter: Usually, strtoll() (which is wrapped by strtonum()) allows whitespace and plus and minus signs before the number, which is not part of the specification. The stricter parser also better differentiates now between invalid requests and range-lists. In that context, the switch in http_send_response() was replaced for better readability. Signed-off-by: Laslo Hunhold <dev@frign.de>
2020-08-05 16:28:21 +00:00
* range has format "first-last" or "first-",
Refactor range-parsing into a separate function The method http_send_response() is already long enough and this separation of concerns both helps shorten it a bit, improves readability and reduces the chance of programming errors. Signed-off-by: Laslo Hunhold <dev@frign.de>
2020-08-04 14:31:08 +00:00
* i.e. return bytes 'first' to 'last' (or the
* last byte if 'last' is not given),
* inclusively, and byte-numbering beginning at 0
*/
Replace off_t with size_t While off_t might be better suited for file-offsets and -sizes, the IEEE Computer Society was unable to mandate limits (min, max) for it in the POSIX specification in the last 32 years. Because it's impossible to portably determine these numbers for signed integers, I decided to switch to size_t for the offsets to be able to pass proper values to strtonum(), because C99 is sane and has defined limits for size_t (i.e. SIZE_MIN and SIZE_MAX). On my system, long long and off_t have the same size, so it didn't trigger any bugs, but strtonum() could pass a bigger number to lower and upper than they can handle and make them overflow. The rationale for switching to size_t is actually given by the fact that functions like mmap() blur the border between memory and filesystem. Another point is that glibc has a horrible define _FILE_OFFSET_BITS you need to set to 64 to actually get decent values for off_t, which was a huge headache in sbase until we found that out. Signed-off-by: Laslo Hunhold <dev@frign.de>
2020-08-05 16:59:55 +00:00
*lower = strtonum(first, 0, SIZE_MAX, &err);
Refactor range-parsing into a separate function The method http_send_response() is already long enough and this separation of concerns both helps shorten it a bit, improves readability and reduces the chance of programming errors. Signed-off-by: Laslo Hunhold <dev@frign.de>
2020-08-04 14:31:08 +00:00
if (!err) {
Ensure const-correctness where possible and refactor parse_range() I know that the effect of 'const' on compiler optimizations is smaller than many believe, but it provides a good insight to the caller which parameters are not modified and simplifies parallelization, in case that is desired at a later point. Throughout processing, the big structs mostly remained unmodified, with the exception of parse_range(), which added a null-byte in the "Range"- header to simplify its parsing. This commit refactors parse_range() such that it won't modify this string anymore. Additionally, the parser was made even stricter: Usually, strtoll() (which is wrapped by strtonum()) allows whitespace and plus and minus signs before the number, which is not part of the specification. The stricter parser also better differentiates now between invalid requests and range-lists. In that context, the switch in http_send_response() was replaced for better readability. Signed-off-by: Laslo Hunhold <dev@frign.de>
2020-08-05 16:28:21 +00:00
if (last[0] != '\0') {
Replace off_t with size_t While off_t might be better suited for file-offsets and -sizes, the IEEE Computer Society was unable to mandate limits (min, max) for it in the POSIX specification in the last 32 years. Because it's impossible to portably determine these numbers for signed integers, I decided to switch to size_t for the offsets to be able to pass proper values to strtonum(), because C99 is sane and has defined limits for size_t (i.e. SIZE_MIN and SIZE_MAX). On my system, long long and off_t have the same size, so it didn't trigger any bugs, but strtonum() could pass a bigger number to lower and upper than they can handle and make them overflow. The rationale for switching to size_t is actually given by the fact that functions like mmap() blur the border between memory and filesystem. Another point is that glibc has a horrible define _FILE_OFFSET_BITS you need to set to 64 to actually get decent values for off_t, which was a huge headache in sbase until we found that out. Signed-off-by: Laslo Hunhold <dev@frign.de>
2020-08-05 16:59:55 +00:00
*upper = strtonum(last, 0, SIZE_MAX, &err);
Refactor range-parsing into a separate function The method http_send_response() is already long enough and this separation of concerns both helps shorten it a bit, improves readability and reduces the chance of programming errors. Signed-off-by: Laslo Hunhold <dev@frign.de>
2020-08-04 14:31:08 +00:00
} else {
*upper = size - 1;
}
}
if (err) {
/* one of the strtonum()'s failed */
return S_BAD_REQUEST;
}
/* check ranges */
if (*lower > *upper || *lower >= size) {
return S_RANGE_NOT_SATISFIABLE;
}
/* adjust upper limit to be at most the last byte */
*upper = MIN(*upper, size - 1);
} else {
Ensure const-correctness where possible and refactor parse_range() I know that the effect of 'const' on compiler optimizations is smaller than many believe, but it provides a good insight to the caller which parameters are not modified and simplifies parallelization, in case that is desired at a later point. Throughout processing, the big structs mostly remained unmodified, with the exception of parse_range(), which added a null-byte in the "Range"- header to simplify its parsing. This commit refactors parse_range() such that it won't modify this string anymore. Additionally, the parser was made even stricter: Usually, strtoll() (which is wrapped by strtonum()) allows whitespace and plus and minus signs before the number, which is not part of the specification. The stricter parser also better differentiates now between invalid requests and range-lists. In that context, the switch in http_send_response() was replaced for better readability. Signed-off-by: Laslo Hunhold <dev@frign.de>
2020-08-05 16:28:21 +00:00
/* last must not also be empty */
if (last[0] == '\0') {
return S_BAD_REQUEST;
}
Refactor range-parsing into a separate function The method http_send_response() is already long enough and this separation of concerns both helps shorten it a bit, improves readability and reduces the chance of programming errors. Signed-off-by: Laslo Hunhold <dev@frign.de>
2020-08-04 14:31:08 +00:00
/*
* Range has format "-num", i.e. return the 'num'
* last bytes
*/
/*
* use upper as a temporary storage for 'num',
* as we know 'upper' is size - 1
*/
Replace off_t with size_t While off_t might be better suited for file-offsets and -sizes, the IEEE Computer Society was unable to mandate limits (min, max) for it in the POSIX specification in the last 32 years. Because it's impossible to portably determine these numbers for signed integers, I decided to switch to size_t for the offsets to be able to pass proper values to strtonum(), because C99 is sane and has defined limits for size_t (i.e. SIZE_MIN and SIZE_MAX). On my system, long long and off_t have the same size, so it didn't trigger any bugs, but strtonum() could pass a bigger number to lower and upper than they can handle and make them overflow. The rationale for switching to size_t is actually given by the fact that functions like mmap() blur the border between memory and filesystem. Another point is that glibc has a horrible define _FILE_OFFSET_BITS you need to set to 64 to actually get decent values for off_t, which was a huge headache in sbase until we found that out. Signed-off-by: Laslo Hunhold <dev@frign.de>
2020-08-05 16:59:55 +00:00
*upper = strtonum(last, 0, SIZE_MAX, &err);
Refactor range-parsing into a separate function The method http_send_response() is already long enough and this separation of concerns both helps shorten it a bit, improves readability and reduces the chance of programming errors. Signed-off-by: Laslo Hunhold <dev@frign.de>
2020-08-04 14:31:08 +00:00
if (err) {
return S_BAD_REQUEST;
}
/* determine lower */
if (*upper > size) {
/* more bytes requested than we have */
*lower = 0;
} else {
*lower = size - *upper;
}
/* set upper to the correct value */
*upper = size - 1;
}
return 0;
}
Refactor the single source file into multiple modules And many other things, too many to list here. For example, it now properly logs uds instead of erroring out. Separating concerns in many places definitely improves the readability.
2018-02-04 20:27:33 +00:00
#undef RELPATH
#define RELPATH(x) ((!*(x) || !strcmp(x, "/")) ? "." : ((x) + 1))
enum status
Ensure const-correctness where possible and refactor parse_range() I know that the effect of 'const' on compiler optimizations is smaller than many believe, but it provides a good insight to the caller which parameters are not modified and simplifies parallelization, in case that is desired at a later point. Throughout processing, the big structs mostly remained unmodified, with the exception of parse_range(), which added a null-byte in the "Range"- header to simplify its parsing. This commit refactors parse_range() such that it won't modify this string anymore. Additionally, the parser was made even stricter: Usually, strtoll() (which is wrapped by strtonum()) allows whitespace and plus and minus signs before the number, which is not part of the specification. The stricter parser also better differentiates now between invalid requests and range-lists. In that context, the switch in http_send_response() was replaced for better readability. Signed-off-by: Laslo Hunhold <dev@frign.de>
2020-08-05 16:28:21 +00:00
http_send_response(int fd, const struct request *req)
Refactor the single source file into multiple modules And many other things, too many to list here. For example, it now properly logs uds instead of erroring out. Separating concerns in many places definitely improves the readability.
2018-02-04 20:27:33 +00:00
{
Ensure const-correctness where possible and refactor parse_range() I know that the effect of 'const' on compiler optimizations is smaller than many believe, but it provides a good insight to the caller which parameters are not modified and simplifies parallelization, in case that is desired at a later point. Throughout processing, the big structs mostly remained unmodified, with the exception of parse_range(), which added a null-byte in the "Range"- header to simplify its parsing. This commit refactors parse_range() such that it won't modify this string anymore. Additionally, the parser was made even stricter: Usually, strtoll() (which is wrapped by strtonum()) allows whitespace and plus and minus signs before the number, which is not part of the specification. The stricter parser also better differentiates now between invalid requests and range-lists. In that context, the switch in http_send_response() was replaced for better readability. Signed-off-by: Laslo Hunhold <dev@frign.de>
2020-08-05 16:28:21 +00:00
enum status returnstatus;
Refactor response-generation I wasn't happy with how responses were generated. HTTP-headers were handled by hand and it was duplicated in multiple parts of the code. Due to the duplication, some functions like timestamp() had really ugly semantics. The HTTP requests are parsed much better: We have an enum of fields we care about that are automatically read into our request struct. This commit adapts this idea to the response: We have an enum of fields we might put into our response, and a response-struct holds the content of these fields. A function http_send_header() automatically sends a header based on the entries in response. In case we don't use a field, we just leave the field in the response-struct empty. With this commit, some logical changes came with it: - timestamp() now has a sane signature, TIMESTAMP_LEN is no more and it can now return proper errors and is also reentrant by using gmtime_r() instead of gmtime() - No more use of a static timestamp-array, making all the methods also reentrant - Better internal-error-reporting: Because the fields are filled before and not during sending the response-headers, we can better report any internal errors as status 500 instead of sending a partial non-500-header and then dying. These improved data structures make it easier to read and hack the code and implement new features, if desired. Signed-off-by: Laslo Hunhold <dev@frign.de>
2020-08-05 11:41:44 +00:00
struct in6_addr addr;
struct response res = { 0 };
Refactor the single source file into multiple modules And many other things, too many to list here. For example, it now properly logs uds instead of erroring out. Separating concerns in many places definitely improves the readability.
2018-02-04 20:27:33 +00:00
struct stat st;
Explicitly initialize struct tm with zeroes This is recommended by the manual as strptime(), in principle, might only touch the fields it parses from the string. Given the struct tm implementations differ from operating system to operating system, we make sure and set everything to zero before passing it to strptime(). Signed-off-by: Laslo Hunhold <dev@frign.de>
2020-07-23 14:54:21 +00:00
struct tm tm = { 0 };
Refactor the single source file into multiple modules And many other things, too many to list here. For example, it now properly logs uds instead of erroring out. Separating concerns in many places definitely improves the readability.
2018-02-04 20:27:33 +00:00
size_t len, i;
Replace off_t with size_t While off_t might be better suited for file-offsets and -sizes, the IEEE Computer Society was unable to mandate limits (min, max) for it in the POSIX specification in the last 32 years. Because it's impossible to portably determine these numbers for signed integers, I decided to switch to size_t for the offsets to be able to pass proper values to strtonum(), because C99 is sane and has defined limits for size_t (i.e. SIZE_MIN and SIZE_MAX). On my system, long long and off_t have the same size, so it didn't trigger any bugs, but strtonum() could pass a bigger number to lower and upper than they can handle and make them overflow. The rationale for switching to size_t is actually given by the fact that functions like mmap() blur the border between memory and filesystem. Another point is that glibc has a horrible define _FILE_OFFSET_BITS you need to set to 64 to actually get decent values for off_t, which was a huge headache in sbase until we found that out. Signed-off-by: Laslo Hunhold <dev@frign.de>
2020-08-05 16:59:55 +00:00
size_t lower, upper;
Refactor the single source file into multiple modules And many other things, too many to list here. For example, it now properly logs uds instead of erroring out. Separating concerns in many places definitely improves the readability.
2018-02-04 20:27:33 +00:00
int hasport, ipv6host;
Refactor response-generation I wasn't happy with how responses were generated. HTTP-headers were handled by hand and it was duplicated in multiple parts of the code. Due to the duplication, some functions like timestamp() had really ugly semantics. The HTTP requests are parsed much better: We have an enum of fields we care about that are automatically read into our request struct. This commit adapts this idea to the response: We have an enum of fields we might put into our response, and a response-struct holds the content of these fields. A function http_send_header() automatically sends a header based on the entries in response. In case we don't use a field, we just leave the field in the response-struct empty. With this commit, some logical changes came with it: - timestamp() now has a sane signature, TIMESTAMP_LEN is no more and it can now return proper errors and is also reentrant by using gmtime_r() instead of gmtime() - No more use of a static timestamp-array, making all the methods also reentrant - Better internal-error-reporting: Because the fields are filled before and not during sending the response-headers, we can better report any internal errors as status 500 instead of sending a partial non-500-header and then dying. These improved data structures make it easier to read and hack the code and implement new features, if desired. Signed-off-by: Laslo Hunhold <dev@frign.de>
2020-08-05 11:41:44 +00:00
static char realtarget[PATH_MAX], tmptarget[PATH_MAX];
Refactor range-parsing into a separate function The method http_send_response() is already long enough and this separation of concerns both helps shorten it a bit, improves readability and reduces the chance of programming errors. Signed-off-by: Laslo Hunhold <dev@frign.de>
2020-08-04 14:31:08 +00:00
char *p, *mime;
const char *vhostmatch, *targethost;
Refactor the single source file into multiple modules And many other things, too many to list here. For example, it now properly logs uds instead of erroring out. Separating concerns in many places definitely improves the readability.
2018-02-04 20:27:33 +00:00
Add support for adding a prefix to a target when matching vhosts This makes quark's vhost-handling very powerful while still being simple. Imagine you have a website with a subdomain you really want to move back to your main domain. Say the subdomain is called "old.example.org" and you want to serve it under "example.org" but in the subdirectory "old/", i.e. you want to redirect a request "old.example.org/subdir/" to "example.org/old/subdir". For a vhost-handler that only takes 4 arguments for each vhost this is actually pretty powerful.
2018-02-27 10:36:24 +00:00
/* make a working copy of the target */
Rename request "r" to "req" Now that we have response-structs called "res", the naming "r" is a bit ambiguous. Signed-off-by: Laslo Hunhold <dev@frign.de>
2020-08-05 13:43:29 +00:00
memcpy(realtarget, req->target, sizeof(realtarget));
Add support for adding a prefix to a target when matching vhosts This makes quark's vhost-handling very powerful while still being simple. Imagine you have a website with a subdomain you really want to move back to your main domain. Say the subdomain is called "old.example.org" and you want to serve it under "example.org" but in the subdirectory "old/", i.e. you want to redirect a request "old.example.org/subdir/" to "example.org/old/subdir". For a vhost-handler that only takes 4 arguments for each vhost this is actually pretty powerful.
2018-02-27 10:36:24 +00:00
Refactor the single source file into multiple modules And many other things, too many to list here. For example, it now properly logs uds instead of erroring out. Separating concerns in many places definitely improves the readability.
2018-02-04 20:27:33 +00:00
/* match vhost */
vhostmatch = NULL;
Introduce flag-centric usage The config.h-interface has proven to be very effective for a lot of suckless tools, but it just does not make too much sense for a web server like quark. $ quark If you run multiple instances of it, you want to see in the command line (or top) what it does, and given the amount of options it's logical to just express them as options given in the command line. It also is a problem if you can modify quark via the config.h, contradicting the manual. Just saying "Well, then don't touch config.h" is also not good, as the vhost and map options were only exposed via this interface. What is left in config.h are mime-types and two constants relating to the incoming HTTP-header-limits. In order to introduce these changes, some structs and safe utility functions were added and imported from OpenBSD respectively.
2018-03-04 23:14:25 +00:00
if (s.vhost) {
for (i = 0; i < s.vhost_len; i++) {
Refactor the single source file into multiple modules And many other things, too many to list here. For example, it now properly logs uds instead of erroring out. Separating concerns in many places definitely improves the readability.
2018-02-04 20:27:33 +00:00
/* switch to vhost directory if there is a match */
Rename request "r" to "req" Now that we have response-structs called "res", the naming "r" is a bit ambiguous. Signed-off-by: Laslo Hunhold <dev@frign.de>
2020-08-05 13:43:29 +00:00
if (!regexec(&s.vhost[i].re, req->field[REQ_HOST], 0,
Refactor the single source file into multiple modules And many other things, too many to list here. For example, it now properly logs uds instead of erroring out. Separating concerns in many places definitely improves the readability.
2018-02-04 20:27:33 +00:00
NULL, 0)) {
Introduce flag-centric usage The config.h-interface has proven to be very effective for a lot of suckless tools, but it just does not make too much sense for a web server like quark. $ quark If you run multiple instances of it, you want to see in the command line (or top) what it does, and given the amount of options it's logical to just express them as options given in the command line. It also is a problem if you can modify quark via the config.h, contradicting the manual. Just saying "Well, then don't touch config.h" is also not good, as the vhost and map options were only exposed via this interface. What is left in config.h are mime-types and two constants relating to the incoming HTTP-header-limits. In order to introduce these changes, some structs and safe utility functions were added and imported from OpenBSD respectively.
2018-03-04 23:14:25 +00:00
if (chdir(s.vhost[i].dir) < 0) {
Refactor the single source file into multiple modules And many other things, too many to list here. For example, it now properly logs uds instead of erroring out. Separating concerns in many places definitely improves the readability.
2018-02-04 20:27:33 +00:00
return http_send_status(fd, (errno == EACCES) ?
S_FORBIDDEN : S_NOT_FOUND);
}
Update the documentation to reflect the new flag-centric usage
2018-03-05 08:51:29 +00:00
vhostmatch = s.vhost[i].chost;
Refactor the single source file into multiple modules And many other things, too many to list here. For example, it now properly logs uds instead of erroring out. Separating concerns in many places definitely improves the readability.
2018-02-04 20:27:33 +00:00
break;
}
}
Introduce flag-centric usage The config.h-interface has proven to be very effective for a lot of suckless tools, but it just does not make too much sense for a web server like quark. $ quark If you run multiple instances of it, you want to see in the command line (or top) what it does, and given the amount of options it's logical to just express them as options given in the command line. It also is a problem if you can modify quark via the config.h, contradicting the manual. Just saying "Well, then don't touch config.h" is also not good, as the vhost and map options were only exposed via this interface. What is left in config.h are mime-types and two constants relating to the incoming HTTP-header-limits. In order to introduce these changes, some structs and safe utility functions were added and imported from OpenBSD respectively.
2018-03-04 23:14:25 +00:00
if (i == s.vhost_len) {
Refactor the single source file into multiple modules And many other things, too many to list here. For example, it now properly logs uds instead of erroring out. Separating concerns in many places definitely improves the readability.
2018-02-04 20:27:33 +00:00
return http_send_status(fd, S_NOT_FOUND);
}
Add support for adding a prefix to a target when matching vhosts This makes quark's vhost-handling very powerful while still being simple. Imagine you have a website with a subdomain you really want to move back to your main domain. Say the subdomain is called "old.example.org" and you want to serve it under "example.org" but in the subdirectory "old/", i.e. you want to redirect a request "old.example.org/subdir/" to "example.org/old/subdir". For a vhost-handler that only takes 4 arguments for each vhost this is actually pretty powerful.
2018-02-27 10:36:24 +00:00
/* if we have a vhost prefix, prepend it to the target */
Introduce flag-centric usage The config.h-interface has proven to be very effective for a lot of suckless tools, but it just does not make too much sense for a web server like quark. $ quark If you run multiple instances of it, you want to see in the command line (or top) what it does, and given the amount of options it's logical to just express them as options given in the command line. It also is a problem if you can modify quark via the config.h, contradicting the manual. Just saying "Well, then don't touch config.h" is also not good, as the vhost and map options were only exposed via this interface. What is left in config.h are mime-types and two constants relating to the incoming HTTP-header-limits. In order to introduce these changes, some structs and safe utility functions were added and imported from OpenBSD respectively.
2018-03-04 23:14:25 +00:00
if (s.vhost[i].prefix) {
http_send_response: fix undefined behaviour for copying the target string ... the format string and buffer were the same (undefined behaviour).
2018-03-05 00:12:09 +00:00
if (esnprintf(tmptarget, sizeof(tmptarget), "%s%s",
Add esnprintf() and refactor some code The (size_t) discards the case where the return value of snprintf is < 0. This is rather unlikely, but we'll keep it in mind anyway.
2018-03-04 23:59:37 +00:00
s.vhost[i].prefix, realtarget)) {
Add support for adding a prefix to a target when matching vhosts This makes quark's vhost-handling very powerful while still being simple. Imagine you have a website with a subdomain you really want to move back to your main domain. Say the subdomain is called "old.example.org" and you want to serve it under "example.org" but in the subdirectory "old/", i.e. you want to redirect a request "old.example.org/subdir/" to "example.org/old/subdir". For a vhost-handler that only takes 4 arguments for each vhost this is actually pretty powerful.
2018-02-27 10:36:24 +00:00
return http_send_status(fd, S_REQUEST_TOO_LARGE);
}
http_send_response: fix undefined behaviour for copying the target string ... the format string and buffer were the same (undefined behaviour).
2018-03-05 00:12:09 +00:00
memcpy(realtarget, tmptarget, sizeof(realtarget));
Add support for adding a prefix to a target when matching vhosts This makes quark's vhost-handling very powerful while still being simple. Imagine you have a website with a subdomain you really want to move back to your main domain. Say the subdomain is called "old.example.org" and you want to serve it under "example.org" but in the subdirectory "old/", i.e. you want to redirect a request "old.example.org/subdir/" to "example.org/old/subdir". For a vhost-handler that only takes 4 arguments for each vhost this is actually pretty powerful.
2018-02-27 10:36:24 +00:00
}
Refactor the single source file into multiple modules And many other things, too many to list here. For example, it now properly logs uds instead of erroring out. Separating concerns in many places definitely improves the readability.
2018-02-04 20:27:33 +00:00
}
Add target prefix mapping This allows e.g. to redirect when a directory has been moved.
2018-02-27 11:43:05 +00:00
/* apply target prefix mapping */
Introduce flag-centric usage The config.h-interface has proven to be very effective for a lot of suckless tools, but it just does not make too much sense for a web server like quark. $ quark If you run multiple instances of it, you want to see in the command line (or top) what it does, and given the amount of options it's logical to just express them as options given in the command line. It also is a problem if you can modify quark via the config.h, contradicting the manual. Just saying "Well, then don't touch config.h" is also not good, as the vhost and map options were only exposed via this interface. What is left in config.h are mime-types and two constants relating to the incoming HTTP-header-limits. In order to introduce these changes, some structs and safe utility functions were added and imported from OpenBSD respectively.
2018-03-04 23:14:25 +00:00
for (i = 0; i < s.map_len; i++) {
len = strlen(s.map[i].from);
if (!strncmp(realtarget, s.map[i].from, len)) {
Change target prefix mapping argument order Put the chost-specification at the end and make it optional. This makes more sense than having to give an arbitrary useless name in case you weren't using virtual hosts in the first place. While at it, clear up the wording in the manpage. Signed-off-by: Laslo Hunhold <dev@frign.de>
2019-02-23 23:40:46 +00:00
/* match canonical host if vhosts are enabled and
* the mapping specifies a canonical host */
if (s.vhost && s.map[i].chost &&
strcmp(s.map[i].chost, vhostmatch)) {
Add target prefix mapping This allows e.g. to redirect when a directory has been moved.
2018-02-27 11:43:05 +00:00
continue;
}
/* swap out target prefix */
Add esnprintf() and refactor some code The (size_t) discards the case where the return value of snprintf is < 0. This is rather unlikely, but we'll keep it in mind anyway.
2018-03-04 23:59:37 +00:00
if (esnprintf(tmptarget, sizeof(tmptarget), "%s%s",
s.map[i].to, realtarget + len)) {
Add target prefix mapping This allows e.g. to redirect when a directory has been moved.
2018-02-27 11:43:05 +00:00
return http_send_status(fd, S_REQUEST_TOO_LARGE);
}
Introduce flag-centric usage The config.h-interface has proven to be very effective for a lot of suckless tools, but it just does not make too much sense for a web server like quark. $ quark If you run multiple instances of it, you want to see in the command line (or top) what it does, and given the amount of options it's logical to just express them as options given in the command line. It also is a problem if you can modify quark via the config.h, contradicting the manual. Just saying "Well, then don't touch config.h" is also not good, as the vhost and map options were only exposed via this interface. What is left in config.h are mime-types and two constants relating to the incoming HTTP-header-limits. In order to introduce these changes, some structs and safe utility functions were added and imported from OpenBSD respectively.
2018-03-04 23:14:25 +00:00
memcpy(realtarget, tmptarget, sizeof(realtarget));
Add target prefix mapping This allows e.g. to redirect when a directory has been moved.
2018-02-27 11:43:05 +00:00
break;
}
}
Refactor the single source file into multiple modules And many other things, too many to list here. For example, it now properly logs uds instead of erroring out. Separating concerns in many places definitely improves the readability.
2018-02-04 20:27:33 +00:00
/* normalize target */
if (normabspath(realtarget)) {
return http_send_status(fd, S_BAD_REQUEST);
}
/* reject hidden target */
if (realtarget[0] == '.' || strstr(realtarget, "/.")) {
return http_send_status(fd, S_FORBIDDEN);
}
/* stat the target */
if (stat(RELPATH(realtarget), &st) < 0) {
return http_send_status(fd, (errno == EACCES) ?
S_FORBIDDEN : S_NOT_FOUND);
}
if (S_ISDIR(st.st_mode)) {
/* add / to target if not present */
len = strlen(realtarget);
Fix one byte NULL stack overflow Don't append a forward slash if the length of a folder is PATH_MAX-1. This can happen if HEADER_MAX is larger than PATH_MAX or if the `-m` option is used to increase the path length.
2018-07-16 20:46:09 +00:00
if (len >= PATH_MAX - 2) {
Refactor the single source file into multiple modules And many other things, too many to list here. For example, it now properly logs uds instead of erroring out. Separating concerns in many places definitely improves the readability.
2018-02-04 20:27:33 +00:00
return http_send_status(fd, S_REQUEST_TOO_LARGE);
}
if (len && realtarget[len - 1] != '/') {
realtarget[len] = '/';
realtarget[len + 1] = '\0';
}
}
Add support for adding a prefix to a target when matching vhosts This makes quark's vhost-handling very powerful while still being simple. Imagine you have a website with a subdomain you really want to move back to your main domain. Say the subdomain is called "old.example.org" and you want to serve it under "example.org" but in the subdirectory "old/", i.e. you want to redirect a request "old.example.org/subdir/" to "example.org/old/subdir". For a vhost-handler that only takes 4 arguments for each vhost this is actually pretty powerful.
2018-02-27 10:36:24 +00:00
/* redirect if targets differ, host is non-canonical or we prefixed */
Rename request "r" to "req" Now that we have response-structs called "res", the naming "r" is a bit ambiguous. Signed-off-by: Laslo Hunhold <dev@frign.de>
2020-08-05 13:43:29 +00:00
if (strcmp(req->target, realtarget) || (s.vhost && vhostmatch &&
strcmp(req->field[REQ_HOST], vhostmatch))) {
Refactor response-generation I wasn't happy with how responses were generated. HTTP-headers were handled by hand and it was duplicated in multiple parts of the code. Due to the duplication, some functions like timestamp() had really ugly semantics. The HTTP requests are parsed much better: We have an enum of fields we care about that are automatically read into our request struct. This commit adapts this idea to the response: We have an enum of fields we might put into our response, and a response-struct holds the content of these fields. A function http_send_header() automatically sends a header based on the entries in response. In case we don't use a field, we just leave the field in the response-struct empty. With this commit, some logical changes came with it: - timestamp() now has a sane signature, TIMESTAMP_LEN is no more and it can now return proper errors and is also reentrant by using gmtime_r() instead of gmtime() - No more use of a static timestamp-array, making all the methods also reentrant - Better internal-error-reporting: Because the fields are filled before and not during sending the response-headers, we can better report any internal errors as status 500 instead of sending a partial non-500-header and then dying. These improved data structures make it easier to read and hack the code and implement new features, if desired. Signed-off-by: Laslo Hunhold <dev@frign.de>
2020-08-05 11:41:44 +00:00
res.status = S_MOVED_PERMANENTLY;
Refactor the single source file into multiple modules And many other things, too many to list here. For example, it now properly logs uds instead of erroring out. Separating concerns in many places definitely improves the readability.
2018-02-04 20:27:33 +00:00
/* encode realtarget */
encode(realtarget, tmptarget);
Refactor response-generation I wasn't happy with how responses were generated. HTTP-headers were handled by hand and it was duplicated in multiple parts of the code. Due to the duplication, some functions like timestamp() had really ugly semantics. The HTTP requests are parsed much better: We have an enum of fields we care about that are automatically read into our request struct. This commit adapts this idea to the response: We have an enum of fields we might put into our response, and a response-struct holds the content of these fields. A function http_send_header() automatically sends a header based on the entries in response. In case we don't use a field, we just leave the field in the response-struct empty. With this commit, some logical changes came with it: - timestamp() now has a sane signature, TIMESTAMP_LEN is no more and it can now return proper errors and is also reentrant by using gmtime_r() instead of gmtime() - No more use of a static timestamp-array, making all the methods also reentrant - Better internal-error-reporting: Because the fields are filled before and not during sending the response-headers, we can better report any internal errors as status 500 instead of sending a partial non-500-header and then dying. These improved data structures make it easier to read and hack the code and implement new features, if desired. Signed-off-by: Laslo Hunhold <dev@frign.de>
2020-08-05 11:41:44 +00:00
/* determine target location */
Send a relative redirection header wherever possible This makes quark much more flexible when it is run behind a network filter or other kind of tunnel. Only send an absolute redirection when we are handling vhosts.
2018-07-02 16:43:06 +00:00
if (s.vhost) {
/* absolute redirection URL */
Rename request "r" to "req" Now that we have response-structs called "res", the naming "r" is a bit ambiguous. Signed-off-by: Laslo Hunhold <dev@frign.de>
2020-08-05 13:43:29 +00:00
targethost = req->field[REQ_HOST][0] ? vhostmatch ?
vhostmatch : req->field[REQ_HOST] : s.host ?
Send a relative redirection header wherever possible This makes quark much more flexible when it is run behind a network filter or other kind of tunnel. Only send an absolute redirection when we are handling vhosts.
2018-07-02 16:43:06 +00:00
s.host : "localhost";
/* do we need to add a port to the Location? */
hasport = s.port && strcmp(s.port, "80");
/* RFC 2732 specifies to use brackets for IPv6-addresses
* in URLs, so we need to check if our host is one and
* honor that later when we fill the "Location"-field */
if ((ipv6host = inet_pton(AF_INET6, targethost,
Refactor response-generation I wasn't happy with how responses were generated. HTTP-headers were handled by hand and it was duplicated in multiple parts of the code. Due to the duplication, some functions like timestamp() had really ugly semantics. The HTTP requests are parsed much better: We have an enum of fields we care about that are automatically read into our request struct. This commit adapts this idea to the response: We have an enum of fields we might put into our response, and a response-struct holds the content of these fields. A function http_send_header() automatically sends a header based on the entries in response. In case we don't use a field, we just leave the field in the response-struct empty. With this commit, some logical changes came with it: - timestamp() now has a sane signature, TIMESTAMP_LEN is no more and it can now return proper errors and is also reentrant by using gmtime_r() instead of gmtime() - No more use of a static timestamp-array, making all the methods also reentrant - Better internal-error-reporting: Because the fields are filled before and not during sending the response-headers, we can better report any internal errors as status 500 instead of sending a partial non-500-header and then dying. These improved data structures make it easier to read and hack the code and implement new features, if desired. Signed-off-by: Laslo Hunhold <dev@frign.de>
2020-08-05 11:41:44 +00:00
&addr)) < 0) {
Send a relative redirection header wherever possible This makes quark much more flexible when it is run behind a network filter or other kind of tunnel. Only send an absolute redirection when we are handling vhosts.
2018-07-02 16:43:06 +00:00
return http_send_status(fd,
S_INTERNAL_SERVER_ERROR);
}
Refactor response-generation I wasn't happy with how responses were generated. HTTP-headers were handled by hand and it was duplicated in multiple parts of the code. Due to the duplication, some functions like timestamp() had really ugly semantics. The HTTP requests are parsed much better: We have an enum of fields we care about that are automatically read into our request struct. This commit adapts this idea to the response: We have an enum of fields we might put into our response, and a response-struct holds the content of these fields. A function http_send_header() automatically sends a header based on the entries in response. In case we don't use a field, we just leave the field in the response-struct empty. With this commit, some logical changes came with it: - timestamp() now has a sane signature, TIMESTAMP_LEN is no more and it can now return proper errors and is also reentrant by using gmtime_r() instead of gmtime() - No more use of a static timestamp-array, making all the methods also reentrant - Better internal-error-reporting: Because the fields are filled before and not during sending the response-headers, we can better report any internal errors as status 500 instead of sending a partial non-500-header and then dying. These improved data structures make it easier to read and hack the code and implement new features, if desired. Signed-off-by: Laslo Hunhold <dev@frign.de>
2020-08-05 11:41:44 +00:00
/* write location to response struct */
if (esnprintf(res.field[RES_LOCATION],
sizeof(res.field[RES_LOCATION]),
"//%s%s%s%s%s%s",
ipv6host ? "[" : "",
targethost,
ipv6host ? "]" : "", hasport ? ":" : "",
hasport ? s.port : "", tmptarget)) {
return http_send_status(fd, S_REQUEST_TOO_LARGE);
Send a relative redirection header wherever possible This makes quark much more flexible when it is run behind a network filter or other kind of tunnel. Only send an absolute redirection when we are handling vhosts.
2018-07-02 16:43:06 +00:00
}
} else {
Refactor response-generation I wasn't happy with how responses were generated. HTTP-headers were handled by hand and it was duplicated in multiple parts of the code. Due to the duplication, some functions like timestamp() had really ugly semantics. The HTTP requests are parsed much better: We have an enum of fields we care about that are automatically read into our request struct. This commit adapts this idea to the response: We have an enum of fields we might put into our response, and a response-struct holds the content of these fields. A function http_send_header() automatically sends a header based on the entries in response. In case we don't use a field, we just leave the field in the response-struct empty. With this commit, some logical changes came with it: - timestamp() now has a sane signature, TIMESTAMP_LEN is no more and it can now return proper errors and is also reentrant by using gmtime_r() instead of gmtime() - No more use of a static timestamp-array, making all the methods also reentrant - Better internal-error-reporting: Because the fields are filled before and not during sending the response-headers, we can better report any internal errors as status 500 instead of sending a partial non-500-header and then dying. These improved data structures make it easier to read and hack the code and implement new features, if desired. Signed-off-by: Laslo Hunhold <dev@frign.de>
2020-08-05 11:41:44 +00:00
/* write relative redirection URL to response struct */
if (esnprintf(res.field[RES_LOCATION],
sizeof(res.field[RES_LOCATION]),
tmptarget)) {
return http_send_status(fd, S_REQUEST_TOO_LARGE);
Send a relative redirection header wherever possible This makes quark much more flexible when it is run behind a network filter or other kind of tunnel. Only send an absolute redirection when we are handling vhosts.
2018-07-02 16:43:06 +00:00
}
Refactor the single source file into multiple modules And many other things, too many to list here. For example, it now properly logs uds instead of erroring out. Separating concerns in many places definitely improves the readability.
2018-02-04 20:27:33 +00:00
}
Refactor response-generation I wasn't happy with how responses were generated. HTTP-headers were handled by hand and it was duplicated in multiple parts of the code. Due to the duplication, some functions like timestamp() had really ugly semantics. The HTTP requests are parsed much better: We have an enum of fields we care about that are automatically read into our request struct. This commit adapts this idea to the response: We have an enum of fields we might put into our response, and a response-struct holds the content of these fields. A function http_send_header() automatically sends a header based on the entries in response. In case we don't use a field, we just leave the field in the response-struct empty. With this commit, some logical changes came with it: - timestamp() now has a sane signature, TIMESTAMP_LEN is no more and it can now return proper errors and is also reentrant by using gmtime_r() instead of gmtime() - No more use of a static timestamp-array, making all the methods also reentrant - Better internal-error-reporting: Because the fields are filled before and not during sending the response-headers, we can better report any internal errors as status 500 instead of sending a partial non-500-header and then dying. These improved data structures make it easier to read and hack the code and implement new features, if desired. Signed-off-by: Laslo Hunhold <dev@frign.de>
2020-08-05 11:41:44 +00:00
return http_send_header(fd, &res);
Refactor the single source file into multiple modules And many other things, too many to list here. For example, it now properly logs uds instead of erroring out. Separating concerns in many places definitely improves the readability.
2018-02-04 20:27:33 +00:00
}
if (S_ISDIR(st.st_mode)) {
/* append docindex to target */
Add esnprintf() and refactor some code The (size_t) discards the case where the return value of snprintf is < 0. This is rather unlikely, but we'll keep it in mind anyway.
2018-03-04 23:59:37 +00:00
if (esnprintf(realtarget, sizeof(realtarget), "%s%s",
Rename request "r" to "req" Now that we have response-structs called "res", the naming "r" is a bit ambiguous. Signed-off-by: Laslo Hunhold <dev@frign.de>
2020-08-05 13:43:29 +00:00
req->target, s.docindex)) {
Refactor the single source file into multiple modules And many other things, too many to list here. For example, it now properly logs uds instead of erroring out. Separating concerns in many places definitely improves the readability.
2018-02-04 20:27:33 +00:00
return http_send_status(fd, S_REQUEST_TOO_LARGE);
}
/* stat the docindex, which must be a regular file */
if (stat(RELPATH(realtarget), &st) < 0 || !S_ISREG(st.st_mode)) {
Introduce flag-centric usage The config.h-interface has proven to be very effective for a lot of suckless tools, but it just does not make too much sense for a web server like quark. $ quark If you run multiple instances of it, you want to see in the command line (or top) what it does, and given the amount of options it's logical to just express them as options given in the command line. It also is a problem if you can modify quark via the config.h, contradicting the manual. Just saying "Well, then don't touch config.h" is also not good, as the vhost and map options were only exposed via this interface. What is left in config.h are mime-types and two constants relating to the incoming HTTP-header-limits. In order to introduce these changes, some structs and safe utility functions were added and imported from OpenBSD respectively.
2018-03-04 23:14:25 +00:00
if (s.listdirs) {
Refactor the single source file into multiple modules And many other things, too many to list here. For example, it now properly logs uds instead of erroring out. Separating concerns in many places definitely improves the readability.
2018-02-04 20:27:33 +00:00
/* remove index suffix and serve dir */
realtarget[strlen(realtarget) -
Introduce flag-centric usage The config.h-interface has proven to be very effective for a lot of suckless tools, but it just does not make too much sense for a web server like quark. $ quark If you run multiple instances of it, you want to see in the command line (or top) what it does, and given the amount of options it's logical to just express them as options given in the command line. It also is a problem if you can modify quark via the config.h, contradicting the manual. Just saying "Well, then don't touch config.h" is also not good, as the vhost and map options were only exposed via this interface. What is left in config.h are mime-types and two constants relating to the incoming HTTP-header-limits. In order to introduce these changes, some structs and safe utility functions were added and imported from OpenBSD respectively.
2018-03-04 23:14:25 +00:00
strlen(s.docindex)] = '\0';
Rename request "r" to "req" Now that we have response-structs called "res", the naming "r" is a bit ambiguous. Signed-off-by: Laslo Hunhold <dev@frign.de>
2020-08-05 13:43:29 +00:00
return resp_dir(fd, RELPATH(realtarget), req);
Refactor the single source file into multiple modules And many other things, too many to list here. For example, it now properly logs uds instead of erroring out. Separating concerns in many places definitely improves the readability.
2018-02-04 20:27:33 +00:00
} else {
/* reject */
if (!S_ISREG(st.st_mode) || errno == EACCES) {
return http_send_status(fd, S_FORBIDDEN);
} else {
return http_send_status(fd, S_NOT_FOUND);
}
}
}
}
/* modified since */
Rename REQ_MOD to REQ_IF_MODIFIED_SINCE The named constants for header fields of the response struct all pretty much matched the actual header name, which I think improves readability for everyone familiar with the HTTP-spec. The request header fields named constants followed the rule, except the "If-Modified-Since"-header, which is addressed in this commit. Signed-off-by: Laslo Hunhold <dev@frign.de>
2020-08-05 13:46:03 +00:00
if (req->field[REQ_IF_MODIFIED_SINCE][0]) {
Refactor the single source file into multiple modules And many other things, too many to list here. For example, it now properly logs uds instead of erroring out. Separating concerns in many places definitely improves the readability.
2018-02-04 20:27:33 +00:00
/* parse field */
Rename REQ_MOD to REQ_IF_MODIFIED_SINCE The named constants for header fields of the response struct all pretty much matched the actual header name, which I think improves readability for everyone familiar with the HTTP-spec. The request header fields named constants followed the rule, except the "If-Modified-Since"-header, which is addressed in this commit. Signed-off-by: Laslo Hunhold <dev@frign.de>
2020-08-05 13:46:03 +00:00
if (!strptime(req->field[REQ_IF_MODIFIED_SINCE],
"%a, %d %b %Y %T GMT", &tm)) {
Refactor the single source file into multiple modules And many other things, too many to list here. For example, it now properly logs uds instead of erroring out. Separating concerns in many places definitely improves the readability.
2018-02-04 20:27:33 +00:00
return http_send_status(fd, S_BAD_REQUEST);
}
/* compare with last modification date of the file */
Use timegm() instead of mktime() to generate UNIX-timestamp The broken down time-representation tm generated earlier is in UTC, and mktime() assumes that it's in local time instead, leading to the problem that quark might not send a NOT_MODIFIED in a different timezone. timegm() instead correctly interprets the broken down time-representation tm as UTC and returns the proper timestamp. It might not be portable like mktime(), but it's complicated to emulate it otherwise. Thanks to Jeremy Bobbin <jer@jer.cx> for reporting the bug and providing this fix, which is why I've added him to the LICENSE. Thanks also to Hiltjo for his input. Signed-off-by: Laslo Hunhold <dev@frign.de>
2020-07-23 14:48:34 +00:00
if (difftime(st.st_mtim.tv_sec, timegm(&tm)) <= 0) {
Refactor response-generation I wasn't happy with how responses were generated. HTTP-headers were handled by hand and it was duplicated in multiple parts of the code. Due to the duplication, some functions like timestamp() had really ugly semantics. The HTTP requests are parsed much better: We have an enum of fields we care about that are automatically read into our request struct. This commit adapts this idea to the response: We have an enum of fields we might put into our response, and a response-struct holds the content of these fields. A function http_send_header() automatically sends a header based on the entries in response. In case we don't use a field, we just leave the field in the response-struct empty. With this commit, some logical changes came with it: - timestamp() now has a sane signature, TIMESTAMP_LEN is no more and it can now return proper errors and is also reentrant by using gmtime_r() instead of gmtime() - No more use of a static timestamp-array, making all the methods also reentrant - Better internal-error-reporting: Because the fields are filled before and not during sending the response-headers, we can better report any internal errors as status 500 instead of sending a partial non-500-header and then dying. These improved data structures make it easier to read and hack the code and implement new features, if desired. Signed-off-by: Laslo Hunhold <dev@frign.de>
2020-08-05 11:41:44 +00:00
res.status = S_NOT_MODIFIED;
return http_send_header(fd, &res);
Refactor the single source file into multiple modules And many other things, too many to list here. For example, it now properly logs uds instead of erroring out. Separating concerns in many places definitely improves the readability.
2018-02-04 20:27:33 +00:00
}
}
/* range */
Ensure const-correctness where possible and refactor parse_range() I know that the effect of 'const' on compiler optimizations is smaller than many believe, but it provides a good insight to the caller which parameters are not modified and simplifies parallelization, in case that is desired at a later point. Throughout processing, the big structs mostly remained unmodified, with the exception of parse_range(), which added a null-byte in the "Range"- header to simplify its parsing. This commit refactors parse_range() such that it won't modify this string anymore. Additionally, the parser was made even stricter: Usually, strtoll() (which is wrapped by strtonum()) allows whitespace and plus and minus signs before the number, which is not part of the specification. The stricter parser also better differentiates now between invalid requests and range-lists. In that context, the switch in http_send_response() was replaced for better readability. Signed-off-by: Laslo Hunhold <dev@frign.de>
2020-08-05 16:28:21 +00:00
if ((returnstatus = parse_range(req->field[REQ_RANGE],
st.st_size, &lower, &upper))) {
if (returnstatus == S_RANGE_NOT_SATISFIABLE) {
res.status = S_RANGE_NOT_SATISFIABLE;
if (esnprintf(res.field[RES_CONTENT_RANGE],
sizeof(res.field[RES_CONTENT_RANGE]),
"bytes */%zu", st.st_size)) {
return http_send_status(fd,
S_INTERNAL_SERVER_ERROR);
}
Refactor response-generation I wasn't happy with how responses were generated. HTTP-headers were handled by hand and it was duplicated in multiple parts of the code. Due to the duplication, some functions like timestamp() had really ugly semantics. The HTTP requests are parsed much better: We have an enum of fields we care about that are automatically read into our request struct. This commit adapts this idea to the response: We have an enum of fields we might put into our response, and a response-struct holds the content of these fields. A function http_send_header() automatically sends a header based on the entries in response. In case we don't use a field, we just leave the field in the response-struct empty. With this commit, some logical changes came with it: - timestamp() now has a sane signature, TIMESTAMP_LEN is no more and it can now return proper errors and is also reentrant by using gmtime_r() instead of gmtime() - No more use of a static timestamp-array, making all the methods also reentrant - Better internal-error-reporting: Because the fields are filled before and not during sending the response-headers, we can better report any internal errors as status 500 instead of sending a partial non-500-header and then dying. These improved data structures make it easier to read and hack the code and implement new features, if desired. Signed-off-by: Laslo Hunhold <dev@frign.de>
2020-08-05 11:41:44 +00:00
Ensure const-correctness where possible and refactor parse_range() I know that the effect of 'const' on compiler optimizations is smaller than many believe, but it provides a good insight to the caller which parameters are not modified and simplifies parallelization, in case that is desired at a later point. Throughout processing, the big structs mostly remained unmodified, with the exception of parse_range(), which added a null-byte in the "Range"- header to simplify its parsing. This commit refactors parse_range() such that it won't modify this string anymore. Additionally, the parser was made even stricter: Usually, strtoll() (which is wrapped by strtonum()) allows whitespace and plus and minus signs before the number, which is not part of the specification. The stricter parser also better differentiates now between invalid requests and range-lists. In that context, the switch in http_send_response() was replaced for better readability. Signed-off-by: Laslo Hunhold <dev@frign.de>
2020-08-05 16:28:21 +00:00
return http_send_header(fd, &res);
} else {
return http_send_status(fd, returnstatus);
Refactor range-parsing Quark previously didn't really handle suffix-range-requests (those of the form "-num", asking for the last num bytes) properly and also did not catch the error when the lower in the range "lower-upper" was actually larger than or equal to the size of the requested file. I always planned to refactor the parsing but got the motivation by Eric Radman <ericshane@eradman.com>, who kindly reported the latter bug to me. Signed-off-by: Laslo Hunhold <dev@frign.de>
2020-07-23 16:16:08 +00:00
}
Refactor the single source file into multiple modules And many other things, too many to list here. For example, it now properly logs uds instead of erroring out. Separating concerns in many places definitely improves the readability.
2018-02-04 20:27:33 +00:00
}
/* mime */
mime = "application/octet-stream";
if ((p = strrchr(realtarget, '.'))) {
for (i = 0; i < sizeof(mimes) / sizeof(*mimes); i++) {
if (!strcmp(mimes[i].ext, p + 1)) {
mime = mimes[i].type;
break;
}
}
}
Rename request "r" to "req" Now that we have response-structs called "res", the naming "r" is a bit ambiguous. Signed-off-by: Laslo Hunhold <dev@frign.de>
2020-08-05 13:43:29 +00:00
return resp_file(fd, RELPATH(realtarget), req, &st, mime, lower, upper);
Refactor the single source file into multiple modules And many other things, too many to list here. For example, it now properly logs uds instead of erroring out. Separating concerns in many places definitely improves the readability.
2018-02-04 20:27:33 +00:00
}
Reference in a new issue Copy permalink