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

    #pragma pack(push)

    18

    #pragma pack(1)

    19

    20

    struct {

    21

        u_int8_t    mode;

    22

    23

        u_int32_t   img_w;

    24

        u_int32_t   img_h;

    25

    26

        double      x1;

    27

        double      y1;

    28

        double      x2;

    29

        double      y2;

    30

    } render_cmd;

    31

    32

    #pragma pack(pop)

    33

    34

    void (*cb_sent)(void *arg);

    35

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

    36

    void (*cb_done)(void *arg);

    37

    void (*cb_fail)(void *arg);

    38

    39

    void *cb_arg;

    40

};

    41

    42

void _remote_render_ctx_free (struct remote_render_ctx **ctx) {

    43

    // free the data_bev

    44

    if ((*ctx)->data_bev) {

    45

        bufferevent_free((*ctx)->data_bev);

    46

        (*ctx)->data_bev = NULL;

    47

    }

    48

    49

    // and the event

    50

    event_free((*ctx)->ev_conn);

    51

    52

    // free the context structure

    53

    free(*ctx);

    54

    55

    *ctx = NULL;

    56

}

    57

    58

#define RENDER_FAILED(ctx, desc) \

    59

    do {                                        \

    60

        perror(desc);                           \

    61

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

    62

        _remote_render_ctx_free(&ctx);          \

    63

        return;                                 \

    64

    } while (0)

    65

    66

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

    67

    struct remote_render_ctx *ctx = arg;

    68

    69

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

    70

    ctx->cb_sent(ctx->cb_arg);

    71

    72

    // we don't care about EV_WRITE anymore

    73

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

    74

        RENDER_FAILED(ctx, "render_remote: bufferevent_disable");

    75

    76

    // start receiving data

    77

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

    78

        RENDER_FAILED(ctx, "render_remote: bufferevent_enable");

    79

}

    80

    81

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

    82

    struct remote_render_ctx *ctx = arg;

    83

    84

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

    85

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

    86

}

    87

    88

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

    89

    struct remote_render_ctx *ctx = arg;

    90

    91

    // OH NOES; WHAT DO WE DO!?

    92

    93

    if (what & EVBUFFER_EOF) {

    94

        // great!

    95

    96

        // send any remaining-chunk data

    97

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

    98

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

    99

   100

        // signal completion

   101

        ctx->cb_done(ctx->cb_arg);

   102

   103

    } else if (what & EVBUFFER_ERROR) {

   104

        // crap.

   105

        perr("render_remote");

   106

   107

        ctx->cb_fail(ctx->cb_arg);

   108

   109

    } else if (what & EVBUFFER_TIMEOUT) {

   110

        // ah well

   111

        error("render_remote: timeout");

   112

   113

        ctx->cb_fail(ctx->cb_arg);

   114

   115

    } else {

   116

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

   117

    }

   118

   119

    // free resources

   120

    _remote_render_ctx_free(&ctx);

   121

}

   122

   123

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

   124

    struct remote_render_ctx *ctx = arg;

   125

   126

    // set up the read/write bufferevent

   127

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

   128

        RENDER_FAILED(ctx, "render_remote: bufferevent_new");

   129

   130

    // write the render command

   131

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

   132

        RENDER_FAILED(ctx, "render_remote: bufferevent_write");

   133

   134

    // wait for it to be written out

   135

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

   136

        RENDER_FAILED(ctx, "render_remote: bufferevent_enable");

   137

}

   138

   139

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

   140

    // just copy over the render params to the render_cmd

   141

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

   142

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

   143

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

   144

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

   145

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

   146

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

   147

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

   148

}

   149

   150

struct remote_render_ctx *render_remote (

   151

        render_t *render_ctx,

   152

        struct sockaddr_storage *remote,

   153

        void (*cb_sent)(void *arg),

   154

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

   155

        void (*cb_done)(void *arg),

   156

        void (*cb_fail)(void *arg),

   157

        void *cb_arg

   158

) {    

   159

    // alloc the remote render ctx

   160

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

   161

   162

    if (!ctx) {

   163

        error("render_remote: malloc");

   164

        return NULL;

   165

    }

   166

   167

    // store the provided callback functions

   168

    ctx->cb_sent = cb_sent;

   169

    ctx->cb_data = cb_data;

   170

    ctx->cb_done = cb_done;

   171

    ctx->cb_fail = cb_fail;

   172

    ctx->cb_arg = cb_arg;

   173

   174

    // copy the relevant stuff from the render_ctx

   175

    render_cmd_build(render_ctx, ctx);

   176

   177

    // create the socket

   178

    int sock = socket(remote->ss_family, SOCK_STREAM, 0);

   179

   180

    if (sock < 0) {

   181

        perror("render_remote: socket");

   182

        goto error;

   183

    }

   184

   185

    // mark it as nonblocking

   186

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

   187

        perror("render_remote: fcntl");

   188

        goto error;

   189

    }

   190

   191

    // initiate the connect

   192

    int err = connect(sock, (struct sockaddr *) remote, sizeof(*remote));

   193

   194

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

   195

        perror("render_remote: connect");

   196

        goto error;

   197

    }

   198

   199

    // do the libevent dance

   200

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

   201

   202

    if (!ctx->ev_conn) {

   203

        error("render_remote: event_new");

   204

        goto error;

   205

    }

   206

   207

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

   208

        error("render_remote: event_add");

   209

        goto error;

   210

    }

   211

   212

    // success

   213

    return ctx;

   214

   215

error:

   216

    free(ctx);

   217

   218

    if (sock > 0)

   219

        close(sock);

   220

   221

    return NULL;

   222

}

   223

   225

    if (ctx->data_bev == NULL)

   226

        return -1;

   227

   238

   239

    return 0;

   240

}

   241

   242

void render_remote_cancel (struct remote_render_ctx *ctx) {

   243

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

   244

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

   245

        event_del(ctx->ev_conn);

   246

   247

    }

   248

   249

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

   250

    close(event_get_fd(ctx->ev_conn));

   251

   252

    // this takes care of the rest

   253

    _remote_render_ctx_free (&ctx);

   254

}

   255