Package-level declarations
Types
This struct defines a single action. It is for use with g_action_map_add_action_entries().
#GActionGroup represents a group of actions. Actions can be used to expose functionality in a structured way, either from one part of a program to another, or to the outside world. Action groups are often used together with a #GMenuModel that provides additional representation data for displaying the actions to the user, e.g. in a menu.
Flags used when creating a #GAppInfo.
#GAppInfoMonitor is a very simple object used for monitoring the app info database for changes (ie: newly installed or removed applications).
Integrating the launch with the launching application. This is used to handle for instance startup notification and launching the new application on the same screen as the launching window.
A #GApplication is the foundation of an application. It wraps some low-level platform-specific services and is intended to act as the foundation for higher-level application classes such as #GtkApplication or #MxApplication. In general, you should not use this class outside of a higher level framework.
#GApplicationCommandLine represents a command-line invocation of an application. It is created by #GApplication and emitted in the #GApplication::command-line signal and virtual function.
Flags used to define the behaviour of a #GApplication.
#GAskPasswordFlags are used to request specific information from the user, or to notify the user of their choices in an authentication situation.
This is the asynchronous version of #GInitable; it behaves the same in all ways except that initialization is asynchronous. For more details see the descriptions on #GInitable.
Type definition for a function that will be called back when an asynchronous operation within GIO has been completed. #GAsyncReadyCallback callbacks from #GTask are guaranteed to be invoked in a later iteration of the g-main-context-push-thread-default where the #GTask was created. All other users of #GAsyncReadyCallback must likewise call it asynchronously in a later iteration of the main context.
Provides a base class for implementing asynchronous function results.
Buffered input stream implements #GFilterInputStream and provides for buffered reads.
Buffered output stream implements #GFilterOutputStream and provides for buffered writes.
Invoked when a connection to a message bus has been obtained.
Invoked when the name is acquired.
Invoked when the name being watched is known to have to have an owner.
Invoked when the name is lost or @connection has been closed.
Flags used in g_bus_own_name().
Invoked when the name being watched is known not to have to have an owner.
Flags used in g_bus_watch_name().
#GBytesIcon specifies an image held in memory in a common format (usually png) to be used as icon.
GCancellable is a thread-safe operation cancellation stack used throughout GIO to allow for cancellation of synchronous and asynchronous operations.
This is the function type of the callback used for the #GSource returned by g_cancellable_source_new().
#GCharsetConverter is an implementation of #GConverter based on GIConv.
Flags used when calling a g_converter_convert().
Converter input stream implements #GInputStream and allows conversion of data of various types during reading.
Converter output stream implements #GOutputStream and allows conversion of data of various types during reading.
Results returned from g_converter_convert().
The #GCredentials type is a reference-counted wrapper for native credentials. This information is typically used for identifying, authenticating and authorizing other processes.
Enumeration describing different kinds of native credential types.
A #GDatagramBased is a networking interface for representing datagram-based communications. It is a more or less direct mapping of the core parts of the BSD socket API in a portable GObject interface. It is implemented by #GSocket, which wraps the UNIX socket API on UNIX and winsock2 on Windows.
This is the function type of the callback used for the #GSource returned by g_datagram_based_create_source().
Data input stream implements #GInputStream and includes functions for reading structured data directly from a binary input stream.
Data output stream implements #GOutputStream and includes functions for writing data directly to an output stream.
#GDataStreamByteOrder is used to ensure proper endianness of streaming data sources across various machine architectures.
#GDataStreamNewlineType is used when checking for or setting the line endings for a given file.
#GDBusActionGroup is an implementation of the #GActionGroup interface that can be used as a proxy for an action group that is exported over D-Bus with g_dbus_connection_export_action_group().
Information about an annotation.
Information about an argument for a method or a signal.
The #GDBusAuthObserver type provides a mechanism for participating in how a #GDBusServer (or a #GDBusConnection) authenticates remote peers. Simply instantiate a #GDBusAuthObserver and connect to the signals you are interested in. Note that new signals may be added in the future
Flags used in g_dbus_connection_call() and similar APIs.
Capabilities negotiated with the remote peer.
The #GDBusConnection type is used for D-Bus connections to remote peers such as a message buses. It is a low-level API that offers a lot of flexibility. For instance, it lets you establish a connection over any transport that can by represented as a #GIOStream.
Flags used when creating a new #GDBusConnection.
Struct used in g_dbus_error_register_error_domain().
The #GDBusInterface type is the base type for D-Bus interfaces both on the service side (see #GDBusInterfaceSkeleton) and client side (see #GDBusProxy).
The type of the @get_property function in #GDBusInterfaceVTable.
Information about a D-Bus interface.
The type of the @method_call function in #GDBusInterfaceVTable.
The type of the @set_property function in #GDBusInterfaceVTable.
Abstract base class for D-Bus interfaces on the service side.
Flags describing the behavior of a #GDBusInterfaceSkeleton instance.
Virtual table for handling properties and method calls for a D-Bus interface.
#GDBusMenuModel is an implementation of #GMenuModel that can be used as a proxy for a menu model that is exported over D-Bus with g_dbus_connection_export_menu_model().
A type for representing D-Bus messages that can be sent or received on a #GDBusConnection.
Enumeration used to describe the byte order of a D-Bus message.
Signature for function used in g_dbus_connection_add_filter().
Message flags used in #GDBusMessage.
Header fields used in #GDBusMessage.
Message types used in #GDBusMessage.
Information about a method on an D-Bus interface.
Instances of the #GDBusMethodInvocation class are used when handling D-Bus method calls. It provides a way to asynchronously return results and errors.
Information about nodes in a remote object hierarchy.
The #GDBusObject type is the base type for D-Bus objects on both the service side (see #GDBusObjectSkeleton) and the client side (see #GDBusObjectProxy). It is essentially just a container of interfaces.
The #GDBusObjectManager type is the base type for service- and client-side implementations of the standardized org.freedesktop.DBus.ObjectManager interface.
#GDBusObjectManagerClient is used to create, monitor and delete object proxies for remote objects exported by a #GDBusObjectManagerServer (or any code implementing the org.freedesktop.DBus.ObjectManager interface).
Flags used when constructing a #GDBusObjectManagerClient.
#GDBusObjectManagerServer is used to export #GDBusObject instances using the standardized org.freedesktop.DBus.ObjectManager interface. For example, remote D-Bus clients can get all objects and properties in a single call. Additionally, any change in the object hierarchy is broadcast using signals. This means that D-Bus clients can keep caches up to date by only listening to D-Bus signals.
A #GDBusObjectProxy is an object used to represent a remote object with one or more D-Bus interfaces. Normally, you don't instantiate a #GDBusObjectProxy yourself - typically #GDBusObjectManagerClient is used to obtain it.
A #GDBusObjectSkeleton instance is essentially a group of D-Bus interfaces. The set of exported interfaces on the object may be dynamic and change at runtime.
Information about a D-Bus property on a D-Bus interface.
Flags describing the access control of a D-Bus property.
#GDBusProxy is a base class used for proxies to access a D-Bus interface on a remote object. A #GDBusProxy can be constructed for both well-known and unique names.
Flags used when constructing an instance of a #GDBusProxy derived class.
Function signature for a function used to determine the #GType to use for an interface proxy (if @interface_name is not null) or object proxy (if @interface_name is null).
Flags used when sending #GDBusMessages on a #GDBusConnection.
#GDBusServer is a helper for listening to and accepting D-Bus connections. This can be used to create a new D-Bus server, allowing two peers to use the D-Bus protocol for their own specialized communication. A server instance provided in this way will not perform message routing or implement the org.freedesktop.DBus interface.
Flags used when creating a #GDBusServer.
Signature for callback function used in g_dbus_connection_signal_subscribe().
Flags used when subscribing to signals via g_dbus_connection_signal_subscribe().
Information about a signal on a D-Bus interface.
The type of the @dispatch function in #GDBusSubtreeVTable.
The type of the @enumerate function in #GDBusSubtreeVTable.
Flags passed to g_dbus_connection_register_subtree().
Virtual table for handling subtrees registered with g_dbus_connection_register_subtree().
#GDebugController is an interface to expose control of debugging features and debug output.
#GDebugControllerDBus is an implementation of #GDebugController which exposes debug settings as a D-Bus object.
#GDesktopAppInfo is an implementation of #GAppInfo based on desktop files.
#GDesktopAppInfoLookup is an opaque data structure and can only be accessed using the following functions.
During invocation, g_desktop_app_info_launch_uris_as_manager() may create one or more child processes. This callback is invoked once for each, providing the process ID.
Flags used when starting a drive.
Enumeration describing how a drive can be started/stopped.
#GDtlsClientConnection is the client-side subclass of #GDtlsConnection, representing a client-side DTLS connection.
#GDtlsConnection is the base DTLS connection class type, which wraps a #GDatagramBased and provides DTLS encryption on top of it. Its subclasses, #GDtlsClientConnection and #GDtlsServerConnection, implement client-side and server-side DTLS, respectively.
#GDtlsServerConnection is the server-side subclass of #GDtlsConnection, representing a server-side DTLS connection.
#GEmblemedIcon is an implementation of #GIcon that supports adding an emblem to an icon. Adding multiple emblems to an icon is ensured via g_emblemed_icon_add_emblem().
GEmblemOrigin is used to add information about the origin of the emblem to #GEmblem.
#GFile is a high level abstraction for manipulating files on a virtual file system. #GFiles are lightweight, immutable objects that do no I/O upon creation. It is necessary to understand that #GFile objects do not represent files, merely an identifier for a file. All file content I/O is implemented as streaming operations (see #GInputStream and #GOutputStream).
Information about a specific attribute.
Flags specifying the behaviour of an attribute.
Acts as a lightweight registry for possible valid file attributes. The registry stores Key-Value pair formats as #GFileAttributeInfos.
Determines if a string matches a file attribute.
Used by g_file_set_attributes_from_info() when setting file attributes.
The data types for file attributes.
Flags used when copying or moving files.
Flags used when an operation may create a file.
#GFileDescriptorBased is implemented by streams (implementations of #GInputStream or #GOutputStream) that are based on file descriptors.
#GFileEnumerator allows you to operate on a set of #GFiles, returning a #GFileInfo structure for each file enumerated (e.g. g_file_enumerate_children() will return a #GFileEnumerator for each of the children within a directory).
#GFileIcon specifies an icon by pointing to an image file to be used as icon.
Functionality for manipulating basic metadata for files. #GFileInfo implements methods for getting information that all files should contain, and allows for manipulation of extended attributes.
GFileInputStream provides input streams that take their content from a file.
GFileIOStream provides io streams that both read and write to the same file handle.
Flags that can be used with g_file_measure_disk_usage().
This callback type is used by g_file_measure_disk_usage() to make periodic progress reports when measuring the amount of disk spaced used by a directory.
Monitors a file or directory for changes.
Specifies what type of event a monitor event is.
Flags used to set what a #GFileMonitor will watch for.
Completes partial file and directory names given a partial string by looking in the file system for clues. Can return a list of possible completion strings for widget implementations.
GFileOutputStream provides output streams that write their content to a file.
When doing file operations that may take a while, such as moving a file or copying a file, a progress callback is used to pass how far along that operation is to the application.
Flags used when querying a #GFileInfo.
When loading the partial contents of a file with g_file_load_partial_contents_async(), it may become necessary to determine if any more data from the file should be loaded. A #GFileReadMoreCallback function facilitates this by returning true if more data should be read, or false otherwise.
Indicates a hint from the file system whether files should be previewed in a file manager. Returned as the value of the key %G_FILE_ATTRIBUTE_FILESYSTEM_USE_PREVIEW.
Base class for input stream implementations that perform some kind of filtering operation on a base stream. Typical examples of filtering operations are character set conversion, compression and byte order flipping.
Base class for output stream implementations that perform some kind of filtering operation on a base stream. Typical examples of filtering operations are character set conversion, compression and byte order flipping.
#GInetAddress represents an IPv4 or IPv6 internet address. Use g_resolver_lookup_by_name() or g_resolver_lookup_by_name_async() to look up the #GInetAddress for a hostname. Use g_resolver_lookup_by_address() or g_resolver_lookup_by_address_async() to look up the hostname for a #GInetAddress.
#GInetAddressMask represents a range of IPv4 or IPv6 addresses described by a base address and a length indicating how many bits of the base address are relevant for matching purposes. These are often given in string form. Eg, "10.0.0.0/8", or "fe80::/10".
An IPv4 or IPv6 socket address; that is, the combination of a #GInetAddress and a port number.
#GInitable is implemented by objects that can fail during initialization. If an object implements this interface then it must be initialized as the first thing after construction, either via g_initable_init() or g_async_initable_init_async() (the latter is only available if it also implements #GAsyncInitable).
Structure used for scatter/gather data input when receiving multiple messages or packets in one go. You generally pass in an array of empty #GInputVectors and the operation will use all the buffers as if they were one buffer, and will set @bytes_received to the total number of bytes received across all #GInputVectors.
#GInputStream has functions to read from a stream (g_input_stream_read()), to close a stream (g_input_stream_close()) and to skip some content (g_input_stream_skip()).
Structure used for scatter/gather data input. You generally pass in an array of #GInputVectors and the operation will store the read data starting in the first buffer, switching to the next as needed.
Error codes returned by GIO functions.
Provides an interface and default functions for loading and unloading modules. This is used internally to make GIO extensible, but can also be used by others to implement module loading.
Flags for use with g_io_module_scope_new().
I/O Job function.
GIOStream represents an object that has both read and write streams. Generally the two streams act as separate input and output streams, but they share some common resources and state. For instance, for seekable streams, both streams may use the same position.
GIOStreamSpliceFlags determine how streams should be spliced.
#GListModel is an interface that represents a mutable list of #GObjects. Its main intention is as a model for various widgets in user interfaces, such as list views, but it can also be used as a convenient method of returning lists of data, with support for updates.
Extends the #GIcon interface and adds the ability to load icons from streams.
#GMemoryInputStream is a class for using arbitrary memory chunks as input for GIO streaming input operations.
#GMemoryMonitor will monitor system memory and suggest to the application when to free memory so as to leave more room for other applications. It is implemented on Linux using the [Low Memory
Memory availability warning levels.
#GMemoryOutputStream is a class for using arbitrary memory chunks as output for GIO streaming output operations.
#GMenuAttributeIter is an opaque structure type. You must access it using the functions below.
#GMenuLinkIter is an opaque structure type. You must access it using the functions below.
#GMenuModel represents the contents of a menu -- an ordered list of menu items. The items are associated with actions, which can be activated through them. Items can be grouped in sections, and may have submenus associated with them. Both items and sections usually have some representation data, such as labels or icons. The type of the associated action (ie whether it is stateful, and what kind of state it has) can influence the representation of the item.
Flags used when mounting a mount.
#GMountOperation provides a mechanism for interacting with the user. It can be used for authenticating mountable operations, such as loop mounting files, hard drive partitions or server locations. It can also be used to ask the user questions or show a list of applications preventing unmount or eject operations from completing.
#GMountOperationResult is returned as a result when a request for information is send by the mounting operation.
Flags used when an unmounting a mount.
A socket address of some unknown native type.
#GNetworkAddress provides an easy way to resolve a hostname and then attempt to connect to that host, handling the possibility of multiple IP addresses and multiple address families.
The host's network connectivity state, as reported by #GNetworkMonitor.
#GNetworkMonitor provides an easy-to-use cross-platform API for monitoring network connectivity. On Linux, the available implementations are based on the kernel's netlink interface and on NetworkManager.
Like #GNetworkAddress does with hostnames, #GNetworkService provides an easy way to resolve a SRV record, and then attempt to connect to one of the hosts that implements that service, handling service priority/weighting, multiple IP addresses, and multiple address families.
#GNotification is a mechanism for creating a notification to be shown to the user -- typically as a pop-up notification presented by the desktop environment shell.
Priority levels for #GNotifications.
Structure used for scatter/gather data output when sending multiple messages or packets in one go. You generally pass in an array of #GOutputVectors and the operation will use all the buffers as if they were one buffer.
#GOutputStream has functions to write to a stream (g_output_stream_write()), to close a stream (g_output_stream_close()) and to flush pending writes (g_output_stream_flush()).
GOutputStreamSpliceFlags determine how streams should be spliced.
Structure used for scatter/gather data output. You generally pass in an array of #GOutputVectors and the operation will use all the buffers as if they were one buffer.
#GPasswordSave is used to indicate the lifespan of a saved password.
A #GPermission represents the status of the caller's permission to perform a certain action.
#GPollableInputStream is implemented by #GInputStreams that can be polled for readiness to read. This can be used when interfacing with a non-GIO API that expects UNIX-file-descriptor-style asynchronous I/O rather than GIO-style.
#GPollableOutputStream is implemented by #GOutputStreams that can be polled for readiness to write. This can be used when interfacing with a non-GIO API that expects UNIX-file-descriptor-style asynchronous I/O rather than GIO-style.
Return value for various IO operations that signal errors via the return value and not necessarily via a #GError.
This is the function type of the callback used for the #GSource returned by g_pollable_input_stream_create_source() and g_pollable_output_stream_create_source().
#GPowerProfileMonitor makes it possible for applications as well as OS components to monitor system power profiles and act upon them. It currently only exports whether the system is in “Power Saver” mode (known as “Low Power” mode on some systems).
A #GPropertyAction is a way to get a #GAction with a state value reflecting and controlling the value of a #GObject property.
A #GProxy handles connecting to a remote host via a given type of proxy server. It is implemented by the 'gio-proxy' extension point. The extensions are named after their proxy protocol name. As an example, a SOCKS5 proxy implementation can be retrieved with the name 'socks5' using the function g_io_extension_point_get_extension_by_name().
Support for proxied #GInetSocketAddress.
#GProxyAddressEnumerator is a wrapper around #GSocketAddressEnumerator which takes the #GSocketAddress instances returned by the #GSocketAddressEnumerator and wraps them in #GProxyAddress instances, using the given #GProxyAddressEnumerator:proxy-resolver.
#GProxyResolver provides synchronous and asynchronous network proxy resolution. #GProxyResolver is used within #GSocketClient through the method g_socket_connectable_proxy_enumerate().
The GRemoteActionGroup interface is implemented by #GActionGroup instances that either transmit action invocations to other processes or receive action invocations in the local process from other processes.
#GResolver provides cancellable synchronous and asynchronous DNS resolution, for hostnames (g_resolver_lookup_by_address(), g_resolver_lookup_by_name() and their async variants) and SRV (service) records (g_resolver_lookup_service()).
An error code used with %G_RESOLVER_ERROR in a #GError returned from a #GResolver routine.
Flags to modify lookup behavior.
The type of record that g_resolver_lookup_records() or g_resolver_lookup_records_async() should retrieve. The records are returned as lists of #GVariant tuples. Each record type has different values in the variant tuples returned.
Applications and libraries often contain binary or textual data that is really part of the application, rather than user data. For instance #GtkBuilder .ui files, splashscreen images, GMenu markup XML, CSS files, icons, etc. These are often shipped as files in $datadir/appname, or manually included as literal strings in the code.
An error code used with %G_RESOURCE_ERROR in a #GError returned from a #GResource routine.
GResourceFlags give information about a particular file inside a resource bundle.
GResourceLookupFlags determine how resource path lookups are handled.
The #GSettingsBackend interface defines a generic interface for non-strictly-typed data that is stored in a hierarchy. To implement an alternative storage backend for #GSettings, you need to implement the #GSettingsBackend interface and then make it implement the extension point %G_SETTINGS_BACKEND_EXTENSION_POINT_NAME.
Flags used when creating a binding. These flags determine in which direction the binding works. The default is to synchronize in both directions.
The type for the function that is used to convert from #GSettings to an object property. The @value is already initialized to hold values of the appropriate type.
The type for the function that is used to convert an object property value to a #GVariant for storing it in #GSettings.
The type of the function that is used to convert from a value stored in a #GSettings to a value that is useful to the application.
The #GSettingsSchemaSource and #GSettingsSchema APIs provide a mechanism for advanced control over the loading of schemas and a mechanism for introspecting their content.
#GSettingsSchemaKey is an opaque data structure and can only be accessed using the following functions.
This is an opaque structure type. You may not access it directly.
A #GSimpleAction is the obvious simple implementation of the #GAction interface. This is the easiest way to create an action for purposes of adding it to a #GSimpleActionGroup.
#GSimpleActionGroup is a hash table filled with #GAction objects, implementing the #GActionGroup and #GActionMap interfaces.
As of GLib 2.46, #GSimpleAsyncResult is deprecated in favor of #GTask, which provides a simpler API.
Simple thread function that runs an asynchronous operation and checks for cancellation.
GSimpleIOStream creates a #GIOStream from an arbitrary #GInputStream and #GOutputStream. This allows any pair of input and output streams to be used with #GIOStream methods.
#GSimplePermission is a trivial implementation of #GPermission that represents a permission that is either always or never allowed. The value is given at construction and doesn't change.
#GSimpleProxyResolver is a simple #GProxyResolver implementation that handles a single default proxy, multiple URI-scheme-specific proxies, and a list of hosts that proxies should not be used for.
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.
#GSocketAddress is the equivalent of struct sockaddr in the BSD sockets API. This is an abstract class; use #GInetSocketAddress for internet sockets, or #GUnixSocketAddress for UNIX domain sockets.
#GSocketAddressEnumerator is an enumerator type for #GSocketAddress instances. It is returned by enumeration functions such as g_socket_connectable_enumerate(), which returns a #GSocketAddressEnumerator to list each #GSocketAddress which could be used to connect to that #GSocketConnectable.
#GSocketClient is a lightweight high-level utility class for connecting to a network host using a connection oriented socket type.
Describes an event occurring on a #GSocketClient. See the #GSocketClient::event signal for more details.
Objects that describe one or more potential socket endpoints implement #GSocketConnectable. Callers can then use g_socket_connectable_enumerate() to get a #GSocketAddressEnumerator to try out each socket address in turn until one succeeds, as shown in the sample code below.
#GSocketConnection is a #GIOStream for a connected socket. They can be created either by #GSocketClient when connecting to a host, or by #GSocketListener when accepting a new client.
A #GSocketControlMessage is a special-purpose utility message that can be sent to or received from a #GSocket. These types of messages are often called "ancillary data".
The protocol family of a #GSocketAddress. (These values are identical to the system defines %AF_INET, %AF_INET6 and %AF_UNIX, if available.)
A #GSocketListener is an object that keeps track of a set of server sockets and helps you accept sockets from any of the socket, either sync or async.
Describes an event occurring on a #GSocketListener. See the #GSocketListener::event signal for more details.
Flags used in g_socket_receive_message() and g_socket_send_message(). The flags listed in the enum are some commonly available flags, but the values used for them are the same as on the platform, and any other flags are passed in/out as is. So to use a platform specific flag, just include the right system header and pass in the flag.
A protocol identifier is specified when creating a #GSocket, which is a family/type specific identifier, where 0 means the default protocol for the particular family/type.
A #GSocketService is an object that represents a service that is provided to the network or over local sockets. When a new connection is made to the service the #GSocketService::incoming signal is emitted.
This is the function type of the callback used for the #GSource returned by g_socket_create_source().
Flags used when creating a #GSocket. Some protocols may not implement all the socket types.
SRV (service) records are used by some network protocols to provide service-specific aliasing and load-balancing. For example, XMPP (Jabber) uses SRV records to locate the XMPP server for a domain; rather than connecting directly to "example.com" or assuming a specific server hostname like "xmpp.example.com", an XMPP client would look up the "xmpp-client" SRV record for "example.com", and then connect to whatever host was pointed to by that record.
#GStaticResource is an opaque data structure and can only be accessed using the following functions.
#GSubprocess allows the creation of and interaction with child processes.
Flags to define the behaviour of a #GSubprocess.
This class contains a set of options for launching child processes, such as where its standard input and output will be directed, the argument list, the environment, and more.
A #GTask represents and manages a cancellable "task".
The prototype for a task function to be run in a thread via g_task_run_in_thread() or g_task_run_in_thread_sync().
This is the subclass of #GSocketConnection that is created for TCP/IP sockets.
A #GTcpWrapperConnection can be used to wrap a #GIOStream that is based on a #GSocket, but which is not actually a #GSocketConnection. This is used by #GSocketClient so that it can always return a #GSocketConnection, even when the connection it has actually created is not directly a #GSocketConnection.
Flags to define future #GTestDBus behaviour.
#GThemedIcon is an implementation of #GIcon that supports icon themes. #GThemedIcon contains a list of all of the icons present in an icon theme, so that icons can be looked up quickly. #GThemedIcon does not provide actual pixmaps for icons, just the icon names. Ideally something like gtk_icon_theme_choose_icon() should be used to resolve the list of names so that fallback icons work nicely with themes that inherit other themes.
A #GThreadedSocketService is a simple subclass of #GSocketService that handles incoming connections by creating a worker thread and dispatching the connection to it by emitting the #GThreadedSocketService::run signal in the new thread.
The client authentication mode for a #GTlsServerConnection.
TLS (Transport Layer Security, aka SSL) and DTLS backend.
A certificate used for TLS authentication and encryption. This can represent either a certificate only (eg, the certificate received by a client from a server), or the combination of a certificate and a private key (which is needed when acting as a #GTlsServerConnection).
A set of flags describing TLS certification validation. This can be used to describe why a particular certificate was rejected (for example, in #GTlsConnection::accept-certificate).
Flags for g_tls_interaction_request_certificate(), g_tls_interaction_request_certificate_async(), and g_tls_interaction_invoke_request_certificate().
An error code used with %G_TLS_CHANNEL_BINDING_ERROR in a #GError to indicate a TLS channel binding retrieval error.
The type of TLS channel binding data to retrieve from #GTlsConnection or #GDtlsConnection, as documented by RFC 5929. The tls-unique-for-telnet binding type is not currently implemented.
#GTlsClientConnection is the client-side subclass of #GTlsConnection, representing a client-side TLS connection.
#GTlsConnection is the base TLS connection class type, which wraps a #GIOStream and provides TLS encryption on top of it. Its subclasses, #GTlsClientConnection and #GTlsServerConnection, implement client-side and server-side TLS, respectively.
#GTlsDatabase is used to look up certificates and other information from a certificate or key store. It is an abstract base class which TLS library specific subtypes override.
Flags for g_tls_database_lookup_certificate_for_handle(), g_tls_database_lookup_certificate_issuer(), and g_tls_database_lookup_certificates_issued_by().
Flags for g_tls_database_verify_chain().
#GTlsFileDatabase is implemented by #GTlsDatabase objects which load their certificate information from a file. It is an interface which TLS library specific subtypes implement.
#GTlsInteraction provides a mechanism for the TLS connection and database code to interact with the user. It can be used to ask the user for passwords.
#GTlsInteractionResult is returned by various functions in #GTlsInteraction when finishing an interaction request.
Holds a password used in TLS.
Various flags for the password.
The TLS or DTLS protocol version used by a #GTlsConnection or #GDtlsConnection. The integer values of these versions are sequential to ensure newer known protocol versions compare greater than older known versions. Any known DTLS protocol version will compare greater than any SSL or TLS protocol version. The protocol version may be %G_TLS_PROTOCOL_VERSION_UNKNOWN if the TLS backend supports a newer protocol version that GLib does not yet know about. This means that it's possible for an unknown DTLS protocol version to compare less than the TLS protocol versions.
When to allow rehandshaking. See g_tls_connection_set_rehandshake_mode().
#GTlsServerConnection is the server-side subclass of #GTlsConnection, representing a server-side TLS connection.
This is the subclass of #GSocketConnection that is created for UNIX domain sockets.
This #GSocketControlMessage contains a #GCredentials instance. It may be sent using g_socket_send_message() and received using g_socket_receive_message() over UNIX sockets (ie: sockets in the %G_SOCKET_FAMILY_UNIX family).
A #GUnixFDList contains a list of file descriptors. It owns the file descriptors that it contains, closing them when finalized.
This #GSocketControlMessage contains a #GUnixFDList. It may be sent using g_socket_send_message() and received using g_socket_receive_message() over UNIX sockets (ie: sockets in the %G_SOCKET_FAMILY_UNIX family). The file descriptors are copied between processes by the kernel.
#GUnixInputStream implements #GInputStream for reading from a UNIX file descriptor, including asynchronous operations. (If the file descriptor refers to a socket or pipe, this will use poll() to do asynchronous I/O. If it refers to a regular file, it will fall back to doing asynchronous I/O in another thread.)
Defines a Unix mount entry (e.g.
Watches #GUnixMounts for changes.
Defines a Unix mount point (e.g.
#GUnixOutputStream implements #GOutputStream for writing to a UNIX file descriptor, including asynchronous operations. (If the file descriptor refers to a socket or pipe, this will use poll() to do asynchronous I/O. If it refers to a regular file, it will fall back to doing asynchronous I/O in another thread.)
Support for UNIX-domain (also known as local) sockets.
The type of name used by a #GUnixSocketAddress. %G_UNIX_SOCKET_ADDRESS_PATH indicates a traditional unix domain socket bound to a filesystem path. %G_UNIX_SOCKET_ADDRESS_ANONYMOUS indicates a socket not bound to any name (eg, a client-side socket, or a socket created with socketpair()).
This function type is used by g_vfs_register_uri_scheme() to make it possible for a client to associate an URI scheme to a different #GFile implementation.
#GVolumeMonitor is for listing the user interesting devices and volumes on the computer. In other words, what a file selector or file manager would show in a sidebar.
#GZlibCompressor is an implementation of #GConverter that compresses data using zlib.
Used to select the type of data format to use for #GZlibDecompressor and #GZlibCompressor.
#GZlibDecompressor is an implementation of #GConverter that decompresses data compressed with zlib.