IO Channels
source link: https://developer.gnome.org/glib/stable/glib-IO-Channels.html
Go to the source link to view the article. You can view the picture content, updated content and better typesetting reading experience. If the link is broken, please click the button below to view the snapshot at that time.
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.
By default, the fd passed will not be closed when the final reference
to the GIOChannel data structure is dropped.
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.
Parameters
a file descriptor.
Returns
a new GIOChannel.
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.
Returns
the file descriptor 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.
Parameters
a C library file descriptor.
Returns
a new GIOChannel.
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.
Parameters
socket
a Winsock socket
Returns
a new GIOChannel
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.
Parameters
a window handle.
Returns
a new GIOChannel.
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).
Parameters
channel
g_io_channel_new_file ()
GIOChannel * g_io_channel_new_file (const gchar *filename
,const gchar *mode
,GError **error
);
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).
Parameters
filename
A string containing the name of a file.
[type filename]
One of "r", "w", "a", "r+", "w+", "a+". These have
the same meaning as in fopen()
error
A location to return an error of type G_FILE_ERROR
Returns
A GIOChannel on success, NULL
on failure.
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.
Parameters
channel
a buffer to read data into.
[out caller-allocates][array length=count][element-type guint8]count
the size of the buffer. Note that the buffer may not be completely filled even if there is data in the buffer if the remaining data is not a complete character.
[in]bytes_read
The number of bytes read. This may be
zero even on success if count < 6 and the channel's encoding
is non-NULL
. This indicates that the next UTF-8 character is
too wide for the buffer.
error
a location to return an error of type GConvertError or GIOChannelError.
Returns
the status of the operation.
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.
Parameters
channel
thechar
a location to return a character.
[out]error
a location to return an error of type GConvertError or GIOChannelError
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
.
Parameters
channel
str_return
The line read from the GIOChannel, including the
line terminator. This data should be freed with g_free()
when no longer needed. This is a nul-terminated string.
If a length
of zero is returned, this will be NULL
instead.
length
location to store length of the read data, or NULL
.
terminator_pos
location to store position of line terminator, or NULL
.
error
A location to return an error of type GConvertError or GIOChannelError
Returns
the status of the operation.
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.
Parameters
channel
buffer
a GString into which the line will be written.
If buffer
already contains data, the old data will
be overwritten.
terminator_pos
location to store position of line terminator, or NULL
.
error
a location to store an error of type GConvertError or GIOChannelError
Returns
the status of the operation.
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.
Parameters
channel
str_return
Location to
store a pointer to a string holding the remaining data in the
GIOChannel. This data should be freed with g_free()
when no
longer needed. This data is terminated by an extra nul
character, but there may be other nuls in the intervening data.
length
location to store length of the data.
[out]error
location to return an error of type GConvertError or GIOChannelError
Returns
G_IO_STATUS_NORMAL
on success.
This function never returns G_IO_STATUS_EOF
.
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()
.
Parameters
channel
a buffer to write data from.
[array][element-type guint8]count
the size of the buffer. If -1, the buffer is taken to be a nul-terminated string.
bytes_written
The number of bytes written. This can be nonzero
even if the return value is not G_IO_STATUS_NORMAL
.
If the return value is G_IO_STATUS_NORMAL
and the
channel is blocking, this will always be equal
to count
if count
>= 0.
error
a location to return an error of type GConvertError or GIOChannelError
Returns
the status of the operation.
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.
Parameters
channel
thechar
a character
error
location to return an error of type GConvertError or GIOChannelError
g_io_channel_flush ()
GIOStatus g_io_channel_flush (GIOChannel *channel
,GError **error
);
Flushes the write buffer for the GIOChannel.
Parameters
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.
Parameters
channel
offset
The offset in bytes from the position specified by type
a GSeekType. The type G_SEEK_CUR
is only allowed in those
cases where a call to g_io_channel_set_encoding()
is allowed. See the documentation for
g_io_channel_set_encoding()
for details.
error
A location to return an error of type GIOChannelError
Returns
the status of the 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()
.
Parameters
Returns
the status of the operation.
g_io_channel_error_from_errno ()
GIOChannelError
g_io_channel_error_from_errno (gint en
);
Converts an errno
error number to a GIOChannelError.
Parameters
an errno
error number, e.g. EINVAL
g_io_channel_ref ()
GIOChannel *
g_io_channel_ref (GIOChannel *channel
);
Increments the reference count of a GIOChannel.
Parameters
channel
Returns
the channel
that was passed in (since 2.6)
g_io_channel_unref ()
void
g_io_channel_unref (GIOChannel *channel
);
Decrements the reference count of a GIOChannel.
Parameters
channel
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.
The callback function invoked by the GSource should be added with
g_source_set_callback()
, but it has type GIOFunc (not GSourceFunc).
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.
Parameters
Returns
a new GSource
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.
Parameters
channel
condition
the condition to watch for
the function to call when the condition is satisfied
user_data
user data to pass to func
Returns
the event source id
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 manually if you need greater control.
[rename-to g_io_add_watch]
Parameters
channel
priority
the priority of the GIOChannel source
condition
the condition to watch for
the function to call when the condition is satisfied
user_data
user data to pass to func
notify
the function to call when the source is removed
Returns
the event source id
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.
Parameters
source
the GIOChannel event source
condition
the condition which has been satisfied
user data set in g_io_add_watch()
or g_io_add_watch_full()
Returns
the function should return FALSE
if the event source
should be removed
g_io_channel_get_buffer_size ()
gsize
g_io_channel_get_buffer_size (GIOChannel *channel
);
Gets the buffer size.
Parameters
channel
Returns
the size of the buffer.
g_io_channel_set_buffer_size ()
void g_io_channel_set_buffer_size (GIOChannel *channel
,gsize size
);
Sets the buffer size.
Parameters
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.
Parameters
channel
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_WRITABLE
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.
Parameters
channel
Returns
the flags which are set on the channel
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_FLAG_SET_MASK
).
Parameters
channel
flags
the flags to set on the IO channel
error
A location to return an error of type GIOChannelError
Returns
the status of the operation.
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.
Parameters
Returns
The line termination string. This value is owned by GLib and must not be freed.
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.
Parameters
channel
line_term
The line termination string. Use NULL
for
autodetect. Autodetection breaks on "\n", "\r\n", "\r", "\0",
and the Unicode paragraph separator. Autodetection should not be
used for anything other than file-based channels.
length
The length of the termination string. If -1 is passed, the string is assumed to be nul-terminated. This option allows termination strings with embedded nuls.
g_io_channel_get_buffered ()
gboolean
g_io_channel_get_buffered (GIOChannel *channel
);
Returns whether channel
is buffered.
Parameters
channel
Returns
TRUE
if the 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.
Parameters
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.
Parameters
channel
Returns
A string containing the encoding, this string is owned by GLib and must not be freed.
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:
The channel was just created, and has not been written to or read from yet.
The channel is write-only.
The channel is a file, and the file pointer was just repositioned by a call to
g_io_channel_seek_position()
. (This flushes all the internal buffers.)The current encoding is
NULL
or UTF-8.One of the (new API) read functions has just returned
G_IO_STATUS_EOF
(or, in the case ofg_io_channel_read_to_end()
,G_IO_STATUS_NORMAL
).One of the functions
g_io_channel_read_chars()
org_io_channel_read_unichar()
has returnedG_IO_STATUS_AGAIN
orG_IO_STATUS_ERROR
. This may be useful in the case ofG_CONVERT_ERROR_ILLEGAL_SEQUENCE
. Returning one of these statuses fromg_io_channel_read_line()
,g_io_channel_read_line_string()
, org_io_channel_read_to_end()
does not guarantee that the encoding can be changed.
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.
Parameters
channel
encoding
the encoding type.
[nullable]error
location to store an error of type GConvertError
Returns
G_IO_STATUS_NORMAL
if the encoding was successfully set
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.
Parameters
channel
a GIOChannel.
g_io_channel_set_close_on_unref ()
void g_io_channel_set_close_on_unref (GIOChannel *channel
,gboolean do_close
);
Whether to close the channel on the final unref of the GIOChannel
data structure. The default value of this is TRUE
for channels
created by g_io_channel_new_file()
, and FALSE
for all other channels.
Setting this flag to TRUE
for a channel you have already closed
can cause problems when the final reference to the GIOChannel is dropped.
Parameters
channel
do_close
Whether to close the channel on the final unref of the GIOChannel data structure.
g_io_channel_read ()
GIOError g_io_channel_read (GIOChannel *channel
,gchar *buf
,gsize count
,gsize *bytes_read
);
g_io_channel_read
has been deprecated since version 2.2 and should not be used in newly-written code.
Use g_io_channel_read_chars()
instead.
Reads data from a GIOChannel.
Parameters
channel
a buffer to read the data into (which should be at least count bytes long)
count
the number of bytes to read from the GIOChannel
bytes_read
returns the number of bytes actually read
Returns
G_IO_ERROR_NONE
if the operation was successful.
g_io_channel_write ()
GIOError g_io_channel_write (GIOChannel *channel
,const gchar *buf
,gsize count
,gsize *bytes_written
);
g_io_channel_write
has been deprecated since version 2.2 and should not be used in newly-written code.
Use g_io_channel_write_chars()
instead.
Writes data to a GIOChannel.
Parameters
channel
the buffer containing the data to write
count
the number of bytes to write
bytes_written
the number of bytes actually written
Returns
G_IO_ERROR_NONE
if the operation was successful.
g_io_channel_seek ()
GIOError g_io_channel_seek (GIOChannel *channel
,gint64 offset
,GSeekType type
);
g_io_channel_seek
has been deprecated since version 2.2 and should not be used in newly-written code.
Use g_io_channel_seek_position()
instead.
Sets the current position in the GIOChannel, similar to the standard
library function fseek()
.
Parameters
channel
offset
an offset, in bytes, which is added to the position specified
by type
the position in the file, which can be G_SEEK_CUR
(the current
position), G_SEEK_SET
(the start of the file), or G_SEEK_END
(the end of the file)
Returns
G_IO_ERROR_NONE
if the operation was successful.
g_io_channel_close ()
void
g_io_channel_close (GIOChannel *channel
);
g_io_channel_close
has been deprecated since version 2.2 and should not be used in newly-written code.
Use g_io_channel_shutdown()
instead.
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()
.
Parameters
channel
Recommend
About Joyk
Aggregate valuable and interesting links.
Joyk means Joy of geeK