1

#include <stdlib.h>

     2

#include <arpa/inet.h>

     3

#include <unistd.h>

     4

#include <fcntl.h>

     5

#include <errno.h>

     6

     7

#include "render_remote.h"

     8

#include "common.h"

     9

    10

struct remote_render_ctx {

    11

    struct event ev_conn;

    12

    struct bufferevent *data_bev;

    13

    14

    #pragma pack(push)

    15

    #pragma pack(1)

    16

    17

    struct {

    18

        u_int8_t    mode;

    19

    20

        u_int32_t   img_w;

    21

        u_int32_t   img_h;

    22

    23

        double      x1;

    24

        double      y1;

    25

        double      x2;

    26

        double      y2;

    27

    } render_cmd;

    28

    29

    #pragma pack(pop)

    30

    31

    void (*cb_sent)(void *arg);

    32

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

    33

    void (*cb_done)(void *arg);

    34

    void (*cb_fail)(void *arg);

    35

    36

    void *cb_arg;

    37

};

    38

    39

void _remote_render_ctx_free (struct remote_render_ctx **ctx) {

    40

    // free the data_bev

    41

    if ((*ctx)->data_bev) {

    42

        bufferevent_free((*ctx)->data_bev);

    43

        (*ctx)->data_bev = NULL;

    44

    }

    45

    46

    // free the context structure

    47

    free(*ctx);

    48

    49

    *ctx = NULL;

    50

}

    51

    52

#define RENDER_FAILED(ctx, desc) \

    53

    do {                                        \

    54

        perror(desc);                           \

    55

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

    56

        _remote_render_ctx_free(&ctx);          \

    58

    } while (0)

    59

    60

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

    61

    struct remote_render_ctx *ctx = arg;

    62

    63

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

    64

    ctx->cb_sent(ctx->cb_arg);

    65

    66

    // we don't care about EV_WRITE anymore

    67

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

    68

        RENDER_FAILED(ctx, "render_remote: bufferevent_disable");

    69

    70

    // start receiving data

    71

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

    72

        RENDER_FAILED(ctx, "render_remote: bufferevent_enable");

    73

}

    74

    75

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

    76

    struct remote_render_ctx *ctx = arg;

    77

    78

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

    80

}

    81

    82

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

    83

    struct remote_render_ctx *ctx = arg;

    84

    85

    // OH NOES; WHAT DO WE DO!?

    86

    87

    if (what & EVBUFFER_EOF) {

    88

        // great!

    95

        ctx->cb_done(ctx->cb_arg);

    96

    97

    } else if (what & EVBUFFER_ERROR) {

    98

        // crap.

    99

        perr("render_remote");

   100

   101

        ctx->cb_fail(ctx->cb_arg);

   102

   103

    } else if (what & EVBUFFER_TIMEOUT) {

   104

        // ah well

   105

        error("render_remote: timeout");

   106

   107

        ctx->cb_fail(ctx->cb_arg);

   108

   109

    } else {

   110

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

   111

    }

   112

   113

    // free resources

   114

    _remote_render_ctx_free(&ctx);

   115

}

   116

   117

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

   118

    struct remote_render_ctx *ctx = arg;

   119

   120

    // set up the read/write bufferevent

   121

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

   122

        RENDER_FAILED(ctx, "render_remote: bufferevent_new");

   123

   124

    // write the render command

   125

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

   126

        RENDER_FAILED(ctx, "render_remote: bufferevent_write");

   127

   128

    // wait for it to be written out

   129

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

   130

        RENDER_FAILED(ctx, "render_remote: bufferevent_enable");

   131

}

   132

   133

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

   134

    // just copy over the render params to the render_cmd

   135

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

   136

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

   137

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

   138

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

   139

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

   140

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

   141

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

   142

}

   143

   145

        render_t *render_ctx,

   146

        struct sockaddr_storage *remote,

   147

        void (*cb_sent)(void *arg),

   148

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

   149

        void (*cb_done)(void *arg),

   150

        void (*cb_fail)(void *arg),

   151

        void *cb_arg

   152

) {    

   153

    // alloc the remote render ctx

   154

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

   155

   156

    if (!ctx) {

   157

        error("render_remote: malloc");

   159

    }

   160

   161

    // store the provided callback functions

   162

    ctx->cb_sent = cb_sent;

   163

    ctx->cb_data = cb_data;

   164

    ctx->cb_done = cb_done;

   165

    ctx->cb_fail = cb_fail;

   166

    ctx->cb_arg = cb_arg;

   167

   168

    // copy the relevant stuff from the render_ctx

   169

    render_cmd_build(render_ctx, ctx);

   170

   171

    // create the socket

   172

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

   173

   174

    if (sock < 0) {

   175

        free(ctx);

   176

        perror("render_remote: socket");

   178

    }

   179

   180

    // mark it as nonblocking

   181

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

   182

        free(ctx);

   183

        close(sock);

   184

        perror("render_remote: fcntl");

   186

    }

   187

   188

    // initiate the connect

   189

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

   190

   191

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

   192

        free(ctx);

   193

        close(sock);

   194

        perror("render_remote: connect");

   196

    }

   197

   198

    // do the libevent dance

   199

    event_set(&ctx->ev_conn, sock, EV_WRITE, &_remote_connected, ctx);

   200

   201

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

   202

        free(ctx);

   203

        close(sock);

   204

        error("render_remote: event_add");

   206

    }

   207

   208

    // success

   218

    return 0;

   219

}