1

#include <sys/types.h>

     2

#include <sys/stat.h>

     3

#include <dirent.h>

     4

#include <fcntl.h>

     5

#include <unistd.h>

     6

#include <sys/mman.h>

     7

#include <stdio.h>

     8

#include <string.h>

     9

    10

#include <event2/http.h>

    11

#include <event2/buffer.h>

    12

    13

#include "static.h"

    14

#include "common.h"

    15

    16

static void _static_hit (struct evhttp_request *request, void *arg) {

    17

    struct static_file *ctx = arg;

    18

    struct evbuffer *buf = NULL;

    19

    int err = -1;

    20

    21

    // create the new buffer

    22

    if ((buf = evbuffer_new()) == NULL)

    23

        ERROR("evbuffer_new");

    24

    25

    // XXX: this is so very, very wasteful...

    26

    if (evbuffer_add(buf, ctx->mmap_addr, ctx->size))

    27

        ERROR("evbuffer_add %zu", ctx->size);

    28

    29

    // send the reply...

    30

    evhttp_send_reply(request, HTTP_OK, "OK", buf);

    31

    32

    err = 0;

    33

    34

error :

    35

    // free the buffer

    36

    if (buf)

    37

        evbuffer_free(buf);

    38

    39

    if (err)

    40

        evhttp_send_error(request, 505, "Internal Server Error");

    41

}

    42

    43

int static_init (struct static_file *ctx, struct evhttp *http_server, const char *url, const char *path) {

    44

    struct stat stat_buf;

    45

    46

    // clear the ctx

    47

    memset(ctx, 0, sizeof(*ctx));

    48

    49

    // open the file...

    50

    if ((ctx->fh = open(path, O_RDONLY)) == -1)

    51

        PERROR("open(O_RDONLY): %s", path);

    52

    53

    // stat the file to get its size

    54

    if (fstat(ctx->fh, &stat_buf))

    55

        PERROR("fstat: %s", path);

    56

    57

    ctx->size = stat_buf.st_size;

    58

    59

    // then mmap the file. MAP_POPULATE so that we block now, not later...

    60

    if ((ctx->mmap_addr = mmap(NULL, ctx->size, PROT_READ, MAP_SHARED | MAP_POPULATE, ctx->fh, 0)) == MAP_FAILED)

    61

        PERROR("mmap: %s 0 -> %zu", path, ctx->size);

    62

    63

    // finally, add the HTTP request handler

    64

    evhttp_set_cb(http_server, url, &_static_hit, ctx);

    65

    66

    INFO("%s -> %s", url, path);

    67

    68

    // return 

    69

    return 0;

    70

    71

error :

    72

    static_deinit(ctx);

    73

    74

    return -1;

    75

}

    76

    77

void static_deinit (struct static_file *ctx) {

    78

    if (ctx->fh)

    79

        if (close(ctx->fh))

    80

            PWARNING("close");

    81

    82

    if (ctx->mmap_addr && ctx->mmap_addr != MAP_FAILED)

    83

        if (munmap(ctx->mmap_addr, ctx->size))

    84

            PWARNING("munmap");

    85

}

    86

    87

int static_dir_init (struct static_dir *ctx, struct evhttp *http_server, const char *url_prefix, const char *dir_path) {

    88

    DIR *dir = NULL;

    89

    struct dirent *ent;

    90

    int i = 0;

    91

    char url_buf[STATIC_PATH_MAX], path_buf[STATIC_PATH_MAX];

    92

    93

    // init the ctx

    94

    ctx->file_count = 0;

    95

    96

    // open the dir

    97

    if ((dir = opendir(dir_path)) == NULL)

    98

        PERROR("opendir: %s", dir_path);

    99

   100

    // scan the files

   101

    while ((ent = readdir(dir)) != NULL) {

   102

        // skip dotfiles

   103

        if (ent->d_name[0] == '.')

   104

            continue;

   105

   106

        // check we still have space

   107

        if (i >= STATIC_DIR_MAX) {

   108

            PWARNING("static_dir is full: %d", i);

   109

            break;

   110

        }

   111

   112

        // format the url/path bufs

   113

        snprintf(url_buf, STATIC_PATH_MAX, "%s/%s", url_prefix, ent->d_name);

   114

        snprintf(path_buf, STATIC_PATH_MAX, "%s/%s", dir_path, ent->d_name);

   115

   116

        // init the static_file

   117

        static_init(&ctx->files[i], http_server, url_buf, path_buf);

   118

   119

        // remember how many files are in use and move on to the next one

   120

        ctx->file_count = ++i;

   121

    }

   122

   123

   124

    // ok

   125

    return 0;

   126

   127

error:

   128

    static_dir_deinit(ctx);

   129

   130

    return -1;

   131

}

   132

   133

void static_dir_deinit (struct static_dir *ctx) {

   134

    for (int i = 0; i < ctx->file_count; i++) {

   135

        static_deinit(&ctx->files[i]);

   136

    }

   137

}