src/common/execio.c src/common/execio.h \

	src/common/misc.c src/common/misc.h \

	src/common/multiio.c src/common/multiio.h \

	src/common/options.c src/common/options.h \

	src/common/protocol.c src/common/protocol.h \

	src/common/remoteio.h \

#see http://sources.redhat.com/autobook/autobook/autobook_91.html

# either increase the revision number or the interface number each release!

libdistrencommon_la_LDFLAGS = $(AM_LDFLAGS) -version-info 0:0:0

# shared server sources:

# distrend:

distrend_CFLAGS = $(AM_CFLAGS) $(MYSQL_CFLAGS)

distrend_LDFLAGS = $(AM_LDFLAGS) $(MYSQL_LDFLAGS)

distrend_SOURCES = $(SERVER_SOURCES) \

distrend_LDADD = libdistrencommon.la

# distrenslave:

distrenslave_SOURCES = $(SERVER_SOURCES) \

	src/server/slave.c

distrenslave_LDADD = libdistrencommon.la

  int sock;

#endif

  remoteio_read_handle_func_t read_handler;

  /* for the read_handler */

  void *read_handler_data;

  /**

   * Store a buffer of data waiting to be processed.

   */

  struct remoteio_packet inbuf;

int multiio_poll(multiio_context_t context)

{

  size_t counter;

  struct multiio_poll_travinfo travinfo;

  for(counter = 0; counter < context->nfds; counter ++)

    if(context->pollfds[counter].revents)

      {

	travinfo.multiio = context;

	travinfo.socket_info = &context->socket_infos[counter];

	travinfo.pollfd = &context->pollfds[counter];

	list_traverse(context->socket_types[context->socket_infos[counter].socket_type].type_handlers,

		      &travinfo,

		      (list_traverse_func_t)&multiio_poll_invoke_handlers,

		      LIST_FRNT | LIST_SAVE);

      }

  return 0;

}

int multiio_socket_type_register(multiio_context_t context, multiio_socket_type_t *new_type)

      context->pollfds_len = new_pollfds_len;

    }

  pollfds = context->pollfds;

  socket_infos = context->socket_infos;

  pollfds[context->nfds].fd = fd;

  pollfds[context->nfds].events = events;

  socket_infos[context->nfds].socket_type = socket_type;

  socket_infos[context->nfds].socket_data = socket_data;

  context->nfds ++;

#include "remoteio.h"

#include <malloc.h>

#include <stdio.h>

#include <string.h>

int distren_request_new(struct distren_request **req, uint32_t len, enum distren_request_type type)

{

  struct distren_request *newreq;

  newreq = malloc(sizeof(struct distren_request));

  };

struct distren_request

{

  uint32_t magic;

  uint32_t len;

  /** treat type as an enum distren_request_type using casting */

  uint32_t /* enum distren_request_type */ type;

};

/**

 */

int distren_request_send(struct remoteio *rem, struct distren_request *req, void *data);

/**

 * initializes and allocates request based on raw input data

 * which includes the headers of the request.

 */

int distren_request_new_fromdata(struct distren_request **req, void *data, size_t len);

/**

 * frees request

 */

}

int remoteio_open_common(struct remoteio **remoteio,

			 enum remoteio_method method,

			 struct remoteio_opts *opts,

			 remoteio_read_handle_func_t read_handler,

{

  struct remoteio *rem;

  rem = malloc(sizeof(struct remoteio));

  if(!rem)

    {

  rem->opts = opts;

  rem->inbuf.data = NULL;

  rem->inbuf.len = 0;

  rem->outmsgs = q_init();

  rem->read_handler = read_handler;

  rem->read_handler_data = read_handler_data;

  /*

   * the following initialization is very important... though the

   * others are too, I suppose :-p. See remoteio_close()

   */

  rem->careful_free = 0;

}

int remoteio_open_socket(struct remoteio **remoteio,

			 struct remoteio_opts *opts,

			 remoteio_read_handle_func_t read_handler,

			 void *read_handler_data,

			 int fd)

{

  struct remoteio *rem;

    return 1;

  rem = *remoteio;

  rem->sock = fd;

  multiio_socket_add(opts->multiio, rem->sock, opts->socket_type, rem, POLLRDNORM);

}

int remoteio_open_server(struct remoteio **remoteio,

			 struct remoteio_opts *opts,

			 remoteio_read_handle_func_t read_handler,

			 void *read_handler_data,

			 const char *servername)

{

  struct remoteio_server *theserver;

  struct remoteio *rem;

  int tmp;

     || theserver->method < 0)

    {

      fprintf(stderr, "%s:%d: Unsupported remoteio method %d\n\tThis is a bug, probably indicating memory corruption. This is, of course, probably my fault (not your hardware's) ;-)\n", __FILE__, __LINE__, theserver->method);

      return 1;

    }

    return 1;

  rem = *remoteio;

  tmp = funcmap[theserver->method].open_func(rem, theserver);

  if(tmp)

    {

  if(rem->careful_free)

    {

      rem->careful_free = 2;

      return 0;

    }

  /* cleanup multiiio stuff */

  multiio_socket_del(rem->opts->multiio, rem->sock);

  /* backend-specific cleanup */

  rtn = funcmap[rem->method].close_func(rem);

 * you may call remoteio_close() from inside of this function.

 *

 * @param rem the associated remoteio handle

 * @param generic_data a pointer that is stored in remoteio's struct remoteio_opts which isn't client-specific

 * @param buf a pointer to the buffer containing data waiting to be processed

 * @param len the size of buf that may be accessed

 * @return the number of bytes that the function accepted and thus should be removed from the rem handle.

 */

typedef size_t(*remoteio_read_handle_func_t)(struct remoteio *rem, void *generic_data, void *buf, size_t len, void *data);

/**

 * Determines the value of generic_data which is passed to

 * remoteio_read_handle_func_t

 *

 * @param opts the remoteio runtime options

 */

int remoteio_generic_data_set(struct remoteio_opts *opts, void *generic_data);

   From this, information about how to make the outgoing connection is derived.

 */

int remoteio_open_server(struct remoteio **rem,

			 struct remoteio_opts *opts,

			 remoteio_read_handle_func_t read_handler,

			 void *read_handler_data,

			 const char *servername);

/**

 * Initializes a remoteio instance for a socket that's already been floating

 * around for a while. I.e., this socket probably came from accept().

 *

 * @param opts self explanatory.

 */

int remoteio_open_socket(struct remoteio **rem,

			 struct remoteio_opts *opts,

			 remoteio_read_handle_func_t read_handler,

			 void *read_handler_data,

			 int fd);

/**

 * Queue bytes to be written to the remote host.

 *

 * @param rem the remoteio handle

int distrend_handle_request(struct distrend_listens *listens, struct distrend_client *client, struct distren_request *req, void *reqdata, struct general_info *geninfo);

/**

   client request handlers

 */

int distrend_handle_version(struct general_info *geninfo, struct distrend_client *client, size_t req_len, void *req_data);

/* **************XML Functions**************** */

void update_general_info(struct general_info *geninfo);

int import_general_info(struct general_info *general_info);

int update_xml_joblist(struct general_info *geninfo);

	  fprintf(stderr, "Error listening on port %d\n", general_info.config->listen_ports[counter]);

	  return 1;

	}

    }

  distrend_listen_handler_add(general_info.config->listens, DISTREN_REQUEST_VERSION, &distrend_handle_version);

  int slaveKey = 0; // Remotio should set me on a per-slave basis

  /* Main Loop */

  general_info.config->die = 0;

  while(!general_info.config->die)

    {

      int clientrequest = 0; /*< temporary example variable, will be replaced when we can handle messages */

      multiio_poll(multiio);

      /* Run the watchdog, @TODO: like every 10 mins or something */

      frame_watchdog(general_info.conn);

      struct frameset frame;

      struct distrenjob *job;

      distrend_send_disconnect(client, tmp_str);

    }

  return 0;

}

/**

   Performs command stored in a client's request. @TODO: Fill stub

*/

int distrend_do()

{

  return 0;

       break;

     case 5:

       while(1)

	 {

	   multiio_poll(multiio);

	 }

       break;

     case 0:

       test = 0;

       break;

struct distrend_client *distrend_client_new(struct distrend_listens *listens,

					    enum distrend_client_state state,

					    struct remoteio *rem);

int distrend_client_free(struct distrend_client *client);

int distrend_dispatch_request(struct distrend_listens *listens, struct remoteio *rem, struct distrend_client *client, struct distren_request *req, void *reqdata);

struct distrend_polled_sock *distrend_polled_sock_get_by_offset(struct distrend_listens *listens, size_t pollfds_offset);

int listen_handle_accept(multiio_context_t multiio,

			 int fd,

			 short revent,

			 struct distrend_listens *listens,

			 int *port);

  listens->options = opts;

  listens->geninfo = geninfo;

  /* multiio */

  listens->multiio = multiio;

  /* This type is used for accepting connections with accept() */

  multiio_socket_type_register(multiio, &listens->socket_type);

  multiio_event_handler_register(multiio,

				 listens->socket_type,

				 POLLERR | POLLHUP | POLLNVAL,

   newclientsock = accept(fd, (struct sockaddr *)NULL, (socklen_t *)NULL);

   /* used to call int distrend_client_add(struct distrend_listens *listens, int sock, DISTREND_CLIENT_PREVERSION)*/

   newclient = distrend_client_new(listens, DISTREND_CLIENT_PREVERSION, NULL);

     {

       fprintf(stderr, "error allocating/adding client struct\n");

       return 1;

     }

   newclient->rem = rem;

   fprintf(stderr, "accepted new connection; fd=%d\n", newclientsock);

   /**

    * For those using netcat/telnet to debug their internets.

    */

 #ifndef PACKAGE_URL

 #define PACKAGE_URL "http://ohnopub.net/distren/"

 #endif

      return req->len + distrend_listen_read_handle(rem, listens, buf + req->len, len - req->len, client);

    }

  return 0;

}

int distrend_listen_free(struct distrend_listens *listens)

{

  fprintf(stderr, "%s:%d: I am a stub that needn't be implemented 'til later\n", __FILE__, __LINE__);

  return 1;

}

/**

   This is probably just NOT a placeholder for remotio

  client->expectlen = 0;

  client->rem = rem;

  return client;

}

int distrend_client_write_request(struct distrend_client *client, const struct distren_request *req, const void *data)

{

  char *towrite;

  int ret;

  size_t msglen;

struct distrend_client;

#ifndef _DISTREN_LISTEN_H

#define _DISTREN_LISTEN_H

#include "distrend.h"

#include "common/options.h"

#include "common/multiio.h"

#include "common/protocol.h"

#include "common/remoteio.h"

  list_t request_handlers;

  /* the data to pass on to all request handlers */

  struct general_info *geninfo;

  /* the distrend config */

  struct options_common *options;

  /* of type (struct distrend_client)  (multiio stores a pointer per socket, we'll store each strut distrend_client as that pointer instead of using this list) */

  /* list_t clients; */

  /* the multiio context the listening interface should use/initialize */

  multiio_context_t multiio;

  /*

   */

  time_t cleanup_time;

  size_t inlen; /*< number of bytes waiting to be processed */

  size_t expectlen; /*< number of bytes that inlen has to be for a complete request to be had, 0 when waiting on header */

  /**

   * Yes, even though the remoteio will have a void *pointer to this

   * struct, we need a reverse pointer for something like

   * distrend_client_write() to work.

   */

  struct remoteio *rem;

    {

      fprintf(stderr, "Expected %d columns, got %d for ``%s''\n", expected_columns, num_columns, query);

      mysql_free_result(result);

      return NULL;

    }

  /**

     Prepare data for return.

   */

  distrenresult = malloc(sizeof(struct distrend_mysql_result));

  if(!distrenresult)

#include "common/asprintf.h"

#include "common/multiio.h"

#include "common/options.h"

#include "common/protocol.h"

#include "common/remoteio.h"

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <sys/stat.h>

#include <unistd.h>

#define DEBUG 0

int main(int argc, char *argv[])

{

  multiio_context_t multiio;

  char *datadir;

  char *server;

  char *username;

  char *password;

  char *hostname;

  cfg_t * my_cfg;

  struct options_common *commonopts;

  // struct distrenjob *myjob; /* Structure to hold data gathered from the XML file - not needed anymore? */

  /**

     initializations

  */

  datadir = NULL;

  server = NULL;

  username = NULL;

  if(!strncmp(password, "!password",10))

    {

      fprintf(stderr, "You haven't specified a password. Please edit distrenslave.conf!\n");

      return 1;

    }

  // Variables needed for main loop

  int jobnum = 0;

  int framenum = 0;

  int slavekey = atoi(username); // @TODO: Make this more friendly

  char *urltoTar;      /* Full URL to the server-side location of job#.tgz */

  char *pathtoJob;     /* Full path to job data folder */

  char *pathtoJobfile; /* Full path to the job's main file */

  char *outputExt = "jpg";     /* Output Extension (e.g., JPG) */

  int haveWork = 0;

  int benchmarkTime = 0;

  int renderPower = 0;

  // @TODO: add call to function to force recalc if $render_power == ""

  if(runBenchmark)

    {

      if(slaveBenchmark(datadir, &benchmarkTime, &renderPower))

        {

          fprintf(stderr,"Benchmark failed! Exiting.\n");

  if(!DEBUG)

    fprintf(stderr, "Running..");

  // Main loop

    {

    // request work

    fprintf(stderr, "Waiting...\n");

    /* If we got a frame */

    if(haveWork)

      {

        fprintf(stderr,"Got work from server...\n");

        /* @TODO: Add remotio hooks */

        // outputExt = remotio)read(outputExt); /* Set output extension from remotio */

        if(DEBUG)

          fprintf(stderr, "Preparing to render frame %d in job %d\n", framenum, jobnum);