g_unix_open_pipe ()

gboolean
g_unix_open_pipe (gint *fds,
                  gint flags,
                  GError **error);

Similar to the UNIX pipe() call, but on modern systems like Linux uses the pipe2() system call, which atomically creates a pipe with the configured flags. The only supported flag currently is FD_CLOEXEC. If for example you want to configure O_NONBLOCK, that must still be done separately with fcntl().

This function does not take O_CLOEXEC, it takes FD_CLOEXEC as if for fcntl(); these are different on Linux/glibc.

Since: 2.30

g_unix_set_fd_nonblocking ()

gboolean
g_unix_set_fd_nonblocking (gint fd,
                           gboolean nonblock,
                           GError **error);

Control the non-blocking state of the given file descriptor, according to nonblock . On most systems this uses O_NONBLOCK, but on some older ones may use O_NDELAY.

Since: 2.30

g_unix_signal_add ()

guint
g_unix_signal_add (gint signum,
                   GSourceFunc handler,
                   gpointer user_data);

A convenience function for g_unix_signal_source_new(), which attaches to the default GMainContext. You can remove the watch using g_source_remove().

Since: 2.30

g_unix_signal_add_full ()

guint
g_unix_signal_add_full (gint priority,
                        gint signum,
                        GSourceFunc handler,
                        gpointer user_data,
                        GDestroyNotify notify);

A convenience function for g_unix_signal_source_new(), which attaches to the default GMainContext. You can remove the watch using g_source_remove().

[rename-to g_unix_signal_add]

Since: 2.30

g_unix_signal_source_new ()

GSource *
g_unix_signal_source_new (gint signum);

Create a GSource that will be dispatched upon delivery of the UNIX signal signum . In GLib versions before 2.36, only SIGHUP, SIGINT, SIGTERM can be monitored. In GLib 2.36, SIGUSR1 and SIGUSR2 were added. In GLib 2.54, SIGWINCH was added.

Note that unlike the UNIX default, all sources which have created a watch will be dispatched, regardless of which underlying thread invoked g_unix_signal_source_new().

For example, an effective use of this function is to handle SIGTERM cleanly; flushing any outstanding files, and then calling g_main_loop_quit(). It is not safe to do any of this from a regular UNIX signal handler; such a handler may be invoked while malloc() or another library function is running, causing reentrancy issues if the handler attempts to use those functions. None of the GLib/GObject API is safe against this kind of reentrancy.

The interaction of this source when combined with native UNIX functions like sigprocmask() is not defined.

The source will not initially be associated with any GMainContext and must be added to one with g_source_attach() before it will be executed.

Since: 2.30

GUnixFDSourceFunc ()

gboolean
(*GUnixFDSourceFunc) (gint fd,
                      GIOCondition condition,
                      gpointer user_data);

The type of functions to be called when a UNIX fd watch source triggers.

g_unix_fd_add ()

guint
g_unix_fd_add (gint fd,
               GIOCondition condition,
               GUnixFDSourceFunc function,
               gpointer user_data);

Sets a function to be called when the IO condition, as specified by condition becomes true for fd .

function will be called when the specified IO condition becomes TRUE. The function is expected to clear whatever event caused the IO condition to become true and return TRUE in order to be notified when it happens again. If function returns FALSE then the watch will be cancelled.

The return value of this function can be passed to g_source_remove() to cancel the watch at any time that it exists.

The source will never close the fd -- you must do it yourself.

Since: 2.36

g_unix_fd_add_full ()

guint
g_unix_fd_add_full (gint priority,
                    gint fd,
                    GIOCondition condition,
                    GUnixFDSourceFunc function,
                    gpointer user_data,
                    GDestroyNotify notify);

Sets a function to be called when the IO condition, as specified by condition becomes true for fd .

This is the same as g_unix_fd_add(), except that it allows you to specify a non-default priority and a provide a GDestroyNotify for user_data .

Since: 2.36

g_unix_fd_source_new ()

GSource *
g_unix_fd_source_new (gint fd,
                      GIOCondition condition);

Creates a GSource to watch for a particular IO condition on a file descriptor.

The source will never close the fd -- you must do it yourself.

Since: 2.36

g_unix_get_passwd_entry ()

struct passwd *
g_unix_get_passwd_entry (const gchar *user_name,
                         GError **error);

Get the passwd file entry for the given user_name using getpwnam_r(). This can fail if the given user_name doesn’t exist.

The returned struct passwd has been allocated using g_malloc() and should be freed using g_free(). The strings referenced by the returned struct are included in the same allocation, so are valid until the struct passwd is freed.

This function is safe to call from multiple threads concurrently.

You will need to include pwd.h to get the definition of struct passwd.

Since: 2.64

G_UNIX_ERROR

#define G_UNIX_ERROR (g_unix_error_quark())

Error domain for API in the g_unix_ namespace. Note that there is no exported enumeration mapping errno. Instead, all functions ensure that errno is relevant. The code for all G_UNIX_ERROR is always 0, and the error message is always generated via g_strerror().

It is expected that most code will not look at errno from these APIs. Important cases where one would want to differentiate between errors are already covered by existing cross-platform GLib API, such as e.g. GFile wrapping ENOENT. However, it is provided for completeness, at least.