GUnixSocket

typedef struct _GUnixSocket GUnixSocket;

A GUnixSocket structure represents a Unix socket. The implementation is hidden.

gnet_unix_socket_new ()

GUnixSocket*        gnet_unix_socket_new                (const gchar *path);

Creates a GUnixSocket and connects to path. This function will block to connect. Use this constructor to create a GUnixSocket for a client.

gnet_unix_socket_new_abstract ()

GUnixSocket*        gnet_unix_socket_new_abstract       (const gchar *path);

Creates a GUnixSocket and connects to path in the abstract unix socket domain. This function will block to connect. Use this constructor to create a GUnixSocket for a client.

If the abstract unix sockets are not available on the platform in use, this function will behave like gnet_unix_socket_new().

Since 2.0.8

gnet_unix_socket_delete ()

void                gnet_unix_socket_delete             (GUnixSocket *socket);

Deletes a GUnixSocket.

gnet_unix_socket_ref ()

void                gnet_unix_socket_ref                (GUnixSocket *socket);

Adds a reference to a GUnixSocket.

gnet_unix_socket_unref ()

void                gnet_unix_socket_unref              (GUnixSocket *socket);

Removes a reference from a GUnixSocket. A GUnixSocket is deleted when the reference count reaches 0.

gnet_unix_socket_get_io_channel ()

GIOChannel*         gnet_unix_socket_get_io_channel     (GUnixSocket *socket);

Gets the GIOChannel of a GUnixSocket.

For a client socket, the GIOChannel represents the data stream. Use it like you would any other GIOChannel.

For a server socket, however, the GIOChannel represents the listening socket. When it's readable, there's a connection waiting to be accepted.

Every GUnixSocket has one and only one GIOChannel. If you ref the channel, then you must unref it eventually. Do not close the channel. The channel is closed by GNet when the socket is deleted.

gnet_unix_socket_get_path ()

gchar*              gnet_unix_socket_get_path           (const GUnixSocket *socket);

Gets the path of a GUnixSocket.

gnet_unix_socket_server_new ()

GUnixSocket*        gnet_unix_socket_server_new         (const gchar *path);

Creates a GUnixSocket bound to path. Use this constructor to create a GUnixSocket for a server.

gnet_unix_socket_server_new_abstract ()

GUnixSocket*        gnet_unix_socket_server_new_abstract
                                                        (const gchar *path);

Creates a GUnixSocket bound to path in the abstract unix socket domain. Use this constructor to create a GUnixSocket for a server.

If the abstract unix sockets are not available on the platform in use, this function will behave the same as gnet_unix_socket_server_new().

Since 2.0.8

gnet_unix_socket_server_accept ()

GUnixSocket*        gnet_unix_socket_server_accept      (const GUnixSocket *socket);

Accepts a connection from a GUnixSocket. The socket must have been created using gnet_unix_socket_server_new(). This function will block. Even if the socket's GIOChannel is readable, the function may still block.

gnet_unix_socket_server_accept_nonblock ()

GUnixSocket*        gnet_unix_socket_server_accept_nonblock
                                                        (const GUnixSocket *socket);

Accepts a connection from a GUnixSocket without blocking. The socket must have been created using gnet_unix_socket_server_new().

Note that if the socket's GIOChannel is readable, then there is PROBABLY a new connection. It is possible for the connection to close by the time this function is called, so it may return NULL.