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>

    11

    12

#include <event2/event.h>

    13

#include <event2/event_compat.h>

    14

#include <event2/http.h>

    15

#include <event2/event_struct.h>

    16

    17

#include "render.h"

    18

#include "render_remote.h"

    19

#include "common.h"

    20

    22

#define OVERFLOW_BUFFER 4096

    23

    26

    27

// what event_base we're using

    28

static struct event_base *ev_base;

    29

    30

// what render node to use

    31

static struct sockaddr_storage render_node;

    32

    33

// info on a render request

    34

struct render_request {

    35

    struct evhttp_request *http_request;

    36

    37

    int headers_sent;

    38

    39

    struct remote_render_ctx *remote_ctx;

    40

    41

    size_t bytes_sent;

    44

};

    45

    49

void _render_cleanup (struct render_request *ctx) {

    50

    // clean up

    51

    free(ctx);

    52

}

    53

    54

void _render_sent (void *arg) {

    55

    struct render_request *ctx = arg;

    56

    57

    // set chunk size

    59

    60

    // send headers

    61

    evhttp_add_header(evhttp_request_get_output_headers(ctx->http_request), "Content-Type", "image/png");

    62

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

    66

    67

    ctx->headers_sent = 1;

    68

    69

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

    70

}

    71

    72

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

    73

    struct render_request *ctx = arg;

    74

    75

    size_t buf_size = EVBUFFER_LENGTH(buf);

    76

    93

    evhttp_send_reply_chunk(ctx->http_request, buf);

    95

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

    96

   101

    ctx->bytes_sent += buf_size;

   102

}

   103

   104

void _render_done (void *arg) {

   105

    struct render_request *ctx = arg;

   106

   115

    // send end

   116

    evhttp_send_reply_end(ctx->http_request);

   117

   118

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

   121

    _render_cleanup(ctx);

   122

}

   123

   124

void _render_fail (void *arg) {

   125

    struct render_request *ctx = arg;

   126

   127

    if (ctx->headers_sent) {

   128

        // just terminate the PNG stream where it is

   129

        evhttp_send_reply_end(ctx->http_request);

   130

    } else {

   131

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

   132

    }

   133

   134

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

   135

   136

    _render_cleanup(ctx);

   137

}

   138

   139

void _render_http_lost (struct evhttp_request *req, void *arg) {

   140

    struct render_request *ctx = arg;

   141

   142

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

   143

   144

    // cancel

   145

    render_remote_cancel(ctx->remote_ctx);

   146

   147

    _render_cleanup(ctx);

   148

}

   149

   162

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

   163

    // render request context

   164

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

   165

   166

    req_ctx->http_request = request;

   167

    req_ctx->headers_sent = 0;

   168

    req_ctx->bytes_sent = 0;

   169

   170

    // render context

   171

    render_t rend_ctx;

   172

    render_init(&rend_ctx, RENDER_PNG);

   173

    render_set_size(&rend_ctx, img_w, img_h);

   174

    render_region_full(&rend_ctx);

   175

   176

    // initiate the remote render operation

   177

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

   178

        &_render_sent,

   179

        &_render_data,

   180

        &_render_done,

   181

        &_render_fail,

   182

        req_ctx

   183

    )) == NULL) {

   184

        free(req_ctx);

   185

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

   186

        return;

   187

    }

   188

   189

    // set close cb

   190

    evhttp_set_reply_abortcb(request, &_render_http_lost, req_ctx);

   191

   192

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

   193

}

   194

   195

/*

   196

 * HTTP request handler

   197

 */

   198

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

   199

    // gather some info about the request

   200

    const char *uri = evhttp_request_get_uri(request);

   201

    char *peer_address;

   202

    u_short peer_port;

   203

   204

    evhttp_request_get_peer(request, &peer_address, &peer_port);

   205

   206

    // request arguments

   207

    u_int32_t img_w = 256, img_h = 256;

   208

    struct evkeyval *qarg;

   209

    struct evkeyvalq qargs;

   210

   211

/*

   212

    enum query_arg_type {

   213

        QARG_END,

   214

        QARG_INT,

   215

    };

   216

   217

    struct query_arg {

   218

        const char          *qa_key;

   219

        enum query_arg_type  qa_type;

   220

        void                *qa_addr;

   221

    } arg_def[] = {

   222

        { "w",      QARG_INT,   &img_w  },

   223

        { "h",      QARG_INT,   &img_h  },

   224

        { NULL,     QARG_END,   NULL    }

   225

    };

   226

*/

   227

   228

    evhttp_parse_query(uri, &qargs);

   229

   230

    TAILQ_FOREACH(qarg, &qargs, next) {

   231

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

   232

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

   233

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

   234

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

   235

    }

   236

   237

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

   238

    evhttp_clear_headers(&qargs);

   239

   240

    // request log

   241

    printf("REQ: [%s:%d] method=%d, uri=%s, img_w=%d, img_h=%d\n", peer_address, peer_port, evhttp_request_get_type(request), uri, img_w, img_h);

   242

   243

    // do it

   244

    _http_render_execute(request, img_w, img_h);

   245

}

   246

   247

struct event ev_sigint;

   248

   249

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

   250

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

   251

   252

    if (event_base_loopexit(ev_base, NULL))

   253

        err_exit("event_loopexit");

   254

}

   255

   256

void signals_init () {

   257

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

   258

    signal_add(&ev_sigint, NULL);

   259

}

   260

   261

void signals_deinit () {

   262

    signal_del(&ev_sigint);

   263

}

   264

   270

    // libevent init

   271

    ev_base = event_init();

   272

   273

    if (!ev_base)

   274

        die("event_init");

   275

   297

    // handle signals

   298

    signals_init();

   300

    // evhttp init

   301

    struct evhttp *http_server = evhttp_new(ev_base);

   302

   303

    if (!http_server)

   304

        die("evhttp_new");

   305

   306

    // bind to the correct interface/port

   307

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

   308

        die("evhttp_bind_socket");

   309

   310

    // add our http request handler

   311

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

   312

   313

    // hack in our render node

   314

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

   315

   316

    render_node_addr->sin_family = AF_INET;

   317

    render_node_addr->sin_port = htons(RENDER_PORT);

   318

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

   319

   320

    // we shall now run

   321

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

   322

   323

    // run the libevent mainloop

   324

    if (event_base_dispatch(ev_base))

   325

        die("event_dispatch");

   326

   327

    printf("SHUTDOWN\n");

   328

   329

    // clean up

   330

    signals_deinit();

   331

    evhttp_free(http_server);

   332

    event_base_free(ev_base);

   333

   334

    // successfull exit

   335

    return 0;

   336

}