gio/auto/

socket.rs

// This file was generated by gir (https://github.com/gtk-rs/gir)
// from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT

use crate::{
    ffi, Cancellable, Credentials, DatagramBased, InetAddress, Initable, SocketAddress,
    SocketConnection, SocketFamily, SocketProtocol, SocketType,
};
use glib::{
    prelude::*,
    signal::{connect_raw, SignalHandlerId},
    translate::*,
};
use std::boxed::Box as Box_;

glib::wrapper! {
    /// 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 [`SocketClient`][crate::SocketClient],
    /// [`SocketService`][crate::SocketService] and [`SocketConnection`][crate::SocketConnection]. However there may
    /// be cases where direct use of `GSocket` is useful.
    ///
    /// `GSocket` implements the [`Initable`][crate::Initable] interface, so if it is manually
    /// constructed by e.g. [`glib::Object::new()`][crate::glib::Object::new()] you must call
    /// [`InitableExt::init()`][crate::prelude::InitableExt::init()] and check the results before using the object.
    /// This is done automatically in [`new()`][Self::new()] and
    /// [`from_fd()`][Self::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
    /// [`SocketExt::condition_check()`][crate::prelude::SocketExt::condition_check()], or [`SocketExt::condition_wait()`][crate::prelude::SocketExt::condition_wait()].
    /// You can also use `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](https://en.wikipedia.org/wiki/Nagle`27s_algorithm`) as it
    /// typically does more harm than good on modern networks.
    ///
    /// If your application needs Nagle’s algorithm enabled, call
    /// [`SocketExt::set_option()`][crate::prelude::SocketExt::set_option()] after constructing a `GSocket` to enable it:
    /// **⚠️ The following code is in c ⚠️**
    ///
    /// ```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
    ///   }
    /// ```
    ///
    /// ## Properties
    ///
    ///
    /// #### `blocking`
    ///  Whether I/O on this socket is blocking.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `broadcast`
    ///  Whether the socket should allow sending to broadcast addresses.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `family`
    ///  The socket’s address family.
    ///
    /// Readable | Writeable | Construct Only
    ///
    ///
    /// #### `fd`
    ///  The socket’s file descriptor.
    ///
    /// Readable | Writeable | Construct Only
    ///
    ///
    /// #### `keepalive`
    ///  Whether to keep the connection alive by sending periodic pings.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `listen-backlog`
    ///  The number of outstanding connections in the listen queue.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `local-address`
    ///  The local address the socket is bound to.
    ///
    /// Readable
    ///
    ///
    /// #### `multicast-loopback`
    ///  Whether outgoing multicast packets loop back to the local host.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `multicast-ttl`
    ///  Time-to-live out outgoing multicast packets
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `protocol`
    ///  The ID of the protocol to use, or `-1` for unknown.
    ///
    /// Readable | Writeable | Construct Only
    ///
    ///
    /// #### `remote-address`
    ///  The remote address the socket is connected to.
    ///
    /// Readable
    ///
    ///
    /// #### `timeout`
    ///  The timeout in seconds on socket I/O
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `ttl`
    ///  Time-to-live for outgoing unicast packets
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `type`
    ///  The socket’s type.
    ///
    /// Readable | Writeable | Construct Only
    ///
    /// # Implements
    ///
    /// [`SocketExt`][trait@crate::prelude::SocketExt], [`trait@glib::ObjectExt`], [`DatagramBasedExt`][trait@crate::prelude::DatagramBasedExt], [`InitableExt`][trait@crate::prelude::InitableExt], [`SocketExtManual`][trait@crate::prelude::SocketExtManual], [`DatagramBasedExtManual`][trait@crate::prelude::DatagramBasedExtManual]
    #[doc(alias = "GSocket")]
    pub struct Socket(Object<ffi::GSocket, ffi::GSocketClass>) @implements DatagramBased, Initable;

    match fn {
        type_ => || ffi::g_socket_get_type(),
    }
}

impl Socket {
    pub const NONE: Option<&'static Socket> = None;

    /// Creates a new #GSocket with the defined family, type and protocol.
    /// If @protocol is 0 ([`SocketProtocol::Default`][crate::SocketProtocol::Default]) the default protocol type
    /// for the family and type is used.
    ///
    /// The @protocol is a family and type specific int that specifies what
    /// kind of protocol to use. #GSocketProtocol lists several common ones.
    /// Many families only support one protocol, and use 0 for this, others
    /// support several and using 0 means to use the default protocol for
    /// the family and type.
    ///
    /// The protocol id is passed directly to the operating
    /// system, so you can use protocols not listed in #GSocketProtocol if you
    /// know the protocol number used for it.
    /// ## `family`
    /// the socket family to use, e.g. [`SocketFamily::Ipv4`][crate::SocketFamily::Ipv4].
    /// ## `type_`
    /// the socket type to use.
    /// ## `protocol`
    /// the id of the protocol to use, or 0 for default.
    ///
    /// # Returns
    ///
    /// a #GSocket or [`None`] on error.
    ///     Free the returned object with g_object_unref().
    #[doc(alias = "g_socket_new")]
    pub fn new(
        family: SocketFamily,
        type_: SocketType,
        protocol: SocketProtocol,
    ) -> Result<Socket, glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let ret = ffi::g_socket_new(
                family.into_glib(),
                type_.into_glib(),
                protocol.into_glib(),
                &mut error,
            );
            if error.is_null() {
                Ok(from_glib_full(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }
}

/// Trait containing all [`struct@Socket`] methods.
///
/// # Implementors
///
/// [`Socket`][struct@crate::Socket]
pub trait SocketExt: IsA<Socket> + 'static {
    /// 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.
    ///
    /// The @self must be bound to a local address with g_socket_bind() and
    /// must be listening for incoming connections (g_socket_listen()).
    ///
    /// If there are no outstanding connections then the operation will block
    /// or return [`IOErrorEnum::WouldBlock`][crate::IOErrorEnum::WouldBlock] if non-blocking I/O is enabled.
    /// To be notified of an incoming connection, wait for the [`glib::IOCondition::IN`][crate::glib::IOCondition::IN] condition.
    /// ## `cancellable`
    /// a `GCancellable` or [`None`]
    ///
    /// # Returns
    ///
    /// a new #GSocket, or [`None`] on error.
    ///     Free the returned object with g_object_unref().
    #[doc(alias = "g_socket_accept")]
    fn accept(&self, cancellable: Option<&impl IsA<Cancellable>>) -> Result<Socket, glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let ret = ffi::g_socket_accept(
                self.as_ref().to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok(from_glib_full(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// 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.
    ///
    /// It is generally required to bind to a local address before you can
    /// receive connections. (See g_socket_listen() and g_socket_accept() ).
    /// In certain situations, you may also want to bind a socket that will be
    /// used to initiate connections, though this is not normally required.
    ///
    /// If @self is a TCP socket, then @allow_reuse controls the setting
    /// of the `SO_REUSEADDR` socket option; normally it should be [`true`] for
    /// server sockets (sockets that you will eventually call
    /// g_socket_accept() on), and [`false`] for client sockets. (Failing to
    /// set this flag on a server socket may cause g_socket_bind() to return
    /// [`IOErrorEnum::AddressInUse`][crate::IOErrorEnum::AddressInUse] if the server program is stopped and then
    /// immediately restarted.)
    ///
    /// If @self is a UDP socket, then @allow_reuse determines whether or
    /// not other UDP sockets can be bound to the same address at the same
    /// time. In particular, you can have several UDP sockets bound to the
    /// same address, and they will all receive all of the multicast and
    /// broadcast packets sent to that address. (The behavior of unicast
    /// UDP packets to an address with multiple listeners is not defined.)
    /// ## `address`
    /// a #GSocketAddress specifying the local address.
    /// ## `allow_reuse`
    /// whether to allow reusing this address
    ///
    /// # Returns
    ///
    /// [`true`] on success, [`false`] on error.
    #[doc(alias = "g_socket_bind")]
    fn bind(
        &self,
        address: &impl IsA<SocketAddress>,
        allow_reuse: bool,
    ) -> Result<(), glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::g_socket_bind(
                self.as_ref().to_glib_none().0,
                address.as_ref().to_glib_none().0,
                allow_reuse.into_glib(),
                &mut error,
            );
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// 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.
    ///
    /// # Returns
    ///
    /// [`true`] if no error, [`false`] otherwise, setting @error to the error
    #[doc(alias = "g_socket_check_connect_result")]
    fn check_connect_result(&self) -> Result<(), glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok =
                ffi::g_socket_check_connect_result(self.as_ref().to_glib_none().0, &mut error);
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Closes the socket, shutting down any active connection.
    ///
    /// Closing a socket does not wait for all outstanding I/O operations
    /// to finish, so the caller should not rely on them to be guaranteed
    /// to complete even if the close returns with no error.
    ///
    /// Once the socket is closed, all other operations will return
    /// [`IOErrorEnum::Closed`][crate::IOErrorEnum::Closed]. Closing a socket multiple times will not
    /// return an error.
    ///
    /// Sockets will be automatically closed when the last reference
    /// is dropped, but you might want to call this function to make sure
    /// resources are released as early as possible.
    ///
    /// Beware that due to the way that TCP works, it is possible for
    /// recently-sent data to be lost if either you close a socket while the
    /// [`glib::IOCondition::IN`][crate::glib::IOCondition::IN] condition is set, or else if the remote connection tries to
    /// send something to you after you close the socket but before it has
    /// finished reading all of the data you sent. There is no easy generic
    /// way to avoid this problem; the easiest fix is to design the network
    /// protocol such that the client will never send data "out of turn".
    /// Another solution is for the server to half-close the connection by
    /// calling g_socket_shutdown() with only the @shutdown_write flag set,
    /// and then wait for the client to notice this and close its side of the
    /// connection, after which the server can safely call g_socket_close().
    /// (This is what #GTcpConnection does if you call
    /// g_tcp_connection_set_graceful_disconnect(). But of course, this
    /// only works if the client will close its connection after the server
    /// does.)
    ///
    /// # Returns
    ///
    /// [`true`] on success, [`false`] on error
    #[doc(alias = "g_socket_close")]
    fn close(&self) -> Result<(), glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::g_socket_close(self.as_ref().to_glib_none().0, &mut error);
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Checks on the readiness of @self to perform operations.
    /// The operations specified in @condition are checked for and masked
    /// against the currently-satisfied conditions on @self. The result
    /// is returned.
    ///
    /// Note that on Windows, it is possible for an operation to return
    /// [`IOErrorEnum::WouldBlock`][crate::IOErrorEnum::WouldBlock] even immediately after
    /// g_socket_condition_check() has claimed that the socket is ready for
    /// writing. Rather than calling g_socket_condition_check() and then
    /// writing to the socket if it succeeds, it is generally better to
    /// simply try writing to the socket right away, and try again later if
    /// the initial attempt returns [`IOErrorEnum::WouldBlock`][crate::IOErrorEnum::WouldBlock].
    ///
    /// It is meaningless to specify [`glib::IOCondition::ERR`][crate::glib::IOCondition::ERR] or [`glib::IOCondition::HUP`][crate::glib::IOCondition::HUP] in condition;
    /// these conditions will always be set in the output if they are true.
    ///
    /// This call never blocks.
    /// ## `condition`
    /// a #GIOCondition mask to check
    ///
    /// # Returns
    ///
    /// the @GIOCondition mask of the current state
    #[doc(alias = "g_socket_condition_check")]
    fn condition_check(&self, condition: glib::IOCondition) -> glib::IOCondition {
        unsafe {
            from_glib(ffi::g_socket_condition_check(
                self.as_ref().to_glib_none().0,
                condition.into_glib(),
            ))
        }
    }

    /// Waits for up to @timeout_us microseconds for @condition to become true
    /// on @self. If the condition is met, [`true`] is returned.
    ///
    /// If @cancellable is cancelled before the condition is met, or if
    /// @timeout_us (or the socket's #GSocket:timeout) is reached before the
    /// condition is met, then [`false`] is returned and @error, if non-[`None`],
    /// is set to the appropriate value ([`IOErrorEnum::Cancelled`][crate::IOErrorEnum::Cancelled] or
    /// [`IOErrorEnum::TimedOut`][crate::IOErrorEnum::TimedOut]).
    ///
    /// If you don't want a timeout, use g_socket_condition_wait().
    /// (Alternatively, you can pass -1 for @timeout_us.)
    ///
    /// Note that although @timeout_us is in microseconds for consistency with
    /// other GLib APIs, this function actually only has millisecond
    /// resolution, and the behavior is undefined if @timeout_us is not an
    /// exact number of milliseconds.
    /// ## `condition`
    /// a #GIOCondition mask to wait for
    /// ## `timeout_us`
    /// the maximum time (in microseconds) to wait, or -1
    /// ## `cancellable`
    /// a #GCancellable, or [`None`]
    ///
    /// # Returns
    ///
    /// [`true`] if the condition was met, [`false`] otherwise
    #[doc(alias = "g_socket_condition_timed_wait")]
    fn condition_timed_wait(
        &self,
        condition: glib::IOCondition,
        timeout_us: i64,
        cancellable: Option<&impl IsA<Cancellable>>,
    ) -> Result<(), glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::g_socket_condition_timed_wait(
                self.as_ref().to_glib_none().0,
                condition.into_glib(),
                timeout_us,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                &mut error,
            );
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Waits for @condition to become true on @self. When the condition
    /// is met, [`true`] is returned.
    ///
    /// If @cancellable is cancelled before the condition is met, or if the
    /// socket has a timeout set and it is reached before the condition is
    /// met, then [`false`] is returned and @error, if non-[`None`], is set to
    /// the appropriate value ([`IOErrorEnum::Cancelled`][crate::IOErrorEnum::Cancelled] or
    /// [`IOErrorEnum::TimedOut`][crate::IOErrorEnum::TimedOut]).
    ///
    /// See also g_socket_condition_timed_wait().
    /// ## `condition`
    /// a #GIOCondition mask to wait for
    /// ## `cancellable`
    /// a #GCancellable, or [`None`]
    ///
    /// # Returns
    ///
    /// [`true`] if the condition was met, [`false`] otherwise
    #[doc(alias = "g_socket_condition_wait")]
    fn condition_wait(
        &self,
        condition: glib::IOCondition,
        cancellable: Option<&impl IsA<Cancellable>>,
    ) -> Result<(), glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::g_socket_condition_wait(
                self.as_ref().to_glib_none().0,
                condition.into_glib(),
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                &mut error,
            );
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Connect the socket to the specified remote address.
    ///
    /// For connection oriented socket this generally means we attempt to make
    /// a connection to the @address. For a connection-less socket it sets
    /// the default address for g_socket_send() and discards all incoming datagrams
    /// from other sources.
    ///
    /// Generally connection oriented sockets can only connect once, but
    /// connection-less sockets can connect multiple times to change the
    /// default address.
    ///
    /// If the connect call needs to do network I/O it will block, unless
    /// non-blocking I/O is enabled. Then [`IOErrorEnum::Pending`][crate::IOErrorEnum::Pending] is returned
    /// and the user can be notified of the connection finishing by waiting
    /// for the G_IO_OUT condition. The result of the connection must then be
    /// checked with g_socket_check_connect_result().
    /// ## `address`
    /// a #GSocketAddress specifying the remote address.
    /// ## `cancellable`
    /// a `GCancellable` or [`None`]
    ///
    /// # Returns
    ///
    /// [`true`] if connected, [`false`] on error.
    #[doc(alias = "g_socket_connect")]
    fn connect(
        &self,
        address: &impl IsA<SocketAddress>,
        cancellable: Option<&impl IsA<Cancellable>>,
    ) -> Result<(), glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::g_socket_connect(
                self.as_ref().to_glib_none().0,
                address.as_ref().to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                &mut error,
            );
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Creates a #GSocketConnection subclass of the right type for
    /// @self.
    ///
    /// # Returns
    ///
    /// a #GSocketConnection
    #[doc(alias = "g_socket_connection_factory_create_connection")]
    fn connection_factory_create_connection(&self) -> SocketConnection {
        unsafe {
            from_glib_full(ffi::g_socket_connection_factory_create_connection(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Get the amount of data pending in the OS input buffer, without blocking.
    ///
    /// If @self is a UDP or SCTP socket, this will return the size of
    /// just the next packet, even if additional packets are buffered after
    /// that one.
    ///
    /// Note that on Windows, this function is rather inefficient in the
    /// UDP case, and so if you know any plausible upper bound on the size
    /// of the incoming packet, it is better to just do a
    /// g_socket_receive() with a buffer of that size, rather than calling
    /// g_socket_get_available_bytes() first and then doing a receive of
    /// exactly the right size.
    ///
    /// # Returns
    ///
    /// the number of bytes that can be read from the socket
    /// without blocking or truncating, or -1 on error.
    #[doc(alias = "g_socket_get_available_bytes")]
    #[doc(alias = "get_available_bytes")]
    fn available_bytes(&self) -> isize {
        unsafe { ffi::g_socket_get_available_bytes(self.as_ref().to_glib_none().0) }
    }

    /// Gets the blocking mode of the socket. For details on blocking I/O,
    /// see g_socket_set_blocking().
    ///
    /// # Returns
    ///
    /// [`true`] if blocking I/O is used, [`false`] otherwise.
    #[doc(alias = "g_socket_get_blocking")]
    #[doc(alias = "get_blocking")]
    #[doc(alias = "blocking")]
    fn is_blocking(&self) -> bool {
        unsafe { from_glib(ffi::g_socket_get_blocking(self.as_ref().to_glib_none().0)) }
    }

    /// Gets the broadcast setting on @self; if [`true`],
    /// it is possible to send packets to broadcast
    /// addresses.
    ///
    /// # Returns
    ///
    /// the broadcast setting on @self
    #[doc(alias = "g_socket_get_broadcast")]
    #[doc(alias = "get_broadcast")]
    #[doc(alias = "broadcast")]
    fn is_broadcast(&self) -> bool {
        unsafe { from_glib(ffi::g_socket_get_broadcast(self.as_ref().to_glib_none().0)) }
    }

    /// Returns the credentials of the foreign process connected to this
    /// socket, if any (e.g. it is only supported for [`SocketFamily::Unix`][crate::SocketFamily::Unix]
    /// sockets).
    ///
    /// If this operation isn't supported on the OS, the method fails with
    /// the [`IOErrorEnum::NotSupported`][crate::IOErrorEnum::NotSupported] error. On Linux this is implemented
    /// by reading the `SO_PEERCRED` option on the underlying socket.
    ///
    /// This method can be expected to be available on the following platforms:
    ///
    /// - Linux since GLib 2.26
    /// - OpenBSD since GLib 2.30
    /// - Solaris, Illumos and OpenSolaris since GLib 2.40
    /// - NetBSD since GLib 2.42
    /// - macOS, tvOS, iOS since GLib 2.66
    ///
    /// Other ways to obtain credentials from a foreign peer includes the
    /// #GUnixCredentialsMessage type and
    /// g_unix_connection_send_credentials() /
    /// g_unix_connection_receive_credentials() functions.
    ///
    /// # Returns
    ///
    /// [`None`] if @error is set, otherwise a #GCredentials object
    /// that must be freed with g_object_unref().
    #[doc(alias = "g_socket_get_credentials")]
    #[doc(alias = "get_credentials")]
    fn credentials(&self) -> Result<Credentials, glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let ret = ffi::g_socket_get_credentials(self.as_ref().to_glib_none().0, &mut error);
            if error.is_null() {
                Ok(from_glib_full(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Gets the socket family of the socket.
    ///
    /// # Returns
    ///
    /// a #GSocketFamily
    #[doc(alias = "g_socket_get_family")]
    #[doc(alias = "get_family")]
    fn family(&self) -> SocketFamily {
        unsafe { from_glib(ffi::g_socket_get_family(self.as_ref().to_glib_none().0)) }
    }

    /// Gets the keepalive mode of the socket. For details on this,
    /// see g_socket_set_keepalive().
    ///
    /// # Returns
    ///
    /// [`true`] if keepalive is active, [`false`] otherwise.
    #[doc(alias = "g_socket_get_keepalive")]
    #[doc(alias = "get_keepalive")]
    #[doc(alias = "keepalive")]
    fn is_keepalive(&self) -> bool {
        unsafe { from_glib(ffi::g_socket_get_keepalive(self.as_ref().to_glib_none().0)) }
    }

    /// Gets the listen backlog setting of the socket. For details on this,
    /// see g_socket_set_listen_backlog().
    ///
    /// # Returns
    ///
    /// the maximum number of pending connections.
    #[doc(alias = "g_socket_get_listen_backlog")]
    #[doc(alias = "get_listen_backlog")]
    #[doc(alias = "listen-backlog")]
    fn listen_backlog(&self) -> i32 {
        unsafe { ffi::g_socket_get_listen_backlog(self.as_ref().to_glib_none().0) }
    }

    /// 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.
    ///
    /// # Returns
    ///
    /// a #GSocketAddress or [`None`] on error.
    ///     Free the returned object with g_object_unref().
    #[doc(alias = "g_socket_get_local_address")]
    #[doc(alias = "get_local_address")]
    #[doc(alias = "local-address")]
    fn local_address(&self) -> Result<SocketAddress, glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let ret = ffi::g_socket_get_local_address(self.as_ref().to_glib_none().0, &mut error);
            if error.is_null() {
                Ok(from_glib_full(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Gets the multicast loopback setting on @self; if [`true`] (the
    /// default), outgoing multicast packets will be looped back to
    /// multicast listeners on the same host.
    ///
    /// # Returns
    ///
    /// the multicast loopback setting on @self
    #[doc(alias = "g_socket_get_multicast_loopback")]
    #[doc(alias = "get_multicast_loopback")]
    #[doc(alias = "multicast-loopback")]
    fn is_multicast_loopback(&self) -> bool {
        unsafe {
            from_glib(ffi::g_socket_get_multicast_loopback(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets the multicast time-to-live setting on @self; see
    /// g_socket_set_multicast_ttl() for more details.
    ///
    /// # Returns
    ///
    /// the multicast time-to-live setting on @self
    #[doc(alias = "g_socket_get_multicast_ttl")]
    #[doc(alias = "get_multicast_ttl")]
    #[doc(alias = "multicast-ttl")]
    fn multicast_ttl(&self) -> u32 {
        unsafe { ffi::g_socket_get_multicast_ttl(self.as_ref().to_glib_none().0) }
    }

    /// Gets the value of an integer-valued option on @self, as with
    /// getsockopt(). (If you need to fetch a  non-integer-valued option,
    /// you will need to call getsockopt() directly.)
    ///
    /// The [`<gio/gnetworking.h>`](networking.html)
    /// header pulls in system headers that will define most of the
    /// standard/portable socket options. For unusual socket protocols or
    /// platform-dependent options, you may need to include additional
    /// headers.
    ///
    /// Note that even for socket options that are a single byte in size,
    /// @value is still a pointer to a #gint variable, not a #guchar;
    /// g_socket_get_option() will handle the conversion internally.
    /// ## `level`
    /// the "API level" of the option (eg, `SOL_SOCKET`)
    /// ## `optname`
    /// the "name" of the option (eg, `SO_BROADCAST`)
    ///
    /// # Returns
    ///
    /// success or failure. On failure, @error will be set, and
    ///   the system error value (`errno` or WSAGetLastError()) will still
    ///   be set to the result of the getsockopt() call.
    ///
    /// ## `value`
    /// return location for the option value
    #[doc(alias = "g_socket_get_option")]
    #[doc(alias = "get_option")]
    fn option(&self, level: i32, optname: i32) -> Result<i32, glib::Error> {
        unsafe {
            let mut value = std::mem::MaybeUninit::uninit();
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::g_socket_get_option(
                self.as_ref().to_glib_none().0,
                level,
                optname,
                value.as_mut_ptr(),
                &mut error,
            );
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(value.assume_init())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Gets the socket protocol id the socket was created with.
    /// In case the protocol is unknown, -1 is returned.
    ///
    /// # Returns
    ///
    /// a protocol id, or -1 if unknown
    #[doc(alias = "g_socket_get_protocol")]
    #[doc(alias = "get_protocol")]
    fn protocol(&self) -> SocketProtocol {
        unsafe { from_glib(ffi::g_socket_get_protocol(self.as_ref().to_glib_none().0)) }
    }

    /// Try to get the remote address of a connected socket. This is only
    /// useful for connection oriented sockets that have been connected.
    ///
    /// # Returns
    ///
    /// a #GSocketAddress or [`None`] on error.
    ///     Free the returned object with g_object_unref().
    #[doc(alias = "g_socket_get_remote_address")]
    #[doc(alias = "get_remote_address")]
    #[doc(alias = "remote-address")]
    fn remote_address(&self) -> Result<SocketAddress, glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let ret = ffi::g_socket_get_remote_address(self.as_ref().to_glib_none().0, &mut error);
            if error.is_null() {
                Ok(from_glib_full(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Gets the socket type of the socket.
    ///
    /// # Returns
    ///
    /// a #GSocketType
    #[doc(alias = "g_socket_get_socket_type")]
    #[doc(alias = "get_socket_type")]
    fn socket_type(&self) -> SocketType {
        unsafe {
            from_glib(ffi::g_socket_get_socket_type(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets the timeout setting of the socket. For details on this, see
    /// g_socket_set_timeout().
    ///
    /// # Returns
    ///
    /// the timeout in seconds
    #[doc(alias = "g_socket_get_timeout")]
    #[doc(alias = "get_timeout")]
    fn timeout(&self) -> u32 {
        unsafe { ffi::g_socket_get_timeout(self.as_ref().to_glib_none().0) }
    }

    /// Gets the unicast time-to-live setting on @self; see
    /// g_socket_set_ttl() for more details.
    ///
    /// # Returns
    ///
    /// the time-to-live setting on @self
    #[doc(alias = "g_socket_get_ttl")]
    #[doc(alias = "get_ttl")]
    fn ttl(&self) -> u32 {
        unsafe { ffi::g_socket_get_ttl(self.as_ref().to_glib_none().0) }
    }

    /// Checks whether a socket is closed.
    ///
    /// # Returns
    ///
    /// [`true`] if socket is closed, [`false`] otherwise
    #[doc(alias = "g_socket_is_closed")]
    fn is_closed(&self) -> bool {
        unsafe { from_glib(ffi::g_socket_is_closed(self.as_ref().to_glib_none().0)) }
    }

    /// Check whether the socket is connected. This is only useful for
    /// connection-oriented sockets.
    ///
    /// If using g_socket_shutdown(), this function will return [`true`] until the
    /// socket has been shut down for reading and writing. If you do a non-blocking
    /// connect, this function will not return [`true`] until after you call
    /// g_socket_check_connect_result().
    ///
    /// # Returns
    ///
    /// [`true`] if socket is connected, [`false`] otherwise.
    #[doc(alias = "g_socket_is_connected")]
    fn is_connected(&self) -> bool {
        unsafe { from_glib(ffi::g_socket_is_connected(self.as_ref().to_glib_none().0)) }
    }

    /// Registers @self to receive multicast messages sent to @group.
    /// @self must be a [`SocketType::Datagram`][crate::SocketType::Datagram] socket, and must have
    /// been bound to an appropriate interface and port with
    /// g_socket_bind().
    ///
    /// If @iface is [`None`], the system will automatically pick an interface
    /// to bind to based on @group.
    ///
    /// If @source_specific is [`true`], source-specific multicast as defined
    /// in RFC 4604 is used. Note that on older platforms this may fail
    /// with a [`IOErrorEnum::NotSupported`][crate::IOErrorEnum::NotSupported] error.
    ///
    /// To bind to a given source-specific multicast address, use
    /// g_socket_join_multicast_group_ssm() instead.
    /// ## `group`
    /// a #GInetAddress specifying the group address to join.
    /// ## `source_specific`
    /// [`true`] if source-specific multicast should be used
    /// ## `iface`
    /// Name of the interface to use, or [`None`]
    ///
    /// # Returns
    ///
    /// [`true`] on success, [`false`] on error.
    #[doc(alias = "g_socket_join_multicast_group")]
    fn join_multicast_group(
        &self,
        group: &impl IsA<InetAddress>,
        source_specific: bool,
        iface: Option<&str>,
    ) -> Result<(), glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::g_socket_join_multicast_group(
                self.as_ref().to_glib_none().0,
                group.as_ref().to_glib_none().0,
                source_specific.into_glib(),
                iface.to_glib_none().0,
                &mut error,
            );
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Registers @self to receive multicast messages sent to @group.
    /// @self must be a [`SocketType::Datagram`][crate::SocketType::Datagram] socket, and must have
    /// been bound to an appropriate interface and port with
    /// g_socket_bind().
    ///
    /// If @iface is [`None`], the system will automatically pick an interface
    /// to bind to based on @group.
    ///
    /// If @source_specific is not [`None`], use source-specific multicast as
    /// defined in RFC 4604. Note that on older platforms this may fail
    /// with a [`IOErrorEnum::NotSupported`][crate::IOErrorEnum::NotSupported] error.
    ///
    /// Note that this function can be called multiple times for the same
    /// @group with different @source_specific in order to receive multicast
    /// packets from more than one source.
    /// ## `group`
    /// a #GInetAddress specifying the group address to join.
    /// ## `source_specific`
    /// a #GInetAddress specifying the
    /// source-specific multicast address or [`None`] to ignore.
    /// ## `iface`
    /// Name of the interface to use, or [`None`]
    ///
    /// # Returns
    ///
    /// [`true`] on success, [`false`] on error.
    #[doc(alias = "g_socket_join_multicast_group_ssm")]
    fn join_multicast_group_ssm(
        &self,
        group: &impl IsA<InetAddress>,
        source_specific: Option<&impl IsA<InetAddress>>,
        iface: Option<&str>,
    ) -> Result<(), glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::g_socket_join_multicast_group_ssm(
                self.as_ref().to_glib_none().0,
                group.as_ref().to_glib_none().0,
                source_specific.map(|p| p.as_ref()).to_glib_none().0,
                iface.to_glib_none().0,
                &mut error,
            );
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Removes @self 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).
    ///
    /// @self remains bound to its address and port, and can still receive
    /// unicast messages after calling this.
    ///
    /// To unbind to a given source-specific multicast address, use
    /// g_socket_leave_multicast_group_ssm() instead.
    /// ## `group`
    /// a #GInetAddress specifying the group address to leave.
    /// ## `source_specific`
    /// [`true`] if source-specific multicast was used
    /// ## `iface`
    /// Interface used
    ///
    /// # Returns
    ///
    /// [`true`] on success, [`false`] on error.
    #[doc(alias = "g_socket_leave_multicast_group")]
    fn leave_multicast_group(
        &self,
        group: &impl IsA<InetAddress>,
        source_specific: bool,
        iface: Option<&str>,
    ) -> Result<(), glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::g_socket_leave_multicast_group(
                self.as_ref().to_glib_none().0,
                group.as_ref().to_glib_none().0,
                source_specific.into_glib(),
                iface.to_glib_none().0,
                &mut error,
            );
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Removes @self 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).
    ///
    /// @self remains bound to its address and port, and can still receive
    /// unicast messages after calling this.
    /// ## `group`
    /// a #GInetAddress specifying the group address to leave.
    /// ## `source_specific`
    /// a #GInetAddress specifying the
    /// source-specific multicast address or [`None`] to ignore.
    /// ## `iface`
    /// Name of the interface to use, or [`None`]
    ///
    /// # Returns
    ///
    /// [`true`] on success, [`false`] on error.
    #[doc(alias = "g_socket_leave_multicast_group_ssm")]
    fn leave_multicast_group_ssm(
        &self,
        group: &impl IsA<InetAddress>,
        source_specific: Option<&impl IsA<InetAddress>>,
        iface: Option<&str>,
    ) -> Result<(), glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::g_socket_leave_multicast_group_ssm(
                self.as_ref().to_glib_none().0,
                group.as_ref().to_glib_none().0,
                source_specific.map(|p| p.as_ref()).to_glib_none().0,
                iface.to_glib_none().0,
                &mut error,
            );
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Marks the socket as a server socket, i.e. a socket that is used
    /// to accept incoming requests using g_socket_accept().
    ///
    /// Before calling this the socket must be bound to a local address using
    /// g_socket_bind().
    ///
    /// To set the maximum amount of outstanding clients, use
    /// g_socket_set_listen_backlog().
    ///
    /// # Returns
    ///
    /// [`true`] on success, [`false`] on error.
    #[doc(alias = "g_socket_listen")]
    fn listen(&self) -> Result<(), glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::g_socket_listen(self.as_ref().to_glib_none().0, &mut error);
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Sets the blocking mode of the socket. In blocking mode
    /// all operations (which don’t take an explicit blocking parameter) block until
    /// they succeed or there is an error. In
    /// non-blocking mode all functions return results immediately or
    /// with a [`IOErrorEnum::WouldBlock`][crate::IOErrorEnum::WouldBlock] error.
    ///
    /// All sockets are created in blocking mode. However, note that the
    /// platform level socket is always non-blocking, and blocking mode
    /// is a GSocket level feature.
    /// ## `blocking`
    /// Whether to use blocking I/O or not.
    #[doc(alias = "g_socket_set_blocking")]
    #[doc(alias = "blocking")]
    fn set_blocking(&self, blocking: bool) {
        unsafe {
            ffi::g_socket_set_blocking(self.as_ref().to_glib_none().0, blocking.into_glib());
        }
    }

    /// Sets whether @self should allow sending to broadcast addresses.
    /// This is [`false`] by default.
    /// ## `broadcast`
    /// whether @self should allow sending to broadcast
    ///     addresses
    #[doc(alias = "g_socket_set_broadcast")]
    #[doc(alias = "broadcast")]
    fn set_broadcast(&self, broadcast: bool) {
        unsafe {
            ffi::g_socket_set_broadcast(self.as_ref().to_glib_none().0, broadcast.into_glib());
        }
    }

    /// Sets or unsets the `SO_KEEPALIVE` flag on the underlying socket. When
    /// this flag is set on a socket, the system will attempt to verify that the
    /// remote socket endpoint is still present if a sufficiently long period of
    /// time passes with no data being exchanged. If the system is unable to
    /// verify the presence of the remote endpoint, it will automatically close
    /// the connection.
    ///
    /// This option is only functional on certain kinds of sockets. (Notably,
    /// [`SocketProtocol::Tcp`][crate::SocketProtocol::Tcp] sockets.)
    ///
    /// The exact time between pings is system- and protocol-dependent, but will
    /// normally be at least two hours. Most commonly, you would set this flag
    /// on a server socket if you want to allow clients to remain idle for long
    /// periods of time, but also want to ensure that connections are eventually
    /// garbage-collected if clients crash or become unreachable.
    /// ## `keepalive`
    /// Value for the keepalive flag
    #[doc(alias = "g_socket_set_keepalive")]
    #[doc(alias = "keepalive")]
    fn set_keepalive(&self, keepalive: bool) {
        unsafe {
            ffi::g_socket_set_keepalive(self.as_ref().to_glib_none().0, keepalive.into_glib());
        }
    }

    /// Sets the maximum number of outstanding connections allowed
    /// when listening on this socket. If more clients than this are
    /// connecting to the socket and the application is not handling them
    /// on time then the new connections will be refused.
    ///
    /// Note that this must be called before g_socket_listen() and has no
    /// effect if called after that.
    /// ## `backlog`
    /// the maximum number of pending connections.
    #[doc(alias = "g_socket_set_listen_backlog")]
    #[doc(alias = "listen-backlog")]
    fn set_listen_backlog(&self, backlog: i32) {
        unsafe {
            ffi::g_socket_set_listen_backlog(self.as_ref().to_glib_none().0, backlog);
        }
    }

    /// Sets whether outgoing multicast packets will be received by sockets
    /// listening on that multicast address on the same host. This is [`true`]
    /// by default.
    /// ## `loopback`
    /// whether @self should receive messages sent to its
    ///   multicast groups from the local host
    #[doc(alias = "g_socket_set_multicast_loopback")]
    #[doc(alias = "multicast-loopback")]
    fn set_multicast_loopback(&self, loopback: bool) {
        unsafe {
            ffi::g_socket_set_multicast_loopback(
                self.as_ref().to_glib_none().0,
                loopback.into_glib(),
            );
        }
    }

    /// Sets the time-to-live for outgoing multicast datagrams on @self.
    /// By default, this is 1, meaning that multicast packets will not leave
    /// the local network.
    /// ## `ttl`
    /// the time-to-live value for all multicast datagrams on @self
    #[doc(alias = "g_socket_set_multicast_ttl")]
    #[doc(alias = "multicast-ttl")]
    fn set_multicast_ttl(&self, ttl: u32) {
        unsafe {
            ffi::g_socket_set_multicast_ttl(self.as_ref().to_glib_none().0, ttl);
        }
    }

    /// Sets the value of an integer-valued option on @self, as with
    /// setsockopt(). (If you need to set a non-integer-valued option,
    /// you will need to call setsockopt() directly.)
    ///
    /// The [`<gio/gnetworking.h>`](networking.html)
    /// header pulls in system headers that will define most of the
    /// standard/portable socket options. For unusual socket protocols or
    /// platform-dependent options, you may need to include additional
    /// headers.
    /// ## `level`
    /// the "API level" of the option (eg, `SOL_SOCKET`)
    /// ## `optname`
    /// the "name" of the option (eg, `SO_BROADCAST`)
    /// ## `value`
    /// the value to set the option to
    ///
    /// # Returns
    ///
    /// success or failure. On failure, @error will be set, and
    ///   the system error value (`errno` or WSAGetLastError()) will still
    ///   be set to the result of the setsockopt() call.
    #[doc(alias = "g_socket_set_option")]
    fn set_option(&self, level: i32, optname: i32, value: i32) -> Result<(), glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::g_socket_set_option(
                self.as_ref().to_glib_none().0,
                level,
                optname,
                value,
                &mut error,
            );
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Sets the time in seconds after which I/O operations on @self will
    /// time out if they have not yet completed.
    ///
    /// On a blocking socket, this means that any blocking #GSocket
    /// operation will time out after @timeout seconds of inactivity,
    /// returning [`IOErrorEnum::TimedOut`][crate::IOErrorEnum::TimedOut].
    ///
    /// On a non-blocking socket, calls to g_socket_condition_wait() will
    /// also fail with [`IOErrorEnum::TimedOut`][crate::IOErrorEnum::TimedOut] after the given time. Sources
    /// created with g_socket_create_source() will trigger after
    /// @timeout seconds of inactivity, with the requested condition
    /// set, at which point calling g_socket_receive(), g_socket_send(),
    /// g_socket_check_connect_result(), etc, will fail with
    /// [`IOErrorEnum::TimedOut`][crate::IOErrorEnum::TimedOut].
    ///
    /// If @timeout is 0 (the default), operations will never time out
    /// on their own.
    ///
    /// Note that if an I/O operation is interrupted by a signal, this may
    /// cause the timeout to be reset.
    /// ## `timeout`
    /// the timeout for @self, in seconds, or 0 for none
    #[doc(alias = "g_socket_set_timeout")]
    #[doc(alias = "timeout")]
    fn set_timeout(&self, timeout: u32) {
        unsafe {
            ffi::g_socket_set_timeout(self.as_ref().to_glib_none().0, timeout);
        }
    }

    /// Sets the time-to-live for outgoing unicast packets on @self.
    /// By default the platform-specific default value is used.
    /// ## `ttl`
    /// the time-to-live value for all unicast packets on @self
    #[doc(alias = "g_socket_set_ttl")]
    #[doc(alias = "ttl")]
    fn set_ttl(&self, ttl: u32) {
        unsafe {
            ffi::g_socket_set_ttl(self.as_ref().to_glib_none().0, ttl);
        }
    }

    /// Shut down part or all of a full-duplex connection.
    ///
    /// If @shutdown_read is [`true`] then the receiving side of the connection
    /// is shut down, and further reading is disallowed.
    ///
    /// If @shutdown_write is [`true`] then the sending side of the connection
    /// is shut down, and further writing is disallowed.
    ///
    /// It is allowed for both @shutdown_read and @shutdown_write to be [`true`].
    ///
    /// One example where it is useful to shut down only one side of a connection is
    /// graceful disconnect for TCP connections where you close the sending side,
    /// then wait for the other side to close the connection, thus ensuring that the
    /// other side saw all sent data.
    /// ## `shutdown_read`
    /// whether to shut down the read side
    /// ## `shutdown_write`
    /// whether to shut down the write side
    ///
    /// # Returns
    ///
    /// [`true`] on success, [`false`] on error
    #[doc(alias = "g_socket_shutdown")]
    fn shutdown(&self, shutdown_read: bool, shutdown_write: bool) -> Result<(), glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::g_socket_shutdown(
                self.as_ref().to_glib_none().0,
                shutdown_read.into_glib(),
                shutdown_write.into_glib(),
                &mut error,
            );
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Checks if a socket is capable of speaking IPv4.
    ///
    /// IPv4 sockets are capable of speaking IPv4.  On some operating systems
    /// and under some combinations of circumstances IPv6 sockets are also
    /// capable of speaking IPv4.  See RFC 3493 section 3.7 for more
    /// information.
    ///
    /// No other types of sockets are currently considered as being capable
    /// of speaking IPv4.
    ///
    /// # Returns
    ///
    /// [`true`] if this socket can be used with IPv4.
    #[doc(alias = "g_socket_speaks_ipv4")]
    fn speaks_ipv4(&self) -> bool {
        unsafe { from_glib(ffi::g_socket_speaks_ipv4(self.as_ref().to_glib_none().0)) }
    }

    /// The socket’s type.
    #[doc(alias = "type")]
    fn type_(&self) -> SocketType {
        ObjectExt::property(self.as_ref(), "type")
    }

    #[doc(alias = "blocking")]
    fn connect_blocking_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_blocking_trampoline<P: IsA<Socket>, F: Fn(&P) + 'static>(
            this: *mut ffi::GSocket,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Socket::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::blocking".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_blocking_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "broadcast")]
    fn connect_broadcast_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_broadcast_trampoline<P: IsA<Socket>, F: Fn(&P) + 'static>(
            this: *mut ffi::GSocket,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Socket::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::broadcast".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_broadcast_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "keepalive")]
    fn connect_keepalive_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_keepalive_trampoline<P: IsA<Socket>, F: Fn(&P) + 'static>(
            this: *mut ffi::GSocket,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Socket::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::keepalive".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_keepalive_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "listen-backlog")]
    fn connect_listen_backlog_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_listen_backlog_trampoline<
            P: IsA<Socket>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GSocket,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Socket::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::listen-backlog".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_listen_backlog_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "local-address")]
    fn connect_local_address_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_local_address_trampoline<
            P: IsA<Socket>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GSocket,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Socket::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::local-address".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_local_address_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "multicast-loopback")]
    fn connect_multicast_loopback_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_multicast_loopback_trampoline<
            P: IsA<Socket>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GSocket,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Socket::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::multicast-loopback".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_multicast_loopback_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "multicast-ttl")]
    fn connect_multicast_ttl_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_multicast_ttl_trampoline<
            P: IsA<Socket>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GSocket,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Socket::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::multicast-ttl".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_multicast_ttl_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "remote-address")]
    fn connect_remote_address_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_remote_address_trampoline<
            P: IsA<Socket>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GSocket,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Socket::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::remote-address".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_remote_address_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "timeout")]
    fn connect_timeout_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_timeout_trampoline<P: IsA<Socket>, F: Fn(&P) + 'static>(
            this: *mut ffi::GSocket,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Socket::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::timeout".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_timeout_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "ttl")]
    fn connect_ttl_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_ttl_trampoline<P: IsA<Socket>, F: Fn(&P) + 'static>(
            this: *mut ffi::GSocket,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Socket::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::ttl".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_ttl_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}

impl<O: IsA<Socket>> SocketExt for O {}