Some more socket stuff

[cascardo/gnio.git] / gnio / gsocket.c

diff --git a/gnio/gsocket.c b/gnio/gsocket.c
index f6c586e..6c045c2 100644 (file)
--- a/gnio/gsocket.c
+++ b/gnio/gsocket.c
@@ -33,6 +33,7 @@
 # include <netdb.h>
 # include <fcntl.h>
 # include <unistd.h>
+# include <sys/types.h>
 #else
 
 #endif
@@ -214,7 +215,7 @@ GSocketAddress *
 g_socket_get_peer_address (GSocket  *socket,
                            GError  **error)
 {
-  gchar buffer[128];
+  gchar buffer[256];
   gsize len;
 
   g_return_val_if_fail (G_IS_SOCKET (socket), NULL);
@@ -245,7 +246,7 @@ g_socket_bind (GSocket         *socket,
   g_return_val_if_fail (G_IS_SOCKET (socket) && G_IS_SOCKET_ADDRESS (address), FALSE);
 
   {
-    gchar addr[g_socket_address_native_size (address)];
+    gchar addr[256];
 
     if (!g_socket_address_to_native (address, addr))
       return FALSE;
@@ -370,6 +371,8 @@ g_socket_accept_async (GSocket             *socket,
     {
       result = g_simple_async_result_new (G_OBJECT (socket), callback, user_data, g_socket_accept_async);
 
+      g_simple_async_result_set_op_res_gpointer (result, g_socket_new_from_fd (ret), g_object_unref);
+
       g_simple_async_result_complete_in_idle (result);
 
       g_object_unref (result);
@@ -388,6 +391,9 @@ g_socket_accept_finish (GSocket       *socket,
 
   simple = G_SIMPLE_ASYNC_RESULT (result);
 
+  if (g_simple_async_result_propagate_error (simple, error))
+    return NULL;
+
   g_warn_if_fail (g_simple_async_result_get_source_tag (simple) == g_socket_accept_async);
 
   new_socket = g_object_ref (g_simple_async_result_get_op_res_gpointer (simple));
@@ -401,9 +407,13 @@ g_socket_connect (GSocket         *socket,
                   GCancellable    *cancellable,
                   GError         **error)
 {
-  g_return_val_if_fail (G_IS_SOCKET (socket), FALSE);
-/*
-  if (connect () < 0)
+  gchar buffer[256];
+
+  g_return_val_if_fail (G_IS_SOCKET (socket) && G_IS_SOCKET_ADDRESS (address), FALSE);
+
+  g_socket_address_to_native (address, buffer);
+
+  if (connect (socket->priv->fd, (struct sockaddr *) buffer, g_socket_address_native_size (address)) < 0)
     {
       if (errno == EINPROGRESS)
         g_set_error (error, G_IO_ERROR, G_IO_ERROR_PENDING, "connection in progress");
@@ -411,18 +421,108 @@ g_socket_connect (GSocket         *socket,
         g_set_error (error, G_IO_ERROR, g_io_error_from_errno (errno), "error connecting: %s", g_strerror (errno));
       return FALSE;
     }
-*/
+
   return TRUE;
 }
 
+typedef struct {
+  GAsyncReadyCallback callback;
+  GCancellable *cancellable;
+  gpointer user_data;
+  GSocket *socket;
+  gchar address_buffer[256];
+  gsize address_length;
+} ConnectData;
+
+static gboolean
+connect_callback (ConnectData *data,
+                  GIOCondition condition,
+                  gint fd)
+{
+  GSocket *socket;
+  GSimpleAsyncResult *result = NULL;
+  guint sockerr;
+  gsize sockerr_size = 1;
+
+  socket = data->socket;
+
+  if (condition & G_IO_OUT)
+    {
+      result = g_simple_async_result_new (G_OBJECT (socket), data->callback, data->user_data, g_socket_connect_async);
+    }
+  else if (condition & G_IO_ERR)
+    {
+      if (getsockopt (socket->priv->fd, SOL_SOCKET, SO_ERROR, (gpointer) &sockerr, &sockerr_size) < 0)
+        g_warning ("getsockopt: %s", g_strerror (errno));
+
+      if (sockerr != 0)
+        result = g_simple_async_result_new_error (G_OBJECT (socket), data->callback, data->user_data, G_IO_ERROR, g_io_error_from_errno (sockerr), "error connecting: %s", g_strerror (sockerr));
+      else
+        g_warning ("getsockopt SO_ERROR returned no error, with sockerr = %d", sockerr);
+    }
+
+  g_simple_async_result_complete (result);
+
+  g_object_unref (result);
+
+  return FALSE;
+}
+
 void
 g_socket_connect_async (GSocket             *socket,
                         GSocketAddress      *address,
                         GCancellable        *cancellable,
-                        GAsyncReadyCallback *callback,
+                        GAsyncReadyCallback  callback,
                         gpointer             user_data)
 {
+  GSource *source;
+  GSimpleAsyncResult *result;
+  ConnectData *data;
+  gint ret;
+  gchar buffer[256];
+  gsize len;
 
+  g_return_if_fail (G_IS_SOCKET (socket) && G_IS_SOCKET_ADDRESS (address));
+
+  if (g_socket_get_blocking (socket))
+    g_socket_set_blocking (socket, FALSE);
+
+  g_socket_address_to_native (address, buffer);
+
+  len = g_socket_address_native_size (address);
+
+  if ((ret = connect (socket->priv->fd, (struct sockaddr *) buffer, len)) < 0)
+    {
+      if (errno == EINPROGRESS)
+        {
+          source = _g_fd_source_new (socket->priv->fd, G_IO_OUT | G_IO_ERR, cancellable);
+
+          data = g_new (ConnectData, 1);
+
+          data->socket = socket;
+          data->callback = callback;
+          data->cancellable = cancellable;
+          data->user_data = user_data;
+          data->address_length = len;
+          memcpy (data->address_buffer, buffer, len);
+
+          g_source_set_callback (source, (GSourceFunc) connect_callback, data, g_free);
+
+          g_source_attach (source, NULL);
+        }
+      else
+        {
+          g_simple_async_report_error_in_idle (G_OBJECT (socket), callback, user_data, G_IO_ERROR, g_io_error_from_errno (errno), "error connecting: %s", g_strerror (errno));
+        }
+    }
+  else
+    {
+      result = g_simple_async_result_new (G_OBJECT (socket), callback, user_data, g_socket_connect_async);
+
+      g_simple_async_result_complete_in_idle (result);
+
+      g_object_unref (result);
+    }
 }
 
 gboolean
@@ -430,5 +530,16 @@ g_socket_connect_finish (GSocket       *socket,
                          GAsyncResult  *result,
                          GError       **error)
 {
-  return FALSE;
+  GSimpleAsyncResult *simple;
+
+  g_return_val_if_fail (G_IS_SOCKET (socket), FALSE);
+
+  simple = G_SIMPLE_ASYNC_RESULT (result);
+
+  if (g_simple_async_result_propagate_error (simple, error))
+    return FALSE;
+
+  g_warn_if_fail (g_simple_async_result_get_source_tag (simple) == g_socket_connect_async);
+
+  return TRUE;
 }