DistRen Changeset - 00963547e6b9 · protofusion repositories

Changeset - 00963547e6b9

Parent rev.

Child rev.

[Not reviewed]

default

0 1 0

Nathan Brink (binki) - 16 years ago 2009-11-04 20:26:37
ohnobinki@ohnopublishing.net

basic remoteio socket client

1 file changed with 64 insertions and 3 deletions:

src/common/remoteio.c

0 comments (0 inline, 0 general)

src/common/remoteio.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 "libremoteio.h"
 #include "execio.h"
 #include "asprintf.h"
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
 #include <errno.h>
 #ifndef WINDOWS
 #include <sys/socket.h>
 #include <sys/un.h>
 #endif
 /* local */
 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);
 #ifndef WINDOWS
 int _remoteio_sock_open(struct remoteio *rem, struct remoteio_server *server);
 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_close(struct remoteio *rem);
 #endif
 /**
   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 WINDOWS
     {REMOTEIO_METHOD_UNIX, &_remoteio_sock_open, &_remoteio_sock_read, &_remoteio_sock_write, &_remoteio_sock_close, "unix"},
 #endif
     {REMOTEIO_METHOD_MAX, NULL, NULL, NULL, NULL, NULL}
   };
 struct remoteio_server *remoteio_getserver(const struct remoteio_opts *opts, const char *servername);
 int remoteio_config(cfg_t *cfg, struct remoteio_opts *opts)
+{
   size_t numservers;
   size_t counter;
   static int haslisted_methods = 0;
   struct remoteio_server *aserver;
   opts->servers = malloc(sizeof(struct remoteio_server));
@@ @@ -268,65 +269,125 @@ int _remoteio_ssh_close(struct remoteio @@
   return rtn;
+}
 #ifndef WINDOWS
 /*
   local sockets implementation (``named pipes''), unix-only
  */
 int _remoteio_sock_open(struct remoteio *rem, struct remoteio_server *server)
+{
   int sock;
   struct sockaddr_un sockaddr;
   /*
     The POSIX docs pretty much say that I can't depend on sockpath being able to be longer than
     some proprietary length. So, if the compiler specifies a long path for RUNSTATEDIR, it could
     cause a buffer overflow.
    */
   char *sockpath = RUNSTATEDIR "/distrend.sock";
   unsigned int sockaddr_len;
   sock = socket(AF_UNIX, SOCK_STREAM, 0);
   if(sock == -1)
+    {
       perror("socket");
       return 1;
+    }
   sockaddr.sun_family = AF_UNIX;
   /*
     The terminating NULL should not be included in what's copied to sun_path,
     although it won't hurt as long as strlen(sockpath) < max socket length
    */
   for(sockaddr_len = 0; sockpath[sockaddr_len]; sockaddr_len ++)
     sockaddr.sun_path[sockaddr_len] = sockpath[sockaddr_len];
   if(connect(sock, (struct sockaddr *)&sockaddr, sockaddr_len) == -1)
+    {
       perror("connect");
       close(sock);
       return 1;
+    }
   rem->sock = sock;
   return 0;
+}
 int _remoteio_sock_read(struct remoteio *rem, void *buf, size_t len, size_t *bytesread)
+{
   ssize_t readrtn;
   return 1;
   readrtn = read(rem->sock, buf, len);
   /*
     The following is valid for blocking sockets:
    */
   if(readrtn == -1)
+    {
       /*
 	in this case, we may have been interrupted by a signal and errno == EINTR
 	or the connection was reset and errno = ECONNRESET
 	Some of these are not error conditions:
        */
       perror("read");
       *bytesread = 0;
       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)
+{
   ssize_t writertn;
   return 1;
   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;
+    }
   return 0;
+}
 int _remoteio_sock_close(struct remoteio *rem)
+{
   close(rem->sock);
-  return 1;
+  return 0;
+}
 #endif

0 comments (0 inline, 0 general)