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

     9

#include "render.h"

    10

#include "render_remote.h"

    11

#include "mandelbrot.h"

    12

#include "common.h"

    13

    14

void sigpipe_handler (int signal) {

    15

    /* ignore */

    16

    fprintf(stderr, "SIGPIPE\n");

    17

}

    18

    19

void sigpipe_ignore () {

    20

    struct sigaction sigpipe_action;

    21

    22

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

    23

    sigpipe_action.sa_handler = SIG_IGN;

    24

    25

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

    26

        perr_exit("sigaction");

    27

}

    28

    29

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

    30

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

    31

    32

    if (ret == 0) {

    33

        error("EOF");

    34

        return 0;

    35

    36

    } else if (ret != 1) {

    37

        perror("fread");

    38

        return 0;

    39

    }

    40

    41

    return 1;

    42

}

    43

    44

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

    45

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

    46

}

    47

    48

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

    49

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

    50

        return 0;

    51

    52

    *i = ntohl(*i);

    53

    54

    return 1;

    55

}

    56

    57

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

    58

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

    59

        return 0;

    60

    61

    return 1;

    62

}

    63

    64

void handle_client (int sock) {

    65

    // open it as a FILE*

    66

    FILE *fh = fdopen(sock, "r+");

    67

    68

    // read the parameters

    69

    u_int8_t mode;

    70

    u_int32_t img_w, img_h;

    71

    double x1, y1, x2, y2;

    72

    73

    if (

    74

        !read_byte(fh, &mode) ||

    75

        !read_int(fh, &img_w) ||

    76

        !read_int(fh, &img_h) ||

    77

        !read_double(fh, &x1) ||

    78

        !read_double(fh, &y1) ||

    79

        !read_double(fh, &x2) ||

    80

        !read_double(fh, &y2)

    81

    ) {

    82

        error("ERR: invalid arguments");

    83

        fclose(fh);

    84

        return;

    85

    }

    86

    87

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

    88

    fflush(stdout);

    89

    90

    double duration;

    91

    92

    // set up the render_ctx

    93

    struct render_ctx ctx;

    94

    render_init(&ctx, RENDER_PNG);

    95

    render_set_size(&ctx, img_w, img_h);

    96

    render_region_raw(&ctx, x1, y1, x2, y2);

    97

    render_io_stream(&ctx, fh);

    98

    99

    sigpipe_ignore();

   100

   101

    // render!

   102

    if (mandelbrot_render_timed(&ctx, &duration))

   103

        printf("error\n");  // XXX: notify our client?

   104

    else

   105

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

   106

   107

    // close the FILE* and socket

   108

    fclose(fh);

   109

   110

    return;

   111

}

   112

   113

   114

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

   115

    int ssock, sock;

   116

    struct sockaddr_in addr;

   117

    socklen_t addr_len;

   118

   119

   120

    // create the socket

   121

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

   122

        perr_exit("socket");

   123

   124

    addr.sin_family = AF_INET;

   125

    addr.sin_port = htons(RENDER_PORT);

   126

    addr.sin_addr.s_addr = INADDR_ANY;

   127

   128

    if (argc > 1)

   129

        addr.sin_port = htons(atoi(argv[1]));

   130

   131

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

   132

        perr_exit("bind");

   133

   134

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

   135

        perr_exit("listen");

   136

   137

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

   138

   139

    // main accept loop

   140

    while (1) {

   141

        addr_len = sizeof(struct sockaddr_in);

   142

   143

        // accept a new client

   144

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

   145

            perr_exit("accept");

   146

   147

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

   148

   149

        // handle their resquest

   150

        handle_client(sock);

   151

    }

   152

}

   153