1

#include <stdlib.h>

     2

#include <arpa/inet.h>

     3

#include <unistd.h>

     4

#include <fcntl.h>

     5

#include <errno.h>

     6

#include <assert.h>

     7

     8

#include <event2/event.h>

     9

#include <event2/event_struct.h>

    10

#include <event2/bufferevent.h>

    11

    12

#include "render_struct.h"

    13

#include "render_remote.h"

    14

#include "render_net.h"

    15

#include "common.h"

    16

    17

struct render_remote {

    18

    // the socket fd

    19

    int sock;

    20

    21

    // the event/bufferevent

    22

    struct event ev_connect, ev_data;

    23

    struct bufferevent *bev_data;

    24

    25

    // the command

    26

    struct render_cmd render_cmd;

    27

    28

    // have we sent the command yet?

    29

    int cmd_sent;

    30

    31

    // have we received the EOF?

    32

    int have_eof;

    33

    34

    // has cb_done/cb_fail/cancel already been called?

    35

    int alive;

    36

    37

    void (*cb_sent)(void *arg);

    38

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

    39

    void (*cb_done)(void *arg);

    40

    void (*cb_fail)(void *arg);

    41

    42

    void *cb_arg;

    43

};

    44

    45

// internal prototypes

    46

static void _render_remote_free (struct render_remote *ctx);

    47

static void _render_remote_do_data (struct render_remote *ctx);

    48

static void _render_remote_do_done (struct render_remote *ctx);

    49

static void _render_remote_do_fail (struct render_remote *ctx);

    50

    51

static void _render_remote_free (struct render_remote *ctx) {

    52

    assert(ctx && !ctx->alive);

    53

    54

    // free the bev_data

    55

    if (ctx->bev_data)

    56

        bufferevent_free(ctx->bev_data);

    57

    58

    // and the events

    59

    if (event_pending(&ctx->ev_connect, EV_WRITE, NULL))

    60

        event_del(&ctx->ev_connect);

    61

    62

    if (event_pending(&ctx->ev_data, EV_READ, NULL))

    63

        event_del(&ctx->ev_data);

    64

    65

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

    66

    if (ctx->sock)

    67

        close(ctx->sock);

    68

    69

    // free the context structure

    70

    free(ctx);

    71

}

    72

    73

static void _render_remote_do_data (struct render_remote *ctx) {

    74

    // if there's data in the buffer, call cb_data

    75

    if (evbuffer_get_length(bufferevent_get_input(ctx->bev_data))) {

    76

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

    77

    }

    78

    79

    // if we got EOF on the connection and there's no data left in the buffer, call cb_done

    80

    if (ctx->have_eof && evbuffer_get_length(bufferevent_get_input(ctx->bev_data)) == 0) {

    81

        _render_remote_do_done(ctx);

    82

    }

    83

}

    84

    85

static void _render_remote_do_done (struct render_remote *ctx) {

    86

    assert(ctx->alive);

    87

    88

    ctx->alive = 0;

    89

    90

    ctx->cb_done(ctx->cb_arg);

    91

}

    92

    93

static void _render_remote_do_fail (struct render_remote *ctx) {

    94

    assert(ctx->alive);

    95

    96

    ctx->alive = 0;

    97

    98

    ctx->cb_fail(ctx->cb_arg);

    99

}

   100

   101

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

   102

    struct render_remote *ctx = arg;

   103

   104

    if (!ctx->cmd_sent) {

   105

        // write the render command

   106

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

   107

            ERROR("bufferevent_write");

   108

   109

        // wait for it to be written out (we get called a second time)

   110

        ctx->cmd_sent = 1;

   111

   112

    } else {

   113

        // the write buffer was drained, so the render command was write():n

   114

        assert(ctx->cb_sent);

   115

        ctx->cb_sent(ctx->cb_arg);

   116

        ctx->cb_sent = NULL;

   117

   118

        // we don't care about EV_WRITE anymore

   119

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

   120

            ERROR("bufferevent_disable");

   121

   122

        // are we buffered or raw?

   123

        if (ctx->cb_data) {

   124

            // start receiving data into our buffer

   125

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

   126

                ERROR("bufferevent_enable");

   127

   128

        } else {

   129

            assert(event_initialized(&ctx->ev_data));

   130

   131

            // enable the raw read event

   132

            if (event_add(&ctx->ev_data, NULL))

   133

                ERROR("event_add");

   134

        }

   135

    }

   136

   137

    return;

   138

   139

error:

   140

    _render_remote_do_fail(ctx);

   141

}

   142

   143

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

   144

    struct render_remote *ctx = arg;

   145

   146

    _render_remote_do_data(ctx);

   147

}

   148

   149

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

   150

    struct render_remote *ctx = arg;

   151

   152

    // OH NOES; WHAT DO WE DO!?

   153

   154

    if (what & EVBUFFER_EOF) {

   155

        // great!

   156

        ctx->have_eof = 1;

   157

   158

        // flush any remaining data/call cb_send as needed

   159

        _render_remote_do_data(ctx);

   160

   161

        return;

   162

   163

    } else if (what & EVBUFFER_ERROR) {

   164

        // crap.

   165

        PWARNING("EVBUFFER_ERROR");

   166

   167

    } else if (what & EVBUFFER_TIMEOUT) {

   168

        // ah well

   169

        WARNING("render_remote: timeout");

   170

   171

    } else {

   172

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

   173

    }

   174

   175

    // cb_fail + free

   176

    _render_remote_do_fail(ctx);

   177

}

   178

   179

/*

   180

 * Do the initial IO-agnostic work to initialize the rendering process

   181

 */

   182

static struct render_remote *_render_remote_init (struct render *render, struct remote_pool *pool_info) {

   183

    struct render_remote *ctx;

   184

    struct remote_node *node_info;

   185

   186

    // get a node from the pool

   187

    if (!(node_info = remote_pool_get(pool_info)))

   188

        ERROR("remote_pool_get");

   189

   190

    // alloc the remote render ctx

   191

    if (!(ctx = calloc(1, sizeof(*ctx))))

   192

        ERROR("calloc");

   193

   194

    // copy the relevant stuff from the render_ctx

   195

    ctx->render_cmd.mode = render->mode;

   196

    ctx->render_cmd.img_w = htonl(render->img_w);

   197

    ctx->render_cmd.img_h = htonl(render->img_h);

   198

    ctx->render_cmd.x1 = render->x1;

   199

    ctx->render_cmd.y1 = render->y1;

   200

    ctx->render_cmd.x2 = render->x2;

   201

    ctx->render_cmd.y2 = render->y2;

   202

   203

    // create the socket

   204

    if ((ctx->sock = socket(node_info->addr.ss_family, SOCK_STREAM, 0)) < 0)

   205

        PERROR("socket");

   206

   207

    // mark it as nonblocking

   208

    if (fcntl(ctx->sock, F_SETFL, O_NONBLOCK) == -1)

   209

        PERROR("fcntl");

   210

   211

    // initiate the connect

   212

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

   213

   214

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

   215

        PERROR("connect");

   216

   217

    // return the raw ctx

   218

    return ctx;

   219

   220

error:

   221

    _render_remote_free(ctx);

   222

    return NULL;

   223

}

   224

   225

/*

   226

 * Raw unbuffered I/O mode

   227

 */

   228

struct render_remote *render_remote_rawio (

   229

        struct render *render,

   230

        struct remote_pool *pool_info,

   231

        void (*cb_sent)(void *arg),

   232

        void (*cb_fail)(void *arg),

   233

        void (*cb_io_data)(evutil_socket_t, short, void*),

   234

        void *cb_arg

   235

) {

   236

    struct render_remote *ctx;

   237

   238

    // short-circuit error handling

   239

    if (!(ctx = _render_remote_init(render, pool_info)))

   240

        return NULL;

   241

   242

    // store the provided callback functions

   243

    ctx->cb_sent = cb_sent;

   244

    ctx->cb_fail = cb_fail;

   245

    ctx->cb_arg = cb_arg;

   246

   247

    // set up the custom EV_READ callback

   248

    event_set(&ctx->ev_data, ctx->sock, EV_READ, cb_io_data, cb_arg);

   249

   250

    // set up the write bufferevent

   251

    if ((ctx->bev_data = bufferevent_new(ctx->sock, NULL, &_remote_write, &_remote_error, ctx)) == NULL)

   252

        ERROR("bufferevent_new");

   253

   254

    // wait for it to connect

   255

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

   256

        ERROR("bufferevent_enable");

   257

   258

    // we are now alive

   259

    ctx->alive = 1;

   260

   261

    // success

   262

    return ctx;

   263

   264

error:

   265

    _render_remote_free(ctx);

   266

    return NULL;

   267

}   

   268

   269

/*

   270

 * Old buffered mode

   271

 */

   272

struct render_remote *render_remote (

   273

        struct render *render,

   274

        struct remote_pool *pool_info,

   275

        void (*cb_sent)(void *arg),

   276

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

   277

        void (*cb_done)(void *arg),

   278

        void (*cb_fail)(void *arg),

   279

        void *cb_arg

   280

) {    

   281

    struct render_remote *ctx;

   282

   283

    // short-circuit error handling

   284

    if (!(ctx = _render_remote_init(render, pool_info)))

   285

        return NULL;

   286

   287

    // store the provided callback functions

   288

    ctx->cb_sent = cb_sent;

   289

    ctx->cb_data = cb_data;

   290

    ctx->cb_done = cb_done;

   291

    ctx->cb_fail = cb_fail;

   292

    ctx->cb_arg = cb_arg;

   293

   294

    // set up the read/write bufferevent

   295

    if ((ctx->bev_data = bufferevent_new(ctx->sock, &_remote_read, &_remote_write, &_remote_error, ctx)) == NULL)

   296

        ERROR("bufferevent_new");

   297

   298

    // wait for it to connect

   299

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

   300

        ERROR("bufferevent_enable");

   301

   302

    // we are now alive

   303

    ctx->alive = 1;

   304

   305

    // success

   306

    return ctx;

   307

   308

error:

   309

    _render_remote_free(ctx);

   310

    return NULL;

   311

}

   312

   313

void render_remote_set_recv (struct render_remote *ctx, size_t recv_threshold, size_t unread_buffer) {

   314

    assert(ctx->bev_data);

   315

   316

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

   317

}

   318

   319

void render_remote_flush (struct render_remote *ctx) {

   320

    assert(ctx->bev_data);

   321

   322

    // call cb_data/cb_done as appropriate

   323

    _render_remote_do_data(ctx);

   324

}

   325

   326

int render_remote_reschedule (struct render_remote *ctx) {

   327

    assert(event_initialized(&ctx->ev_data));

   328

   329

    // just reschedule it

   330

    if (event_add(&ctx->ev_data, NULL))

   331

        ERROR("event_add");

   332

   333

    // ok

   334

    return 0;

   335

   336

error:

   337

    return -1;

   338

}

   339

   340

void render_remote_cancel (struct render_remote *ctx) {

   341

    // we must be alive for this..

   342

    assert(ctx->alive);

   343

   344

    ctx->alive = 0;

   345

   346

    _render_remote_free(ctx);

   347

}

   348

   349

void render_remote_done (struct render_remote *ctx) {

   350

    // we must be alive and non-buffered for this..

   351

    assert(ctx->alive && event_initialized(&ctx->ev_data));

   352

   353

    ctx->alive = 0;

   354

   355

    _render_remote_free(ctx);

   356

}

   357

   358

void render_remote_free (struct render_remote *ctx) {

   359

    // must be dead already

   360

    assert(!ctx->alive);

   361

   362

    _render_remote_free(ctx);

   363

}

   364