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

    57

    } while (0)

    58

    59

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

    60

    struct remote_render_ctx *ctx = arg;

    61

    62

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

    63

    ctx->cb_sent(ctx->cb_arg);

    64

    65

    // we don't care about EV_WRITE anymore

    66

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

    67

        RENDER_FAILED(ctx, "render_remote: bufferevent_disable");

    68

    69

    // start receiving data

    70

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

    71

        RENDER_FAILED(ctx, "render_remote: bufferevent_enable");

    72

}

    73

    74

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

    75

    struct remote_render_ctx *ctx = arg;

    76

    77

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

    78

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

    79

}

    80

    81

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

    82

    struct remote_render_ctx *ctx = arg;

    83

    84

    // OH NOES; WHAT DO WE DO!?

    85

    86

    if (what & EVBUFFER_EOF) {

    87

        // great!

    88

        ctx->cb_done(ctx->cb_arg);

    89

    90

    } else if (what & EVBUFFER_ERROR) {

    91

        // crap.

    92

        perr("render_remote");

    93

    94

        ctx->cb_fail(ctx->cb_arg);

    95

    96

    } else if (what & EVBUFFER_TIMEOUT) {

    97

        // ah well

    98

        error("render_remote: timeout");

    99

   100

        ctx->cb_fail(ctx->cb_arg);

   101

   102

    } else {

   103

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

   104

    }

   105

   106

    // free resources

   107

    _remote_render_ctx_free(&ctx);

   108

}

   109

   110

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

   111

    struct remote_render_ctx *ctx = arg;

   112

   113

    // set up the read/write bufferevent

   114

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

   115

        RENDER_FAILED(ctx, "render_remote: bufferevent_new");

   116

   117

    // write the render command

   118

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

   119

        RENDER_FAILED(ctx, "render_remote: bufferevent_write");

   120

   121

    // wait for it to be written out

   122

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

   123

        RENDER_FAILED(ctx, "render_remote: bufferevent_enable");

   124

}

   125

   126

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

   127

    // just copy over the render params to the render_cmd

   128

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

   129

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

   130

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

   131

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

   132

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

   133

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

   134

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

   135

}

   136

   137

int render_remote (

   138

        render_t *render_ctx,

   139

        struct sockaddr_storage *remote,

   140

        void (*cb_sent)(void *arg),

   141

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

   142

        void (*cb_done)(void *arg),

   143

        void (*cb_fail)(void *arg),

   144

        void *cb_arg

   145

) {    

   146

    // alloc the remote render ctx

   147

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

   148

   149

    if (!ctx) {

   150

        error("render_remote: malloc");

   151

        return -1;

   152

    }

   153

   154

    // store the provided callback functions

   155

    ctx->cb_sent = cb_sent;

   156

    ctx->cb_data = cb_data;

   157

    ctx->cb_done = cb_done;

   158

    ctx->cb_fail = cb_fail;

   159

    ctx->cb_arg = cb_arg;

   160

   161

    // copy the relevant stuff from the render_ctx

   162

    render_cmd_build(render_ctx, ctx);

   163

   164

    // create the socket

   165

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

   166

   167

    if (sock < 0) {

   168

        free(ctx);

   169

        perror("render_remote: socket");

   170

        return -1;

   171

    }

   172

   173

    // mark it as nonblocking

   174

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

   175

        free(ctx);

   176

        close(sock);

   177

        perror("render_remote: fcntl");

   178

        return -1;

   179

    }

   180

   181

    // initiate the connect

   182

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

   183

   184

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

   185

        free(ctx);

   186

        close(sock);

   187

        perror("render_remote: connect");

   188

        return -1;

   189

    }

   190

   191

    // do the libevent dance

   192

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

   193

   194

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

   195

        free(ctx);

   196

        close(sock);

   197

        error("render_remote: event_add");

   198

        return -1;

   199

    }

   200

   201

    // success

   202

    return 0;

   203

}