giochannel.c 66.9 KB
Newer Older
1
2
3
4
5
6
7
/* GLIB - Library of useful routines for C programming
 * Copyright (C) 1995-1997  Peter Mattis, Spencer Kimball and Josh MacDonald
 *
 * giochannel.c: IO Channel abstraction
 * Copyright 1998 Owen Taylor
 *
 * This library is free software; you can redistribute it and/or
8
 * modify it under the terms of the GNU Lesser General Public
9
10
11
12
13
14
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	 See the GNU
15
 * Lesser General Public License for more details.
16
 *
17
 * You should have received a copy of the GNU Lesser General Public
18
19
20
21
22
 * License along with this library; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
 */

23
/*
24
 * Modified by the GLib Team and others 1997-2000.  See the AUTHORS
25
26
27
28
29
 * file for a list of people on the GLib Team.  See the ChangeLog
 * files for a list of changes.  These files are distributed with
 * GLib at ftp://ftp.gtk.org/pub/gtk/. 
 */

30
31
32
33
/* 
 * MT safe
 */

34
35
#include "config.h"

36
37
#include <string.h>
#include <errno.h>
38
39

#ifdef HAVE_UNISTD_H
40
#include <unistd.h>
41
#endif
42

43
44
45
46
#undef G_DISABLE_DEPRECATED

#include "glib.h"

47
48
#include "giochannel.h"

49
50
51
52
#include "glibintl.h"

#define G_IO_NICE_BUF_SIZE	1024

53
54
55
56
57
58
59
60
61
62
63
/* This needs to be as wide as the largest character in any possible encoding */
#define MAX_CHAR_SIZE		10

/* Some simplifying macros, which reduce the need to worry whether the
 * buffers have been allocated. These also make USE_BUF () an lvalue,
 * which is used in g_io_channel_read_to_end ().
 */
#define USE_BUF(channel)	((channel)->encoding ? (channel)->encoded_read_buf \
				 : (channel)->read_buf)
#define BUF_LEN(string)		((string) ? (string)->len : 0)

64
static GIOError		g_io_error_get_from_g_error	(GIOStatus    status,
65
66
67
68
							 GError      *err);
static void		g_io_channel_purge		(GIOChannel  *channel);
static GIOStatus	g_io_channel_fill_buffer	(GIOChannel  *channel,
							 GError     **err);
69
70
71
72
static GIOStatus	g_io_channel_read_line_backend	(GIOChannel  *channel,
							 gsize       *length,
							 gsize       *terminator_pos,
							 GError     **error);
73

74
75
void
g_io_channel_init (GIOChannel *channel)
76
{
77
  channel->ref_count = 1;
78
  channel->encoding = g_strdup ("UTF-8");
79
  channel->line_term = NULL;
80
  channel->line_term_len = 0;
81
  channel->buf_size = G_IO_NICE_BUF_SIZE;
82
83
84
85
86
87
  channel->read_cd = (GIConv) -1;
  channel->write_cd = (GIConv) -1;
  channel->read_buf = NULL; /* Lazy allocate buffers */
  channel->encoded_read_buf = NULL;
  channel->write_buf = NULL;
  channel->partial_write_buf[0] = '\0';
88
89
90
  channel->use_buffer = TRUE;
  channel->do_encode = FALSE;
  channel->close_on_unref = FALSE;
91
92
93
94
95
96
97
}

void 
g_io_channel_ref (GIOChannel *channel)
{
  g_return_if_fail (channel != NULL);

98
  channel->ref_count++;
99
100
101
102
103
104
105
}

void 
g_io_channel_unref (GIOChannel *channel)
{
  g_return_if_fail (channel != NULL);

106
107
  channel->ref_count--;
  if (channel->ref_count == 0)
108
109
    {
      if (channel->close_on_unref)
110
        g_io_channel_shutdown (channel, TRUE, NULL);
111
112
113
      else
        g_io_channel_purge (channel);
      g_free (channel->encoding);
114
115
116
117
      if (channel->read_cd != (GIConv) -1)
        g_iconv_close (channel->read_cd);
      if (channel->write_cd != (GIConv) -1)
        g_iconv_close (channel->write_cd);
118
119
      if (channel->line_term)
        g_free (channel->line_term);
120
121
122
123
124
125
      if (channel->read_buf)
        g_string_free (channel->read_buf, TRUE);
      if (channel->write_buf)
        g_string_free (channel->write_buf, TRUE);
      if (channel->encoded_read_buf)
        g_string_free (channel->encoded_read_buf, TRUE);
126
127
      channel->funcs->io_free (channel);
    }
128
129
}

130
131
132
133
static GIOError
g_io_error_get_from_g_error (GIOStatus status,
			     GError *err)
{
134
135
  g_return_val_if_fail (err != NULL, G_ERROR_ERROR_UNKNOWN);
	
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
  switch (status)
    {
      case G_IO_STATUS_NORMAL:
      case G_IO_STATUS_EOF:
        return G_IO_ERROR_NONE;
      case G_IO_STATUS_AGAIN:
        return G_IO_ERROR_AGAIN;
      case G_IO_STATUS_ERROR:
        if (err->domain != G_IO_CHANNEL_ERROR)
          return G_IO_ERROR_UNKNOWN;
        switch (err->code)
          {
            case G_IO_CHANNEL_ERROR_INVAL:
              return G_IO_ERROR_INVAL;
            default:
              return G_IO_ERROR_UNKNOWN;
          }
      default:
        g_assert_not_reached ();
        return G_IO_ERROR_UNKNOWN; /* Keep the compiler happy */
    }
}

/**
 * g_io_channel_read:
 * @channel: a #GIOChannel. 
 * @buf: a buffer to read the data into (which should be at least count bytes long).
 * @count: the number of bytes to read from the #GIOChannel.
 * @bytes_read: returns the number of bytes actually read. 
 * 
166
 * Reads data from a #GIOChannel. 
167
168
 * 
 * Return value: %G_IO_ERROR_NONE if the operation was successful. 
169
170
 *
 * Deprecated: Use g_io_channel_read_chars() instead.
171
 **/
172
173
174
GIOError 
g_io_channel_read (GIOChannel *channel, 
		   gchar      *buf, 
175
176
		   gsize       count,
		   gsize      *bytes_read)
177
{
178
179
180
181
  GError *err = NULL;
  GIOError error;
  GIOStatus status;

182
  g_return_val_if_fail (channel != NULL, G_IO_ERROR_UNKNOWN);
183
184
  g_return_val_if_fail (bytes_read != NULL, G_IO_ERROR_UNKNOWN);

185
186
187
188
189
190
191
192
193
  if (count == 0)
    {
      if (bytes_read)
        *bytes_read = 0;
      return G_IO_STATUS_NORMAL;
    }

  g_return_val_if_fail (buf != NULL, G_IO_ERROR_UNKNOWN);

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

196
197
198
199
200
201
  error = g_io_error_get_from_g_error (status, err);

  if (err)
    g_error_free (err);

  return error;
202
203
}

204
205
206
207
208
209
210
/**
 * g_io_channel_write:
 * @channel:  a #GIOChannel.
 * @buf: the buffer containing the data to write. 
 * @count: the number of bytes to write.
 * @bytes_written:  the number of bytes actually written.
 * 
211
 * Writes data to a #GIOChannel. 
212
213
 * 
 * Return value:  %G_IO_ERROR_NONE if the operation was successful.
214
215
 *
 * Deprecated: Use g_io_channel_write_chars() instead.
216
 **/
217
GIOError 
218
219
220
221
g_io_channel_write (GIOChannel  *channel, 
		    const gchar *buf, 
		    gsize        count,
		    gsize       *bytes_written)
222
{
223
224
225
226
  GError *err = NULL;
  GIOError error;
  GIOStatus status;

227
  g_return_val_if_fail (channel != NULL, G_IO_ERROR_UNKNOWN);
228
229
230
231
232
  g_return_val_if_fail (bytes_written != NULL, G_IO_ERROR_UNKNOWN);

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

  error = g_io_error_get_from_g_error (status, err);
233

234
235
236
237
  if (err)
    g_error_free (err);

  return error;
238
239
}

240
241
242
243
244
245
246
247
248
/**
 * g_io_channel_seek:
 * @channel: a #GIOChannel. 
 * @offset: an offset, in bytes, which is added to the position specified by @type
 * @type: the position in the file, which can be %G_SEEK_CUR (the current
 *        position), %G_SEEK_SET (the start of the file), or %G_SEEK_END (the end of the
 *        file).
 * 
 * Sets the current position in the #GIOChannel, similar to the standard library
249
 * function <function>fseek()</function>. 
250
251
 * 
 * Return value: %G_IO_ERROR_NONE if the operation was successful.
252
253
 *
 * Deprecated: Use g_io_channel_seek_position() instead.
254
 **/
255
256
GIOError 
g_io_channel_seek  (GIOChannel   *channel,
Owen Taylor's avatar
Owen Taylor committed
257
		    gint64        offset, 
258
		    GSeekType     type)
259
{
260
261
262
263
  GError *err = NULL;
  GIOError error;
  GIOStatus status;

264
  g_return_val_if_fail (channel != NULL, G_IO_ERROR_UNKNOWN);
265
  g_return_val_if_fail (channel->is_seekable, G_IO_ERROR_UNKNOWN);
266

267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
  switch (type)
    {
      case G_SEEK_CUR:
      case G_SEEK_SET:
      case G_SEEK_END:
        break;
      default:
        g_warning ("g_io_channel_seek: unknown seek type");
        return G_IO_ERROR_UNKNOWN;
    }

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

  error = g_io_error_get_from_g_error (status, err);

  if (err)
    g_error_free (err);

  return error;
286
}
287
288
289
290
291
292
293
294

/* The function g_io_channel_new_file() is prototyped in both
 * giounix.c and giowin32.c, so we stick its documentation here.
 */

/**
 * g_io_channel_new_file:
 * @filename: A string containing the name of a file.
295
 * @mode: One of "r", "w", "a", "r+", "w+", "a+". These have
Matthias Clasen's avatar
Matthias Clasen committed
296
 *        the same meaning as in <function>fopen()</function>.
297
 * @error: A location to return an error of type %G_FILE_ERROR.
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
 *
 * Open a file @filename as a #GIOChannel using mode @mode. This
 * channel will be closed when the last reference to it is dropped,
 * so there is no need to call g_io_channel_close() (though doing
 * so will not cause problems, as long as no attempt is made to
 * access the channel after it is closed).
 *
 * Return value: A #GIOChannel on success, %NULL on failure.
 **/

/**
 * g_io_channel_close:
 * @channel: A #GIOChannel
 * 
 * Close an IO channel. Any pending data to be written will be
 * flushed, ignoring errors. The channel will not be freed until the
314
315
316
 * last reference is dropped using g_io_channel_unref(). 
 *
 * Deprecated: Use g_io_channel_shutdown() instead.
317
 **/
318
319
320
void
g_io_channel_close (GIOChannel *channel)
{
321
322
  GError *err = NULL;
  
323
324
  g_return_if_fail (channel != NULL);

325
326
327
328
329
330
331
332
333
334
335
  g_io_channel_purge (channel);

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

  if (err)
    { /* No way to return the error */
      g_warning ("Error closing channel: %s", err->message);
      g_error_free (err);
    }
  
  channel->close_on_unref = FALSE; /* Because we already did */
336
337
338
  channel->is_readable = FALSE;
  channel->is_writeable = FALSE;
  channel->is_seekable = FALSE;
339
340
341
342
343
344
345
346
347
}

/**
 * g_io_channel_shutdown:
 * @channel: a #GIOChannel
 * @flush: if %TRUE, flush pending
 * @err: location to store a #GIOChannelError
 * 
 * Close an IO channel. Any pending data to be written will be
348
 * flushed if @flush is %TRUE. The channel will not be freed until the
349
 * last reference is dropped using g_io_channel_unref().
350
 *
351
 * Return value: the status of the operation.
352
353
354
355
 **/
GIOStatus
g_io_channel_shutdown (GIOChannel *channel,
		       gboolean    flush,
356
		       GError    **err)
357
{
358
359
  GIOStatus status, result;
  GError *tmperr = NULL;
360
361
  
  g_return_val_if_fail (channel != NULL, G_IO_STATUS_ERROR);
362
  g_return_val_if_fail (err == NULL || *err == NULL, G_IO_STATUS_ERROR);
363

364
  if (channel->write_buf && channel->write_buf->len > 0)
365
    {
366
367
368
      if (flush)
        {
          GIOFlags flags;
369
      
370
371
372
373
374
          /* Set the channel to blocking, to avoid a busy loop
           */
          flags = g_io_channel_get_flags (channel);
          /* Ignore any errors here, they're irrelevant */
          g_io_channel_set_flags (channel, flags & ~G_IO_FLAG_NONBLOCK, NULL);
375

376
          result = g_io_channel_flush (channel, &tmperr);
377
        }
378
379
380
381
      else
        result = G_IO_STATUS_NORMAL;

      g_string_truncate(channel->write_buf, 0);
382
    }
383
384
  else
    result = G_IO_STATUS_NORMAL;
385

386
387
388
389
390
391
392
  if (channel->partial_write_buf[0] != '\0')
    {
      if (flush)
        g_warning ("Partial character at end of write buffer not flushed.\n");
      channel->partial_write_buf[0] = '\0';
    }

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

  channel->close_on_unref = FALSE; /* Because we already did */
396
397
398
  channel->is_readable = FALSE;
  channel->is_writeable = FALSE;
  channel->is_seekable = FALSE;
399

400
401
402
403
404
405
406
407
408
409
410
411
  if (status != G_IO_STATUS_NORMAL)
    {
      g_clear_error (&tmperr);
      return status;
    }
  else if (result != G_IO_STATUS_NORMAL)
    {
      g_propagate_error (err, tmperr);
      return result;
    }
  else
    return G_IO_STATUS_NORMAL;
412
413
414
415
416
417
418
}

/* This function is used for the final flush on close or unref */
static void
g_io_channel_purge (GIOChannel *channel)
{
  GError *err = NULL;
419
  GIOStatus status;
420
421
422

  g_return_if_fail (channel != NULL);

423
  if (channel->write_buf && channel->write_buf->len > 0)
424
425
426
427
428
429
430
431
    {
      GIOFlags flags;
      
      /* Set the channel to blocking, to avoid a busy loop
       */
      flags = g_io_channel_get_flags (channel);
      g_io_channel_set_flags (channel, flags & ~G_IO_FLAG_NONBLOCK, NULL);

432
      status = g_io_channel_flush (channel, &err);
433
434
435
436
437
438
439
440
441
442

      if (err)
	{ /* No way to return the error */
	  g_warning ("Error flushing string: %s", err->message);
	  g_error_free (err);
	}
    }

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

443
444
445
446
  if (channel->read_buf)
    g_string_truncate (channel->read_buf, 0);
  if (channel->write_buf)
    g_string_truncate (channel->write_buf, 0);
447
  if (channel->encoding)
448
449
450
451
452
453
454
455
456
457
    {
      if (channel->encoded_read_buf)
        g_string_truncate (channel->encoded_read_buf, 0);

      if (channel->partial_write_buf[0] != '\0')
        {
          g_warning ("Partial character at end of write buffer not flushed.\n");
          channel->partial_write_buf[0] = '\0';
        }
    }
458
459
}

460
461
462
463
464
465
466
467
468
GSource *
g_io_create_watch (GIOChannel  *channel,
		   GIOCondition condition)
{
  g_return_val_if_fail (channel != NULL, NULL);

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

469
guint 
470
g_io_add_watch_full (GIOChannel    *channel,
471
472
473
474
475
476
		     gint           priority,
		     GIOCondition   condition,
		     GIOFunc        func,
		     gpointer       user_data,
		     GDestroyNotify notify)
{
477
  GSource *source;
478
  guint id;
479
  
480
481
  g_return_val_if_fail (channel != NULL, 0);

482
483
484
485
486
487
  source = g_io_create_watch (channel, condition);

  if (priority != G_PRIORITY_DEFAULT)
    g_source_set_priority (source, priority);
  g_source_set_callback (source, (GSourceFunc)func, user_data, notify);

488
489
490
491
  id = g_source_attach (source, NULL);
  g_source_unref (source);

  return id;
492
493
494
}

guint 
495
g_io_add_watch (GIOChannel    *channel,
496
497
498
499
		GIOCondition   condition,
		GIOFunc        func,
		gpointer       user_data)
{
500
  return g_io_add_watch_full (channel, G_PRIORITY_DEFAULT, condition, func, user_data, NULL);
501
}
502
503
504
505
506

/**
 * g_io_channel_get_buffer_condition:
 * @channel: A #GIOChannel
 *
507
508
 * This function returns a #GIOCondition depending on whether there
 * is data to be read/space to write data in the
509
 * internal buffers in the #GIOChannel. Only the flags %G_IO_IN and
510
 * %G_IO_OUT may be set.
511
512
513
514
515
516
 *
 * Return value: A #GIOCondition
 **/
GIOCondition
g_io_channel_get_buffer_condition (GIOChannel *channel)
{
517
518
  GIOCondition condition = 0;

519
520
521
522
523
524
525
526
527
528
  if (channel->encoding)
    {
      if (channel->encoded_read_buf && (channel->encoded_read_buf->len > 0))
        condition |= G_IO_IN; /* Only return if we have full characters */
    }
  else
    {
      if (channel->read_buf && (channel->read_buf->len > 0))
        condition |= G_IO_IN;
    }
529
530

  if (channel->write_buf && (channel->write_buf->len < channel->buf_size))
531
    condition |= G_IO_OUT;
532
533

  return condition;
534
535
536
}

/**
537
 * g_io_channel_error_from_errno:
538
 * @en: an <literal>errno</literal> error number, e.g. %EINVAL.
539
 *
540
541
542
 * Converts an <literal>errno</literal> error number to a #GIOChannelError.
 *
 * Return value: a #GIOChannelError error number, e.g. %G_IO_CHANNEL_ERROR_INVAL.
543
544
 **/
GIOChannelError
545
g_io_channel_error_from_errno (gint en)
546
547
548
549
550
551
552
553
554
555
556
557
{
#ifdef EAGAIN
  g_return_val_if_fail (en != EAGAIN, G_IO_CHANNEL_ERROR_FAILED);
#endif
#ifdef EINTR
  g_return_val_if_fail (en != EINTR, G_IO_CHANNEL_ERROR_FAILED);
#endif

  switch (en)
    {
#ifdef EBADF
    case EBADF:
558
559
      g_warning("Invalid file descriptor.\n");
      return G_IO_CHANNEL_ERROR_FAILED;
560
561
562
563
#endif

#ifdef EFAULT
    case EFAULT:
564
      g_warning("Buffer outside valid address space.\n");
565
566
567
568
569
570
      return G_IO_CHANNEL_ERROR_FAILED;
#endif

#ifdef EFBIG
    case EFBIG:
      return G_IO_CHANNEL_ERROR_FBIG;
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
#endif

#ifdef EINVAL
    case EINVAL:
      return G_IO_CHANNEL_ERROR_INVAL;
#endif

#ifdef EIO
    case EIO:
      return G_IO_CHANNEL_ERROR_IO;
#endif

#ifdef EISDIR
    case EISDIR:
      return G_IO_CHANNEL_ERROR_ISDIR;
#endif

#ifdef ENOSPC
    case ENOSPC:
      return G_IO_CHANNEL_ERROR_NOSPC;
#endif

593
594
595
#ifdef ENXIO
    case ENXIO:
      return G_IO_CHANNEL_ERROR_NXIO;
596
#endif
597
598
599
600
601
602

#ifdef EOVERFLOW
    case EOVERFLOW:
      return G_IO_CHANNEL_ERROR_OVERFLOW;
#endif

603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
#ifdef EPIPE
    case EPIPE:
      return G_IO_CHANNEL_ERROR_PIPE;
#endif

    default:
      return G_IO_CHANNEL_ERROR_FAILED;
    }
}

/**
 * g_io_channel_set_buffer_size:
 * @channel: a #GIOChannel
 * @size: the size of the buffer. 0 == pick a good size
 *
Matthias Clasen's avatar
Matthias Clasen committed
618
 * Sets the buffer size.
619
620
621
622
623
624
625
626
627
628
 **/  
void
g_io_channel_set_buffer_size (GIOChannel	*channel,
                              gsize		 size)
{
  g_return_if_fail (channel != NULL);

  if (size == 0)
    size = G_IO_NICE_BUF_SIZE;

629
630
  if (size < MAX_CHAR_SIZE)
    size = MAX_CHAR_SIZE;
631

632
633
634
635
636
637
638
  channel->buf_size = size;
}

/**
 * g_io_channel_get_buffer_size:
 * @channel: a #GIOChannel
 *
Matthias Clasen's avatar
Matthias Clasen committed
639
 * Gets the buffer size.
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
 *
 * Return value: the size of the buffer.
 **/  
gsize
g_io_channel_get_buffer_size (GIOChannel	*channel)
{
  g_return_val_if_fail (channel != NULL, 0);

  return channel->buf_size;
}

/**
 * g_io_channel_set_line_term:
 * @channel: a #GIOChannel
 * @line_term: The line termination string. Use %NULL for auto detect.
655
 *             Auto detection breaks on "\n", "\r\n", "\r", "\0", and
Matthias Clasen's avatar
Matthias Clasen committed
656
 *             the Unicode paragraph separator. Auto detection should
657
 *             not be used for anything other than file-based channels.
658
 * @length: The length of the termination string. If -1 is passed, the
Matthias Clasen's avatar
Matthias Clasen committed
659
660
 *          string is assumed to be nul-terminated. This option allows
 *          termination strings with embeded nuls.
661
662
663
664
665
666
 *
 * This sets the string that #GIOChannel uses to determine
 * where in the file a line break occurs.
 **/
void
g_io_channel_set_line_term (GIOChannel	*channel,
667
668
                            const gchar	*line_term,
			    gint         length)
669
670
{
  g_return_if_fail (channel != NULL);
671
  g_return_if_fail (line_term == NULL || length != 0); /* Disallow "" */
672

673
674
675
676
677
678
679
680
681
  if (line_term == NULL)
    length = 0;
  else if (length < 0)
    length = strlen (line_term);

  if (channel->line_term)
    g_free (channel->line_term);
  channel->line_term = line_term ? g_memdup (line_term, length) : NULL;
  channel->line_term_len = length;
682
683
684
685
686
}

/**
 * g_io_channel_get_line_term:
 * @channel: a #GIOChannel
687
 * @length: a location to return the length of the line terminator
688
689
690
691
692
693
694
695
696
 *
 * This returns the string that #GIOChannel uses to determine
 * where in the file a line break occurs. A value of %NULL
 * indicates auto detection.
 *
 * Return value: The line termination string. This value
 *   is owned by GLib and must not be freed.
 **/
G_CONST_RETURN gchar*
697
698
g_io_channel_get_line_term (GIOChannel	*channel,
			    gint        *length)
699
700
701
{
  g_return_val_if_fail (channel != NULL, 0);

702
703
704
  if (length)
    *length = channel->line_term_len;

705
706
707
708
709
  return channel->line_term;
}

/**
 * g_io_channel_set_flags:
710
 * @channel: a #GIOChannel.
Matthias Clasen's avatar
Matthias Clasen committed
711
 * @flags: the flags to set on the IO channel.
712
713
 * @error: A location to return an error of type #GIOChannelError.
 *
714
 * Sets the (writeable) flags in @channel to (@flags & %G_IO_CHANNEL_SET_MASK).
715
 *
716
 * Return value: the status of the operation. 
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
 **/
GIOStatus
g_io_channel_set_flags (GIOChannel *channel,
                        GIOFlags    flags,
                        GError    **error)
{
  g_return_val_if_fail (channel != NULL, G_IO_STATUS_ERROR);
  g_return_val_if_fail ((error == NULL) || (*error == NULL),
			G_IO_STATUS_ERROR);

  return (* channel->funcs->io_set_flags)(channel,
					  flags & G_IO_FLAG_SET_MASK,
					  error);
}

/**
 * g_io_channel_get_flags:
 * @channel: a #GIOChannel
 *
 * Gets the current flags for a #GIOChannel, including read-only
 * flags such as %G_IO_FLAG_IS_READABLE.
738
 *
739
740
741
 * The values of the flags %G_IO_FLAG_IS_READABLE and %G_IO_FLAG_IS_WRITEABLE
 * are cached for internal use by the channel when it is created.
 * If they should change at some later point (e.g. partial shutdown
742
 * of a socket with the UNIX <function>shutdown()</function> function), the user
743
744
745
 * should immediately call g_io_channel_get_flags () to update
 * the internal values of these flags.
 *
746
 * Return value: the flags which are set on the channel
747
748
749
750
 **/
GIOFlags
g_io_channel_get_flags (GIOChannel *channel)
{
751
752
  GIOFlags flags;

753
  g_return_val_if_fail (channel != NULL, 0);
754

755
756
757
758
759
760
761
762
763
764
765
766
  flags = (* channel->funcs->io_get_flags) (channel);

  /* Cross implementation code */

  if (channel->is_seekable)
    flags |= G_IO_FLAG_IS_SEEKABLE;
  if (channel->is_readable)
    flags |= G_IO_FLAG_IS_READABLE;
  if (channel->is_writeable)
    flags |= G_IO_FLAG_IS_WRITEABLE;

  return flags;
767
768
}

769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
/**
 * g_io_channel_set_close_on_unref:
 * @channel: a #GIOChannel
 * @do_close: Whether to close the channel on the final unref of
 *            the GIOChannel data structure. The default value of
 *            this is %TRUE for channels created by g_io_channel_new_file (),
 *            and %FALSE for all other channels.
 *
 * Setting this flag to %TRUE for a channel you have already closed
 * can cause problems.
 **/
void
g_io_channel_set_close_on_unref	(GIOChannel *channel,
				 gboolean    do_close)
{
  g_return_if_fail (channel != NULL);

  channel->close_on_unref = do_close;
}

/**
 * g_io_channel_get_close_on_unref:
791
 * @channel: a #GIOChannel.
792
 *
793
794
795
796
797
798
799
 * Returns whether the file/socket/whatever associated with @channel
 * will be closed when @channel receives its final unref and is
 * destroyed. The default value of this is %TRUE for channels created
 * by g_io_channel_new_file (), and %FALSE for all other channels.
 *
 * Return value: Whether the channel will be closed on the final unref of
 *               the GIOChannel data structure.
800
801
802
803
804
805
806
807
808
 **/
gboolean
g_io_channel_get_close_on_unref	(GIOChannel *channel)
{
  g_return_val_if_fail (channel != NULL, FALSE);

  return channel->close_on_unref;
}

809
810
811
812
/**
 * g_io_channel_seek_position:
 * @channel: a #GIOChannel
 * @offset: The offset in bytes from the position specified by @type
813
814
815
816
 * @type: a #GSeekType. The type %G_SEEK_CUR is only allowed in those
 *                      cases where a call to g_io_channel_set_encoding ()
 *                      is allowed. See the documentation for
 *                      g_io_channel_set_encoding () for details.
817
818
819
820
 * @error: A location to return an error of type #GIOChannelError
 *
 * Replacement for g_io_channel_seek() with the new API.
 *
821
 * Return value: the status of the operation.
822
823
824
 **/
GIOStatus
g_io_channel_seek_position	(GIOChannel* channel,
Owen Taylor's avatar
Owen Taylor committed
825
				 gint64      offset,
826
827
828
829
830
831
832
833
834
835
836
837
				 GSeekType   type,
				 GError    **error)
{
  GIOStatus status;

  /* For files, only one of the read and write buffers can contain data.
   * For sockets, both can contain data.
   */

  g_return_val_if_fail (channel != NULL, G_IO_STATUS_ERROR);
  g_return_val_if_fail ((error == NULL) || (*error == NULL),
			G_IO_STATUS_ERROR);
838
  g_return_val_if_fail (channel->is_seekable, G_IO_STATUS_ERROR);
839
840
841
842

  switch (type)
    {
      case G_SEEK_CUR: /* The user is seeking relative to the head of the buffer */
843
        if (channel->use_buffer)
844
          {
845
846
            if (channel->do_encode && channel->encoded_read_buf
                && channel->encoded_read_buf->len > 0)
847
848
849
850
851
852
853
              {
                g_warning ("Seek type G_SEEK_CUR not allowed for this"
                  " channel's encoding.\n");
                return G_IO_STATUS_ERROR;
              }
          if (channel->read_buf)
            offset -= channel->read_buf->len;
854
855
          if (channel->encoded_read_buf)
            {
856
              g_assert (channel->encoded_read_buf->len == 0 || !channel->do_encode);
857
858
859
860
861
862
863
864

              /* If there's anything here, it's because the encoding is UTF-8,
               * so we can just subtract the buffer length, the same as for
               * the unencoded data.
               */

              offset -= channel->encoded_read_buf->len;
            }
865
          }
866
        break;
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
      case G_SEEK_SET:
      case G_SEEK_END:
        break;
      default:
        g_warning ("g_io_channel_seek_position: unknown seek type");
        return G_IO_STATUS_ERROR;
    }

  if (channel->use_buffer)
    {
      status = g_io_channel_flush (channel, error);
      if (status != G_IO_STATUS_NORMAL)
        return status;
    }

  status = channel->funcs->io_seek (channel, offset, type, error);

  if ((status == G_IO_STATUS_NORMAL) && (channel->use_buffer))
    {
886
887
      if (channel->read_buf)
        g_string_truncate (channel->read_buf, 0);
888
889
890
891
892
893
894
895

      /* Conversion state no longer matches position in file */
      if (channel->read_cd != (GIConv) -1)
        g_iconv (channel->read_cd, NULL, NULL, NULL, NULL);
      if (channel->write_cd != (GIConv) -1)
        g_iconv (channel->write_cd, NULL, NULL, NULL, NULL);

      if (channel->encoded_read_buf)
896
        {
897
898
          g_assert (channel->encoded_read_buf->len == 0 || !channel->do_encode);
          g_string_truncate (channel->encoded_read_buf, 0);
899
        }
900

901
902
903
904
      if (channel->partial_write_buf[0] != '\0')
        {
          g_warning ("Partial character at end of write buffer not flushed.\n");
          channel->partial_write_buf[0] = '\0';
905
906
907
908
909
910
911
912
913
914
915
        }
    }

  return status;
}

/**
 * g_io_channel_flush:
 * @channel: a #GIOChannel
 * @error: location to store an error of type #GIOChannelError
 *
Matthias Clasen's avatar
Matthias Clasen committed
916
 * Flushes the write buffer for the GIOChannel.
917
918
 *
 * Return value: the status of the operation: One of
Matthias Clasen's avatar
Matthias Clasen committed
919
920
 *   #G_IO_CHANNEL_NORMAL, #G_IO_CHANNEL_AGAIN, or
 *   #G_IO_CHANNEL_ERROR.
921
922
923
924
925
926
 **/
GIOStatus
g_io_channel_flush (GIOChannel	*channel,
		    GError     **error)
{
  GIOStatus status;
927
  gsize this_time = 1, bytes_written = 0;
928
929
930
931

  g_return_val_if_fail (channel != NULL, G_IO_STATUS_ERROR);
  g_return_val_if_fail ((error == NULL) || (*error == NULL), G_IO_STATUS_ERROR);

932
  if (channel->write_buf == NULL || channel->write_buf->len == 0)
933
    return G_IO_STATUS_NORMAL;
934
935
936

  do
    {
937
938
      g_assert (this_time > 0);

939
      status = channel->funcs->io_write (channel,
940
941
942
					 channel->write_buf->str + bytes_written,
					 channel->write_buf->len - bytes_written,
					 &this_time, error);
943
944
945
      bytes_written += this_time;
    }
  while ((bytes_written < channel->write_buf->len)
946
         && (status == G_IO_STATUS_NORMAL));
947
948
949

  g_string_erase (channel->write_buf, 0, bytes_written);

950
951
  return status;
}
952

953
954
955
956
957
958
959
960
/**
 * g_io_channel_set_buffered:
 * @channel: a #GIOChannel
 * @buffered: whether to set the channel buffered or unbuffered
 *
 * The buffering state can only be set if the channel's encoding
 * is %NULL. For any other encoding, the channel must be buffered.
 *
961
962
 * A buffered channel can only be set unbuffered if the channel's
 * internal buffers have been flushed. Newly created channels or
Matthias Clasen's avatar
Matthias Clasen committed
963
 * channels which have returned %G_IO_STATUS_EOF
964
965
966
967
968
969
970
971
972
973
974
975
 * not require such a flush. For write-only channels, a call to
 * g_io_channel_flush () is sufficient. For all other channels,
 * the buffers may be flushed by a call to g_io_channel_seek_position ().
 * This includes the possibility of seeking with seek type %G_SEEK_CUR
 * and an offset of zero. Note that this means that socket-based
 * channels cannot be set unbuffered once they have had data
 * read from them.
 *
 * On unbuffered channels, it is safe to mix read and write
 * calls from the new and old APIs, if this is necessary for
 * maintaining old code.
 *
976
977
978
979
980
981
982
 * The default state of the channel is buffered.
 **/
void
g_io_channel_set_buffered	(GIOChannel *channel,
				 gboolean    buffered)
{
  g_return_if_fail (channel != NULL);
983

984
985
986
987
988
989
  if (channel->encoding != NULL)
    {
      g_warning ("Need to have NULL encoding to set the buffering state of the "
                 "channel.\n");
      return;
    }
990

991
992
993
994
995
996
997
998
  g_return_if_fail (!channel->read_buf || channel->read_buf->len == 0);
  g_return_if_fail (!channel->write_buf || channel->write_buf->len == 0);

  channel->use_buffer = buffered;
}

/**
 * g_io_channel_get_buffered:
999
1000
 * @channel: a #GIOChannel.
 *
1001
 * Returns whether @channel is buffered.
1002
 *
1003
 * Return Value: %TRUE if the @channel is buffered. 
1004
1005
1006
1007
1008
1009
1010
 **/
gboolean
g_io_channel_get_buffered	(GIOChannel *channel)
{
  g_return_val_if_fail (channel != NULL, FALSE);

  return channel->use_buffer;
1011
1012
1013
1014
1015
1016
1017
1018
}

/**
 * g_io_channel_set_encoding:
 * @channel: a #GIOChannel
 * @encoding: the encoding type
 * @error: location to store an error of type #GConvertError.
 *
Matthias Clasen's avatar
Matthias Clasen committed
1019
 * Sets the encoding for the input/output of the channel. The internal
1020
1021
 * encoding is always UTF-8. The default encoding for the
 * external file is UTF-8.
1022
 *
1023
 * The encoding %NULL is safe to use with binary data.
1024
 *
1025
1026
 * The encoding can only be set if one of the following conditions
 * is true:
1027
1028
1029
1030
 *
 * 1. The channel was just created, and has not been written to
 *    or read from yet.
 *
1031
1032
1033
 * 2. The channel is write-only.
 *
 * 3. The channel is a file, and the file pointer was just
1034
1035
1036
 *    repositioned by a call to g_io_channel_seek_position().
 *    (This flushes all the internal buffers.)
 *
1037
1038
 * 4. The current encoding is %NULL or UTF-8.
 *
Matthias Clasen's avatar
Matthias Clasen committed
1039
1040
 * 5. One of the (new API) read functions has just returned %G_IO_STATUS_EOF
 *    (or, in the case of g_io_channel_read_to_end (), %G_IO_STATUS_NORMAL).
1041
1042
 *
 * 6. One of the functions g_io_channel_read_chars () or g_io_channel_read_unichar ()
Matthias Clasen's avatar
Matthias Clasen committed
1043
1044
 *    has returned %G_IO_STATUS_AGAIN or %G_IO_STATUS_ERROR. This may be
 *    useful in the case of %G_CONVERT_ERROR_ILLEGAL_SEQUENCE.
1045
1046
 *    Returning one of these statuses from g_io_channel_read_line (),
 *    g_io_channel_read_line_string (), or g_io_channel_read_to_end ()
Matthias Clasen's avatar
Matthias Clasen committed
1047
 *    does <emphasis>not</emphasis> guarantee that the encoding can be changed.
1048
 *
1049
 * Channels which do not meet one of the above conditions cannot call
1050
 * g_io_channel_seek_position () with an offset of %G_SEEK_CUR,
1051
 * and, if they are "seekable", cannot
1052
1053
 * call g_io_channel_write_chars () after calling one
 * of the API "read" functions.
1054
 *
Matthias Clasen's avatar
Matthias Clasen committed
1055
 * Return Value: %G_IO_STATUS_NORMAL if the encoding was successfully set.
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
 **/
GIOStatus
g_io_channel_set_encoding (GIOChannel	*channel,
                           const gchar	*encoding,
			   GError      **error)
{
  GIConv read_cd, write_cd;
  gboolean did_encode;

  g_return_val_if_fail (channel != NULL, G_IO_STATUS_ERROR);
  g_return_val_if_fail ((error == NULL) || (*error == NULL), G_IO_STATUS_ERROR);

1068
  /* Make sure the encoded buffers are empty */
1069

1070
  g_return_val_if_fail (!channel->do_encode || !channel->encoded_read_buf ||
1071
1072
			channel->encoded_read_buf->len == 0, G_IO_STATUS_ERROR);

1073
  if (!channel->use_buffer)
1074
    {
1075
1076
1077
      g_warning ("Need to set the channel buffered before setting the encoding.\n");
      g_warning ("Assuming this is what you meant and acting accordingly.\n");

1078
1079
      channel->use_buffer = TRUE;
    }
1080

1081
1082
1083
1084
1085
1086
  if (channel->partial_write_buf[0] != '\0')
    {
      g_warning ("Partial character at end of write buffer not flushed.\n");
      channel->partial_write_buf[0] = '\0';
    }

1087
1088
1089
  did_encode = channel->do_encode;

  if (!encoding || strcmp (encoding, "UTF8") == 0 || strcmp (encoding, "UTF-8") == 0)
1090
1091
    {
      channel->do_encode = FALSE;
1092
      read_cd = write_cd = (GIConv) -1;
1093
1094
1095
    }
  else
    {
1096
1097
      gint err = 0;
      const gchar *from_enc = NULL, *to_enc = NULL;
1098

1099
      if (channel->is_readable)
1100
        {
1101
1102
1103
1104
1105
1106
1107
1108
          read_cd = g_iconv_open ("UTF-8", encoding);

          if (read_cd == (GIConv) -1)
            {
              err = errno;
              from_enc = "UTF-8";
              to_enc = encoding;
            }
1109
1110
        }
      else
1111
1112
1113
        read_cd = (GIConv) -1;

      if (channel->is_writeable && err == 0)
1114
1115
        {
          write_cd = g_iconv_open (encoding, "UTF-8");
1116

1117
1118
1119
1120
1121
1122
1123
          if (write_cd == (GIConv) -1)
            {
              err = errno;
              from_enc = encoding;
              to_enc = "UTF-8";
            }
        }
1124
1125
      else
        write_cd = (GIConv) -1;
1126

1127
      if (err != 0)
1128
        {
1129
1130
1131
          g_assert (from_enc);
          g_assert (to_enc);

1132
1133
1134
1135
1136
1137
1138
          if (err == EINVAL)
            g_set_error (error, G_CONVERT_ERROR, G_CONVERT_ERROR_NO_CONVERSION,
                         _("Conversion from character set `%s' to `%s' is not supported"),
                         from_enc, to_enc);
          else
            g_set_error (error, G_CONVERT_ERROR, G_CONVERT_ERROR_FAILED,
                         _("Could not open converter from `%s' to `%s': %s"),
Owen Taylor's avatar
Owen Taylor committed
1139
                         from_enc, to_enc, g_strerror (err));
1140
1141
1142
1143
1144
1145

          if (read_cd != (GIConv) -1)
            g_iconv_close (read_cd);
          if (write_cd != (GIConv) -1)
            g_iconv_close (write_cd);

1146
1147
1148
1149
1150
1151
1152
1153
          return G_IO_STATUS_ERROR;
        }

      channel->do_encode = TRUE;
    }

  /* The encoding is ok, so set the fields in channel */

1154
1155
1156
1157
  if (channel->read_cd != (GIConv) -1)
    g_iconv_close (channel->read_cd);
  if (channel->write_cd != (GIConv) -1)
    g_iconv_close (channel->write_cd);
1158

1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
  if (channel->encoded_read_buf && channel->encoded_read_buf->len > 0)
    {
      g_assert (!did_encode); /* Encoding UTF-8, NULL doesn't use encoded_read_buf */

      /* This is just validated UTF-8, so we can copy it back into read_buf
       * so it can be encoded in whatever the new encoding is.
       */

      g_string_prepend_len (channel->read_buf, channel->encoded_read_buf->str,
                            channel->encoded_read_buf->len);
      g_string_truncate (channel->encoded_read_buf, 0);
    }

1172
1173
  channel->read_cd = read_cd;
  channel->write_cd = write_cd;
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184

  g_free (channel->encoding);
  channel->encoding = g_strdup (encoding);

  return G_IO_STATUS_NORMAL;
}

/**
 * g_io_channel_get_encoding:
 * @channel: a #GIOChannel
 *
Matthias Clasen's avatar
Matthias Clasen committed
1185
 * Gets the encoding for the input/output of the channel. The internal
1186
1187
 * encoding is always UTF-8. The encoding %NULL makes the
 * channel safe for binary data.
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
 *
 * Return value: A string containing the encoding, this string is
 *   owned by GLib and must not be freed.
 **/
G_CONST_RETURN gchar*
g_io_channel_get_encoding (GIOChannel      *channel)
{
  g_return_val_if_fail (channel != NULL, NULL);

  return channel->encoding;
}

static GIOStatus
g_io_channel_fill_buffer (GIOChannel *channel,
                          GError    **err)
{
  gsize read_size, cur_len, oldlen;
  GIOStatus status;

1207
  if (channel->is_seekable && channel->write_buf && channel->write_buf->len > 0)
1208
    {
1209
1210
1211
1212
1213
1214
1215
1216
      status = g_io_channel_flush (channel, err);
      if (status != G_IO_STATUS_NORMAL)
        return status;
    }
  if (channel->is_seekable && channel->partial_write_buf[0] != '\0')
    {
      g_warning ("Partial character at end of write buffer not flushed.\n");
      channel->partial_write_buf[0] = '\0';
1217
1218
    }

1219
1220
  if (!channel->read_buf)
    channel->read_buf = g_string_sized_new (channel->buf_size);
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238

  cur_len = channel->read_buf->len;

  g_string_set_size (channel->read_buf, channel->read_buf->len + channel->buf_size);

  status = channel->funcs->io_read (channel, channel->read_buf->str + cur_len,
                                    channel->buf_size, &read_size, err);

  g_assert ((status == G_IO_STATUS_NORMAL) || (read_size == 0));

  g_string_truncate (channel->read_buf, read_size + cur_len);

  if ((status != G_IO_STATUS_NORMAL)
    && ((status != G_IO_STATUS_EOF) || (channel->read_buf->len == 0)))
    return status;

  g_assert (channel->read_buf->len > 0);

1239
1240
1241
  if (channel->encoded_read_buf)
    oldlen = channel->encoded_read_buf->len;
  else
1242
1243
    {
      oldlen = 0;
1244
1245
      if (channel->encoding)
        channel->encoded_read_buf = g_string_sized_new (channel->buf_size);
1246
    }
1247

1248
1249
1250
1251
  if (channel->do_encode)
    {
      size_t errnum, inbytes_left, outbytes_left;
      gchar *inbuf, *outbuf;
1252
      int errval;
1253

1254
1255
      g_assert (channel->encoded_read_buf);

1256
1257
1258
reencode:

      inbytes_left = channel->read_buf->len;
1259
      outbytes_left = MAX (channel->read_buf->len,
1260
                           channel->encoded_read_buf->allocated_len
1261
1262
                           - channel->encoded_read_buf->len - 1); /* 1 for NULL */
      outbytes_left = MAX (outbytes_left, 6);
1263
1264

      inbuf = channel->read_buf->str;
1265
1266
      g_string_set_size (channel->encoded_read_buf,
                         channel->encoded_read_buf->len + outbytes_left);
1267
1268
      outbuf = channel->encoded_read_buf->str + channel->encoded_read_buf->len
               - outbytes_left;
1269
1270
1271

      errnum = g_iconv (channel->read_cd, &inbuf, &inbytes_left,
			&outbuf, &outbytes_left);
1272
1273
1274
1275
1276
1277
      errval = errno;

      g_assert (inbuf + inbytes_left == channel->read_buf->str
                + channel->read_buf->len);
      g_assert (outbuf + outbytes_left == channel->encoded_read_buf->str
                + channel->encoded_read_buf->len);
1278
1279
1280
1281
1282
1283
1284
1285

      g_string_erase (channel->read_buf, 0,
		      channel->read_buf->len - inbytes_left);
      g_string_truncate (channel->encoded_read_buf,
			 channel->encoded_read_buf->len - outbytes_left);

      if (errnum == (size_t) -1)
        {
1286
          switch (errval)
1287
1288
1289
1290
            {
              case EINVAL:
                if ((oldlen == channel->encoded_read_buf->len)
                  && (status == G_IO_STATUS_EOF))
1291
                  status = G_IO_STATUS_EOF;
1292
1293
1294
1295
                else
                  status = G_IO_STATUS_NORMAL;
                break;
              case E2BIG:
1296
1297
                /* Buffer size at least 6, wrote at least on character */
                g_assert (inbuf != channel->read_buf->str);
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
                goto reencode;
              case EILSEQ:
                if (oldlen < channel->encoded_read_buf->len)
                  status = G_IO_STATUS_NORMAL;
                else
                  {
                    g_set_error (err, G_CONVERT_ERROR,
                      G_CONVERT_ERROR_ILLEGAL_SEQUENCE,
                      _("Invalid byte sequence in conversion input"));
                    return G_IO_STATUS_ERROR;
                  }
                break;
              default:
1311
                g_assert (errval != EBADF); /* The converter should be open */
1312
                g_set_error (err, G_CONVERT_ERROR, G_CONVERT_ERROR_FAILED,
Owen Taylor's avatar
Owen Taylor committed
1313
                  _("Error during conversion: %s"), g_strerror (errval));
1314
1315
1316
                return G_IO_STATUS_ERROR;
            }
        }
1317
1318
1319
1320
1321
1322
1323
      g_assert ((status != G_IO_STATUS_NORMAL)
               || (channel->encoded_read_buf->len > 0));
    }
  else if (channel->encoding) /* UTF-8 */
    {
      gchar *nextchar, *lastchar;

1324
1325
      g_assert (channel->encoded_read_buf);

1326
1327
1328
1329
      nextchar = channel->read_buf->str;
      lastchar = channel->read_buf->str + channel->read_buf->len;

      while (nextchar < lastchar)