struct GIOChannel

struct GIOChannel {
};

A data structure representing an IO Channel. The fields should be considered private and should only be accessed with the following functions.

g_io_channel_unix_new ()

GIOChannel *        g_io_channel_unix_new               (int fd);

Creates a new GIOChannel given a file descriptor. On UNIX systems this works for plain files, pipes, and sockets.

The returned GIOChannel has a reference count of 1.

The default encoding for GIOChannel is UTF-8. If your application is reading output from a command using via pipe, you may need to set the encoding to the encoding of the current locale (see g_get_charset()) with the g_io_channel_set_encoding() function.

If you want to read raw binary data without interpretation, then call the g_io_channel_set_encoding() function with NULL for the encoding argument.

This function is available in GLib on Windows, too, but you should avoid using it on Windows. The domain of file descriptors and sockets overlap. There is no way for GLib to know which one you mean in case the argument you pass to this function happens to be both a valid file descriptor and socket. If that happens a warning is issued, and GLib assumes that it is the file descriptor you mean.

g_io_channel_unix_get_fd ()

gint                g_io_channel_unix_get_fd            (GIOChannel *channel);

Returns the file descriptor of the GIOChannel.

On Windows this function returns the file descriptor or socket of the GIOChannel.

g_io_channel_win32_new_fd ()

GIOChannel *        g_io_channel_win32_new_fd           (gint fd);

Creates a new GIOChannel given a file descriptor on Windows. This works for file descriptors from the C runtime.

This function works for file descriptors as returned by the open(), creat(), pipe() and fileno() calls in the Microsoft C runtime. In order to meaningfully use this function your code should use the same C runtime as GLib uses, which is msvcrt.dll. Note that in current Microsoft compilers it is near impossible to convince it to build code that would use msvcrt.dll. The last Microsoft compiler version that supported using msvcrt.dll as the C runtime was version 6. The GNU compiler and toolchain for Windows, also known as Mingw, fully supports msvcrt.dll.

If you have created a GIOChannel for a file descriptor and started watching (polling) it, you shouldn't call read() on the file descriptor. This is because adding polling for a file descriptor is implemented in GLib on Windows by starting a thread that sits blocked in a read() from the file descriptor most of the time. All reads from the file descriptor should be done by this internal GLib thread. Your code should call only g_io_channel_read().

This function is available only in GLib on Windows.

g_io_channel_win32_new_socket ()

GIOChannel *        g_io_channel_win32_new_socket       (gint socket);

Creates a new GIOChannel given a socket on Windows.

This function works for sockets created by Winsock. It's available only in GLib on Windows.

Polling a GSource created to watch a channel for a socket puts the socket in non-blocking mode. This is a side-effect of the implementation and unavoidable.

g_io_channel_win32_new_messages ()

GIOChannel *        g_io_channel_win32_new_messages     (gsize hwnd);

Creates a new GIOChannel given a window handle on Windows.

This function creates a GIOChannel that can be used to poll for Windows messages for the window in question.

g_io_channel_init ()

void                g_io_channel_init                   (GIOChannel *channel);

Initializes a GIOChannel struct.

This is called by each of the above functions when creating a GIOChannel, and so is not often needed by the application programmer (unless you are creating a new type of GIOChannel).

g_io_channel_new_file

#define             g_io_channel_new_file

Open a file filename as a GIOChannel using mode mode. This channel will be closed when the last reference to it is dropped, so there is no need to call g_io_channel_close() (though doing so will not cause problems, as long as no attempt is made to access the channel after it is closed).

g_io_channel_read_chars ()

GIOStatus           g_io_channel_read_chars             (GIOChannel *channel,
                                                         gchar *buf,
                                                         gsize count,
                                                         gsize *bytes_read,
                                                         GError **error);

Replacement for g_io_channel_read() with the new API.

g_io_channel_read_unichar ()

GIOStatus           g_io_channel_read_unichar           (GIOChannel *channel,
                                                         gunichar *thechar,
                                                         GError **error);

Reads a Unicode character from channel. This function cannot be called on a channel with NULL encoding.

g_io_channel_read_line ()

GIOStatus           g_io_channel_read_line              (GIOChannel *channel,
                                                         gchar **str_return,
                                                         gsize *length,
                                                         gsize *terminator_pos,
                                                         GError **error);

Reads a line, including the terminating character(s), from a GIOChannel into a newly-allocated string. str_return will contain allocated memory if the return is G_IO_STATUS_NORMAL.

g_io_channel_read_line_string ()

GIOStatus           g_io_channel_read_line_string       (GIOChannel *channel,
                                                         GString *buffer,
                                                         gsize *terminator_pos,
                                                         GError **error);

Reads a line from a GIOChannel, using a GString as a buffer.

g_io_channel_read_to_end ()

GIOStatus           g_io_channel_read_to_end            (GIOChannel *channel,
                                                         gchar **str_return,
                                                         gsize *length,
                                                         GError **error);

Reads all the remaining data from the file.

g_io_channel_write_chars ()

GIOStatus           g_io_channel_write_chars            (GIOChannel *channel,
                                                         const gchar *buf,
                                                         gssize count,
                                                         gsize *bytes_written,
                                                         GError **error);

Replacement for g_io_channel_write() with the new API.

On seekable channels with encodings other than NULL or UTF-8, generic mixing of reading and writing is not allowed. A call to g_io_channel_write_chars() may only be made on a channel from which data has been read in the cases described in the documentation for g_io_channel_set_encoding().

g_io_channel_write_unichar ()

GIOStatus           g_io_channel_write_unichar          (GIOChannel *channel,
                                                         gunichar thechar,
                                                         GError **error);

Writes a Unicode character to channel. This function cannot be called on a channel with NULL encoding.

g_io_channel_flush ()

GIOStatus           g_io_channel_flush                  (GIOChannel *channel,
                                                         GError **error);

Flushes the write buffer for the GIOChannel.

g_io_channel_seek_position ()

GIOStatus           g_io_channel_seek_position          (GIOChannel *channel,
                                                         gint64 offset,
                                                         GSeekType type,
                                                         GError **error);

Replacement for g_io_channel_seek() with the new API.

enum GSeekType

typedef enum {
  G_SEEK_CUR,
  G_SEEK_SET,
  G_SEEK_END
} GSeekType;

An enumeration specifying the base position for a g_io_channel_seek_position() operation.

g_io_channel_shutdown ()

GIOStatus           g_io_channel_shutdown               (GIOChannel *channel,
                                                         gboolean flush,
                                                         GError **err);

Close an IO channel. Any pending data to be written will be flushed if flush is TRUE. The channel will not be freed until the last reference is dropped using g_io_channel_unref().

enum GIOStatus

typedef enum {
  G_IO_STATUS_ERROR,
  G_IO_STATUS_NORMAL,
  G_IO_STATUS_EOF,
  G_IO_STATUS_AGAIN
} GIOStatus;

Stati returned by most of the GIOFuncs functions.

enum GIOChannelError

typedef enum {
  /* Derived from errno */
  G_IO_CHANNEL_ERROR_FBIG,
  G_IO_CHANNEL_ERROR_INVAL,
  G_IO_CHANNEL_ERROR_IO,
  G_IO_CHANNEL_ERROR_ISDIR,
  G_IO_CHANNEL_ERROR_NOSPC,
  G_IO_CHANNEL_ERROR_NXIO,
  G_IO_CHANNEL_ERROR_OVERFLOW,
  G_IO_CHANNEL_ERROR_PIPE,
  /* Other */
  G_IO_CHANNEL_ERROR_FAILED
} GIOChannelError;

Error codes returned by GIOChannel operations.

G_IO_CHANNEL_ERROR

#define G_IO_CHANNEL_ERROR g_io_channel_error_quark()

Error domain for GIOChannel operations. Errors in this domain will be from the GIOChannelError enumeration. See GError for information on error domains.

g_io_channel_error_from_errno ()

GIOChannelError     g_io_channel_error_from_errno       (gint en);

Converts an errno error number to a GIOChannelError.

g_io_channel_ref ()

GIOChannel *        g_io_channel_ref                    (GIOChannel *channel);

Increments the reference count of a GIOChannel.

g_io_channel_unref ()

void                g_io_channel_unref                  (GIOChannel *channel);

Decrements the reference count of a GIOChannel.

g_io_create_watch ()

GSource *           g_io_create_watch                   (GIOChannel *channel,
                                                         GIOCondition condition);

Creates a GSource that's dispatched when condition is met for the given channel. For example, if condition is G_IO_IN, the source will be dispatched when there's data available for reading.

g_io_add_watch() is a simpler interface to this same functionality, for the case where you want to add the source to the default main loop context at the default priority.

On Windows, polling a GSource created to watch a channel for a socket puts the socket in non-blocking mode. This is a side-effect of the implementation and unavoidable.

g_io_add_watch ()

guint               g_io_add_watch                      (GIOChannel *channel,
                                                         GIOCondition condition,
                                                         GIOFunc func,
                                                         gpointer user_data);

Adds the GIOChannel into the default main loop context with the default priority.

g_io_add_watch_full ()

guint               g_io_add_watch_full                 (GIOChannel *channel,
                                                         gint priority,
                                                         GIOCondition condition,
                                                         GIOFunc func,
                                                         gpointer user_data,
                                                         GDestroyNotify notify);

Adds the GIOChannel into the default main loop context with the given priority.

This internally creates a main loop source using g_io_create_watch() and attaches it to the main loop context with g_source_attach(). You can do these steps manuallt if you need greater control.

enum GIOCondition

typedef enum {
  G_IO_IN GLIB_SYSDEF_POLLIN,
  G_IO_OUT GLIB_SYSDEF_POLLOUT,
  G_IO_PRI GLIB_SYSDEF_POLLPRI,
  G_IO_ERR GLIB_SYSDEF_POLLERR,
  G_IO_HUP GLIB_SYSDEF_POLLHUP,
  G_IO_NVAL GLIB_SYSDEF_POLLNVAL
} GIOCondition;

A bitwise combination representing a condition to watch for on an event source.

GIOFunc ()

gboolean            (*GIOFunc)                          (GIOChannel *source,
                                                         GIOCondition condition,
                                                         gpointer data);

Specifies the type of function passed to g_io_add_watch() or g_io_add_watch_full(), which is called when the requested condition on a GIOChannel is satisfied.

struct GIOFuncs

struct GIOFuncs {
  GIOStatus (*io_read)           (GIOChannel   *channel, 
			          gchar        *buf, 
				  gsize         count,
				  gsize        *bytes_read,
				  GError      **err);
  GIOStatus (*io_write)          (GIOChannel   *channel, 
				  const gchar  *buf, 
				  gsize         count,
				  gsize        *bytes_written,
				  GError      **err);
  GIOStatus (*io_seek)           (GIOChannel   *channel, 
				  gint64        offset, 
				  GSeekType     type,
				  GError      **err);
  GIOStatus  (*io_close)         (GIOChannel   *channel,
				  GError      **err);
  GSource*   (*io_create_watch)  (GIOChannel   *channel,
				  GIOCondition  condition);
  void       (*io_free)          (GIOChannel   *channel);
  GIOStatus  (*io_set_flags)     (GIOChannel   *channel,
                                  GIOFlags      flags,
				  GError      **err);
  GIOFlags   (*io_get_flags)     (GIOChannel   *channel);
};

A table of functions used to handle different types of GIOChannel in a generic way.

g_io_channel_get_buffer_size ()

gsize               g_io_channel_get_buffer_size        (GIOChannel *channel);

Gets the buffer size.

g_io_channel_set_buffer_size ()

void                g_io_channel_set_buffer_size        (GIOChannel *channel,
                                                         gsize size);

Sets the buffer size.

g_io_channel_get_buffer_condition ()

GIOCondition        g_io_channel_get_buffer_condition   (GIOChannel *channel);

This function returns a GIOCondition depending on whether there is data to be read/space to write data in the internal buffers in the GIOChannel. Only the flags G_IO_IN and G_IO_OUT may be set.

g_io_channel_get_flags ()

GIOFlags            g_io_channel_get_flags              (GIOChannel *channel);

Gets the current flags for a GIOChannel, including read-only flags such as G_IO_FLAG_IS_READABLE.

The values of the flags G_IO_FLAG_IS_READABLE and G_IO_FLAG_IS_WRITEABLE are cached for internal use by the channel when it is created. If they should change at some later point (e.g. partial shutdown of a socket with the UNIX shutdown() function), the user should immediately call g_io_channel_get_flags() to update the internal values of these flags.

g_io_channel_set_flags ()

GIOStatus           g_io_channel_set_flags              (GIOChannel *channel,
                                                         GIOFlags flags,
                                                         GError **error);

Sets the (writeable) flags in channel to (flags & G_IO_CHANNEL_SET_MASK).

enum GIOFlags

typedef enum {
  G_IO_FLAG_APPEND = 1 << 0,
  G_IO_FLAG_NONBLOCK = 1 << 1,
  G_IO_FLAG_IS_READABLE = 1 << 2, /* Read only flag */
  G_IO_FLAG_IS_WRITEABLE = 1 << 3, /* Read only flag */
  G_IO_FLAG_IS_SEEKABLE = 1 << 4, /* Read only flag */
  G_IO_FLAG_MASK = (1 << 5) - 1,
  G_IO_FLAG_GET_MASK = G_IO_FLAG_MASK,
  G_IO_FLAG_SET_MASK = G_IO_FLAG_APPEND | G_IO_FLAG_NONBLOCK
} GIOFlags;

Specifies properties of a GIOChannel. Some of the flags can only be read with g_io_channel_get_flags(), but not changed with g_io_channel_set_flags().

g_io_channel_get_line_term ()

const gchar *       g_io_channel_get_line_term          (GIOChannel *channel,
                                                         gint *length);

This returns the string that GIOChannel uses to determine where in the file a line break occurs. A value of NULL indicates autodetection.

g_io_channel_set_line_term ()

void                g_io_channel_set_line_term          (GIOChannel *channel,
                                                         const gchar *line_term,
                                                         gint length);

This sets the string that GIOChannel uses to determine where in the file a line break occurs.

g_io_channel_get_buffered ()

gboolean            g_io_channel_get_buffered           (GIOChannel *channel);

Returns whether channel is buffered.

g_io_channel_set_buffered ()

void                g_io_channel_set_buffered           (GIOChannel *channel,
                                                         gboolean buffered);

The buffering state can only be set if the channel's encoding is NULL. For any other encoding, the channel must be buffered.

A buffered channel can only be set unbuffered if the channel's internal buffers have been flushed. Newly created channels or channels which have returned G_IO_STATUS_EOF not require such a flush. For write-only channels, a call to g_io_channel_flush() is sufficient. For all other channels, the buffers may be flushed by a call to g_io_channel_seek_position(). This includes the possibility of seeking with seek type G_SEEK_CUR and an offset of zero. Note that this means that socket-based channels cannot be set unbuffered once they have had data read from them.

On unbuffered channels, it is safe to mix read and write calls from the new and old APIs, if this is necessary for maintaining old code.

The default state of the channel is buffered.

g_io_channel_get_encoding ()

const gchar *       g_io_channel_get_encoding           (GIOChannel *channel);

Gets the encoding for the input/output of the channel. The internal encoding is always UTF-8. The encoding NULL makes the channel safe for binary data.

g_io_channel_set_encoding ()

GIOStatus           g_io_channel_set_encoding           (GIOChannel *channel,
                                                         const gchar *encoding,
                                                         GError **error);

Sets the encoding for the input/output of the channel. The internal encoding is always UTF-8. The default encoding for the external file is UTF-8.

The encoding NULL is safe to use with binary data.

The encoding can only be set if one of the following conditions is true:

Channels which do not meet one of the above conditions cannot call g_io_channel_seek_position() with an offset of G_SEEK_CUR, and, if they are "seekable", cannot call g_io_channel_write_chars() after calling one of the API "read" functions.

g_io_channel_get_close_on_unref ()

gboolean            g_io_channel_get_close_on_unref     (GIOChannel *channel);

Returns whether the file/socket/whatever associated with channel will be closed when channel receives its final unref and is destroyed. The default value of this is TRUE for channels created by g_io_channel_new_file(), and FALSE for all other channels.

g_io_channel_set_close_on_unref ()

void                g_io_channel_set_close_on_unref     (GIOChannel *channel,
                                                         gboolean do_close);

Setting this flag to TRUE for a channel you have already closed can cause problems.

g_io_channel_read ()

GIOError            g_io_channel_read                   (GIOChannel *channel,
                                                         gchar *buf,
                                                         gsize count,
                                                         gsize *bytes_read);

Reads data from a GIOChannel.

enum GIOError

typedef enum {
  G_IO_ERROR_NONE,
  G_IO_ERROR_AGAIN,
  G_IO_ERROR_INVAL,
  G_IO_ERROR_UNKNOWN
} GIOError;

GIOError is only used by the deprecated functions g_io_channel_read(), g_io_channel_write(), and g_io_channel_seek().

g_io_channel_write ()

GIOError            g_io_channel_write                  (GIOChannel *channel,
                                                         const gchar *buf,
                                                         gsize count,
                                                         gsize *bytes_written);

Writes data to a GIOChannel.

g_io_channel_seek ()

GIOError            g_io_channel_seek                   (GIOChannel *channel,
                                                         gint64 offset,
                                                         GSeekType type);

Sets the current position in the GIOChannel, similar to the standard library function fseek().

g_io_channel_close ()

void                g_io_channel_close                  (GIOChannel *channel);

Close an IO channel. Any pending data to be written will be flushed, ignoring errors. The channel will not be freed until the last reference is dropped using g_io_channel_unref().