X-Git-Url: http://git.cascardo.eti.br/?a=blobdiff_plain;f=gnio%2Fgtcpclient.c;h=479cd008d75c8c72dc38dc71b8cc5954d42fd7af;hb=f1d6db9d7660f921543ec5d8bbd561aceef49a69;hp=599358e08b5c0526050279c56fd235b03322455e;hpb=1c031c7647fc229c3be8fc40a4153aa47d3aea6b;p=cascardo%2Fgnio.git diff --git a/gnio/gtcpclient.c b/gnio/gtcpclient.c index 599358e..479cd00 100644 --- a/gnio/gtcpclient.c +++ b/gnio/gtcpclient.c @@ -24,50 +24,107 @@ #include #include #include -#include +#include #include #include -#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_0, + PROP_ADDRESS, + PROP_HOSTNAME, + PROP_PORT, + PROP_INPUT_STREAM, + PROP_OUTPUT_STREAM }; struct _GTcpClientPrivate { - + GInetSocketAddress *address; + gchar *hostname; + gushort port; + GSocket *socket; + GNetworkInputStream *input; + GNetworkOutputStream *output; }; 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); switch (prop_id) { + case PROP_ADDRESS: + 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; + + case PROP_INPUT_STREAM: + g_value_set_object (value, g_tcp_client_get_input_stream (client)); + break; + + case PROP_OUTPUT_STREAM: + g_value_set_object (value, g_tcp_client_get_output_stream (client)); + 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); } @@ -78,6 +135,8 @@ g_tcp_client_finalize (GObject *object) { 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); } @@ -87,6 +146,8 @@ g_tcp_client_dispose (GObject *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); } @@ -100,21 +161,328 @@ g_tcp_client_class_init (GTcpClientClass *klass) 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_object_class_install_property (gobject_class, PROP_ADDRESS, + g_param_spec_object ("address", + "address", + "the remote address the socket will connect to", + 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)); + + g_object_class_install_property (gobject_class, PROP_INPUT_STREAM, + g_param_spec_object ("input-stream", + "input stream", + "the GNetworkInputStream for reading from this socket", + G_TYPE_NETWORK_INPUT_STREAM, + G_PARAM_READABLE | G_PARAM_STATIC_NAME | G_PARAM_STATIC_BLURB | G_PARAM_STATIC_NICK)); + + g_object_class_install_property (gobject_class, PROP_OUTPUT_STREAM, + g_param_spec_object ("output-stream", + "output stream", + "the GNetworkOutputStream for writing to this socket", + G_TYPE_NETWORK_OUTPUT_STREAM, + G_PARAM_READABLE | 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; + client->priv->input = NULL; + client->priv->output = NULL; +} + +GTcpClient * +g_tcp_client_new (const gchar *hostname, + gushort port) +{ + return G_TCP_CLIENT (g_object_new (G_TYPE_TCP_CLIENT, "hostname", hostname, "port", port, NULL)); } GTcpClient * -g_tcp_client_new (GInetSocketAddress *address, - GError **error) +g_tcp_client_new_from_address (GInetSocketAddress *address) +{ + return G_TCP_CLIENT (g_object_new (G_TYPE_TCP_CLIENT, "address", address, NULL)); +} + +GNetworkInputStream * +g_tcp_client_get_input_stream (GTcpClient *client) +{ + if (!client->priv->socket) + return NULL; + + if (client->priv->input) + return client->priv->input; + + // TODO: should we set g_object_notify here, or just create both these streams earlier? + + return (client->priv->input = _g_network_input_stream_new (client->priv->socket)); +} + +GNetworkOutputStream * +g_tcp_client_get_output_stream (GTcpClient *client) +{ + if (!client->priv->socket) + return NULL; + + if (client->priv->output) + return client->priv->output; + + // TODO: should we set g_object_notify here, or just create both these streams earlier? + + return (client->priv->output = _g_network_output_stream_new (client->priv->socket)); +} + +gboolean +g_tcp_client_connect (GTcpClient *client, + GCancellable *cancellable, + GError **error) +{ + 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; + GTcpClient *client; +} ConnectData; + +static gboolean +connect_callback (ConnectData *data, + GIOCondition condition, + gint fd) +{ + GTcpClient *client; + GSimpleAsyncResult *result; + GError *error = NULL; + + client = data->client; + + if (condition & G_IO_OUT) + { + result = g_simple_async_result_new (G_OBJECT (client), data->callback, data->user_data, g_tcp_client_connect_async); + } + else + { + if (!g_socket_has_socket_error (client->priv->socket, &error)) + g_warning ("got G_IO_ERR but socket does not have error"); + + result = g_simple_async_result_new_from_error (G_OBJECT (client), data->callback, data->user_data, error); + } + + g_simple_async_result_complete (result); + + g_object_unref (result); + + return FALSE; +} + +static void +resolve_callback (GObject *source, + GAsyncResult *result, + gpointer user_data) +{ + ConnectData *data = (ConnectData *) user_data; + GInetAddress *address; + GSimpleAsyncResult *error_result; + GError *error = NULL; + + address = g_resolver_resolve_finish (G_RESOLVER (source), result, &error); + + g_object_unref (G_RESOLVER (source)); + + if (!address) + { + error_result = g_simple_async_result_new_from_error (G_OBJECT (data->client), data->callback, data->user_data, error); + + g_simple_async_result_complete (error_result); + + g_object_unref (error_result); + } + else + { + data->client->priv->address = g_inet_socket_address_new (address, data->client->priv->port); + + g_object_ref_sink (data->client->priv->address); + + // at this point, the address has been resolved, so connect_async again + g_tcp_client_connect_async (data->client, data->cancellable, data->callback, data->user_data); + } + + g_free (data); +} + +void +g_tcp_client_connect_async (GTcpClient *client, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data) +{ + GInetAddress *address; + GSimpleAsyncResult *result; + GSource *source; + ConnectData *data; + GError *error = NULL; + + g_return_if_fail (G_IS_TCP_CLIENT (client)); + + if (!client->priv->address) + { + // we've been constructed with just hostname+port, resolve + GResolver *resolver = g_resolver_new (); + + data = g_new (ConnectData, 1); + + data->client = client; + data->callback = callback; + data->cancellable = cancellable; + data->user_data = user_data; + + g_resolver_resolve_async (resolver, client->priv->hostname, cancellable, resolve_callback, data); + + return; + } + + 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_simple_async_report_error_in_idle (G_OBJECT (client), callback, user_data, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED, "unsupported address domain"); + return; + } + + if (!client->priv->socket) + { + g_simple_async_report_gerror_in_idle (G_OBJECT (client), callback, user_data, error); + return; + } + + g_socket_set_blocking (client->priv->socket, FALSE); + + if (!g_socket_connect (client->priv->socket, G_SOCKET_ADDRESS (client->priv->address), &error)) + { + if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_PENDING)) + { + // the connection is in progress + source = g_socket_create_source (client->priv->socket, G_IO_OUT | G_IO_ERR | G_IO_HUP, cancellable); + + data = g_new (ConnectData, 1); + + data->client = client; + data->callback = callback; + data->cancellable = cancellable; + data->user_data = user_data; + + g_source_set_callback (source, (GSourceFunc) connect_callback, data, g_free); + + g_source_attach (source, NULL); + } + else + { + g_simple_async_report_gerror_in_idle (G_OBJECT (client), callback, user_data, error); + } + } + else + { + // the connection is already completed + result = g_simple_async_result_new (G_OBJECT (client), callback, user_data, g_tcp_client_connect_async); + + g_simple_async_result_complete_in_idle (result); + + g_object_unref (result); + } +} + +gboolean +g_tcp_client_connect_finish (GTcpClient *client, + GAsyncResult *result, + GError **error) { - return NULL; + GSimpleAsyncResult *simple; + + 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_tcp_client_connect_async); + + return TRUE; } void