1

#include <stdlib.h>

     2

#include <arpa/inet.h>

     3

#include <unistd.h>

     4

#include <fcntl.h>

     5

#include <errno.h>

     6

     7

#include <event2/event.h>

     8

#include <event2/bufferevent.h>

     9

    10

#include "render_remote.h"

    11

#include "common.h"

    12

    13

struct remote_render_ctx {

    14

    struct event *ev_conn;

    15

    struct bufferevent *data_bev;

    16

    17

    struct remote_node *remote_node;

    18

    19

    #pragma pack(push)

    20

    #pragma pack(1)

    21

    22

    struct {

    23

        u_int8_t    mode;

    24

    25

        u_int32_t   img_w;

    26

        u_int32_t   img_h;

    27

    28

        double      x1;

    29

        double      y1;

    30

        double      x2;

    31

        double      y2;

    32

    } render_cmd;

    33

    34

    #pragma pack(pop)

    35

    36

    void (*cb_sent)(void *arg);

    37

    void (*cb_data)(struct evbuffer *buf, void *arg);

    38

    void (*cb_done)(void *arg);

    39

    void (*cb_fail)(void *arg);

    40

    41

    void *cb_arg;

    42

};

    43

    44

void _remote_render_ctx_free (struct remote_render_ctx *ctx) {

    45

    // close the socket (ctx->ev_conn remains valid even after we're done with it...)

    46

    close(event_get_fd(ctx->ev_conn));

    47

    48

    // free the connect event

    49

    event_free(ctx->ev_conn);

    50

    51

    // free the data_bev

    52

    if (ctx->data_bev) {

    53

        bufferevent_free(ctx->data_bev);

    54

        ctx->data_bev = NULL;

    55

    }

    56

    57

    // update remote_node load

    58

    ctx->remote_node->current_load--;

    59

    60

    // free the context structure

    61

    free(ctx);

    62

    63

    ctx = NULL;

    64

}

    65

    66

#define RENDER_FAILED(ctx, desc) \

    67

    do {                                        \

    68

        perror(desc);                           \

    69

        ctx->cb_fail(ctx->cb_arg);              \

    70

        _remote_render_ctx_free(ctx);          \

    71

        return;                                 \

    72

    } while (0)

    73

    74

void _remote_write (struct bufferevent *bev, void *arg) {

    75

    struct remote_render_ctx *ctx = arg;

    76

    77

    // the write buffer was drained, so the render command was sent

    78

    ctx->cb_sent(ctx->cb_arg);

    79

    80

    // we don't care about EV_WRITE anymore

    81

    if (bufferevent_disable(ctx->data_bev, EV_WRITE))

    82

        RENDER_FAILED(ctx, "render_remote: bufferevent_disable");

    83

    84

    // start receiving data

    85

    if (bufferevent_enable(ctx->data_bev, EV_READ))

    86

        RENDER_FAILED(ctx, "render_remote: bufferevent_enable");

    87

}

    88

    89

void _remote_read (struct bufferevent *bev, void *arg) {

    90

    struct remote_render_ctx *ctx = arg;

    91

    92

    // pass the bufferevent's input buffer to our callback - libevent doesn't provide any function to access this, but hopefully this works correctly

    93

    ctx->cb_data(EVBUFFER_INPUT(bev), ctx->cb_arg);

    94

}

    95

    96

void _remote_error (struct bufferevent *bev, short what, void *arg) {

    97

    struct remote_render_ctx *ctx = arg;

    98

    99

    // OH NOES; WHAT DO WE DO!?

   100

   101

    if (what & EVBUFFER_EOF) {

   102

        // great!

   103

   104

        // send any remaining-chunk data

   105

        if (EVBUFFER_LENGTH(EVBUFFER_INPUT(bev)) > 0)

   106

            ctx->cb_data(EVBUFFER_INPUT(bev), ctx->cb_arg);

   107

   108

        // signal completion

   109

        ctx->cb_done(ctx->cb_arg);

   110

   111

    } else if (what & EVBUFFER_ERROR) {

   112

        // crap.

   113

        perr("render_remote");

   114

   115

        ctx->cb_fail(ctx->cb_arg);

   116

   117

    } else if (what & EVBUFFER_TIMEOUT) {

   118

        // ah well

   119

        error("render_remote: timeout");

   120

   121

        ctx->cb_fail(ctx->cb_arg);

   122

   123

    } else {

   124

        err_exit("weird bufferevent error code: 0x%02X", what);

   125

    }

   126

   127

    // free resources

   128

    _remote_render_ctx_free(ctx);

   129

}

   130

   131

void _remote_connected (int fd, short event, void *arg) {

   132

    struct remote_render_ctx *ctx = arg;

   133

   134

    // set up the read/write bufferevent

   135

    if ((ctx->data_bev = bufferevent_new(fd, &_remote_read, &_remote_write, &_remote_error, ctx)) == NULL)

   136

        RENDER_FAILED(ctx, "render_remote: bufferevent_new");

   137

   138

    // write the render command

   139

    if (bufferevent_write(ctx->data_bev, &ctx->render_cmd, sizeof(ctx->render_cmd)))

   140

        RENDER_FAILED(ctx, "render_remote: bufferevent_write");

   141

   142

    // wait for it to be written out

   143

    if (bufferevent_enable(ctx->data_bev, EV_WRITE))

   144

        RENDER_FAILED(ctx, "render_remote: bufferevent_enable");

   145

}

   146

   147

void render_cmd_build (render_t *rctx, struct remote_render_ctx *rrctx) {

   148

    // just copy over the render params to the render_cmd

   149

    rrctx->render_cmd.mode = rctx->mode;

   150

    rrctx->render_cmd.img_w = htonl(rctx->img_w);

   151

    rrctx->render_cmd.img_h = htonl(rctx->img_h);

   152

    rrctx->render_cmd.x1 = rctx->x1;

   153

    rrctx->render_cmd.y1 = rctx->y1;

   154

    rrctx->render_cmd.x2 = rctx->x2;

   155

    rrctx->render_cmd.y2 = rctx->y2;

   156

}

   157

   158

struct remote_render_ctx *render_remote (

   159

        render_t *render_ctx,

   160

        struct remote_node *remote_node,

   161

        void (*cb_sent)(void *arg),

   162

        void (*cb_data)(struct evbuffer *buf, void *arg),

   163

        void (*cb_done)(void *arg),

   164

        void (*cb_fail)(void *arg),

   165

        void *cb_arg

   166

) {    

   167

    printf("render_remote: remote render load: %d/%d\n", remote_node->current_load, remote_node->parallel_renders);

   168

   169

    // alloc the remote render ctx

   170

    struct remote_render_ctx *ctx = malloc(sizeof(struct remote_render_ctx));

   171

   172

    if (!ctx) {

   173

        error("render_remote: malloc");

   174

        return NULL;

   175

    }

   176

   177

    // store the provided callback functions

   178

    ctx->cb_sent = cb_sent;

   179

    ctx->cb_data = cb_data;

   180

    ctx->cb_done = cb_done;

   181

    ctx->cb_fail = cb_fail;

   182

    ctx->cb_arg = cb_arg;

   183

   184

    // keep a reference to remote_node so we can decr it's load

   185

    ctx->remote_node = remote_node;

   186

   187

    // copy the relevant stuff from the render_ctx

   188

    render_cmd_build(render_ctx, ctx);

   189

   190

    // create the socket

   191

    int sock = socket(remote_node->addr.ss_family, SOCK_STREAM, 0);

   192

   193

    if (sock < 0) {

   194

        perror("render_remote: socket");

   195

        goto error;

   196

    }

   197

   198

    // mark it as nonblocking

   199

    if (fcntl(sock, F_SETFL, O_NONBLOCK) == -1) {

   200

        perror("render_remote: fcntl");

   201

        goto error;

   202

    }

   203

   204

    // initiate the connect

   205

    int err = connect(sock, (struct sockaddr *) &remote_node->addr, sizeof(remote_node->addr));

   206

   207

    if (err != -1 || errno != EINPROGRESS) {

   208

        perror("render_remote: connect");

   209

        goto error;

   210

    }

   211

   212

    // do the libevent dance

   213

    ctx->ev_conn = event_new(NULL, sock, EV_WRITE, &_remote_connected, ctx);

   214

   215

    if (!ctx->ev_conn) {

   216

        error("render_remote: event_new");

   217

        goto error;

   218

    }

   219

   220

    if (event_add(ctx->ev_conn, NULL)) {

   221

        error("render_remote: event_add");

   222

        goto error;

   223

    }

   224

   225

    // update remote_node load

   226

    remote_node->current_load++;

   227

   228

    // success

   229

    return ctx;

   230

   231

error:

   232

    free(ctx);

   233

   234

    if (sock > 0)

   235

        close(sock);

   236

   237

    return NULL;

   238

}

   239

   240

int render_remote_set_recv (struct remote_render_ctx *ctx, size_t recv_threshold, size_t unread_buffer) {

   241

    if (ctx->data_bev == NULL)

   242

        return -1;

   243

   244

    bufferevent_setwatermark(ctx->data_bev, EV_READ, recv_threshold, recv_threshold + unread_buffer);

   245

   246

    return 0;

   247

}

   248

   249

int render_remote_shake (struct remote_render_ctx *ctx) {

   250

    if (ctx->data_bev == NULL)

   251

        return -1;

   252

   253

    ctx->cb_data(EVBUFFER_INPUT(ctx->data_bev), ctx->cb_arg);

   254

   255

    return 0;

   256

}

   257

   258

void render_remote_cancel (struct remote_render_ctx *ctx) {

   259

    // if it's still just connecting, cancel that

   260

    if (event_pending(ctx->ev_conn, EV_WRITE, NULL)) {

   261

        event_del(ctx->ev_conn);

   262

    }

   263

   264

    // this takes care of the rest

   265

    _remote_render_ctx_free (ctx);

   266

}

   267