root/luci2/zhttpd/zhttpd.c @ 5793

#include <signal.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/epoll.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

#include "zhttpd.h"
#include "tcp.h"

static volatile int running;
zhttpd_context_t zhttpd = {.handler = NULL};

static void daemonize() {
    switch (fork()) {
        case -1:
            exit(1);
        case 0:
            break;
        default:
            exit(0);
    }
    setsid();
    chdir("/");
    int devnull = open("/dev/null", O_RDWR);
    dup2(devnull, STDIN_FILENO);
    dup2(devnull, STDOUT_FILENO);
    dup2(devnull, STDERR_FILENO);
    close(devnull);
}

static void sighandler(int signal) {
    if (signal == SIGHUP) {
        running = 2;
    } else {
        running = 0;
    }
}

static void configure() {
    zhttpd.threads = 32;
    zhttpd.timeout = 5;
    zhttpd.daemonize = 1;
}

static void cleanup() {
    close(zhttpd.epollfd);
    zthread_destroy(zhttpd.threadpool);
    zhttpd_vfs_t *d = NULL;
    for (zhttpd_vfs_t *c = zhttpd.vfs; c; c = d) {
        c->handler->vfs_context_destroy(c->context);
        d = c->next;
        free(c);
    }
}

static void run() {
    running = 1;
    zhttpd.threadpool = zthread_create(zhttpd.threads);
    zhttpd.epollfd = epoll_create(0);
    zhttpd_tcp_cloexec(zhttpd.epollfd);
    struct epoll_event *events = malloc
            (sizeof(struct epoll_event) * zhttpd.threads);

    do {
        int ready = zthread_step(zhttpd.threadpool, zhttpd.timeout);
        int signals = epoll_wait(zhttpd.epollfd, events, zhttpd.threads,
                (ready) ? 0 : 1000);
        for (int i = 0; i < signals; i++) {
            ((zthread_t*)events[i].data.ptr)->status = ZTHREAD_READY;
        }
    } while(running == 1);
    free(events);
}

int main() {
    struct sigaction action;
    memset(&action, 0, sizeof(action));
    action.sa_handler = sighandler;
    sigaction(SIGHUP, &action, NULL);
    sigaction(SIGTERM, &action, NULL);
    action.sa_handler = SIG_IGN;
    sigaction(SIGPIPE, &action, NULL);

    int firstrun = 1;
    do {
        configure();
        if (firstrun && zhttpd.daemonize) {
            daemonize();
            firstrun = 0;
        }
        run();
        cleanup();
    } while(running);
    return 0;
}

int zhttpd_vfs_mount(const char *point, zhttpd_options_t *options) {
    size_t pointlen = strlen(point);
    const char *handlername = zhttpd_options_get(options, "handler");
    if (!handlername) {
        return ZHTTPD_EINVAL;
    }

    zhttpd_handler_t *handler = NULL;
    for (zhttpd_handler_t *c = zhttpd.handler; c; c = c->next) {
        if (!strcmp(handlername, c->name)) {
            handler = c;
            break;
        }
    }

    if (!handler) {
        return ZHTTPD_ENOENT;
    }

    zhttpd_vfs_t *mount = calloc(1, sizeof(zhttpd_vfs_t) + pointlen + 2);
    if (!mount) {
        return ZHTTPD_ENOMEM;
    }

    memcpy(mount->pattern, point, pointlen);
    if (point[pointlen - 1] != '/') {
        mount->pattern[pointlen++] = '/';
    }
    mount->patternlen = pointlen;
    mount->handler = handler;
    mount->context = handler->vfs_context_create(options);
    mount->next = zhttpd.vfs;
    zhttpd.vfs = mount;

    return ZHTTPD_OK;
}

const char* zhttpd_options_get(zhttpd_options_t *options, const char *key) {
    size_t keylen = strlen(key);
    for (; options; options = options->next) {
        if (!strcmp(key, options->option) && options->option[keylen] == '=') {
            return &options->option[keylen + 1];
        }
    }
    return NULL;
}

void zhttpd_register(zhttpd_handler_t *handler) {
    handler->next = zhttpd.handler;
    zhttpd.handler = handler;
}