X-Git-Url: http://git.cascardo.eti.br/?a=blobdiff_plain;f=hcconn.c;h=02f15721d5d3b45db226ebd98bd4c69181f000b1;hb=9e01543ef65baeb4e1d477b61391aaef051141e1;hp=5c6e60ea6bf186d28a700f5be3fce807a9519997;hpb=b7dc018999a689010314c3847576cef772fd1d16;p=cascardo%2Frnetproxy.git

diff --git a/hcconn.c b/hcconn.c
index 5c6e60e..02f1572 100644
--- a/hcconn.c
+++ b/hcconn.c
@@ -20,6 +20,10 @@
 #include "hcconn.h"
 #include <unistd.h>
 #include <fcntl.h>
+#include <sys/socket.h>
+#include "hcconn_internal.h"
+
+/* The server connection watch */
 
 struct hc_server_cb
 {
@@ -57,69 +61,105 @@ hc_server_add_watch (int fd,
   cb->channel = g_io_channel_unix_new (fd);
   cb->func = func;
   cb->data = data;
+  /* TODO: we should have some way to remove this watch */
   g_io_add_watch_full (cb->channel, G_PRIORITY_DEFAULT, G_IO_IN,
                        hc_server_watch, cb, hc_server_cb_destroy);
 }
 
-struct _hc_conn_t
+
+/* The IOChannel (simple socket) layer */
+
+struct channel_layer
 {
   GIOChannel *channel;
-  HCClientFunc func;
-  gpointer data;
-  ssize_t (*read) (gpointer, char *, size_t);
-  ssize_t (*write) (gpointer, char *, size_t);
-  void (*close) (gpointer);
-  gpointer layer;
   guint watch;
 };
 
 ssize_t
 hc_conn_channel_read (gpointer data, char *buffer, size_t len)
 {
-  int fd = g_io_channel_unix_get_fd ((GIOChannel *) data);
+  struct channel_layer *layer = data;
+  int fd = g_io_channel_unix_get_fd (layer->channel);
   return read (fd, buffer, len);
 }
 
 ssize_t
 hc_conn_channel_write (gpointer data, char *buffer, size_t len)
 {
-  int fd = g_io_channel_unix_get_fd ((GIOChannel *) data);
+  struct channel_layer *layer = data;
+  int fd = g_io_channel_unix_get_fd (layer->channel);
   return write (fd, buffer, len);
 }
 
 void
 hc_conn_channel_close (gpointer data)
 {
-  int fd = g_io_channel_unix_get_fd ((GIOChannel *) data);
-  shutdown (fd, SHUT_RDWR);
+  struct channel_layer *layer = data;
+  int fd = g_io_channel_unix_get_fd (layer->channel);
+  g_source_remove (layer->watch);
+  close (fd);
+  g_io_channel_unref (layer->channel);
+  g_slice_free (struct channel_layer, layer);
 }
 
 gboolean
 hc_conn_watch (GIOChannel *channel, GIOCondition cond, gpointer data)
 {
   HCConn *conn = data;
-  HCEvent event = HC_EVENT_READ;
+  /* TODO: What about other events, like closing? */
+  HCEvent event;
+  int fd = g_io_channel_unix_get_fd (channel);
+  char buffer;
+  int r;
+  switch (cond)
+    {
+    case G_IO_IN:
+      event = HC_EVENT_READ;
+      r = recv (fd, &buffer, 1, MSG_PEEK);
+      if (r == 0)
+        event = HC_EVENT_CLOSE;
+      break;
+    case G_IO_HUP:
+      event = HC_EVENT_CLOSE;
+      break;
+    default:
+      /* TODO: handle other conditions and create error event */
+      g_warning ("Received an unexpected IO condition.");
+      break;
+    }
   if (conn->func)
     conn->func (conn, event, conn->data);
   return TRUE;
 }
 
-HCConn *
-hc_conn_new (int fd, HCClientFunc func, gpointer data)
+void
+hc_conn_set_driver_channel (HCConn *conn, int fd)
 {
-  HCConn *conn;
-  conn = g_slice_new (HCConn);
-  conn->channel = g_io_channel_unix_new (fd);
-  conn->func = func;
-  conn->data = data;
-  conn->layer = conn->channel;
+  struct channel_layer *layer = g_slice_new (struct channel_layer);
+  layer->channel = g_io_channel_unix_new (fd);
+  conn->layer = layer;
   conn->read = hc_conn_channel_read;
   conn->write = hc_conn_channel_write;
   conn->close = hc_conn_channel_close;
-  conn->watch = g_io_add_watch (conn->channel, G_IO_IN, hc_conn_watch, conn);
+  /* TODO: We must watch other events */
+  layer->watch = g_io_add_watch (layer->channel, G_IO_IN | G_IO_HUP,
+                                 hc_conn_watch, conn);
+  /* TODO: connection should be asynchronous so this could make sense */
   if (conn->func)
     conn->func (conn, HC_EVENT_CONNECT, conn->data);
   fcntl (fd, F_SETFL, fcntl (fd, F_GETFL, 0) | O_NONBLOCK);
+}
+
+
+/* The core connection system */
+
+HCConn *
+hc_conn_new (HCClientFunc func, gpointer data)
+{
+  HCConn *conn;
+  conn = g_slice_new (HCConn);
+  conn->func = func;
+  conn->data = data;
   return conn;
 }
 
@@ -133,21 +173,29 @@ hc_conn_set_callback (HCConn *conn, HCClientFunc func, gpointer data)
 ssize_t
 hc_conn_read (HCConn *conn, char *buffer, size_t len)
 {
-  return conn->read (conn->layer, buffer, len);
+  if (conn->read)
+    return conn->read (conn->layer, buffer, len);
+  return 0;
 }
 
 void
 hc_conn_write (HCConn *conn, char *buffer, size_t len)
 {
   /* TODO: Do buffering or something like that */
-  conn->write (conn->layer, buffer, len);
+  /* Do we really need to? */
+  /* In case of error, we should do something */
+  if (conn->write)
+    conn->write (conn->layer, buffer, len);
 }
 
 void
 hc_conn_close (HCConn *conn)
 {
-  conn->close (conn->layer);
-  g_source_remove (conn->watch);
-  g_io_channel_unref (conn->channel);
+  if (conn->close)
+    conn->close (conn->layer);
+  conn->read = NULL;
+  conn->write = NULL;
+  conn->close = NULL;
+  conn->func = NULL;
   g_slice_free (HCConn, conn);
 }