1

#include <sys/types.h>

     2

#include <sys/queue.h>

     3

#include <sys/socket.h>

     4

#include <stdlib.h>

     5

#include <stdio.h>

     6

#include <string.h>

     7

#include <netinet/ip.h>

     8

#include <arpa/inet.h>

     9

#include <signal.h>

    10

    15

    16

#include "render.h"

    17

#include "render_remote.h"

    18

#include "common.h"

    19

    20

#define CHUNK_SIZE 4096

    21

#define OVERFLOW_BUFFER 4096

    22

    27

// what render node to use

    28

static struct sockaddr_storage render_node;

    29

    30

// info on a render request

    31

struct render_request {

    32

    struct evhttp_request *http_request;

    33

    34

    int headers_sent;

    35

    36

    struct remote_render_ctx *remote_ctx;

    37

    38

    size_t bytes_sent;

    39

};

    40

    41

void _render_cleanup (struct render_request *ctx) {

    42

    // clean up

    43

    free(ctx);

    44

}

    45

    46

void _render_sent (void *arg) {

    47

    struct render_request *ctx = arg;

    48

    49

    // set chunk size

    50

    render_remote_set_chunk_size(ctx->remote_ctx, CHUNK_SIZE, OVERFLOW_BUFFER);

    51

    52

    // send headers

    54

    evhttp_send_reply_start(ctx->http_request, HTTP_OK, "OK");

    55

    56

    ctx->headers_sent = 1;

    57

    58

    printf("render [%p]: sent headers\n", ctx);

    59

}

    60

    61

void _render_data (struct evbuffer *buf, void *arg) {

    62

    struct render_request *ctx = arg;

    63

    64

    size_t buf_size = EVBUFFER_LENGTH(buf);

    65

    66

    // send chunk

    67

    evhttp_send_reply_chunk(ctx->http_request, buf);

    68

    69

    printf("render [%p]: enqueued chunk: %zu/%zu bytes\n", ctx, buf_size, ctx->bytes_sent);

    70

    71

    ctx->bytes_sent += buf_size;

    72

}

    73

    74

void _render_done (void *arg) {

    75

    struct render_request *ctx = arg;

    76

    77

    // send end

    78

    evhttp_send_reply_end(ctx->http_request);

    79

    80

    printf("render [%p]: done: %zu bytes\n", ctx, ctx->bytes_sent);

    81

    82

    _render_cleanup(ctx);

    83

}

    84

    85

void _render_fail (void *arg) {

    86

    struct render_request *ctx = arg;

    87

    88

    if (ctx->headers_sent) {

    89

        // just terminate the PNG stream where it is

    90

        evhttp_send_reply_end(ctx->http_request);

    91

    } else {

    92

        evhttp_send_error(ctx->http_request, 500, "Internal Server Error");

    93

    }

    94

    95

    printf("render [%p]: failed\n", ctx);

    96

    97

    _render_cleanup(ctx);

    98

}

    99

   101

    struct render_request *ctx = arg;

   102

   103

    printf("render [%p]: lost http connection\n", ctx);

   104

   105

    // cancel

   106

    render_remote_cancel(ctx->remote_ctx);

   107

   108

    _render_cleanup(ctx);

   109

}

   110

   111

void _http_render_execute (struct evhttp_request *request, u_int32_t img_w, u_int32_t img_h) {

   112

    // render request context

   113

    struct render_request *req_ctx = calloc(1, sizeof(struct render_request));

   114

   115

    req_ctx->http_request = request;

   116

    req_ctx->headers_sent = 0;

   117

    req_ctx->bytes_sent = 0;

   118

   119

    // render context

   120

    render_t rend_ctx;

   121

    render_init(&rend_ctx, RENDER_PNG);

   122

    render_set_size(&rend_ctx, img_w, img_h);

   123

    render_region_full(&rend_ctx);

   124

   125

    // initiate the remote render operation

   126

    if ((req_ctx->remote_ctx = render_remote(&rend_ctx, &render_node,

   127

        &_render_sent,

   128

        &_render_data,

   129

        &_render_done,

   130

        &_render_fail,

   131

        req_ctx

   132

    )) == NULL) {

   133

        free(req_ctx);

   134

        fprintf(stderr, "ERR: render_remote\n");

   135

        return;

   136

    }

   137

   138

    // set close cb

   140

   141

    printf("render [%p]: started\n", req_ctx);

   142

}

   143

   144

/*

   145

 * HTTP request handler

   146

 */

   147

void http_render (struct evhttp_request *request, void *arg) {

   148

    // gather some info about the request

   150

    char *peer_address;

   151

    u_short peer_port;

   152

   154

   155

    // request arguments

   156

    u_int32_t img_w = 256, img_h = 256;

   157

    struct evkeyval *qarg;

   158

    struct evkeyvalq qargs;

   159

   177

    evhttp_parse_query(uri, &qargs);

   178

   179

    TAILQ_FOREACH(qarg, &qargs, next) {

   180

        if (strcmp(qarg->key, "w") == 0)

   181

            img_w = strtol(qarg->value, NULL, 10);

   182

        else if (strcmp(qarg->key, "h") == 0)

   183

            img_h = strtol(qarg->value, NULL, 10);

   184

    }

   185

   186

    // clean up the qargs (badly named functions :< )

   187

    evhttp_clear_headers(&qargs);

   188

   189

    // request log

   191

   192

    // do it

   193

    _http_render_execute(request, img_w, img_h);

   194

}

   195

   196

struct event ev_sigint;

   197

   198

void sigint_handler (int signal, short event, void *arg) {

   199

    printf("SIGINT: shutting down\n");

   200

   202

        err_exit("event_loopexit");

   203

}

   204

   205

void signals_init () {

   206

    signal_set(&ev_sigint, SIGINT, &sigint_handler, NULL);

   207

    signal_add(&ev_sigint, NULL);

   208

}

   209

   210

void signals_deinit () {

   211

    signal_del(&ev_sigint);

   212

}

   213

   214

int main (void) {

   215

    // libevent init

   217

   218

    if (!ev_base)

   219

        die("event_init");

   220

   221

    // handle signals

   222

    signals_init();

   223

   224

    // evhttp init

   225

    struct evhttp *http_server = evhttp_new(ev_base);

   226

   227

    if (!http_server)

   228

        die("evhttp_new");

   229

   230

    // bind to the correct interface/port

   231

    if (evhttp_bind_socket(http_server, "0.0.0.0", 8117))

   232

        die("evhttp_bind_socket");

   233

   234

    // add our http request handler

   235

    evhttp_set_cb(http_server, "/render", &http_render, NULL);

   236

   237

    // hack in our render node

   238

    struct sockaddr_in *render_node_addr = (struct sockaddr_in *) &render_node;

   239

   240

    render_node_addr->sin_family = AF_INET;

   241

    render_node_addr->sin_port = htons(RENDER_PORT);

   242

    inet_aton("127.0.0.1", &render_node_addr->sin_addr);

   243

   244

    // we shall now run

   245

    printf("RUN 0.0.0.0:8117\n");

   246

   247

    // run the libevent mainloop

   249

        die("event_dispatch");

   250

   251

    printf("SHUTDOWN\n");

   252

   253

    // clean up

   254

    signals_deinit();

   255

    evhttp_free(http_server);

   256

    event_base_free(ev_base);

   257

   258

    // successfull exit

   259

    return 0;

   260

}