#include <config.h>
#include <glib.h>
#include <gio/gio.h>
-#include <gio/gasynchelper.h>
+#include <gnio/gnio.h>
#include <string.h>
#include <errno.h>
-#include "ginetaddress.h"
-#include "ginet4address.h"
-#include "ginet6address.h"
-#include "gsocket.h"
-#include "gtcpclient.h"
-#include "gnioerror.h"
-#include "ginetsocketaddress.h"
-
G_DEFINE_TYPE (GTcpClient, g_tcp_client, G_TYPE_OBJECT);
enum
{
PROP_0,
- PROP_ADDRESS
+ PROP_ADDRESS,
+ PROP_HOSTNAME,
+ PROP_PORT
};
struct _GTcpClientPrivate
{
- GSocketAddress *address;
+ GInetSocketAddress *address;
+ gchar *hostname;
+ gushort port;
+ GSocket *socket;
};
static void
-g_tcp_client_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
+g_tcp_client_constructed (GObject *object)
+{
+ GTcpClient *client = G_TCP_CLIENT (object);
+
+ if (client->priv->address)
+ {
+ // we've been constructed with an address, extract hostname+port
+ client->priv->hostname = g_inet_address_to_string (g_inet_socket_address_get_address (client->priv->address));
+ client->priv->port = g_inet_socket_address_get_port (client->priv->address);
+ return;
+ }
+}
+
+static void
+g_tcp_client_get_property (GObject *object,
+ guint prop_id,
+ GValue *value,
+ GParamSpec *pspec)
{
GTcpClient *client = G_TCP_CLIENT (object);
g_value_set_object (value, client->priv->address);
break;
+ case PROP_HOSTNAME:
+ g_value_set_string (value, client->priv->hostname);
+ break;
+
+ case PROP_PORT:
+ g_value_set_uint (value, client->priv->port);
+ break;
+
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
}
}
static void
-g_tcp_client_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec)
+g_tcp_client_set_property (GObject *object,
+ guint prop_id,
+ const GValue *value,
+ GParamSpec *pspec)
{
GTcpClient *client = G_TCP_CLIENT (object);
switch (prop_id)
{
+ case PROP_ADDRESS:
+ // sink the address' floating reference
+ client->priv->address = G_INET_SOCKET_ADDRESS (g_value_get_object (value));
+ if (client->priv->address)
+ g_object_ref_sink (client->priv->address);
+ break;
+
+ case PROP_HOSTNAME:
+ client->priv->hostname = g_value_dup_string (value);
+ break;
+
+ case PROP_PORT:
+ client->priv->port = g_value_get_uint (value);
+ break;
+
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
}
{
GTcpClient *client = G_TCP_CLIENT (object);
+ g_object_unref (client->priv->address);
+
if (G_OBJECT_CLASS (g_tcp_client_parent_class)->finalize)
(*G_OBJECT_CLASS (g_tcp_client_parent_class)->finalize) (object);
}
{
GTcpClient *client = G_TCP_CLIENT (object);
+ g_free (client->priv->hostname);
+
if (G_OBJECT_CLASS (g_tcp_client_parent_class)->dispose)
(*G_OBJECT_CLASS (g_tcp_client_parent_class)->dispose) (object);
}
gobject_class->finalize = g_tcp_client_finalize;
gobject_class->dispose = g_tcp_client_dispose;
+ gobject_class->constructed = g_tcp_client_constructed;
gobject_class->set_property = g_tcp_client_set_property;
gobject_class->get_property = g_tcp_client_get_property;
g_param_spec_object ("address",
"address",
"the remote address the socket will connect to",
- G_TYPE_SOCKET_ADDRESS,
- G_TYPE_CONSTRUCT_ONLY | G_PARAM_READABLE | G_PARAM_STATIC_NAME | G_PARAM_STATIC_BLURB | G_PARAM_STATIC_NICK));
+ G_TYPE_INET_SOCKET_ADDRESS,
+ G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE | G_PARAM_STATIC_NAME | G_PARAM_STATIC_BLURB | G_PARAM_STATIC_NICK));
+
+ g_object_class_install_property (gobject_class, PROP_HOSTNAME,
+ g_param_spec_string ("hostname",
+ "hostname",
+ "the hostname of the remote address the socket will connect to",
+ NULL,
+ G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE | G_PARAM_STATIC_NAME | G_PARAM_STATIC_BLURB | G_PARAM_STATIC_NICK));
+
+ g_object_class_install_property (gobject_class, PROP_PORT,
+ g_param_spec_uint ("port",
+ "port",
+ "the remote port the socket will connect to",
+ 0,
+ G_MAXUSHORT,
+ 0,
+ G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE | G_PARAM_STATIC_NAME | G_PARAM_STATIC_BLURB | G_PARAM_STATIC_NICK));
}
static void
g_tcp_client_init (GTcpClient *client)
{
client->priv = G_TYPE_INSTANCE_GET_PRIVATE (client, G_TYPE_TCP_CLIENT, GTcpClientPrivate);
+
+ client->priv->address = NULL;
+ client->priv->hostname = NULL;
+ client->priv->port = 0;
+ client->priv->socket = NULL;
}
GTcpClient *
-g_tcp_client_new (GInetSocketAddress *address,
- GError **error)
+g_tcp_client_new (const gchar *hostname,
+ gushort port)
{
- return NULL;
+ return G_TCP_CLIENT (g_object_new (G_TYPE_TCP_CLIENT, "hostname", hostname, "port", port, NULL));
+}
+
+GTcpClient *
+g_tcp_client_new_from_address (GInetSocketAddress *address)
+{
+ return G_TCP_CLIENT (g_object_new (G_TYPE_TCP_CLIENT, "address", address, NULL));
}
gboolean
-g_tcp_client_connect (GTcpClient *client,
- GError **error)
+g_tcp_client_connect (GTcpClient *client,
+ GCancellable *cancellable,
+ GError **error)
{
- return FALSE;
+ GInetAddress *address;
+
+ g_return_val_if_fail (G_IS_TCP_CLIENT (client), FALSE);
+
+ if (!client->priv->address)
+ {
+ // we've been constructed with just hostname+port, resolve
+ GResolver *resolver = g_resolver_new ();
+
+ address = g_resolver_resolve (resolver, client->priv->hostname, cancellable, error);
+
+ if (!address)
+ return FALSE;
+
+ client->priv->address = g_inet_socket_address_new (address, client->priv->port);
+
+ g_object_unref (resolver);
+
+ g_object_ref_sink (client->priv->address);
+ }
+ else
+ {
+ address = g_inet_socket_address_get_address (client->priv->address);
+ }
+
+ if (G_IS_INET4_ADDRESS (address))
+ client->priv->socket = g_socket_new (G_SOCKET_DOMAIN_INET, G_SOCKET_TYPE_STREAM, NULL);
+ else if (G_IS_INET6_ADDRESS (address))
+ client->priv->socket = g_socket_new (G_SOCKET_DOMAIN_INET6, G_SOCKET_TYPE_STREAM, NULL);
+ else
+ {
+ g_set_error (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED, "unsupported address domain");
+ return FALSE;
+ }
+
+ if (g_socket_has_error (client->priv->socket, error))
+ return FALSE;
+
+ if (g_cancellable_set_error_if_cancelled (cancellable, error))
+ return FALSE;
+
+ if (!g_socket_connect (client->priv->socket, G_SOCKET_ADDRESS (client->priv->address), error))
+ return FALSE;
+
+ return TRUE;
}
typedef struct {
GAsyncReadyCallback callback;
GCancellable *cancellable;
gpointer user_data;
- GSocket *socket;
+ GTcpClient *client;
gchar address_buffer[256];
gsize address_length;
} ConnectData;
GIOCondition condition,
gint fd)
{
- GSocket *socket;
- GSimpleAsyncResult *result = NULL;
- gint sockerr = 0;
- 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 (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 (GTcpClient *client,
- GCancellable *cancellable,
- GAsyncReadyCallback callback,
- gpointer user_data)
+g_tcp_client_connect_async (GTcpClient *client,
+ GCancellable *cancellable,
+ 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
-g_socket_connect_finish (GSocket *socket,
- GAsyncResult *result,
- GError **error)
+g_tcp_client_connect_finish (GTcpClient *client,
+ GAsyncResult *result,
+ GError **error)
{
GSimpleAsyncResult *simple;
- g_return_val_if_fail (G_IS_SOCKET (socket), FALSE);
+ g_return_val_if_fail (G_IS_TCP_CLIENT (client), 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);
+ g_warn_if_fail (g_simple_async_result_get_source_tag (simple) == g_tcp_client_connect_async);
return TRUE;
}
projects / cascardo / gnio.git / blobdiff