Use G_N_ELEMENTS rather than a custom macro.
[platform/upstream/glib.git] / 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 <string.h>
35 #include <errno.h>
36
37 #include "config.h"
38 #ifdef HAVE_UNISTD_H
39 #include <unistd.h>
40 #endif
41
42 #undef G_DISABLE_DEPRECATED
43
44 #include "glib.h"
45
46 #include "glibintl.h"
47
48 #define G_IO_NICE_BUF_SIZE      1024
49
50 static GIOError         g_io_error_get_from_g_error     (GIOStatus status,
51                                                          GError      *err);
52 static void             g_io_channel_purge              (GIOChannel  *channel);
53 static GIOStatus        g_io_channel_fill_buffer        (GIOChannel  *channel,
54                                                          GError     **err);
55
56 void
57 g_io_channel_init (GIOChannel *channel)
58 {
59   channel->channel_flags = 0;
60   channel->ref_count = 1;
61   channel->encoding = NULL;
62   channel->line_term = NULL;
63   channel->buf_size = G_IO_NICE_BUF_SIZE;
64   channel->read_buf = g_string_sized_new (G_IO_NICE_BUF_SIZE);
65   channel->encoded_read_buf = NULL; /* Allocate if we get an encoding */
66   channel->write_buf = g_string_sized_new (G_IO_NICE_BUF_SIZE);
67   channel->use_buffer = TRUE;
68   channel->do_encode = FALSE;
69   channel->ready_to_read = TRUE;
70   channel->ready_to_write = TRUE;
71   channel->close_on_unref = FALSE;
72   channel->seekable_cached = FALSE;
73 }
74
75 void 
76 g_io_channel_ref (GIOChannel *channel)
77 {
78   g_return_if_fail (channel != NULL);
79
80   channel->ref_count++;
81 }
82
83 void 
84 g_io_channel_unref (GIOChannel *channel)
85 {
86   g_return_if_fail (channel != NULL);
87
88   channel->ref_count--;
89   if (channel->ref_count == 0)
90     {
91       if (channel->close_on_unref)
92         g_io_channel_close (channel);
93       else
94         g_io_channel_purge (channel);
95       g_free (channel->encoding);
96       if (channel->do_encode)
97         {
98           g_iconv_close (channel->read_cd);
99           g_iconv_close (channel->write_cd);
100           g_string_free (channel->encoded_read_buf, TRUE);
101         }
102       g_free (channel->line_term);
103       g_string_free (channel->read_buf, TRUE);
104       g_string_free (channel->write_buf, TRUE);
105       channel->funcs->io_free (channel);
106     }
107 }
108
109 static GIOError
110 g_io_error_get_from_g_error (GIOStatus status,
111                              GError *err)
112 {
113   switch (status)
114     {
115       case G_IO_STATUS_NORMAL:
116       case G_IO_STATUS_EOF:
117         return G_IO_ERROR_NONE;
118       case G_IO_STATUS_AGAIN:
119         return G_IO_ERROR_AGAIN;
120       case G_IO_STATUS_ERROR:
121         if (err->domain != G_IO_CHANNEL_ERROR)
122           return G_IO_ERROR_UNKNOWN;
123         switch (err->code)
124           {
125             case G_IO_CHANNEL_ERROR_INVAL:
126               return G_IO_ERROR_INVAL;
127             default:
128               return G_IO_ERROR_UNKNOWN;
129           }
130       default:
131         g_assert_not_reached ();
132         return G_IO_ERROR_UNKNOWN; /* Keep the compiler happy */
133     }
134 }
135
136 /**
137  * g_io_channel_read:
138  * @channel: a #GIOChannel. 
139  * @buf: a buffer to read the data into (which should be at least count bytes long).
140  * @count: the number of bytes to read from the #GIOChannel.
141  * @bytes_read: returns the number of bytes actually read. 
142  * 
143  * Reads data from a #GIOChannel. This function is depricated. New code should
144  * use g_io_channel_read_chars() instead.
145  * 
146  * Return value: %G_IO_ERROR_NONE if the operation was successful. 
147  **/
148 GIOError 
149 g_io_channel_read (GIOChannel *channel, 
150                    gchar      *buf, 
151                    gsize       count,
152                    gsize      *bytes_read)
153 {
154   GError *err = NULL;
155   GIOError error;
156   GIOStatus status;
157
158   g_return_val_if_fail (channel != NULL, G_IO_ERROR_UNKNOWN);
159   g_return_val_if_fail (bytes_read != NULL, G_IO_ERROR_UNKNOWN);
160
161   status = channel->funcs->io_read (channel, buf, count, bytes_read, &err);
162
163   error = g_io_error_get_from_g_error (status, err);
164
165   if (err)
166     g_error_free (err);
167
168   return error;
169 }
170
171 /**
172  * g_io_channel_write:
173  * @channel:  a #GIOChannel.
174  * @buf: the buffer containing the data to write. 
175  * @count: the number of bytes to write.
176  * @bytes_written:  the number of bytes actually written.
177  * 
178  * Writes data to a #GIOChannel. This function is depricated. New code should
179  * use g_io_channel_write_chars() instead.
180  * 
181  * Return value:  %G_IO_ERROR_NONE if the operation was successful.
182  **/
183 GIOError 
184 g_io_channel_write (GIOChannel  *channel, 
185                     const gchar *buf, 
186                     gsize        count,
187                     gsize       *bytes_written)
188 {
189   GError *err = NULL;
190   GIOError error;
191   GIOStatus status;
192
193   g_return_val_if_fail (channel != NULL, G_IO_ERROR_UNKNOWN);
194   g_return_val_if_fail (bytes_written != NULL, G_IO_ERROR_UNKNOWN);
195
196   status = channel->funcs->io_write (channel, buf, count, bytes_written, &err);
197
198   error = g_io_error_get_from_g_error (status, err);
199
200   if (err)
201     g_error_free (err);
202
203   return error;
204 }
205
206 /**
207  * g_io_channel_seek:
208  * @channel: a #GIOChannel. 
209  * @offset: an offset, in bytes, which is added to the position specified by @type
210  * @type: the position in the file, which can be %G_SEEK_CUR (the current
211  *        position), %G_SEEK_SET (the start of the file), or %G_SEEK_END (the end of the
212  *        file).
213  * 
214  * Sets the current position in the #GIOChannel, similar to the standard library
215  * function fseek(). This function is depricated. New code should
216  * use g_io_channel_seek_position() instead.
217  * 
218  * Return value: %G_IO_ERROR_NONE if the operation was successful.
219  **/
220 GIOError 
221 g_io_channel_seek  (GIOChannel   *channel,
222                     glong         offset, 
223                     GSeekType     type)
224 {
225   GError *err = NULL;
226   GIOError error;
227   GIOStatus status;
228
229   g_return_val_if_fail (channel != NULL, G_IO_ERROR_UNKNOWN);
230
231   switch (type)
232     {
233       case G_SEEK_CUR:
234       case G_SEEK_SET:
235       case G_SEEK_END:
236         break;
237       default:
238         g_warning ("g_io_channel_seek: unknown seek type");
239         return G_IO_ERROR_UNKNOWN;
240     }
241
242   status = channel->funcs->io_seek (channel, offset, type, &err);
243
244   error = g_io_error_get_from_g_error (status, err);
245
246   if (err)
247     g_error_free (err);
248
249   return error;
250 }
251
252 /* The function g_io_channel_new_file() is prototyped in both
253  * giounix.c and giowin32.c, so we stick its documentation here.
254  */
255
256 /**
257  * g_io_channel_new_file:
258  * @filename: A string containing the name of a file.
259  * @mode: A #GIOFileMode
260  * @error: A location to return an error of type %G_IO_CHANNEL_ERROR.
261  *
262  * Open a file @filename as a #GIOChannel using mode @mode. This
263  * channel will be closed when the last reference to it is dropped,
264  * so there is no need to call g_io_channel_close() (though doing
265  * so will not cause problems, as long as no attempt is made to
266  * access the channel after it is closed).
267  *
268  * Return value: A #GIOChannel on success, %NULL on failure.
269  **/
270
271 /**
272  * g_io_channel_close:
273  * @channel: A #GIOChannel
274  * 
275  * Close an IO channel. Any pending data to be written will be
276  * flushed, ignoring errors. The channel will not be freed until the
277  * last reference is dropped using g_io_channel_unref(). This
278  * function is deprecated: you should use g_io_channel_shutdown()
279  * instead.
280  **/
281 void
282 g_io_channel_close (GIOChannel *channel)
283 {
284   GError *err = NULL;
285   
286   g_return_if_fail (channel != NULL);
287
288   g_io_channel_purge (channel);
289
290   channel->funcs->io_close (channel, &err);
291
292   if (err)
293     { /* No way to return the error */
294       g_warning ("Error closing channel: %s", err->message);
295       g_error_free (err);
296     }
297   
298   channel->close_on_unref = FALSE; /* Because we already did */
299   channel->ready_to_read = FALSE;
300   channel->ready_to_write = FALSE;
301 }
302
303 /**
304  * g_io_channel_shutdown:
305  * @channel: a #GIOChannel
306  * @flush: if %TRUE, flush pending
307  * @err: location to store a #GIOChannelError
308  * 
309  * Close an IO channel. Any pending data to be written will be
310  * flushed. The channel will not be freed until the
311  * last reference is dropped using g_io_channel_unref().
312  **/
313 GIOStatus
314 g_io_channel_shutdown (GIOChannel *channel,
315                        gboolean    flush,
316                        GError     **err)
317 {
318   GIOStatus status;
319   GIOStatus result = G_IO_STATUS_NORMAL;
320   
321   g_return_val_if_fail (channel != NULL, G_IO_STATUS_ERROR);
322
323   if (flush && channel->write_buf->len > 0)
324     {
325       GIOFlags flags;
326       
327       /* Set the channel to blocking, to avoid a busy loop
328        */
329       flags = g_io_channel_get_flags (channel);
330       status = g_io_channel_set_flags (channel, flags & ~G_IO_FLAG_NONBLOCK, NULL);
331       if (status != G_IO_STATUS_NORMAL)
332         result = G_IO_STATUS_ERROR; 
333       
334       g_io_channel_flush (channel, err);
335     }
336
337   status = channel->funcs->io_close (channel, err && *err ? NULL : err);
338   if (status != G_IO_STATUS_NORMAL)
339     result = G_IO_STATUS_ERROR; 
340
341   channel->close_on_unref = FALSE; /* Because we already did */
342   channel->ready_to_read = FALSE;
343   channel->ready_to_write = FALSE;
344
345   return result;
346 }
347
348 /* This function is used for the final flush on close or unref */
349 static void
350 g_io_channel_purge (GIOChannel *channel)
351 {
352   GError *err = NULL;
353
354   g_return_if_fail (channel != NULL);
355
356   if (channel->write_buf->len > 0)
357     {
358       GIOFlags flags;
359       
360       /* Set the channel to blocking, to avoid a busy loop
361        */
362       flags = g_io_channel_get_flags (channel);
363       g_io_channel_set_flags (channel, flags & ~G_IO_FLAG_NONBLOCK, NULL);
364
365       g_io_channel_flush (channel, &err);
366
367       if (err)
368         { /* No way to return the error */
369           g_warning ("Error flushing string: %s", err->message);
370           g_error_free (err);
371         }
372     }
373
374   /* Flush these in case anyone tries to close without unrefing */
375
376   g_string_truncate (channel->read_buf, 0);
377   if (channel->do_encode)
378     g_string_truncate (channel->encoded_read_buf, 0);
379   g_string_truncate (channel->write_buf, 0);
380 }
381
382 GSource *
383 g_io_create_watch (GIOChannel  *channel,
384                    GIOCondition condition)
385 {
386   g_return_val_if_fail (channel != NULL, NULL);
387
388   return channel->funcs->io_create_watch (channel, condition);
389 }
390
391 guint 
392 g_io_add_watch_full (GIOChannel    *channel,
393                      gint           priority,
394                      GIOCondition   condition,
395                      GIOFunc        func,
396                      gpointer       user_data,
397                      GDestroyNotify notify)
398 {
399   GSource *source;
400   guint id;
401   
402   g_return_val_if_fail (channel != NULL, 0);
403
404   source = g_io_create_watch (channel, condition);
405
406   if (priority != G_PRIORITY_DEFAULT)
407     g_source_set_priority (source, priority);
408   g_source_set_callback (source, (GSourceFunc)func, user_data, notify);
409
410   id = g_source_attach (source, NULL);
411   g_source_unref (source);
412
413   return id;
414 }
415
416 guint 
417 g_io_add_watch (GIOChannel    *channel,
418                 GIOCondition   condition,
419                 GIOFunc        func,
420                 gpointer       user_data)
421 {
422   return g_io_add_watch_full (channel, G_PRIORITY_DEFAULT, condition, func, user_data, NULL);
423 }
424
425 /**
426  * g_io_channel_get_buffer_condition:
427  * @channel: A #GIOChannel
428  *
429  * This function returns a #GIOCondition depending on the status of the
430  * internal buffers in the #GIOChannel. Only the flags %G_IO_IN and
431  * %G_IO_OUT may be set.
432  *
433  * Return value: A #GIOCondition
434  **/
435 GIOCondition
436 g_io_channel_get_buffer_condition (GIOChannel *channel)
437 {
438   return (((channel->read_buf->len > 0) || (channel->encoded_read_buf->len > 0))
439     ? G_IO_IN : 0) & ((channel->write_buf->len > 0) ? G_IO_OUT : 0);
440 }
441
442 /**
443  * g_channel_error_from_errno:
444  * @en: An errno error number, e.g. EINVAL
445  *
446  * Return value: A #GIOChannelError error number, e.g. %G_IO_CHANNEL_ERROR_INVAL
447  **/
448 GIOChannelError
449 g_channel_error_from_errno (gint en)
450 {
451 #ifdef EAGAIN
452   g_return_val_if_fail (en != EAGAIN, G_IO_CHANNEL_ERROR_FAILED);
453 #endif
454 #ifdef EINTR
455   g_return_val_if_fail (en != EINTR, G_IO_CHANNEL_ERROR_FAILED);
456 #endif
457
458   switch (en)
459     {
460 #ifdef EACCES
461     case EACCES:
462       return G_IO_CHANNEL_ERROR_ACCES;
463 #endif
464
465 #ifdef EBADF
466     case EBADF:
467       return G_IO_CHANNEL_ERROR_BADF;
468 #endif
469
470 #ifdef EFAULT
471     case EFAULT:
472       return G_IO_CHANNEL_ERROR_FAULT;
473 #endif
474
475 #ifdef EINVAL
476     case EINVAL:
477       return G_IO_CHANNEL_ERROR_INVAL;
478 #endif
479
480 #ifdef EIO
481     case EIO:
482       return G_IO_CHANNEL_ERROR_IO;
483 #endif
484
485 #ifdef EISDIR
486     case EISDIR:
487       return G_IO_CHANNEL_ERROR_ISDIR;
488 #endif
489
490 #ifdef EMFILE
491     case EMFILE:
492       return G_IO_CHANNEL_ERROR_MFILE;
493 #endif
494
495 #ifdef ENOLCK
496     case ENOLCK:
497       return G_IO_CHANNEL_ERROR_NOLCK;
498 #endif
499
500 #ifdef ENOSPC
501     case ENOSPC:
502       return G_IO_CHANNEL_ERROR_NOSPC;
503 #endif
504
505 #ifdef EPERM
506     case EPERM:
507       return G_IO_CHANNEL_ERROR_PERM;
508 #endif
509       
510 #ifdef EPIPE
511     case EPIPE:
512       return G_IO_CHANNEL_ERROR_PIPE;
513 #endif
514
515 #ifdef ESPIPE
516     case ESPIPE:
517       return G_IO_CHANNEL_ERROR_SPIPE;
518 #endif
519
520     default:
521       return G_IO_CHANNEL_ERROR_FAILED;
522     }
523 }
524
525 /**
526  * g_io_channel_set_buffer_size:
527  * @channel: a #GIOChannel
528  * @size: the size of the buffer. 0 == pick a good size
529  *
530  * Set the buffer size.
531  **/  
532 void
533 g_io_channel_set_buffer_size (GIOChannel        *channel,
534                               gsize              size)
535 {
536   g_return_if_fail (channel != NULL);
537
538   if (size == 0)
539     size = G_IO_NICE_BUF_SIZE;
540
541   channel->buf_size = size;
542 }
543
544 /**
545  * g_io_channel_get_buffer_size:
546  * @channel: a #GIOChannel
547  *
548  * Get the buffer size.
549  *
550  * Return value: the size of the buffer.
551  **/  
552 gsize
553 g_io_channel_get_buffer_size (GIOChannel        *channel)
554 {
555   g_return_val_if_fail (channel != NULL, 0);
556
557   return channel->buf_size;
558 }
559
560 /**
561  * g_io_channel_set_line_term:
562  * @channel: a #GIOChannel
563  * @line_term: The line termination string. Use %NULL for auto detect.
564  *
565  * This sets the string that #GIOChannel uses to determine
566  * where in the file a line break occurs.
567  **/
568 void
569 g_io_channel_set_line_term (GIOChannel  *channel,
570                             const gchar *line_term)
571 {
572   g_return_if_fail (channel != NULL);
573   g_return_if_fail (!line_term || line_term[0]); /* Disallow "" */
574
575   g_free (channel->line_term);
576   channel->line_term = g_strdup (line_term);
577 }
578
579 /**
580  * g_io_channel_get_line_term:
581  * @channel: a #GIOChannel
582  *
583  * This returns the string that #GIOChannel uses to determine
584  * where in the file a line break occurs. A value of %NULL
585  * indicates auto detection.
586  *
587  * Return value: The line termination string. This value
588  *   is owned by GLib and must not be freed.
589  **/
590 G_CONST_RETURN gchar*
591 g_io_channel_get_line_term (GIOChannel  *channel)
592 {
593   g_return_val_if_fail (channel != NULL, 0);
594
595   return channel->line_term;
596 }
597
598 /**
599  * g_io_channel_set_flags:
600  * @channel: a #GIOChannel
601  * @flags: the flags to set on the channel
602  * @error: A location to return an error of type #GIOChannelError
603  *
604  * Return value:
605  **/
606 GIOStatus
607 g_io_channel_set_flags (GIOChannel *channel,
608                         GIOFlags    flags,
609                         GError    **error)
610 {
611   g_return_val_if_fail (channel != NULL, G_IO_STATUS_ERROR);
612   g_return_val_if_fail ((error == NULL) || (*error == NULL),
613                         G_IO_STATUS_ERROR);
614
615   return (* channel->funcs->io_set_flags)(channel,
616                                           flags & G_IO_FLAG_SET_MASK,
617                                           error);
618 }
619
620 /**
621  * g_io_channel_get_flags:
622  * @channel: a #GIOChannel
623  * @flags: the flags which are set on the channel
624  *
625  * Gets the current flags for a #GIOChannel, including read-only
626  * flags such as %G_IO_FLAG_IS_READABLE.
627  **/
628 GIOFlags
629 g_io_channel_get_flags (GIOChannel *channel)
630 {
631   g_return_val_if_fail (channel != NULL, G_IO_STATUS_ERROR);
632
633   return (* channel->funcs->io_get_flags) (channel);
634 }
635
636 /**
637  * g_io_channel_seek_position:
638  * @channel: a #GIOChannel
639  * @offset: The offset in bytes from the position specified by @type
640  * @type: a #GSeekType. The type %G_SEEK_CUR is only allowed if
641  *        the channel has the default encoding or the
642  *        encoding %G_IO_CHANNEL_ENCODE_RAW for raw file access.
643  * @error: A location to return an error of type #GIOChannelError
644  *
645  * Replacement for g_io_channel_seek() with the new API.
646  *
647  * Return value:
648  **/
649 GIOStatus
650 g_io_channel_seek_position      (GIOChannel* channel,
651                                  glong       offset,
652                                  GSeekType   type,
653                                  GError    **error)
654 {
655   GIOStatus status;
656
657   /* For files, only one of the read and write buffers can contain data.
658    * For sockets, both can contain data.
659    */
660
661   g_return_val_if_fail (channel != NULL, G_IO_STATUS_ERROR);
662   g_return_val_if_fail ((error == NULL) || (*error == NULL),
663                         G_IO_STATUS_ERROR);
664
665   switch (type)
666     {
667       case G_SEEK_CUR: /* The user is seeking relative to the head of the buffer */
668         if (channel->do_encode)
669           {
670             g_warning ("Seek type G_SEEK_CUR not allowed for this channel's encoding.\n");
671             return G_IO_STATUS_ERROR;
672           }
673           break;
674       case G_SEEK_SET:
675       case G_SEEK_END:
676         break;
677       default:
678         g_warning ("g_io_channel_seek_position: unknown seek type");
679         return G_IO_STATUS_ERROR;
680     }
681
682   /* Do a quick check for easy failure
683    */
684   if (!channel->seekable_cached)
685     g_io_channel_get_flags (channel);
686
687   g_assert (channel->seekable_cached);
688
689   if (!channel->is_seekable)
690     {
691       g_set_error (error, G_IO_CHANNEL_ERROR, G_IO_CHANNEL_ERROR_SPIPE,
692         _("Seeking not allowed on this type of channel"));
693       return G_IO_STATUS_ERROR;
694     }
695
696   if (channel->use_buffer)
697     {
698       status = g_io_channel_flush (channel, error);
699       if (status != G_IO_STATUS_NORMAL)
700         return status;
701
702       if (type == G_SEEK_CUR)
703         {
704           g_assert (!channel->do_encode);
705           offset -= channel->read_buf->len;
706         }
707     }
708
709   status = channel->funcs->io_seek (channel, offset, type, error);
710
711   if ((status == G_IO_STATUS_NORMAL) && (channel->use_buffer))
712     {
713       g_string_erase (channel->read_buf, 0, channel->read_buf->len);
714       g_string_erase (channel->encoded_read_buf, 0, channel->read_buf->len);
715       channel->ready_to_write = TRUE;
716       if (channel->do_encode) /* Conversion state no longer matches position in file */
717         {
718           g_iconv (channel->read_cd, NULL, NULL, NULL, NULL);
719           g_iconv (channel->write_cd, NULL, NULL, NULL, NULL);
720         }
721     }
722
723   return status;
724 }
725
726 /**
727  * g_io_channel_flush:
728  * @channel: a #GIOChannel
729  * @error: location to store an error of type #GIOChannelError
730  *
731  * Flush the write buffer for the GIOChannel.
732  *
733  * Return value: the status of the operation: One of
734  *   G_IO_CHANNEL_NORMAL, G_IO_CHANNEL_AGAIN, or
735  *   G_IO_CHANNEL_ERROR.
736  **/
737 GIOStatus
738 g_io_channel_flush (GIOChannel  *channel,
739                     GError     **error)
740 {
741   GIOStatus status;
742   gsize this_time, bytes_written = 0;
743
744   g_return_val_if_fail (channel != NULL, G_IO_STATUS_ERROR);
745   g_return_val_if_fail ((error == NULL) || (*error == NULL), G_IO_STATUS_ERROR);
746
747   if (channel->write_buf->len == 0)
748     {
749       channel->ready_to_read = TRUE;
750       return G_IO_STATUS_NORMAL;
751     }
752
753   do
754     {
755       status = channel->funcs->io_write (channel,
756                                       channel->write_buf->str + bytes_written,
757                                       channel->write_buf->len - bytes_written,
758                                       &this_time, error);
759       bytes_written += this_time;
760     }
761   while ((bytes_written < channel->write_buf->len)
762          && (status == G_IO_STATUS_NORMAL)
763          && (this_time > 0)); /* Prevent an infinite loop */
764
765   g_string_erase (channel->write_buf, 0, bytes_written);
766
767   if (status != G_IO_STATUS_NORMAL)
768     return status;
769
770   if (channel->write_buf->len > 0)
771     return G_IO_STATUS_AGAIN;
772
773   channel->ready_to_read = TRUE;
774
775   return G_IO_STATUS_NORMAL;
776 }
777
778 /**
779  * g_io_channel_set_encoding:
780  * @channel: a #GIOChannel
781  * @encoding: the encoding type
782  * @error: location to store an error of type #GConvertError.
783  *
784  * Set the encoding for the input/output of the channel. The internal
785  * encoding is always UTF-8.
786  *
787  * The encoding %G_IO_CHANNEL_ENCODE_RAW disables encoding and turns
788  * off internal buffering. Data can be read from it only with
789  * g_io_channel_read_chars(). Both %G_IO_CHANNEL_ENCODE_RAW and
790  * the default state (no encoding, but buffered)
791  * are safe to use with binary data.
792  *
793  * Encodings
794  * other than the default and %G_IO_CHANNEL_ENCODE_RAW cannot
795 b * use g_io_channel_seek_position() with seek type %G_SEEK_CUR,
796  * and cannot mix reading and writing if the channel is
797  * a file without first doing a seek of type %G_SEEK_SET or
798  * %G_SEEK_END.
799  *
800  * The encoding can only be set under three conditions:
801  *
802  * 1. The channel was just created, and has not been written to
803  *    or read from yet.
804  *
805  * 2. The channel is a file, and the file pointer was just
806  *    repositioned by a call to g_io_channel_seek_position().
807  *    (This flushes all the internal buffers.)
808  *
809  * 3. The current encoding is %G_IO_CHANNEL_ENCODE_RAW.
810  *
811  * Return Value: %G_IO_STATUS_NORMAL if the encoding was succesfully set.
812  **/
813 GIOStatus
814 g_io_channel_set_encoding (GIOChannel   *channel,
815                            const gchar  *encoding,
816                            GError      **error)
817 {
818   GIConv read_cd, write_cd;
819   gboolean did_encode;
820
821   g_return_val_if_fail (channel != NULL, G_IO_STATUS_ERROR);
822   g_return_val_if_fail ((error == NULL) || (*error == NULL), G_IO_STATUS_ERROR);
823
824   /* Make sure the buffers are empty */
825
826   g_return_val_if_fail (channel->read_buf->len == 0, G_IO_STATUS_ERROR);
827   g_return_val_if_fail (channel->write_buf->len == 0, G_IO_STATUS_ERROR);
828   g_return_val_if_fail (channel->encoded_read_buf == NULL ||
829                         channel->encoded_read_buf->len == 0, G_IO_STATUS_ERROR);
830
831   did_encode = channel->do_encode;
832
833   if (!encoding || strcmp (encoding, "UTF8") == 0 || strcmp (encoding, "UTF-8") == 0)
834     {
835       channel->use_buffer = TRUE;
836       channel->do_encode = FALSE;
837       read_cd = write_cd = (GIConv) -1; /* keep the compiler happy */
838     }
839   else if (!strcmp (encoding, G_IO_CHANNEL_ENCODE_RAW))
840     {
841       channel->use_buffer = FALSE;
842       channel->do_encode = FALSE;
843       read_cd = write_cd = (GIConv) -1; /* keep the compiler happy */
844     }
845   else
846     {
847       gint err;
848       const gchar *from_enc, *to_enc;
849
850       read_cd = g_iconv_open ("UTF-8", encoding);
851
852       if (read_cd == (GIConv) -1)
853         {
854           err = errno;
855           from_enc = "UTF-8";
856           to_enc = encoding;
857           write_cd = (GIConv) -1; /* keep the compiler happy */
858         }
859       else
860         {
861           write_cd = g_iconv_open (encoding, "UTF-8");
862           if (write_cd == (GIConv) -1)
863             {
864               err = errno;
865               g_iconv_close (read_cd);
866               from_enc = encoding;
867               to_enc = "UTF-8";
868             }
869           else
870             {
871               err = 0;
872               from_enc = to_enc = NULL; /* Keep the compiler happy */
873             }
874         }
875
876       if (err)
877         {
878           /* Something went wrong.  */
879           if (err == EINVAL)
880             g_set_error (error, G_CONVERT_ERROR, G_CONVERT_ERROR_NO_CONVERSION,
881                          _("Conversion from character set `%s' to `%s' is not supported"),
882                          from_enc, to_enc);
883           else
884             g_set_error (error, G_CONVERT_ERROR, G_CONVERT_ERROR_FAILED,
885                          _("Could not open converter from `%s' to `%s': %s"),
886                          from_enc, to_enc, strerror (errno));
887           return G_IO_STATUS_ERROR;
888         }
889
890       channel->use_buffer = TRUE;
891       channel->do_encode = TRUE;
892       if (!did_encode)
893         channel->encoded_read_buf = g_string_sized_new (channel->buf_size);
894     }
895
896   /* The encoding is ok, so set the fields in channel */
897
898   if (did_encode)
899     {
900       g_iconv_close (channel->read_cd);
901       g_iconv_close (channel->write_cd);
902       if (!channel->do_encode)
903         {
904           g_string_free (channel->encoded_read_buf, TRUE);
905           channel->encoded_read_buf = NULL;
906         }
907     }
908
909   if (channel->do_encode)
910     {
911       channel->read_cd = read_cd;
912       channel->write_cd = write_cd;
913     }
914
915   g_free (channel->encoding);
916   channel->encoding = g_strdup (encoding);
917
918   return G_IO_STATUS_NORMAL;
919 }
920
921 /**
922  * g_io_channel_get_encoding:
923  * @channel: a #GIOChannel
924  *
925  * Get the encoding for the input/output of the channel. The internal
926  * encoding is always UTF-8. The encoding %G_IO_CHANNEL_ENCODE_RAW
927  * disables encoding and turns off internal buffering. Both
928  * %G_IO_CHANNEL_ENCODE_RAW and the default (no encoding, but buffered)
929  * are safe to use with binary data.
930  *
931  * Return value: A string containing the encoding, this string is
932  *   owned by GLib and must not be freed.
933  **/
934 G_CONST_RETURN gchar*
935 g_io_channel_get_encoding (GIOChannel      *channel)
936 {
937   g_return_val_if_fail (channel != NULL, NULL);
938
939   return channel->encoding;
940 }
941
942 static GIOStatus
943 g_io_channel_fill_buffer (GIOChannel *channel,
944                           GError    **err)
945 {
946   gsize read_size, cur_len, oldlen;
947   GIOStatus status;
948
949   if (!channel->ready_to_read)
950     {
951     status = g_io_channel_flush (channel, err);
952     if (status != G_IO_STATUS_NORMAL)
953       return status;
954     }
955   g_assert (channel->ready_to_read);
956
957   if (!channel->seekable_cached)
958     g_io_channel_get_flags (channel);
959
960   g_assert (channel->seekable_cached);
961
962   if (channel->is_seekable)
963     channel->ready_to_write = FALSE;
964
965   cur_len = channel->read_buf->len;
966
967   g_string_set_size (channel->read_buf, channel->read_buf->len + channel->buf_size);
968
969   status = channel->funcs->io_read (channel, channel->read_buf->str + cur_len,
970                                     channel->buf_size, &read_size, err);
971
972   g_assert ((status == G_IO_STATUS_NORMAL) || (read_size == 0));
973
974   g_string_truncate (channel->read_buf, read_size + cur_len);
975
976   if ((status != G_IO_STATUS_NORMAL)
977     && ((status != G_IO_STATUS_EOF) || (channel->read_buf->len == 0)))
978     return status;
979
980   g_assert (channel->read_buf->len > 0);
981
982   if (channel->do_encode)
983     {
984       size_t errnum, inbytes_left, outbytes_left;
985       gchar *inbuf, *outbuf;
986
987       oldlen = channel->encoded_read_buf->len;
988
989 reencode:
990
991       inbytes_left = channel->read_buf->len;
992       outbytes_left = channel->buf_size;
993
994       g_string_set_size (channel->encoded_read_buf, channel->encoded_read_buf->len + outbytes_left);
995
996       inbuf = channel->read_buf->str;
997       outbuf = channel->encoded_read_buf->str + channel->encoded_read_buf->len - outbytes_left;
998
999       errnum = g_iconv (channel->read_cd, &inbuf, &inbytes_left,
1000                         &outbuf, &outbytes_left);
1001
1002       g_string_erase (channel->read_buf, 0,
1003                       channel->read_buf->len - inbytes_left);
1004       g_string_truncate (channel->encoded_read_buf,
1005                          channel->encoded_read_buf->len - outbytes_left);
1006
1007       if (errnum == (size_t) -1)
1008         {
1009           switch (errno)
1010             {
1011               case EINVAL:
1012                 if ((oldlen == channel->encoded_read_buf->len)
1013                   && (status == G_IO_STATUS_EOF))
1014                   status = G_IO_STATUS_PARTIAL_CHARS;
1015                 else
1016                   status = G_IO_STATUS_NORMAL;
1017                 break;
1018               case E2BIG:
1019                 goto reencode;
1020               case EILSEQ:
1021                 if (oldlen < channel->encoded_read_buf->len)
1022                   status = G_IO_STATUS_NORMAL;
1023                 else
1024                   {
1025                     g_set_error (err, G_CONVERT_ERROR,
1026                       G_CONVERT_ERROR_ILLEGAL_SEQUENCE,
1027                       _("Invalid byte sequence in conversion input"));
1028                     return G_IO_STATUS_ERROR;
1029                   }
1030                 break;
1031               default:
1032                 g_set_error (err, G_CONVERT_ERROR, G_CONVERT_ERROR_FAILED,
1033                   _("Error during conversion: %s"), strerror (errno));
1034                 return G_IO_STATUS_ERROR;
1035             }
1036         }
1037       if (channel->encoded_read_buf->len == 0)
1038         {
1039           g_assert (status != G_IO_STATUS_NORMAL);
1040           return status;
1041         }
1042     }
1043
1044   return status;
1045 }
1046
1047 /**
1048  * g_io_channel_read_line:
1049  * @channel: a #GIOChannel
1050  * @str_return: The line read from the #GIOChannel, not including the
1051  *              line terminator. This data should be freed with g_free()
1052  *              when no longer needed. This
1053  *              is a null terminated string. If a @length of zero is
1054  *              returned, this will be %NULL instead.
1055  * @length: location to store length of the read data, or %NULL
1056  * @terminator_pos: location to store position of line terminator, or %NULL
1057  * @error: A location to return an error of type #GConvertError
1058  *         or #GIOChannelError
1059  *
1060  * Read a line, not including the terminating character(s),
1061  * from a #GIOChannel into a newly allocated string.
1062  * @length will contain allocated memory if the return
1063  * is %G_IO_STATUS_NORMAL.
1064  *
1065  * Return value: a newly allocated string. Free this string
1066  *   with g_free() when you are done with it.
1067  **/
1068 GIOStatus
1069 g_io_channel_read_line (GIOChannel *channel,
1070                         gchar     **str_return,
1071                         gsize      *length,
1072                         gsize      *terminator_pos,
1073                         GError    **error)
1074 {
1075   GIOStatus status;
1076   GString *string;
1077   
1078   g_return_val_if_fail (channel != NULL, G_IO_STATUS_ERROR);
1079   g_return_val_if_fail (str_return != NULL, G_IO_STATUS_ERROR);
1080   g_return_val_if_fail ((error == NULL) || (*error == NULL),
1081                         G_IO_STATUS_ERROR);
1082
1083   string = g_string_sized_new (channel->buf_size);
1084
1085   status = g_io_channel_read_line_string (channel, string, terminator_pos, error);
1086
1087   if (length)
1088     *length = string->len;
1089
1090   if (str_return)
1091     *str_return = g_string_free (string, FALSE);
1092   else
1093     g_string_free (string, TRUE);
1094   
1095   return status;
1096 }
1097
1098 /**
1099  * g_io_channel_read_line_string:
1100  * @channel: a #GIOChannel
1101  * @buffer: a #GString into which the line will be written.
1102  *          If @buffer already contains data, the new data will
1103  *          be appended to it.
1104  * @terminator_pos: location to store position of line terminator, or %NULL
1105  * @error: a location to store an error of type #GConvertError
1106  *         or #GIOChannelError
1107  *
1108  * Read a line from a #GIOChannel, using a #GString as a buffer.
1109  *
1110  * Return value:
1111  **/
1112 GIOStatus
1113 g_io_channel_read_line_string (GIOChannel *channel,
1114                                GString    *buffer,
1115                                gsize      *terminator_pos,
1116                                GError    **error)
1117 {
1118   GIOStatus status;
1119   gsize checked_to, line_term_len, line_length;
1120   GString *use_buf;
1121   gboolean first_time = TRUE;
1122
1123   g_return_val_if_fail (channel != NULL, G_IO_STATUS_ERROR);
1124   g_return_val_if_fail (buffer != NULL, G_IO_STATUS_ERROR);
1125   g_return_val_if_fail ((error == NULL) || (*error == NULL),
1126                         G_IO_STATUS_ERROR);
1127   
1128   if (!channel->use_buffer)
1129     {
1130       /* Can't do a raw read in read_line */
1131       g_set_error (error, G_CONVERT_ERROR, G_CONVERT_ERROR_FAILED,
1132                    _("Can't do a raw read in g_io_channel_read_line_string"));
1133       return G_IO_STATUS_ERROR;
1134     }
1135
1136   if (!channel->ready_to_read)
1137     {
1138       status = g_io_channel_flush (channel, error);
1139       if (status != G_IO_STATUS_NORMAL)
1140         return status;
1141     }
1142   g_assert (channel->ready_to_read);
1143
1144   if (channel->do_encode)
1145     use_buf = channel->encoded_read_buf;
1146   else
1147     use_buf = channel->read_buf;
1148
1149   status = G_IO_STATUS_NORMAL;
1150
1151   if (channel->line_term)
1152     line_term_len = strlen (channel->line_term);
1153   else
1154     line_term_len = 2;
1155
1156   checked_to = 0;
1157
1158   while (TRUE)
1159     {
1160       if (!first_time || (use_buf->len == 0))
1161         {
1162           status = g_io_channel_fill_buffer (channel, error);
1163           switch (status)
1164             {
1165               case G_IO_STATUS_NORMAL:
1166                 g_assert (use_buf->len > 0);
1167                 break;
1168               case G_IO_STATUS_EOF:
1169               case G_IO_STATUS_PARTIAL_CHARS:
1170                 if (use_buf->len == 0)
1171                   return status;
1172                 break;
1173               default:
1174                 return status;
1175             }
1176         }
1177
1178       g_assert (use_buf->len > 0);
1179
1180       first_time = FALSE;
1181
1182       if (channel->line_term)
1183         {
1184           gchar *line_end = strstr (use_buf->str + checked_to, channel->line_term);
1185           if (line_end)
1186             {
1187               line_length = line_end - use_buf->str;
1188               break;
1189             }
1190         }
1191       else /* auto detect */
1192         {
1193           gchar *newline_pos, *linefeed_pos;
1194
1195           newline_pos = strchr (use_buf->str + checked_to, '\n');
1196           linefeed_pos = strchr (use_buf->str + checked_to, '\r');
1197
1198           g_assert (!newline_pos || !linefeed_pos || (newline_pos != linefeed_pos));
1199
1200           if (newline_pos && (!linefeed_pos || (linefeed_pos > newline_pos))) /* unix */
1201             {
1202               line_length = newline_pos - use_buf->str;
1203               line_term_len = 1;
1204               break;
1205             }
1206           else if (linefeed_pos &&
1207                    (linefeed_pos < use_buf->str + use_buf->len - 1 ||
1208                     status == G_IO_STATUS_EOF))
1209             {
1210               line_length = linefeed_pos - use_buf->str;
1211               if (newline_pos && (newline_pos == linefeed_pos + 1)) /* dos */
1212                 line_term_len = 2;
1213               else /* mac */
1214                 line_term_len = 1;
1215               break;
1216             }
1217         }
1218
1219       /* Also terminate on '\0' */
1220
1221       line_length = strlen (use_buf->str);
1222       if (line_length < use_buf->len)
1223         {
1224           line_term_len = 0;
1225           break;
1226         }
1227
1228       /* Check for EOF */
1229
1230       if (status != G_IO_STATUS_NORMAL)
1231         {
1232           line_length = use_buf->len;
1233           line_term_len = 0;
1234           break;
1235         }
1236
1237       if (use_buf->len > line_term_len - 1)
1238         checked_to = use_buf->len - (line_term_len - 1);
1239       else
1240         checked_to = 0;
1241     }
1242
1243   g_string_append_len (buffer, use_buf->str, line_length + line_term_len);
1244   g_string_erase (use_buf, 0, line_length + line_term_len);
1245
1246   if (terminator_pos)
1247     *terminator_pos = line_length;
1248
1249   return G_IO_STATUS_NORMAL;
1250 }
1251
1252 /**
1253  * g_io_channel_read_to_end:
1254  * @channel: a #GIOChannel
1255  * @str_return: Location to store a pointer to a string holding
1256  *              the remaining data in the #GIOChannel. This data should
1257  *              be freed with g_free() when no longer needed. This
1258  *              data is terminated by an extra null, but there may be other
1259  *              nulls in the intervening data.
1260  * @length: Location to store length of the data
1261  * @error: A location to return an error of type #GConvertError
1262  *         or #GIOChannelError
1263  *
1264  * Read all the remaining data from the file. Parameters as
1265  * for g_io_channel_read_line.
1266  *
1267  * Return value: One of #G_IO_STATUS_EOF or #G_IO_STATUS_PARTIAL_CHARS
1268  *               on success
1269  **/
1270 GIOStatus
1271 g_io_channel_read_to_end (GIOChannel    *channel,
1272                           gchar        **str_return,
1273                           gsize         *length,
1274                           GError       **error)
1275 {
1276   GIOStatus status;
1277   GString **use_buf;
1278     
1279   g_return_val_if_fail (channel != NULL, G_IO_STATUS_ERROR);
1280   g_return_val_if_fail (str_return != NULL, G_IO_STATUS_ERROR);
1281   g_return_val_if_fail (length != NULL, G_IO_STATUS_ERROR);
1282   g_return_val_if_fail ((error == NULL) || (*error == NULL),
1283     G_IO_STATUS_ERROR);
1284
1285   *str_return = NULL;
1286   *length = 0;
1287
1288   if (!channel->use_buffer)
1289     {
1290       g_set_error (error, G_CONVERT_ERROR, G_CONVERT_ERROR_FAILED,
1291                    _("Can't do a raw read in g_io_channel_read_to_end"));
1292       return G_IO_STATUS_ERROR;
1293     }
1294
1295   do
1296     status = g_io_channel_fill_buffer (channel, error);
1297   while (status == G_IO_STATUS_NORMAL);
1298
1299   if ((status != G_IO_STATUS_EOF)
1300     && (status != G_IO_STATUS_PARTIAL_CHARS))
1301     return status;
1302
1303   if (channel->do_encode)
1304     use_buf = &channel->encoded_read_buf;
1305   else
1306     use_buf = &channel->read_buf;
1307
1308   if (length)
1309     *length = (*use_buf)->len;
1310
1311   if (str_return)
1312     *str_return = g_string_free (*use_buf, FALSE);
1313   else
1314     g_string_free (*use_buf, TRUE);
1315   
1316   *use_buf = g_string_sized_new (channel->buf_size);
1317
1318   return status;
1319 }
1320
1321 /**
1322  * g_io_channel_read_chars:
1323  * @channel: a #GIOChannel
1324  * @buf: a buffer to read data into
1325  * @count: the size of the buffer. Note that the buffer may
1326  *         not be complelely filled even if there is data
1327  *         in the buffer if the remaining data is not a
1328  *         complete character.
1329  * @bytes_read: The number of bytes read.
1330  * @error: A location to return an error of type #GConvertError
1331  *         or #GIOChannelError.
1332  *
1333  * Replacement for g_io_channel_read() with the new API.
1334  *
1335  * Return value:
1336  **/
1337 GIOStatus
1338 g_io_channel_read_chars (GIOChannel     *channel,
1339                          gchar          *buf,
1340                          gsize           count,
1341                          gsize          *bytes_read,
1342                          GError        **error)
1343 {
1344   GIOStatus status;
1345   GString *use_buf;
1346
1347   g_return_val_if_fail (channel != NULL, G_IO_STATUS_ERROR);
1348   g_return_val_if_fail ((error == NULL) || (*error == NULL),
1349                         G_IO_STATUS_ERROR);
1350   g_return_val_if_fail (bytes_read != NULL, G_IO_STATUS_ERROR);
1351
1352   if (count == 0)
1353     {
1354       *bytes_read = 0;
1355       return G_IO_STATUS_NORMAL;
1356     }
1357   g_return_val_if_fail (buf != NULL, G_IO_STATUS_ERROR);
1358
1359   if (!channel->use_buffer)
1360     {
1361       g_assert (channel->ready_to_read);
1362       g_assert (channel->read_buf->len == 0);
1363
1364       return channel->funcs->io_read (channel, buf, count, bytes_read, error);
1365     }
1366
1367   if (!channel->ready_to_read)
1368     {
1369       status = g_io_channel_flush (channel, error);
1370       if (status != G_IO_STATUS_NORMAL)
1371         return status;
1372     }
1373   g_assert (channel->ready_to_read);
1374
1375   if (channel->do_encode)
1376     use_buf = channel->encoded_read_buf;
1377   else
1378     use_buf = channel->read_buf;
1379
1380   status = G_IO_STATUS_NORMAL;
1381
1382   while (use_buf->len < count && status == G_IO_STATUS_NORMAL)
1383     {
1384       status = g_io_channel_fill_buffer (channel, error);
1385     }
1386
1387   switch (status)
1388     {
1389     case G_IO_STATUS_NORMAL:
1390       g_assert (use_buf->len > 0);
1391       break;
1392     case G_IO_STATUS_EOF:
1393     case G_IO_STATUS_PARTIAL_CHARS:
1394       if (use_buf->len == 0)
1395         {
1396           *bytes_read = 0;
1397           return status;
1398         }
1399       break;
1400     default:
1401       *bytes_read = 0;
1402       return status;
1403     }
1404
1405   *bytes_read = MIN (count, use_buf->len);
1406   memcpy (buf, use_buf->str, *bytes_read);
1407   g_string_erase (use_buf, 0, *bytes_read);
1408
1409   return G_IO_STATUS_NORMAL;
1410 }
1411
1412 /**
1413  * g_io_channel_write_chars:
1414  * @channel: a #GIOChannel
1415  * @buf: a buffer to write data from
1416  * @count: the size of the buffer. If -1, the buffer
1417  *         is taken to be a nul terminated string.
1418  * @bytes_written: The number of bytes written.
1419  * @error: A location to return an error of type #GConvertError
1420  *         or #GIOChannelError
1421  *
1422  * Replacement for g_io_channel_write() with the new API.
1423  *
1424  * Return value: a return value of %G_IO_STATUS_PARTIAL_CHARS
1425  *               indicates that @buf contains less than one
1426  *               complete UTF-8 character.
1427  **/
1428 GIOStatus
1429 g_io_channel_write_chars (GIOChannel    *channel,
1430                           const gchar   *buf,
1431                           gssize         count,
1432                           gsize         *bytes_written,
1433                           GError       **error)
1434 {
1435   GIOStatus status;
1436
1437   g_return_val_if_fail (channel != NULL, G_IO_STATUS_ERROR);
1438   g_return_val_if_fail (bytes_written != NULL, G_IO_STATUS_ERROR);
1439   g_return_val_if_fail ((error == NULL) || (*error == NULL),
1440                         G_IO_STATUS_ERROR);
1441
1442   if (count < 0)
1443     count = strlen (buf);
1444   
1445   if (count == 0)
1446     return G_IO_STATUS_NORMAL;
1447
1448   g_return_val_if_fail (buf != NULL, G_IO_STATUS_ERROR);
1449   g_return_val_if_fail (count > 0, G_IO_STATUS_ERROR);
1450
1451   /* Raw write case */
1452
1453   if (!channel->use_buffer)
1454     {
1455       g_assert (channel->write_buf->len == 0);
1456       return channel->funcs->io_write (channel, buf, count, bytes_written, error);
1457     }
1458
1459   /* General case */
1460
1461   if (channel->write_buf->len == 0)
1462     {
1463       /* Check to make sure the channel's writeable before we stick
1464        * the first data in the buffer.
1465        */
1466       GIOFlags flags = g_io_channel_get_flags (channel);
1467
1468       if (!(flags & G_IO_FLAG_IS_WRITEABLE))
1469         {
1470           /* Mimic a failure of channel->funcs->io_write */
1471           g_set_error (error, G_IO_CHANNEL_ERROR, G_IO_CHANNEL_ERROR_BADF,
1472                        _("Channel is not writeable"));
1473           return G_IO_STATUS_ERROR;
1474         }
1475     }
1476   g_assert (channel->seekable_cached);
1477
1478   if (!channel->ready_to_write)
1479     {
1480       if (channel->is_seekable)
1481         {
1482           if (channel->do_encode)
1483             {
1484               g_set_error (error, G_IO_CHANNEL_ERROR, G_IO_CHANNEL_ERROR_ENCODE_RW,
1485                            _("Mixed reading and writing not allowed on encoded files"));
1486               return G_IO_STATUS_ERROR;
1487             }
1488           status = g_io_channel_seek_position (channel, 0, G_SEEK_CUR, error);
1489           if (status != G_IO_STATUS_NORMAL)
1490             return status;
1491         }
1492       channel->ready_to_write = TRUE;
1493     }
1494
1495   if (channel->is_seekable)
1496     channel->ready_to_read = FALSE;
1497
1498   if (!channel->do_encode)
1499     {
1500       g_string_append_len (channel->write_buf, buf, count);
1501       *bytes_written = count;
1502     }
1503   else
1504     {
1505       gsize bytes_to_go = count, buf_space, err;
1506       gchar *outbuf;
1507       gsize oldlen = channel->write_buf->len;
1508
1509       do
1510         {
1511           g_string_set_size (channel->write_buf, channel->write_buf->len + channel->buf_size);
1512           buf_space = channel->buf_size;
1513           outbuf = channel->write_buf->str + channel->write_buf->len - buf_space;
1514     
1515           err = g_iconv (channel->write_cd, (gchar**) &buf, &bytes_to_go,
1516                          &outbuf, &buf_space);
1517
1518           g_string_truncate (channel->write_buf, channel->write_buf->len - buf_space);
1519           *bytes_written = count - bytes_to_go;
1520
1521           if (err == (size_t) -1)
1522             {
1523               switch (errno)
1524                 {
1525                   case EINVAL:
1526                     if (*bytes_written > 0)
1527                       return G_IO_STATUS_NORMAL;
1528                     else
1529                       return G_IO_STATUS_PARTIAL_CHARS;
1530                   case E2BIG:
1531                     break;
1532                   case EILSEQ:
1533                     if (*bytes_written > 0)
1534                       return G_IO_STATUS_NORMAL;
1535                     else
1536                       {
1537                         g_set_error (error, G_CONVERT_ERROR,
1538                          G_CONVERT_ERROR_ILLEGAL_SEQUENCE,
1539                           _("Invalid byte sequence in conversion input"));
1540                         return G_IO_STATUS_ERROR;
1541                       }
1542                   default:
1543                     g_set_error (error, G_CONVERT_ERROR, G_CONVERT_ERROR_FAILED,
1544                       _("Error during conversion: %s"), strerror (errno));
1545                     g_string_truncate (channel->write_buf, oldlen);
1546                     *bytes_written = 0;
1547                     return G_IO_STATUS_ERROR;
1548                 }
1549             }
1550         }
1551       while (bytes_to_go > 0);
1552     }
1553
1554   if (channel->write_buf->len > channel->buf_size)
1555     return g_io_channel_flush (channel, error);
1556   else
1557     return G_IO_STATUS_NORMAL;
1558 }
1559
1560 /**
1561  * g_channel_error_quark:
1562  *
1563  * Return value: The quark used as %G_IO_CHANNEL_ERROR
1564  **/
1565 GQuark
1566 g_channel_error_quark (void)
1567 {
1568   static GQuark q = 0;
1569   if (q == 0)
1570     q = g_quark_from_static_string ("g-channel-error-quark");
1571
1572   return q;
1573 }