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

    11

#include "render.h"

    12

#include "render_remote.h"

    14

#include "mandelbrot.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) {

    70

    u_int8_t mode;

    71

    u_int32_t img_w, img_h;

    72

    double x1, y1, x2, y2;

    73

    80

    if (

    90

    92

    fflush(stdout);

    93

    94

    // set up the render_ctx

   110

   111

    // render!

   118

    // close the FILE* and socket

   119

    fclose(fh);

   120

   121

    return;

   122

}

   123

   124

   125

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

   126

    int ssock, sock;

   127

    struct sockaddr_in addr;

   128

    socklen_t addr_len;

   129

   130

    // parse arguments

   131

    int opt;

   132

    const char *port_name = NULL;

   134

   135

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

   136

        switch (opt) {

   137

            case 'l':

   138

                if (port_name)

   140

   141

                port_name = optarg;

   142

                break;

   143

   144

            default:

   145

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

   146

        }

   147

    }

   150

    if (!port_name)

   151

        port_name = RENDER_PORT_NAME;

   152

   155

   156

    // create the socket

   157

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

   159

   160

    addr.sin_family = AF_INET;

   161

    addr.sin_port = htons(port);

   162

    addr.sin_addr.s_addr = INADDR_ANY;

   163

   164

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

   166

   167

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

   169

   174

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

   175

   176

    while (1) {

   177

        addr_len = sizeof(struct sockaddr_in);

   178

   179

        // accept a new client

   180

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

   182

   183

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

   184

   185

        // handle their resquest

   186

        handle_client(sock);

   187

    }

   191

}

   192