DistRen Changeset - 92659c5651ef · protofusion repositories

Changeset - 92659c5651ef

Parent rev.

Child rev.

[Not reviewed]

default

1 23 0

Nathan Brink (binki) - 15 years ago 2010-07-22 00:03:45
ohnobinki@ohnopublishing.net

Reformed buildsystem.
- replace malloc.h with stdlib.h
- use AC_CONFIG_HEADERS for cleaner compile output
- clean out some useless AC_* macros and add useful AC_TYPE_UINT* macros

24 files changed with 91 insertions and 93 deletions:

configure.ac

m4/pkgconfig_ohnowrap.m4

src/client/distren.c

src/client/libdistren.c

src/client/libdistren_config.c

src/client/libdistren_job.c

src/client/libdistren_unbias.c

src/common/asprintf.c

src/common/execio.c

src/common/misc.c

src/common/multiio.c

src/common/options.c

src/common/protocol.c

src/common/remoteio.c

src/common/request.c

src/server/distrend.c

src/server/distrenjob.c

src/server/listen.c

src/server/mysql.c

src/server/simpleslave.c

src/server/slave.c

src/server/slavefuncs.c

src/server/tabletennis.c

src/server/user_mgr.c

0 comments (0 inline, 0 general)

configure.ac

➞

Show inline comments

 # Copyright 2010 Nathan Phillip Brink, Ethan Zonca
+#
 # This file is a part of DistRen.
+#
 # Distren is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License as published by
 # the Free Software Foundation, either version 3 of the License, or
 # (at your option) any later version.
+#
 # DistRen is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU Affero General Public License for more details.
+#
 # You should have received a copy of the GNU Affero General Public License
 # along with DistRen.  If not, see <http://www.gnu.org/licenses/>.
 AC_PREREQ(2.61)
 AC_INIT([distren],[0.0],[http://bugs.ohnopub.net/], [], [http://ohnopub.net/distren/])
 AC_CONFIG_HEADERS([src/common/config.h])
 AC_CONFIG_SRCDIR([src/server/distrend.c])
 AC_CONFIG_MACRO_DIR([m4])
 AC_PROG_CC
 AC_PROG_LIBTOOL
 #AC_PROG_RANLIB #don't add this even if autoscan says to, because AC_PROG_LIBTOOL is enough
 AM_INIT_AUTOMAKE([gnu dist-bzip2 subdir-objects -Wall])
 AM_PROG_CC_C_O
 #basic low-level checks (suggested by autoscan)
 AC_CHECK_FUNCS([dup2])
 AC_CHECK_FUNCS([memset])
 AC_CHECK_FUNCS([strdup])
 AC_CHECK_HEADERS([fcntl.h])
 AC_CHECK_HEADERS([malloc.h])
 AC_FUNC_FORK
 AC_FUNC_MALLOC
 dnl these macros force the refered to types to be available without me
 dnl writing my own magic :-)
 AC_TYPE_PID_T
 AC_TYPE_SIZE_T
 # selective compilation
 # For now, this is only left for when the C-based client is
 # reintroducded.
 AC_TYPE_UINT8_T
 AC_TYPE_UINT16_T
 AC_TYPE_UINT32_T
 dnl selective compilation
 dnl For now, this is only left for when the C-based client is
 dnl reintroducded.
 AC_ARG_ENABLE([server],
 	[AS_HELP_STRING([--disable-server],[Don't build the distren server])],
 	[enable_server=$enableval],
 	[enable_server=yes])
 AM_CONDITIONAL([ENABLE_SERVER],
 	[test "x$enable_server" = "xyes"])
 # to grab GNU-specific function prototypes for the following functions:
 # getline
 AC_DEFINE([_GNU_SOURCE], [1])
 dnl package dependencies:
 #package dependencies:
 PKG_PROG_PKG_CONFIG(0.17.2)
 PKGCONFIG_OHNOWRAP([DISTLIBS], [libconfuse >= 2.5 libcurl libxml-2.0 liblist >= 2.2.1 libarchive >= 2.8.0 ])
 PKG_CHECK_MODULES([DISTLIBS], [libconfuse >= 2.5 libcurl libxml-2.0 liblist >= 2.3.1 libarchive >= 2.8.0])
 AX_LIB_MYSQL
 AS_IF( [test "x${MYSQL_VERSION}" = "x"],
 	[ AC_MSG_ERROR([I need mysql]) ] )
-PKGCONFIG_OHNOWRAP([CHECK], [check >= 0.9.3])
+PKG_CHECK_MODULES([CHECK], [check >= 0.9.3])
 # define paths for configuration files:
 dnl define paths for configuration files until a better arrangement is
 dnl made:
 AC_DEFINE_DIR([LOCALSTATEDIR], [localstatedir], [Default directory for storing state information])
 AC_DEFINE_DIR([RUNSTATEDIR], [localstatedir/run], [Default directory for registering runtime information like pid-files])
 AC_CONFIG_FILES([Makefile
 etc/distrendaemon.conf
 etc/distrenslave.conf
 ])
 AC_OUTPUT

m4/pkgconfig_ohnowrap.m4

➞

Show inline comments

deleted file

src/client/distren.c

➞

Show inline comments

 /*
   Copyright 2010 Nathan Phillip Brink, Ethan Zonca, Matthew Orlando
   This file is a part of DistRen.
   DistRen is free software: you can redistribute it and/or modify
   it under the terms of the GNU Affero General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.
   DistRen is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU Affero General Public License for more details.
   You should have received a copy of the GNU Affero General Public License
   along with DistRen.  If not, see <http://www.gnu.org/licenses/>.
 */
 /* This code is meant to submit files to the distren server(s). Let's say server for now. And let's state file purpose in each file just so we don't get screwed up! */
 /* Ideas for php-side stuff:
+ *
  * PHP adds the users... has captcha and email confirmation wth a pseudo-random number that
  * the user must enter on the site. Apache should be running mod_peruser for safety, and I'm
  * thinking zserver2 for web serving for convenience...
  */
 #include "common/config.h"
 #include "distren.h"
 #include <stdio.h> /* sprintf, printf */
 #include <stdlib.h> /* malloc, free */
 #include <unistd.h> /* getopt */
 #include <confuse.h>
 #include <string.h> // for strcat
 int main(int argc, char *argv[])
+{
   int doLogin = 0;
   char *input;
   char *output;
   char *jobid;
   char *username;
   char *password;
   char curopt;
   distren_t distren;
   distren_job_t distren_job;
   input = NULL;
   output = NULL;
   while(-1 != (curopt = getopt(argc, argv, "i:o:u:p:h")))
+    {
       if(curopt == ':')
+	{
 	  fprintf(stderr, "-%c: is missing an argument\n", optopt);
 	  return 1;
+	}
       else if(curopt == '?')
+	{
 	  fprintf(stderr, "-%c: invalid option specified\n", optopt);
 	  return 1;
+	}
       else if(curopt == 'h')
+	{
 	  fprintf(stderr, "Usage: %s -i <inputfile> -o <outputfile> [ -u <username> -p <password> ]\n", argv[0]);
 	  fprintf(stderr, "\t-i\tSpecifies the input file\n\
 \t-o\tSpecifies the output file\n\
 \t-h\tShows this help message\n");
 	  //  don't return here because options_init will have an overall
 	  //  options help page
+	}
       else if(curopt == 'u') {
         doLogin = 1;
         username = strdup(optarg);
+      }
       else if(curopt == 'p') {
         doLogin = 1;
         password = strdup(optarg);
+      }
       else if(curopt == 'i')
 	 //  TODO: is strdup good or bad? what about
 	 //  the idea that all libs should allow plugging different
 	 //  malloc/free implementations in?
 	input = strdup(optarg);
       else if(curopt == 'o')
 	output = strdup(optarg);
+    }
      // give this error after the general arguments parsing so that
      // the general help from options_init can have effect
   if(!username || !password){
     fprintf(stderr, "Username and password must be specified");
     return 1;
+  }
   if(doLogin == 1){
     fprintf(stderr, "Trying username and password on server...");
     return 0;
+  }
   if(!input
      || !output)
+    {
       fprintf(stderr, "Input and output files must be specified\n");
       return 1;
+    }
   fprintf(stderr, "reading from %s\nwriting to %s\n", input, output);
   if(distren_init_mf(&distren, &malloc, &free))
+    {
       fprintf(stderr, "error initializing distren handle\n");
       return 1;
+    }
   if(distren_submit_file(distren, &distren_job, input))
+    {
       fprintf(stderr, "error submitting file\n");
       return 1;
+    }
   if(distren_job_getid(distren_job, &jobid))
+    {
       fprintf(stderr, "error retrieving job id\n");

src/client/libdistren.c

➞

Show inline comments

 /*
   Copyright 2010 Nathan Phillip Brink, Ethan Zonca, Matt Orlando
   This file is a part of DistRen.
   DistRen is free software: you can redistribute it and/or modify
   it under the terms of the GNU Affero General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.
   DistRen is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU Affero General Public License for more details.
   You should have received a copy of the GNU Affero General Public License
   along with DistRen.  If not, see <http://www.gnu.org/licenses/>.
 */
 /*
   Implementation of distren_* functions from distren.h excluding distren_job_* functions.
  */
 #include "common/config.h"
 #include "libdistren.h"
 #include <malloc.h>
 #include <stdio.h>
 #include <stdlib.h>
 /**
    @todo needs to read configuration in
  */
 int distren_init_mf(distren_t *handle, distren_malloc_t mymalloc, distren_free_t myfree)
+{
   if(!handle
      || !mymalloc
      || !myfree)
+    {
       fprintf(stderr, "distren_init_mf passed NULL pointers\n");
       return 1;
+    }
   *handle = (*mymalloc)(sizeof(struct distren));
   if(!*handle)
     return 1;
   (*handle)->malloc = mymalloc;
   (*handle)->free = myfree;
   /* now the environment is ready for general use */
   if(_distren_getoptions(*handle))
+    {
       fprintf(stderr, "error getting configuration\n");
       distren_free(*handle);
       return 1;
+    }
   /**
      @todo open a connection to the server now and return error if we can't
      connect.
    */
   return 0;
+}
 int distren_init(distren_t *handle)
+{
   return distren_init_mf(handle, &malloc, &free);
+}
 /**
    @todo Stub
  */
 int distren_submit_file(distren_t handle, distren_job_t *job, const char *filename)
+{
   return 1;
+}
 /**
  */
 int distren_free(distren_t handle)
+{
   _free(handle, handle);
   return 0;
+}

src/client/libdistren_config.c

➞

Show inline comments

 /*
   Copyright 2010 Nathan Phillip Brink, Ethan Zonca, Matt Orlando
   This file is a part of DistRen.
   DistRen is free software: you can redistribute it and/or modify
   it under the terms of the GNU Affero General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.
   DistRen is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU Affero General Public License for more details.
   You should have received a copy of the GNU Affero General Public License
   along with DistRen.  If not, see <http://www.gnu.org/licenses/>.
 */
 /*
   Functions and code for retrieving the client's configuration information.
  */
 #include "common/config.h"
 #include "client/libdistren.h"
 #include "common/options.h"
 /**
 @todo Stub
  */
 int _distren_getoptions(distren_t handle)
+{
   cfg_t *cfg;
   cfg_opt_t cfg_opts[] =
+    {
       CFG_STR("server", NULL, 0),
       CFG_END()
     };
   if(options_init(0, NULL, &cfg, cfg_opts, "client", &handle->options))
+    {
       fprintf(stderr, "error getting configuration\n");
       return 1;
+    }
   handle->server = cfg_getstr(cfg, "server");
   fprintf(stderr, "using ``%s'' as server\n", handle->server);
   return 0;
+}
 /**
 @todo stubish
  */
 int _distren_loseoptions(distren_t handle)
+{
   options_free(handle->options);
   return 0;
+}

src/client/libdistren_job.c

➞

Show inline comments

 /*
   Copyright 2010 Nathan Phillip Brink, Ethan Zonca, Matt Orlando
   This file is a part of DistRen.
   DistRen is free software: you can redistribute it and/or modify
   it under the terms of the GNU Affero General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.
   DistRen is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU Affero General Public License for more details.
   You should have received a copy of the GNU Affero General Public License
   along with DistRen.  If not, see <http://www.gnu.org/licenses/>.
 */
 /*
   Implementation of distren_job_* functions from distren.h.
  */
 #include "common/config.h"
 #include "libdistren.h"
 /**
    @todo Stub
  */
 int distren_job_getid(distren_job_t job, char **jobid)
+{
   return 1;
+}
 /**
    @todo Stub
  */
 int distren_job_retrieve_file(distren_job_t job, const char *outfile)
+{
   return 1;
+}
 /**
    @todo Stub
  */
 int distren_job_free(distren_job_t job)
+{
   return 1;
+}

src/client/libdistren_unbias.c

➞

Show inline comments

 /*
   Copyright 2010 Nathan Phillip Brink, Ethan Zonca, Matt Orlando
   This file is a part of DistRen.
   DistRen is free software: you can redistribute it and/or modify
   it under the terms of the GNU Affero General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.
   DistRen is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU Affero General Public License for more details.
   You should have received a copy of the GNU Affero General Public License
   along with DistRen.  If not, see <http://www.gnu.org/licenses/>.
 */
 /*
   Implementation of libdistren functions that exist to prevent this library from being biased toward certain methods of reporting errors/debug info or free()ing and malloc()ing
  */
 #include "common/config.h"
 #include "libdistren.h"
 void *_malloc(distren_t distren, size_t size)
+{
   return (*distren->malloc)(size);
+}
 void _free(distren_t distren, void *tofree)
+{
   (*distren->free)(tofree);
+}

src/common/asprintf.c

➞

Show inline comments

 /*
   Copyright 2009 Nathan Phillip Brink
   This file is a part of DistRen.
   DistRen is free software: you can redistribute it and/or modify
   it under the terms of the GNU Affero General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.
   DistRen is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU Affero General Public License for more details.
   You should have received a copy of the GNU Affero General Public License
   along with DistRen.  If not, see <http://www.gnu.org/licenses/>.
 */
 #include "common/config.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <stdarg.h>
 #include <string.h>
 int _distren_asprintf(char **strp, const char *fmt, ...)
+{
   va_list ap;
   size_t needed;
   va_start(ap, fmt);
   /**
      The return value is the size of the string that snprintf wants
      to write excluding the terminating '\0'
    */
   needed = vsnprintf(NULL, 0, fmt, ap); /*< returns the number of bytes to allocate */
   va_end(ap);
   needed ++;
   *strp = malloc(needed);
   if(!*strp)
     return -1;
   va_start(ap, fmt);
   /**
      The n argument must specify the size of the allocated space
   */
   needed = vsnprintf(*strp, needed, fmt, ap);
   va_end(ap);
   return needed;
+}

src/common/execio.c

➞

Show inline comments

 /*
   Copyright 2008 Nathan Phillip Brink, Ethan Zonca
   This file is a part of DistRen.
   DistRen is free software: you can redistribute it and/or modify
   it under the terms of the GNU Affero General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.
   DistRen is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU Affero General Public License for more details.
   You should have received a copy of the GNU Affero General Public License
   along with DistRen.  If not, see <http://www.gnu.org/licenses/>.
 */
 #include "execio.h"
 #include "common/config.h"
 #include "common/execio.h"
 #include <unistd.h>
 #include <sys/types.h>
 #ifndef _WIN32
 #include <sys/wait.h>
 #endif
 #include <signal.h>
 #include <malloc.h>
 #include <fcntl.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <errno.h>
 int execio_open(struct execio **rem, const char *progname, char *const argv[])
+{
   /* pipe used to write to child */
   int pipe_write[2];
   /* pipe used to read from child */
   int pipe_read[2];
   pid_t child;
   /* for wait(2) if needed */
   int childstatus;
   int counter;
   int counter2;
   int maxfds;
   /* create two pipes to facilitate communication with child */
   if(pipe(pipe_write))
     return 1;
   if(pipe(pipe_read))
+    {
       close(pipe_write[0]);
       close(pipe_write[1]);
       return 1;
+    }
   /* parent */
   child = fork();
   if(child == -1)
+    {
       close(pipe_write[0]);
       close(pipe_write[1]);
       close(pipe_read[0]);
       close(pipe_read[1]);
       return 1;
+    }
   if(child)
     /* the parent proc: */
+    {
       /* close sides of pipe we won't use */
       close(pipe_write[0]);
       close(pipe_read[1]);
       /* setup execio struct */
       (*rem) = malloc(sizeof(struct execio));
       if(!(*rem))
+	{
 	  /* we should tell the child we're dead - use wait and close our end of the pipes! */
 	  close(pipe_write[1]);
 	  close(pipe_read[0]);
 	  /* we should probably pass of the wait() call to a thread that just does boring things like that. Especially for when the server tries to connect to other servers... */
 	  /* maybe we should just kill instead of term the child */
 	  kill(child, SIGTERM);
 	  /* the waitpid(2) seems to indicate that only when the child is terminated will this wait return. */
 	  waitpid(child, &childstatus, 0);
+	}
       (*rem)->pipe_write = pipe_write[1];
       (*rem)->pipe_read = pipe_read[0];
       (*rem)->state = 0;
       (*rem)->child = child;
       return 0;
+    }
   /* child */
   else
+    {
       /* close unused pipes */
       close(pipe_write[1]);
       close(pipe_read[0]);
       /*
 	reset stdin, stdout, and stderr to the appropriate files. OK, not stderr :-)
       */
       dup2(pipe_read[1], STDOUT_FILENO);
       dup2(pipe_write[0], STDIN_FILENO);
       /*
 	close the fds that were dup'd
        */
       close(pipe_read[1]);
       close(pipe_write[0]);
       /*
 	 close all other file descriptors. We want to keep 0, 1, and 2 open. We don't know that the last open() or pipe() always gives the highest fd number. However, I will assume that it does. Maybe this is a bad idea:
        */
       counter = pipe_write[0];
       if(counter < pipe_write[1])
 	counter = pipe_write[1];
       if(counter < pipe_read[0])
 	counter = pipe_read[0];
       if(counter < pipe_read[1])

src/common/misc.c

➞

Show inline comments

 /*
   Copyright 2010 Nathan Phillip Brink <ohnobinki@ohnopublishing.net>
   This file is a part of DistRen.
   DistRen is free software: you can redistribute it and/or modify
   it under the terms of the GNU Affero General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.
   DistRen is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU Affero General Public License for more details.
   You should have received a copy of the GNU Affero General Public License
   along with DistRen.  If not, see <http://www.gnu.org/licenses/>.
 */
 #include "common/config.h"
 #include "common/misc.h"
 #include <errno.h>
 #include <malloc.h>
 #include <unistd.h>
 #include <stddef.h>
 #include <stdlib.h>
 char *distren_getcwd()
+{
   char *mycwd;
   size_t counter;
   /**
      This is completely wrong, feel free to rewrite with
      pathconf() in mind.
    */
   for(counter = 128; ; counter +=32)
+    {
       mycwd = malloc(counter);
       errno = 0;
       if(getcwd(mycwd, counter))
 	return mycwd;
       /** ERANGE means that counter is too small */
       if(errno != ERANGE)
 	return (char *)NULL;
       free(mycwd);
+    }
   return (char *)NULL;
+}

src/common/multiio.c

➞

Show inline comments

 /*
   Copyright 2010 Nathan Phillip Brink
   This file is a part of DistRen.
   DistRen is free software: you can redistribute it and/or modify
   it under the terms of the GNU Affero General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.
   DistRen is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU Affero General Public License for more details.
   You should have received a copy of the GNU Affero General Public License
   along with DistRen.  If not, see <http://www.gnu.org/licenses/>.
 */
 #include "common/config.h"
 #include "common/multiio.h"
 #include <list.h>
 #include <fcntl.h>
 #include <malloc.h>
 #include <poll.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 struct multiio_socket_info
+{
   /* the type of socket */
   multiio_socket_type_t socket_type;
   /* to be passed to the socket handler */
   void *socket_data;
 };
 struct multiio_socket_type_info
+{
   /* type: struct multiio_socket_type_handler_info */
   list_t type_handlers;
 };
 /*
   The basic concept is that pollfds is an array. Thus, we have to
   have another array reflecting that array to hold socket-specific
   information.
  */
 struct multiio_context
+{
   /* the array passed to poll() */
   struct pollfd *pollfds;
   /* the number of entries pollfds could hold */
   nfds_t pollfds_len;
   /* the number of entries that pollfds does hold */
   nfds_t nfds;
   /*
     an array whose order mirrors pollfds containing information
     about the fd mentioned in pollfds.
   */
   struct multiio_socket_info *socket_infos;
   /* the number of socket types registered (equivilent to the type ID of the next registered type) */
   multiio_socket_type_t num_socket_types;
   /* the information about each individual socket type keyed by the type ID */
   struct multiio_socket_type_info *socket_types;
 };
 /*
   stores information about a handler associated with a socket type/class.
  */
 struct multiio_socket_type_handler_info
+{
   /* the poll() event to which this handler responds */
   short event;
   /* the handler function to call when the event is matched */
   multiio_event_handler_func_t handler;
   /* the pointer passed to multiio_event_handler_register() */
   void *handler_data;
 };
 /**
    Finds the index in the context->pollfds array of a particular socket.
    @param context the multiio context
    @param fd the socket to search for
    @param index a pointer which will be filled with the index of the socket if found
    @return 0 if the pollfds entry is found, 1 if the entry is not found
  */
 int multiio_pollfd_index_by_fd(const multiio_context_t context, int fd, size_t *index);
 multiio_context_t multiio_context_new()
+{
   struct multiio_context *context;
   context = malloc(sizeof(struct multiio_context));
   if(!context)
     return NULL;
   context->pollfds = malloc(sizeof(struct pollfd) * 2);
   if(!context->pollfds)
+    {
       free(context);
       return NULL;
+    }
   context->pollfds_len = 2;
   context->nfds = 0;
   context->socket_infos = malloc(sizeof(struct multiio_socket_info) * 2);
   context->num_socket_types = 0;
   context->socket_types = NULL;
   if(!context->pollfds
      || !context->socket_infos)
+    {
       free(context->pollfds);
       free(context->socket_infos);
       free(context);
       return NULL;
+    }

src/common/options.c

➞

Show inline comments

 /*
   Copyright 2010 Nathan Phillip Brink, Ethan Zonca
   This file is a part of DistRen.
   DistRen is free software: you can redistribute it and/or modify
   it under the terms of the GNU Affero General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.
   DistRen is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU Affero General Public License for more details.
   You should have received a copy of the GNU Affero General Public License
   along with DistRen.  If not, see <http://www.gnu.org/licenses/>.
 */
 #include "common/config.h"
 #include "common/options.h"
 #include "common/asprintf.h"
 #include "common/misc.h"
 #include "common/multiio.h"
 #include "common/libremoteio.h"
 #include "common/protocol.h"
 #include <confuse.h>
 #include <string.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <unistd.h>
 struct options_common_data
+{
   cfg_t *cfg;
 };
 /**
    Not reentrant because of call to getenv()
    @todo replace abort()s with something useful
  */
 int options_init(int argc, char *argv[], cfg_t **mycfg, cfg_opt_t *myopts, char *myname, struct options_common **allopts, multiio_context_t multiio)
+{
   char *configfileprefix;
   char *configfile;
   size_t i;
   char *optstring = "hc:";
   char curopt;
   char *workingdir;
   char *tmp;
   configfileprefix = NULL;
   while((curopt = getopt(argc, argv, optstring)) != (char)-1)
     switch(curopt)
+      {
       case 'h':
 	fprintf(stderr, "libdistren common options\n\
 \n\
 \t-h\tShow this help.\n\
 \t-c <path>\tBasename for configuration files. For instance, if distrencommon.conf is located at /etc/distren/distrencommon.conf, set this option /etc/distren/distren . Default value: %s\n\
 \n", SYSCONFDIR "/distren");
 	return 2;
 	break;
       case 'c':
 	configfileprefix = strdup(optarg);
 	if(!configfileprefix)
 	  /* return is unnecessary here */
 	  fprintf(stderr, "OOM\n");
 	break;
       case ':':
 	fprintf(stderr, "Option -%c requires an argument\n", optopt);
 	return 1;
+      }
   /* restore optind for other people who use getopt */
   optind = 1;
   if(!configfileprefix
      && (configfileprefix = getenv("DISTREN_CONFIG_PREFIX")) )
+    {
       configfileprefix = strdup(configfileprefix);
       if(!configfileprefix)
+	{
 	  fprintf(stderr, "OOM\n");
 	  return 1;
+	}
+    }
   /* For those of you who don't know, the following is an example of concatenation of constant strings by the C compiler. Now, that doesn't mean you can do run-time string concatenation ;-)
      strdup is because someday configfile will be customizable via argv[]
   */
   if(!configfileprefix)
       configfileprefix = strdup(SYSCONFDIR);
   if(!configfileprefix)
+    {
       fprintf(stderr, "OOM\n");
       return 1;
+    }
   workingdir = distren_getcwd();
   if(!workingdir)
     fprintf(stderr, "Error finding working directory, I will not be able to return to it after reading the configuration files\n");
   if(chdir(configfileprefix))
     fprintf(stderr, "Unable to chdir(\"%s\") where I expected to find config files, expect failure\n", configfileprefix);
   free(configfileprefix);
   _distren_asprintf(&configfile, "%s%s.conf", PACKAGE, myname);
   if(!configfile)
+    {
       perror("blah");
       free(workingdir);

src/common/protocol.c

➞

Show inline comments

 /*
   Copyright 2010 Nathan Phillip Brink
   This file is a part of DistRen.
   DistRen is free software: you can redistribute it and/or modify
   it under the terms of the GNU Affero General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.
   DistRen is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU Affero General Public License for more details.
   You should have received a copy of the GNU Affero General Public License
   along with DistRen.  If not, see <http://www.gnu.org/licenses/>.
 */
 #include "protocol.h"
 #include "remoteio.h"
 #include "common/config.h"
 #include <malloc.h>
 #include "common/protocol.h"
 #include "common/remoteio.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #define DISTREN_REQUEST_MAGIC ((uint32_t)0x32423434)
 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));
   if(!newreq)
+    {
       (*req) = NULL;
       return 1;
+    }
   newreq->magic = DISTREN_REQUEST_MAGIC;
   newreq->len = len;
   newreq->type = type;
   (*req) = newreq;
   return 0;
+}
 int distren_request_send(struct remoteio *rem, struct distren_request *req, void *data)
+{
   void *packet;
   size_t len;
   int write_err;
   if(req->magic != DISTREN_REQUEST_MAGIC)
     fprintf(stderr, "distren_request_send got a bad req\n");
   len = sizeof(struct distren_request) + req->len;
   packet = malloc(len);
   if(!packet)
+    {
       fprintf(stderr, "Error allocating memory for packet\n");
       return 1;
+    }
   memcpy(packet, req, sizeof(struct distren_request));
   memcpy(packet + sizeof(struct distren_request), data, req->len);
   write_err = remoteio_write(rem, packet, len);
   free(packet);
   return 0;
+}
 int distren_request_new_fromdata(struct distren_request **req, void *data, size_t len)
+{
   struct distren_request *newreq;
 #if 0
   size_t counter;
   uint32_t debugtmp;
 #endif
   if(len < sizeof(struct distren_request))
     return 1;
   if( ((struct distren_request *)data)->magic != DISTREN_REQUEST_MAGIC )
+    {
       fprintf(stderr, "packet doesn't match magic stuffs");
 #if 0
       fputs("\n\tmagic=`", stderr);
       debugtmp = DISTREN_REQUEST_MAGIC;
       for(counter = 0; counter < sizeof(uint32_t); counter ++)
 	putc(((char *)&debugtmp)[counter], stderr);
       fputs("'\n\t`", stderr);
       for(counter = 0; counter < sizeof(struct distren_request); counter ++)
 	putc(((char *)data)[counter], stderr);
       fputs("'\n", stderr);
 #endif
       return 1;
+    }
   newreq = malloc(sizeof(struct distren_request));
   if(!newreq)
+    {
       fprintf(stderr, "OOM\n");
       return 1;
+    }
   memcpy(newreq, data, sizeof(struct distren_request));
   (*req) = newreq;
   return 0;
+}
 int distren_request_free(struct distren_request *req)
+{
   free(req);
   return 0;
+}

src/common/remoteio.c

➞

Show inline comments

 /*
   Copyright 2010 Nathan Phillip Brink
   This file is a part of DistRen.
   DistRen is free software: you can redistribute it and/or modify
   it under the terms of the GNU Affero General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.
   DistRen is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU Affero General Public License for more details.
   You should have received a copy of the GNU Affero General Public License
   along with DistRen.  If not, see <http://www.gnu.org/licenses/>.
 */
 #include "libremoteio.h"
 #include "execio.h"
 #include "asprintf.h"
 #include "common/config.h"
 #include "common/libremoteio.h"
 #include "common/execio.h"
 #include "common/asprintf.h"
 #include <list.h>
 #include <errno.h>
 #ifndef _WIN32
 #include <netdb.h>
 #endif
 #include <poll.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
 #include <sys/types.h>
 #ifdef _WIN32
 #include <winsock2.h>
 #include <ws2tcpip.h>
 #else
 #include <sys/socket.h>
 #endif
 #include <unistd.h>
 #include <queue.h>
 #ifndef _WIN32
 #include <sys/un.h>
 #endif
 /* local */
 #define REMOTEIO_DEFAULT_PORT "4050"
 int _remoteio_handle_write(multiio_context_t multiio,
 			   int fd,
 			   short revent,
 			   struct remoteio_opts *opts,
 			   struct remoteio *rem);
 int _remoteio_handle_read(multiio_context_t multiio,
 			  int fd,
 			  short revent,
 			  struct remoteio_opts *opts,
 			  struct remoteio *rem);
 int _remoteio_ssh_open(struct remoteio *rem, struct remoteio_server *server);
 int _remoteio_ssh_read(struct remoteio *rem, void *buf, size_t len, size_t *bytesread);
 int _remoteio_ssh_write(struct remoteio *rem, void *buf, size_t len, size_t *byteswritten);
 int _remoteio_ssh_close(struct remoteio *rem);
 /**
    ``named pipes''
  */
 #ifndef _WIN32
 int _remoteio_sock_open(struct remoteio *rem, struct remoteio_server *server);
 int _remoteio_sock_close(struct remoteio *rem);
 #endif
 int _remoteio_sock_read(struct remoteio *rem, void *buf, size_t len, size_t *bytesread);
 int _remoteio_sock_write(struct remoteio *rem, void *buf, size_t len, size_t *byteswritten);
 /**
    These borrow from _remoteio_sock_read() and _remoteio_sock_write().
  */
 int _remoteio_tcp_open(struct remoteio *rem, struct remoteio_server *server);
 int _remoteio_tcp_close(struct remoteio *rem);
 /**
   lookup table for different methods of remoteio:
   the enum remoteio_method is the index of the entry to use for that method.
   Regardless, a NULL terminator is required because the configuration function
   searches through this table for the method specified in the config file.
 */
 struct remoteio_method_funcmap funcmap[] =
+  {
     /* [REMOTEIO_METHOD_SSH] */
     {REMOTEIO_METHOD_SSH, &_remoteio_ssh_open, &_remoteio_ssh_read, &_remoteio_ssh_write, &_remoteio_ssh_close, "ssh"},
 #ifndef _WIN32
     {REMOTEIO_METHOD_UNIX, &_remoteio_sock_open, &_remoteio_sock_read, &_remoteio_sock_write, &_remoteio_sock_close, "unix"},
 #endif
     {REMOTEIO_METHOD_TCP, &_remoteio_tcp_open, &_remoteio_sock_read, &_remoteio_sock_write, &_remoteio_tcp_close, "tcp"},
     {REMOTEIO_METHOD_SOCKET, NULL, &_remoteio_sock_read, &_remoteio_sock_write, &_remoteio_sock_close},
     {REMOTEIO_METHOD_MAX, NULL, NULL, NULL, NULL, NULL}
   };
 struct remoteio_server *remoteio_getserver(const struct remoteio_opts *opts, const char *servername);
 void remoteio_packet_free(struct remoteio_packet *packet);
 int remoteio_config(cfg_t *cfg, struct remoteio_opts *opts)
+{
   size_t numservers;
   size_t counter, counter2;
   static int haslisted_methods = 0;
   struct remoteio_server aserver;
   multiio_socket_type_register(opts->multiio, &opts->socket_type);
   multiio_event_handler_register(opts->multiio,
 				 opts->socket_type,
-				 POLLWRNORM,
+				 POLLOUT,
 				 (multiio_event_handler_func_t)&_remoteio_handle_write,
 				 opts);
   multiio_event_handler_register(opts->multiio,
 				 opts->socket_type,
-				 POLLRDNORM,
+				 POLLIN,
 				 (multiio_event_handler_func_t)&_remoteio_handle_read,
 				 opts);
   opts->servers = list_init();
   if(!opts->servers)
+    {
       fprintf(stderr, "@todo cleanup!\n");
       abort();
+    }
   numservers = cfg_size(cfg, "server");
   for(counter = 0; counter < numservers; counter ++)
+    {
       cfg_t *cfg_aserver;
       char *method;
       cfg_aserver = cfg_getnsec(cfg, "server", counter);
       aserver.name = strdup(cfg_title(cfg_aserver));
       aserver.hostname = strdup(cfg_getstr(cfg_aserver, "hostname"));
       aserver.username = strdup(cfg_getstr(cfg_aserver, "username"));
       aserver.method = REMOTEIO_METHOD_MAX;
       method = cfg_getstr(cfg_aserver, "method");
       for(counter2 = 0; funcmap[counter2].name; counter2 ++)
 	if(strcmp(method, funcmap[counter2].name) == 0)
 	  aserver.method = funcmap[counter2].method;
       if(aserver.method == REMOTEIO_METHOD_MAX)
+	{
 	  fprintf(stderr, "No such method as %s\n", method);
 	  if(!haslisted_methods)
+	    {
 	      fprintf(stderr, "Available methods:\n");
 	      for(counter2 = 0; funcmap[counter2].name; counter2 ++)
 		fprintf(stderr, "\t%s\n", funcmap[counter2].name);
 	      haslisted_methods ++;
+	    }
 	  abort();
+	}
       list_insert_after(opts->servers, &aserver, sizeof(struct remoteio_server));
+    }
   return 0;
+}
 int remoteio_generic_data_set(struct remoteio_opts *opts, void *generic_data)
+{
   opts->generic_handler_data = generic_data;
   return 0;
+}
 int remoteio_open_common(struct remoteio **remoteio,
 			 enum remoteio_method method,
 			 struct remoteio_opts *opts,
 			 remoteio_read_handle_func_t read_handler,
 			 void *read_handler_data,
 			 remoteio_close_handle_func_t close_handler)
+{
   struct remoteio *rem;
   rem = malloc(sizeof(struct remoteio));
   if(!rem)
+    {
       fprintf(stderr, "OOM\n");
       return 2;
+    }
   *remoteio = rem;
   rem->execio = NULL;
   rem->method = method;
   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;
   rem->close_handler = close_handler;
   /*
    * the following initialization is very important... though the
    * others are too, I suppose :-p. See remoteio_close()
    */
   rem->careful_free = 0;
   return 0;
+}
 int remoteio_open_socket(struct remoteio **remoteio,
 			 struct remoteio_opts *opts,
 			 remoteio_read_handle_func_t read_handler,
 			 void *read_handler_data,
 			 remoteio_close_handle_func_t close_handler,
 			 int fd)
+{
   struct remoteio *rem;
   if(remoteio_open_common(remoteio, REMOTEIO_METHOD_SOCKET, opts, read_handler, read_handler_data, close_handler))
     return 1;
   rem = *remoteio;
   rem->sock = fd;
-  multiio_socket_add(opts->multiio, rem->sock, opts->socket_type, rem, POLLRDNORM);
+  multiio_socket_add(opts->multiio, rem->sock, opts->socket_type, rem, POLLIN);
   return 0;
+}
 int remoteio_open_server(struct remoteio **remoteio,
 			 struct remoteio_opts *opts,
 			 remoteio_read_handle_func_t read_handler,
 			 void *read_handler_data,
 			 remoteio_close_handle_func_t close_handler,
 			 const char *servername)
+{
   struct remoteio_server *theserver;
   struct remoteio *rem;
   int tmp;
   if(!opts)
+    {
       fprintf(stderr, "%s:%d: no null opts!\n\tThis is a bug, please report it (after making sure it isn't already reported)\n", __FILE__, __LINE__);
       return 1;
+    }
   theserver = remoteio_getserver(opts, servername);
   if(!theserver)
+    {
       fprintf(stderr, "%s:%d: Could not find server named ``%s''\n", __FILE__, __LINE__, servername);
       return 1;
+    }
   if(theserver->method >= REMOTEIO_METHOD_MAX
      || 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;
+    }
   if(remoteio_open_common(remoteio, theserver->method, opts, read_handler, read_handler_data, close_handler))
     return 1;
   rem = *remoteio;
   tmp = funcmap[theserver->method].open_func(rem, theserver);
   if(tmp)
+    {
       fprintf(stderr, "Error using method %s for server ``%s''", funcmap[theserver->method].name, servername);
       free(rem->inbuf.data);
       q_free(rem->outmsgs, QUEUE_NODEALLOC);
       free(rem);
       *remoteio = NULL;
       return tmp;
+    }
   /**
    * @todo make this code slightly more generic... able to handle
    * execio's multi-sockets by letting execio register itself with
    * multiio instead of us registering here perhaps
    */
-  multiio_socket_add(opts->multiio, rem->sock, opts->socket_type, rem, POLLRDNORM);
+  multiio_socket_add(opts->multiio, rem->sock, opts->socket_type, rem, POLLIN);
   return 0;
+}
 /**
  * Implementation of multiio_event_handler_func_t
  */
 int _remoteio_handle_read(multiio_context_t multiio,
 			  int fd,
 			  short revent,
 			  struct remoteio_opts *opts,
 			  struct remoteio *rem)
+{
   struct remoteio_packet packet;
   size_t readlen;
   char buf[8192];
   int tmp;
   packet.len = 0;
   packet.data = NULL;
   if(rem->sock != fd)
     fprintf(stderr, "%d != %d\n", rem->sock, fd);
   tmp = funcmap[rem->method].read_func(rem, buf, sizeof(buf), &readlen);
   if(tmp)
+    {
       remoteio_close(rem);
       return 1;
+    }
   /* expand the input buffer */
   packet.len = rem->inbuf.len + readlen;
   packet.data = malloc(rem->inbuf.len + readlen);
   if(!packet.data)
+    {
       fprintf(stderr, "OOM!\n");
       return 1;
+    }
   if(rem->inbuf.data)
     memcpy(packet.data, rem->inbuf.data, rem->inbuf.len);
   memcpy(packet.data + rem->inbuf.len, buf, readlen);
   free(rem->inbuf.data);
   memcpy(&rem->inbuf, &packet, sizeof(struct remoteio_packet));
   /*
    * readlen wil now keeps track of how many bytes the handler
    * function has read.
+   *
    * Call the read_handler. Set careful_free, see remoteio_close(), so
    * that rem->read_handler() may call remoteio_close() without
    * segfaulting us ;-).
    */
   rem->careful_free = 1;
   readlen = (*rem->read_handler)(rem, rem->opts->generic_handler_data, rem->inbuf.data, rem->inbuf.len, rem->read_handler_data);
   if(rem->careful_free == 2)
+    {
       rem->careful_free = 0;
       remoteio_close(rem);
       return 0;
+    }
   rem->careful_free = 0;
   memmove(rem->inbuf.data, rem->inbuf.data + readlen, rem->inbuf.len - readlen);
   rem->inbuf.len -= readlen;
   return 0;
+}
 int remoteio_write(struct remoteio *rem, const void *buf, size_t len)
+{
   struct remoteio_packet *packet;
   struct pollfd pollfd;
   ssize_t bytes_written;
   /**
    * This is probably about the only optimization that exists in
    * distren.... :-D
+   *
    * Write to the client immediately if there are no other messages
    * waiting and if the client will accept it.
    */
   if(q_empty(rem->outmsgs))
+    {
       pollfd.fd = rem->sock;
-      pollfd.revents = POLLWRNORM;
+      pollfd.revents = POLLOUT;
       pollfd.events = 0;
       poll(&pollfd, 1, 0);
-      if(pollfd.events & POLLWRNORM)
+      if(pollfd.events & POLLOUT)
+	{
 	  bytes_written = write(rem->sock, buf, len);
 	  if(bytes_written > 0)
+	    {
 	      len -= bytes_written;
 	      buf += bytes_written;
+	    }
+	}
+    }
   /**
    * zero length is easy... and might be possible if the above
    * optimization works ;-)
    */
   if(!len)
     return 0;
   packet = malloc(sizeof(struct remoteio_packet));
   if(!packet)
+    {
       fprintf(stderr, "OOM\n");
       return 1;
+    }
   packet->len = len;
   packet->data = malloc(len);
   if(!packet->data)
+    {
       free(packet);
       fprintf(stderr, "OOM\n");
       return 1;
+    }
   memcpy(packet->data, buf, len);
   q_enqueue(rem->outmsgs, packet, 0);
-  multiio_socket_event_enable(rem->opts->multiio, rem->sock, POLLWRNORM);
+  multiio_socket_event_enable(rem->opts->multiio, rem->sock, POLLOUT);
   return 0;
+}
 int _remoteio_handle_write(multiio_context_t multiio,
 			   int fd,
 			   short revent,
 			   struct remoteio_opts *opts,
 			   struct remoteio *rem)
+{
   struct remoteio_packet *packet;
   size_t written_amount;
   int tmp;
   fprintf(stderr, "%s:%d: <del>My</del><ins>Someone else's</ins> traversal says that sock %d is available for writing\n",
 	  __FILE__, __LINE__, fd);
   /*
    * check if we're out of stuff to write.
    */
   if(q_empty(rem->outmsgs))
+    {
-      multiio_socket_event_disable(multiio, fd, POLLWRNORM);
+      multiio_socket_event_disable(multiio, fd, POLLOUT);
       return 0;
+    }
   packet = q_front(rem->outmsgs);
   tmp = funcmap[rem->method].write_func(rem, packet->data, packet->len, &written_amount);
   /**
      Disconnect in case of write error.
   */
   if(tmp)
+    {
       fprintf(stderr, __FILE__ ":%d: error handling for write() needs to be inserted into remoteio.... perhaps.. ;-)\n", __LINE__);
+    }
   if(packet->len == written_amount)
+    {
       q_dequeue(rem->outmsgs);
       remoteio_packet_free(packet);
       if(q_empty(rem->outmsgs))
-	multiio_socket_event_disable(multiio, fd, POLLWRNORM);
+	multiio_socket_event_disable(multiio, fd, POLLOUT);
+    }
   else
+    {
       /**
        * shifting seems the simplest solution.
        */
       packet->len -= written_amount;
       memmove(packet->data, packet->data + written_amount, packet->len);
+    }
   return 0;
+}
 int remoteio_close(struct remoteio *rem)
+{
   int rtn;
   /**
    * See careful_free's and _remoteio_handle_read()'s docs.  If
    * careful_free is nonzero, then we shouldn't free it here because
    * such a free would cause a segfault. However, whoever set
    * rem->careful_free to nonzero will handle resetting
    * rem->careful_free to zero and calling remoteio_close() if
    * necessary.
    */
   if(rem->careful_free)
+    {
       rem->careful_free = 2;
       return 0;
+    }
   /* call close handler */
   if(rem->close_handler)
     (*rem->close_handler)(rem->opts->generic_handler_data, rem->read_handler_data);
   /* cleanup multiiio stuff */
   multiio_socket_del(rem->opts->multiio, rem->sock);
   /* backend-specific cleanup */
   rtn = funcmap[rem->method].close_func(rem);
   /* this part is normal ;-) */
   free(rem->inbuf.data);
   q_free(rem->outmsgs, (list_dealloc_func_t)remoteio_packet_free);
   free(rem);
   return rtn;
+}
 /**
  * Frees an entire packet, including the passed pointer. If you just
  * want the contents of the packet free()ed, just do
  * free(packet.data);
  */
 void remoteio_packet_free(struct remoteio_packet *packet)
+{
   free(packet->data);
   free(packet);
+}
 int _remoteio_getserver_traverse(char *servername, struct remoteio_server *aserver)
+{
   if(!strcmp(aserver->name, servername))
     return FALSE; /* stop traversal */
   return TRUE;
+}
 struct remoteio_server *remoteio_getserver(const struct remoteio_opts *opts, const char *servername)
+{
   int traversal_result;
   char *dispensible_servername;
   dispensible_servername = strdup(servername); /* for the sake of constness... */
   traversal_result = list_traverse(opts->servers, dispensible_servername, (list_traverse_func_t)&_remoteio_getserver_traverse, LIST_FRNT | LIST_ALTR);
   free(dispensible_servername);
   if(traversal_result == LIST_OK)
     return (struct remoteio_server *)list_curr(opts->servers);
   return (struct remoteio_server *)NULL;
+}
 /**
    different remoteio methods' implementations:
  */
 /*
   SSH, via execio
 */

src/common/request.c

➞

Show inline comments

 /*
  * Copyright 2010 Nathan Phillip Brink
+ *
  * This file is a part of DistRen.
+ *
  * DistRen is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as published by
  * the Free Software Foundation, either version 3 of the License, or
  * (at your option) any later version.
+ *
  * DistRen is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU Affero General Public License for more details.
+ *
  * You should have received a copy of the GNU Affero General Public License
  * along with DistRen.  If not, see <http://www.gnu.org/licenses/>.
  */
 #include "common/config.h"
 #include "common/protocol.h"
 #include <stdlib.h>
 #include <string.h>
 int distren_request_free_with_data(struct distren_request *req, void *data)
+{
   free(data);
   return distren_request_free(req);
+}
 int distren_request_poing(struct distren_request **req, void **data, short is_ping, const void *poing_cookie, size_t poing_data_len)
+{
   enum distren_request_type type;
   if(is_ping)
     type = DISTREN_REQUEST_PING;
   else
     type = DISTREN_REQUEST_PONG;
   distren_request_new(req, poing_data_len, type);
   (*data) = malloc(poing_data_len);
   memcpy(*data, poing_cookie, poing_data_len);
   return 0;
+}

src/server/distrend.c

➞

Show inline comments

 /*
   Copyright 2010 Nathan Phillip Brink, Ethan Zonca, Matthew Orlando
   This file is a part of DistRen.
   DistRen is free software: you can redistribute it and/or modify
   it under the terms of the GNU Affero General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.
   DistRen is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU Affero General Public License for more details.
   You should have received a copy of the GNU Affero General Public License
   along with DistRen.  If not, see <http://www.gnu.org/licenses/>.
 */
 /* This file contains the code which both processes (renders) jobs as a slave, and the code which distributes frames to slaves after receiving them from the client portion of the codebase. */
 #include "common/config.h"
 #include "distrenjob.h"
 #include "listen.h"
 #include "slavefuncs.h"
 #include "mysql.h"
 #include "common/asprintf.h"
 #include "common/execio.h"
 #include "common/options.h"
 #include "common/protocol.h"
 #include <confuse.h>
 #include <malloc.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <time.h>
 #include <unistd.h>
 #include <libxml/encoding.h>
 #include <libxml/parser.h>
 #include <libxml/tree.h>
 #include <libxml/xmlmemory.h>
 #include <libxml/xmlreader.h>
 #include <libxml/xmlwriter.h>
 /* ******************* Structs ************************ */
 struct general_info
+{
   struct distrenjob head;
   distrend_mysql_conn_t conn;
   struct distrend_config *config;
   struct
+  {
     /** general_info.xml */
     char *geninfo;
   } files;
   int jobs_in_queue;
   unsigned int free_clients;
   unsigned int rendering_clients;
   unsigned int total_finished_jobs;
   unsigned int total_frames_rendered;
   unsigned int highest_jobnum;
   int hibernate;
   time_t timestamp;
   unsigned long total_render_power;
   unsigned long total_priority_pieces;
 };
 /* *********************************************
    Function Prototypes
    ********************************************* */
 /* ************General Functions************* */
 int distrend_do();
 int distrend_do_config(int argc, char *argv[], struct distrend_config **config, multiio_context_t multiio);
 int distrend_config_free(struct distrend_config *config);
 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);
 /* **************Test Functions**************** */
 int interactiveTest(int test, multiio_context_t multiio, struct general_info *general_info);
 /* **************** Main ********************* */
 int main(int argc, char *argv[])
+{
   /* Parse arguments */
   int counter;
   int test = 0; /*< Interactive mode if 1 */
   int tmp;
   struct general_info general_info;
   multiio_context_t multiio;
   enum clientstatus
+  {
     CLIENTSTATUS_UNINITIALIZED = 0,
     CLIENTSTATUS_BUSY = 1,
     CLIENTSTATUS_IDLE = 2
   } clientstatus;
   clientstatus = CLIENTSTATUS_UNINITIALIZED;
   // xmlinit();
   for(counter = 0; counter < argc; counter ++)
+    {
       if(strcmp(argv[counter], "-h") == 0)
+      {
     	  fprintf(stderr, "Usage: distrend [option] \nStarts the distrend server\n\t-h\tshow this help\n\t-t\tlaunches queue testing interface \n");
 	  return 2;
+      }
       else if(strcmp(argv[counter], "-t") == 0)
+      {

src/server/distrenjob.c

➞

Show inline comments

 /*
   Copyright 2010 Nathan Phillip Brink <ohnobinki@ohnopublishing.net>
   This file is a part of DistRen.
   DistRen is free software: you can redistribute it and/or modify
   it under the terms of the GNU Affero General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.
   DistRen is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU Affero General Public License for more details.
   You should have received a copy of the GNU Affero General Public License
   along with DistRen.  If not, see <http://www.gnu.org/licenses/>.
 */
 #include "common/config.h"
 #include "distrenjob.h"
 #include "slavefuncs.h"
 #include "common/asprintf.h"
 #include <libxml/parser.h>
 #include <libxml/tree.h>
 #include <libxml/xmlwriter.h>
 #include <time.h>
 void distrenjob_free(struct distrenjob **distrenjob)
+{
   struct distrenjob *dj;
   dj = *distrenjob;
   xmlFree(dj->name);
   xmlFree(dj->submitter);
   free(dj->frameset);
   free(dj);
   *distrenjob = NULL;
+}
 int distrenjob_new(struct distrenjob **distrenjob)
+{
   struct distrenjob *dj;
   dj = malloc(sizeof(struct distrenjob));
   if(!dj)
+    {
       /* try to catch code that doesn't respect return values
        faster: */
       *distrenjob = NULL;
       return 1;
+    }
   *distrenjob = dj;
   dj->next = NULL;
   dj->jobnum = 0; /*< @todo there should be a central jobnum allocator and a way to save the maximum jobnumber allocated */
   dj->type = 1;
   dj->name = (char *)NULL;
   dj->submitter = (char *)NULL;
   dj->output_format = (char *)NULL;
   dj->width = 0;
   dj->height = 0;
   dj->priority = 0;
   dj->completed_frames = 0;
   dj->assigned_frames = 0;
   dj->total_frames = 0;
   dj->prev_frame_index = -1;
   dj->total_render_time = 0;
   dj->assigned_render_power = 0;
   dj->watchdog_forgiveness = 3600; // initialize watchdog forgiveness at 1 hour
   dj->hibernate = 0;
   dj->frameset = (struct frameset *)NULL; /*< @todo does frameset need to be initialized here? */
   return 0;
+}
 /**
    read an unsigned integer property from an xmlNode
    convenience function for distrenjob_unserialize()
    @param xmlnode may be NULL for convenience
    @return 0 on success, other on error
  */
 int _distrenjob_xml_readuint(xmlNodePtr xmlnode, xmlChar *propname, unsigned int *num)
+{
   xmlChar *string;
   if(!xmlnode)
     return 1;
   string = xmlGetProp(xmlnode, propname);
   if(!string)
+    {
       fprintf(stderr, "_distrenjob_xml_readuint(): warning: unable to get property ``%s''\n",
 	      propname);
       return 1;
+    }
   *num = (unsigned int)strtoul((char *)string, (char **)NULL, 10);
   xmlFree(string);
   return 0;
+}
 /**
    Loads a distrenjob that was serialized with distrenjob_serialize()
    @see distrenjob_serialize()
    @param pathtoxml path to XML file
    @param distrenjob will be set to a pointer
 */
 int distrenjob_unserialize(struct distrenjob **distrenjob, char *pathtoxml)
+{
   struct distrenjob *dj;
   struct frameset *fs;
   unsigned int start_frame;
   unsigned int end_frame;
   unsigned int counter;

src/server/listen.c

➞

Show inline comments

 /*
   Copyright 2010 Nathan Phillip Brink
   This file is a part of DistRen.
   DistRen is free software: you can redistribute it and/or modify
   it under the terms of the GNU Affero General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.
   DistRen is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU Affero General Public License for more details.
   You should have received a copy of the GNU Affero General Public License
   along with DistRen.  If not, see <http://www.gnu.org/licenses/>.
 */
 #include "common/config.h"
 #include "listen.h"
 #include "common/protocol.h"
 #include "common/remoteio.h"
 #include <errno.h>
 #include <list.h>
 #include <malloc.h>
 #include <netinet/in.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/types.h>
 #include <poll.h>
 #include <sys/socket.h>
 #include <unistd.h>
 /* local */
 struct distrend_request_handler_info
+{
   enum distren_request_type request_type;
   distrend_handle_request_func_t handler;
 };
 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);
 static size_t distrend_listen_read_handle(struct remoteio *rem, struct distrend_listens *listens, void *buf, size_t len, struct distrend_client *client);
 static void distrend_listen_remoteio_handle_close(struct distrend_listens *listens, struct distrend_client *client);
 int listen_handle_accept(multiio_context_t multiio,
 			 int fd,
 			 short revent,
 			 struct distrend_listens *listens,
 			 int *port);
 int listen_handle_error(multiio_context_t multiio,
 			int fd,
 			short revent,
 			struct distrend_listens *listens,
 			int *port);
 /*** TO BE MOVED TO REMOTEIO */
 int listen_handle_existence(multiio_context_t multiio,
 			    int fd,
 			    short revent,
 			    struct distrend_listens *listens,
 			    struct distrend_client *client);
 struct distrend_listens *distrend_listens_new(multiio_context_t multiio,
 					      struct general_info *geninfo,
 					      struct options_common *opts)
+{
   struct distrend_listens *listens;
   listens = malloc(sizeof(struct distrend_listens));
   if(!listens)
     return NULL;
   listens->request_handlers = list_init();
   if(!listens->request_handlers)
+    {
       free(listens);
       return NULL;
+    }
   listens->options = opts;
   listens->geninfo = geninfo;
   /* multiio */
   listens->multiio = multiio;
   /* tabletennis */
   listens->tabletennis = tabletennis_new(listens, 32, 16);
   /* 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,
 				 (multiio_event_handler_func_t)&listen_handle_error,
 				 listens);
   multiio_event_handler_register(multiio,
 				 listens->socket_type,
-				 POLLRDNORM,
+				 POLLIN,
 				 (multiio_event_handler_func_t)&listen_handle_accept,
 				 listens);
   return listens;
+}
 int distrend_listen_add(struct distrend_listens *listens, int port)
+{
   int tmp;
   int fd;
   int *saved_port;
   struct sockaddr_in6 sockaddr =
+    {
       .sin6_family = AF_INET6,
       .sin6_port = 0,
       .sin6_flowinfo = 0,
       .sin6_addr = IN6ADDR_ANY_INIT,
       .sin6_scope_id = 0
     };
   sockaddr.sin6_port = htons(port);
   fd = socket(AF_INET6, SOCK_STREAM, 0);
   tmp = bind(fd, (struct sockaddr *)&sockaddr, sizeof(sockaddr));
   if(tmp == -1)
+    {
       perror("bind");
       close(fd);
       return 1;
+    }
   tmp = listen(fd, 1);
   if(tmp == -1)
+    {
       perror("listen");
       close(fd);
       return 1;
+    }
   saved_port = malloc(sizeof(int));
   if(!saved_port)
+    {
       perror("malloc");
       close(fd);
       return 1;
+    }
   *saved_port = port;
-  tmp = multiio_socket_add(listens->multiio, fd, listens->socket_type, saved_port, POLLRDNORM);
+  tmp = multiio_socket_add(listens->multiio, fd, listens->socket_type, saved_port, POLLIN);
   if(tmp)
+    {
       close(fd);
       return 1;
+    }
   /**
    * @todo perhaps we'll someday want the ability to unlisten()? :-p
    * Then we have to store the fd somewheres so that we can call
    * multiio_socket_del() on it. So far, however, that functionality
    * isn't needed.
    */
   return 0;
+}
 int listen_handle_error(multiio_context_t multiio,
 			int fd,
 			short revent,
 			struct distrend_listens *listens,
 			int *port)
+{
   fprintf(stderr, "Port %d experienced an error or is closed. Closing it.\n", *port);
   multiio_socket_del(listens->multiio, fd);
   close(fd);
   free(port);
   return 0;
+}
 /**
  * an important thing to handle
+ *
  * @deprecated to be replaced with table_tennis
  */
 int listen_handle_existence(multiio_context_t multiio,
 			    int fd,
 			    short revent,
 			    struct distrend_listens *listens,
 			    struct distrend_client *client)
+{
   /**
    * handle dead/closed sockets here!
    */
   fprintf(stderr, __FILE__ ":%d: handle dead/closed sockets here!\n", __LINE__);
   /**
    * Manage timing-out clients.
    */
   if(time(NULL) > client->cleanup_time)
     switch(client->state)
+      {
       case DISTREND_CLIENT_PREVERSION:
 	distrend_send_disconnect(client, "You have failed to present version information in a timely manner. Cya :-p");
 	break;
       case DISTREND_CLIENT_PREAUTH:
 	distrend_send_disconnect(client, "You have failed to present authentication information in a timely manner. Cya ;-)");
 	break;
       case DISTREND_CLIENT_GOOD:
 	/*
 	 * pings should be managed with two queues sharing this struct:
 	 *   struct pingpong_queue { struct distrend_client *client; time_t ping_time };
+	 *
 	 * - queue to_ping: contains queue of clients to send pings to
 	 *   with the client whose ping time is earliest at the front
+	 *
 	 * - queue to_be_ponged: contains a queue of clients to clean up
 	 *   if they haven't recieved pongs. client with earliest cleanup
 	 *   time is at the front. If a PONG packet is received in time, the
 	 *   cleanup_time is bumped but the queue is left alone. When the
 	 *   queue's element is encountered, cleanup_time is checked and then
 	 *   the client is readded to the to_ping queue.
+	 *
 	 * Each queue shall be eaten as time passes and continue forever
 	 * in circularity.
+	 *
 	 * data structures.
 	 * fun.
 	 * impossible to explain in text.
 	 * easy to think up.
 	 * impossible to determine the workings of existing ones.
 	 * and... when you need them, screenshot utilities just aren't available :-/.
 	 */
 	distrend_send_disconnect(client, "Ping timeout :-p");
 	break;
       case DISTREND_CLIENT_BAD:
 	fprintf(stderr, __FILE__ ":%d: aaarrrrgh!\n :-D\n", __LINE__);
 	break;
       default:
 	break;

src/server/mysql.c

➞

Show inline comments

 /*
   Copyright 2010 Nathan Phillip Brink, Ethan Zonca, Matthew Orlando
   This file is a part of DistRen.
   DistRen is free software: you can redistribute it and/or modify
   it under the terms of the GNU Affero General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.
   DistRen is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU Affero General Public License for more details.
   You should have received a copy of the GNU Affero General Public License
   along with DistRen.  If not, see <http://www.gnu.org/licenses/>.
 */
 #include "common/config.h"
 #include "mysql.h"
 #include <mysql/mysql.h>
 #include "common/asprintf.h"
 #include "common/protocol.h"
 #include <stdio.h>
 #include <string.h>
 #include <unistd.h>
 #include <stdlib.h>
 #include <sys/stat.h>
 #include <fcntl.h>
 /**
    local types
  */
 #define SEVENTY_FIVE 75
 #define FORTY_TWO 42
 /**
    performs mysql query.
    errors will be logged to the user by this function.
    @return pointer to query handle on success, NULL on failure or if expected_columns=0 (no result set expected)
  */
 distrend_mysql_result_t mysqlQuery(distrend_mysql_conn_t conn, char *query, MYSQL_FIELD_OFFSET expected_columns);
 /**
    frees mysql query result. Accepts a NULL pointer and ignores it to
    help deal with one-shot calls to mysqlQuery so that you don't have to
    check if it returned NULL or not.
    @return 0 on success
  */
 int mysqlResultFree(distrend_mysql_conn_t conn, distrend_mysql_result_t result);
 /**
    reads an integer mysql field value
    @return 0 on success
 */
 int distrend_mysql_getint(MYSQL_ROW row, MYSQL_FIELD_OFFSET column, int32_t *theint)
+{
   if(!row[column])
     return 1;
   *theint = atol(row[column]);
   return 0;
+}
 struct distrend_mysql_conn
+{
   MYSQL *mysqlconn;
   short pointlesscheck;
 };
 struct distrend_mysql_result
+{
   MYSQL_RES *mysqlresult;
   short pointlesscheck;
 };
 /**
     funcs
  */
 int mysqlConnect(distrend_mysql_conn_t *conn, const char *user, const char *host, const char *pass, const char *database)
+{
   MYSQL *mysqlconn;
   my_bool mybool;
   mysqlconn = mysql_init(NULL);
   if(!mysql_real_connect(mysqlconn, host, user, pass, database, 0, NULL, CLIENT_MULTI_STATEMENTS))
+    {
       fprintf(stderr, "%s\n", mysql_error(mysqlconn));
       return 1;
+    }
   /**
      Called after mysql_real_connect() due to bug fixed in MySQL 5.1.6 and later
   */
   mybool = 1;
   mysql_options(mysqlconn, MYSQL_OPT_RECONNECT, (char *)&mybool);
   *conn = malloc(sizeof(struct distrend_mysql_conn));
   if(!*conn)
+    {
       mysql_close(mysqlconn);
       mysql_server_end();
       return 2;
+    }
   (*conn)->mysqlconn = mysqlconn;
   (*conn)->pointlesscheck = SEVENTY_FIVE;

src/server/simpleslave.c

➞

Show inline comments

 /*
   Copyright 2010 Nathan Phillip Brink, Ethan Zonca, Matthew Orlando
   This file is a part of DistRen.
   DistRen is free software: you can redistribute it and/or modify
   it under the terms of the GNU Affero General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.
   DistRen is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU Affero General Public License for more details.
   You should have received a copy of the GNU Affero General Public License
   along with DistRen.  If not, see <http://www.gnu.org/licenses/>.
 */
 #include "common/config.h"
 #include "slavefuncs.h"
 #include "common/asprintf.h"
 #include "common/options.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/stat.h>
 #include <unistd.h>
 #define DEBUG 1
 int main(int argc, char *argv[])
+{
   char *datadir;
   char *server;
   char *username;
   char *password;
   char *hostname;
   multiio_context_t multiio;
   cfg_opt_t myopts[] = {
     CFG_SIMPLE_STR("username", &username),
     CFG_SIMPLE_STR("password", &password),
     CFG_SIMPLE_STR("datadir", &datadir),
     CFG_SIMPLE_STR("server", &server),
     CFG_SIMPLE_STR("hostname", &hostname),
     CFG_END()
   };
   cfg_t * my_cfg;
   struct options_common *commonopts;
   /**
      initializations
   */
   datadir = NULL;
   server = NULL;
   username = NULL;
   password = NULL;
   hostname = NULL;
   char curopt;
   int runBenchmark = 0;
   int updateConf = 0;
   multiio = multiio_context_new();
   while(((char)-1) != (curopt = getopt(argc, argv, "u:p:rh")))
+     {
        if(curopt == ':')
+         {
            fprintf(stderr, "-%c: is missing an argument\n", optopt);
            return 1;
+         }
        else if(curopt == '?')
+         {
            fprintf(stderr, "-%c: invalid option specified\n", optopt);
            return 1;
+         }
        else if(curopt == 'h')
+         {
            fprintf(stderr, "Usage: distrensimpleslave [option] \nStarts a distren slave\n\t-u\tset Slave ID/Username (run after fresh install)\n\t-p\tset Slave Passphrase (run after fresh install)\n\t-r\tRecalculate render power (benchmark)\n\t-h\tshow this help\n");
            return 2;
+         }
        else if(curopt == 'r')
+         {
            runBenchmark = 1;
            break;
+         }
        else if(curopt == 'u'){
          username = strdup(optarg);
          updateConf = 1;
+       }
        else if(curopt == 'p'){
          password = strdup(optarg);
          updateConf = 1;
+       }
+     }
 if(updateConf){
   if(DEBUG)
     fprintf(stderr, "Putting Slave ID \"%s\" and Slave Passphrase \"%s\" in distrenslave.conf\n", username, password);
   if(username != NULL)
     conf_replace("distrenslave.conf", "!username", username);
   if(password != NULL)
     conf_replace("distrenslave.conf", "!password", password);
   fprintf(stderr, "Please invoke distrensimpleslave with no arguments to run with the slave ID and/or passphrase you just set\n");
   return 0;
+}
   /* Get conf data */
  options_init(argc, argv, &my_cfg, myopts, "slave", &commonopts, multiio);

src/server/slave.c

➞

Show inline comments

 /*
   Copyright 2010 Nathan Phillip Brink, Ethan Zonca, Matthew Orlando
   This file is a part of DistRen.
   DistRen is free software: you can redistribute it and/or modify
   it under the terms of the GNU Affero General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.
   DistRen is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU Affero General Public License for more details.
   You should have received a copy of the GNU Affero General Public License
   along with DistRen.  If not, see <http://www.gnu.org/licenses/>.
 */
 #include "common/config.h"
 #include "slavefuncs.h"
 #include "common/asprintf.h"
 #include "common/multiio.h"
 #include "common/options.h"
 #include "common/protocol.h"
 #include "common/remoteio.h"
 #include "common/request.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/stat.h>
 #include <unistd.h>
 #define DEBUG 0
 struct slave_state
+{
   /* whether or not we've gotten past the copyright line */
   short copyright_done;
   /* number of bytes that we need to read before we have a whole packet */
   size_t expectlen;
   /* whether or not we should exit */
   int quit;
   /* the server's remoteio handle */
   struct remoteio *rem;
 };
 static void distren_slave_remoteio_close_handle(void *blah, void *data);
 static size_t distren_slave_remoteio_read_handle(struct remoteio *rem,
 						 void *blah,
 						 void *buf,
 						 size_t len,
 						 void *data);
 int main(int argc, char *argv[])
+{
   multiio_context_t multiio;
   struct slave_state slave_state;
   char *datadir;
   char *server;
   char *username;
   char *password;
   char *hostname;
   cfg_opt_t myopts[] = {
     CFG_SIMPLE_STR("username", &username),
     CFG_SIMPLE_STR("password", &password),
     CFG_SIMPLE_STR("datadir", &datadir),
     CFG_SIMPLE_STR("server", &server),
     CFG_SIMPLE_STR("hostname", &hostname),
     CFG_END()
   };
   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;
   password = NULL;
   hostname = NULL;
   char curopt;
   int runBenchmark = 0;
   multiio = multiio_context_new();
   while(((char)-1) != (curopt = getopt(argc, argv, "u:rh")))
+     {
        if(curopt == ':')
+         {
            fprintf(stderr, "-%c: is missing an argument\n", optopt);
            return 1;
+         }
        else if(curopt == '?')
+         {
            fprintf(stderr, "-%c: invalid option specified\n", optopt);
            return 1;
+         }
        else if(curopt == 'h')
+         {
            fprintf(stderr, "Usage: distrenslave [option] \nStarts a distren slave\n\t-u\tset username (run after fresh install)\n\t-r\tRecalculate render power (benchmark)\n\t-h\tshow this help\n");
            return 2;
+         }
        else if(curopt == 'r')

src/server/slavefuncs.c

➞

Show inline comments

 /*
   Copyright 2010 Nathan Phillip Brink, Ethan Zonca, Matthew Orlando
   This file is a part of DistRen.
   DistRen is free software: you can redistribute it and/or modify
   it under the terms of the GNU Affero General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.
   DistRen is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU Affero General Public License for more details.
   You should have received a copy of the GNU Affero General Public License
   along with DistRen.  If not, see <http://www.gnu.org/licenses/>.
 */
 #include "common/config.h"
 #include "distrenjob.h"
 #include "slavefuncs.h"
 #include "common/asprintf.h"
 #include "common/execio.h"
 #include "common/protocol.h"
 #include "common/remoteio.h"
 #include <curl/curl.h>
 #include <curl/easy.h>
 #include <curl/types.h>
 #include <archive.h>
 #include <archive_entry.h>
 #include <stdio.h>
 #include <string.h>
 #include <unistd.h>
 #include <stdlib.h>
 #include <sys/stat.h>
 #include <fcntl.h>
 #include <time.h>
 #define DEBUG 0
 /**
    Grabs the xml DOM node reached by an XPath.
    @param path an XPath that lead to DOM node
    @return the first node associated with the path or NULL if there is no match
  */
 xmlNodePtr xml_quickxpath(xmlXPathContextPtr xpathctxt, xmlChar *path)
+{
   xmlNodePtr toreturn;
   xmlXPathObjectPtr xmlxpathobjptr;
   xmlxpathobjptr = xmlXPathEval(path, xpathctxt);
   if(!xmlxpathobjptr
      || !xmlxpathobjptr->nodesetval->nodeNr)
+    {
       fprintf(stderr, "XPath resolution failed for ``%s'' in ``%s'' (``%s'')\n", path, xpathctxt->doc->name, xpathctxt->doc->URL);
       return (xmlNodePtr)NULL;
+    }
   toreturn = *(xmlxpathobjptr->nodesetval->nodeTab);
   xmlXPathFreeObject(xmlxpathobjptr);
   return toreturn;
+}
 /** Deletes job data from the disk. @TODO: add error checking! */
 int delete_jobdata(int jobnum, char *datadir)
+{
   char *jobpath;
   char *jobcont;
   _distren_asprintf(&jobpath, "%s/%d", datadir, jobnum);
   _distren_asprintf(&jobcont, "%s/%d/*", datadir, jobnum);
   remove(jobcont);
   rmdir(jobpath);
   fprintf(stderr, "Removed files in %s/%d/ if everything was successful\n", jobpath, jobnum);
   free(jobpath);
   free(jobcont);
   return 0;
+}
 /** Function referenced by curlget() to write data to disk. */
 size_t curl_writetodisk(void *ptr, size_t size, size_t nmemb, FILE *stream)
+ {
     return fwrite(ptr, size, nmemb, stream);
+  }
 /** Helper function for cURL's progress display */
 int curl_progress(char *Bar, double t, double d, double ultotal, double ulnow)
+{
 fprintf(stderr,"Downloading: %f%% complete\r",d/t*100);
 return 0;
+}
 /** Retrieves a URL with cURL and saves it to disk */
 CURLcode curlget(char *url, char *out){
   fprintf(stderr,"Preparing to download %s\n",url);
   double *Bar; // Stores cURL progress display info
   CURL *curl;
   CURLcode res;
   FILE *outfile;
   res = CURLE_FAILED_INIT;
   curl = curl_easy_init();
   if(curl)
+    {
     outfile = fopen(out, "w"); // Open where we're writing to

src/server/tabletennis.c

➞

Show inline comments

 /*
  * Copyright 2010 Nathan Phillip Brink
+ *
  * This file is a part of DistRen.
+ *
  * DistRen is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as published by
  * the Free Software Foundation, either version 3 of the License, or
  * (at your option) any later version.
+ *
  * DistRen is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU Affero General Public License for more details.
+ *
  * You should have received a copy of the GNU Affero General Public License
  * along with DistRen.  If not, see <http://www.gnu.org/licenses/>.
  */
 #include "common/config.h"
 #include "distrend.h"
 #include "listen.h"
 #include "tabletennis.h"
 #include "common/request.h"
 #include "common/protocol.h"
 #include <queue.h>
 #include <stdlib.h>
 #include <string.h>
 #include <time.h>
 struct tabletennis
+{
   unsigned int ping_interval;
   unsigned int pong_time;
   /* of type (struct distrend_client *) */
   queue_t clients_to_ping;
   /* of type (struct distrend_client *) */
   queue_t clients_need_pong;
   struct timespec time_last_check;
 };
 static int tabletennis_pong_request_handle(struct general_info *geninfo, struct distrend_client *client, size_t req_len, void *req_data);
 static int tabletennis_ping_request_handle(struct general_info *geninfo, struct distrend_client *client, size_t req_len, void *req_data);
 tabletennis_t tabletennis_new(struct distrend_listens *listens, unsigned int ping_interval, unsigned int pong_time)
+{
   tabletennis_t tabletennis;
   tabletennis = malloc(sizeof(struct tabletennis));
   tabletennis->ping_interval = ping_interval;
   tabletennis->pong_time = pong_time;
   tabletennis->clients_to_ping = q_init();
   tabletennis->clients_need_pong = q_init();
   clock_gettime(CLOCK_MONOTONIC, &tabletennis->time_last_check);
   distrend_listen_handler_add(listens, DISTREN_REQUEST_PING, &tabletennis_ping_request_handle);
   distrend_listen_handler_add(listens, DISTREN_REQUEST_PONG, &tabletennis_pong_request_handle);
   return tabletennis;
+}
 int tabletennis_add_client(tabletennis_t tabletennis, struct distrend_client *client)
+{
   client->tabletennis_client.state = TABLETENNIS_NEED_PING;
   client->tabletennis_client.time_next_check = tabletennis->time_last_check.tv_sec
     + tabletennis->ping_interval;
   q_enqueue(tabletennis->clients_to_ping, client, 0);
   return 0;
+}
 int tabletennis_serve(tabletennis_t tabletennis)
+{
   struct timespec time_now;
   struct distrend_client *client;
   time_t time_next_check;
   struct distren_request *req;
   void *req_data;
   clock_gettime(CLOCK_MONOTONIC, &time_now);
   time_next_check = time_now.tv_sec + tabletennis->pong_time;
   for(client = q_front(tabletennis->clients_to_ping);
       client && client->tabletennis_client.time_next_check < time_now.tv_sec;
       client = q_front(tabletennis->clients_to_ping))
+    {
       q_dequeue(tabletennis->clients_to_ping);
       /* use time_next_check as the ping data */
       distren_request_poing(&req, &req_data, 1, &time_next_check, sizeof(time_next_check));
       distrend_client_write_request(client, req, req_data);
       distren_request_free_with_data(req, req_data);
       client->tabletennis_client.state = TABLETENNIS_NEED_PONG;
       client->tabletennis_client.time_next_check = time_next_check;
       q_enqueue(tabletennis->clients_need_pong, client, 0);
+    }
   time_next_check = time_now.tv_sec + tabletennis->ping_interval;
   for(client = q_front(tabletennis->clients_need_pong);
       client && client->tabletennis_client.time_next_check < time_now.tv_sec;
       client = q_front(tabletennis->clients_need_pong))
+    {
       q_dequeue(tabletennis->clients_need_pong);
       if(client->tabletennis_client.state == TABLETENNIS_NEED_PONG)

src/server/user_mgr.c

➞

Show inline comments

 /*
   Copyright 2010 Nathan Phillip Brink, Ethan Zonca, Matthew Orlando
   This file is a part of DistRen.
   DistRen is free software: you can redistribute it and/or modify
   it under the terms of the GNU Affero General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.
   DistRen is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU Affero General Public License for more details.
   You should have received a copy of the GNU Affero General Public License
   along with DistRen.  If not, see <http://www.gnu.org/licenses/>.
 */
 #include "common/config.h"
 #include "user_mgr.h"
 #include "common/asprintf.h"
 #include <libxml/xmlmemory.h>
 #include <libxml/parser.h>
 #include <libxml/tree.h>
 #include <libxml/encoding.h>
 #include <libxml/xmlwriter.h>
 #include <libxml/xmlreader.h>
 #include <malloc.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 #include <sys/stat.h>
 struct user_mgr_info
+{
 	struct user *user_array;
 	int current_users;
 	int user_array_size;
 } user_mgr_info;
 int resize_user_array()
+{
 	int counter;
 	int counter2;
 	// create array twice the size of the current amount of users
 	user_mgr_info.user_array_size = user_mgr_info.current_users * 2;
 	struct user *new_user_array = malloc(sizeof(struct user) * user_mgr_info.user_array_size);
 	// this copies the original user_array over to the new one
 	// using two counters allows the array to be resized at any time
 	// leaving exactly 1 open space between each user when it is done;
 	counter2 = 0;
 	for(counter = 0; counter < user_mgr_info.current_users; counter++)
+	{
 		if(user_mgr_info.user_array[counter].username != 0)
+		{
 			new_user_array[counter2*2] = user_mgr_info.user_array[counter];
 			counter2++;
+		}
+	}
 	// cleanup old array
 	free(user_mgr_info.user_array);
 	// change the pointer to point to the new user array
 	user_mgr_info.user_array = new_user_array;
 	return 1;
+}
 struct user *findUser(char *nameOfUser)
+{
 	int high;
 	int low;
 	int middle;
 	int result;
 	high = user_mgr_info.user_array_size - 1;
 	low = 0;
 	result = -1;
 	for(middle = (low+high)/2; 1 == 1; middle = (low+high)/2)
+	{
 		// in case middle lands on a part of the array with no user
 		while(user_mgr_info.user_array[middle].username == 0)
+		{
 			if(result < 0)
 				middle--;
 			else
 				middle++;
+		}
 		// this is where the array is cut in half and the half that the nameOfUser is on is kept
 		result = strcmp(nameOfUser, user_mgr_info.user_array[middle].username);
 		if(result == 0)
 			return &user_mgr_info.user_array[middle];
 		else if(result < 0)
 			high = middle;
 		else
 			low = middle;
 		// in case the user doesn't exist
 		if(high-low <= 0)
 			return 0;
+	}
+}
 int deleteUser(struct user *user_ptr)
+{
 	free(user_ptr->username);
 	memset(user_ptr, '\0', sizeof(struct user));
 	user_mgr_info.current_users--;
 	return 1;
 	backup_list_XML();
+}
 int createUser(struct user *user_ptr, char *nameOfUser)
+{
 	// clear old memory
 	memset(user_ptr, '\0', sizeof(struct user));
 	user_ptr->username = nameOfUser;
 	user_ptr->render_power = 0;
 	user_ptr->last_job = 0;
 	user_mgr_info.current_users++;
 	return 1;
+}
 // places the new user at position index in the array, moves other users if it needs to
 int placeUser(int index, char *nameOfUser)
+{
 	int higher;
 	int lower;
 	int total_moves;
 	total_moves = 0;
 	// I shift data in the array to create an open the space where the user should be added
 	// but first I figure out which way is the shortest
 	if(user_mgr_info.user_array[index].username != 0)
+	{
 		higher = index + 1;
 		while(user_mgr_info.user_array[higher].username != 0)
 			higher++;
 		lower = index - 1;
 		while(user_mgr_info.user_array[lower].username != 0)
 			lower--;
 		// here the data is shifted to open up a space
 		if(index - lower < higher - index)
+		  {
 		    total_moves = index - lower;
 		    for(; lower < index; lower++)
 				memcpy(&user_mgr_info.user_array[lower], &user_mgr_info.user_array[lower + 1], sizeof(struct user));
+		  }
 		else
+		  {
 		    total_moves = higher - index;
 		    for(; higher > index; higher--)
 				memcpy(&user_mgr_info.user_array[higher], &user_mgr_info.user_array[higher - 1], sizeof(struct user));
+		  }
+	}
 	// add the user to the array
 	createUser(&user_mgr_info.user_array[index], nameOfUser);
-	if(total_moves > 50){
 	if(total_moves > 50)
 	  resize_user_array();
+	}
 	return 1;
+}
 int addUser(char *nameOfUser)
+{
 	int high;
 	int low;
 	int middle;
 	int result;
 	high = user_mgr_info.user_array_size - 1;
 	low = 0;
 	result = -1;
 	for(middle = (low+high)/2; 1 == 1; middle = (low+high)/2)
+	{
 		// in case middle lands on a part of the array with no user
 		while(user_mgr_info.user_array[middle].username == 0)
+		{
 			if(result < 0)
 				middle--;
 			else
 				middle++;
+		}
 		// this is where the array is cut in half and the half that the nameOfUser is on is kept
 		result = strcmp(nameOfUser, user_mgr_info.user_array[middle].username);
 		if(result == 0)
 			return 0;
 		else if(result < 0)
 			high = middle;
 		else
 			low = middle;
 		// once there are less than 10 possible places for the user to be placed
 		// break out of this loop and begin next loop
 		if(high-low <= 10)
 			break;
+	}
 	// this function starts at the low index number, and goes up until it finds a
 	// username that is bigger than it alphabetically, and tells the userPlacer
 	// that it needs to go 1 before that spot
 	for(; low <= high; low++)
+	{
 		while(user_mgr_info.user_array[low].username == 0)
 			low++;
 		result = strcmp(nameOfUser, user_mgr_info.user_array[low].username) < 0;
 		if(result < 0)
+		{
 			placeUser(low - 1, nameOfUser);
 			return 1;
+		}
 		if(result == 0)
+		{
 			fprintf(stderr, "user already exists");
 			return 0;
+		}
+	}
 	backup_list_XML();
 	return 0;
+}
 int initialize_users()
+{
   struct stat buffer;
   // cif user_list.xml exists
   if(stat("user_list.xml", &buffer) == 0)
+  {
     restart_From_XML_backup();
+  }
   else
+  {
     user_mgr_info.current_users = 0;
     user_mgr_info.user_array_size = 50;
     user_mgr_info.user_array = malloc(sizeof(struct user) * 50);
+  }
   // if XML file is not found create new array of size 50
   return 1;
+}
 /********************************** XMLness *****************************/
 int backup_list_XML()
+{
 	xmlTextWriterPtr writer;
         char *tmp;
 	int counter;
 	writer = xmlNewTextWriterFilename("user_list.xml", 0);
 	xmlTextWriterStartDocument(writer, NULL, "utf-8", NULL);
 	// create root element user_list
 	xmlTextWriterStartElement(writer, (xmlChar*)"user_list");
 	_distren_asprintf(&tmp, "%d", user_mgr_info.current_users);
 	xmlTextWriterWriteAttribute(writer, (xmlChar*)"amount_of_users", (xmlChar*)tmp);
 	free(tmp);
 	for(counter = 0; counter < user_mgr_info.user_array_size; counter++)
+	{
 		if(user_mgr_info.user_array[counter].username != 0)

0 comments (0 inline, 0 general)