giochannel.h

   1 /* GLIB - Library of useful routines for C programming
   2  * Copyright (C) 1995-1997  Peter Mattis, Spencer Kimball and Josh MacDonald
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  */
  19
  20 /*
  21  * Modified by the GLib Team and others 1997-2000.  See the AUTHORS
  22  * file for a list of people on the GLib Team.  See the ChangeLog
  23  * files for a list of changes.  These files are distributed with
  24  * GLib at ftp://ftp.gtk.org/pub/gtk/.
  25  */
  26
  27 #ifndef __G_IOCHANNEL_H__
  28 #define __G_IOCHANNEL_H__
  29
  30 #include <gtypes.h>
  31
  32 G_BEGIN_DECLS
  33
  34 /* GIOChannel
  35  */
  36
  37 typedef struct _GIOChannel      GIOChannel;
  38 typedef struct _GIOFuncs        GIOFuncs;
  39 typedef enum
  40 {
  41   G_IO_ERROR_NONE,
  42   G_IO_ERROR_AGAIN,
  43   G_IO_ERROR_INVAL,
  44   G_IO_ERROR_UNKNOWN
  45 } GIOError;
  46 typedef enum
  47 {
  48   G_SEEK_CUR,
  49   G_SEEK_SET,
  50   G_SEEK_END
  51 } GSeekType;
  52 typedef enum
  53 {
  54   G_IO_IN       GLIB_SYSDEF_POLLIN,
  55   G_IO_OUT      GLIB_SYSDEF_POLLOUT,
  56   G_IO_PRI      GLIB_SYSDEF_POLLPRI,
  57   G_IO_ERR      GLIB_SYSDEF_POLLERR,
  58   G_IO_HUP      GLIB_SYSDEF_POLLHUP,
  59   G_IO_NVAL     GLIB_SYSDEF_POLLNVAL
  60 } GIOCondition;
  61
  62 struct _GIOChannel
  63 {
  64   guint channel_flags;
  65   guint ref_count;
  66   GIOFuncs *funcs;
  67 };
  68
  69 typedef gboolean (*GIOFunc) (GIOChannel   *source,
  70                              GIOCondition  condition,
  71                              gpointer      data);
  72 struct _GIOFuncs
  73 {
  74   GIOError (*io_read)   (GIOChannel     *channel,
  75                          gchar          *buf,
  76                          guint           count,
  77                          guint          *bytes_read);
  78   GIOError (*io_write)  (GIOChannel     *channel,
  79                          gchar          *buf,
  80                          guint           count,
  81                          guint          *bytes_written);
  82   GIOError (*io_seek)   (GIOChannel     *channel,
  83                          gint            offset,
  84                          GSeekType       type);
  85   void (*io_close)      (GIOChannel     *channel);
  86   guint (*io_add_watch) (GIOChannel     *channel,
  87                          gint            priority,
  88                          GIOCondition    condition,
  89                          GIOFunc         func,
  90                          gpointer        user_data,
  91                          GDestroyNotify  notify);
  92   void (*io_free)       (GIOChannel     *channel);
  93 };
  94
  95 void        g_io_channel_init   (GIOChannel    *channel);
  96 void        g_io_channel_ref    (GIOChannel    *channel);
  97 void        g_io_channel_unref  (GIOChannel    *channel);
  98 GIOError    g_io_channel_read   (GIOChannel    *channel,
  99                                  gchar         *buf,
 100                                  guint          count,
 101                                  guint         *bytes_read);
 102 GIOError  g_io_channel_write    (GIOChannel    *channel,
 103                                  gchar         *buf,
 104                                  guint          count,
 105                                  guint         *bytes_written);
 106 GIOError  g_io_channel_seek     (GIOChannel    *channel,
 107                                  gint           offset,
 108                                  GSeekType      type);
 109 void      g_io_channel_close    (GIOChannel    *channel);
 110 guint     g_io_add_watch_full   (GIOChannel    *channel,
 111                                  gint           priority,
 112                                  GIOCondition   condition,
 113                                  GIOFunc        func,
 114                                  gpointer       user_data,
 115                                  GDestroyNotify notify);
 116 guint    g_io_add_watch         (GIOChannel    *channel,
 117                                  GIOCondition   condition,
 118                                  GIOFunc        func,
 119                                  gpointer       user_data);
 120
 121 /* On Unix, IO channels created with this function for any file
 122  * descriptor or socket.
 123  *
 124  * On Win32, use this only for files opened with the MSVCRT (the
 125  * Microsoft run-time C library) _open() or _pipe, including file
 126  * descriptors 0, 1 and 2 (corresponding to stdin, stdout and stderr).
 127  *
 128  * The term file descriptor as used in the context of Win32 refers to
 129  * the emulated Unix-like file descriptors MSVCRT provides. The native
 130  * corresponding concept is file HANDLE. There isn't as of yet a way to
 131  * get GIOChannels for file HANDLEs.
 132  */
 133 GIOChannel* g_io_channel_unix_new    (int         fd);
 134 gint        g_io_channel_unix_get_fd (GIOChannel *channel);
 135
 136 #ifdef G_OS_WIN32
 137
 138 #define G_WIN32_MSG_HANDLE 19981206
 139
 140 /* Use this to get a GPollFD from a GIOChannel, so that you can call
 141  * g_io_channel_win32_poll(). After calling this you should only use
 142  * g_io_channel_read() to read from the GIOChannel, i.e. never read()
 143  * or recv() from the underlying file descriptor or SOCKET.
 144  */
 145 void        g_io_channel_win32_make_pollfd (GIOChannel   *channel,
 146                                             GIOCondition  condition,
 147                                             GPollFD      *fd);
 148
 149 /* This can be used to wait a until at least one of the channels is readable.
 150  * On Unix you would do a select() on the file descriptors of the channels.
 151  * This should probably be available for all platforms?
 152  */
 153 gint        g_io_channel_win32_poll   (GPollFD    *fds,
 154                                        gint        n_fds,
 155                                        gint        timeout);
 156
 157 /* This is used to add polling for Windows messages. GDK (GTk+) programs
 158  * should *not* use this.
 159  */
 160 void        g_main_poll_win32_msg_add (gint        priority,
 161                                        GPollFD    *fd,
 162                                        guint       hwnd);
 163
 164 /* An IO channel for Windows messages for window handle hwnd. */
 165 GIOChannel *g_io_channel_win32_new_messages (guint hwnd);
 166
 167 /* An IO channel for C runtime (emulated Unix-like) file
 168  * descriptors. Identical to g_io_channel_unix_new above.
 169  * After calling g_io_add_watch() on a IO channel returned
 170  * by this function, you shouldn't call read() on the file
 171  * descriptor.
 172  */
 173 GIOChannel* g_io_channel_win32_new_fd (int         fd);
 174
 175 /* Get the C runtime file descriptor of a channel. */
 176 gint        g_io_channel_win32_get_fd (GIOChannel *channel);
 177
 178 /* An IO channel for a SOCK_STREAM winsock socket. The parameter
 179  * should be a SOCKET. After calling g_io_add_watch() on a IO channel
 180  * returned by this function, you shouldn't call recv() on the SOCKET.
 181  */
 182 GIOChannel *g_io_channel_win32_new_stream_socket (int socket);
 183
 184 #endif
 185
 186 G_END_DECLS
 187
 188 #endif /* __G_IOCHANNEL_H__ */