DistRen Changeset - 00afcd810c9b · protofusion repositories

Changeset - 00afcd810c9b

Parent rev.

Child rev.

[Not reviewed]

Merge default

0 5 0

Nathan Brink (binki) - 15 years ago 2010-07-29 21:28:47
ohnobinki@ohnopublishing.net

merge

5 files changed with 22 insertions and 13 deletions:

src/common/execio.c

src/common/execio.h

src/common/libremoteio.h

src/common/remoteio.c

src/common/remoteio.h

0 comments (0 inline, 0 general)

src/common/execio.c

➞

Show inline comments

@@ @@ -144,87 +144,87 @@ int execio_open(struct execio **rem, con @@
       fprintf(stderr, "uh-oh, ``%s'' didn't start for execio\n", progname);
       exit(1);
+    }
+}
 /*
   returns 1 if child has exited,
   returns 0 if child is still alive
  */
 int _execio_checkpid(struct execio *eio)
+{
   int childstatus;
 #ifdef _WIN32
   waitpid(eio->child, &childstatus, 0);
 #else
   waitpid(eio->child, &childstatus, WNOHANG);
 #endif
   /* perror()? */
   return WIFEXITED(childstatus);
+}
 int execio_read(struct execio *eio, void *buf, size_t len, size_t *bytesread)
+int execio_read(struct execio *eio, const void *buf, size_t len, size_t *bytesread)
+{
   ssize_t ret;
   /*
     TODO: detect NULL eio?
     TODO: errno?
     update status of eio for execio_status/to be able to cleanup subproc??
     whenever read() returns 0, it means EOF
    */
   ret = read(eio->pipe_read, buf, len);
   if(ret == -1)
+    {
       (*bytesread) = 0;
       perror("read");
       switch(errno)
+	{
 	case EAGAIN:
 	case EINTR:
 	  return 0;
 	  break;
 	default:
 	  return 1;
+	}
+    }
   (*bytesread) = (size_t)ret;
   if(!ret)
+    {
       /* should also be able to figure out if is bad fd and should set EXECIO_STATE_ERROR instead of _EOF */
       eio->state = EXECIO_STATE_EOF;
       return 1;
+    }
   return 0;
+}
 int execio_write(struct execio *eio, void *buf, size_t len, size_t *bytesread)
+int execio_write(struct execio *eio, const void *buf, size_t len, size_t *bytesread)
+{
   errno = 0;
   (*bytesread) = write(eio->pipe_write, buf, len);
   if(!*bytesread)
+    {
       switch(errno)
+	{
 	case EPIPE:
 	  /*
 	     the program closed the pipe (died)
 	  */
 	fprintf(stderr, "execio_write: the child program closed its stdin pipe\n");
 	eio->state = EXECIO_STATE_EOF;
 	break;
 	default:
 	  fprintf(stderr, "execio_write: unhandled error writing to an fd: \n");
 	  perror("write");
 	  eio->state = EXECIO_STATE_ERROR;
 	  break;
+	}
       return 1;

src/common/execio.h

➞

Show inline comments

@@ @@ -33,42 +33,42 @@ enum execio_state @@
   };
 struct execio
+{
   int pipe_write;
   int pipe_read;
   enum execio_state state;
   pid_t child;
 };
 /**
   runs progname with the arguments in argv. argv must be null terminated!!!!!!!!!
   returns nonzero return on error
 */
 int execio_open(struct execio **eio, const char *progname, char *const argv[]);
 /**
    doesn't block,
    returns 0 on success, 1 on failure
 */
 int execio_read(struct execio *eio, void *buf, size_t len, size_t *bytesread);
 int execio_write(struct execio *eio, void *buf, size_t len, size_t *byteswritten);
 int execio_read(struct execio *eio, const void *buf, size_t len, size_t *bytesread);
 int execio_write(struct execio *eio, const void *buf, size_t len, size_t *byteswritten);
 /**
   use this function to determine if the using program should keep trying to read/write
   @todo is this function good enough/necessary?
  */
 enum execio_state execio_state(struct execio *eio);
 /**
    Closes an execio session.
    @return nonzero on error
 */
 int execio_close(struct execio *eio);
 #endif

src/common/libremoteio.h

➞

Show inline comments

@@ @@ -96,42 +96,42 @@ struct remoteio @@
   /**
    * Store a buffer of data waiting to be processed.
    */
   struct remoteio_packet inbuf;
   /**
    * Provide the asynchronosity abstraction by queuing outgoing messages.
    */
   queue_t outmsgs;
   /**
    * This is disappointingly hacky. If this variable is 0, then
    * remoteio_close() will act normal. If set to 1, then
    * remoteio_close() will not actually free this struct but instead
    * increment this variable to 2. This is so that read_handler can
    * call remoteio_close() without segfaulting us.
    */
   short careful_free;
 };
 /* lookup table */
 typedef int remoteio_open_func_t(struct remoteio *rem, struct remoteio_server *server);
 typedef int remoteio_read_func_t(struct remoteio *rem, void *buf, size_t len, size_t *bytesread);
 typedef int remoteio_write_func_t(struct remoteio *rem, void *buf, size_t len, size_t *bytesread);
+typedef int remoteio_write_func_t(struct remoteio *rem, const void *buf, size_t len, size_t *bytesread);
 typedef int remoteio_close_func_t(struct remoteio *rem);
 struct remoteio_method_funcmap
+{
   enum remoteio_method method;
   remoteio_open_func_t *open_func;
   remoteio_read_func_t *read_func;
   remoteio_write_func_t *write_func;
   remoteio_close_func_t *close_func;
   char *name; /*< used for error messages */
 };
 int remoteio_config(cfg_t *cfg, struct remoteio_opts *opts);
 #endif

src/common/remoteio.c

➞

Show inline comments

@@ @@ -44,60 +44,60 @@ @@
 #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_write(struct remoteio *rem, const 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);
+int _remoteio_sock_write(struct remoteio *rem, const 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}
   };
@@ @@ -340,66 +340,67 @@ int _remoteio_handle_read(multiio_contex @@
    * 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;
   size_t bytes_written;
   int err;
   /**
    * 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 = POLLOUT;
       pollfd.events = 0;
       poll(&pollfd, 1, 0);
       if(pollfd.events & POLLOUT)
+	{
-	  bytes_written = write(rem->sock, buf, len);
+	  err = funcmap[rem->method].write_func(rem, buf, len, &bytes_written);
 	  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);
@@ @@ -523,90 +524,92 @@ void remoteio_packet_free(struct remotei @@
 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;
+}
 size_t remoteio_sendq_len(const struct remoteio *rem)
+{
   return (size_t)q_size(rem->outmsgs);
+}
 /**
    different remoteio methods' implementations:
  */
 /*
   SSH, via execio
 */
 int _remoteio_ssh_open(struct remoteio *rem, struct remoteio_server *server)
+{
   char *userhost;
   char *sshargs[] = {rem->opts->ssh_command, NULL /* userhost */, "distrend", "-d", (char *)NULL};
   int rtn;
   if(server->username)
     _distren_asprintf(&userhost, "%s@%s", server->username, server->hostname);
   else
     userhost = strdup(server->hostname);
   sshargs[1] = userhost;
   rtn = execio_open( &rem->execio, "ssh", sshargs);
   if(rtn)
+    {
       fprintf(stderr, "error opening remoteio channel to ssh userhost ``%s''\n" , userhost);
       free(userhost);
       return 1;
+    }
   free(userhost);
   return 0;
+}
 int _remoteio_ssh_read(struct remoteio *rem, void *buf, size_t len, size_t *bytesread)
+{
   return execio_read(rem->execio, buf, len, bytesread);
+}
 int _remoteio_ssh_write(struct remoteio *rem, void *buf, size_t len, size_t *byteswritten)
+int _remoteio_ssh_write(struct remoteio *rem, const void *buf, size_t len, size_t *byteswritten)
+{
   return execio_write(rem->execio, buf, len, byteswritten);
+}
 int _remoteio_ssh_close(struct remoteio *rem)
+{
   int rtn;
   rtn = execio_close(rem->execio);
   if(rtn)
     fprintf(stderr, "%s:%d: error closing execio\n", __FILE__, __LINE__);
   return rtn;
+}
 #ifndef _WIN32
 /*
   local sockets implementation (``named pipes''), unix-only
  */
 int _remoteio_sock_open(struct remoteio *rem, struct remoteio_server *server)
+{
   int sock;
   struct sockaddr_un sockaddr;
@@ @@ -674,49 +677,49 @@ int _remoteio_sock_read(struct remoteio @@
       perror("read");
       if(errno != EINTR)
+	{
 	  fprintf(stderr, "error reading socket in remoteio_sock_read\n");
 	  return 1;
+	}
       return 0;
+    }
   *bytesread = readrtn;
   if(!readrtn)
+    {
       /*
 	means EOF except when FD is in ``message-nondiscard'' or ``message-discard''
 	modes.
        */
       return 1;
+    }
   return 0;
+}
 int _remoteio_sock_write(struct remoteio *rem, void *buf, size_t len, size_t *byteswritten)
+int _remoteio_sock_write(struct remoteio *rem, const void *buf, size_t len, size_t *byteswritten)
+{
   ssize_t writertn;
   writertn = write(rem->sock, buf, len);
   if(writertn == -1)
+    {
       perror("write");
       if(errno != EINTR)
+	{
 	  fprintf(stderr, "error writing to socket in remoteio_sock_write()\n");
 	  return 1;
+	}
+    }
   *byteswritten = writertn;
   if(!writertn)
+    {
       /*
 	should we consider this an error? I'm pretty
 	sure we should :-/
        */
       fprintf(stderr, "write() returned 0 in remoteio_sock_write()\n");
       return 1;

src/common/remoteio.h

➞

Show inline comments

@@ @@ -108,25 +108,31 @@ int remoteio_open_socket(struct remoteio @@
 			 void *read_handler_data,
 			 remoteio_close_handle_func_t close_handler,
 			 int fd);
 /**
  * Queue bytes to be written to the remote host.
+ *
  * @param rem the remoteio handle
  * @param buf a buffer to be queued for writing. We will copy this, so the caller has to handle its memory (and free() it if necessary).
  * @param len number of bytes to grab from buf
  * @return 0 on success, 1 on failure
  */
 int remoteio_write(struct remoteio *rem, const void *buf, size_t len);
 /**
  * Closes a remoteio session.
+ *
  * It is safe to call this function from within
  * remoteio_read_handle_func_t.
+ *
  * @return nonzero on error
 */
 int remoteio_close(struct remoteio *rem);
 /**
  * Returns the number of unfulfilled remoteio_write() calls pending on
  * a remoteio handle.
  */
 size_t remoteio_sendq_len(const struct remoteio *rem);
 #endif

0 comments (0 inline, 0 general)