Socket

open class Socket(pointer: <Error class: unknown class><<Error class: unknown class>>) : DatagramBased, Initable

A GSocket is a low-level networking primitive. It is a more or less direct mapping of the BSD socket API in a portable GObject based API. It supports both the UNIX socket implementations and winsock2 on Windows.

GSocket is the platform independent base upon which the higher level network primitives are based. Applications are not typically meant to use it directly, but rather through classes like class@Gio.SocketClient, class@Gio.SocketService and class@Gio.SocketConnection. However there may be cases where direct use of GSocket is useful.

GSocket implements the iface@Gio.Initable interface, so if it is manually constructed by e.g. ctor@GObject.Object.new you must call method@Gio.Initable.init and check the results before using the object. This is done automatically in ctor@Gio.Socket.new and ctor@Gio.Socket.new_from_fd, so these functions can return NULL.

Sockets operate in two general modes, blocking or non-blocking. When in blocking mode all operations (which don’t take an explicit blocking parameter) block until the requested operation is finished or there is an error. In non-blocking mode all calls that would block return immediately with a G_IO_ERROR_WOULD_BLOCK error. To know when a call would successfully run you can call method@Gio.Socket.condition_check, or method@Gio.Socket.condition_wait. You can also use method@Gio.Socket.create_source and attach it to a type@GLib.MainContext to get callbacks when I/O is possible. Note that all sockets are always set to non blocking mode in the system, and blocking mode is emulated in GSocket.

When working in non-blocking mode applications should always be able to handle getting a G_IO_ERROR_WOULD_BLOCK error even when some other function said that I/O was possible. This can easily happen in case of a race condition in the application, but it can also happen for other reasons. For instance, on Windows a socket is always seen as writable until a write returns G_IO_ERROR_WOULD_BLOCK.

GSockets can be either connection oriented or datagram based. For connection oriented types you must first establish a connection by either connecting to an address or accepting a connection from another address. For connectionless socket types the target/source address is specified or received in each I/O operation.

All socket file descriptors are set to be close-on-exec.

Note that creating a GSocket causes the signal SIGPIPE to be ignored for the remainder of the program. If you are writing a command-line utility that uses GSocket, you may need to take into account the fact that your program will not automatically be killed if it tries to write to stdout after it has been closed.

Like most other APIs in GLib, GSocket is not inherently thread safe. To use a GSocket concurrently from multiple threads, you must implement your own locking.

Nagle’s algorithm

Since GLib 2.80, GSocket will automatically set the TCP_NODELAY option on all G_SOCKET_TYPE_STREAM sockets. This disables Nagle’s algorithm as it typically does more harm than good on modern networks.

If your application needs Nagle’s algorithm enabled, call method@Gio.Socket.set_option after constructing a GSocket to enable it:

socket = g_socket_new (…, G_SOCKET_TYPE_STREAM, …);
if (socket != NULL)
{
g_socket_set_option (socket, IPPROTO_TCP, TCP_NODELAY, FALSE, &local_error);
// handle error if needed
}

Skipped during bindings generation

  • parameter value: value: Out parameter is not supported

  • parameter buffer: buffer: Out parameter is not supported

  • parameter address: address: Out parameter is not supported

  • parameter address: address: Out parameter is not supported

  • method receive_message: In/Out parameter is not supported

  • parameter messages: InputMessage

  • parameter buffer: buffer: Out parameter is not supported

  • parameter buffer: Array parameter of type guint8 is not supported

  • parameter vectors: OutputVector

  • parameter vectors: OutputVector

  • parameter messages: OutputMessage

  • parameter buffer: Array parameter of type guint8 is not supported

  • parameter buffer: Array parameter of type guint8 is not supported

  • method local-address: Property getter throws

  • method remote-address: Property getter throws

  • method type: Property has no getter nor setter

Since

2.22

Constructors

Link copied to clipboard
constructor(family: SocketFamily, type: SocketType, protocol: SocketProtocol)

Creates a new #GSocket with the defined family, type and protocol. If @protocol is 0 (%G_SOCKET_PROTOCOL_DEFAULT) the default protocol type for the family and type is used.

constructor(fd: <Error class: unknown class>)

Creates a new #GSocket from a native file descriptor or winsock SOCKET handle.

constructor(pointer: <Error class: unknown class><<Error class: unknown class>>)

Types

Link copied to clipboard
object Companion

Properties

Link copied to clipboard
open var blocking: Boolean

Whether I/O on this socket is blocking.

Link copied to clipboard
open var broadcast: Boolean

Whether the socket should allow sending to broadcast addresses.

Link copied to clipboard

The socket’s address family.

Link copied to clipboard
open val fd: <Error class: unknown class>

The socket’s file descriptor.

Link copied to clipboard
open override val gioDatagramBasedPointer: <Error class: unknown class><<Error class: unknown class>>
Link copied to clipboard
open override val gioInitablePointer: <Error class: unknown class><<Error class: unknown class>>
Link copied to clipboard
val gioSocketPointer: <Error class: unknown class><<Error class: unknown class>>
Link copied to clipboard
open var keepalive: Boolean

Whether to keep the connection alive by sending periodic pings.

Link copied to clipboard
open var listenBacklog: <Error class: unknown class>

The number of outstanding connections in the listen queue.

Link copied to clipboard

Whether outgoing multicast packets loop back to the local host.

Link copied to clipboard
open var multicastTtl: <Error class: unknown class>

Time-to-live out outgoing multicast packets

Link copied to clipboard

The ID of the protocol to use, or -1 for unknown.

Link copied to clipboard
open var timeout: <Error class: unknown class>

The timeout in seconds on socket I/O

Link copied to clipboard
open var ttl: <Error class: unknown class>

Time-to-live for outgoing unicast packets

Functions

Link copied to clipboard
open fun accept(cancellable: Cancellable? = null): <Error class: unknown class><Socket>

Accept incoming connections on a connection-based socket. This removes the first outstanding connection request from the listening socket and creates a #GSocket object for it.

Link copied to clipboard
open fun bind(address: SocketAddress, allowReuse: Boolean): <Error class: unknown class><Boolean>

When a socket is created it is attached to an address family, but it doesn't have an address in this family. g_socket_bind() assigns the address (sometimes called name) of the socket.

Link copied to clipboard
open fun checkConnectResult(): <Error class: unknown class><Boolean>

Checks and resets the pending connect error for the socket. This is used to check for errors when g_socket_connect() is used in non-blocking mode.

Link copied to clipboard
open fun close(): <Error class: unknown class><Boolean>

Closes the socket, shutting down any active connection.

Link copied to clipboard
open override fun conditionCheck(condition: <Error class: unknown class>): <Error class: unknown class>

Checks on the readiness of @socket to perform operations. The operations specified in @condition are checked for and masked against the currently-satisfied conditions on @socket. The result is returned.

Link copied to clipboard
open fun conditionTimedWait(condition: <Error class: unknown class>, timeoutUs: <Error class: unknown class>, cancellable: Cancellable? = null): <Error class: unknown class><Boolean>

Waits for up to @timeout_us microseconds for @condition to become true on @socket. If the condition is met, true is returned.

Link copied to clipboard
open fun conditionWait(condition: <Error class: unknown class>, timeout: <Error class: unknown class>, cancellable: Cancellable? = null): <Error class: unknown class><Boolean>

Waits for up to @timeout microseconds for condition to become true on

open fun conditionWait(condition: <Error class: unknown class>, cancellable: Cancellable? = null): <Error class: unknown class><Boolean>

Waits for @condition to become true on @socket. When the condition is met, true is returned.

Link copied to clipboard
open fun connect(address: SocketAddress, cancellable: Cancellable? = null): <Error class: unknown class><Boolean>

Connect the socket to the specified remote address.

Link copied to clipboard

Creates a #GSocketConnection subclass of the right type for

Link copied to clipboard
open override fun createSource(condition: <Error class: unknown class>, cancellable: Cancellable?): <Error class: unknown class>

Creates a #GSource that can be attached to a %GMainContext to monitor for the availability of the specified @condition on the socket. The #GSource keeps a reference to the @socket.

Link copied to clipboard

Get the amount of data pending in the OS input buffer, without blocking.

Link copied to clipboard
open fun getCredentials(): <Error class: unknown class><Credentials>

Returns the credentials of the foreign process connected to this socket, if any (e.g. it is only supported for %G_SOCKET_FAMILY_UNIX sockets).

Link copied to clipboard
open fun getLocalAddress(): <Error class: unknown class><SocketAddress>

Try to get the local address of a bound socket. This is only useful if the socket has been bound to a local address, either explicitly or implicitly when connecting.

Link copied to clipboard
open fun getRemoteAddress(): <Error class: unknown class><SocketAddress>

Try to get the remote address of a connected socket. This is only useful for connection oriented sockets that have been connected.

Link copied to clipboard

Gets the socket type of the socket.

Link copied to clipboard
open fun init(cancellable: Cancellable? = null): <Error class: unknown class><Boolean>

Initializes the object implementing the interface.

Link copied to clipboard
open fun isClosed(): Boolean

Checks whether a socket is closed.

Link copied to clipboard
open fun isConnected(): Boolean

Check whether the socket is connected. This is only useful for connection-oriented sockets.

Link copied to clipboard
open fun joinMulticastGroup(group: InetAddress, sourceSpecific: Boolean, iface: String? = null): <Error class: unknown class><Boolean>

Registers @socket to receive multicast messages sent to @group.

Link copied to clipboard
open fun joinMulticastGroupSsm(group: InetAddress, sourceSpecific: InetAddress? = null, iface: String? = null): <Error class: unknown class><Boolean>

Registers @socket to receive multicast messages sent to @group.

Link copied to clipboard
open fun leaveMulticastGroup(group: InetAddress, sourceSpecific: Boolean, iface: String? = null): <Error class: unknown class><Boolean>

Removes @socket from the multicast group defined by @group, @iface, and @source_specific (which must all have the same values they had when you joined the group).

Link copied to clipboard
open fun leaveMulticastGroupSsm(group: InetAddress, sourceSpecific: InetAddress? = null, iface: String? = null): <Error class: unknown class><Boolean>

Removes @socket from the multicast group defined by @group, @iface, and @source_specific (which must all have the same values they had when you joined the group).

Link copied to clipboard
open fun listen(): <Error class: unknown class><Boolean>

Marks the socket as a server socket, i.e. a socket that is used to accept incoming requests using g_socket_accept().

Link copied to clipboard
open fun receiveBytes(size: <Error class: unknown class>, timeoutUs: <Error class: unknown class>, cancellable: Cancellable? = null): <Error class: unknown class><<Error class: unknown class>>

Receives data (up to @size bytes) from a socket.

Link copied to clipboard
open fun setOption(level: <Error class: unknown class>, optname: <Error class: unknown class>, value: <Error class: unknown class>): <Error class: unknown class><Boolean>

Sets the value of an integer-valued option on @socket, as with setsockopt(). (If you need to set a non-integer-valued option, you will need to call setsockopt() directly.)

Link copied to clipboard
open fun shutdown(shutdownRead: Boolean, shutdownWrite: Boolean): <Error class: unknown class><Boolean>

Shut down part or all of a full-duplex connection.

Link copied to clipboard
open fun speaksIpv4(): Boolean

Checks if a socket is capable of speaking IPv4.