/* GLIB - Library of useful routines for C programming

 * Copyright (C) 1995-1997  Peter Mattis, Spencer Kimball and Josh MacDonald

 *

 * giochannel.c: IO Channel abstraction

 * Copyright 1998 Owen Taylor

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2.1 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	 See the GNU

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with this library; if not, see <http://www.gnu.org/licenses/>.

 */

/*

 * Modified by the GLib Team and others 1997-2000.  See the AUTHORS

 * file for a list of people on the GLib Team.  See the ChangeLog

 * files for a list of changes.  These files are distributed with

 * GLib at ftp://ftp.gtk.org/pub/gtk/. 

 */

/* 

 * MT safe

 */

#include "config.h"

#include <string.h>

#include <errno.h>

#include "giochannel.h"

#include "gstrfuncs.h"

#include "gtestutils.h"

#include "glibintl.h"

/**

 * SECTION:iochannels

 * @title: IO Channels

 * @short_description: portable support for using files, pipes and sockets

 * @see_also: g_io_add_watch(), g_io_add_watch_full(), g_source_remove(),

 *     #GMainLoop

 *

 * The #GIOChannel data type aims to provide a portable method for

 * using file descriptors, pipes, and sockets, and integrating them

 * into the [main event loop][glib-The-Main-Event-Loop]. Currently,

 * full support is available on UNIX platforms, support for Windows

 * is only partially complete.

 *

 * To create a new #GIOChannel on UNIX systems use

 * g_io_channel_unix_new(). This works for plain file descriptors,

 * pipes and sockets. Alternatively, a channel can be created for a

 * file in a system independent manner using g_io_channel_new_file().

 *

 * Once a #GIOChannel has been created, it can be used in a generic

 * manner with the functions g_io_channel_read_chars(),

 * g_io_channel_write_chars(), g_io_channel_seek_position(), and

 * g_io_channel_shutdown().

 *

 * To add a #GIOChannel to the [main event loop][glib-The-Main-Event-Loop],

 * use g_io_add_watch() or g_io_add_watch_full(). Here you specify which

 * events you are interested in on the #GIOChannel, and provide a

 * function to be called whenever these events occur.

 *

 * #GIOChannel instances are created with an initial reference count of 1.

 * g_io_channel_ref() and g_io_channel_unref() can be used to

 * increment or decrement the reference count respectively. When the

 * reference count falls to 0, the #GIOChannel is freed. (Though it

 * isn't closed automatically, unless it was created using

 * g_io_channel_new_file().) Using g_io_add_watch() or

 * g_io_add_watch_full() increments a channel's reference count.

 *

 * The new functions g_io_channel_read_chars(),

 * g_io_channel_read_line(), g_io_channel_read_line_string(),

 * g_io_channel_read_to_end(), g_io_channel_write_chars(),

 * g_io_channel_seek_position(), and g_io_channel_flush() should not be

 * mixed with the deprecated functions g_io_channel_read(),

 * g_io_channel_write(), and g_io_channel_seek() on the same channel.

 **/

/**

 * GIOChannel:

 *

 * A data structure representing an IO Channel. The fields should be

 * considered private and should only be accessed with the following

 * functions.

 **/

/**

 * GIOFuncs:

 * @io_read: reads raw bytes from the channel.  This is called from

 *           various functions such as g_io_channel_read_chars() to

 *           read raw bytes from the channel.  Encoding and buffering

 *           issues are dealt with at a higher level.

 * @io_write: writes raw bytes to the channel.  This is called from

 *            various functions such as g_io_channel_write_chars() to

 *            write raw bytes to the channel.  Encoding and buffering

 *            issues are dealt with at a higher level.

 * @io_seek: (optional) seeks the channel.  This is called from

 *           g_io_channel_seek() on channels that support it.

 * @io_close: closes the channel.  This is called from

 *            g_io_channel_close() after flushing the buffers.

 * @io_create_watch: creates a watch on the channel.  This call

 *                   corresponds directly to g_io_create_watch().

 * @io_free: called from g_io_channel_unref() when the channel needs to

 *           be freed.  This function must free the memory associated

 *           with the channel, including freeing the #GIOChannel

 *           structure itself.  The channel buffers have been flushed

 *           and possibly @io_close has been called by the time this

 *           function is called.

 * @io_set_flags: sets the #GIOFlags on the channel.  This is called

 *                from g_io_channel_set_flags() with all flags except

 *                for %G_IO_FLAG_APPEND and %G_IO_FLAG_NONBLOCK masked

 *                out.

 * @io_get_flags: gets the #GIOFlags for the channel.  This function

 *                need only return the %G_IO_FLAG_APPEND and

 *                %G_IO_FLAG_NONBLOCK flags; g_io_channel_get_flags()

 *                automatically adds the others as appropriate.

 *

 * A table of functions used to handle different types of #GIOChannel

 * in a generic way.

 **/

/**

 * GIOStatus:

 * @G_IO_STATUS_ERROR: An error occurred.

 * @G_IO_STATUS_NORMAL: Success.

 * @G_IO_STATUS_EOF: End of file.

 * @G_IO_STATUS_AGAIN: Resource temporarily unavailable.

 *

 * Stati returned by most of the #GIOFuncs functions.

 **/

/**

 * GIOError:

 * @G_IO_ERROR_NONE: no error

 * @G_IO_ERROR_AGAIN: an EAGAIN error occurred

 * @G_IO_ERROR_INVAL: an EINVAL error occurred

 * @G_IO_ERROR_UNKNOWN: another error occurred

 *

 * #GIOError is only used by the deprecated functions

 * g_io_channel_read(), g_io_channel_write(), and g_io_channel_seek().

 **/

#define G_IO_NICE_BUF_SIZE	1024

/* This needs to be as wide as the largest character in any possible encoding */

#define MAX_CHAR_SIZE		10

/* Some simplifying macros, which reduce the need to worry whether the

 * buffers have been allocated. These also make USE_BUF () an lvalue,

 * which is used in g_io_channel_read_to_end ().

 */

#define USE_BUF(channel)	((channel)->encoding ? (channel)->encoded_read_buf \

				 : (channel)->read_buf)

#define BUF_LEN(string)		((string) ? (string)->len : 0)

static GIOError		g_io_error_get_from_g_error	(GIOStatus    status,

							 GError      *err);

static void		g_io_channel_purge		(GIOChannel  *channel);

static GIOStatus	g_io_channel_fill_buffer	(GIOChannel  *channel,

							 GError     **err);

static GIOStatus	g_io_channel_read_line_backend	(GIOChannel  *channel,

							 gsize       *length,

							 gsize       *terminator_pos,

							 GError     **error);

/**

 * g_io_channel_init:

 * @channel: a #GIOChannel

 *

 * 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).

 */

void

g_io_channel_init (GIOChannel *channel)

{

  channel->ref_count = 1;

  channel->encoding = g_strdup ("UTF-8");

  channel->line_term = NULL;

  channel->line_term_len = 0;

  channel->buf_size = G_IO_NICE_BUF_SIZE;

  channel->read_cd = (GIConv) -1;

  channel->write_cd = (GIConv) -1;

  channel->read_buf = NULL; /* Lazy allocate buffers */

  channel->encoded_read_buf = NULL;

  channel->write_buf = NULL;

  channel->partial_write_buf[0] = '\0';

  channel->use_buffer = TRUE;

  channel->do_encode = FALSE;

  channel->close_on_unref = FALSE;

}

/**

 * g_io_channel_ref:

 * @channel: a #GIOChannel

 *

 * Increments the reference count of a #GIOChannel.

 *

 * Returns: the @channel that was passed in (since 2.6)

 */

GIOChannel *

g_io_channel_ref (GIOChannel *channel)

{

  g_return_val_if_fail (channel != NULL, NULL);

  g_atomic_int_inc (&channel->ref_count);

  return channel;

}

/**

 * g_io_channel_unref:

 * @channel: a #GIOChannel

 *

 * Decrements the reference count of a #GIOChannel.

 */

void 

g_io_channel_unref (GIOChannel *channel)

{

  gboolean is_zero;

  g_return_if_fail (channel != NULL);

  is_zero = g_atomic_int_dec_and_test (&channel->ref_count);

  if (G_UNLIKELY (is_zero))

    {

      if (channel->close_on_unref)

        g_io_channel_shutdown (channel, TRUE, NULL);

      else

        g_io_channel_purge (channel);

      g_free (channel->encoding);

      if (channel->read_cd != (GIConv) -1)

        g_iconv_close (channel->read_cd);

      if (channel->write_cd != (GIConv) -1)

        g_iconv_close (channel->write_cd);

      g_free (channel->line_term);

      if (channel->read_buf)

        g_string_free (channel->read_buf, TRUE);

      if (channel->write_buf)

        g_string_free (channel->write_buf, TRUE);

      if (channel->encoded_read_buf)

        g_string_free (channel->encoded_read_buf, TRUE);

      channel->funcs->io_free (channel);

    }

}

static GIOError

g_io_error_get_from_g_error (GIOStatus  status,

			     GError    *err)

{

  switch (status)

    {

      case G_IO_STATUS_NORMAL:

      case G_IO_STATUS_EOF:

        return G_IO_ERROR_NONE;

      case G_IO_STATUS_AGAIN:

        return G_IO_ERROR_AGAIN;

      case G_IO_STATUS_ERROR:

	g_return_val_if_fail (err != NULL, G_IO_ERROR_UNKNOWN);

        if (err->domain != G_IO_CHANNEL_ERROR)

          return G_IO_ERROR_UNKNOWN;

        switch (err->code)

          {

            case G_IO_CHANNEL_ERROR_INVAL:

              return G_IO_ERROR_INVAL;

            default:

              return G_IO_ERROR_UNKNOWN;

          }

      default:

        g_assert_not_reached ();

    }

}

/**

 * g_io_channel_read:

 * @channel: a #GIOChannel

 * @buf: 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

 * 

 * Reads data from a #GIOChannel. 

 * 

 * Returns: %G_IO_ERROR_NONE if the operation was successful. 

 *

 * Deprecated:2.2: Use g_io_channel_read_chars() instead.

 **/

GIOError 

g_io_channel_read (GIOChannel *channel, 

		   gchar      *buf, 

		   gsize       count,

		   gsize      *bytes_read)

{

  GError *err = NULL;

  GIOError error;

  GIOStatus status;

  g_return_val_if_fail (channel != NULL, G_IO_ERROR_UNKNOWN);

  g_return_val_if_fail (bytes_read != NULL, G_IO_ERROR_UNKNOWN);

  if (count == 0)

    {

      if (bytes_read)

        *bytes_read = 0;

      return G_IO_ERROR_NONE;

    }

  g_return_val_if_fail (buf != NULL, G_IO_ERROR_UNKNOWN);

  status = channel->funcs->io_read (channel, buf, count, bytes_read, &err;;

  error = g_io_error_get_from_g_error (status, err);

  if (err)

    g_error_free (err);

  return error;

}

/**

 * g_io_channel_write:

 * @channel:  a #GIOChannel

 * @buf: the buffer containing the data to write

 * @count: the number of bytes to write

 * @bytes_written: the number of bytes actually written

 * 

 * Writes data to a #GIOChannel. 

 * 

 * Returns:  %G_IO_ERROR_NONE if the operation was successful.

 *

 * Deprecated:2.2: Use g_io_channel_write_chars() instead.

 **/

GIOError 

g_io_channel_write (GIOChannel  *channel, 

		    const gchar *buf, 

		    gsize        count,

		    gsize       *bytes_written)

{

  GError *err = NULL;

  GIOError error;

  GIOStatus status;

  g_return_val_if_fail (channel != NULL, G_IO_ERROR_UNKNOWN);

  g_return_val_if_fail (bytes_written != NULL, G_IO_ERROR_UNKNOWN);

  status = channel->funcs->io_write (channel, buf, count, bytes_written, &err;;

  error = g_io_error_get_from_g_error (status, err);

  if (err)

    g_error_free (err);

  return error;

}

/**

 * g_io_channel_seek:

 * @channel: a #GIOChannel

 * @offset: an offset, in bytes, which is added to the position specified 

 *          by @type

 * @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)

 * 

 * Sets the current position in the #GIOChannel, similar to the standard 

 * library function fseek(). 

 * 

 * Returns: %G_IO_ERROR_NONE if the operation was successful.

 *

 * Deprecated:2.2: Use g_io_channel_seek_position() instead.

 **/

GIOError 

g_io_channel_seek (GIOChannel *channel,

		   gint64      offset, 

		   GSeekType   type)

{

  GError *err = NULL;

  GIOError error;

  GIOStatus status;

  g_return_val_if_fail (channel != NULL, G_IO_ERROR_UNKNOWN);

  g_return_val_if_fail (channel->is_seekable, G_IO_ERROR_UNKNOWN);

  switch (type)

    {

      case G_SEEK_CUR:

      case G_SEEK_SET:

      case G_SEEK_END:

        break;

      default:

        g_warning ("g_io_channel_seek: unknown seek type");

        return G_IO_ERROR_UNKNOWN;

    }

  status = channel->funcs->io_seek (channel, offset, type, &err;;

  error = g_io_error_get_from_g_error (status, err);

  if (err)

    g_error_free (err);

  return error;

}

/* The function g_io_channel_new_file() is prototyped in both

 * giounix.c and giowin32.c, so we stick its documentation here.

 */

/**

 * g_io_channel_new_file:

 * @filename: (type filename): A string containing the name of a file

 * @mode: 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

 *

 * 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).

 *

 * Returns: A #GIOChannel on success, %NULL on failure.

 **/

/**

 * g_io_channel_close:

 * @channel: A #GIOChannel

 * 

 * 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(). 

 *

 * Deprecated:2.2: Use g_io_channel_shutdown() instead.

 **/

void

g_io_channel_close (GIOChannel *channel)

{

  GError *err = NULL;

  g_return_if_fail (channel != NULL);

  g_io_channel_purge (channel);

  channel->funcs->io_close (channel, &err;;

  if (err)

    { /* No way to return the error */

      g_warning ("Error closing channel: %s", err->message);

      g_error_free (err);

    }

  channel->close_on_unref = FALSE; /* Because we already did */

  channel->is_readable = FALSE;

  channel->is_writeable = FALSE;

  channel->is_seekable = FALSE;

}

/**

 * g_io_channel_shutdown:

 * @channel: a #GIOChannel

 * @flush: if %TRUE, flush pending

 * @err: location to store a #GIOChannelError

 * 

 * 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().

 *

 * Returns: the status of the operation.

 **/

GIOStatus

g_io_channel_shutdown (GIOChannel  *channel,

		       gboolean     flush,

		       GError     **err)

{

  GIOStatus status, result;

  GError *tmperr = NULL;

  g_return_val_if_fail (channel != NULL, G_IO_STATUS_ERROR);

  g_return_val_if_fail (err == NULL || *err == NULL, G_IO_STATUS_ERROR);

  if (channel->write_buf && channel->write_buf->len > 0)

    {

      if (flush)

        {

          GIOFlags flags;

          /* Set the channel to blocking, to avoid a busy loop

           */

          flags = g_io_channel_get_flags (channel);

          /* Ignore any errors here, they're irrelevant */

          g_io_channel_set_flags (channel, flags & ~G_IO_FLAG_NONBLOCK, NULL);

          result = g_io_channel_flush (channel, &tmperr);

        }

      else

        result = G_IO_STATUS_NORMAL;

      g_string_truncate(channel->write_buf, 0);

    }

  else

    result = G_IO_STATUS_NORMAL;

  if (channel->partial_write_buf[0] != '\0')

    {

      if (flush)

        g_warning ("Partial character at end of write buffer not flushed.\n");

      channel->partial_write_buf[0] = '\0';

    }

  status = channel->funcs->io_close (channel, err);

  channel->close_on_unref = FALSE; /* Because we already did */

  channel->is_readable = FALSE;

  channel->is_writeable = FALSE;

  channel->is_seekable = FALSE;

  if (status != G_IO_STATUS_NORMAL)

    {

      g_clear_error (&tmperr);

      return status;

    }

  else if (result != G_IO_STATUS_NORMAL)

    {

      g_propagate_error (err, tmperr);

      return result;

    }

  else

    return G_IO_STATUS_NORMAL;

}

/* This function is used for the final flush on close or unref */

static void

g_io_channel_purge (GIOChannel *channel)

{

  GError *err = NULL;

  GIOStatus status G_GNUC_UNUSED;

  g_return_if_fail (channel != NULL);

  if (channel->write_buf && channel->write_buf->len > 0)

    {

      GIOFlags flags;

      /* Set the channel to blocking, to avoid a busy loop

       */

      flags = g_io_channel_get_flags (channel);

      g_io_channel_set_flags (channel, flags & ~G_IO_FLAG_NONBLOCK, NULL);

      status = g_io_channel_flush (channel, &err;;

      if (err)

        { /* No way to return the error */

          g_warning ("Error flushing string: %s", err->message);

          g_error_free (err);

        }

    }

  /* Flush these in case anyone tries to close without unrefing */

  if (channel->read_buf)

    g_string_truncate (channel->read_buf, 0);

  if (channel->write_buf)

    g_string_truncate (channel->write_buf, 0);

  if (channel->encoding)

    {

      if (channel->encoded_read_buf)

        g_string_truncate (channel->encoded_read_buf, 0);

      if (channel->partial_write_buf[0] != '\0')

        {

          g_warning ("Partial character at end of write buffer not flushed.\n");

          channel->partial_write_buf[0] = '\0';

        }

    }

}

/**

 * g_io_create_watch:

 * @channel: a #GIOChannel to watch

 * @condition: conditions to watch for

 *

 * 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.

 *

 * Returns: a new #GSource

 */

GSource *

g_io_create_watch (GIOChannel   *channel,

		   GIOCondition  condition)

{

  g_return_val_if_fail (channel != NULL, NULL);

  return channel->funcs->io_create_watch (channel, condition);

}

/**

 * g_io_add_watch_full: (rename-to g_io_add_watch)

 * @channel: a #GIOChannel

 * @priority: the priority of the #GIOChannel source

 * @condition: the condition to watch for

 * @func: 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

 *

 * 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.

 *

 * Returns: the event source id

 */

guint 

g_io_add_watch_full (GIOChannel    *channel,

		     gint           priority,

		     GIOCondition   condition,

		     GIOFunc        func,

		     gpointer       user_data,

		     GDestroyNotify notify)

{

  GSource *source;

  guint id;

  g_return_val_if_fail (channel != NULL, 0);

  source = g_io_create_watch (channel, condition);

  if (priority != G_PRIORITY_DEFAULT)

    g_source_set_priority (source, priority);

  g_source_set_callback (source, (GSourceFunc)func, user_data, notify);

  id = g_source_attach (source, NULL);

  g_source_unref (source);

  return id;

}

/**

 * g_io_add_watch:

 * @channel: a #GIOChannel

 * @condition: the condition to watch for

 * @func: the function to call when the condition is satisfied

 * @user_data: user data to pass to @func

 *

 * Adds the #GIOChannel into the default main loop context

 * with the default priority.

 *

 * Returns: the event source id

 */

/**

 * GIOFunc:

 * @source: the #GIOChannel event source

 * @condition: the condition which has been satisfied

 * @data: user data set in g_io_add_watch() or g_io_add_watch_full()

 *

 * 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.

 *

 * Returns: the function should return %FALSE if the event source

 *          should be removed

 **/

/**

 * GIOCondition:

 * @G_IO_IN: There is data to read.

 * @G_IO_OUT: Data can be written (without blocking).

 * @G_IO_PRI: There is urgent data to read.

 * @G_IO_ERR: Error condition.

 * @G_IO_HUP: Hung up (the connection has been broken, usually for

 *            pipes and sockets).

 * @G_IO_NVAL: Invalid request. The file descriptor is not open.

 *

 * A bitwise combination representing a condition to watch for on an

 * event source.

 **/

guint 

g_io_add_watch (GIOChannel   *channel,

		GIOCondition  condition,

		GIOFunc       func,

		gpointer      user_data)

{

  return g_io_add_watch_full (channel, G_PRIORITY_DEFAULT, condition, func, user_data, NULL);

}

/**

 * g_io_channel_get_buffer_condition:

 * @channel: A #GIOChannel

 *

 * 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.

 *

 * Returns: A #GIOCondition

 **/

GIOCondition

g_io_channel_get_buffer_condition (GIOChannel *channel)

{

  GIOCondition condition = 0;

  if (channel->encoding)

    {

      if (channel->encoded_read_buf && (channel->encoded_read_buf->len > 0))

        condition |= G_IO_IN; /* Only return if we have full characters */

    }

  else

    {

      if (channel->read_buf && (channel->read_buf->len > 0))

        condition |= G_IO_IN;

    }

  if (channel->write_buf && (channel->write_buf->len < channel->buf_size))

    condition |= G_IO_OUT;

  return condition;

}

/**

 * g_io_channel_error_from_errno:

 * @en: an `errno` error number, e.g. `EINVAL`

 *

 * Converts an `errno` error number to a #GIOChannelError.

 *

 * Returns: a #GIOChannelError error number, e.g. 

 *      %G_IO_CHANNEL_ERROR_INVAL.

 **/

GIOChannelError

g_io_channel_error_from_errno (gint en)

{

#ifdef EAGAIN

  g_return_val_if_fail (en != EAGAIN, G_IO_CHANNEL_ERROR_FAILED);

#endif

  switch (en)

    {

#ifdef EBADF

    case EBADF:

      g_warning("Invalid file descriptor.\n");

      return G_IO_CHANNEL_ERROR_FAILED;

#endif

#ifdef EFAULT

    case EFAULT:

      g_warning("Buffer outside valid address space.\n");

      return G_IO_CHANNEL_ERROR_FAILED;

#endif

#ifdef EFBIG

    case EFBIG:

      return G_IO_CHANNEL_ERROR_FBIG;

#endif

#ifdef EINTR

    /* In general, we should catch EINTR before we get here,

     * but close() is allowed to return EINTR by POSIX, so

     * we need to catch it here; EINTR from close() is

     * unrecoverable, because it's undefined whether

     * the fd was actually closed or not, so we just return

     * a generic error code.

     */

    case EINTR:

      return G_IO_CHANNEL_ERROR_FAILED;

#endif

#ifdef EINVAL

    case EINVAL:

      return G_IO_CHANNEL_ERROR_INVAL;

#endif

#ifdef EIO

    case EIO:

      return G_IO_CHANNEL_ERROR_IO;

#endif

#ifdef EISDIR

    case EISDIR:

      return G_IO_CHANNEL_ERROR_ISDIR;

#endif

#ifdef ENOSPC

    case ENOSPC:

      return G_IO_CHANNEL_ERROR_NOSPC;

#endif

#ifdef ENXIO

    case ENXIO:

      return G_IO_CHANNEL_ERROR_NXIO;

#endif

#ifdef EOVERFLOW

#if EOVERFLOW != EFBIG

    case EOVERFLOW:

      return G_IO_CHANNEL_ERROR_OVERFLOW;

#endif

#endif

#ifdef EPIPE

    case EPIPE:

      return G_IO_CHANNEL_ERROR_PIPE;

#endif

    default:

      return G_IO_CHANNEL_ERROR_FAILED;

    }

}

/**

 * g_io_channel_set_buffer_size:

 * @channel: a #GIOChannel

 * @size: the size of the buffer, or 0 to let GLib pick a good size

 *

 * Sets the buffer size.

 **/  

void

g_io_channel_set_buffer_size (GIOChannel *channel,

                              gsize       size)

{

  g_return_if_fail (channel != NULL);

  if (size == 0)

    size = G_IO_NICE_BUF_SIZE;

  if (size < MAX_CHAR_SIZE)

    size = MAX_CHAR_SIZE;

  channel->buf_size = size;

}

/**

 * g_io_channel_get_buffer_size:

 * @channel: a #GIOChannel

 *

 * Gets the buffer size.

 *

 * Returns: the size of the buffer.

 **/  

gsize

g_io_channel_get_buffer_size (GIOChannel *channel)

{

  g_return_val_if_fail (channel != NULL, 0);

  return channel->buf_size;

}

/**

 * g_io_channel_set_line_term:

 * @channel: a #GIOChannel

 * @line_term: (nullable): 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.

 *

 * This sets the string that #GIOChannel uses to determine

 * where in the file a line break occurs.

 **/