glib/giochannel.c

   1 /* GLIB - Library of useful routines for C programming
   2  * Copyright (C) 1995-1997  Peter Mattis, Spencer Kimball and Josh MacDonald
   3  *
   4  * giochannel.c: IO Channel abstraction
   5  * Copyright 1998 Owen Taylor
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the
  19  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  20  * Boston, MA 02111-1307, USA.
  21  */
  22
  23 /*
  24  * Modified by the GLib Team and others 1997-2000.  See the AUTHORS
  25  * file for a list of people on the GLib Team.  See the ChangeLog
  26  * files for a list of changes.  These files are distributed with
  27  * GLib at ftp://ftp.gtk.org/pub/gtk/.
  28  */
  29
  30 /*
  31  * MT safe
  32  */
  33
  34 #include "config.h"
  35 #include "giochannel.h"
  36
  37 #include <string.h>
  38 #include <errno.h>
  39
  40 #ifdef HAVE_UNISTD_H
  41 #include <unistd.h>
  42 #endif
  43
  44 #undef G_DISABLE_DEPRECATED
  45
  46 #include "glib.h"
  47
  48 #include "glibintl.h"
  49
  50 #define G_IO_NICE_BUF_SIZE      1024
  51
  52 /* This needs to be as wide as the largest character in any possible encoding */
  53 #define MAX_CHAR_SIZE           10
  54
  55 /* Some simplifying macros, which reduce the need to worry whether the
  56  * buffers have been allocated. These also make USE_BUF () an lvalue,
  57  * which is used in g_io_channel_read_to_end ().
  58  */
  59 #define USE_BUF(channel)        ((channel)->encoding ? (channel)->encoded_read_buf \
  60                                  : (channel)->read_buf)
  61 #define BUF_LEN(string)         ((string) ? (string)->len : 0)
  62
  63 static GIOError         g_io_error_get_from_g_error     (GIOStatus    status,
  64                                                          GError      *err);
  65 static void             g_io_channel_purge              (GIOChannel  *channel);
  66 static GIOStatus        g_io_channel_fill_buffer        (GIOChannel  *channel,
  67                                                          GError     **err);
  68 static GIOStatus        g_io_channel_read_line_backend  (GIOChannel  *channel,
  69                                                          gsize       *length,
  70                                                          gsize       *terminator_pos,
  71                                                          GError     **error);
  72
  73 void
  74 g_io_channel_init (GIOChannel *channel)
  75 {
  76   channel->ref_count = 1;
  77   channel->encoding = g_strdup ("UTF-8");
  78   channel->line_term = NULL;
  79   channel->buf_size = G_IO_NICE_BUF_SIZE;
  80   channel->read_cd = (GIConv) -1;
  81   channel->write_cd = (GIConv) -1;
  82   channel->read_buf = NULL; /* Lazy allocate buffers */
  83   channel->encoded_read_buf = NULL;
  84   channel->write_buf = NULL;
  85   channel->partial_write_buf[0] = '\0';
  86   channel->use_buffer = TRUE;
  87   channel->do_encode = FALSE;
  88   channel->close_on_unref = FALSE;
  89 }
  90
  91 void
  92 g_io_channel_ref (GIOChannel *channel)
  93 {
  94   g_return_if_fail (channel != NULL);
  95
  96   channel->ref_count++;
  97 }
  98
  99 void
 100 g_io_channel_unref (GIOChannel *channel)
 101 {
 102   g_return_if_fail (channel != NULL);
 103
 104   channel->ref_count--;
 105   if (channel->ref_count == 0)
 106     {
 107       if (channel->close_on_unref)
 108         g_io_channel_shutdown (channel, TRUE, NULL);
 109       else
 110         g_io_channel_purge (channel);
 111       g_free (channel->encoding);
 112       if (channel->read_cd != (GIConv) -1)
 113         g_iconv_close (channel->read_cd);
 114       if (channel->write_cd != (GIConv) -1)
 115         g_iconv_close (channel->write_cd);
 116       g_free (channel->line_term);
 117       if (channel->read_buf)
 118         g_string_free (channel->read_buf, TRUE);
 119       if (channel->write_buf)
 120         g_string_free (channel->write_buf, TRUE);
 121       if (channel->encoded_read_buf)
 122         g_string_free (channel->encoded_read_buf, TRUE);
 123       channel->funcs->io_free (channel);
 124     }
 125 }
 126
 127 static GIOError
 128 g_io_error_get_from_g_error (GIOStatus status,
 129                              GError *err)
 130 {
 131   switch (status)
 132     {
 133       case G_IO_STATUS_NORMAL:
 134       case G_IO_STATUS_EOF:
 135         return G_IO_ERROR_NONE;
 136       case G_IO_STATUS_AGAIN:
 137         return G_IO_ERROR_AGAIN;
 138       case G_IO_STATUS_ERROR:
 139         if (err->domain != G_IO_CHANNEL_ERROR)
 140           return G_IO_ERROR_UNKNOWN;
 141         switch (err->code)
 142           {
 143             case G_IO_CHANNEL_ERROR_INVAL:
 144               return G_IO_ERROR_INVAL;
 145             default:
 146               return G_IO_ERROR_UNKNOWN;
 147           }
 148       default:
 149         g_assert_not_reached ();
 150         return G_IO_ERROR_UNKNOWN; /* Keep the compiler happy */
 151     }
 152 }
 153
 154 /**
 155  * g_io_channel_read:
 156  * @channel: a #GIOChannel.
 157  * @buf: a buffer to read the data into (which should be at least count bytes long).
 158  * @count: the number of bytes to read from the #GIOChannel.
 159  * @bytes_read: returns the number of bytes actually read.
 160  *
 161  * Reads data from a #GIOChannel. This function is depricated. New code should
 162  * use g_io_channel_read_chars() instead.
 163  *
 164  * Return value: %G_IO_ERROR_NONE if the operation was successful.
 165  **/
 166 GIOError
 167 g_io_channel_read (GIOChannel *channel,
 168                    gchar      *buf,
 169                    gsize       count,
 170                    gsize      *bytes_read)
 171 {
 172   GError *err = NULL;
 173   GIOError error;
 174   GIOStatus status;
 175
 176   g_return_val_if_fail (channel != NULL, G_IO_ERROR_UNKNOWN);
 177   g_return_val_if_fail (bytes_read != NULL, G_IO_ERROR_UNKNOWN);
 178
 179   status = channel->funcs->io_read (channel, buf, count, bytes_read, &err);
 180
 181   error = g_io_error_get_from_g_error (status, err);
 182
 183   if (err)
 184     g_error_free (err);
 185
 186   return error;
 187 }
 188
 189 /**
 190  * g_io_channel_write:
 191  * @channel:  a #GIOChannel.
 192  * @buf: the buffer containing the data to write.
 193  * @count: the number of bytes to write.
 194  * @bytes_written:  the number of bytes actually written.
 195  *
 196  * Writes data to a #GIOChannel. This function is depricated. New code should
 197  * use g_io_channel_write_chars() instead.
 198  *
 199  * Return value:  %G_IO_ERROR_NONE if the operation was successful.
 200  **/
 201 GIOError
 202 g_io_channel_write (GIOChannel  *channel,
 203                     const gchar *buf,
 204                     gsize        count,
 205                     gsize       *bytes_written)
 206 {
 207   GError *err = NULL;
 208   GIOError error;
 209   GIOStatus status;
 210
 211   g_return_val_if_fail (channel != NULL, G_IO_ERROR_UNKNOWN);
 212   g_return_val_if_fail (bytes_written != NULL, G_IO_ERROR_UNKNOWN);
 213
 214   status = channel->funcs->io_write (channel, buf, count, bytes_written, &err);
 215
 216   error = g_io_error_get_from_g_error (status, err);
 217
 218   if (err)
 219     g_error_free (err);
 220
 221   return error;
 222 }
 223
 224 /**
 225  * g_io_channel_seek:
 226  * @channel: a #GIOChannel.
 227  * @offset: an offset, in bytes, which is added to the position specified by @type
 228  * @type: the position in the file, which can be %G_SEEK_CUR (the current
 229  *        position), %G_SEEK_SET (the start of the file), or %G_SEEK_END (the end of the
 230  *        file).
 231  *
 232  * Sets the current position in the #GIOChannel, similar to the standard library
 233  * function fseek(). This function is depricated. New code should
 234  * use g_io_channel_seek_position() instead.
 235  *
 236  * Return value: %G_IO_ERROR_NONE if the operation was successful.
 237  **/
 238 GIOError
 239 g_io_channel_seek  (GIOChannel   *channel,
 240                     glong         offset,
 241                     GSeekType     type)
 242 {
 243   GError *err = NULL;
 244   GIOError error;
 245   GIOStatus status;
 246
 247   g_return_val_if_fail (channel != NULL, G_IO_ERROR_UNKNOWN);
 248   g_return_val_if_fail (channel->is_seekable, G_IO_ERROR_UNKNOWN);
 249
 250   switch (type)
 251     {
 252       case G_SEEK_CUR:
 253       case G_SEEK_SET:
 254       case G_SEEK_END:
 255         break;
 256       default:
 257         g_warning ("g_io_channel_seek: unknown seek type");
 258         return G_IO_ERROR_UNKNOWN;
 259     }
 260
 261   status = channel->funcs->io_seek (channel, offset, type, &err);
 262
 263   error = g_io_error_get_from_g_error (status, err);
 264
 265   if (err)
 266     g_error_free (err);
 267
 268   return error;
 269 }
 270
 271 /* The function g_io_channel_new_file() is prototyped in both
 272  * giounix.c and giowin32.c, so we stick its documentation here.
 273  */
 274
 275 /**
 276  * g_io_channel_new_file:
 277  * @filename: A string containing the name of a file.
 278  * @mode: One of "r", "w", "a", "r+", "w+", "a+". These have
 279  *        the same meaning as in fopen().
 280  * @error: A location to return an error of type %G_IO_FILE_ERROR.
 281  *
 282  * Open a file @filename as a #GIOChannel using mode @mode. This
 283  * channel will be closed when the last reference to it is dropped,
 284  * so there is no need to call g_io_channel_close() (though doing
 285  * so will not cause problems, as long as no attempt is made to
 286  * access the channel after it is closed).
 287  *
 288  * Return value: A #GIOChannel on success, %NULL on failure.
 289  **/
 290
 291 /**
 292  * g_io_channel_close:
 293  * @channel: A #GIOChannel
 294  *
 295  * Close an IO channel. Any pending data to be written will be
 296  * flushed, ignoring errors. The channel will not be freed until the
 297  * last reference is dropped using g_io_channel_unref(). This
 298  * function is deprecated: you should use g_io_channel_shutdown()
 299  * instead.
 300  **/
 301 void
 302 g_io_channel_close (GIOChannel *channel)
 303 {
 304   GError *err = NULL;
 305
 306   g_return_if_fail (channel != NULL);
 307
 308   g_io_channel_purge (channel);
 309
 310   channel->funcs->io_close (channel, &err);
 311
 312   if (err)
 313     { /* No way to return the error */
 314       g_warning ("Error closing channel: %s", err->message);
 315       g_error_free (err);
 316     }
 317
 318   channel->close_on_unref = FALSE; /* Because we already did */
 319   channel->is_readable = FALSE;
 320   channel->is_writeable = FALSE;
 321   channel->is_seekable = FALSE;
 322 }
 323
 324 /**
 325  * g_io_channel_shutdown:
 326  * @channel: a #GIOChannel
 327  * @flush: if %TRUE, flush pending
 328  * @err: location to store a #GIOChannelError
 329  *
 330  * Close an IO channel. Any pending data to be written will be
 331  * flushed. The channel will not be freed until the
 332  * last reference is dropped using g_io_channel_unref().
 333  *
 334  * Return value:
 335  **/
 336 GIOStatus
 337 g_io_channel_shutdown (GIOChannel *channel,
 338                        gboolean    flush,
 339                        GError    **err)
 340 {
 341   GIOStatus status, result;
 342   GError *tmperr = NULL;
 343
 344   g_return_val_if_fail (channel != NULL, G_IO_STATUS_ERROR);
 345   g_return_val_if_fail (err == NULL || *err == NULL, G_IO_STATUS_ERROR);
 346
 347   if (flush && channel->write_buf && channel->write_buf->len > 0)
 348     {
 349       GIOFlags flags;
 350
 351       /* Set the channel to blocking, to avoid a busy loop
 352        */
 353       flags = g_io_channel_get_flags (channel);
 354       /* Ignore any errors here, they're irrelevant */
 355       g_io_channel_set_flags (channel, flags & ~G_IO_FLAG_NONBLOCK, NULL);
 356
 357       result = g_io_channel_flush (channel, &tmperr);
 358
 359       if (channel->partial_write_buf[0] != '\0')
 360         {
 361           g_warning ("Partial character at end of write buffer not flushed.\n");
 362           channel->partial_write_buf[0] = '\0';
 363         }
 364     }
 365   else
 366     result = G_IO_STATUS_NORMAL;
 367
 368   status = channel->funcs->io_close (channel, err);
 369
 370   channel->close_on_unref = FALSE; /* Because we already did */
 371   channel->is_readable = FALSE;
 372   channel->is_writeable = FALSE;
 373   channel->is_seekable = FALSE;
 374
 375   if (status != G_IO_STATUS_NORMAL)
 376     {
 377       g_clear_error (&tmperr);
 378       return status;
 379     }
 380   else if (result != G_IO_STATUS_NORMAL)
 381     {
 382       g_propagate_error (err, tmperr);
 383       return result;
 384     }
 385   else
 386     return G_IO_STATUS_NORMAL;
 387 }
 388
 389 /* This function is used for the final flush on close or unref */
 390 static void
 391 g_io_channel_purge (GIOChannel *channel)
 392 {
 393   GError *err = NULL;
 394   GIOStatus status;
 395
 396   g_return_if_fail (channel != NULL);
 397
 398   if (channel->write_buf && channel->write_buf->len > 0)
 399     {
 400       GIOFlags flags;
 401
 402       /* Set the channel to blocking, to avoid a busy loop
 403        */
 404       flags = g_io_channel_get_flags (channel);
 405       g_io_channel_set_flags (channel, flags & ~G_IO_FLAG_NONBLOCK, NULL);
 406
 407       status = g_io_channel_flush (channel, &err);
 408
 409       if (err)
 410         { /* No way to return the error */
 411           g_warning ("Error flushing string: %s", err->message);
 412           g_error_free (err);
 413         }
 414     }
 415
 416   /* Flush these in case anyone tries to close without unrefing */
 417
 418   if (channel->read_buf)
 419     g_string_truncate (channel->read_buf, 0);
 420   if (channel->write_buf)
 421     g_string_truncate (channel->write_buf, 0);
 422   if (channel->encoding)
 423     {
 424       if (channel->encoded_read_buf)
 425         g_string_truncate (channel->encoded_read_buf, 0);
 426
 427       if (channel->partial_write_buf[0] != '\0')
 428         {
 429           g_warning ("Partial character at end of write buffer not flushed.\n");
 430           channel->partial_write_buf[0] = '\0';
 431         }
 432     }
 433 }
 434
 435 GSource *
 436 g_io_create_watch (GIOChannel  *channel,
 437                    GIOCondition condition)
 438 {
 439   g_return_val_if_fail (channel != NULL, NULL);
 440
 441   return channel->funcs->io_create_watch (channel, condition);
 442 }
 443
 444 guint
 445 g_io_add_watch_full (GIOChannel    *channel,
 446                      gint           priority,
 447                      GIOCondition   condition,
 448                      GIOFunc        func,
 449                      gpointer       user_data,
 450                      GDestroyNotify notify)
 451 {
 452   GSource *source;
 453   guint id;
 454
 455   g_return_val_if_fail (channel != NULL, 0);
 456
 457   source = g_io_create_watch (channel, condition);
 458
 459   if (priority != G_PRIORITY_DEFAULT)
 460     g_source_set_priority (source, priority);
 461   g_source_set_callback (source, (GSourceFunc)func, user_data, notify);
 462
 463   id = g_source_attach (source, NULL);
 464   g_source_unref (source);
 465
 466   return id;
 467 }
 468
 469 guint
 470 g_io_add_watch (GIOChannel    *channel,
 471                 GIOCondition   condition,
 472                 GIOFunc        func,
 473                 gpointer       user_data)
 474 {
 475   return g_io_add_watch_full (channel, G_PRIORITY_DEFAULT, condition, func, user_data, NULL);
 476 }
 477
 478 /**
 479  * g_io_channel_get_buffer_condition:
 480  * @channel: A #GIOChannel
 481  *
 482  * This function returns a #GIOCondition depending on the status of the
 483  * internal buffers in the #GIOChannel. Only the flags %G_IO_IN and
 484  * %G_IO_OUT will be set.
 485  *
 486  * Return value: A #GIOCondition
 487  **/
 488 GIOCondition
 489 g_io_channel_get_buffer_condition (GIOChannel *channel)
 490 {
 491   GIOCondition condition = 0;
 492
 493   if (channel->encoding)
 494     {
 495       if (channel->encoded_read_buf && (channel->encoded_read_buf->len > 0))
 496         condition |= G_IO_IN; /* Only return if we have full characters */
 497     }
 498   else
 499     {
 500       if (channel->read_buf && (channel->read_buf->len > 0))
 501         condition |= G_IO_IN;
 502     }
 503
 504   if (channel->write_buf && (channel->write_buf->len < channel->buf_size))
 505     condition |= G_IO_OUT;
 506
 507   return condition;
 508 }
 509
 510 /**
 511  * g_io_channel_error_from_errno:
 512  * @en: An errno error number, e.g. EINVAL
 513  *
 514  * Return value: A #GIOChannelError error number, e.g. %G_IO_CHANNEL_ERROR_INVAL
 515  **/
 516 GIOChannelError
 517 g_io_channel_error_from_errno (gint en)
 518 {
 519 #ifdef EAGAIN
 520   g_return_val_if_fail (en != EAGAIN, G_IO_CHANNEL_ERROR_FAILED);
 521 #endif
 522 #ifdef EINTR
 523   g_return_val_if_fail (en != EINTR, G_IO_CHANNEL_ERROR_FAILED);
 524 #endif
 525
 526   switch (en)
 527     {
 528 #ifdef EBADF
 529     case EBADF:
 530       g_warning("Invalid file descriptor.\n");
 531       return G_IO_CHANNEL_ERROR_FAILED;
 532 #endif
 533
 534 #ifdef EFAULT
 535     case EFAULT:
 536       g_warning("File descriptor outside valid address space.\n");
 537       return G_IO_CHANNEL_ERROR_FAILED;
 538 #endif
 539
 540 #ifdef EFBIG
 541     case EFBIG:
 542       return G_IO_CHANNEL_ERROR_FBIG;
 543 #endif
 544
 545 #ifdef EINVAL
 546     case EINVAL:
 547       return G_IO_CHANNEL_ERROR_INVAL;
 548 #endif
 549
 550 #ifdef EIO
 551     case EIO:
 552       return G_IO_CHANNEL_ERROR_IO;
 553 #endif
 554
 555 #ifdef EISDIR
 556     case EISDIR:
 557       return G_IO_CHANNEL_ERROR_ISDIR;
 558 #endif
 559
 560 #ifdef ENOSPC
 561     case ENOSPC:
 562       return G_IO_CHANNEL_ERROR_NOSPC;
 563 #endif
 564
 565 #ifdef ENXIO
 566     case ENXIO:
 567       return G_IO_CHANNEL_ERROR_NXIO;
 568 #endif
 569
 570 #ifdef EOVERFLOW
 571     case EOVERFLOW:
 572       return G_IO_CHANNEL_ERROR_OVERFLOW;
 573 #endif
 574
 575 #ifdef EPIPE
 576     case EPIPE:
 577       return G_IO_CHANNEL_ERROR_PIPE;
 578 #endif
 579
 580     default:
 581       return G_IO_CHANNEL_ERROR_FAILED;
 582     }
 583 }
 584
 585 /**
 586  * g_io_channel_set_buffer_size:
 587  * @channel: a #GIOChannel
 588  * @size: the size of the buffer. 0 == pick a good size
 589  *
 590  * Set the buffer size.
 591  **/
 592 void
 593 g_io_channel_set_buffer_size (GIOChannel        *channel,
 594                               gsize              size)
 595 {
 596   g_return_if_fail (channel != NULL);
 597
 598   if (size == 0)
 599     size = G_IO_NICE_BUF_SIZE;
 600
 601   if (size < MAX_CHAR_SIZE)
 602     size = MAX_CHAR_SIZE;
 603
 604   channel->buf_size = size;
 605 }
 606
 607 /**
 608  * g_io_channel_get_buffer_size:
 609  * @channel: a #GIOChannel
 610  *
 611  * Get the buffer size.
 612  *
 613  * Return value: the size of the buffer.
 614  **/
 615 gsize
 616 g_io_channel_get_buffer_size (GIOChannel        *channel)
 617 {
 618   g_return_val_if_fail (channel != NULL, 0);
 619
 620   return channel->buf_size;
 621 }
 622
 623 /**
 624  * g_io_channel_set_line_term:
 625  * @channel: a #GIOChannel
 626  * @line_term: The line termination string. Use %NULL for auto detect.
 627  *
 628  * This sets the string that #GIOChannel uses to determine
 629  * where in the file a line break occurs.
 630  **/
 631 void
 632 g_io_channel_set_line_term (GIOChannel  *channel,
 633                             const gchar *line_term)
 634 {
 635   g_return_if_fail (channel != NULL);
 636   g_return_if_fail (!line_term || line_term[0]); /* Disallow "" */
 637   g_return_if_fail (!line_term || g_utf8_validate (line_term, -1, NULL));
 638                    /* Require valid UTF-8 */
 639
 640   g_free (channel->line_term);
 641   channel->line_term = g_strdup (line_term);
 642 }
 643
 644 /**
 645  * g_io_channel_get_line_term:
 646  * @channel: a #GIOChannel
 647  *
 648  * This returns the string that #GIOChannel uses to determine
 649  * where in the file a line break occurs. A value of %NULL
 650  * indicates auto detection.
 651  *
 652  * Return value: The line termination string. This value
 653  *   is owned by GLib and must not be freed.
 654  **/
 655 G_CONST_RETURN gchar*
 656 g_io_channel_get_line_term (GIOChannel  *channel)
 657 {
 658   g_return_val_if_fail (channel != NULL, 0);
 659
 660   return channel->line_term;
 661 }
 662
 663 /**
 664  * g_io_channel_set_flags:
 665  * @channel: a #GIOChannel
 666  * @flags: the flags to set on the channel
 667  * @error: A location to return an error of type #GIOChannelError
 668  *
 669  * Return value:
 670  **/
 671 GIOStatus
 672 g_io_channel_set_flags (GIOChannel *channel,
 673                         GIOFlags    flags,
 674                         GError    **error)
 675 {
 676   g_return_val_if_fail (channel != NULL, G_IO_STATUS_ERROR);
 677   g_return_val_if_fail ((error == NULL) || (*error == NULL),
 678                         G_IO_STATUS_ERROR);
 679
 680   return (* channel->funcs->io_set_flags)(channel,
 681                                           flags & G_IO_FLAG_SET_MASK,
 682                                           error);
 683 }
 684
 685 /**
 686  * g_io_channel_get_flags:
 687  * @channel: a #GIOChannel
 688  *
 689  * Gets the current flags for a #GIOChannel, including read-only
 690  * flags such as %G_IO_FLAG_IS_READABLE.
 691  *
 692  * Return value: the flags which are set on the channel
 693  **/
 694 GIOFlags
 695 g_io_channel_get_flags (GIOChannel *channel)
 696 {
 697   GIOFlags flags;
 698
 699   g_return_val_if_fail (channel != NULL, G_IO_STATUS_ERROR);
 700
 701   flags = (* channel->funcs->io_get_flags) (channel);
 702
 703   /* Cross implementation code */
 704
 705   if (channel->is_seekable)
 706     flags |= G_IO_FLAG_IS_SEEKABLE;
 707   if (channel->is_readable)
 708     flags |= G_IO_FLAG_IS_READABLE;
 709   if (channel->is_writeable)
 710     flags |= G_IO_FLAG_IS_WRITEABLE;
 711
 712   return flags;
 713 }
 714
 715 /**
 716  * g_io_channel_seek_position:
 717  * @channel: a #GIOChannel
 718  * @offset: The offset in bytes from the position specified by @type
 719  * @type: a #GSeekType. The type %G_SEEK_CUR is only allowed if
 720  *        the channel has the default encoding or the
 721  *        encoding %G_IO_CHANNEL_ENCODE_RAW for raw file access.
 722  * @error: A location to return an error of type #GIOChannelError
 723  *
 724  * Replacement for g_io_channel_seek() with the new API.
 725  *
 726  * Return value:
 727  **/
 728 GIOStatus
 729 g_io_channel_seek_position      (GIOChannel* channel,
 730                                  glong       offset,
 731                                  GSeekType   type,
 732                                  GError    **error)
 733 {
 734   GIOStatus status;
 735
 736   /* For files, only one of the read and write buffers can contain data.
 737    * For sockets, both can contain data.
 738    */
 739
 740   g_return_val_if_fail (channel != NULL, G_IO_STATUS_ERROR);
 741   g_return_val_if_fail ((error == NULL) || (*error == NULL),
 742                         G_IO_STATUS_ERROR);
 743   g_return_val_if_fail (channel->is_seekable, G_IO_STATUS_ERROR);
 744
 745   switch (type)
 746     {
 747       case G_SEEK_CUR: /* The user is seeking relative to the head of the buffer */
 748         if (channel->use_buffer)
 749           {
 750             if (channel->do_encode && channel->encoded_read_buf
 751                 && channel->encoded_read_buf->len > 0)
 752               {
 753                 g_warning ("Seek type G_SEEK_CUR not allowed for this"
 754                   " channel's encoding.\n");
 755                 return G_IO_STATUS_ERROR;
 756               }
 757           if (channel->read_buf)
 758             offset -= channel->read_buf->len;
 759           if (channel->encoded_read_buf)
 760             {
 761               g_assert (channel->encoded_read_buf->len == 0 && !channel->do_encode);
 762
 763               /* If there's anything here, it's because the encoding is UTF-8,
 764                * so we can just subtract the buffer length, the same as for
 765                * the unencoded data.
 766                */
 767
 768               offset -= channel->encoded_read_buf->len;
 769             }
 770           }
 771         break;
 772       case G_SEEK_SET:
 773       case G_SEEK_END:
 774         break;
 775       default:
 776         g_warning ("g_io_channel_seek_position: unknown seek type");
 777         return G_IO_STATUS_ERROR;
 778     }
 779
 780   if (channel->use_buffer)
 781     {
 782       status = g_io_channel_flush (channel, error);
 783       if (status != G_IO_STATUS_NORMAL)
 784         return status;
 785     }
 786
 787   status = channel->funcs->io_seek (channel, offset, type, error);
 788
 789   if ((status == G_IO_STATUS_NORMAL) && (channel->use_buffer))
 790     {
 791       if (channel->read_buf)
 792         g_string_truncate (channel->read_buf, 0);
 793
 794       /* Conversion state no longer matches position in file */
 795       if (channel->read_cd != (GIConv) -1)
 796         g_iconv (channel->read_cd, NULL, NULL, NULL, NULL);
 797       if (channel->write_cd != (GIConv) -1)
 798         g_iconv (channel->write_cd, NULL, NULL, NULL, NULL);
 799
 800       if (channel->encoded_read_buf)
 801         {
 802           g_assert (channel->encoded_read_buf->len == 0 || !channel->do_encode);
 803           g_string_truncate (channel->encoded_read_buf, 0);
 804         }
 805
 806       if (channel->partial_write_buf[0] != '\0')
 807         {
 808           g_warning ("Partial character at end of write buffer not flushed.\n");
 809           channel->partial_write_buf[0] = '\0';
 810         }
 811     }
 812
 813   return status;
 814 }
 815
 816 /**
 817  * g_io_channel_flush:
 818  * @channel: a #GIOChannel
 819  * @error: location to store an error of type #GIOChannelError
 820  *
 821  * Flush the write buffer for the GIOChannel.
 822  *
 823  * Return value: the status of the operation: One of
 824  *   G_IO_CHANNEL_NORMAL, G_IO_CHANNEL_AGAIN, or
 825  *   G_IO_CHANNEL_ERROR.
 826  **/
 827 GIOStatus
 828 g_io_channel_flush (GIOChannel  *channel,
 829                     GError     **error)
 830 {
 831   GIOStatus status;
 832   gsize this_time = 1, bytes_written = 0;
 833
 834   g_return_val_if_fail (channel != NULL, G_IO_STATUS_ERROR);
 835   g_return_val_if_fail ((error == NULL) || (*error == NULL), G_IO_STATUS_ERROR);
 836
 837   if (channel->write_buf == NULL || channel->write_buf->len == 0)
 838     return G_IO_STATUS_NORMAL;
 839
 840   do
 841     {
 842       g_assert (this_time > 0);
 843
 844       status = channel->funcs->io_write (channel,
 845                                       channel->write_buf->str + bytes_written,
 846                                       channel->write_buf->len - bytes_written,
 847                                       &this_time, error);
 848       bytes_written += this_time;
 849     }
 850   while ((bytes_written < channel->write_buf->len)
 851          && (status == G_IO_STATUS_NORMAL));
 852
 853   g_string_erase (channel->write_buf, 0, bytes_written);
 854
 855   return status;
 856 }
 857
 858 /**
 859  * g_io_channel_set_buffered:
 860  * @channel: a #GIOChannel
 861  * @buffered: whether to set the channel buffered or unbuffered
 862  *
 863  * The buffering state can only be set if the channel's encoding
 864  * is %NULL. For any other encoding, the channel must be buffered.
 865  *
 866  * The default state of the channel is buffered.
 867  **/
 868 void
 869 g_io_channel_set_buffered       (GIOChannel *channel,
 870                                  gboolean    buffered)
 871 {
 872   g_return_if_fail (channel != NULL);
 873
 874   if (channel->encoding != NULL)
 875     {
 876       g_warning ("Need to have NULL encoding to set the buffering state of the "
 877                  "channel.\n");
 878       return;
 879     }
 880
 881   g_return_if_fail (!channel->read_buf || channel->read_buf->len == 0);
 882   g_return_if_fail (!channel->write_buf || channel->write_buf->len == 0);
 883
 884   channel->use_buffer = buffered;
 885 }
 886
 887 /**
 888  * g_io_channel_get_buffered:
 889  * @channel: a #GIOChannel
 890  *
 891  * Return Value: the buffering state of the channel
 892  **/
 893 gboolean
 894 g_io_channel_get_buffered       (GIOChannel *channel)
 895 {
 896   g_return_val_if_fail (channel != NULL, FALSE);
 897
 898   return channel->use_buffer;
 899 }
 900
 901 /**
 902  * g_io_channel_set_encoding:
 903  * @channel: a #GIOChannel
 904  * @encoding: the encoding type
 905  * @error: location to store an error of type #GConvertError.
 906  *
 907  * Set the encoding for the input/output of the channel. The internal
 908  * encoding is always UTF-8. The default encoding for the
 909  * external file is UTF-8.
 910  *
 911  * The encoding %NULL is safe to use with binary data.
 912  * Encodings other than %NULL must use a buffered channel.
 913  * Encodings other than %NULL and UTF-8 cannot
 914  * use g_io_channel_seek_position() with seek type %G_SEEK_CUR,
 915  * and cannot mix reading and writing if the channel is
 916  * a file without first doing a seek of type %G_SEEK_SET or
 917  * %G_SEEK_END.
 918  *
 919  * The encoding can only be set under three conditions:
 920  *
 921  * 1. The channel was just created, and has not been written to
 922  *    or read from yet.
 923  *
 924  * 2. The channel is a file, and the file pointer was just
 925  *    repositioned by a call to g_io_channel_seek_position().
 926  *    (This flushes all the internal buffers.)
 927  *
 928  * 3. The current encoding is %NULL or UTF-8.
 929  *
 930  * Return Value: %G_IO_STATUS_NORMAL if the encoding was succesfully set.
 931  **/
 932 GIOStatus
 933 g_io_channel_set_encoding (GIOChannel   *channel,
 934                            const gchar  *encoding,
 935                            GError      **error)
 936 {
 937   GIConv read_cd, write_cd;
 938   gboolean did_encode;
 939
 940   g_return_val_if_fail (channel != NULL, G_IO_STATUS_ERROR);
 941   g_return_val_if_fail ((error == NULL) || (*error == NULL), G_IO_STATUS_ERROR);
 942
 943   /* Make sure the encoded buffers are empty */
 944
 945   g_return_val_if_fail (!channel->do_encode || !channel->encoded_read_buf ||
 946                         channel->encoded_read_buf->len == 0, G_IO_STATUS_ERROR);
 947
 948   if (!channel->use_buffer)
 949     {
 950       g_warning ("Need to set the channel buffered before setting the encoding.\n");
 951       g_warning ("Assuming this is what you meant and acting accordingly.\n");
 952
 953       channel->use_buffer = TRUE;
 954     }
 955
 956   if (channel->partial_write_buf[0] != '\0')
 957     {
 958       g_warning ("Partial character at end of write buffer not flushed.\n");
 959       channel->partial_write_buf[0] = '\0';
 960     }
 961
 962   did_encode = channel->do_encode;
 963
 964   if (!encoding || strcmp (encoding, "UTF8") == 0 || strcmp (encoding, "UTF-8") == 0)
 965     {
 966       channel->do_encode = FALSE;
 967       read_cd = write_cd = (GIConv) -1;
 968     }
 969   else
 970     {
 971       gint err = 0;
 972       const gchar *from_enc = NULL, *to_enc = NULL;
 973
 974       if (channel->is_readable)
 975         {
 976           read_cd = g_iconv_open ("UTF-8", encoding);
 977
 978           if (read_cd == (GIConv) -1)
 979             {
 980               err = errno;
 981               from_enc = "UTF-8";
 982               to_enc = encoding;
 983             }
 984         }
 985       else
 986         read_cd = (GIConv) -1;
 987
 988       if (channel->is_writeable && err == 0)
 989         {
 990           write_cd = g_iconv_open (encoding, "UTF-8");
 991
 992           if (write_cd == (GIConv) -1)
 993             {
 994               err = errno;
 995               from_enc = encoding;
 996               to_enc = "UTF-8";
 997             }
 998         }
 999       else
1000         write_cd = (GIConv) -1;
1001
1002       if (err != 0)
1003         {
1004           g_assert (from_enc);
1005           g_assert (to_enc);
1006
1007           if (err == EINVAL)
1008             g_set_error (error, G_CONVERT_ERROR, G_CONVERT_ERROR_NO_CONVERSION,
1009                          _("Conversion from character set `%s' to `%s' is not supported"),
1010                          from_enc, to_enc);
1011           else
1012             g_set_error (error, G_CONVERT_ERROR, G_CONVERT_ERROR_FAILED,
1013                          _("Could not open converter from `%s' to `%s': %s"),
1014                          from_enc, to_enc, strerror (errno));
1015
1016           if (read_cd != (GIConv) -1)
1017             g_iconv_close (read_cd);
1018           if (write_cd != (GIConv) -1)
1019             g_iconv_close (write_cd);
1020
1021           return G_IO_STATUS_ERROR;
1022         }
1023
1024       channel->do_encode = TRUE;
1025     }
1026
1027   /* The encoding is ok, so set the fields in channel */
1028
1029   if (channel->read_cd != (GIConv) -1)
1030     g_iconv_close (channel->read_cd);
1031   if (channel->write_cd != (GIConv) -1)
1032     g_iconv_close (channel->write_cd);
1033
1034   if (channel->encoded_read_buf && channel->encoded_read_buf->len > 0)
1035     {
1036       g_assert (!did_encode); /* Encoding UTF-8, NULL doesn't use encoded_read_buf */
1037
1038       /* This is just validated UTF-8, so we can copy it back into read_buf
1039        * so it can be encoded in whatever the new encoding is.
1040        */
1041
1042       g_string_prepend_len (channel->read_buf, channel->encoded_read_buf->str,
1043                             channel->encoded_read_buf->len);
1044       g_string_truncate (channel->encoded_read_buf, 0);
1045     }
1046
1047   channel->read_cd = read_cd;
1048   channel->write_cd = write_cd;
1049
1050   g_free (channel->encoding);
1051   channel->encoding = g_strdup (encoding);
1052
1053   return G_IO_STATUS_NORMAL;
1054 }
1055
1056 /**
1057  * g_io_channel_get_encoding:
1058  * @channel: a #GIOChannel
1059  *
1060  * Get the encoding for the input/output of the channel. The internal
1061  * encoding is always UTF-8. The encoding %G_IO_CHANNEL_ENCODE_RAW
1062  * disables encoding and turns off internal buffering. Both
1063  * %G_IO_CHANNEL_ENCODE_RAW and the default (no encoding, but buffered)
1064  * are safe to use with binary data.
1065  *
1066  * Return value: A string containing the encoding, this string is
1067  *   owned by GLib and must not be freed.
1068  **/
1069 G_CONST_RETURN gchar*
1070 g_io_channel_get_encoding (GIOChannel      *channel)
1071 {
1072   g_return_val_if_fail (channel != NULL, NULL);
1073
1074   return channel->encoding;
1075 }
1076
1077 static GIOStatus
1078 g_io_channel_fill_buffer (GIOChannel *channel,
1079                           GError    **err)
1080 {
1081   gsize read_size, cur_len, oldlen;
1082   GIOStatus status;
1083
1084   if (channel->is_seekable && channel->write_buf && channel->write_buf->len > 0)
1085     {
1086       status = g_io_channel_flush (channel, err);
1087       if (status != G_IO_STATUS_NORMAL)
1088         return status;
1089     }
1090   if (channel->is_seekable && channel->partial_write_buf[0] != '\0')
1091     {
1092       g_warning ("Partial character at end of write buffer not flushed.\n");
1093       channel->partial_write_buf[0] = '\0';
1094     }
1095
1096   if (!channel->read_buf)
1097     channel->read_buf = g_string_sized_new (channel->buf_size);
1098
1099   cur_len = channel->read_buf->len;
1100
1101   g_string_set_size (channel->read_buf, channel->read_buf->len + channel->buf_size);
1102
1103   status = channel->funcs->io_read (channel, channel->read_buf->str + cur_len,
1104                                     channel->buf_size, &read_size, err);
1105
1106   g_assert ((status == G_IO_STATUS_NORMAL) || (read_size == 0));
1107
1108   g_string_truncate (channel->read_buf, read_size + cur_len);
1109
1110   if ((status != G_IO_STATUS_NORMAL)
1111     && ((status != G_IO_STATUS_EOF) || (channel->read_buf->len == 0)))
1112     return status;
1113
1114   g_assert (channel->read_buf->len > 0);
1115
1116   if (channel->encoded_read_buf)
1117     oldlen = channel->encoded_read_buf->len;
1118   else
1119     {
1120       oldlen = 0;
1121       if (channel->encoding)
1122         channel->encoded_read_buf = g_string_sized_new (channel->buf_size);
1123     }
1124
1125   if (channel->do_encode)
1126     {
1127       size_t errnum, inbytes_left, outbytes_left;
1128       gchar *inbuf, *outbuf;
1129
1130       g_assert (channel->encoded_read_buf);
1131
1132 reencode:
1133
1134       inbytes_left = channel->read_buf->len;
1135       outbytes_left = MIN (channel->buf_size / 4,
1136                            channel->encoded_read_buf->allocated_len
1137                            - channel->encoded_read_buf->len);
1138
1139       g_string_set_size (channel->encoded_read_buf,
1140                          channel->encoded_read_buf->len + outbytes_left);
1141
1142       inbuf = channel->read_buf->str;
1143       outbuf = channel->encoded_read_buf->str + channel->encoded_read_buf->len
1144                - outbytes_left;
1145
1146       errnum = g_iconv (channel->read_cd, &inbuf, &inbytes_left,
1147                         &outbuf, &outbytes_left);
1148
1149       g_string_erase (channel->read_buf, 0,
1150                       channel->read_buf->len - inbytes_left);
1151       g_string_truncate (channel->encoded_read_buf,
1152                          channel->encoded_read_buf->len - outbytes_left);
1153
1154       if (errnum == (size_t) -1)
1155         {
1156           switch (errno)
1157             {
1158               case EINVAL:
1159                 if ((oldlen == channel->encoded_read_buf->len)
1160                   && (status == G_IO_STATUS_EOF))
1161                   status = G_IO_STATUS_EOF;
1162                 else
1163                   status = G_IO_STATUS_NORMAL;
1164                 break;
1165               case E2BIG:
1166                 goto reencode;
1167               case EILSEQ:
1168                 if (oldlen < channel->encoded_read_buf->len)
1169                   status = G_IO_STATUS_NORMAL;
1170                 else
1171                   {
1172                     g_set_error (err, G_CONVERT_ERROR,
1173                       G_CONVERT_ERROR_ILLEGAL_SEQUENCE,
1174                       _("Invalid byte sequence in conversion input"));
1175                     return G_IO_STATUS_ERROR;
1176                   }
1177                 break;
1178               default:
1179                 g_set_error (err, G_CONVERT_ERROR, G_CONVERT_ERROR_FAILED,
1180                   _("Error during conversion: %s"), strerror (errno));
1181                 return G_IO_STATUS_ERROR;
1182             }
1183         }
1184       g_assert ((status != G_IO_STATUS_NORMAL)
1185                || (channel->encoded_read_buf->len > 0));
1186     }
1187   else if (channel->encoding) /* UTF-8 */
1188     {
1189       gchar *nextchar, *lastchar;
1190
1191       g_assert (channel->encoded_read_buf);
1192
1193       nextchar = channel->read_buf->str;
1194       lastchar = channel->read_buf->str + channel->read_buf->len;
1195
1196       while (nextchar < lastchar)
1197         {
1198           gunichar val_char;
1199
1200           val_char = g_utf8_get_char_validated (nextchar, lastchar - nextchar);
1201
1202           switch (val_char)
1203             {
1204               case -2:
1205                 /* stop, leave partial character in buffer */
1206                 lastchar = nextchar;
1207                 break;
1208               case -1:
1209                 if (oldlen > channel->encoded_read_buf->len)
1210                   status = G_IO_STATUS_NORMAL;
1211                 else
1212                   {
1213                     g_set_error (err, G_CONVERT_ERROR,
1214                       G_CONVERT_ERROR_ILLEGAL_SEQUENCE,
1215                       _("Invalid byte sequence in conversion input"));
1216                     status = G_IO_STATUS_ERROR;
1217                   }
1218                 lastchar = nextchar;
1219                 break;
1220               default:
1221                 nextchar = g_utf8_next_char (nextchar);
1222                 break;
1223             }
1224         }
1225
1226       if (lastchar > channel->read_buf->str)
1227         {
1228           gint copy_len = lastchar - channel->read_buf->str;
1229
1230           g_string_append_len (channel->encoded_read_buf, channel->read_buf->str,
1231                                copy_len);
1232           g_string_erase (channel->read_buf, 0, copy_len);
1233         }
1234     }
1235
1236   return status;
1237 }
1238
1239 /**
1240  * g_io_channel_read_line:
1241  * @channel: a #GIOChannel
1242  * @str_return: The line read from the #GIOChannel, not including the
1243  *              line terminator. This data should be freed with g_free()
1244  *              when no longer needed. This
1245  *              is a null terminated string. If a @length of zero is
1246  *              returned, this will be %NULL instead.
1247  * @length: location to store length of the read data, or %NULL
1248  * @terminator_pos: location to store position of line terminator, or %NULL
1249  * @error: A location to return an error of type #GConvertError
1250  *         or #GIOChannelError
1251  *
1252  * Read a line, not including the terminating character(s),
1253  * from a #GIOChannel into a newly allocated string.
1254  * @length will contain allocated memory if the return
1255  * is %G_IO_STATUS_NORMAL.
1256  *
1257  * Return value: a newly allocated string. Free this string
1258  *   with g_free() when you are done with it.
1259  **/
1260 GIOStatus
1261 g_io_channel_read_line (GIOChannel *channel,
1262                         gchar     **str_return,
1263                         gsize      *length,
1264                         gsize      *terminator_pos,
1265                         GError    **error)
1266 {
1267   GIOStatus status;
1268   gsize got_length;
1269
1270   g_return_val_if_fail (channel != NULL, G_IO_STATUS_ERROR);
1271   g_return_val_if_fail (str_return != NULL, G_IO_STATUS_ERROR);
1272   g_return_val_if_fail ((error == NULL) || (*error == NULL),
1273                         G_IO_STATUS_ERROR);
1274   g_return_val_if_fail (channel->is_readable, G_IO_STATUS_ERROR);
1275
1276   status = g_io_channel_read_line_backend (channel, &got_length, terminator_pos, error);
1277
1278   if (length)
1279     *length = got_length;
1280
1281   if (status == G_IO_STATUS_NORMAL)
1282     {
1283       g_assert (USE_BUF (channel));
1284       *str_return = g_strndup (USE_BUF (channel)->str, got_length);
1285       g_string_erase (USE_BUF (channel), 0, got_length);
1286     }
1287   else
1288     *str_return = NULL;
1289
1290   return status;
1291 }
1292
1293 /**
1294  * g_io_channel_read_line_string:
1295  * @channel: a #GIOChannel
1296  * @buffer: a #GString into which the line will be written.
1297  *          If @buffer already contains data, the new data will
1298  *          be appended to it.
1299  * @terminator_pos: location to store position of line terminator, or %NULL
1300  * @error: a location to store an error of type #GConvertError
1301  *         or #GIOChannelError
1302  *
1303  * Read a line from a #GIOChannel, using a #GString as a buffer.
1304  *
1305  * Return value:
1306  **/
1307 GIOStatus
1308 g_io_channel_read_line_string (GIOChannel *channel,
1309                                GString    *buffer,
1310                                gsize      *terminator_pos,
1311                                GError    **error)
1312 {
1313   gsize length;
1314   GIOStatus status;
1315
1316   g_return_val_if_fail (channel != NULL, G_IO_STATUS_ERROR);
1317   g_return_val_if_fail (buffer != NULL, G_IO_STATUS_ERROR);
1318   g_return_val_if_fail ((error == NULL) || (*error == NULL),
1319                         G_IO_STATUS_ERROR);
1320   g_return_val_if_fail (channel->is_readable, G_IO_STATUS_ERROR);
1321
1322   if (buffer->len > 0)
1323     g_string_truncate (buffer, 0); /* clear out the buffer */
1324
1325   status = g_io_channel_read_line_backend (channel, &length, terminator_pos, error);
1326
1327   if (status == G_IO_STATUS_NORMAL)
1328     {
1329       g_assert (USE_BUF (channel));
1330       g_string_append_len (buffer, USE_BUF (channel)->str, length);
1331       g_string_erase (USE_BUF (channel), 0, length);
1332     }
1333
1334   return status;
1335 }
1336
1337
1338 static GIOStatus
1339 g_io_channel_read_line_backend  (GIOChannel *channel,
1340                                  gsize      *length,
1341                                  gsize      *terminator_pos,
1342                                  GError    **error)
1343 {
1344   GIOStatus status;
1345   gsize checked_to, line_term_len, line_length, got_term_len;
1346   gboolean first_time = TRUE;
1347
1348   if (!channel->use_buffer)
1349     {
1350       /* Can't do a raw read in read_line */
1351       g_set_error (error, G_CONVERT_ERROR, G_CONVERT_ERROR_FAILED,
1352                    _("Can't do a raw read in g_io_channel_read_line_string"));
1353       return G_IO_STATUS_ERROR;
1354     }
1355
1356   status = G_IO_STATUS_NORMAL;
1357
1358   if (channel->line_term)
1359     line_term_len = strlen (channel->line_term);
1360   else
1361     line_term_len = 3;
1362     /* This value used for setting checked_to, it's the longest of the four
1363      * we autodetect for.
1364      */
1365
1366   checked_to = 0;
1367
1368   while (TRUE)
1369     {
1370       gchar *nextchar, *lastchar;
1371       GString *use_buf;
1372
1373       if (!first_time || (BUF_LEN (USE_BUF (channel)) == 0))
1374         {
1375 read_again:
1376           status = g_io_channel_fill_buffer (channel, error);
1377           switch (status)
1378             {
1379               case G_IO_STATUS_NORMAL:
1380                 if (BUF_LEN (USE_BUF (channel)) == 0)
1381                   /* Can happen when using conversion and only read
1382                    * part of a character
1383                    */
1384                   {
1385                     first_time = FALSE;
1386                     continue;
1387                   }
1388                 break;
1389               case G_IO_STATUS_EOF:
1390                 if (BUF_LEN (USE_BUF (channel)) == 0)
1391                   {
1392                     if (length)
1393                       *length = 0;
1394
1395                     if (channel->encoding && channel->read_buf->len != 0)
1396                       {
1397                         g_set_error (error, G_CONVERT_ERROR,
1398                                      G_CONVERT_ERROR_PARTIAL_INPUT,
1399                                      "Leftover unconverted data in read buffer");
1400                         return G_IO_STATUS_ERROR;
1401                       }
1402                     else
1403                       return G_IO_STATUS_EOF;
1404                   }
1405                 break;
1406               default:
1407                 if (length)
1408                   *length = 0;
1409                 return status;
1410             }
1411         }
1412
1413       g_assert (BUF_LEN (USE_BUF (channel)) != 0);
1414
1415       use_buf = USE_BUF (channel); /* The buffer has been created by this point */
1416
1417       first_time = FALSE;
1418
1419       lastchar = use_buf->str + strlen (use_buf->str);
1420
1421       for (nextchar = use_buf->str + checked_to; nextchar < lastchar;
1422            channel->encoding ? nextchar = g_utf8_next_char (nextchar) : nextchar++)
1423         {
1424           if (channel->line_term)
1425             {
1426               if (strncmp (channel->line_term, nextchar, line_term_len) == 0)
1427                 {
1428                   line_length = nextchar - use_buf->str;
1429                   got_term_len = line_term_len;
1430                   goto done;
1431                 }
1432             }
1433           else /* auto detect */
1434             {
1435               switch (*nextchar)
1436                 {
1437                   case '\n': /* unix */
1438                     line_length = nextchar - use_buf->str;
1439                     got_term_len = 1;
1440                     goto done;
1441                   case '\r': /* Warning: do not use with sockets */
1442                     line_length = nextchar - use_buf->str;
1443                     if ((nextchar == lastchar - 1) && (status != G_IO_STATUS_EOF)
1444                        && (lastchar == use_buf->str + use_buf->len))
1445                       goto read_again; /* Try to read more data */
1446                     if ((nextchar < lastchar - 1) && (*(nextchar + 1) == '\n')) /* dos */
1447                       got_term_len = 2;
1448                     else /* mac */
1449                       got_term_len = 1;
1450                     goto done;
1451                   case '\xe2': /* Unicode paragraph separator */
1452                     if (strncmp ("\xe2\x80\xa9", nextchar, 3) == 0)
1453                       {
1454                         line_length = nextchar - use_buf->str;
1455                         got_term_len = 3;
1456                         goto done;
1457                       }
1458                     break;
1459                   default: /* no match */
1460                     break;
1461                 }
1462             }
1463         }
1464
1465       g_assert (nextchar == lastchar); /* Valid UTF-8, didn't overshoot */
1466
1467       /* Also terminate on '\0' */
1468
1469       line_length = lastchar - use_buf->str;
1470       if (line_length < use_buf->len)
1471         {
1472           got_term_len = 0;
1473           break;
1474         }
1475
1476       /* Check for EOF */
1477
1478       if (status == G_IO_STATUS_EOF)
1479         {
1480           if (channel->encoding && channel->read_buf->len > 0)
1481             {
1482               g_set_error (error, G_CONVERT_ERROR, G_CONVERT_ERROR_PARTIAL_INPUT,
1483                            "Channel terminates in a partial character");
1484               return G_IO_STATUS_ERROR;
1485             }
1486           line_length = use_buf->len;
1487           got_term_len = 0;
1488           break;
1489         }
1490
1491       if (use_buf->len > line_term_len - 1)
1492         checked_to = use_buf->len - (line_term_len - 1);
1493       else
1494         checked_to = 0;
1495     }
1496
1497 done:
1498
1499   if (terminator_pos)
1500     *terminator_pos = line_length;
1501
1502   if (length)
1503     *length = line_length + got_term_len;
1504
1505   return G_IO_STATUS_NORMAL;
1506 }
1507
1508 /**
1509  * g_io_channel_read_to_end:
1510  * @channel: a #GIOChannel
1511  * @str_return: Location to store a pointer to a string holding
1512  *              the remaining data in the #GIOChannel. This data should
1513  *              be freed with g_free() when no longer needed. This
1514  *              data is terminated by an extra null, but there may be other
1515  *              nulls in the intervening data.
1516  * @length: Location to store length of the data
1517  * @error: A location to return an error of type #GConvertError
1518  *         or #GIOChannelError
1519  *
1520  * Read all the remaining data from the file. Parameters as
1521  * for g_io_channel_read_line.
1522  *
1523  * Return value: One of #G_IO_STATUS_EOF or #G_IO_STATUS_PARTIAL_CHARS
1524  *               on success
1525  **/
1526 GIOStatus
1527 g_io_channel_read_to_end (GIOChannel    *channel,
1528                           gchar        **str_return,
1529                           gsize         *length,
1530                           GError       **error)
1531 {
1532   GIOStatus status;
1533
1534   g_return_val_if_fail (channel != NULL, G_IO_STATUS_ERROR);
1535   g_return_val_if_fail ((error == NULL) || (*error == NULL),
1536     G_IO_STATUS_ERROR);
1537   g_return_val_if_fail (channel->is_readable, G_IO_STATUS_ERROR);
1538
1539   if (str_return)
1540     *str_return = NULL;
1541   if (length)
1542     *length = 0;
1543
1544   if (!channel->use_buffer)
1545     {
1546       g_set_error (error, G_CONVERT_ERROR, G_CONVERT_ERROR_FAILED,
1547                    _("Can't do a raw read in g_io_channel_read_to_end"));
1548       return G_IO_STATUS_ERROR;
1549     }
1550
1551   do
1552     status = g_io_channel_fill_buffer (channel, error);
1553   while (status == G_IO_STATUS_NORMAL);
1554
1555   if (status != G_IO_STATUS_EOF)
1556     return status;
1557
1558   if (channel->encoding && channel->read_buf->len > 0)
1559     {
1560       g_set_error (error, G_CONVERT_ERROR, G_CONVERT_ERROR_PARTIAL_INPUT,
1561                    "Channel terminates in a partial character");
1562       return G_IO_STATUS_ERROR;
1563     }
1564
1565   if (USE_BUF (channel) == NULL)
1566     {
1567       /* length is already set to zero */
1568       if (str_return)
1569         *str_return = g_strdup ("");
1570     }
1571   else
1572     {
1573       if (length)
1574         *length = USE_BUF (channel)->len;
1575
1576       if (str_return)
1577         *str_return = g_string_free (USE_BUF (channel), FALSE);
1578       else
1579         g_string_free (USE_BUF (channel), TRUE);
1580
1581       /* This only works because USE_BUF () is a macro */
1582       USE_BUF (channel) = NULL;
1583     }
1584
1585   return G_IO_STATUS_NORMAL;
1586 }
1587
1588 /**
1589  * g_io_channel_read_chars:
1590  * @channel: a #GIOChannel
1591  * @buf: a buffer to read data into
1592  * @count: the size of the buffer. Note that the buffer may
1593  *         not be complelely filled even if there is data
1594  *         in the buffer if the remaining data is not a
1595  *         complete character.
1596  * @bytes_read: The number of bytes read.
1597  * @error: A location to return an error of type #GConvertError
1598  *         or #GIOChannelError.
1599  *
1600  * Replacement for g_io_channel_read() with the new API.
1601  *
1602  * Return value:
1603  **/
1604 GIOStatus
1605 g_io_channel_read_chars (GIOChannel     *channel,
1606                          gchar          *buf,
1607                          gsize           count,
1608                          gsize          *bytes_read,
1609                          GError        **error)
1610 {
1611   GIOStatus status;
1612   gsize got_bytes;
1613
1614   g_return_val_if_fail (channel != NULL, G_IO_STATUS_ERROR);
1615   g_return_val_if_fail ((error == NULL) || (*error == NULL),
1616                         G_IO_STATUS_ERROR);
1617   g_return_val_if_fail (channel->is_readable, G_IO_STATUS_ERROR);
1618
1619   if (count == 0)
1620     {
1621       *bytes_read = 0;
1622       return G_IO_STATUS_NORMAL;
1623     }
1624   g_return_val_if_fail (buf != NULL, G_IO_STATUS_ERROR);
1625
1626   if (!channel->use_buffer)
1627     {
1628       g_assert (!channel->read_buf || channel->read_buf->len == 0);
1629
1630       return channel->funcs->io_read (channel, buf, count, bytes_read, error);
1631     }
1632
1633   status = G_IO_STATUS_NORMAL;
1634
1635   while (BUF_LEN (USE_BUF (channel)) < count && status == G_IO_STATUS_NORMAL)
1636     status = g_io_channel_fill_buffer (channel, error);
1637
1638   /* Only return an error if we have no data */
1639
1640   if (BUF_LEN (USE_BUF (channel)) == 0)
1641     {
1642       g_assert (status != G_IO_STATUS_NORMAL);
1643
1644       if (status == G_IO_STATUS_EOF && channel->encoding
1645           && BUF_LEN (channel->read_buf) > 0)
1646         {
1647           g_set_error (error, G_CONVERT_ERROR,
1648                        G_CONVERT_ERROR_PARTIAL_INPUT,
1649                        "Leftover unconverted data in read buffer");
1650           status = G_IO_STATUS_ERROR;
1651         }
1652
1653       if (bytes_read)
1654         *bytes_read = 0;
1655
1656       return status;
1657     }
1658
1659   if (status == G_IO_STATUS_ERROR)
1660     g_clear_error (error);
1661
1662   got_bytes = MIN (count, BUF_LEN (USE_BUF (channel)));
1663
1664   g_assert (got_bytes > 0);
1665
1666   if (channel->encoding)
1667     /* Don't validate for NULL encoding, binary safe */
1668     {
1669       gchar *nextchar, *prevchar;
1670
1671       g_assert (USE_BUF (channel) == channel->encoded_read_buf);
1672
1673       nextchar = channel->encoded_read_buf->str;
1674
1675       do
1676         {
1677           prevchar = nextchar;
1678           nextchar = g_utf8_next_char (nextchar);
1679         }
1680       while (nextchar < channel->encoded_read_buf->str + got_bytes);
1681
1682       if (nextchar > channel->encoded_read_buf->str + got_bytes)
1683         got_bytes = prevchar - channel->encoded_read_buf->str;
1684
1685       g_assert (got_bytes > 0 || count < 6);
1686     }
1687
1688   memcpy (buf, USE_BUF (channel)->str, got_bytes);
1689   g_string_erase (USE_BUF (channel), 0, got_bytes);
1690
1691   if (bytes_read)
1692     *bytes_read = got_bytes;
1693
1694   return G_IO_STATUS_NORMAL;
1695 }
1696
1697 /**
1698  * g_io_channel_write_chars:
1699  * @channel: a #GIOChannel
1700  * @buf: a buffer to write data from
1701  * @count: the size of the buffer. If -1, the buffer
1702  *         is taken to be a nul terminated string.
1703  * @bytes_written: The number of bytes written. This can be nonzero
1704  *                 even if the return value is not %G_IO_STATUS_NORMAL.
1705  * @error: A location to return an error of type #GConvertError
1706  *         or #GIOChannelError
1707  *
1708  * Replacement for g_io_channel_write() with the new API.
1709  *
1710  * Return value:
1711  **/
1712 GIOStatus
1713 g_io_channel_write_chars (GIOChannel    *channel,
1714                           const gchar   *buf,
1715                           gssize         count,
1716                           gsize         *bytes_written,
1717                           GError       **error)
1718 {
1719   GIOStatus status;
1720   gssize wrote_bytes = 0;
1721
1722   g_return_val_if_fail (channel != NULL, G_IO_STATUS_ERROR);
1723   g_return_val_if_fail (bytes_written != NULL, G_IO_STATUS_ERROR);
1724   g_return_val_if_fail ((error == NULL) || (*error == NULL),
1725                         G_IO_STATUS_ERROR);
1726   g_return_val_if_fail (channel->is_writeable, G_IO_STATUS_ERROR);
1727
1728   if ((count < 0) && buf)
1729     count = strlen (buf);
1730
1731   if (count == 0)
1732     return G_IO_STATUS_NORMAL;
1733
1734   g_return_val_if_fail (buf != NULL, G_IO_STATUS_ERROR);
1735   g_return_val_if_fail (count > 0, G_IO_STATUS_ERROR);
1736
1737   /* Raw write case */
1738
1739   if (!channel->use_buffer)
1740     {
1741       g_assert (!channel->write_buf || channel->write_buf->len == 0);
1742       g_assert (channel->partial_write_buf[0] == '\0');
1743       return channel->funcs->io_write (channel, buf, count, bytes_written, error);
1744     }
1745
1746   /* General case */
1747
1748   if (channel->is_seekable && (( BUF_LEN (channel->read_buf) > 0)
1749     || (BUF_LEN (channel->encoded_read_buf) > 0)))
1750     {
1751       if (channel->do_encode && BUF_LEN (channel->encoded_read_buf) > 0)
1752         {
1753           g_warning("Mixed reading and writing not allowed on encoded files");
1754           return G_IO_STATUS_ERROR;
1755         }
1756       status = g_io_channel_seek_position (channel, 0, G_SEEK_CUR, error);
1757       if (status != G_IO_STATUS_NORMAL)
1758         return status;
1759     }
1760
1761   if (!channel->write_buf)
1762     channel->write_buf = g_string_sized_new (channel->buf_size);
1763
1764   while (wrote_bytes < count)
1765     {
1766       gsize space_in_buf;
1767
1768       /* If the buffer is full, try a write immediately. In
1769        * the nonblocking case, this prevents the user from
1770        * writing just a little bit to the buffer every time
1771        * and never receiving an EAGAIN.
1772        */
1773
1774       if (channel->write_buf->len >= channel->buf_size)
1775         {
1776           gsize did_write = 0, this_time;
1777
1778           do
1779             {
1780               status = channel->funcs->io_write (channel, channel->write_buf->str
1781                                                  + did_write, channel->write_buf->len
1782                                                  - did_write, &this_time, error);
1783               did_write += this_time;
1784             }
1785           while (status == G_IO_STATUS_NORMAL &&
1786                  did_write < MIN (channel->write_buf->len,
1787                              MAX (MAX_CHAR_SIZE, channel->buf_size / 4)));
1788
1789           g_string_erase (channel->write_buf, 0, did_write);
1790
1791           if (status != G_IO_STATUS_NORMAL)
1792             {
1793               if (status == G_IO_STATUS_AGAIN && wrote_bytes > 0)
1794                 status = G_IO_STATUS_NORMAL;
1795               if (bytes_written)
1796                 *bytes_written = wrote_bytes;
1797               return status;
1798             }
1799         }
1800
1801       space_in_buf = MAX (channel->buf_size, channel->write_buf->allocated_len)
1802                      - channel->write_buf->len;
1803
1804       /* This is only true because g_io_channel_set_buffer_size ()
1805        * ensures that channel->buf_size >= MAX_CHAR_SIZE.
1806        */
1807       g_assert (space_in_buf >= MAX_CHAR_SIZE);
1808
1809       if (!channel->encoding)
1810         {
1811           gssize write_this = MIN (space_in_buf, count - wrote_bytes);
1812
1813           g_string_append_len (channel->write_buf, buf, write_this);
1814           buf += write_this;
1815           wrote_bytes += write_this;
1816         }
1817       else
1818         {
1819           const gchar *from_buf;
1820           gsize from_buf_len, from_buf_old_len, left_len;
1821           size_t err;
1822           gint errnum;
1823
1824           if (channel->partial_write_buf[0] != '\0')
1825             {
1826               g_assert (wrote_bytes == 0);
1827
1828               from_buf = channel->partial_write_buf;
1829               from_buf_old_len = strlen (channel->partial_write_buf);
1830               g_assert (from_buf_old_len > 0);
1831               from_buf_len = MIN (6, from_buf_old_len + count);
1832
1833               memcpy (channel->partial_write_buf + from_buf_old_len, buf,
1834                       from_buf_len - from_buf_old_len);
1835             }
1836           else
1837             {
1838               from_buf = buf;
1839               from_buf_len = count - wrote_bytes;
1840               from_buf_old_len = 0;
1841             }
1842
1843 reconvert:
1844
1845           if (!channel->do_encode)
1846             {
1847               const gchar *badchar;
1848
1849               /* UTF-8, just validate, emulate g_iconv */
1850
1851               if (!g_utf8_validate (from_buf, from_buf_len, &badchar))
1852                 {
1853                   gunichar try_char;
1854
1855                   left_len = from_buf + from_buf_len - badchar;
1856
1857                   try_char = g_utf8_get_char_validated (badchar, left_len);
1858
1859                   switch (try_char)
1860                     {
1861                       case -2:
1862                         g_assert (left_len < 6);
1863                         errnum = EINVAL;
1864                         break;
1865                       case -1:
1866                         errnum = EILSEQ;
1867                         break;
1868                       default:
1869                         g_assert_not_reached ();
1870                         errnum = 0; /* Don't confunse the compiler */
1871                     }
1872                   err = (size_t) -1;
1873                 }
1874               else
1875                 {
1876                   err = (size_t) 0;
1877                   errnum = 0;
1878                   left_len = 0;
1879                 }
1880
1881               g_string_append_len (channel->write_buf, from_buf,
1882                                    from_buf_len - left_len);
1883               from_buf += from_buf_len - left_len;
1884             }
1885           else
1886             {
1887                gchar *outbuf;
1888
1889                left_len = from_buf_len;
1890                outbuf = channel->write_buf->str + channel->write_buf->len;
1891                g_string_set_size (channel->write_buf, channel->write_buf->len
1892                                   + space_in_buf);
1893                err = g_iconv (channel->write_cd, (gchar **) &from_buf, &left_len,
1894                               &outbuf, &space_in_buf);
1895                errnum = errno;
1896                g_string_truncate (channel->write_buf, channel->write_buf->len
1897                                   - space_in_buf);
1898             }
1899
1900           if (err == (size_t) -1)
1901             {
1902               switch (errnum)
1903                 {
1904                   case EINVAL:
1905                     g_assert (left_len < 6);
1906
1907                     if (from_buf_old_len == 0)
1908                       {
1909                         /* Not from partial_write_buf */
1910
1911                         memcpy (channel->partial_write_buf, from_buf, left_len);
1912                         channel->partial_write_buf[left_len] = '\0';
1913                         return G_IO_STATUS_NORMAL;
1914                       }
1915
1916                     /* Working in partial_write_buf */
1917
1918                     if (left_len == from_buf_len)
1919                       {
1920                         /* Didn't convert anything, must still have
1921                          * less than a full character
1922                          */
1923
1924                         g_assert (count == from_buf_len - from_buf_old_len);
1925
1926                         channel->partial_write_buf[from_buf_len] = '\0';
1927
1928                         if (bytes_written)
1929                           *bytes_written = count;
1930
1931                         return G_IO_STATUS_NORMAL;
1932                       }
1933
1934                     g_assert (from_buf_len - left_len >= from_buf_old_len);
1935
1936                     /* We converted all the old data. This is fine */
1937
1938                     break;
1939                   case E2BIG:
1940                     if (from_buf_len == left_len)
1941                       {
1942                         /* Nothing was written, add enough space for
1943                          * at least one character.
1944                          */
1945                         space_in_buf += MAX_CHAR_SIZE;
1946                         goto reconvert;
1947                       }
1948                     break;
1949                   case EILSEQ:
1950                     g_set_error (error, G_CONVERT_ERROR,
1951                       G_CONVERT_ERROR_ILLEGAL_SEQUENCE,
1952                       _("Invalid byte sequence in conversion input"));
1953                     if (from_buf_old_len > 0 && from_buf_len == left_len)
1954                       g_warning ("Illegal sequence due to partial character "
1955                                  "at the end of a previous write.\n");
1956                     else
1957                       wrote_bytes += from_buf_len - left_len - from_buf_old_len;
1958                     if (bytes_written)
1959                       *bytes_written = wrote_bytes;
1960                     channel->partial_write_buf[0] = '\0';
1961                     return G_IO_STATUS_ERROR;
1962                   default:
1963                     g_set_error (error, G_CONVERT_ERROR, G_CONVERT_ERROR_FAILED,
1964                       _("Error during conversion: %s"), strerror (errno));
1965                     if (from_buf_len >= left_len + from_buf_old_len)
1966                       wrote_bytes += from_buf_len - left_len - from_buf_old_len;
1967                     if (bytes_written)
1968                       *bytes_written = wrote_bytes;
1969                     channel->partial_write_buf[0] = '\0';
1970                     return G_IO_STATUS_ERROR;
1971                 }
1972             }
1973
1974           g_assert (from_buf_len - left_len >= from_buf_old_len);
1975
1976           wrote_bytes += from_buf_len - left_len - from_buf_old_len;
1977
1978           if (from_buf_old_len > 0)
1979             {
1980               /* We were working in partial_write_buf */
1981
1982               buf += from_buf_len - left_len - from_buf_old_len;
1983               channel->partial_write_buf[0] = '\0';
1984             }
1985           else
1986             buf = from_buf;
1987         }
1988     }
1989
1990   if (bytes_written)
1991     *bytes_written = wrote_bytes;
1992
1993   return G_IO_STATUS_NORMAL;
1994 }
1995
1996
1997 /**
1998  * g_io_channel_error_quark:
1999  *
2000  * Return value: The quark used as %G_IO_CHANNEL_ERROR
2001  **/
2002 GQuark
2003 g_io_channel_error_quark (void)
2004 {
2005   static GQuark q = 0;
2006   if (q == 0)
2007     q = g_quark_from_static_string ("g-io-channel-error-quark");
2008
2009   return q;
2010 }