DistRen Changeset - 1c075fe042df · protofusion repositories

Changeset - 1c075fe042df

Parent rev.

Child rev.

[Not reviewed]

default

0 2 0

Nathan Brink (binki) - 15 years ago 2010-07-18 20:54:37
ohnobinki@ohnopublishing.net

Fixed one of the stupidest mistakes one could make when using poll(); I used .events where I needed .revents.
Fixed typo in function name: mulitiio_poll_invoke_handlers() -> multiio_poll_invoke_handlers() and small variable initialization cleanup.

2 files changed with 4 insertions and 4 deletions:

src/common/multiio.c

src/common/remoteio.c

0 comments (0 inline, 0 general)

src/common/multiio.c

➞

Show inline comments

@@ @@ -112,129 +112,129 @@ multiio_context_t multiio_context_new() @@
   context->socket_types = NULL;
   if(!context->pollfds
      || !context->socket_infos)
+    {
       free(context->pollfds);
       free(context->socket_infos);
       free(context);
       return NULL;
+    }
   return context;
+}
 int multiio_context_free(multiio_context_t context)
+{
   size_t counter;
   /*
     clean up pollfds and socket_infos
    */
   free(context->pollfds);
   free(context->socket_infos);
   /*
     wipe up the socket_types
    */
   for(counter = 0; counter < context->num_socket_types; counter ++)
     list_free(context->socket_types[counter].type_handlers, LIST_DEALLOC);
   free(context->socket_types);
   /*
     bye!
    */
   free(context);
   return 0;
+}
 struct multiio_poll_travinfo
+{
   multiio_context_t multiio;
   struct multiio_socket_info *socket_info;
   struct pollfd *pollfd;
 };
 /**
    list traverser for multiio_poll()
  */
-int mulitiio_poll_invoke_handlers(struct multiio_poll_travinfo *travinfo, struct multiio_socket_type_handler_info *handler_info)
+int multiio_poll_invoke_handlers(struct multiio_poll_travinfo *travinfo, struct multiio_socket_type_handler_info *handler_info)
+{
   short event;
-  event = travinfo->pollfd->events & handler_info->event;
+  event = travinfo->pollfd->revents & handler_info->event;
   if(!event)
     return TRUE;
   handler_info->handler(travinfo->multiio,
 			travinfo->pollfd->fd,
 			event,
 			handler_info->handler_data,
 			travinfo->socket_info->socket_data);
   return TRUE;
+}
 int multiio_poll(multiio_context_t context)
+{
   size_t counter;
   struct multiio_poll_travinfo travinfo;
   poll(context->pollfds, context->nfds, -1);
   for(counter = 0; counter < context->nfds; counter ++)
     if(context->pollfds[counter].revents)
+      {
 	travinfo.multiio = context;
 	travinfo.socket_info = &context->socket_infos[counter];
 	travinfo.pollfd = &context->pollfds[counter];
 	list_traverse(context->socket_types[context->socket_infos[counter].socket_type].type_handlers,
 		      &travinfo,
-		      (list_traverse_func_t)&mulitiio_poll_invoke_handlers,
+		      (list_traverse_func_t)&multiio_poll_invoke_handlers,
 		      LIST_FRNT | LIST_SAVE);
+      }
   return 0;
+}
 int multiio_socket_type_register(multiio_context_t context, multiio_socket_type_t *new_type)
+{
   struct multiio_socket_type_info *new_socket_types;
   new_socket_types = malloc(sizeof(struct multiio_socket_type_info) * (context->num_socket_types + 1));
   if(!new_socket_types)
     return 1;
   *new_type = context->num_socket_types;
   new_socket_types[*new_type].type_handlers = list_init();
   if(!new_socket_types[*new_type].type_handlers)
+    {
       free(new_socket_types);
       return 2;
+    }
   if(context->num_socket_types)
+    {
       memcpy(new_socket_types, context->socket_types, sizeof(struct multiio_socket_type_info) * context->num_socket_types);
       free(context->socket_types);
+    }
   context->socket_types = new_socket_types;
   context->num_socket_types ++;
   return 0;
+}
 int multiio_event_handler_register(multiio_context_t context, multiio_socket_type_t socket_type, short event, multiio_event_handler_func_t handler_func, void *handler_data)
+{
   struct multiio_socket_type_handler_info handler_info;
   if(socket_type >= context->num_socket_types)
     return 1;
   if(!event)
     return 2;
   handler_info.event = event;
   handler_info.handler = handler_func;
   handler_info.handler_data = handler_data;

src/common/remoteio.c

➞

Show inline comments

@@ @@ -603,110 +603,110 @@ int _remoteio_sock_open(struct remoteio @@
   /*
     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;
+}
 #endif /* _WIN32 */
 int _remoteio_sock_close(struct remoteio *rem)
+{
   close(rem->sock);
   return 0;
+}
 int _remoteio_sock_read(struct remoteio *rem, void *buf, size_t len, size_t *bytesread)
+{
   ssize_t readrtn;
   *bytesread = 0;
   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;
   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;

0 comments (0 inline, 0 general)