#ifndef INDEX_HTML
#define INDEX_HTML "index.html"
#endif
#ifndef SERVER_SOFTWARE
#define SERVER_SOFTWARE "bozohttpd/20260508"
#endif
#ifndef PUBLIC_HTML
#define PUBLIC_HTML "public_html"
#endif
#ifndef USE_ARG
#define USE_ARG(x) (void)&(x)
#endif
#include <sys/param.h>
#include <sys/socket.h>
#include <sys/time.h>
#include <sys/mman.h>
#include <arpa/inet.h>
#include <ctype.h>
#include <dirent.h>
#include <errno.h>
#include <fcntl.h>
#include <netdb.h>
#include <pwd.h>
#include <grp.h>
#include <stdarg.h>
#include <stdlib.h>
#include <stdint.h>
#include <strings.h>
#include <string.h>
#include <syslog.h>
#include <time.h>
#include <unistd.h>
#include "bozohttpd.h"
#ifndef SSL_TIMEOUT
#define SSL_TIMEOUT "30"
#endif
#ifndef INITIAL_TIMEOUT
#define INITIAL_TIMEOUT "30"
#endif
#ifndef HEADER_WAIT_TIME
#define HEADER_WAIT_TIME "10"
#endif
#ifndef TOTAL_MAX_REQ_TIME
#define TOTAL_MAX_REQ_TIME "600"
#endif
#ifndef CLOCK_MONOTONIC
#define CLOCK_MONOTONIC CLOCK_REALTIME
#endif
#ifndef LOG_FTP
#define LOG_FTP LOG_DAEMON
#endif
struct {
const char *file;
const char *name;
} specials[] = {
{ REDIRECT_FILE, "rejected redirect request" },
{ ABSREDIRECT_FILE, "rejected absredirect request" },
{ REMAP_FILE, "rejected remap request" },
{ AUTH_FILE, "rejected authfile request" },
{ NULL, NULL },
};
volatile sig_atomic_t bozo_timeout_hit;
static int
size_arrays(bozohttpd_t *httpd, bozoprefs_t *bozoprefs, size_t needed)
{
size_t len = sizeof(char *) * needed;
if (bozoprefs->size == 0) {
bozoprefs->name = bozomalloc(httpd, len);
bozoprefs->value = bozomalloc(httpd, len);
} else if (bozoprefs->count == bozoprefs->size) {
bozoprefs->name = bozorealloc(httpd, bozoprefs->name, len);
bozoprefs->value = bozorealloc(httpd, bozoprefs->value, len);
}
bozoprefs->size = needed;
return 1;
}
static ssize_t
findvar(bozoprefs_t *bozoprefs, const char *name)
{
size_t i;
for (i = 0; i < bozoprefs->count; i++)
if (strcmp(bozoprefs->name[i], name) == 0)
return (ssize_t)i;
return -1;
}
int
bozo_set_pref(bozohttpd_t *httpd, bozoprefs_t *bozoprefs,
const char *name, const char *value)
{
ssize_t i;
if ((i = findvar(bozoprefs, name)) < 0) {
if (!size_arrays(httpd, bozoprefs, bozoprefs->size + 15))
return 0;
i = bozoprefs->count++;
bozoprefs->name[i] = bozostrdup(httpd, NULL, name);
} else {
free(bozoprefs->value[i]);
}
bozoprefs->value[i] = bozostrdup(httpd, NULL, value);
return 1;
}
static void
bozo_clear_prefs(bozoprefs_t *prefs)
{
size_t i;
for (i = 0; i < prefs->count; i++) {
free(prefs->name[i]);
free(prefs->value[i]);
}
free(prefs->name);
free(prefs->value);
}
char *
bozo_get_pref(bozoprefs_t *bozoprefs, const char *name)
{
ssize_t i;
i = findvar(bozoprefs, name);
return i < 0 ? NULL : bozoprefs->value[i];
}
char *
bozo_http_date(char *date, size_t datelen)
{
struct tm *tm;
time_t now;
now = time(NULL);
tm = gmtime(&now);
strftime(date, datelen, "%a, %d %b %Y %H:%M:%S GMT", tm);
return date;
}
static void
parse_request(bozohttpd_t *httpd, char *in, char **method, char **file,
char **query, char **proto)
{
ssize_t len;
char *val;
USE_ARG(httpd);
debug((httpd, DEBUG_EXPLODING, "parse in: %s", in));
*method = *file = *query = *proto = NULL;
len = (ssize_t)strlen(in);
val = bozostrnsep(&in, " \t\n\r", &len);
if (len < 1 || val == NULL || in == NULL)
return;
*method = val;
while (*in == ' ' || *in == '\t')
in++;
val = bozostrnsep(&in, " \t\n\r", &len);
if (len < 1) {
if (len == 0)
*file = val;
else
*file = in;
} else {
*file = val;
*query = strchr(*file, '?');
if (*query)
*(*query)++ = '\0';
if (in) {
while (*in && (*in == ' ' || *in == '\t'))
in++;
if (*in)
*proto = in;
}
}
*file = bozostrdup(httpd, NULL, *file);
if (*query)
*query = bozostrdup(httpd, NULL, *query);
debug((httpd, DEBUG_FAT,
"url: method: \"%s\" file: \"%s\" query: \"%s\" proto: \"%s\"",
*method, *file, *query ? *query : "", *proto ? *proto : ""));
}
void
bozo_clean_request(bozo_httpreq_t *request)
{
struct bozoheaders *hdr, *ohdr = NULL;
if (request == NULL)
return;
bozo_ssl_destroy(request->hr_httpd);
free(request->hr_remotehost);
free(request->hr_remoteaddr);
free(request->hr_serverport);
free(request->hr_virthostname);
free(request->hr_file_free);
if (request->hr_file_free != request->hr_oldfile)
free(request->hr_oldfile);
else
free(request->hr_file);
free(request->hr_query);
free(request->hr_host);
bozo_user_free(request->hr_user);
bozo_auth_cleanup(request);
for (hdr = SIMPLEQ_FIRST(&request->hr_headers); hdr;
hdr = SIMPLEQ_NEXT(hdr, h_next)) {
free(hdr->h_value);
free(hdr->h_header);
free(ohdr);
ohdr = hdr;
}
free(ohdr);
ohdr = NULL;
for (hdr = SIMPLEQ_FIRST(&request->hr_replheaders); hdr;
hdr = SIMPLEQ_NEXT(hdr, h_next)) {
free(hdr->h_value);
free(hdr->h_header);
free(ohdr);
ohdr = hdr;
}
free(ohdr);
free(request);
}
static void
alarmer(int sig)
{
USE_ARG(sig);
bozo_timeout_hit = 1;
}
int
bozo_set_timeout(bozohttpd_t *httpd, bozoprefs_t *prefs,
const char *target, const char *val)
{
const char **cur, *timeouts[] = {
"ssl timeout",
"initial timeout",
"header timeout",
"request timeout",
NULL,
};
const size_t minlen = 1;
size_t len = strlen(target);
for (cur = timeouts; len >= minlen && *cur; cur++) {
if (strncmp(target, *cur, len) == 0) {
bozo_set_pref(httpd, prefs, *cur, val);
return 0;
}
}
return 1;
}
const char *header_quirks[] = { "WWW-Authenticate", NULL };
static bozoheaders_t *
addmerge_header(bozo_httpreq_t *request, struct qheaders *headers,
const char *val, const char *str, ssize_t len)
{
struct bozohttpd_t *httpd = request->hr_httpd;
struct bozoheaders *hdr = NULL;
const char **quirk;
USE_ARG(len);
for (quirk = header_quirks; *quirk; quirk++)
if (strcasecmp(*quirk, val) == 0)
break;
if (*quirk == NULL) {
SIMPLEQ_FOREACH(hdr, headers, h_next) {
if (strcasecmp(val, hdr->h_header) == 0)
break;
}
}
if (hdr) {
char *nval;
bozoasprintf(httpd, &nval, "%s, %s", hdr->h_value, str);
free(hdr->h_value);
hdr->h_value = nval;
} else {
hdr = bozomalloc(httpd, sizeof *hdr);
hdr->h_header = bozostrdup(httpd, request, val);
if (str && *str)
hdr->h_value = bozostrdup(httpd, request, str);
else
hdr->h_value = bozostrdup(httpd, request, " ");
SIMPLEQ_INSERT_TAIL(headers, hdr, h_next);
request->hr_nheaders++;
}
return hdr;
}
bozoheaders_t *
addmerge_reqheader(bozo_httpreq_t *request, const char *val, const char *str,
ssize_t len)
{
return addmerge_header(request, &request->hr_headers, val, str, len);
}
bozoheaders_t *
addmerge_replheader(bozo_httpreq_t *request, const char *val, const char *str,
ssize_t len)
{
return addmerge_header(request, &request->hr_replheaders,
val, str, len);
}
static int
process_proto(bozo_httpreq_t *request, const char *proto)
{
struct bozohttpd_t *httpd = request->hr_httpd;
char majorstr[16], *minorstr;
int majorint, minorint;
if (proto == NULL) {
got_proto_09:
request->hr_proto = httpd->consts.http_09;
debug((httpd, DEBUG_FAT, "request %s is http/0.9",
request->hr_file));
return 0;
}
if (strncasecmp(proto, "HTTP/", 5) != 0)
goto bad;
strncpy(majorstr, proto + 5, sizeof(majorstr)-1);
majorstr[sizeof(majorstr)-1] = 0;
minorstr = strchr(majorstr, '.');
if (minorstr == NULL)
goto bad;
*minorstr++ = 0;
majorint = atoi(majorstr);
minorint = atoi(minorstr);
switch (majorint) {
case 0:
if (minorint != 9)
break;
goto got_proto_09;
case 1:
if (minorint == 0)
request->hr_proto = httpd->consts.http_10;
else if (minorint == 1)
request->hr_proto = httpd->consts.http_11;
else
break;
debug((httpd, DEBUG_FAT, "request %s is %s",
request->hr_file, request->hr_proto));
SIMPLEQ_INIT(&request->hr_headers);
request->hr_nheaders = 0;
return 0;
}
bad:
return bozo_http_error(httpd, 404, NULL, "unknown prototype");
}
static struct method_map {
const char *name;
int type;
} method_map[] = {
{ "GET", HTTP_GET, },
{ "POST", HTTP_POST, },
{ "HEAD", HTTP_HEAD, },
#if 0
{ "OPTIONS", HTTP_OPTIONS, },
{ "PUT", HTTP_PUT, },
{ "DELETE", HTTP_DELETE, },
{ "TRACE", HTTP_TRACE, },
{ "CONNECT", HTTP_CONNECT, },
#endif
{ NULL, 0, },
};
static int
process_method(bozo_httpreq_t *request, const char *method)
{
struct bozohttpd_t *httpd = request->hr_httpd;
struct method_map *mmp;
if (request->hr_proto == httpd->consts.http_11)
request->hr_allow = "GET, HEAD, POST";
for (mmp = method_map; mmp->name; mmp++)
if (strcasecmp(method, mmp->name) == 0) {
request->hr_method = mmp->type;
request->hr_methodstr = mmp->name;
return 0;
}
return bozo_http_error(httpd, 404, request, "unknown method");
}
static int
bozo_got_header_length(bozo_httpreq_t *request, size_t len)
{
if (len > BOZO_HEADERS_MAX_SIZE - request->hr_header_bytes)
return bozo_http_error(request->hr_httpd, 413, request,
"too many headers");
request->hr_header_bytes += len;
return 0;
}
bozo_httpreq_t *
bozo_read_request(bozohttpd_t *httpd)
{
struct sigaction sa;
char *str, *val, *method, *file, *proto, *query;
char *host, *addr, *port;
char bufport[10];
char hbuf[NI_MAXHOST], abuf[NI_MAXHOST];
struct sockaddr_storage ss;
ssize_t len;
int line = 0;
socklen_t slen;
bozo_httpreq_t *request;
struct timespec ots, ts;
if (bozo_daemon_fork(httpd))
return NULL;
request = bozomalloc(httpd, sizeof(*request));
memset(request, 0, sizeof(*request));
request->hr_httpd = httpd;
request->hr_allow = request->hr_host = NULL;
request->hr_content_type = request->hr_content_length = NULL;
request->hr_range = NULL;
request->hr_last_byte_pos = -1;
request->hr_if_modified_since = NULL;
request->hr_virthostname = NULL;
request->hr_file_free = NULL;
request->hr_file = NULL;
request->hr_oldfile = NULL;
SIMPLEQ_INIT(&request->hr_replheaders);
bozo_auth_init(request);
slen = sizeof(ss);
if (getpeername(0, (struct sockaddr *)(void *)&ss, &slen) < 0)
host = addr = NULL;
else {
if (getnameinfo((struct sockaddr *)(void *)&ss, slen,
abuf, sizeof abuf, NULL, 0, NI_NUMERICHOST) == 0)
addr = abuf;
else
addr = NULL;
if (httpd->numeric == 0 &&
getnameinfo((struct sockaddr *)(void *)&ss, slen,
hbuf, sizeof hbuf, NULL, 0, 0) == 0)
host = hbuf;
else
host = NULL;
}
if (host != NULL)
request->hr_remotehost = bozostrdup(httpd, request, host);
if (addr != NULL)
request->hr_remoteaddr = bozostrdup(httpd, request, addr);
slen = sizeof(ss);
port = NULL;
if (httpd->bindport) {
if (strcmp(httpd->bindport, BOZO_HTTP_PORT) != 0)
port = httpd->bindport;
} else if (getsockname(0, (struct sockaddr *)(void *)&ss, &slen) == 0 &&
getnameinfo((struct sockaddr *)(void *)&ss, slen, NULL, 0,
bufport, sizeof bufport, NI_NUMERICSERV) == 0)
port = bufport;
if (port != NULL)
request->hr_serverport = bozostrdup(httpd, request, port);
sa.sa_handler = alarmer;
sigemptyset(&sa.sa_mask);
sigaddset(&sa.sa_mask, SIGALRM);
sa.sa_flags = 0;
sigaction(SIGALRM, &sa, NULL);
if (clock_gettime(CLOCK_MONOTONIC, &ots) != 0) {
bozo_http_error(httpd, 500, NULL, "clock_gettime failed");
goto cleanup;
}
if (bozo_ssl_accept(httpd))
return NULL;
alarm(httpd->initial_timeout);
while ((str = bozodgetln(httpd, STDIN_FILENO, &len, bozo_read)) != NULL) {
alarm(0);
if (clock_gettime(CLOCK_MONOTONIC, &ts) != 0) {
bozo_http_error(httpd, 500, NULL, "clock_gettime failed");
goto cleanup;
}
if (ts.tv_sec > ots.tv_sec &&
ts.tv_sec > httpd->request_timeout &&
ts.tv_sec - httpd->request_timeout > ots.tv_sec)
bozo_timeout_hit = 1;
if (bozo_timeout_hit) {
bozo_http_error(httpd, 408, NULL, "request timed out");
goto cleanup;
}
line++;
if (line == 1) {
if (len < 1) {
bozo_http_error(httpd, 404, NULL, "null method");
goto cleanup;
}
bozowarn(httpd,
"got request ``%s'' from host %s to port %s",
str,
host ? host : addr ? addr : "<local>",
port ? port : "<stdin>");
parse_request(httpd, str, &method, &file, &query, &proto);
request->hr_file_free = request->hr_file = file;
request->hr_query = query;
if (method == NULL) {
bozo_http_error(httpd, 404, NULL, "null method");
goto cleanup;
}
if (file == NULL) {
bozo_http_error(httpd, 404, NULL, "null file");
goto cleanup;
}
if (process_proto(request, proto) ||
process_method(request, method)) {
goto cleanup;
}
debug((httpd, DEBUG_FAT, "got file \"%s\" query \"%s\"",
request->hr_file,
request->hr_query ? request->hr_query : "<none>"));
if (request->hr_proto == httpd->consts.http_09)
break;
} else {
bozoheaders_t *hdr;
if (*str == '\0')
break;
val = bozostrnsep(&str, ":", &len);
debug((httpd, DEBUG_EXPLODING, "read_req2: after "
"bozostrnsep: str `%s' val `%s'",
str ? str : "<null>", val ? val : "<null>"));
if (val == NULL || len == -1) {
bozo_http_error(httpd, 404, request, "no header");
goto cleanup;
}
if (str == NULL) {
bozo_http_error(httpd, 404, request,
"malformed header");
goto cleanup;
}
while (*str == ' ' || *str == '\t')
len--, str++;
while (*val == ' ' || *val == '\t')
val++;
if (bozo_got_header_length(request, len))
goto cleanup;
if (bozo_auth_check_headers(request, val, str, len))
goto next_header;
hdr = addmerge_reqheader(request, val, str, len);
if (strcasecmp(hdr->h_header, "content-type") == 0)
request->hr_content_type = hdr->h_value;
else if (strcasecmp(hdr->h_header, "content-length") == 0)
request->hr_content_length = hdr->h_value;
else if (strcasecmp(hdr->h_header, "host") == 0) {
if (request->hr_host) {
bozo_http_error(httpd, 400, request,
"Only allow one Host: header");
goto cleanup;
}
request->hr_host = bozostrdup(httpd, request,
hdr->h_value);
}
else if (strcasecmp(hdr->h_header, "expect") == 0) {
bozo_http_error(httpd, 417, request,
"we don't support Expect:");
goto cleanup;
}
else if (strcasecmp(hdr->h_header, "referrer") == 0 ||
strcasecmp(hdr->h_header, "referer") == 0)
request->hr_referrer = hdr->h_value;
else if (strcasecmp(hdr->h_header, "range") == 0)
request->hr_range = hdr->h_value;
else if (strcasecmp(hdr->h_header,
"if-modified-since") == 0)
request->hr_if_modified_since = hdr->h_value;
else if (strcasecmp(hdr->h_header,
"accept-encoding") == 0)
request->hr_accept_encoding = hdr->h_value;
debug((httpd, DEBUG_FAT, "adding header %s: %s",
hdr->h_header, hdr->h_value));
}
next_header:
alarm(httpd->header_timeout);
}
if (str == NULL) {
bozo_http_error(httpd, 413, request, "request too large");
goto cleanup;
}
alarm(0);
signal(SIGALRM, SIG_DFL);
if (request->hr_method == HTTP_POST &&
request->hr_content_length == NULL) {
bozo_http_error(httpd, 400, request, "missing content length");
goto cleanup;
}
if (request->hr_proto == httpd->consts.http_11 &&
request->hr_host == NULL) {
bozo_http_error(httpd, 400, request, "missing Host header");
goto cleanup;
}
if (request->hr_range != NULL) {
debug((httpd, DEBUG_FAT, "hr_range: %s", request->hr_range));
if (strchr(request->hr_range, ',') == NULL) {
const char *rstart, *dash;
rstart = strchr(request->hr_range, '=');
if (rstart != NULL) {
rstart++;
dash = strchr(rstart, '-');
if (dash != NULL && dash != rstart) {
dash++;
request->hr_have_range = 1;
request->hr_first_byte_pos =
strtoll(rstart, NULL, 10);
if (request->hr_first_byte_pos < 0)
request->hr_first_byte_pos = 0;
if (*dash != '\0') {
request->hr_last_byte_pos =
strtoll(dash, NULL, 10);
if (request->hr_last_byte_pos < 0)
request->hr_last_byte_pos = -1;
}
}
}
}
}
debug((httpd, DEBUG_FAT, "bozo_read_request returns url %s in request",
request->hr_file));
return request;
cleanup:
bozo_clean_request(request);
return NULL;
}
static int
mmap_and_write_part(bozohttpd_t *httpd, int fd, off_t first_byte_pos, size_t sz)
{
size_t mappedsz, wroffset;
off_t mappedoffset;
char *addr;
void *mappedaddr;
mappedoffset = first_byte_pos & ~((off_t)httpd->page_size - 1);
mappedsz = (size_t)
(first_byte_pos - mappedoffset + sz + httpd->page_size - 1) &
~(httpd->page_size - 1);
wroffset = (size_t)(first_byte_pos - mappedoffset);
addr = mmap(0, mappedsz, PROT_READ, MAP_SHARED, fd, mappedoffset);
if (addr == MAP_FAILED) {
bozowarn(httpd, "mmap failed: %s", strerror(errno));
return -1;
}
mappedaddr = addr;
#ifdef MADV_SEQUENTIAL
(void)madvise(addr, sz, MADV_SEQUENTIAL);
#endif
while (sz > BOZO_WRSZ) {
if (bozo_write(httpd, STDOUT_FILENO, addr + wroffset,
BOZO_WRSZ) != BOZO_WRSZ) {
bozowarn(httpd, "write failed: %s", strerror(errno));
goto out;
}
debug((httpd, DEBUG_OBESE, "wrote %d bytes", BOZO_WRSZ));
sz -= BOZO_WRSZ;
addr += BOZO_WRSZ;
}
if (sz && (size_t)bozo_write(httpd, STDOUT_FILENO, addr + wroffset,
sz) != sz) {
bozowarn(httpd, "final write failed: %s", strerror(errno));
goto out;
}
debug((httpd, DEBUG_OBESE, "wrote %d bytes", (int)sz));
out:
if (munmap(mappedaddr, mappedsz) < 0) {
bozowarn(httpd, "munmap failed");
return -1;
}
return 0;
}
static int
parse_http_date(const char *val, time_t *timestamp)
{
char *remainder;
struct tm tm;
if ((remainder = strptime(val, "%a, %d %b %Y %T GMT", &tm)) == NULL &&
(remainder = strptime(val, "%a, %d-%b-%y %T GMT", &tm)) == NULL &&
(remainder = strptime(val, "%a %b %d %T %Y", &tm)) == NULL)
return 0;
if (*remainder)
return 0;
*timestamp = timegm(&tm);
return 1;
}
char *
bozo_escape_rfc3986(bozohttpd_t *httpd, const char *url, int absolute)
{
static char *buf;
static size_t buflen = 0;
size_t len;
const char *s;
char *d;
len = strlen(url);
if (buflen < len * 3 + 1) {
buflen = len * 3 + 1;
buf = bozorealloc(httpd, buf, buflen);
}
for (s = url, d = buf; *s;) {
if (*s & 0x80)
goto encode_it;
switch (*s) {
case ':':
case '?':
case '#':
case '[':
case ']':
case '@':
case '!':
case '$':
case '&':
case '\'':
case '(':
case ')':
case '*':
case '+':
case ',':
case ';':
case '=':
case '%':
case '"':
if (absolute)
goto leave_it;
case '\n':
case '\r':
case ' ':
encode_it:
snprintf(d, 4, "%%%02X", (unsigned char)*s++);
d += 3;
break;
default:
leave_it:
*d++ = *s++;
break;
}
}
*d = 0;
return buf;
}
static void
handle_redirect(bozo_httpreq_t *request, const char *url, int absolute)
{
bozohttpd_t *httpd = request->hr_httpd;
char *finalurl, *urlbuf;
#ifndef NO_USER_SUPPORT
char *userbuf;
#endif
char portbuf[20];
const char *scheme, *query, *quest;
const char *hostname = BOZOHOST(httpd, request);
int absproto = 0;
if (url == NULL) {
bozoasprintf(httpd, &urlbuf, "/%s/", request->hr_file);
url = urlbuf;
} else
urlbuf = NULL;
#ifndef NO_USER_SUPPORT
if (request->hr_user && !absolute) {
bozoasprintf(httpd, &userbuf, "/~%s%s", request->hr_user, url);
url = userbuf;
} else
userbuf = NULL;
#endif
if (absolute) {
const char *sep = NULL;
const char *s;
sep = strstr(url, "://");
if (sep) {
for (s = url; s != sep;) {
if (!isalnum((unsigned char)*s) &&
*s != '+' && *s != '-' && *s != '.')
break;
if (++s == sep) {
absproto = 1;
}
}
}
}
scheme = absproto ? "" : httpd->sslinfo ? "https://" : "http://";
if (absolute) {
hostname = "";
portbuf[0] = '\0';
} else {
const char *defport = httpd->sslinfo ? BOZO_HTTPS_PORT : BOZO_HTTP_PORT;
if (request->hr_serverport &&
strcmp(request->hr_serverport, defport) != 0)
snprintf(portbuf, sizeof(portbuf), ":%s",
request->hr_serverport);
else
portbuf[0] = '\0';
}
url = bozo_escape_rfc3986(httpd, url, absolute);
if (request->hr_query && strlen(request->hr_query)) {
query = request->hr_query;
quest = "?";
} else {
query = quest = "";
}
bozoasprintf(httpd, &finalurl, "%s%s%s%s%s%s",
scheme, hostname, portbuf, url, quest, query);
bozowarn(httpd, "redirecting %s", finalurl);
debug((httpd, DEBUG_FAT, "redirecting %s", finalurl));
bozo_printf(httpd, "%s 301 Document Moved\r\n", request->hr_proto);
if (request->hr_proto != httpd->consts.http_09)
bozo_print_header(request, NULL, "text/html", NULL);
if (request->hr_proto != httpd->consts.http_09)
bozo_printf(httpd, "Location: %s\r\n", finalurl);
bozo_printf(httpd, "\r\n");
if (request->hr_method == HTTP_HEAD)
goto head;
bozo_printf(httpd, "<html><head><title>Document Moved</title></head>\n");
bozo_printf(httpd, "<body><h1>Document Moved</h1>\n");
bozo_printf(httpd, "This document had moved <a href=\"%s\">here</a>\n",
finalurl);
bozo_printf(httpd, "</body></html>\n");
head:
bozo_flush(httpd, stdout);
free(urlbuf);
free(finalurl);
#ifndef NO_USER_SUPPORT
free(userbuf);
#endif
}
static int
esccmp(const char *s_plain, const char *s_esc, size_t len)
{
bool esc = false;
while (len) {
if (!esc && *s_esc == '\\') {
esc = true;
s_esc++;
continue;
}
esc = false;
if (*s_plain == 0 || *s_esc == 0 || *s_plain != *s_esc)
return *s_esc - *s_plain;
s_esc++;
s_plain++;
len--;
}
return 0;
}
static void
check_remap(bozo_httpreq_t *request)
{
bozohttpd_t *httpd = request->hr_httpd;
char *file = request->hr_file, *newfile;
void *fmap;
const char *replace = NULL, *map_to = NULL, *p;
struct stat st;
int mapfile;
size_t avail, len, rlen, reqlen, num_esc = 0;
bool escaped = false;
mapfile = open(REMAP_FILE, O_RDONLY, 0);
if (mapfile == -1)
return;
debug((httpd, DEBUG_FAT, "remap file found"));
if (fstat(mapfile, &st) == -1) {
bozowarn(httpd, "could not stat " REMAP_FILE ", errno: %d",
errno);
goto out;
}
fmap = mmap(NULL, st.st_size, PROT_READ, MAP_SHARED, mapfile, 0);
if (fmap == MAP_FAILED) {
bozowarn(httpd, "could not mmap " REMAP_FILE ", error %d",
errno);
goto out;
}
reqlen = strlen(file);
for (p = fmap, avail = st.st_size; avail; ) {
while ((*p == '\r' || *p == '\n') && avail) {
p++;
avail--;
}
replace = p;
escaped = false;
while (avail) {
if (*p == '\r' || *p == '\n')
break;
if (!escaped && *p == ':')
break;
if (escaped) {
escaped = false;
num_esc++;
} else if (*p == '\\') {
escaped = true;
}
p++;
avail--;
}
if (!avail || *p != ':') {
replace = NULL;
map_to = NULL;
break;
}
len = p - replace - num_esc;
if (avail < 2 || reqlen < len ||
(reqlen == len && esccmp(file, replace, len) != 0) ||
(reqlen > len && (file[len] != '/' ||
esccmp(file, replace, len) != 0))) {
while (*p != '\r' && *p != '\n' && avail) {
p++;
avail--;
}
replace = NULL;
map_to = NULL;
continue;
}
p++;
avail--;
map_to = p;
while (*p != '\r' && *p != '\n' && avail) {
p++;
avail--;
}
rlen = p - map_to;
break;
}
if (replace && map_to) {
newfile = bozomalloc(httpd, strlen(file) + rlen - len + 1);
memcpy(newfile, map_to, rlen);
strcpy(newfile+rlen, file + len);
debug((httpd, DEBUG_NORMAL, "remapping found '%s'",
newfile));
free(request->hr_file_free);
request->hr_file_free = request->hr_file = newfile;
}
munmap(fmap, st.st_size);
out:
close(mapfile);
}
static int
check_virtual(bozo_httpreq_t *request)
{
bozohttpd_t *httpd = request->hr_httpd;
char *file = request->hr_file, *s;
size_t len;
int allocated = 0, rc;
debug((httpd, DEBUG_OBESE,
"checking for http:// virtual host in '%s'", file));
if (strncasecmp(file, "http://", 7) == 0) {
file += 7;
free(request->hr_host);
request->hr_host = bozostrdup(httpd, request, file);
if ((s = strchr(request->hr_host, '/')) != NULL)
*s = '\0';
s = strchr(file, '/');
request->hr_file = bozostrdup(httpd, request, s ? s : "/");
free(request->hr_file_free);
request->hr_file_free = request->hr_file;
debug((httpd, DEBUG_OBESE, "got host '%s' file is now '%s'",
request->hr_host, request->hr_file));
} else if (!request->hr_host)
goto use_slashdir;
len = strlen(request->hr_host);
if (len > 3 &&
strcmp(request->hr_host + len - 3, ":" BOZO_HTTP_PORT) == 0) {
request->hr_host[len - 3] = '\0';
len = strlen(request->hr_host);
}
if (!httpd->virtbase) {
if (request->hr_host) {
s = strrchr(request->hr_host, ':');
if (s != NULL)
*s = '\0';
request->hr_virthostname = bozostrdup(httpd, request,
request->hr_host);
if (s != NULL)
*s = ':';
}
goto use_slashdir;
}
debug((httpd, DEBUG_OBESE,
"check_virtual: checking host `%s' under httpd->virtbase `%s' "
"for file `%s'",
request->hr_host, httpd->virtbase, request->hr_file));
if (strncasecmp(httpd->virthostname, request->hr_host, len) != 0) {
s = NULL;
DIR *dirp;
struct dirent *d;
if ((dirp = opendir(httpd->virtbase)) != NULL) {
while ((d = readdir(dirp)) != NULL) {
if (strcmp(d->d_name, ".") == 0 ||
strcmp(d->d_name, "..") == 0) {
continue;
}
debug((httpd, DEBUG_OBESE, "looking at dir '%s'",
d->d_name));
if (strcmp(d->d_name, request->hr_host) == 0) {
debug((httpd, DEBUG_OBESE, "found it punch it"));
request->hr_virthostname =
bozostrdup(httpd, request, d->d_name);
bozoasprintf(httpd, &s, "%s/%s",
httpd->virtbase,
request->hr_virthostname);
allocated = 1;
break;
}
}
closedir(dirp);
}
else {
debug((httpd, DEBUG_FAT, "opendir %s failed: %s",
httpd->virtbase, strerror(errno)));
}
if (s == 0) {
if (httpd->unknown_slash)
goto use_slashdir;
return bozo_http_error(httpd, 404, request,
"unknown URL");
}
} else
use_slashdir:
s = httpd->slashdir;
rc = chdir(s);
if (allocated != 0)
free(s);
if (rc < 0)
return bozo_http_error(httpd, 404, request,
"can't chdir to slashdir");
check_remap(request);
return 0;
}
static int
check_bzredirect(bozo_httpreq_t *request)
{
bozohttpd_t *httpd = request->hr_httpd;
struct stat sb;
char dir[MAXPATHLEN], redir[MAXPATHLEN], redirpath[MAXPATHLEN + 1],
path[MAXPATHLEN + 1];
char *basename, *finalredir;
int rv, absolute;
if ((size_t)snprintf(dir, sizeof(dir), "%s", request->hr_file + 1) >=
sizeof(dir)) {
bozo_http_error(httpd, 404, request, "file path too long");
return -1;
}
debug((httpd, DEBUG_FAT, "check_bzredirect: dir %s", dir));
basename = strrchr(dir, '/');
if ((!basename || basename[1] != '\0') &&
lstat(dir, &sb) == 0 && S_ISDIR(sb.st_mode)) {
strcpy(path, dir);
basename = dir;
} else if (basename == NULL) {
strcpy(path, ".");
strcpy(dir, "");
basename = request->hr_file + 1;
} else {
*basename++ = '\0';
strcpy(path, dir);
}
if (bozo_check_special_files(request, basename, true))
return -1;
debug((httpd, DEBUG_FAT, "check_bzredirect: path %s", path));
if ((size_t)snprintf(redir, sizeof(redir), "%s/%s", path,
REDIRECT_FILE) >= sizeof(redir)) {
return bozo_http_error(httpd, 404, request,
"redirectfile path too long");
}
if (lstat(redir, &sb) == 0) {
if (!S_ISLNK(sb.st_mode))
return 0;
absolute = 0;
} else {
if ((size_t)snprintf(redir, sizeof(redir), "%s/%s", path,
ABSREDIRECT_FILE) >= sizeof(redir)) {
bozo_http_error(httpd, 404, request,
"redirectfile path too long");
return -1;
}
if (lstat(redir, &sb) < 0 || !S_ISLNK(sb.st_mode))
return 0;
absolute = 1;
}
debug((httpd, DEBUG_FAT, "check_bzredirect: calling readlink"));
rv = readlink(redir, redirpath, sizeof redirpath - 1);
if (rv == -1 || rv == 0) {
debug((httpd, DEBUG_FAT, "readlink failed"));
return 0;
}
redirpath[rv] = '\0';
debug((httpd, DEBUG_FAT, "readlink returned \"%s\"", redirpath));
snprintf(path, sizeof(path), "%s/", dir);
if (bozo_auth_check(request, path))
return 1;
if (!absolute && redirpath[0] != '/') {
if ((size_t)snprintf(finalredir = redir, sizeof(redir), "%s%s/%s",
(strlen(dir) > 0 ? "/" : ""), dir, redirpath) >= sizeof(redir)) {
bozo_http_error(httpd, 404, request,
"redirect path too long");
return -1;
}
} else
finalredir = redirpath;
debug((httpd, DEBUG_FAT, "check_bzredirect: new redir %s", finalredir));
handle_redirect(request, finalredir, absolute);
return 1;
}
int
bozo_decode_url_percent(bozo_httpreq_t *request, char *str)
{
bozohttpd_t *httpd = request->hr_httpd;
char *s, *t, buf[3];
char *end;
end = str + strlen(str);
if ((s = strchr(str, '%')) == NULL)
return 0;
t = s;
do {
if (end && s >= end) {
debug((httpd, DEBUG_EXPLODING,
"fu_%%: past end, filling out.."));
while (*s)
*t++ = *s++;
break;
}
if (&s[2] < end)
debug((httpd, DEBUG_EXPLODING,
"fu_%%: got s == %%, s[1]s[2] == %c%c",
s[1], s[2]));
else
debug((httpd, DEBUG_EXPLODING,
"fu_%%: got s == %%, s[1] == %c s[2] is not set",
s[1]));
if (s[1] == '\0' || s[2] == '\0')
return bozo_http_error(httpd, 400, request,
"percent hack missing two chars afterwards");
if (s[1] == '0' && s[2] == '0')
return bozo_http_error(httpd, 404, request,
"percent hack was %00");
if (s[1] == '2' && (s[2] == 'f' || s[2] == 'F'))
return bozo_http_error(httpd, 404, request,
"percent hack was %2f (/)");
buf[0] = *++s;
buf[1] = *++s;
buf[2] = '\0';
s++;
*t = (char)strtol(buf, NULL, 16);
debug((httpd, DEBUG_EXPLODING,
"fu_%%: strtol put '%02x' into *t", *t));
if (*t++ == '\0')
return bozo_http_error(httpd, 400, request,
"percent hack got a 0 back");
while (*s && *s != '%') {
if (end && s >= end)
break;
*t++ = *s++;
}
} while (*s);
*t = '\0';
debug((httpd, DEBUG_FAT, "bozo_decode_url_percent returns `%s'",
request->hr_file));
return 0;
}
static int
transform_request(bozo_httpreq_t *request, int *isindex)
{
bozohttpd_t *httpd = request->hr_httpd;
char *file, *newfile = NULL;
size_t len;
file = NULL;
*isindex = 0;
debug((httpd, DEBUG_FAT, "tf_req: file %s", request->hr_file));
if (bozo_decode_url_percent(request, request->hr_file) ||
check_virtual(request))
goto bad_done;
file = request->hr_file;
if (file[0] != '/') {
bozo_http_error(httpd, 404, request, "unknown URL");
goto bad_done;
}
while (file[1] == '/')
file++;
request->hr_file = file;
len = strlen(file);
#ifndef NO_USER_SUPPORT
if (len > 1 && httpd->enable_users && file[1] == '~') {
if (file[2] == '\0') {
bozo_http_error(httpd, 404, request,
"missing username");
goto bad_done;
}
if (strchr(file + 2, '/') == NULL) {
char *userredirecturl;
bozoasprintf(httpd, &userredirecturl, "%s/", file);
handle_redirect(request, userredirecturl, 0);
free(userredirecturl);
return 0;
}
debug((httpd, DEBUG_FAT, "calling bozo_user_transform"));
if (!bozo_user_transform(request))
return 0;
file = request->hr_file;
len = strlen(file);
}
#endif
switch (check_bzredirect(request)) {
case -1:
goto bad_done;
case 0:
break;
default:
return 0;
}
if (len > 1) {
debug((httpd, DEBUG_FAT, "file[len-1] == %c", file[len-1]));
if (file[len-1] == '/') {
*isindex = 1;
debug((httpd, DEBUG_FAT, "appending index.html"));
newfile = bozomalloc(httpd,
len + strlen(httpd->index_html) + 1);
strcpy(newfile, file + 1);
strcat(newfile, httpd->index_html);
} else
newfile = bozostrdup(httpd, request, file + 1);
} else if (len == 1) {
debug((httpd, DEBUG_EXPLODING, "tf_req: len == 1"));
newfile = bozostrdup(httpd, request, httpd->index_html);
*isindex = 1;
} else {
bozo_http_error(httpd, 500, request, "request->hr_file is nul");
goto bad_done;
}
if (newfile == NULL) {
bozo_http_error(httpd, 500, request, "internal failure");
goto bad_done;
}
debug((httpd, DEBUG_FAT, "newfile: %s", newfile));
if (*newfile == '/' || strcmp(newfile, "..") == 0 ||
strstr(newfile, "/..") || strstr(newfile, "../")) {
bozo_http_error(httpd, 403, request, "illegal request");
goto bad_done;
}
if (bozo_auth_check(request, newfile))
goto bad_done;
if (strlen(newfile)) {
request->hr_oldfile = request->hr_file_free;
request->hr_file = newfile;
}
if (bozo_process_cgi(request) ||
bozo_process_lua(request))
return 0;
debug((httpd, DEBUG_FAT, "transform_request set: %s", newfile));
return 1;
bad_done:
debug((httpd, DEBUG_FAT, "transform_request returning: 0"));
free(newfile);
return 0;
}
static int
can_gzip(bozo_httpreq_t *request)
{
const char *pos;
const char *tmp;
size_t len;
tmp = bozo_content_encoding(request, request->hr_file);
if (tmp && *tmp)
return 0;
if (request->hr_last_byte_pos != -1 || request->hr_have_range)
return 0;
for (pos = request->hr_accept_encoding; pos && *pos; pos += len) {
while (*pos == ' ')
pos++;
len = strcspn(pos, ";,");
if ((len == 4 && strncasecmp("gzip", pos, 4) == 0) ||
(len == 6 && strncasecmp("x-gzip", pos, 6) == 0))
return 1;
if (pos[len] == ';')
len += strcspn(&pos[len], ",");
if (pos[len])
len++;
}
return 0;
}
void
bozo_process_request(bozo_httpreq_t *request)
{
bozohttpd_t *httpd = request->hr_httpd;
struct stat sb;
time_t timestamp;
char *file;
const char *type, *encoding;
int fd, isindex;
if (transform_request(request, &isindex) == 0)
return;
fd = -1;
encoding = NULL;
if (can_gzip(request)) {
bozoasprintf(httpd, &file, "%s.gz", request->hr_file);
fd = open(file, O_RDONLY);
if (fd >= 0)
encoding = "gzip";
free(file);
}
file = request->hr_file;
if (fd < 0)
fd = open(file, O_RDONLY);
if (fd < 0) {
debug((httpd, DEBUG_FAT, "open failed: %s", strerror(errno)));
switch (errno) {
case EPERM:
case EACCES:
bozo_http_error(httpd, 403, request,
"no permission to open file");
break;
case ENAMETOOLONG:
case ENOENT:
if (!bozo_dir_index(request, file, isindex))
bozo_http_error(httpd, 404, request, "no file");
break;
default:
bozo_http_error(httpd, 500, request, "open file");
}
goto cleanup_nofd;
}
if (fstat(fd, &sb) < 0) {
bozo_http_error(httpd, 500, request, "can't fstat");
goto cleanup;
}
if (S_ISDIR(sb.st_mode)) {
handle_redirect(request, NULL, 0);
goto cleanup;
}
if (request->hr_if_modified_since &&
parse_http_date(request->hr_if_modified_since, ×tamp) &&
timestamp >= sb.st_mtime) {
bozo_printf(httpd, "%s 304 Not Modified\r\n",
request->hr_proto);
bozo_printf(httpd, "\r\n");
bozo_flush(httpd, stdout);
goto cleanup;
}
if (request->hr_last_byte_pos == -1 ||
request->hr_last_byte_pos >= sb.st_size)
request->hr_last_byte_pos = sb.st_size - 1;
if (request->hr_have_range &&
request->hr_first_byte_pos > request->hr_last_byte_pos) {
request->hr_have_range = 0;
request->hr_first_byte_pos = 0;
request->hr_last_byte_pos = sb.st_size - 1;
}
debug((httpd, DEBUG_FAT, "have_range %d first_pos %lld last_pos %lld",
request->hr_have_range,
(long long)request->hr_first_byte_pos,
(long long)request->hr_last_byte_pos));
if (request->hr_have_range)
bozo_printf(httpd, "%s 206 Partial Content\r\n",
request->hr_proto);
else
bozo_printf(httpd, "%s 200 OK\r\n", request->hr_proto);
if (request->hr_proto != httpd->consts.http_09) {
type = bozo_content_type(request, file);
if (!encoding)
encoding = bozo_content_encoding(request, file);
bozo_print_header(request, &sb, type, encoding);
bozo_printf(httpd, "\r\n");
}
bozo_flush(httpd, stdout);
if (request->hr_method != HTTP_HEAD) {
off_t szleft, cur_byte_pos;
szleft =
request->hr_last_byte_pos - request->hr_first_byte_pos + 1;
cur_byte_pos = request->hr_first_byte_pos;
retry:
while (szleft) {
size_t sz;
if ((off_t)httpd->mmapsz < szleft)
sz = httpd->mmapsz;
else
sz = (size_t)szleft;
if (mmap_and_write_part(httpd, fd, cur_byte_pos, sz)) {
if (errno == ENOMEM) {
httpd->mmapsz /= 2;
if (httpd->mmapsz >= httpd->page_size)
goto retry;
}
goto cleanup;
}
cur_byte_pos += sz;
szleft -= sz;
}
}
cleanup:
close(fd);
cleanup_nofd:
bozo_ssl_shutdown(request->hr_httpd);
close(STDIN_FILENO);
close(STDOUT_FILENO);
}
int
bozo_check_special_files(bozo_httpreq_t *request, const char *name, bool doerror)
{
bozohttpd_t *httpd = request->hr_httpd;
size_t i;
int error = 0;
for (i = 0; specials[i].file; i++) {
if (strcmp(name, specials[i].file) == 0) {
if (doerror) {
error = bozo_http_error(httpd, 403, request,
specials[i].name);
} else {
error = -1;
}
}
}
return error;
}
void
bozo_print_header(bozo_httpreq_t *request,
struct stat *sbp, const char *type, const char *encoding)
{
bozohttpd_t *httpd = request->hr_httpd;
off_t len;
char date[40];
bozoheaders_t *hdr;
SIMPLEQ_FOREACH(hdr, &request->hr_replheaders, h_next) {
bozo_printf(httpd, "%s: %s\r\n", hdr->h_header,
hdr->h_value);
}
bozo_printf(httpd, "Date: %s\r\n", bozo_http_date(date, sizeof(date)));
bozo_printf(httpd, "Server: %s\r\n", httpd->server_software);
bozo_printf(httpd, "Accept-Ranges: bytes\r\n");
if (sbp) {
char filedate[40];
struct tm *tm;
tm = gmtime(&sbp->st_mtime);
strftime(filedate, sizeof filedate,
"%a, %d %b %Y %H:%M:%S GMT", tm);
bozo_printf(httpd, "Last-Modified: %s\r\n", filedate);
}
if (type && *type)
bozo_printf(httpd, "Content-Type: %s\r\n", type);
if (encoding && *encoding)
bozo_printf(httpd, "Content-Encoding: %s\r\n", encoding);
if (sbp) {
if (request->hr_have_range) {
len = request->hr_last_byte_pos -
request->hr_first_byte_pos +1;
bozo_printf(httpd,
"Content-Range: bytes %qd-%qd/%qd\r\n",
(long long) request->hr_first_byte_pos,
(long long) request->hr_last_byte_pos,
(long long) sbp->st_size);
} else
len = sbp->st_size;
bozo_printf(httpd, "Content-Length: %qd\r\n", (long long)len);
}
if (request->hr_proto == httpd->consts.http_11)
bozo_printf(httpd, "Connection: close\r\n");
bozo_flush(httpd, stdout);
}
#ifndef NO_DEBUG
void
debug__(bozohttpd_t *httpd, int level, const char *fmt, ...)
{
va_list ap;
int savederrno;
if (httpd->debug < level)
return;
savederrno = errno;
va_start(ap, fmt);
if (!httpd->nolog) {
if (httpd->logstderr) {
vfprintf(stderr, fmt, ap);
fputs("\n", stderr);
} else
vsyslog(LOG_DEBUG, fmt, ap);
}
va_end(ap);
errno = savederrno;
}
#endif
void
bozowarn(bozohttpd_t *httpd, const char *fmt, ...)
{
va_list ap;
va_start(ap, fmt);
if (!httpd->nolog) {
if (httpd->logstderr || isatty(STDERR_FILENO)) {
vfprintf(stderr, fmt, ap);
fputs("\n", stderr);
} else
vsyslog(LOG_INFO, fmt, ap);
}
va_end(ap);
}
void
bozoerr(bozohttpd_t *httpd, int code, const char *fmt, ...)
{
va_list ap;
va_start(ap, fmt);
if (!httpd->nolog) {
if (httpd->logstderr || isatty(STDERR_FILENO)) {
vfprintf(stderr, fmt, ap);
fputs("\n", stderr);
} else
vsyslog(LOG_ERR, fmt, ap);
}
va_end(ap);
exit(code);
}
void
bozoasprintf(bozohttpd_t *httpd, char **str, const char *fmt, ...)
{
va_list ap;
int e;
va_start(ap, fmt);
e = vasprintf(str, fmt, ap);
va_end(ap);
if (e < 0)
bozoerr(httpd, EXIT_FAILURE, "asprintf");
}
char *
bozo_escape_html(bozohttpd_t *httpd, const char *url)
{
int i, j;
char *tmp;
size_t len;
for (i = 0, j = 0; url[i]; i++) {
switch (url[i]) {
case '<':
case '>':
j += 4;
break;
case '&':
j += 5;
break;
case '"':
j += 6;
break;
}
}
if (j == 0)
return NULL;
len = strlen(url) + j;
if (httpd)
tmp = bozomalloc(httpd, len);
else if ((tmp = malloc(len)) == 0)
return NULL;
for (i = 0, j = 0; url[i]; i++) {
switch (url[i]) {
case '<':
memcpy(tmp + j, "<", 4);
j += 4;
break;
case '>':
memcpy(tmp + j, ">", 4);
j += 4;
break;
case '&':
memcpy(tmp + j, "&", 5);
j += 5;
break;
case '"':
memcpy(tmp + j, """, 6);
j += 6;
break;
default:
tmp[j++] = url[i];
}
}
tmp[j] = 0;
return tmp;
}
static struct errors_map {
int code;
const char *shortmsg;
const char *longmsg;
} errors_map[] = {
{ 200, "200 OK", "The request was valid", },
{ 400, "400 Bad Request", "The request was not valid", },
{ 401, "401 Unauthorized", "No authorization", },
{ 403, "403 Forbidden", "Access to this item has been denied",},
{ 404, "404 Not Found", "This item has not been found", },
{ 408, "408 Request Timeout", "This request took too long", },
{ 413, "413 Payload Too Large", "Use smaller requests", },
{ 417, "417 Expectation Failed","Expectations not available", },
{ 420, "420 Enhance Your Calm","Chill, Winston", },
{ 500, "500 Internal Error", "An error occurred on the server", },
{ 501, "501 Not Implemented", "This request is not available", },
{ 0, NULL, NULL, },
};
static const char *help = "DANGER! WILL ROBINSON! DANGER!";
static const char *
http_errors_short(int code)
{
struct errors_map *ep;
for (ep = errors_map; ep->code; ep++)
if (ep->code == code)
return (ep->shortmsg);
return (help);
}
static const char *
http_errors_long(int code)
{
struct errors_map *ep;
for (ep = errors_map; ep->code; ep++)
if (ep->code == code)
return (ep->longmsg);
return (help);
}
#ifndef NO_BLOCKLIST_SUPPORT
static struct blocklist *blstate;
void
pfilter_notify(const int what, const int code)
{
if (blstate == NULL)
blstate = blocklist_open();
if (blstate == NULL)
return;
(void)blocklist_r(blstate, what, 0, http_errors_short(code));
}
#endif
int
bozo_http_error(bozohttpd_t *httpd, int code, bozo_httpreq_t *request,
const char *msg)
{
char portbuf[20];
const char *header = http_errors_short(code);
const char *reason = http_errors_long(code);
const char *proto = (request && request->hr_proto) ?
request->hr_proto : httpd->consts.http_11;
int size;
bozoheaders_t *hdr;
USE_ARG(msg);
debug((httpd, DEBUG_FAT, "bozo_http_error %d: %s", code, msg));
if (header == NULL || reason == NULL) {
bozoerr(httpd, 1,
"bozo_http_error() failed (short = %p, long = %p)",
header, reason);
return code;
}
if (request && request->hr_serverport &&
strcmp(request->hr_serverport, BOZO_HTTP_PORT) != 0)
snprintf(portbuf, sizeof(portbuf), ":%s",
request->hr_serverport);
else
portbuf[0] = '\0';
if (request && request->hr_file) {
char *file = NULL, *user = NULL;
int file_alloc = 0;
const char *hostname = BOZOHOST(httpd, request);
file = bozo_escape_html(NULL, request->hr_file);
if (file == NULL)
file = request->hr_file;
else
file_alloc = 1;
#ifndef NO_USER_SUPPORT
if (request->hr_user != NULL) {
char *user_escaped;
user_escaped = bozo_escape_html(NULL, request->hr_user);
if (user_escaped == NULL)
user_escaped = request->hr_user;
bozoasprintf(httpd, &user, "~%s/", user_escaped);
if (user_escaped != request->hr_user)
free(user_escaped);
}
#endif
size = snprintf(httpd->errorbuf, BOZO_MINBUFSIZE,
"<html><head><title>%s</title></head>\n"
"<body><h1>%s</h1>\n"
"%s%s: <pre>%s</pre>\n"
"<hr><address><a href=\"//%s%s/\">%s%s</a></address>\n"
"</body></html>\n",
header, header,
user ? user : "", file,
reason, hostname, portbuf, hostname, portbuf);
free(user);
if (size >= (int)BOZO_MINBUFSIZE) {
bozowarn(httpd,
"bozo_http_error buffer too small, truncated");
size = (int)BOZO_MINBUFSIZE;
}
if (file_alloc)
free(file);
} else
size = 0;
bozo_printf(httpd, "%s %s\r\n", proto, header);
if (request) {
bozo_auth_check_401(request, code);
SIMPLEQ_FOREACH(hdr, &request->hr_replheaders, h_next) {
bozo_printf(httpd, "%s: %s\r\n", hdr->h_header,
hdr->h_value);
}
}
bozo_printf(httpd, "Content-Type: text/html\r\n");
bozo_printf(httpd, "Content-Length: %d\r\n", size);
bozo_printf(httpd, "Server: %s\r\n", httpd->server_software);
if (request && request->hr_allow)
bozo_printf(httpd, "Allow: %s\r\n", request->hr_allow);
if (code == 408 && request &&
request->hr_proto == httpd->consts.http_11)
bozo_printf(httpd, "Connection: close\r\n");
bozo_printf(httpd, "\r\n");
if (size && request && request->hr_method != HTTP_HEAD)
bozo_printf(httpd, "%s", httpd->errorbuf);
bozo_flush(httpd, stdout);
#ifndef NO_BLOCKLIST_SUPPORT
switch(code) {
case 401:
pfilter_notify(BLOCKLIST_AUTH_FAIL, code);
break;
case 403:
pfilter_notify(BLOCKLIST_ABUSIVE_BEHAVIOR, code);
break;
}
#endif
return code;
}
char *
bozostrnsep(char **strp, const char *delim, ssize_t *lenp)
{
char *s;
const char *spanp;
int c, sc;
char *tok;
if ((s = *strp) == NULL)
return (NULL);
for (tok = s;;) {
if (lenp && --(*lenp) == -1)
return (NULL);
c = *s++;
spanp = delim;
do {
if ((sc = *spanp++) == c) {
if (c == 0)
s = NULL;
else
s[-1] = '\0';
*strp = s;
return (tok);
}
} while (sc != 0);
}
}
char *
bozodgetln(bozohttpd_t *httpd, int fd, ssize_t *lenp,
ssize_t (*readfn)(bozohttpd_t *, int, void *, size_t))
{
ssize_t len;
int got_cr = 0;
char c, *nbuffer;
if (httpd->getln_buflen == 0) {
httpd->getln_buflen = 128;
httpd->getln_buffer =
bozomalloc(httpd, (size_t)httpd->getln_buflen);
}
len = 0;
for (; readfn(httpd, fd, &c, 1) == 1; ) {
debug((httpd, DEBUG_EXPLODING, "bozodgetln read %c", c));
if (httpd->getln_buflen > BOZO_HEADERS_MAX_SIZE)
return NULL;
if (len >= httpd->getln_buflen - 1) {
httpd->getln_buflen *= 2;
debug((httpd, DEBUG_EXPLODING, "bozodgetln: "
"reallocating buffer to buflen %zu",
httpd->getln_buflen));
nbuffer = bozorealloc(httpd, httpd->getln_buffer,
(size_t)httpd->getln_buflen);
httpd->getln_buffer = nbuffer;
}
httpd->getln_buffer[len++] = c;
if (c == '\r') {
got_cr = 1;
continue;
} else if (c == '\n') {
if (got_cr)
len -= 2;
else
len -= 1;
break;
}
}
httpd->getln_buffer[len] = '\0';
debug((httpd, DEBUG_OBESE, "bozodgetln returns: '%s' with len %zd",
httpd->getln_buffer, len));
*lenp = len;
return httpd->getln_buffer;
}
void *
bozorealloc(bozohttpd_t *httpd, void *ptr, size_t size)
{
void *p;
p = realloc(ptr, size);
if (p)
return p;
bozo_http_error(httpd, 500, NULL, "memory allocation failure");
exit(EXIT_FAILURE);
}
void *
bozomalloc(bozohttpd_t *httpd, size_t size)
{
void *p;
p = malloc(size);
if (p)
return p;
bozo_http_error(httpd, 500, NULL, "memory allocation failure");
exit(EXIT_FAILURE);
}
char *
bozostrdup(bozohttpd_t *httpd, bozo_httpreq_t *request, const char *str)
{
char *p;
p = strdup(str);
if (p)
return p;
if (!request)
bozoerr(httpd, EXIT_FAILURE, "strdup");
bozo_http_error(httpd, 500, request, "memory allocation failure");
exit(EXIT_FAILURE);
}
int
bozo_init_httpd(bozohttpd_t *httpd)
{
(void) memset(httpd, 0x0, sizeof(*httpd));
httpd->consts.http_09 = "HTTP/0.9";
httpd->consts.http_10 = "HTTP/1.0";
httpd->consts.http_11 = "HTTP/1.1";
httpd->consts.text_plain = "text/plain";
httpd->mmapsz = BOZO_MMAPSZ;
httpd->defbindport = BOZO_HTTP_PORT;
if ((httpd->errorbuf = malloc(BOZO_MINBUFSIZE)) == NULL) {
fprintf(stderr,
"bozohttpd: memory_allocation failure\n");
return 0;
}
#ifndef NO_LUA_SUPPORT
SIMPLEQ_INIT(&httpd->lua_states);
#endif
return 1;
}
int
bozo_init_prefs(bozohttpd_t *httpd, bozoprefs_t *prefs)
{
int rv = 1;
(void) memset(prefs, 0x0, sizeof(*prefs));
if (!bozo_set_pref(httpd, prefs, "server software", SERVER_SOFTWARE))
rv = 0;
if (!bozo_set_pref(httpd, prefs, "index.html", INDEX_HTML))
rv = 0;
if (!bozo_set_pref(httpd, prefs, "public_html", PUBLIC_HTML))
rv = 0;
if (!bozo_set_pref(httpd, prefs, "ssl timeout", SSL_TIMEOUT))
rv = 0;
if (!bozo_set_pref(httpd, prefs, "initial timeout", INITIAL_TIMEOUT))
rv = 0;
if (!bozo_set_pref(httpd, prefs, "header timeout", HEADER_WAIT_TIME))
rv = 0;
if (!bozo_set_pref(httpd, prefs, "request timeout", TOTAL_MAX_REQ_TIME))
rv = 0;
return rv;
}
int
bozo_set_defaults(bozohttpd_t *httpd, bozoprefs_t *prefs)
{
return bozo_init_httpd(httpd) && bozo_init_prefs(httpd, prefs);
}
int
bozo_setup(bozohttpd_t *httpd, bozoprefs_t *prefs, const char *vhost,
const char *root)
{
struct passwd *pw;
extern char **environ;
static char *cleanenv[1] = { NULL };
uid_t uid;
int uidset = 0;
char *chrootdir;
char *username;
char *portnum;
char *cp;
int dirtyenv;
dirtyenv = 0;
if (vhost == NULL) {
httpd->virthostname = bozomalloc(httpd, MAXHOSTNAMELEN+1);
if (gethostname(httpd->virthostname, MAXHOSTNAMELEN+1) < 0)
bozoerr(httpd, 1, "gethostname");
httpd->virthostname[MAXHOSTNAMELEN] = '\0';
} else {
httpd->virthostname = bozostrdup(httpd, NULL, vhost);
}
httpd->slashdir = bozostrdup(httpd, NULL, root);
if ((portnum = bozo_get_pref(prefs, "port number")) != NULL) {
httpd->bindport = bozostrdup(httpd, NULL, portnum);
}
if ((cp = bozo_get_pref(prefs, "numeric")) != NULL &&
strcmp(cp, "true") == 0) {
httpd->numeric = 1;
}
if ((cp = bozo_get_pref(prefs, "log to stderr")) != NULL &&
strcmp(cp, "true") == 0) {
httpd->logstderr = 1;
}
if ((cp = bozo_get_pref(prefs, "no log")) != NULL &&
strcmp(cp, "true") == 0) {
httpd->nolog = 1;
}
if ((cp = bozo_get_pref(prefs, "bind address")) != NULL) {
httpd->bindaddress = bozostrdup(httpd, NULL, cp);
}
if ((cp = bozo_get_pref(prefs, "background")) != NULL) {
httpd->background = atoi(cp);
}
if ((cp = bozo_get_pref(prefs, "foreground")) != NULL &&
strcmp(cp, "true") == 0) {
httpd->foreground = 1;
}
if ((cp = bozo_get_pref(prefs, "pid file")) != NULL) {
httpd->pidfile = bozostrdup(httpd, NULL, cp);
}
if ((cp = bozo_get_pref(prefs, "unknown slash")) != NULL &&
strcmp(cp, "true") == 0) {
httpd->unknown_slash = 1;
}
if ((cp = bozo_get_pref(prefs, "virtual base")) != NULL) {
httpd->virtbase = bozostrdup(httpd, NULL, cp);
}
if ((cp = bozo_get_pref(prefs, "enable users")) != NULL &&
strcmp(cp, "true") == 0) {
httpd->enable_users = 1;
}
if ((cp = bozo_get_pref(prefs, "enable user cgibin")) != NULL &&
strcmp(cp, "true") == 0) {
httpd->enable_cgi_users = 1;
}
if ((cp = bozo_get_pref(prefs, "dirty environment")) != NULL &&
strcmp(cp, "true") == 0) {
dirtyenv = 1;
}
if ((cp = bozo_get_pref(prefs, "hide dots")) != NULL &&
strcmp(cp, "true") == 0) {
httpd->hide_dots = 1;
}
if ((cp = bozo_get_pref(prefs, "directory indexing")) != NULL &&
strcmp(cp, "true") == 0) {
httpd->dir_indexing = 1;
}
if ((cp = bozo_get_pref(prefs, "directory index readme")) != NULL) {
httpd->dir_readme = bozostrdup(httpd, NULL, cp);
}
if ((cp = bozo_get_pref(prefs, "public_html")) != NULL) {
httpd->public_html = bozostrdup(httpd, NULL, cp);
}
if ((cp = bozo_get_pref(prefs, "ssl timeout")) != NULL) {
httpd->ssl_timeout = atoi(cp);
}
if ((cp = bozo_get_pref(prefs, "initial timeout")) != NULL) {
httpd->initial_timeout = atoi(cp);
}
if ((cp = bozo_get_pref(prefs, "header timeout")) != NULL) {
httpd->header_timeout = atoi(cp);
}
if ((cp = bozo_get_pref(prefs, "request timeout")) != NULL) {
httpd->request_timeout = atoi(cp);
}
httpd->server_software =
bozostrdup(httpd, NULL, bozo_get_pref(prefs, "server software"));
httpd->index_html =
bozostrdup(httpd, NULL, bozo_get_pref(prefs, "index.html"));
bozo_ssl_init(httpd);
bozo_daemon_init(httpd);
username = bozo_get_pref(prefs, "username");
if (username != NULL) {
if ((pw = getpwnam(username)) == NULL)
bozoerr(httpd, 1, "getpwnam(%s): %s", username,
strerror(errno));
if (initgroups(pw->pw_name, pw->pw_gid) == -1)
bozoerr(httpd, 1, "initgroups: %s", strerror(errno));
if (setgid(pw->pw_gid) == -1)
bozoerr(httpd, 1, "setgid(%u): %s", pw->pw_gid,
strerror(errno));
uid = pw->pw_uid;
uidset = 1;
}
if ((chrootdir = bozo_get_pref(prefs, "chroot dir")) != NULL) {
httpd->rootdir = bozostrdup(httpd, NULL, chrootdir);
if (chdir(httpd->rootdir) == -1)
bozoerr(httpd, 1, "chdir(%s): %s", httpd->rootdir,
strerror(errno));
if (chroot(httpd->rootdir) == -1)
bozoerr(httpd, 1, "chroot(%s): %s", httpd->rootdir,
strerror(errno));
}
if (uidset && setuid(uid) == -1)
bozoerr(httpd, 1, "setuid(%d): %s", uid, strerror(errno));
if ((chrootdir != NULL || username != NULL) && !dirtyenv)
environ = cleanenv;
#ifdef _SC_PAGESIZE
httpd->page_size = (long)sysconf(_SC_PAGESIZE);
#else
httpd->page_size = 4096;
#endif
debug((httpd, DEBUG_OBESE, "myname is %s, slashdir is %s",
httpd->virthostname, httpd->slashdir));
return 1;
}
void
bozo_cleanup(bozohttpd_t *httpd, bozoprefs_t *prefs)
{
bozo_clear_prefs(prefs);
free(httpd->virthostname);
free(httpd->errorbuf);
free(httpd->getln_buffer);
free(httpd->slashdir);
free(httpd->bindport);
free(httpd->pidfile);
free(httpd->cgibin);
free(httpd->virtbase);
free(httpd->dynamic_content_map);
#define bozo_unconst(x) ((void *)(uintptr_t)x)
free(bozo_unconst(httpd->server_software));
free(bozo_unconst(httpd->index_html));
free(bozo_unconst(httpd->dir_readme));
free(bozo_unconst(httpd->public_html));
#undef bozo_unconst
}
int
bozo_get_version(char *buf, size_t size)
{
return snprintf(buf, size, "%s", SERVER_SOFTWARE);
}
