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 /* Windows emulation stubs for common Unix functions
 187  */
 188 #ifdef G_OS_WIN32
 189 #  define MAXPATHLEN 1024
 190
 191 #ifdef _MSC_VER
 192 typedef int pid_t;
 193 #endif
 194
 195 /*
 196  * To get prototypes for the following POSIXish functions, you have to
 197  * include the indicated non-POSIX headers. The functions are defined
 198  * in OLDNAMES.LIB (MSVC) or -lmoldname-msvc (mingw32).
 199  *
 200  * getcwd: <direct.h> (MSVC), <io.h> (mingw32)
 201  * getpid: <process.h>
 202  * access: <io.h>
 203  * unlink: <stdio.h> or <io.h>
 204  * open, read, write, lseek, close: <io.h>
 205  * rmdir: <direct.h>
 206  * pipe: <direct.h>
 207  */
 208
 209 /* pipe is not in OLDNAMES.LIB or -lmoldname-msvc. */
 210 #define pipe(phandles)  _pipe (phandles, 4096, _O_BINARY)
 211
 212 /* For some POSIX functions that are not provided by the MS runtime,
 213  * we provide emulators in glib, which are prefixed with g_win32_.
 214  */
 215 #    define ftruncate(fd, size) g_win32_ftruncate (fd, size)
 216
 217 /* -lmingw32 also has emulations for these, but we need our own
 218  * for MSVC anyhow, so we might aswell use them always.
 219  */
 220 #    define opendir             g_win32_opendir
 221 #    define readdir             g_win32_readdir
 222 #    define rewinddir           g_win32_rewinddir
 223 #    define closedir            g_win32_closedir
 224 #    define NAME_MAX 255
 225
 226 struct dirent
 227 {
 228   gchar  d_name[NAME_MAX + 1];
 229 };
 230
 231 struct DIR
 232 {
 233   gchar        *dir_name;
 234   gboolean      just_opened;
 235   guint         find_file_handle;
 236   gpointer      find_file_data;
 237   struct dirent readdir_result;
 238 };
 239 typedef struct DIR DIR;
 240
 241 /* emulation functions */
 242 extern int      g_win32_ftruncate       (gint            f,
 243                                          guint           size);
 244 DIR*            g_win32_opendir         (const gchar    *dirname);
 245 struct dirent*  g_win32_readdir         (DIR            *dir);
 246 void            g_win32_rewinddir       (DIR            *dir);
 247 gint            g_win32_closedir        (DIR            *dir);
 248
 249 /* The MS setlocale uses locale names of the form "English_United
 250  * States.1252" etc. We want the Unixish standard form "en", "zh_TW"
 251  * etc. This function gets the current thread locale from Windows and
 252  * returns it as a string of the above form for use in forming file
 253  * names etc. The returned string should be deallocated with g_free().
 254  */
 255 gchar *         g_win32_getlocale  (void);
 256
 257 /* Translate a Win32 error code (as returned by GetLastError()) into
 258  * the corresponding message. The returned string should be deallocated
 259  * with g_free().
 260  */
 261 gchar *         g_win32_error_message (gint error);
 262
 263 #endif   /* G_OS_WIN32 */
 264
 265 G_END_DECLS
 266
 267 #endif /* __G_IOCHANNEL_H__ */