quark

http.c (23865B)

---

 /* 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; i++) {
 		if (*s == '%' && isxdigit((unsigned char)s[1]) &&
 		    isxdigit((unsigned char)s[2])) {
 			sscanf(s + 1, "%2hhx", &n);
 			dest[i] = n;
 			s += 3;
 		} 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;
 		}
 	}
 }