Socket

Object Hierarchy:

GLib.Socket GLib.Socket GLib.Socket GLib.Object GLib.Object GLib.Object->GLib.Socket GLib.DatagramBased GLib.DatagramBased GLib.DatagramBased->GLib.Socket GLib.Initable GLib.Initable GLib.Initable->GLib.Socket

Description:

[ CCode ( type_id = "g_socket_get_type ()" ) ]
[ Version ( since = "2.22" ) ]
public class Socket : Object, 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`.

`GSocket`s 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: ```c 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 } ```

Example: Sockets:

public static void server (SocketAddress address) throws Error {
	Socket socket = new Socket (SocketFamily.IPV4, SocketType.STREAM, SocketProtocol.TCP);
	assert (socket != null);

	socket.bind (address, true);
	socket.set_listen_backlog (10);
	socket.listen ();

	for (int i = 0; true ; i = (i + 1) % 10) {
		Socket connection = socket.accept ();
		print (@"Accepted ($i)\n");

		connection.send (i.to_string ().data);
	}
}

public static void client (SocketAddress address) throws Error {
	Socket socket = new Socket (SocketFamily.IPV4, SocketType.STREAM, SocketProtocol.TCP);
	assert (socket != null);

	socket.connect (address);
	print ("Connected\n");

	uint8 buffer[100];
	ssize_t len;

	len = socket.receive (buffer);
	stdout.write (buffer, len);
	print ("\n");
}

public static int main (string[] args) {
	try {
		if (args.length != 2) {
			print ("%s server|client\n", args[0]);
			return 0;
		}

		InetAddress address = new InetAddress.loopback (SocketFamily.IPV4);
		InetSocketAddress inetaddress = new InetSocketAddress (address, 2001);

		if (args[1] == "server") {
			server (inetaddress);
		} else if (args[1] == "client") {
			client (inetaddress);
		} else {
			print ("Unknown option.\n");
		}
	} catch (Error e) {
		print ("Error: %s\n", e.message);
	}

	return 0;
}

valac --pkg gio-2.0 GLib.Socket.vala


Namespace: GLib
Package: gio-2.0

Content:

Properties:

  • public bool blocking { get; set; }
    Whether I/O on this socket is blocking.
  • public bool broadcast { get; set; }
    Whether the socket should allow sending to broadcast addresses.
  • public SocketFamily family { get; construct; }
    The socket’s address family.
  • public int fd { get; construct; }
    The socket’s file descriptor.
  • public bool keepalive { get; set; }
    Whether to keep the connection alive by sending periodic pings.
  • public int listen_backlog { get; set; }
    The number of outstanding connections in the listen queue.
  • public SocketAddress local_address { owned get; }
    The local address the socket is bound to.
  • public bool multicast_loopback { get; set; }
    Whether outgoing multicast packets loop back to the local host.
  • public uint multicast_ttl { get; set; }
    Time-to-live out outgoing multicast packets
  • public SocketProtocol protocol { get; construct; }
    The ID of the protocol to use, or `-1` for unknown.
  • public SocketAddress remote_address { owned get; }
    The remote address the socket is connected to.
  • public uint timeout { get; set; }
    The timeout in seconds on socket I/O
  • public uint ttl { get; set; }
    Time-to-live for outgoing unicast packets
  • public SocketType type { get; construct; }
    The socket’s type.

Creation methods:

Methods:

Inherited Members:

All known members inherited from class GLib.Object
All known members inherited from interface GLib.DatagramBased
All known members inherited from interface GLib.Initable