1

#include <stdio.h>

     2

#include <sys/types.h>

     3

#include <arpa/inet.h>

     4

#include <sys/socket.h>

     5

#include <stdlib.h>

     6

#include <signal.h>

     7

#include <string.h>

     8

#include <unistd.h>

     9

    10

#include "common.h"

    11

#include "render.h"

    12

#include "render_remote.h"  // for RENDER_PORT_NAME

    13

#include "render_local.h"

    15

    16

void sigpipe_handler (int signal) {

    17

    /* ignore */

    18

    fprintf(stderr, "SIGPIPE\n");

    19

}

    20

    21

void sigpipe_ignore () {

    22

    struct sigaction sigpipe_action;

    23

    24

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

    25

    sigpipe_action.sa_handler = SIG_IGN;

    26

    27

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

    28

        perr_exit("sigaction");

    29

}

    30

    31

int my_fread(FILE *fh, void *ptr, size_t size) {

    32

    int ret = fread(ptr, size, 1, fh);

    33

    34

    if (ret == 0) {

    35

        error("EOF");

    36

        return 0;

    37

    38

    } else if (ret != 1) {

    39

        perror("fread");

    40

        return 0;

    41

    }

    42

    43

    return 1;

    44

}

    45

    46

int read_byte (FILE *fh, u_int8_t *byte) {

    47

    return my_fread(fh, byte, sizeof(*byte));

    48

}

    49

    50

int read_int (FILE *fh, u_int32_t *i) {

    51

    if (!my_fread(fh, i, sizeof(*i)))

    52

        return 0;

    53

    54

    *i = ntohl(*i);

    55

    56

    return 1;

    57

}

    58

    59

int read_double (FILE *fh, double *dbl) {

    60

    if (!my_fread(fh, dbl, sizeof(*dbl)))

    61

        return 0;

    62

    63

    return 1;

    64

}

    65

    66

void handle_client (int sock) {

    67

    double duration;

    68

    struct render *ctx;

    69

    FILE *fh;

    70

    u_int8_t mode;

    71

    u_int32_t img_w, img_h;

    72

    double x1, y1, x2, y2;

    73

    74

    75

    // open it as a FILE*

    76

    if (!(fh = fdopen(sock, "r+")))

    77

        ERROR("fdopen");

    78

    79

    // read the parameters

    80

    if (

    81

            !read_byte(fh, &mode)

    82

         || !read_int(fh, &img_w)

    83

         || !read_int(fh, &img_h)

    84

         || !read_double(fh, &x1)

    85

         || !read_double(fh, &y1)

    86

         || !read_double(fh, &x2)

    87

         || !read_double(fh, &y2)

    88

    )

    89

        ERROR("read_{byte,int,double}");

    90

    91

    printf("RENDER: [%ux%u] (%f, %f) -> (%f, %f): ... ", img_w, img_h, x1, y1, x2, y2);

    92

    fflush(stdout);

    93

    94

    // set up the render_ctx

    95

    if (!(ctx = render_alloc()))

    96

        ERROR("render_alloc");

    97

    98

    if (render_set_mode(ctx, mode))

    99

        ERROR("render_set_mode");

   100

   101

    if (render_set_size(ctx, img_w, img_h))

   102

        ERROR("render_set_size");

   103

   104

    if (render_region_raw(ctx, x1, y1, x2, y2))

   105

        ERROR("render_region_raw");

   106

   107

    if (render_io_stream(ctx, fh))

   108

        ERROR("render_io_stream");

   109

   121

    // render!

   122

    if (render_local(ctx, &duration))

   123

        ERROR("render_local");

   124

   125

    printf("time=%fs\n", duration);

   129

   130

error:

   135

    // close the FILE* and socket

   136

    fclose(fh);

   137

   138

    return;

   139

}

   140

   141

   142

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

   143

    int ssock, sock;

   144

    struct sockaddr_in addr;

   145

    socklen_t addr_len;

   146

   147

    // parse arguments

   148

    int opt;

   149

    const char *port_name = NULL;

   150

    unsigned short port;

   151

   152

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

   153

        switch (opt) {

   154

            case 'l':

   155

                if (port_name)

   156

                    ERROR("only specify -l once");

   157

   158

                port_name = optarg;

   159

                break;

   160

   161

            default:

   162

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

   163

        }

   164

    }

   165

   166

    // post-process arguments

   167

    if (!port_name)

   168

        port_name = RENDER_PORT_NAME;

   169

   170

    if (!(port = atoi(port_name)))

   171

        ERROR("invalid port: %s", port_name);

   172

   173

    // create the socket

   174

    if ((ssock = socket(PF_INET, SOCK_STREAM, 0)) == -1)

   175

        PERROR("socket");

   176

   177

    addr.sin_family = AF_INET;

   178

    addr.sin_port = htons(port);

   179

    addr.sin_addr.s_addr = INADDR_ANY;

   180

   181

    if (bind(ssock, (struct sockaddr *) &addr, sizeof(struct sockaddr_in)) == -1)

   182

        PERROR("bind");

   183

   184

    if (listen(ssock, 1) == -1)

   185

        PERROR("listen");

   186

   187

    // ignore sigpipe

   188

    sigpipe_ignore();

   189

   190

    // main accept loop

   191

    printf("RUN: %s:%hu\n", inet_ntoa(addr.sin_addr), ntohs(addr.sin_port));

   192

   193

    while (1) {

   194

        addr_len = sizeof(struct sockaddr_in);

   195

   196

        // accept a new client

   197

        if ((sock = accept(ssock, (struct sockaddr *) &addr, &addr_len)) == -1)

   198

            PERROR("accept");

   199

   200

        printf("ACCEPT: %s:%hu\n", inet_ntoa(addr.sin_addr), addr.sin_port);

   201

   202

        // handle their resquest

   203

        handle_client(sock);

   204

    }

   205

   206

error:

   207

    return 1;

   208

}

   209