1

#include <stdio.h>

     2

#include <sys/types.h>

     3

#include <arpa/inet.h>

     4

#include <stdlib.h>

     5

#include <signal.h>

     6

#include <string.h>

     7

#include <unistd.h>

     8

     9

#include <assert.h>

    10

    11

#include <event2/event.h>

    12

#include <event2/event_struct.h>

    13

#include <event2/event_compat.h>

    14

#include <event2/bufferevent.h>

    15

    16

#include "common.h"

    17

#include "socket.h"

    18

#include "render.h"

    19

#include "render_struct.h"

    20

#include "render_net.h"

    21

#include "render_thread.h"

    22

#include "render_thread_struct.h"

    23

    24

void sigpipe_ignore () {

    25

    struct sigaction sigpipe_action;

    26

    27

    memset(&sigpipe_action, 0, sizeof(sigpipe_action));

    28

    sigpipe_action.sa_handler = SIG_IGN;

    29

    30

    if (sigaction(SIGPIPE, &sigpipe_action, NULL))

    31

        perr_exit("sigaction");

    32

}

    33

    34

void log_null (int severity, const char *msg) {

    35

    // ignore

    36

}

    37

    38

/*

    39

 * State needed to handle a client

    40

 */

    41

struct client_info {

    42

    // the client socket

    43

    evutil_socket_t socket;

    44

    45

    // the read-a-command buffer

    46

    struct bufferevent *bufev;

    47

    48

    // the write-a-mandelbrot stream

    49

    FILE *out_stream;

    50

    51

    // the render_thread op

    52

    // thread_info.is_active is useful

    53

    struct render_thread thread_info;

    54

};

    55

    56

static void client_free (struct client_info *ctx) {

    57

    // free the read-a-command buffer

    58

    if (ctx->bufev)

    59

        bufferevent_free(ctx->bufev);

    60

    61

    // cancel the render thread if needed

    62

    if (ctx->thread_info.is_active)

    63

        render_thread_cancel(&ctx->thread_info);

    64

    65

    // deinit it in any case

    66

    render_thread_deinit(&ctx->thread_info);

    67

    68

    // close the write-a-mandelbrot stream, or just the socket

    69

    if (ctx->out_stream) {

    70

        if (fclose(ctx->out_stream))

    71

            PWARNING("fclose");

    72

    73

    } else if (ctx->socket != -1) {

    74

        if (close(ctx->socket))

    75

            PWARNING("close");

    76

    77

    }

    78

    79

    // free the client info

    80

    free(ctx);

    81

}

    82

    83

static void handle_render_done (struct render_thread *thread_info, int err, void *arg) {

    84

    struct client_info *ctx = arg;

    85

    86

#if INFO_ENABLED

    87

    INFO("client [%p]: %s", ctx, err ? "failed" : "done");

    88

#endif    

    89

    90

    // just free it, it takes care of closing it as well

    91

    client_free(ctx);

    92

}

    93

    94

static int handle_render_cmd (struct client_info *ctx, struct render_cmd *cmd) {

    95

    // the render ctx...

    96

    struct render render_info;

    97

    98

    // open it as a normal FILE*

    99

    if (!(ctx->out_stream = fdopen(ctx->socket, "w")))

   100

        ERROR("fdopen");

   101

   102

#if INFO_ENABLED

   103

    INFO("client [%p]: render [%ux%u] (%f, %f) -> (%f, %f)", ctx, cmd->img_w, cmd->img_h, cmd->x1, cmd->y1, cmd->x2, cmd->y2);

   104

#endif    

   105

   106

    // set up the render_info

   107

    if (

   108

            render_init(&render_info)

   109

         || render_set_mode(&render_info, cmd->mode)

   110

         || render_set_size(&render_info, cmd->img_w, cmd->img_h)

   111

         || render_region_raw(&render_info, cmd->x1, cmd->y1, cmd->x2, cmd->y2)

   112

         || render_io_stream(&render_info, ctx->out_stream)

   113

    )

   114

        ERROR("render_*");

   115

   116

    // start the render thread

   117

    if (render_thread_init(&ctx->thread_info, &render_info, &handle_render_done, ctx))

   118

        ERROR("render_thread_init");

   119

   120

    // ok, wait for it to complete

   121

    return 0;

   122

   123

error:

   124

    // FAAAIL

   125

    return -1;

   126

}

   127

   128

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

   129

    struct client_info *ctx = arg;

   130

    struct render_cmd cmd;

   131

   132

    // meh, just read it in

   133

    size_t len;

   134

   135

    // we set a watermark, so this should hold true

   136

    assert(len = bufferevent_read(bev, &cmd, sizeof(cmd)) == sizeof(cmd));

   137

   138

    // fix the byte order

   139

    cmd.img_w = ntohl(cmd.img_w);

   140

    cmd.img_h = ntohl(cmd.img_h);

   141

   142

    // handle it

   143

    if (handle_render_cmd(ctx, &cmd))

   144

        goto error;

   145

   146

    // ok

   147

    return;

   148

   149

error:

   150

    client_free(ctx);

   151

}

   152

   153

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

   154

    struct client_info *ctx = arg;

   155

   156

    // read-EOF

   157

    if ((what & (EVBUFFER_READ | EVBUFFER_EOF)) && ctx->thread_info.is_active) {

   158

        // this is fine, expected, and doesn't matter

   159

        return;

   160

    }

   161

   162

    PWARNING("client [%p]: eventbuffer error: %s %s", ctx,

   163

        (what & EVBUFFER_READ) ? "read" : ((what & EVBUFFER_WRITE) ? "write" : "???"),

   164

        (what & EVBUFFER_EOF) ? "eof" : ((what & EVBUFFER_ERROR) ? "error" : ((what & EVBUFFER_TIMEOUT) ? "timeout" : "???"))

   165

    );

   166

   167

    client_free(ctx);

   168

}

   169

   170

static void handle_accept (evutil_socket_t fd, short event, void *arg) {

   171

    struct client_info *ctx = NULL;

   172

   173

    evutil_socket_t socket = -1;

   174

    struct sockaddr_storage addr;

   175

    socklen_t addr_len;

   176

   177

    // arg is NULL and unused

   178

    (void) arg;

   179

   180

    // accept the connection

   181

    addr_len = sizeof(struct sockaddr_storage);

   182

   183

    if ((socket = accept(fd, (struct sockaddr *) &addr, &addr_len)) == -1)

   184

        PERROR("accept");

   185

   186

    // alloc a new client_info

   187

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

   188

        ERROR("calloc");

   189

   190

    // store the socket

   191

    ctx->socket = socket;

   192

   193

#if INFO_ENABLED

   194

    assert(INET_ADDRSTRLEN < INET6_ADDRSTRLEN);

   195

   196

    char addr_buf[INET6_ADDRSTRLEN];

   197

    const char *addr_str;

   198

    short nport;

   199

   200

    if (addr.ss_family == AF_UNIX)

   201

        addr_str = "local";

   202

    else if (addr.ss_family == AF_INET || addr.ss_family == AF_INET6) {

   203

        const void *src;

   204

   205

        if (addr.ss_family == AF_INET) {

   206

            src = &(((struct sockaddr_in *) &addr)->sin_addr);

   207

            nport = ((struct sockaddr_in *) &addr)->sin_port;

   208

        } else {

   209

            src = &(((struct sockaddr_in6 *) &addr)->sin6_addr);

   210

            nport = ((struct sockaddr_in6 *) &addr)->sin6_port;

   211

        }

   212

   213

        if (!(inet_ntop(addr.ss_family, src, addr_buf, sizeof(addr_buf))))

   214

            PERROR("inet_ntop");

   215

   216

        addr_str = addr_buf;

   217

    }

   218

   219

    INFO("client [%p]: accept from %s:%hu", ctx, addr_str, ntohs(nport));

   220

#endif

   221

   222

    // then a bufferevent so that we can read in the command

   223

    if (!(ctx->bufev = bufferevent_new(ctx->socket, &handle_read, NULL, &handle_error, ctx)))

   224

        ERROR("bufferevent_new");

   225

   226

    // and enable it for read only

   227

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

   228

        ERROR("bufferevent_enable");

   229

   230

    // set the watermark for receiving the render_cmd

   231

    bufferevent_setwatermark(ctx->bufev, EV_READ, sizeof(struct render_cmd), 0);

   232

   233

    // now we just wait for the cmd...

   234

    return;

   235

   236

error:

   237

    if (ctx)

   238

        client_free(ctx);

   239

    else if (socket != -1)

   240

        close(socket);

   241

}

   242

   243

int main (int argc, char** argv) {

   244

    struct event_base *ev_base;

   245

    struct config_endpoint endpoint;

   246

    int ssock;

   247

   248

    // parse arguments

   249

    int opt;

   250

    const char *listen_spec = NULL;

   251

    int enable_debug = 0;

   252

   253

    while ((opt = getopt(argc, argv, "l:")) != -1) {

   254

        switch (opt) {

   255

            case 'l':

   256

                if (listen_spec)

   257

                    ERROR("only specify -l once");

   258

   259

                 listen_spec = optarg;

   260

                break;

   261

   262

            case 'd':

   263

                // enable libevent debugging

   264

                enable_debug = 1;

   265

                break;

   266

   267

            default:

   268

                err_exit("Usage: %s [-l addr_spec] [-d]", argv[0]);

   269

        }

   270

    }

   271

   272

    // init libevent

   273

    if (!(ev_base = event_init()))

   274

        FATAL("event_init");

   275

   276

    // per default it is enabled

   277

    if (!enable_debug)

   278

        event_set_log_callback(&log_null);

   279

   280

    // create the socket

   281

    endpoint_init(&endpoint, RENDER_PORT);

   282

   283

    if (endpoint_parse(&endpoint, listen_spec))

   284

        goto error;

   285

   286

    if ((ssock = socket_listen(&endpoint, SOCK_STREAM)) == -1)

   287

        goto error;

   288

   289

    // create the listen event

   290

    struct event listen_ev;

   291

   292

    event_set(&listen_ev, ssock, EV_READ | EV_PERSIST, &handle_accept, NULL);

   293

   294

    if (event_add(&listen_ev, NULL))

   295

        PERROR("event_add");

   296

   297

    // ignore sigpipe

   298

    sigpipe_ignore();

   299

   300

    // run the libevent mainloop

   301

    INFO("run");

   302

   303

    if (event_base_dispatch(ev_base))

   304

        WARNING("event_dispatch");

   305

   306

    INFO("SHUTDOWN");

   307

   308

    event_base_free(ev_base);

   309

   310

    // succesful exit

   311

    return EXIT_SUCCESS;

   312

   313

error:

   314

    // failure

   315

    return EXIT_FAILURE;

   316

}

   317