eris/eris.c

/*
 * simple httpd to be started from tcpserver 
 */
#define _FILE_OFFSET_BITS 64
#include <stdlib.h>
#include <unistd.h>
#include <ctype.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <time.h>
#include <stdio.h>
#include <string.h>
#include <signal.h>
#include <sys/wait.h>
#include <grp.h>
#include <errno.h>
#include <sys/poll.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <dirent.h>
#include <sys/mman.h>
#include <limits.h>

/*
 * Some things I use for debugging 
 */
#define XXNODUMP

#ifndef NODUMP
#define DUMPf(fmt, args...) fprintf(stderr, "%s:%s:%d " fmt "\n", __FILE__, __FUNCTION__, __LINE__, ##args)
#else
#define DUMPf(fmt, args...)
#endif
#define DUMP() DUMPf("")
#define DUMP_d(v) DUMPf("%s = %d", #v, v)
#define DUMP_u(v) DUMPf("%s = %u", #v, v)
#define DUMP_x(v) DUMPf("%s = 0x%x", #v, v)
#define DUMP_s(v) DUMPf("%s = %s", #v, v)
#define DUMP_c(v) DUMPf("%s = %c", #v, v)
#define DUMP_p(v) DUMPf("%s = %p", #v, v)
#define DUMP_buf(v, l) DUMPf("%s = %.*s", #v, (int)(l), v)

/*
 * the following is the time in seconds that fnord should wait for a valid 
 * HTTP request 
 */
#define READTIMEOUT 2

/*
 * the following is the time in seconds that fnord should wait before
 * aborting a request when trying to write the answer 
 */
#define WRITETIMEOUT 20

#define CGI_TIMEOUT	(5*60)  /* 5 minutes time-out for CGI to complete */

/*
 * defining USE_SENDFILE enables zero-copy TCP on Linux for static files.
 * I measured over 320 meg per second with apache bench over localhost
 * with sendfile and keep-alive.  However, sendfile does not work with
 * large files and may be considered cheating ;-) Also, sendfile is a
 * blocking operation.  Thus, no timeout handling. 
 */
#define USE_SENDFILE

#ifndef __linux__
#undef USE_SENDFILE
#endif

#ifdef USE_SENDFILE
#include <sys/sendfile.h>
#endif

#define USE_MMAP
#ifndef _POSIX_MAPPED_FILES
#undef USE_MMAP
#endif

enum { UNKNOWN, GET, HEAD, POST } method;

#ifdef TCP_CORK
static int      corked;
#endif
static long     retcode = 404;  /* used for logging code */
char           *host = "?";     /* Host: header */
char           *port;           /* also Host: header, :80 part */
char           *args;           /* URL behind ? (for CGIs) */
char           *url;            /* string between GET and HTTP/1.0, *
                                 * demangled */
char           *ua = "?";       /* user-agent */
char           *refer;          /* Referrer: header */
char           *accept_enc;     /* Accept-Encoding */
int             httpversion;    /* 0 == 1.0, 1 == 1.1 */
int             keepalive = 0;  /* should we keep the connection alive? */
int             rootdir;        /* fd of root directory, so we can fchdir
                                 * * back for keep-alive */
char           *cookie;         /* Referrer: header */
char           *uri;            /* copy of url before demangling */
char           *content_type;
char           *content_len;
char           *auth_type;
char           *post_miss;
unsigned long   post_mlen;
unsigned long   post_len = 0;

#if _FILE_OFFSET_BITS == 64
static unsigned long long rangestart,
                rangeend;       /* for ranged queries */
#define strtorange strtoull
#else
static unsigned long rangestart,
                rangeend;       /* for ranged queries */
#define strtorange strtoul
#endif

static const char days[] = "SunMonTueWedThuFriSat";
static const char months[] = "JanFebMarAprMayJunJulAugSepOctNovDec";

#define MAXHEADERLEN 8192

char           *remote_ip;
char           *remote_port;
char           *remote_ident;

#define BUFFER_OUTSIZE 8192
char            stdout_buf[BUFFER_OUTSIZE];

static void
sanitize(char *ua)
{                               /* replace strings with underscores for *
                                 * logging */
    int             j;
    if (!ua)
        return;
    for (j = 0; ua[j]; ++j)
        if (isspace(ua[j]))
            ua[j] = '_';
}

static void
dolog(off_t len)
{                               /* write a log line to stderr */
    sanitize(host);
    sanitize(ua);
    sanitize(refer);

    fprintf(stderr, "%s %ld %lu %s %s %s %s\n",
            remote_ip ? remote_ip : "0.0.0.0",
            retcode, (unsigned long) len, host, ua, refer, url);
}

/*
 * output an error message and exit 
 */
static void
badrequest(long code, const char *httpcomment, const char *message)
{
    retcode = code;
    dolog(0);
    printf("HTTP/1.0 %ld %s\r\nConnection: close\r\n", code, httpcomment);
    if (message) {
        printf("Content-Length: %lu\r\nContent-Type: text/html\r\n\r\n",
               (unsigned long) (strlen(message) * 2) + 15);
        printf("<title>%s</title>%s", message, message);
    } else {
        fputs("\r\n", stdout);
    }
    fflush(stdout);
    exit(0);
}

#define CGIENVLEN 21

static const char *cgivars[CGIENVLEN] = {
    "GATEWAY_INTERFACE=",
    "SERVER_PROTOCOL=",
    "SERVER_SOFTWARE=",
    "SERVER_NAME=",
    "SERVER_PORT=",
    "REQUEST_METHOD=",
    "REQUEST_URI=",
    "SCRIPT_NAME=",
    "REMOTE_ADDR=",
    "REMOTE_PORT=",
    "REMOTE_IDENT=",
    "HTTP_USER_AGENT=",
    "HTTP_COOKIE=",
    "HTTP_REFERER=",
    "HTTP_ACCEPT_ENCODING=",
    "AUTH_TYPE=",
    "CONTENT_TYPE=",
    "CONTENT_LENGTH=",
    "QUERY_STRING=",
    "PATH_INFO=",
    "PATH_TRANSLATED="
};

static int
iscgivar(const char *s)
{
    int             sl = strlen(s);
    register unsigned int i = 0;

    for (; i < CGIENVLEN; i++)
        if (!strncmp(s, cgivars[i], sl))
            return 1;
    return 0;
}

static unsigned int
elen(register const char *const *e)
{
    register unsigned int i = 0;
    while (e[i])
        i++;
    return i;
}

/*
 * Read header block. Try to read from stdin until \r?\n\r?\n is
 * encountered.  Read no more than *buflen bytes.  Convert bare \n to
 * \r\n. Preserve state across calls, provided buf is the same. Returns:
 * 1 found 0 not found, call again -1 EOF or other error 
 */
static int
read_header(FILE * f, char *buf, size_t * buflen)
{
    static char    *lastbuf = NULL;
    static int      found = 0;
    static int      bare = 1;   /* LF here would be bare */
    int             bufsize = *buflen;

    if (lastbuf != buf) {
        lastbuf = buf;
        bare = 1;
        found = 0;
    }
    *buflen = 0;

    while (*buflen + bare < bufsize) {
        int             c = getchar();

        switch (c) {
            case EOF:
                if (errno == EWOULDBLOCK) {
                    return 0;
                } else {
                    return -1;
                }
                break;
            case '\r':
                bare = 0;
                break;
            case '\n':
                if (bare) {
                    buf[(*buflen)++] = '\r';
                    bare = 1;
                }
                found += 1;
                break;
            default:
                found = 0;
                bare = 1;
                break;
        }
        buf[(*buflen)++] = c;

        if (found == 2) {
            return 1;
        }
    }

    return 0;
}

char           *
env_append(const char *key, const char *val)
{
    static char     buf[MAXHEADERLEN * 2 + PATH_MAX + 200];
    static char    *p = buf;
    char           *ret = p;

    if (!key) {
        p = buf;
        return NULL;
    }

    p = stpcpy(p, key);
    *(p++) = '=';
    if (val) {
        p = stpcpy(p, val) + 1;
    } else {
        *(p++) = 0;
    }

    return ret;
}

static void
do_cgi(const char *pathinfo, const char *const *envp)
{
    const char     *method_name[] = { "?", "GET", "HEAD", "POST" };
    register unsigned int en = elen(envp);
    char          **cgi_arg;
    register int    i;
    char          **cgi_env =
        (char **) alloca((CGIENVLEN + en + 1) * sizeof(char *));

    cgi_env[0] = "GATEWAY_INTERFACE=CGI/1.1";
    cgi_env[1] = "SERVER_PROTOCOL=HTTP/1.0";
    cgi_env[2] = "SERVER_SOFTWARE=" FNORD;

    i = 3;
    env_append(NULL, NULL);
    cgi_env[i++] = env_append("SERVER_NAME", host);
    cgi_env[i++] = env_append("SERVER_PORT", port);
    cgi_env[i++] = env_append("REQUEST_METHOD", method_name[method]);
    cgi_env[i++] = env_append("REQUEST_URI", uri);
    cgi_env[i++] = env_append("SCRIPT_NAME", url);
    if (remote_ip)
        cgi_env[i++] = env_append("REMOTE_ADDR", remote_ip);
    if (remote_port)
        cgi_env[i++] = env_append("REMOTE_PORT", remote_port);
    if (remote_ident)
        cgi_env[i++] = env_append("REMOTE_IDENT", remote_ident);
    if (ua)
        cgi_env[i++] = env_append("HTTP_USER_AGENT", ua);
    if (cookie)
        cgi_env[i++] = env_append("HTTP_COOKIE", cookie);
    if (refer)
        cgi_env[i++] = env_append("HTTP_REFERER", refer);
    if (accept_enc)
        cgi_env[i++] = env_append("HTTP_ACCEPT_ENCODING", accept_enc);
    if (auth_type)
        cgi_env[i++] = env_append("AUTH_TYPE", auth_type);
    if (content_type)
        cgi_env[i++] = env_append("CONTENT_TYPE", content_type);
    if (content_type)
        cgi_env[i++] = env_append("CONTENT_LENGTH", content_len);
    if (args)
        cgi_env[i++] = env_append("QUERY_STRING", args);
    if (pathinfo) {
        char           *rp = realpath(pathinfo, NULL);

        cgi_env[i++] = env_append("PATH_INFO", pathinfo);
        cgi_env[i++] = env_append("PATH_TRANSLATED", rp ? rp : pathinfo);
        if (rp)
            free(rp);
    }

    {
        unsigned int    j = 0;
        for (; j < en; j++)
            if (!iscgivar(envp[j]))
                cgi_env[++i] = (char *) envp[j];
    }
    cgi_env[++i] = 0;

    /*
     * argv 
     */
    if (args && (strchr(args, '=') == 0)) {
        int             n = 3;
        for (i = 0; args[i]; ++i)
            if (args[i] == '+')
                ++n;
        cgi_arg = alloca(n * sizeof(char *));
        cgi_arg[n = 1] = args;
        for (i = 0; args[i]; ++i) {
            if (args[i] == '+') {
                args[i] = 0;
                ++i;
                cgi_arg[++n] = args + i;
            }
        }
        cgi_arg[++n] = 0;
    } else {
        cgi_arg = alloca(2 * sizeof(char *));
        cgi_arg[1] = 0;
    }

    {
        char            tmp[PATH_MAX];

        i = strrchr(url, '/') - url;
        strncpy(tmp, url + 1, i);
        tmp[i] = 0;
        chdir(tmp);
    }

    {
        char            tmp[PATH_MAX];

        /*
         * program name 
         */
        cgi_arg[0] = tmp;
        tmp[0] = '.';
        strcpy(tmp + 1, url + i);

        /*
         * start cgi 
         */
        execve(cgi_arg[0], cgi_arg, cgi_env);
        raise(SIGQUIT);         /* gateway unavailable. */
    }
}

static void
cgi_child(int sig)
{
    int             n,
                    pid = waitpid(0, &n, WNOHANG);
    if (pid > 0) {
        if (WIFSIGNALED(n)) {
            if (WTERMSIG(n) == SIGALRM)
                badrequest(504, "Gateway Time-out",
                           "Gateway has hit the Time-out.");
            else
                badrequest(502, "Bad Gateway",
                           "Gateway broken or unavailable.");
        }
    }
    signal(SIGCHLD, cgi_child);
}

/*
 * Convert bare \n to \r\n in header.  Return 0 if header is over. 
 */
static int
cgi_send_correct_http(const char *s, unsigned int sl)
{
    unsigned int    i;
    int             newline = 0;

    for (i = 0; i < sl; i += 1) {
        switch (s[i]) {
            case '\r':
                if (s[i + 1] == '\n') {
                    i += 1;
            case '\n':
                    printf("\r\n");
                    if (newline) {
                        fwrite(s + i + 1, sl - i - 1, 1, stdout);
                        return 0;
                    } else {
                        newline = 1;
                    }
                    break;
                } else {
            default:
                    newline = 0;
                    putchar(s[i]);
                }
                break;
        }
    }
    return 1;
}

static void
start_cgi(int nph, const char *pathinfo, const char *const *envp)
{
    size_t          size = 0;
    int             n;
    int             pid;
    char            ibuf[8192],
                    obuf[8192];
    int             fd[2],
                    df[2];

    if (pipe(fd) || pipe(df)) {
        badrequest(500, "Internal Server Error",
                   "Server Resource problem.");
    }

    if ((pid = fork())) {
        if (pid > 0) {
            struct pollfd   pfd[2];
            int             nr = 1;
            int             startup = 1;

            signal(SIGCHLD, cgi_child);
            signal(SIGPIPE, SIG_IGN);   /* NO! no signal! */

            close(df[0]);
            close(fd[1]);

            pfd[0].fd = fd[0];
            pfd[0].events = POLLIN;
            pfd[0].revents = 0;

            pfd[1].fd = df[1];
            pfd[1].events = POLLOUT;
            pfd[1].revents = 0;

            if (post_len)
                ++nr;           /* have post data */
            else
                close(df[1]);   /* no post data */

            while (poll(pfd, nr, -1) != -1) {
                /*
                 * read from cgi 
                 */
                if (pfd[0].revents & POLLIN) {
                    size_t          len;

                    if (startup) {
                        /*
                         * XXX: could block :< 
                         */
                        // len = read_header(fd[0], ibuf, sizeof ibuf,
                        // NULL);
                        len = 0;
                    } else {
                        len = read(fd[0], ibuf, sizeof ibuf);
                    }
                    DUMP_u((unsigned int) len);

                    if (0 == len) {
                        break;
                    }
                    if (len == -1) {
                        goto cgi_500;
                    }

                    /*
                     * startup 
                     */
                    if (startup) {
                        if (nph) {      /* NPH-CGI */
                            startup = 0;
                            printf("%.*s", (int) len, ibuf);
                            /*
                             * skip HTTP/x.x 
                             */
                            retcode = strtoul(ibuf + 9, NULL, 10);
                        } else {        /* CGI */
                            if (memcmp(ibuf, "Location: ", 10) == 0) {
                                retcode = 302;
                                printf
                                    ("HTTP/1.0 302 CGI-Redirect\r\nConnection: close\r\n");
                                signal(SIGCHLD, SIG_IGN);
                                cgi_send_correct_http(ibuf, n);
                                fflush(stdout);
                                dolog(0);
                                exit(0);
                            } else {
                                retcode = 200;
                                printf("HTTP/1.0 200 OK\r\nServer: "
                                       FNORD
                                       "\r\nPragma: no-cache\r\nConnection: close\r\n");
                                signal(SIGCHLD, SIG_IGN);
                                cgi_send_correct_http(ibuf, len);
                                startup = 0;
                            }
                        }
                    }
                    /*
                     * non startup 
                     */
                    else {
                        fwrite(ibuf, len, 1, stdout);
                    }
                    size += len;
                    if (pfd[0].revents & POLLHUP)
                        break;
                }
                /*
                 * write to cgi the post data 
                 */
                else if (nr > 1 && pfd[1].revents & POLLOUT) {
                    if (post_miss) {
                        write(df[1], post_miss, post_mlen);
                        post_miss = 0;
                    } else if (post_mlen < post_len) {
                        n = read(0, obuf, sizeof(obuf));
                        if (n < 1)
                            goto cgi_500;
                        post_mlen += n;
                        write(df[1], obuf, n);
                    } else {
                        --nr;
                        close(df[1]);
                    }
                } else if (pfd[0].revents & POLLHUP)
                    break;
                else {
                  cgi_500:if (startup)
                        badrequest(500, "Internal Server Error",
                                   "Looks like the CGI crashed.");
                    else {
                        printf("\n\nLooks like the CGI crashed.\n\n");
                        break;
                    }
                }
            }

            fflush(stdout);
            dolog(size);
#ifdef TCP_CORK
            {
                int             zero = 0;
                setsockopt(1, IPPROTO_TCP, TCP_CORK, &zero, sizeof(zero));
            }
#endif
        }
    } else {
        close(df[1]);
        close(fd[0]);

        dup2(df[0], 0);
        dup2(fd[1], 1);

        close(df[0]);
        close(fd[1]);

        alarm(CGI_TIMEOUT);
        do_cgi(pathinfo, envp);
    }
    exit(0);
}

static int
fromhex(int c)
{
    if (c >= '0' && c <= '9')
        return c - '0';
    else {
        c |= ' ';
        if (c >= 'a' && c <= 'f')
            return c - 'a' + 10;
    }
    return -1;
}

/*
 * header(buf,buflen,"User-Agent")="Mozilla" 
 */
static char    *
header(char *buf, int buflen, const char *hname)
{
    int             slen = strlen(hname);
    int             i;
    char           *c;

    for (i = 0; i < buflen - slen - 2; ++i) {
        if (!strncasecmp(buf + i, hname, slen)) {
            if (i && (buf[i - 1] && buf[i - 1] != '\n'))
                continue;
            if (buf[i + slen] != ':' || buf[i + slen + 1] != ' ')
                continue;
            c = buf + i + slen + 2;
            i += slen + 2;
            for (; i < buflen; ++i) {
                if (buf[i] == 0 || buf[i] == '\n' || buf[i] == '\r') {
                    buf[i] = 0;
                    break;
                }
            }
            while (*c == ' ' || *c == '\t')
                ++c;
            return c;
        }
    }
    return 0;
}

static char    *encoding = 0;
static char    *mimetype = "application/octet-stream";

static struct mimeentry {
    const char     *name,
                   *type;
} mimetab[] = {
    {
    "html", "text/html; charset=UTF-8"}, {
    "htm", "text/html; charset=UTF-8"}, {
    "txt", "text/plain; charset=UTF-8"}, {
    "css", "text/css"}, {
    "ps", "application/postscript"}, {
    "pdf", "application/pdf"}, {
    "js", "application/javascript"}, {
    "gif", "image/gif"}, {
    "png", "image/png"}, {
    "jpeg", "image/jpeg"}, {
    "jpg", "image/jpeg"}, {
    "svg", "image/svg+xml"}, {
    "mpeg", "video/mpeg"}, {
    "mpg", "video/mpeg"}, {
    "avi", "video/x-msvideo"}, {
    "mov", "video/quicktime"}, {
    "qt", "video/quicktime"}, {
    "mp3", "audio/mpeg"}, {
    "ogg", "audio/ogg"}, {
    "wav", "audio/x-wav"}, {
    "epub", "application/epub+zip"}, {
    "dvi", "application/x-dvi"}, {
    "pac", "application/x-ns-proxy-autoconfig"}, {
    "sig", "application/pgp-signature"}, {
    "swf", "application/x-shockwave-flash"}, {
    "torrent", "application/x-bittorrent"}, {
    "tar", "application/x-tar"}, {
    "zip", "application/zip"}, {
    "dtd", "text/xml"}, {
    "xml", "text/xml"}, {
    "xbm", "image/x-xbitmap"}, {
    "xpm", "image/x-xpixmap"}, {
    "xwd", "image/x-xwindowdump"}, {
    "ico", "image/x-icon"}, {
0}};

/*
 * try to find out MIME type and content encoding. This is called twice,
 * once for the actual URL and once for URL.gz. If the actual URL already
 * ende with .gz, return application/octet-stream to make sure the client
 * can download the file even if he does not support gzip encoding 
 */
static void
getmimetype(char *url, int explicit)
{
    char            save;
    int             ext;
    ext = strlen(url);
    while (ext > 0 && url[ext] != '.' && url[ext] != '/')
        --ext;
    if (url[ext] == '.') {
        ++ext;
        if (!strcmp(url + ext, "bz2"))
            goto octetstream;
        if (!strcmp(url + ext, "gz")) {
            if (!encoding) {
                if (explicit)
                    goto octetstream;
                encoding = "gzip";
                save = url[ext - 1];
                url[ext - 1] = 0;
                getmimetype(url, explicit);
                url[ext - 1] = save;
            } else
              octetstream:
                mimetype = "application/octet-stream";
        } else {
            int             i;
            for (i = 0; mimetab[i].name; ++i)
                if (!strcmp(mimetab[i].name, url + ext)) {
                    mimetype = (char *) mimetab[i].type;
                    break;
                }
        }
    }
}

static int
matchcommalist(const char *needle, const char *haystack)
{
    /*
     * needle: "text/html", haystack: the accept header, "text/html,
     * text/plain\r\n" 
     */
    /*
     * return nonzero if match was found 
     */
    int             len = strlen(needle);

    DUMP_s(needle);
    DUMP_s(haystack);
    if (strncmp(needle, haystack, len))
        return 0;
    switch (haystack[len]) {
        case ';':
        case ',':
        case '\r':
        case '\n':
        case 0:
            return 1;
    }
    return 0;
}

static int
findincommalist(const char *needle, const char *haystack)
{
    const char     *accept;

    DUMP_s(needle);
    DUMP_s(haystack);
    for (accept = haystack; accept;) {
        /*
         * format: foo/bar, 
         */
        const char     *tmp = accept;
        int             final;
        while (*tmp) {
            if (*tmp == ';')
                break;
            else if (*tmp == ',')
                break;
            ++tmp;
        }
        final = (*tmp == 0 || *tmp == ';');
        DUMP_s(accept);
        if (matchcommalist("*/*", accept))
            break;
        if (matchcommalist(haystack, accept))
            break;
        accept = tmp + 1;
        if (final)
            return 0;
    }
    return 1;
}

/*
 *   timerfc function Copyright 1996, Michiel Boland.
 *   All rights reserved.
 *
 *   Redistribution and use in source and binary forms, with or
 *   without modification, are permitted provided that the following
 *   conditions are met:
 *
 *   1. Redistributions of source code must retain the above
 *      copyright notice, this list of conditions and the following
 *      disclaimer.
 *
 *   2. Redistributions in binary form must reproduce the above
 *      copyright notice, this list of conditions and the following
 *      disclaimer in the documentation and/or other materials
 *      provided with the distribution.
 *
 *   3. The name of the author may not be used to endorse or promote
 *      products derived from this software without specific prior
 *      written permission.
 *
 *   THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY
 *   EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 *   THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
 *   PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR
 *   BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 *   EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
 *   TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 *   ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 *   LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
 *   IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 *   THE POSSIBILITY OF SUCH DAMAGE.
 */
static          time_t
timerfc(const char *s)
{
    static const int daytab[2][12] = {
        {0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334},
        {0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335}
    };
    unsigned        sec,
                    min,
                    hour,
                    day,
                    mon,
                    year;
    char            month[3];
    int             c;
    unsigned        n;
    char            flag;
    char            state;