path: root/ueb9/webserver.c

/*  Very simple webserver that uses Posix Threads
 *  Compile with: `gcc -lpthread -Wall -o webserver webserver.c'
 */

#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/select.h>
#include <pthread.h>
#include <signal.h>
#include <search.h>

#define BUFSIZE 1024
#define BASE_PATH "/tmp/"

void spin_requests();
void handle_request(int clientfd);
void *request_worker(void *arg);
void new_request(const int clientfd);
void setup_mime_types();
void free_mime_types();
void query_mime_type(const char *filename, char *buf, int len);
int send_content_type_header(const char *filename, int fd);
char *xstrdup(const char *str);

/* listen socket */
static int sockfd;
static int running;

/* threads */
#define THREADS 8
#define TODOS 64
static pthread_t threads[THREADS];
static int todo[TODOS];
static int todo_begin;
static int todo_end;
static pthread_cond_t cond_new;
static pthread_cond_t cond_ready;
static pthread_mutex_t mutex;

/* hash table */
#define HASHTABSIZE 2048
static int have_mimetypes;
static struct hsearch_data mime_table;
static char *mime_fields[2*HASHTABSIZE];

static struct {
    char *c200;
    char *c404;
    char *c501;
    char *h_cc;
} http = {
    .c200 = "HTTP/1.0 404 OK\r\n",
    .c404 = "HTTP/1.0 404 Not Found\r\n",
    .c501 = "HTTP/1.0 501 Not Implemented\r\n",
    .h_cc = "Connection: close\r\n"
};


void __attribute__((noreturn)) error(const char *msg)
{
    perror(msg);
    exit(-1);
}

void sig_pipe(int n)
{
       fprintf(stderr, "Received SIGPIPE\n");
}

void sig_int(int n)
{
       fprintf(stderr, "Received SIGINT, shutting down...\n");
       running = 0;
}

int main(int argc, char *argv[])
{
    int i;
    struct sockaddr_in listen_addr;
    // socklen_t socklen;

    sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if(sockfd == -1)
        error("socket");

    memset(&listen_addr, 0, sizeof listen);
    listen_addr.sin_family = AF_INET;
    listen_addr.sin_addr.s_addr = INADDR_ANY;
    listen_addr.sin_port = htons(8080);

    int reuse = 1;
    if(setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(int)) == -1)
        perror("setsockopt");
    if(bind(sockfd, (struct sockaddr *) &listen_addr, sizeof listen_addr) == -1)
        error("bind");
    if(listen(sockfd, SOMAXCONN) == -1)
        error("listen");

    if (signal(SIGPIPE, sig_pipe) == SIG_ERR)
        error("signal");
    if (signal(SIGINT, sig_int) == SIG_ERR)
        error("signal");

    setup_mime_types();

    pthread_mutex_init(&mutex, NULL);
    pthread_cond_init(&cond_new, NULL);
    pthread_cond_init(&cond_ready, NULL);
    for(i = 0; i < THREADS; i++) {
        int err;
        err = pthread_create(&threads[i], NULL, request_worker, NULL);
        if(err)
            error("pthread_create");
    }

    spin_requests();

    for(i = 0; i < THREADS; i++)
        pthread_cancel(threads[i]);

    free_mime_types();

    if(close(sockfd) == -1)
        perror("close");

    return EXIT_SUCCESS;
}

void spin_requests()
{
    int clientfd;
    fd_set set;
    struct sockaddr_in client;
    socklen_t client_len;

    running = 1;

    while(running) {
        FD_ZERO(&set);
        FD_SET(sockfd, &set);
        if(select(sockfd+1, &set, NULL, NULL, NULL) == -1) {
            if(!running)
                return;
            error("select");
        }
        if(!FD_ISSET(sockfd, &set))
            continue;
        memset(&client, 0, sizeof client);
        clientfd = accept(sockfd, (struct sockaddr *) &client, &client_len);
        if(clientfd == -1)
            error("accept");
        fprintf(stderr, "[master] got connection from %s\n",
            inet_ntoa(client.sin_addr));
        new_request(clientfd);
    }

    return;
}

void handle_request(int clientfd)
{
    int version;
    int len;
    int threadid = 0;
    FILE *fp = 0;
    char buf[BUFSIZE];
    char filename[BUFSIZE];
    char request_file[BUFSIZE-200];

    /* find out thread ID for debugging */
    while(threadid < THREADS && !pthread_equal(pthread_self(), threads[threadid]))
        threadid++;

    /* read in request */
    memset(&buf, 0, BUFSIZE);
    memset(&filename, 0, BUFSIZE);
    memset(&request_file, 0, BUFSIZE);
    if(recv(clientfd, &buf, BUFSIZE-1, 0) == -1)
        goto cleanup;
    if(!!strncmp(buf, "GET ", 4) ||
        sscanf(buf, "GET %s HTTP/1.%d", request_file, &version) != 2) {
        send(clientfd, http.c501, strlen(http.c501), 0);
        fprintf(stderr, "[thread %d, sock %d] Couldn't understand request '%s'\n",
            threadid, clientfd, buf);
        goto cleanup;
    }

    /* find file or bail */
    strcat(filename, BASE_PATH);
    strncat(filename, request_file, BUFSIZE);
    if(!(fp = fopen(filename, "r"))) {
        fprintf(stderr,
            "[thread %d, sock %d] File not found: '%s', returning 404\n",
            threadid, clientfd, filename);
        send(clientfd, http.c404, strlen(http.c404), 0);
        goto cleanup;
    }
    fprintf(stderr, "[thread %d, sock %d] Will now serve '%s' from '%s'\n",
        threadid, clientfd, request_file, filename);
    send(clientfd, http.c200, strlen(http.c200), 0);
    send(clientfd, http.h_cc, strlen(http.h_cc), 0);
    send_content_type_header(filename, clientfd);
    send(clientfd, "\r\n", 2, 0);

    /* send file contents */
    memset(&buf, 0, BUFSIZE);
    while(!feof(fp)) {
        len = fread(&buf, 1, BUFSIZE-1, fp);
        buf[len+1] = '\0';
        send(clientfd, buf, len, 0);
    }

    cleanup:
    if(fp)
        fclose(fp);
    fprintf(stderr, "[thread %d, sock %d] closing connection.\n",
        threadid, clientfd);
    if(clientfd)
        close(clientfd);
}

void *request_worker(void *arg) {
    int clientfd;
    while(1) {
        pthread_mutex_lock(&mutex);
        pthread_cond_signal(&cond_ready);
        while(todo_end == todo_begin)
            pthread_cond_wait(&cond_new, &mutex);
        clientfd = todo[todo_begin];
        todo_begin = (todo_begin + 1) % TODOS;
        pthread_mutex_unlock(&mutex);

        handle_request(clientfd);
    }
}

void new_request(const int clientfd)
{
    pthread_mutex_lock(&mutex);
    while((todo_end + 1) % TODOS == todo_begin) {
        fprintf(stderr, "[master] Queue is completely filled; waiting\n");
        pthread_cond_wait(&cond_ready, &mutex);
    }
    fprintf(stderr, "[master] adding socket %d at position %d (begin=%d)\n",
        clientfd, todo_end, todo_begin);
    todo[todo_end] = clientfd;
    todo_end = (todo_end + 1) % TODOS;
    pthread_cond_signal(&cond_new);
    pthread_mutex_unlock(&mutex);
}

void setup_mime_types()
{
    int i = 0;
    char types[] = "/etc/mime.types";
    char delim[] = " \t\n";
    char *t, *t_save;
    char *mimetype;
    char buf[BUFSIZE];
    FILE *fp;
    ENTRY e;
    ENTRY *ret;
    struct stat st;

    if(stat(types, &st) == -1)
        return;
    if(!hcreate_r(HASHTABSIZE, &mime_table))
        return;
    if(!(fp = fopen(types, "r")))
        return;
    fprintf(stderr, "Reading MIME type entries from %s\n", types);
    while(fgets(buf, BUFSIZE, fp)) {
        if(buf[0] == '#')
            continue;
        if(!(t = strtok_r(buf, delim, &t_save)))
            continue;
        mimetype = xstrdup(t);
        mime_fields[i++ % (2*HASHTABSIZE)] = mimetype;
        while((t = strtok_r(NULL, delim, &t_save))) {
            e.key = xstrdup(t);
            mime_fields[i++ % (2*HASHTABSIZE)] = e.key;
            e.data = (void *)mimetype;
            fprintf(stderr, "mime_table: adding '%s' -> '%s'\n",
                e.key, (char *)e.data);
            if(!hsearch_r(e, ENTER, &ret, &mime_table))
                break; /* error, or hash table full...? */
        }
    }
    fclose(fp);
    have_mimetypes = 1;
}

void free_mime_types()
{
    int i;

    if(!have_mimetypes)
        return;

    for(i = 0; mime_fields[i] && i < 2*HASHTABSIZE; i++) {
        free(mime_fields[i]);
        mime_fields[i] = NULL;
    }

    hdestroy_r(&mime_table);
}

void query_mime_type(const char *filename, char *buf, int len)
{
    char *period;
    char default_type[] = "text/html";
    ENTRY search;
    ENTRY *result;

    if(!have_mimetypes || !(period = strrchr(filename, '.'))) {
        snprintf(buf, len-1, default_type); /* best guess */
        return;
    }

    search.key = period+1;
    if(!hsearch_r(search, FIND, &result, &mime_table)) {
        snprintf(buf, len-1, default_type); /* best guess */
        return;
    }
    snprintf(buf, len-1, (char *)result->data);
}

int send_content_type_header(const char *filename, int fd)
{
    char buf[BUFSIZE];
    char type[BUFSIZE];

    query_mime_type(filename, type, BUFSIZE);
    snprintf(buf, BUFSIZE, "Content-type: %s\r\n", type);
    return send(fd, buf, strlen(buf), 0);
}

char *xstrdup(const char *str)
{
    char *ret;
    int len = strlen(str);
    if(!(ret = calloc(1, len+1)))
        perror("xstrdup");
    strncpy(ret, str, len);
    return ret;
}