X-Git-Url: http://git.cascardo.info/?a=blobdiff_plain;f=gnio%2Fgsocket.c;h=605f92b4ede8580cfedce1c51da780e47240a727;hb=48aa363fffb042f947130762acc7cd3c787b11d9;hp=9a61e1136cac9219ee717f90ff6f08d5dd7d230d;hpb=ce2943ed9b80f86ca8d49dea8207634785eef69c;p=cascardo%2Fgnio.git diff --git a/gnio/gsocket.c b/gnio/gsocket.c index 9a61e11..605f92b 100644 --- a/gnio/gsocket.c +++ b/gnio/gsocket.c @@ -33,6 +33,7 @@ # include # include # include +# include #else #endif @@ -51,17 +52,28 @@ enum { PROP_0, PROP_FD, - PROP_BLOCKING + PROP_BLOCKING, + PROP_BACKLOG, + PROP_REUSE_ADDRESS, + PROP_LOCAL_ADDRESS, + PROP_REMOTE_ADDRESS }; struct _GSocketPrivate { gint fd; gboolean blocking; + gint backlog; + gboolean reuse_address; + GSocketAddress *local_address; + GSocketAddress *remote_address; }; static void -g_socket_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec) +g_socket_get_property (GObject *object, + guint prop_id, + GValue *value, + GParamSpec *pspec) { GSocket *socket = G_SOCKET (object); @@ -75,13 +87,32 @@ g_socket_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec g_value_set_boolean (value, socket->priv->blocking); break; + case PROP_BACKLOG: + g_value_set_int (value, socket->priv->backlog); + break; + + case PROP_REUSE_ADDRESS: + g_value_set_boolean (value, socket->priv->reuse_address); + break; + + case PROP_LOCAL_ADDRESS: + g_value_set_object (value, socket->priv->local_address); + break; + + case PROP_REMOTE_ADDRESS: + g_value_set_object (value, socket->priv->remote_address); + break; + default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); } } static void -g_socket_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec) +g_socket_set_property (GObject *object, + guint prop_id, + const GValue *value, + GParamSpec *pspec) { GSocket *socket = G_SOCKET (object); @@ -95,6 +126,14 @@ g_socket_set_property (GObject *object, guint prop_id, const GValue *value, GPar g_socket_set_blocking (socket, g_value_get_boolean (value)); break; + case PROP_BACKLOG: + socket->priv->backlog = g_value_get_int (value); + break; + + case PROP_REUSE_ADDRESS: + g_socket_set_reuse_address (socket, g_value_get_boolean (value)); + break; + default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); } @@ -103,7 +142,13 @@ g_socket_set_property (GObject *object, guint prop_id, const GValue *value, GPar static void g_socket_finalize (GObject *object) { - GSocket *socket G_GNUC_UNUSED = G_SOCKET (object); + GSocket *socket = G_SOCKET (object); + + if (socket->priv->local_address) + g_object_unref (socket->priv->local_address); + + if (socket->priv->remote_address) + g_object_unref (socket->priv->remote_address); if (G_OBJECT_CLASS (g_socket_parent_class)->finalize) (*G_OBJECT_CLASS (g_socket_parent_class)->finalize) (object); @@ -112,7 +157,9 @@ g_socket_finalize (GObject *object) static void g_socket_dispose (GObject *object) { - GSocket *socket G_GNUC_UNUSED = G_SOCKET (object);; + GSocket *socket = G_SOCKET (object); + + g_socket_close (socket); if (G_OBJECT_CLASS (g_socket_parent_class)->dispose) (*G_OBJECT_CLASS (g_socket_parent_class)->dispose) (object); @@ -123,6 +170,8 @@ g_socket_class_init (GSocketClass *klass) { GObjectClass *gobject_class G_GNUC_UNUSED = G_OBJECT_CLASS (klass); + // TODO: WSAStartup + g_type_class_add_private (klass, sizeof (GSocketPrivate)); gobject_class->finalize = g_socket_finalize; @@ -145,6 +194,36 @@ g_socket_class_init (GSocketClass *klass) "whether or not this socket is blocking", TRUE, G_PARAM_READWRITE | G_PARAM_STATIC_NAME | G_PARAM_STATIC_BLURB | G_PARAM_STATIC_NICK)); + + g_object_class_install_property (gobject_class, PROP_BACKLOG, + g_param_spec_int ("backlog", + "listen backlog", + "outstanding connections in the listen queue", + 0, + SOMAXCONN, + 10, + G_PARAM_READWRITE | G_PARAM_STATIC_NAME | G_PARAM_STATIC_BLURB | G_PARAM_STATIC_NICK)); + + g_object_class_install_property (gobject_class, PROP_REUSE_ADDRESS, + g_param_spec_boolean ("reuse-address", + "reuse address", + "allow reuse of local addresses when binding", + FALSE, + G_PARAM_READWRITE | G_PARAM_STATIC_NAME | G_PARAM_STATIC_BLURB | G_PARAM_STATIC_NICK)); + + g_object_class_install_property (gobject_class, PROP_LOCAL_ADDRESS, + g_param_spec_object ("local-address", + "local address", + "the local address the socket is bound to", + G_TYPE_SOCKET_ADDRESS, + G_PARAM_READABLE | G_PARAM_STATIC_NAME | G_PARAM_STATIC_BLURB | G_PARAM_STATIC_NICK)); + + g_object_class_install_property (gobject_class, PROP_REMOTE_ADDRESS, + g_param_spec_object ("remote-address", + "remote address", + "the remote address the socket is connected to", + G_TYPE_SOCKET_ADDRESS, + G_PARAM_READABLE | G_PARAM_STATIC_NAME | G_PARAM_STATIC_BLURB | G_PARAM_STATIC_NICK)); } static void @@ -154,19 +233,80 @@ g_socket_init (GSocket *socket) socket->priv->fd = -1; socket->priv->blocking = TRUE; + socket->priv->backlog = 10; + socket->priv->remote_address = NULL; + socket->priv->local_address = NULL; } GSocket * -g_socket_new (gint domain, gint type, gint protocol) +g_socket_new (GSocketDomain domain, GSocketType type, const gchar *protocol, GError **error) { - gint sock; + static GStaticMutex getprotobyname_mutex = G_STATIC_MUTEX_INIT; + gint fd, native_domain, native_type, native_protocol; + + switch (domain) + { + case G_SOCKET_DOMAIN_INET: + native_domain = PF_INET; + break; + + case G_SOCKET_DOMAIN_INET6: + native_domain = PF_INET6; + break; + + case G_SOCKET_DOMAIN_UNIX: + native_domain = PF_UNIX; + break; - sock = socket(domain, type, protocol); + default: + g_set_error (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED, "unsupported socket domain"); + return NULL; + } - if (sock < 0) - return NULL; + switch (type) + { + case G_SOCKET_TYPE_STREAM: + native_type = SOCK_STREAM; + break; - return G_SOCKET (g_object_new (G_TYPE_SOCKET, "fd", sock, NULL)); + case G_SOCKET_TYPE_DATAGRAM: + native_type = SOCK_DGRAM; + break; + + case G_SOCKET_TYPE_SEQPACKET: + native_type = SOCK_SEQPACKET; + break; + + default: + g_set_error (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED, "unsupported socket type"); + return NULL; + } + + if (protocol == NULL) + native_protocol = 0; + else + { + struct protoent *ent; + g_static_mutex_lock (&getprotobyname_mutex); + if (!(ent = getprotobyname (protocol))) + { + g_static_mutex_unlock (&getprotobyname_mutex); + g_set_error (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED, "unsupported socket protocol"); + return NULL; + } + native_protocol = ent->p_proto; + g_static_mutex_unlock (&getprotobyname_mutex); + } + + fd = socket(native_domain, native_type, native_protocol); + + if (fd < 0) + { + g_set_error (error, G_IO_ERROR, g_io_error_from_errno (errno), "unable to create socket: %s", g_strerror (errno)); + return NULL; + } + + return G_SOCKET (g_object_new (G_TYPE_SOCKET, "fd", fd, "blocking", TRUE, NULL)); } GSocket * @@ -178,9 +318,9 @@ g_socket_new_from_fd (gint fd) if ((arg = fcntl (fd, F_GETFL, NULL)) < 0) g_warning ("Error getting socket status flags: %s", g_strerror (errno)); - blocking = ((arg & O_NONBLOCK) != 0); + blocking = ((arg & O_NONBLOCK) == 0); - return G_SOCKET (g_object_new (G_TYPE_SOCKET, "blocking", blocking, "fd", fd, NULL)); + return G_SOCKET (g_object_new (G_TYPE_SOCKET, "fd", fd, "blocking", blocking, NULL)); } void @@ -194,7 +334,7 @@ g_socket_set_blocking (GSocket *socket, if ((arg = fcntl (socket->priv->fd, F_GETFL, NULL)) < 0) g_warning ("Error getting socket status flags: %s", g_strerror (errno)); - arg = blocking ? arg | O_NONBLOCK : arg & ~O_NONBLOCK; + arg = blocking ? arg & ~O_NONBLOCK : arg | O_NONBLOCK; if (fcntl (socket->priv->fd, F_SETFL, arg) < 0) g_warning ("Error setting socket status flags: %s", g_strerror (errno)); @@ -210,31 +350,83 @@ g_socket_get_blocking (GSocket *socket) return socket->priv->blocking; } +void +g_socket_set_reuse_address (GSocket *socket, + gboolean reuse) +{ + gint value = (gint) reuse; + + g_return_if_fail (G_IS_SOCKET (socket)); + + if (setsockopt (socket->priv->fd, SOL_SOCKET, SO_REUSEADDR, (gpointer) &value, sizeof (value)) < 0) + g_warning ("error setting reuse address: %s", g_strerror (errno)); + + socket->priv->reuse_address = reuse; +} + +gboolean +g_socket_get_reuse_address (GSocket *socket) +{ + g_return_val_if_fail (G_IS_SOCKET (socket), FALSE); + + return socket->priv->reuse_address; +} + +GSocketAddress * +g_socket_get_local_address (GSocket *socket, + GError **error) +{ + gchar buffer[256]; + gsize len = 256; + + g_return_val_if_fail (G_IS_SOCKET (socket), NULL); + + if (socket->priv->local_address) + return socket->priv->local_address; + + if (getsockname (socket->priv->fd, (struct sockaddr *) buffer, &len) < 0) + { + g_set_error (error, G_IO_ERROR, g_io_error_from_errno (errno), "could not get local address: %s", g_strerror (errno)); + return NULL; + } + + return (socket->priv->local_address = g_object_ref_sink (g_socket_address_from_native (buffer, len))); +} + GSocketAddress * -g_socket_get_peer_address (GSocket *socket, - GError **error) +g_socket_get_remote_address (GSocket *socket, + GError **error) { - gchar buffer[128]; - gsize len; + gchar buffer[256]; + gsize len = 256; g_return_val_if_fail (G_IS_SOCKET (socket), NULL); + if (socket->priv->remote_address) + return socket->priv->remote_address; + if (getpeername (socket->priv->fd, (struct sockaddr *) buffer, &len) < 0) { - g_set_error (error, G_IO_ERROR, g_io_error_from_errno (errno), "could not get peer address"); + g_set_error (error, G_IO_ERROR, g_io_error_from_errno (errno), "could not get remote address: %s", g_strerror (errno)); return NULL; } - return g_socket_address_from_native (buffer, len); + return (socket->priv->remote_address = g_object_ref_sink (g_socket_address_from_native (buffer, len))); } -void -g_socket_listen (GSocket *socket, - gint backlog) +gboolean +g_socket_listen (GSocket *socket, + GError **error) { - g_return_if_fail (G_IS_SOCKET (socket)); + g_return_val_if_fail (G_IS_SOCKET (socket), FALSE); - listen (socket->priv->fd, backlog); + if (listen (socket->priv->fd, socket->priv->backlog) < 0) + { + g_set_error (error, G_IO_ERROR, g_io_error_from_errno (errno), "could not listen: %s", g_strerror (errno)); + return FALSE; + } + + return TRUE; } gboolean @@ -245,18 +437,20 @@ 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; if (bind (socket->priv->fd, (struct sockaddr *) addr, g_socket_address_native_size (address)) < 0) { - // TODO: set error + g_set_error (error, G_IO_ERROR, g_io_error_from_errno (errno), "error binding to address: %s", g_strerror (errno)); return FALSE; } - g_object_unref (address); + g_object_ref_sink (address); + + socket->priv->local_address = address; return TRUE; } @@ -264,139 +458,100 @@ g_socket_bind (GSocket *socket, GSocket * g_socket_accept (GSocket *socket, - GCancellable *cancellable, GError **error) { gint ret; - if (g_cancellable_set_error_if_cancelled (cancellable, error)) - return NULL; - if ((ret = accept (socket->priv->fd, NULL, 0)) < 0) { - g_set_error (error, G_IO_ERROR, g_io_error_from_errno (errno), "error accepting connection"); - return NULL; - } - - if (g_cancellable_set_error_if_cancelled (cancellable, error)) - { - close (ret); + g_set_error (error, G_IO_ERROR, g_io_error_from_errno (errno), "error accepting connection: %s", g_strerror (errno)); return NULL; } return g_socket_new_from_fd (ret); } -typedef struct { - GAsyncReadyCallback callback; - GCancellable *cancellable; - gpointer user_data; - GSocket *socket; -} AcceptData; - -static gboolean -accept_callback (AcceptData *data, - GIOCondition condition, - gint fd) +gboolean +g_socket_connect (GSocket *socket, + GSocketAddress *address, + GError **error) { - if (condition & G_IO_IN) + 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) { - g_print ("WE COULD ACCEPT HERE\n"); + if (errno == EINPROGRESS) + g_set_error (error, G_IO_ERROR, G_IO_ERROR_PENDING, "connection in progress"); + else + g_set_error (error, G_IO_ERROR, g_io_error_from_errno (errno), "error connecting: %s", g_strerror (errno)); + return FALSE; } - return FALSE; + socket->priv->remote_address = g_object_ref_sink (address); + + return TRUE; } -void -g_socket_accept_async (GSocket *socket, - GCancellable *cancellable, - GAsyncReadyCallback callback, - gpointer user_data) +gssize +g_socket_receive (GSocket *socket, + gchar *buffer, + gsize size, + GError **error) { - GSource *source; - GSimpleAsyncResult *result; - AcceptData *data; - gint ret; + gssize ret; - g_return_if_fail (G_IS_SOCKET (socket)); + g_return_val_if_fail (G_IS_SOCKET (socket) && buffer != NULL, FALSE); - if (g_socket_get_blocking (socket)) - g_socket_set_blocking (socket, FALSE); - - if ((ret = accept (socket->priv->fd, NULL, 0)) < 0) + if ((ret = recv (socket->priv->fd, buffer, size, 0)) < 0) { - if (errno == EAGAIN) - { - source = _g_fd_source_new (socket->priv->fd, G_IO_IN | G_IO_HUP | G_IO_ERR, cancellable); - - data = g_new (AcceptData, 1); - - data->socket = socket; - data->callback = callback; - data->cancellable = cancellable; - data->user_data = user_data; - - g_source_set_callback (source, (GSourceFunc) accept_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 accepting connection"); - } + g_set_error (error, G_IO_ERROR, g_io_error_from_errno (errno), "error receiving data: %s", g_strerror (errno)); + return -1; } - else - { - result = g_simple_async_result_new (G_OBJECT (socket), callback, user_data, g_socket_accept_async); - - g_simple_async_result_complete_in_idle (result); - g_object_unref (result); - } + return ret; } -GSocket * -g_socket_accept_finish (GSocket *socket, - GAsyncResult *result, - GError **error) +gssize +g_socket_send (GSocket *socket, + gchar *buffer, + gsize size, + GError **error) { - return NULL; -} + gssize ret; -gboolean -g_socket_connect (GSocket *socket, - GSocketAddress *address, - GCancellable *cancellable, - GError **error) -{ - g_return_val_if_fail (G_IS_SOCKET (socket), FALSE); -/* - if (connect () < 0) + g_return_val_if_fail (G_IS_SOCKET (socket) && buffer != NULL, FALSE); + + if ((ret = send (socket->priv->fd, buffer, size, 0)) < 0) { - if (errno == EINPROGRESS) - g_set_error (error, G_IO_ERROR, G_IO_ERROR_PENDING, "connection in progress"); - else - g_set_error (error, G_IO_ERROR, g_io_error_from_errno (errno), "error connecting: %s", g_strerror (errno)); - return FALSE; + g_set_error (error, G_IO_ERROR, g_io_error_from_errno (errno), "error sending data: %s", g_strerror (errno)); + return -1; } -*/ - return TRUE; + + return ret; } void -g_socket_connect_async (GSocket *socket, - GSocketAddress *address, - GCancellable *cancellable, - GAsyncReadyCallback *callback, - gpointer user_data) +g_socket_close (GSocket *socket) { + g_return_if_fail (G_IS_SOCKET (socket)); +#ifdef G_OS_WIN32 + closesocket (socket->priv->fd); +#else + close (socket->priv->fd); +#endif } -gboolean -g_socket_connect_finish (GSocket *socket, - GAsyncResult *result, - GError **error) +GSource * +g_socket_create_source (GSocket *socket, + GIOCondition condition, + GCancellable *cancellable) { - return FALSE; + g_return_val_if_fail (G_IS_SOCKET (socket) && (cancellable == NULL || G_IS_CANCELLABLE (cancellable)), NULL); + + return _g_fd_source_new (socket->priv->fd, G_IO_IN | G_IO_HUP | G_IO_ERR, cancellable); }