yigitcolakoglu
/
dotfiles
1
0
Fork 0
Code Issues 0 Pull Requests 0 Projects 0 Releases 0 Wiki Activity
Another copy of my dotfiles. Because I don't completely trust GitHub.
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
251 Commits
2 Branches
105 MiB
 
 
 
 
 
 
Tree: 11d6692c18
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '11d6692c18'
${ noResults }
dotfiles/suckless/quark/http.c

1044 lines
23 KiB
Raw Blame History

/* See LICENSE file for copyright and license details. */
#include <arpa/inet.h>
#include <ctype.h>
#include <errno.h>
#include <limits.h>
#include <netinet/in.h>
#include <regex.h>
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>
#include <strings.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <time.h>
#include <unistd.h>
#include "config.h"
#include "http.h"
#include "util.h"
const char *req_field_str[] = {
[REQ_HOST] = "Host",
[REQ_RANGE] = "Range",
[REQ_IF_MODIFIED_SINCE] = "If-Modified-Since",
};
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",
};
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",
};
enum status
http_prepare_header_buf(const struct response *res, struct buffer *buf)
{
char tstmp[FIELD_MAX];
size_t i;
/* reset buffer */
memset(buf, 0, sizeof(*buf));
/* generate timestamp */
if (timestamp(tstmp, sizeof(tstmp), time(NULL))) {
goto err;
}
/* write data */
if (buffer_appendf(buf,
"HTTP/1.1 %d %s\r\n"
"Date: %s\r\n"
"Connection: close\r\n",
res->status, status_str[res->status], tstmp)) {
goto err;
}
for (i = 0; i < NUM_RES_FIELDS; i++) {
if (res->field[i][0] != '\0' &&
buffer_appendf(buf, "%s: %s\r\n", res_field_str[i],
res->field[i])) {
goto err;
}
}
if (buffer_appendf(buf, "\r\n")) {
goto err;
}
return 0;
err:
memset(buf, 0, sizeof(*buf));
return S_INTERNAL_SERVER_ERROR;
}
enum status
http_send_buf(int fd, struct buffer *buf)
{
ssize_t r;
if (buf == NULL) {
return S_INTERNAL_SERVER_ERROR;
}
while (buf->len > 0) {
if ((r = write(fd, buf->data, buf->len)) <= 0) {
if (errno == EAGAIN || errno == EWOULDBLOCK) {
/*
* socket is blocking, return normally.
* given the buffer still contains data,
* this indicates to the caller that we
* have been interrupted.
*/
return 0;
} else {
return S_REQUEST_TIMEOUT;
}
}
memmove(buf->data, buf->data + r, buf->len - r);
buf->len -= r;
}
return 0;
}
static void
decode(const char src[PATH_MAX], char dest[PATH_MAX])
{
size_t i;
uint8_t n;
const char *s;
for (s = src, i = 0; *s; s++, i++) {
if (*s == '%' && (sscanf(s + 1, "%2hhx", &n) == 1)) {
dest[i] = n;
s += 2;
} else {
dest[i] = *s;
}
}
dest[i] = '\0';
}
enum status
http_recv_header(int fd, struct buffer *buf, int *done)
{
enum status s;
ssize_t r;
while (1) {
if ((r = read(fd, buf->data + buf->len,
sizeof(buf->data) - buf->len)) < 0) {
if (errno == EAGAIN || errno == EWOULDBLOCK) {
/*
* socket is drained, return normally,
* but set done to zero
*/
*done = 0;
return 0;
} else {
s = S_REQUEST_TIMEOUT;
goto err;
}
} else if (r == 0) {
/*
* unexpected EOF because the client probably
* hung up. This is technically a bad request,
* because it's incomplete
*/
s = S_BAD_REQUEST;
goto err;
}
buf->len += r;
/* check if we are done (header terminated) */
if (buf->len >= 4 && !memcmp(buf->data + buf->len - 4,
"\r\n\r\n", 4)) {
break;
}
/* buffer is full or read over, but header is not terminated */
if (r == 0 || buf->len == sizeof(buf->data)) {
s = S_REQUEST_TOO_LARGE;
goto err;
}
}
/* header is complete, remove last \r\n and set done */
buf->len -= 2;
*done = 1;
return 0;
err:
memset(buf, 0, sizeof(*buf));
return s;
}
enum status
http_parse_header(const char *h, struct request *req)
{
struct in6_addr addr;
size_t i, mlen;
const char *p, *q, *r, *s, *t;
char *m, *n;
/* empty the request struct */
memset(req, 0, sizeof(*req));
/*
* 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)) {
req->method = i;
break;
}
}
if (i == NUM_REQ_METHODS) {
return S_METHOD_NOT_ALLOWED;
}
/* a single space must follow the method */
if (h[mlen] != ' ') {
return S_BAD_REQUEST;
}
/* basis for next step */
p = h + mlen + 1;
/* RESOURCE */
/*
* path?query#fragment
* ^ ^ ^ ^
* | | | |
* p r s q
*
*/
if (!(q = strchr(p, ' '))) {
return S_BAD_REQUEST;
}
/* search for first '?' */
for (r = p; r < q; r++) {
if (!isprint(*r)) {
return S_BAD_REQUEST;
}
if (*r == '?') {
break;
}
}
if (r == q) {
/* not found */
r = NULL;
}
/* search for first '#' */
for (s = p; s < q; s++) {
if (!isprint(*s)) {
return S_BAD_REQUEST;
}
if (*s == '#') {
break;
}
}
if (s == q) {
/* not found */
s = NULL;
}
if (r != NULL && s != NULL && s < r) {
/*
* '#' comes before '?' and thus the '?' is literal,
* because the query must come before the fragment
*/
r = NULL;
}
/* write path using temporary endpointer t */
if (r != NULL) {
/* resource contains a query, path ends at r */
t = r;
} else if (s != NULL) {
/* resource contains only a fragment, path ends at s */
t = s;
} else {
/* resource contains no queries, path ends at q */
t = q;
}
if ((size_t)(t - p + 1) > LEN(req->path)) {
return S_REQUEST_TOO_LARGE;
}
memcpy(req->path, p, t - p);
req->path[t - p] = '\0';
decode(req->path, req->path);
/* write query if present */
if (r != NULL) {
/* query ends either at s (if fragment present) or q */
t = (s != NULL) ? s : q;
if ((size_t)(t - (r + 1) + 1) > LEN(req->query)) {
return S_REQUEST_TOO_LARGE;
}
memcpy(req->query, r + 1, t - (r + 1));
req->query[t - (r + 1)] = '\0';
}
/* write fragment if present */
if (s != NULL) {
/* the fragment always starts at s + 1 and ends at q */
if ((size_t)(q - (s + 1) + 1) > LEN(req->fragment)) {
return S_REQUEST_TOO_LARGE;
}
memcpy(req->fragment, s + 1, q - (s + 1));
req->fragment[q - (s + 1)] = '\0';
}
/* basis for next step */
p = q + 1;
/* HTTP-VERSION */
if (strncmp(p, "HTTP/", sizeof("HTTP/") - 1)) {
return 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 S_VERSION_NOT_SUPPORTED;
}
p += sizeof("1.*") - 1;
/* check terminator */
if (strncmp(p, "\r\n", sizeof("\r\n") - 1)) {
return 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 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 S_BAD_REQUEST;
}
/* skip whitespace */
for (++p; *p == ' ' || *p == '\t'; p++)
;
/* extract field content */
if (!(q = strstr(p, "\r\n"))) {
return S_BAD_REQUEST;
}
if ((size_t)(q - p + 1) > LEN(req->field[i])) {
return S_REQUEST_TOO_LARGE;
}
memcpy(req->field[i], p, q - p);
req->field[i][q - p] = '\0';
/* go to next line */
p = q + (sizeof("\r\n") - 1);
}
/*
* clean up host
*/
m = strrchr(req->field[REQ_HOST], ':');
n = strrchr(req->field[REQ_HOST], ']');
/* strip port suffix but don't interfere with IPv6 bracket notation
* as per RFC 2732 */
if (m && (!n || m > n)) {
/* port suffix must not be empty */
if (*(m + 1) == '\0') {
return S_BAD_REQUEST;
}
*m = '\0';
}
/* strip the brackets from the IPv6 notation and validate the address */
if (n) {
/* brackets must be on the outside */
if (req->field[REQ_HOST][0] != '[' || *(n + 1) != '\0') {
return S_BAD_REQUEST;
}
/* remove the right bracket */
*n = '\0';
m = req->field[REQ_HOST] + 1;
/* validate the contained IPv6 address */
if (inet_pton(AF_INET6, m, &addr) != 1) {
return S_BAD_REQUEST;
}
/* copy it into the host field */
memmove(req->field[REQ_HOST], m, n - m + 1);
}
return 0;
}
static void
encode(const char src[PATH_MAX], char dest[PATH_MAX])
{
size_t i;
const char *s;
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 enum status
path_normalize(char *uri, int *redirect)
{
size_t len;
int last = 0;
char *p, *q;
/* require and skip first slash */
if (uri[0] != '/') {
return S_BAD_REQUEST;
}
p = uri + 1;
/* get length of URI */
len = strlen(p);
for (; !last; ) {
/* bound uri component within (p,q) */
if (!(q = strchr(p, '/'))) {
q = strchr(p, '\0');
last = 1;
}
if (*p == '\0') {
break;
} else if (p == q || (q - p == 1 && p[0] == '.')) {
/* "/" or "./" */
goto squash;
} else if (q - p == 2 && p[0] == '.' && p[1] == '.') {
/* "../" */
if (p != uri + 1) {
/* place p right after the previous / */
for (p -= 2; p > uri && *p != '/'; p--);
p++;
}
goto squash;
} else {
/* move on */
p = q + 1;
continue;
}
squash:
/* squash (p,q) into void */
if (last) {
*p = '\0';
len = p - uri;
} else {
memmove(p, q + 1, len - ((q + 1) - uri) + 2);
len -= (q + 1) - p;
}
if (redirect != NULL) {
*redirect = 1;
}
}
return 0;
}
static enum status
path_add_vhost_prefix(char uri[PATH_MAX], int *redirect,
const struct server *srv, const struct response *res)
{
if (srv->vhost && res->vhost && res->vhost->prefix) {
if (prepend(uri, PATH_MAX, res->vhost->prefix)) {
return S_REQUEST_TOO_LARGE;
}
if (redirect != NULL) {
*redirect = 1;
}
}
return 0;
}
static enum status
path_apply_prefix_mapping(char uri[PATH_MAX], int *redirect,
const struct server *srv, const struct response *res)
{
size_t i, len;
for (i = 0; i < srv->map_len; i++) {
len = strlen(srv->map[i].from);
if (!strncmp(uri, srv->map[i].from, len)) {
/*
* if vhosts are enabled only apply mappings
* defined for the current canonical host
*/
if (srv->vhost && res->vhost && srv->map[i].chost &&
strcmp(srv->map[i].chost, res->vhost->chost)) {
continue;
}
/* swap out URI prefix */
memmove(uri, uri + len, strlen(uri) + 1);
if (prepend(uri, PATH_MAX, srv->map[i].to)) {
return S_REQUEST_TOO_LARGE;
}
if (redirect != NULL) {
*redirect = 1;
}
/* break so we don't possibly hit an infinite loop */
break;
}
}
return 0;
}
static enum status
path_ensure_dirslash(char uri[PATH_MAX], int *redirect)
{
size_t len;
/* append '/' to URI if not present */
len = strlen(uri);
if (len + 1 + 1 > PATH_MAX) {
return S_REQUEST_TOO_LARGE;
}
if (len > 0 && uri[len - 1] != '/') {
uri[len] = '/';
uri[len + 1] = '\0';
if (redirect != NULL) {
*redirect = 1;
}
}
return 0;
}
static enum status
parse_range(const char *str, size_t size, size_t *lower, size_t *upper)
{
char first[FIELD_MAX], last[FIELD_MAX];
const char *p, *q, *r, *err;
/* default to the complete range */
*lower = 0;
*upper = size - 1;
/* done if no range-string is given */
if (str == NULL || *str == '\0') {
return 0;
}
/* skip opening statement */
if (strncmp(str, "bytes=", sizeof("bytes=") - 1)) {
return S_BAD_REQUEST;
}
p = str + (sizeof("bytes=") - 1);
/* 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 */
return S_BAD_REQUEST;
}
r = q + strlen(q);
/*
* byte-range=first-last\0
* ^ ^ ^
* | | |
* p q r
*/
/* 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;
}
memcpy(first, p, (q - 1) - p);
first[(q - 1) - p] = '\0';
memcpy(last, q, r - q);
last[r - q] = '\0';
if (first[0] != '\0') {
/*
* range has format "first-last" or "first-",
* i.e. return bytes 'first' to 'last' (or the
* last byte if 'last' is not given),
* inclusively, and byte-numbering beginning at 0
*/
*lower = strtonum(first, 0, MIN(SIZE_MAX, LLONG_MAX),
&err);
if (!err) {
if (last[0] != '\0') {
*upper = strtonum(last, 0,
MIN(SIZE_MAX, LLONG_MAX),
&err);
} 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 {
/* last must not also be empty */
if (last[0] == '\0') {
return S_BAD_REQUEST;
}
/*
* 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
*/
*upper = strtonum(last, 0, MIN(SIZE_MAX, LLONG_MAX), &err);
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;
}
void
http_prepare_response(const struct request *req, struct response *res,
const struct server *srv)
{
enum status s, tmps;
struct in6_addr addr;
struct stat st;
struct tm tm = { 0 };
size_t i;
int redirect, hasport, ipv6host;
static char tmppath[PATH_MAX];
char *p, *mime;
/* empty all response fields */
memset(res, 0, sizeof(*res));
/* determine virtual host */
if (srv->vhost) {
for (i = 0; i < srv->vhost_len; i++) {
if (!regexec(&(srv->vhost[i].re),
req->field[REQ_HOST], 0, NULL, 0)) {
/* we have a matching vhost */
res->vhost = &(srv->vhost[i]);
break;
}
}
if (i == srv->vhost_len) {
s = S_NOT_FOUND;
goto err;
}
}
/* copy request-path to response-path and clean it up */
redirect = 0;
memcpy(res->path, req->path, MIN(sizeof(res->path), sizeof(req->path)));
if ((tmps = path_normalize(res->path, &redirect)) ||
(tmps = path_add_vhost_prefix(res->path, &redirect, srv, res)) ||
(tmps = path_apply_prefix_mapping(res->path, &redirect, srv, res)) ||
(tmps = path_normalize(res->path, &redirect))) {
s = tmps;
goto err;
}
/* redirect all non-canonical hosts to their canonical forms */
if (srv->vhost && res->vhost &&
strcmp(req->field[REQ_HOST], res->vhost->chost)) {
redirect = 1;
}
/* reject all non-well-known hidden targets (see RFC 8615) */
if (strstr(res->path, "/.") && strncmp(res->path, "/.well-known/",
sizeof("/.well-known/") - 1)) {
s = S_FORBIDDEN;
goto err;
}
/*
* generate and stat internal path based on the cleaned up request
* path and the virtual host while ignoring query and fragment
* (valid according to RFC 3986)
*/
if (esnprintf(res->internal_path, sizeof(res->internal_path), "/%s/%s",
(srv->vhost && res->vhost) ? res->vhost->dir : "",
res->path)) {
s = S_REQUEST_TOO_LARGE;
goto err;
}
if ((tmps = path_normalize(res->internal_path, NULL))) {
s = tmps;
goto err;
}
if (stat(res->internal_path, &st) < 0) {
s = (errno == EACCES) ? S_FORBIDDEN : S_NOT_FOUND;
goto err;
}
/*
* if the path points at a directory, make sure both the path
* and internal path have a trailing slash
*/
if (S_ISDIR(st.st_mode)) {
if ((tmps = path_ensure_dirslash(res->path, &redirect)) ||
(tmps = path_ensure_dirslash(res->internal_path, NULL))) {
s = tmps;
goto err;
}
}
/* redirect if the path-cleanup necessitated it earlier */
if (redirect) {
res->status = S_MOVED_PERMANENTLY;
/* encode path */
encode(res->path, tmppath);
/* determine target location */
if (srv->vhost && res->vhost) {
/* absolute redirection URL */
/* do we need to add a port to the Location? */
hasport = srv->port && strcmp(srv->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, res->vhost->chost,
&addr)) < 0) {
s = S_INTERNAL_SERVER_ERROR;
goto err;
}
/*
* write location to response struct (re-including
* the query and fragment, if present)
*/
if (esnprintf(res->field[RES_LOCATION],
sizeof(res->field[RES_LOCATION]),
"//%s%s%s%s%s%s%s%s%s%s",
ipv6host ? "[" : "",
res->vhost->chost,
ipv6host ? "]" : "",
hasport ? ":" : "",
hasport ? srv->port : "",
tmppath,
req->query[0] ? "?" : "",
req->query,
req->fragment[0] ? "#" : "",
req->fragment)) {
s = S_REQUEST_TOO_LARGE;
goto err;
}
} else {
/*
* write relative redirection URI to response struct
* (re-including the query and fragment, if present)
*/
if (esnprintf(res->field[RES_LOCATION],
sizeof(res->field[RES_LOCATION]),
"%s%s%s%s%s",
tmppath,
req->query[0] ? "?" : "",
req->query,
req->fragment[0] ? "#" : "",
req->fragment)) {
s = S_REQUEST_TOO_LARGE;
goto err;
}
}
return;
}
if (S_ISDIR(st.st_mode)) {
/*
* when we serve a directory, we first check if there
* exists a directory index. If not, we either make
* a directory listing (if enabled) or send an error
*/
/*
* append docindex to internal_path temporarily
* (internal_path is guaranteed to end with '/')
*/
if (esnprintf(tmppath, sizeof(tmppath), "%s%s",
res->internal_path, srv->docindex)) {
s = S_REQUEST_TOO_LARGE;
goto err;
}
/* stat the temporary path, which must be a regular file */
if (stat(tmppath, &st) < 0 || !S_ISREG(st.st_mode)) {
if (srv->listdirs) {
/* serve directory listing */
/* check if directory is accessible */
if (access(res->internal_path, R_OK) != 0) {
s = S_FORBIDDEN;
goto err;
} else {
res->status = S_OK;
}
res->type = RESTYPE_DIRLISTING;
if (esnprintf(res->field[RES_CONTENT_TYPE],
sizeof(res->field[RES_CONTENT_TYPE]),
"%s", "text/html; charset=utf-8")) {
s = S_INTERNAL_SERVER_ERROR;
goto err;
}
return;
} else {
/* reject */
s = (!S_ISREG(st.st_mode) || errno == EACCES) ?
S_FORBIDDEN : S_NOT_FOUND;
goto err;
}
} else {
/* the docindex exists; copy tmppath to internal path */
if (esnprintf(res->internal_path,
sizeof(res->internal_path), "%s",
tmppath)) {
s = S_REQUEST_TOO_LARGE;
goto err;
}
}
}
/* modified since */
if (req->field[REQ_IF_MODIFIED_SINCE][0]) {
/* parse field */
if (!strptime(req->field[REQ_IF_MODIFIED_SINCE],
"%a, %d %b %Y %T GMT", &tm)) {
s = S_BAD_REQUEST;
goto err;
}
/* compare with last modification date of the file */
if (difftime(st.st_mtim.tv_sec, timegm(&tm)) <= 0) {
res->status = S_NOT_MODIFIED;
return;
}
}
/* range */
if ((s = parse_range(req->field[REQ_RANGE], st.st_size,
&(res->file.lower), &(res->file.upper)))) {
if (s == 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)) {
s = S_INTERNAL_SERVER_ERROR;
goto err;
}
return;
} else {
goto err;
}
}
/* mime */
mime = "application/octet-stream";
if ((p = strrchr(res->internal_path, '.'))) {
for (i = 0; i < LEN(mimes); i++) {
if (!strcmp(mimes[i].ext, p + 1)) {
mime = mimes[i].type;
break;
}
}
}
/* fill response struct */
res->type = RESTYPE_FILE;
/* check if file is readable */
res->status = (access(res->internal_path, R_OK)) ? S_FORBIDDEN :
(req->field[REQ_RANGE][0] != '\0') ?
S_PARTIAL_CONTENT : S_OK;
if (esnprintf(res->field[RES_ACCEPT_RANGES],
sizeof(res->field[RES_ACCEPT_RANGES]),
"%s", "bytes")) {
s = S_INTERNAL_SERVER_ERROR;
goto err;
}
if (esnprintf(res->field[RES_CONTENT_LENGTH],
sizeof(res->field[RES_CONTENT_LENGTH]),
"%zu", res->file.upper - res->file.lower + 1)) {
s = S_INTERNAL_SERVER_ERROR;
goto err;
}
if (req->field[REQ_RANGE][0] != '\0') {
if (esnprintf(res->field[RES_CONTENT_RANGE],
sizeof(res->field[RES_CONTENT_RANGE]),
"bytes %zd-%zd/%zu", res->file.lower,
res->file.upper, st.st_size)) {
s = S_INTERNAL_SERVER_ERROR;
goto err;
}
}
if (esnprintf(res->field[RES_CONTENT_TYPE],
sizeof(res->field[RES_CONTENT_TYPE]),
"%s", mime)) {
s = S_INTERNAL_SERVER_ERROR;
goto err;
}
if (timestamp(res->field[RES_LAST_MODIFIED],
sizeof(res->field[RES_LAST_MODIFIED]),
st.st_mtim.tv_sec)) {
s = S_INTERNAL_SERVER_ERROR;
goto err;
}
return;
err:
http_prepare_error_response(req, res, s);
}
void
http_prepare_error_response(const struct request *req,
struct response *res, enum status s)
{
/* used later */
(void)req;
/* empty all response fields */
memset(res, 0, sizeof(*res));
res->type = RESTYPE_ERROR;
res->status = s;
if (esnprintf(res->field[RES_CONTENT_TYPE],
sizeof(res->field[RES_CONTENT_TYPE]),
"text/html; charset=utf-8")) {
res->status = S_INTERNAL_SERVER_ERROR;
}
if (res->status == S_METHOD_NOT_ALLOWED) {
if (esnprintf(res->field[RES_ALLOW],
sizeof(res->field[RES_ALLOW]),
"Allow: GET, HEAD")) {
res->status = S_INTERNAL_SERVER_ERROR;
}
}
}