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

#include <unistd.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"

    21

#include "common.h"

    22

    23

#define MIN_CHUNK_SIZE 4096

    24

#define OVERFLOW_BUFFER 4096

    25

    26

// do not do any userland socket output buffering

    27

#define HTTP_BUFFER 0

    28

    29

// what event_base we're using

    30

static struct event_base *ev_base;

    31

    34

    35

// info on a render request

    36

struct render_request {

    37

    struct evhttp_request *http_request;

    38

    39

    int headers_sent;

    40

    41

    struct remote_render_ctx *remote_ctx;

    42

    43

    size_t bytes_sent;

    44

    45

    int paused;

    46

};

    47

    48

// cb func prototypes

    49

void _render_http_written (struct evhttp_request *request, void *arg);

    50

    51

void _render_cleanup (struct render_request *ctx) {

    52

    // clean up

    53

    free(ctx);

    54

}

    55

    56

void _render_sent (void *arg) {

    57

    struct render_request *ctx = arg;

    58

    59

    // set chunk size

    60

    render_remote_set_recv(ctx->remote_ctx, MIN_CHUNK_SIZE, OVERFLOW_BUFFER);

    61

    62

    // send headers

    63

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

    64

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

    65

    66

    // setup flow-control

    67

    evhttp_set_reply_notify(ctx->http_request, HTTP_BUFFER, &_render_http_written, ctx);

    68

    69

    ctx->headers_sent = 1;

    70

    71

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

    72

}

    73

    74

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

    75

    struct render_request *ctx = arg;

    76

    77

    size_t buf_size = EVBUFFER_LENGTH(buf);

    78

    79

    // ignore empty buffers, a result of render_remote_shake()

    80

    if (buf_size == 0) {

    81

        printf("render [%p]: remote buffer is empty\n", ctx);

    82

    83

        return;

    84

    }

    85

    86

    // check if we are paused

    87

    if (ctx->paused) {

    88

        // we are waiting for the HTTP send buffer to clear, so keep the data in the render buffer

    89

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

    90

    91

        return;

    92

    }

    93

    94

    // move chunk to http buffers

    95

    evhttp_send_reply_chunk(ctx->http_request, buf);

    96

    97

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

    98

    99

    // mark ourself as paused until httpd tells us to continue

   100

    ctx->paused = 1;

   101

   102

    // keep a tally of total sent bytes

   103

    ctx->bytes_sent += buf_size;

   104

}

   105

   106

void _render_done (void *arg) {

   107

    struct render_request *ctx = arg;

   108

   109

    // if we are paused, just shove the data into the http buffers, they might become larger than they should be, but it's easier to just move the data there and let render_remote complete

   110

    if (ctx->paused) {

   111

        printf("render [%p]: done: flushing the rest of our data\n", ctx);

   112

        ctx->paused = 0;

   113

   114

        render_remote_shake(ctx->remote_ctx);

   115

    }

   116

   117

    // send end

   118

    evhttp_send_reply_end(ctx->http_request);

   119

   120

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

   121

   122

    // the request is now done, clean up

   123

    _render_cleanup(ctx);

   124

}

   125

   126

void _render_fail (void *arg) {

   127

    struct render_request *ctx = arg;

   128

   129

    if (ctx->headers_sent) {

   130

        // just terminate the PNG stream where it is

   131

        evhttp_send_reply_end(ctx->http_request);

   132

    } else {

   133

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

   134

    }

   135

   136

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

   137

   138

    _render_cleanup(ctx);

   139

}

   140

   141

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

   142

    struct render_request *ctx = arg;

   143

   144

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

   145

   146

    // cancel

   147

    render_remote_cancel(ctx->remote_ctx);

   148

   149

    _render_cleanup(ctx);

   150

}

   151

   152

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

   153

    struct render_request *ctx = arg;

   154

   155

    printf("render [%p]: http available for write\n", ctx);

   156

   157

    // unpause ourself

   158

    ctx->paused = 0;

   159

   160

    // shake out the buffers

   161

    render_remote_shake(ctx->remote_ctx);

   162

}

   163

   164

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

   170

    // render request context

   171

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

   175

   176

    req_ctx->http_request = request;

   177

    req_ctx->headers_sent = 0;

   178

    req_ctx->bytes_sent = 0;

   179

   180

    // render context

   181

    render_t rend_ctx;

   197

    // initiate the remote render operation

   199

        &_render_sent,

   200

        &_render_data,

   201

        &_render_done,

   202

        &_render_fail,

   203

        req_ctx

   208

   209

    // set close cb

   210

    evhttp_set_reply_abortcb(request, &_render_http_lost, req_ctx);

   211

   212

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

   222

}

   223

   224

/*

   225

 * HTTP request handler

   226

 */

   227

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

   228

    // gather some info about the request

   229

    const char *uri = evhttp_request_get_uri(request);

   230

    char *peer_address;

   231

    u_short peer_port;

   232

   233

    evhttp_request_get_peer(request, &peer_address, &peer_port);

   234

   235

    // request arguments

   236

    u_int32_t img_w = 256, img_h = 256;

   237

    struct evkeyval *qarg;

   238

    struct evkeyvalq qargs;

   239

   240

/*

   241

    enum query_arg_type {

   242

        QARG_END,

   243

        QARG_INT,

   244

    };

   245

   246

    struct query_arg {

   247

        const char          *qa_key;

   248

        enum query_arg_type  qa_type;

   249

        void                *qa_addr;

   250

    } arg_def[] = {

   251

        { "w",      QARG_INT,   &img_w  },

   252

        { "h",      QARG_INT,   &img_h  },

   253

        { NULL,     QARG_END,   NULL    }

   254

    };

   255

*/

   256

   257

    evhttp_parse_query(uri, &qargs);

   258

   259

    TAILQ_FOREACH(qarg, &qargs, next) {

   260

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

   261

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

   262

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

   263

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

   264

    }

   265

   266

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

   267

    evhttp_clear_headers(&qargs);

   268

   269

    // request log

   270

    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);

   271

   272

    // do it

   273

    _http_render_execute(request, img_w, img_h);

   274

}

   275

   276

struct event ev_sigint;

   277

   278

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

   279

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

   280

   281

    if (event_base_loopexit(ev_base, NULL))

   282

        err_exit("event_loopexit");

   283

}

   284

   285

void signals_init () {

   287

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

   288

    signal_add(&ev_sigint, NULL);

   297

}

   298

   299

void signals_deinit () {

   300

    signal_del(&ev_sigint);

   301

}

   302

   303

void log_null (int severity, const char *msg) {

   304

    // ignore

   305

}

   306

   307

int main (int argc, char **argv) {

   308

    // libevent init

   309

    ev_base = event_init();

   310

   311

    if (!ev_base)

   312

        die("event_init");

   313

   318

    int opt;

   319

    int enable_debug = 0;

   321

   323

        switch (opt) {

   341

            case 'd':

   342

                // enable libevent debugging

   343

                enable_debug = 1;

   344

                break;

   345

   346

            default:

   348

   349

        }

   350

    }

   359

   360

    // per default it is enabled

   361

    if (!enable_debug)

   362

        event_set_log_callback(&log_null);

   363

   364

    // handle signals

   365

    signals_init();

   366

   367

    // evhttp init

   368

    struct evhttp *http_server = evhttp_new(ev_base);

   369

   370

    if (!http_server)

   371

        die("evhttp_new");

   372

   373

    // bind to the correct interface/port

   374

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

   375

        die("evhttp_bind_socket");

   376

   377

    // add our http request handler

   378

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

   379

   380

    // we shall now run

   381

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

   382

   383

    // run the libevent mainloop

   384

    if (event_base_dispatch(ev_base))

   385

        die("event_dispatch");

   386

   387

    printf("SHUTDOWN\n");

   388

   389

    // clean up

   390

    signals_deinit();

   391

    evhttp_free(http_server);

   392

    event_base_free(ev_base);

   393

   394

    // successfull exit

   395

    return 0;

   396

}