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"

    14 

    15 void sigpipe_handler (int signal) {

    16     /* ignore */

    17     fprintf(stderr, "SIGPIPE\n");

    18 }

    19 

    20 void sigpipe_ignore () {

    21     struct sigaction sigpipe_action;

    22 

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

    24     sigpipe_action.sa_handler = SIG_IGN;

    25 

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

    27         perr_exit("sigaction");

    28 }

    29 

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

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

    32     

    33     if (ret == 0) {

    34         error("EOF");

    35         return 0;

    36 

    37     } else if (ret != 1) {

    38         perror("fread");

    39         return 0;

    40     }

    41 

    42     return 1;

    43 }

    44 

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

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

    47 }

    48 

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

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

    51         return 0;

    52 

    53     *i = ntohl(*i);

    54 

    55     return 1;

    56 }

    57 

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

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

    60         return 0;

    61 

    62     return 1;

    63 }

    64 

    65 void handle_client (int sock) {

    66     double duration;

    67     struct render *ctx;

    68     FILE *fh;

    69     u_int8_t mode;

    70     u_int32_t img_w, img_h;

    71     double x1, y1, x2, y2;

    72 

    73     

    74     // open it as a FILE*

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

    76         ERROR("fdopen");

    77     

    78     // read the parameters

    79     if (

    80             !read_byte(fh, &mode)

    81          || !read_int(fh, &img_w)

    82          || !read_int(fh, &img_h)

    83          || !read_double(fh, &x1)

    84          || !read_double(fh, &y1)

    85          || !read_double(fh, &x2)

    86          || !read_double(fh, &y2)

    87     )

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

    89 

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

    91     fflush(stdout);

    92 

    93     // set up the render_ctx

    94     if (!(ctx = render_alloc()))

    95         ERROR("render_alloc");

    96 

    97     if (render_set_mode(ctx, mode))

    98         ERROR("render_set_mode");

    99 

   100     if (render_set_size(ctx, img_w, img_h))

   101         ERROR("render_set_size");

   102 

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

   104         ERROR("render_region_raw");

   105 

   106     if (render_io_stream(ctx, fh))

   107         ERROR("render_io_stream");

   108   

   109     

   110     // render!

   111     if (render_local(ctx, &duration))

   112         ERROR("render_local");

   113 

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

   115 

   116 error:

   117     // close the FILE* and socket

   118     fclose(fh);

   119     

   120     return;

   121 }

   122 

   123 

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

   125     int ssock, sock;

   126     struct sockaddr_in addr;

   127     socklen_t addr_len;

   128     

   129     // parse arguments

   130     int opt;

   131     const char *port_name = NULL;

   132     unsigned short port;

   133 

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

   135         switch (opt) {

   136             case 'l':

   137                 if (port_name)

   138                     ERROR("only specify -l once");

   139 

   140                 port_name = optarg;

   141                 break;

   142 

   143             default:

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

   145         }

   146     }

   147     

   148     // post-process arguments

   149     if (!port_name)

   150         port_name = RENDER_PORT_NAME;

   151 

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

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

   154 

   155     // create the socket

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

   157         PERROR("socket");

   158 

   159     addr.sin_family = AF_INET;

   160     addr.sin_port = htons(port);

   161     addr.sin_addr.s_addr = INADDR_ANY;

   162 

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

   164         PERROR("bind");

   165     

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

   167         PERROR("listen");

   168     

   169     // ignore sigpipe

   170     sigpipe_ignore();

   171     

   172     // main accept loop

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

   174 

   175     while (1) {

   176         addr_len = sizeof(struct sockaddr_in);

   177 

   178         // accept a new client

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

   180             PERROR("accept");

   181         

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

   183         

   184         // handle their resquest

   185         handle_client(sock);

   186     }

   187 

   188 error:

   189     return 1;

   190 }

   191