* Copyright 1998 Owen Taylor
*
* This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Library General Public
+ * modify it under the terms of the GNU Lesser General Public
* 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
- * Library General Public License for more details.
+ * Lesser General Public License for more details.
*
- * You should have received a copy of the GNU Library General Public
+ * You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
/*
- * Modified by the GLib Team and others 1997-1999. See the AUTHORS
+ * Modified by the GLib Team and others 1997-2000. See the AUTHORS
* 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/.
* MT safe
*/
-#include "glib.h"
+#include "config.h"
+
+#define _POSIX_SOURCE /* for SSIZE_MAX */
+
#include <sys/types.h>
+#include <sys/stat.h>
+#include <stdio.h>
#include <unistd.h>
#include <errno.h>
+#include <string.h>
+#include <fcntl.h>
+
+#include "galias.h"
+#include "glib.h"
/*
* Unix IO Channels
typedef struct _GIOUnixChannel GIOUnixChannel;
typedef struct _GIOUnixWatch GIOUnixWatch;
-struct _GIOUnixChannel {
+struct _GIOUnixChannel
+{
GIOChannel channel;
gint fd;
};
-struct _GIOUnixWatch {
+struct _GIOUnixWatch
+{
+ GSource source;
GPollFD pollfd;
GIOChannel *channel;
GIOCondition condition;
- GIOFunc callback;
};
-static GIOError g_io_unix_read (GIOChannel *channel,
- gchar *buf,
- guint count,
- guint *bytes_written);
-
-static GIOError g_io_unix_write(GIOChannel *channel,
- gchar *buf,
- guint count,
- guint *bytes_written);
-static GIOError g_io_unix_seek (GIOChannel *channel,
- gint offset,
- GSeekType type);
-static void g_io_unix_close (GIOChannel *channel);
-static void g_io_unix_free (GIOChannel *channel);
-static guint g_io_unix_add_watch (GIOChannel *channel,
- gint priority,
- GIOCondition condition,
- GIOFunc func,
- gpointer user_data,
- GDestroyNotify notify);
-static gboolean g_io_unix_prepare (gpointer source_data,
- GTimeVal *current_time,
- gint *timeout,
- gpointer user_data);
-static gboolean g_io_unix_check (gpointer source_data,
- GTimeVal *current_time,
- gpointer user_data);
-static gboolean g_io_unix_dispatch (gpointer source_data,
- GTimeVal *current_time,
- gpointer user_data);
-static void g_io_unix_destroy (gpointer source_data);
-
-GSourceFuncs unix_watch_funcs = {
+static GIOStatus g_io_unix_read (GIOChannel *channel,
+ gchar *buf,
+ gsize count,
+ gsize *bytes_read,
+ GError **err);
+static GIOStatus g_io_unix_write (GIOChannel *channel,
+ const gchar *buf,
+ gsize count,
+ gsize *bytes_written,
+ GError **err);
+static GIOStatus g_io_unix_seek (GIOChannel *channel,
+ gint64 offset,
+ GSeekType type,
+ GError **err);
+static GIOStatus g_io_unix_close (GIOChannel *channel,
+ GError **err);
+static void g_io_unix_free (GIOChannel *channel);
+static GSource* g_io_unix_create_watch (GIOChannel *channel,
+ GIOCondition condition);
+static GIOStatus g_io_unix_set_flags (GIOChannel *channel,
+ GIOFlags flags,
+ GError **err);
+static GIOFlags g_io_unix_get_flags (GIOChannel *channel);
+
+static gboolean g_io_unix_prepare (GSource *source,
+ gint *timeout);
+static gboolean g_io_unix_check (GSource *source);
+static gboolean g_io_unix_dispatch (GSource *source,
+ GSourceFunc callback,
+ gpointer user_data);
+static void g_io_unix_finalize (GSource *source);
+
+GSourceFuncs g_io_watch_funcs = {
g_io_unix_prepare,
g_io_unix_check,
g_io_unix_dispatch,
- g_io_unix_destroy
+ g_io_unix_finalize
};
-GIOFuncs unix_channel_funcs = {
+static GIOFuncs unix_channel_funcs = {
g_io_unix_read,
g_io_unix_write,
g_io_unix_seek,
g_io_unix_close,
- g_io_unix_add_watch,
+ g_io_unix_create_watch,
g_io_unix_free,
+ g_io_unix_set_flags,
+ g_io_unix_get_flags,
};
static gboolean
-g_io_unix_prepare (gpointer source_data,
- GTimeVal *current_time,
- gint *timeout,
- gpointer user_data)
+g_io_unix_prepare (GSource *source,
+ gint *timeout)
{
+ GIOUnixWatch *watch = (GIOUnixWatch *)source;
+ GIOCondition buffer_condition = g_io_channel_get_buffer_condition (watch->channel);
+
*timeout = -1;
- return FALSE;
+
+ /* Only return TRUE here if _all_ bits in watch->condition will be set
+ */
+ return ((watch->condition & buffer_condition) == watch->condition);
}
static gboolean
-g_io_unix_check (gpointer source_data,
- GTimeVal *current_time,
- gpointer user_data)
+g_io_unix_check (GSource *source)
{
- GIOUnixWatch *data = source_data;
+ GIOUnixWatch *watch = (GIOUnixWatch *)source;
+ GIOCondition buffer_condition = g_io_channel_get_buffer_condition (watch->channel);
+ GIOCondition poll_condition = watch->pollfd.revents;
- return (data->pollfd.revents & data->condition);
+ return ((poll_condition | buffer_condition) & watch->condition);
}
static gboolean
-g_io_unix_dispatch (gpointer source_data,
- GTimeVal *current_time,
- gpointer user_data)
+g_io_unix_dispatch (GSource *source,
+ GSourceFunc callback,
+ gpointer user_data)
{
- GIOUnixWatch *data = source_data;
+ GIOFunc func = (GIOFunc)callback;
+ GIOUnixWatch *watch = (GIOUnixWatch *)source;
+ GIOCondition buffer_condition = g_io_channel_get_buffer_condition (watch->channel);
- return (*data->callback)(data->channel,
- data->pollfd.revents & data->condition,
- user_data);
+ if (!func)
+ {
+ g_warning ("IO watch dispatched without callback\n"
+ "You must call g_source_connect().");
+ return FALSE;
+ }
+
+ return (*func) (watch->channel,
+ (watch->pollfd.revents | buffer_condition) & watch->condition,
+ user_data);
}
static void
-g_io_unix_destroy (gpointer source_data)
+g_io_unix_finalize (GSource *source)
{
- GIOUnixWatch *data = source_data;
+ GIOUnixWatch *watch = (GIOUnixWatch *)source;
- g_main_remove_poll (&data->pollfd);
- g_io_channel_unref (data->channel);
- g_free (data);
+ g_io_channel_unref (watch->channel);
}
-static GIOError
+static GIOStatus
g_io_unix_read (GIOChannel *channel,
- gchar *buf,
- guint count,
- guint *bytes_read)
+ gchar *buf,
+ gsize count,
+ gsize *bytes_read,
+ GError **err)
{
GIOUnixChannel *unix_channel = (GIOUnixChannel *)channel;
- gint result;
+ gssize result;
+ if (count > SSIZE_MAX) /* At least according to the Debian manpage for read */
+ count = SSIZE_MAX;
+
+ retry:
result = read (unix_channel->fd, buf, count);
if (result < 0)
{
*bytes_read = 0;
+
switch (errno)
- {
- case EINVAL:
- return G_IO_ERROR_INVAL;
- case EAGAIN:
- return G_IO_ERROR_AGAIN;
- default:
- return G_IO_ERROR_UNKNOWN;
- }
- }
- else
- {
- *bytes_read = result;
- return G_IO_ERROR_NONE;
+ {
+#ifdef EINTR
+ case EINTR:
+ goto retry;
+#endif
+#ifdef EAGAIN
+ case EAGAIN:
+ return G_IO_STATUS_AGAIN;
+#endif
+ default:
+ g_set_error (err, G_IO_CHANNEL_ERROR,
+ g_io_channel_error_from_errno (errno),
+ g_strerror (errno));
+ return G_IO_STATUS_ERROR;
+ }
}
+
+ *bytes_read = result;
+
+ return (result > 0) ? G_IO_STATUS_NORMAL : G_IO_STATUS_EOF;
}
-
-static GIOError
-g_io_unix_write(GIOChannel *channel,
- gchar *buf,
- guint count,
- guint *bytes_written)
+
+static GIOStatus
+g_io_unix_write (GIOChannel *channel,
+ const gchar *buf,
+ gsize count,
+ gsize *bytes_written,
+ GError **err)
{
GIOUnixChannel *unix_channel = (GIOUnixChannel *)channel;
- gint result;
+ gssize result;
+ retry:
result = write (unix_channel->fd, buf, count);
if (result < 0)
{
*bytes_written = 0;
+
switch (errno)
- {
- case EINVAL:
- return G_IO_ERROR_INVAL;
- case EAGAIN:
- return G_IO_ERROR_AGAIN;
- default:
- return G_IO_ERROR_UNKNOWN;
- }
- }
- else
- {
- *bytes_written = result;
- return G_IO_ERROR_NONE;
+ {
+#ifdef EINTR
+ case EINTR:
+ goto retry;
+#endif
+#ifdef EAGAIN
+ case EAGAIN:
+ return G_IO_STATUS_AGAIN;
+#endif
+ default:
+ g_set_error (err, G_IO_CHANNEL_ERROR,
+ g_io_channel_error_from_errno (errno),
+ g_strerror (errno));
+ return G_IO_STATUS_ERROR;
+ }
}
+
+ *bytes_written = result;
+
+ return G_IO_STATUS_NORMAL;
}
-static GIOError
+static GIOStatus
g_io_unix_seek (GIOChannel *channel,
- gint offset,
- GSeekType type)
+ gint64 offset,
+ GSeekType type,
+ GError **err)
{
GIOUnixChannel *unix_channel = (GIOUnixChannel *)channel;
int whence;
+ off_t tmp_offset;
off_t result;
switch (type)
whence = SEEK_END;
break;
default:
- g_warning ("g_io_unix_seek: unknown seek type");
- return G_IO_ERROR_UNKNOWN;
+ whence = -1; /* Shut the compiler up */
+ g_assert_not_reached ();
}
- result = lseek (unix_channel->fd, offset, whence);
+ tmp_offset = offset;
+ if (tmp_offset != offset)
+ {
+ g_set_error (err, G_IO_CHANNEL_ERROR,
+ g_io_channel_error_from_errno (EINVAL),
+ g_strerror (EINVAL));
+ return G_IO_STATUS_ERROR;
+ }
+
+ result = lseek (unix_channel->fd, tmp_offset, whence);
if (result < 0)
{
- switch (errno)
- {
- case EINVAL:
- return G_IO_ERROR_INVAL;
- default:
- return G_IO_ERROR_UNKNOWN;
- }
+ g_set_error (err, G_IO_CHANNEL_ERROR,
+ g_io_channel_error_from_errno (errno),
+ g_strerror (errno));
+ return G_IO_STATUS_ERROR;
}
- else
- return G_IO_ERROR_NONE;
+
+ return G_IO_STATUS_NORMAL;
}
-static void
-g_io_unix_close (GIOChannel *channel)
+static GIOStatus
+g_io_unix_close (GIOChannel *channel,
+ GError **err)
{
GIOUnixChannel *unix_channel = (GIOUnixChannel *)channel;
- close (unix_channel->fd);
+ if (close (unix_channel->fd) < 0)
+ {
+ g_set_error (err, G_IO_CHANNEL_ERROR,
+ g_io_channel_error_from_errno (errno),
+ g_strerror (errno));
+ return G_IO_STATUS_ERROR;
+ }
+
+ return G_IO_STATUS_NORMAL;
}
static void
g_free (unix_channel);
}
-static guint
-g_io_unix_add_watch (GIOChannel *channel,
- gint priority,
- GIOCondition condition,
- GIOFunc func,
- gpointer user_data,
- GDestroyNotify notify)
+static GSource *
+g_io_unix_create_watch (GIOChannel *channel,
+ GIOCondition condition)
{
- GIOUnixWatch *watch = g_new (GIOUnixWatch, 1);
GIOUnixChannel *unix_channel = (GIOUnixChannel *)channel;
+ GSource *source;
+ GIOUnixWatch *watch;
+
+
+ source = g_source_new (&g_io_watch_funcs, sizeof (GIOUnixWatch));
+ watch = (GIOUnixWatch *)source;
watch->channel = channel;
g_io_channel_ref (channel);
-
- watch->callback = func;
+
watch->condition = condition;
watch->pollfd.fd = unix_channel->fd;
watch->pollfd.events = condition;
- g_main_add_poll (&watch->pollfd, priority);
+ g_source_add_poll (source, &watch->pollfd);
- return g_source_add (priority, TRUE, &unix_watch_funcs, watch, user_data, notify);
+ return source;
+}
+
+static GIOStatus
+g_io_unix_set_flags (GIOChannel *channel,
+ GIOFlags flags,
+ GError **err)
+{
+ glong fcntl_flags;
+ GIOUnixChannel *unix_channel = (GIOUnixChannel *) channel;
+
+ fcntl_flags = 0;
+
+ if (flags & G_IO_FLAG_APPEND)
+ fcntl_flags |= O_APPEND;
+ if (flags & G_IO_FLAG_NONBLOCK)
+#ifdef O_NONBLOCK
+ fcntl_flags |= O_NONBLOCK;
+#else
+ fcntl_flags |= O_NDELAY;
+#endif
+
+ if (fcntl (unix_channel->fd, F_SETFL, fcntl_flags) == -1)
+ {
+ g_set_error (err, G_IO_CHANNEL_ERROR,
+ g_io_channel_error_from_errno (errno),
+ g_strerror (errno));
+ return G_IO_STATUS_ERROR;
+ }
+
+ return G_IO_STATUS_NORMAL;
+}
+
+static GIOFlags
+g_io_unix_get_flags (GIOChannel *channel)
+{
+ GIOFlags flags = 0;
+ glong fcntl_flags;
+ GIOUnixChannel *unix_channel = (GIOUnixChannel *) channel;
+
+ fcntl_flags = fcntl (unix_channel->fd, F_GETFL);
+
+ if (fcntl_flags == -1)
+ {
+ g_warning (G_STRLOC "Error while getting flags for FD: %s (%d)\n",
+ g_strerror (errno), errno);
+ return 0;
+ }
+
+ if (fcntl_flags & O_APPEND)
+ flags |= G_IO_FLAG_APPEND;
+#ifdef O_NONBLOCK
+ if (fcntl_flags & O_NONBLOCK)
+#else
+ if (fcntl_flags & O_NDELAY)
+#endif
+ flags |= G_IO_FLAG_NONBLOCK;
+
+ switch (fcntl_flags & (O_RDONLY | O_WRONLY | O_RDWR))
+ {
+ case O_RDONLY:
+ channel->is_readable = TRUE;
+ channel->is_writeable = FALSE;
+ break;
+ case O_WRONLY:
+ channel->is_readable = FALSE;
+ channel->is_writeable = TRUE;
+ break;
+ case O_RDWR:
+ channel->is_readable = TRUE;
+ channel->is_writeable = TRUE;
+ break;
+ default:
+ g_assert_not_reached ();
+ }
+
+ return flags;
+}
+
+GIOChannel *
+g_io_channel_new_file (const gchar *filename,
+ const gchar *mode,
+ GError **error)
+{
+ int fid, flags;
+ mode_t create_mode;
+ GIOChannel *channel;
+ enum { /* Cheesy hack */
+ MODE_R = 1 << 0,
+ MODE_W = 1 << 1,
+ MODE_A = 1 << 2,
+ MODE_PLUS = 1 << 3
+ } mode_num;
+ struct stat buffer;
+
+ g_return_val_if_fail (filename != NULL, NULL);
+ g_return_val_if_fail (mode != NULL, NULL);
+ g_return_val_if_fail ((error == NULL) || (*error == NULL), NULL);
+
+ switch (mode[0])
+ {
+ case 'r':
+ mode_num = MODE_R;
+ break;
+ case 'w':
+ mode_num = MODE_W;
+ break;
+ case 'a':
+ mode_num = MODE_A;
+ break;
+ default:
+ g_warning ("Invalid GIOFileMode %s.\n", mode);
+ return NULL;
+ }
+
+ switch (mode[1])
+ {
+ case '\0':
+ break;
+ case '+':
+ if (mode[2] == '\0')
+ {
+ mode_num |= MODE_PLUS;
+ break;
+ }
+ /* Fall through */
+ default:
+ g_warning ("Invalid GIOFileMode %s.\n", mode);
+ return NULL;
+ }
+
+ switch (mode_num)
+ {
+ case MODE_R:
+ flags = O_RDONLY;
+ break;
+ case MODE_W:
+ flags = O_WRONLY | O_TRUNC | O_CREAT;
+ break;
+ case MODE_A:
+ flags = O_WRONLY | O_APPEND | O_CREAT;
+ break;
+ case MODE_R | MODE_PLUS:
+ flags = O_RDWR;
+ break;
+ case MODE_W | MODE_PLUS:
+ flags = O_RDWR | O_TRUNC | O_CREAT;
+ break;
+ case MODE_A | MODE_PLUS:
+ flags = O_RDWR | O_APPEND | O_CREAT;
+ break;
+ default:
+ g_assert_not_reached ();
+ flags = 0;
+ }
+
+ create_mode = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH;
+ fid = open (filename, flags, create_mode);
+ if (fid == -1)
+ {
+ g_set_error (error, G_FILE_ERROR,
+ g_file_error_from_errno (errno),
+ g_strerror (errno));
+ return (GIOChannel *)NULL;
+ }
+
+ if (fstat (fid, &buffer) == -1) /* In case someone opens a FIFO */
+ {
+ close (fid);
+ g_set_error (error, G_FILE_ERROR,
+ g_file_error_from_errno (errno),
+ g_strerror (errno));
+ return (GIOChannel *)NULL;
+ }
+
+ channel = (GIOChannel *) g_new (GIOUnixChannel, 1);
+
+ channel->is_seekable = S_ISREG (buffer.st_mode) || S_ISCHR (buffer.st_mode)
+ || S_ISBLK (buffer.st_mode);
+
+ switch (mode_num)
+ {
+ case MODE_R:
+ channel->is_readable = TRUE;
+ channel->is_writeable = FALSE;
+ break;
+ case MODE_W:
+ case MODE_A:
+ channel->is_readable = FALSE;
+ channel->is_writeable = TRUE;
+ break;
+ case MODE_R | MODE_PLUS:
+ case MODE_W | MODE_PLUS:
+ case MODE_A | MODE_PLUS:
+ channel->is_readable = TRUE;
+ channel->is_writeable = TRUE;
+ break;
+ default:
+ g_assert_not_reached ();
+ }
+
+ g_io_channel_init (channel);
+ channel->close_on_unref = TRUE; /* must be after g_io_channel_init () */
+ channel->funcs = &unix_channel_funcs;
+
+ ((GIOUnixChannel *) channel)->fd = fid;
+ return channel;
}
GIOChannel *
g_io_channel_unix_new (gint fd)
{
+ struct stat buffer;
GIOUnixChannel *unix_channel = g_new (GIOUnixChannel, 1);
GIOChannel *channel = (GIOChannel *)unix_channel;
channel->funcs = &unix_channel_funcs;
unix_channel->fd = fd;
+
+ /* I'm not sure if fstat on a non-file (e.g., socket) works
+ * it should be safe to say if it fails, the fd isn't seekable.
+ */
+ /* Newer UNIX versions support S_ISSOCK(), fstat() will probably
+ * succeed in most cases.
+ */
+ if (fstat (unix_channel->fd, &buffer) == 0)
+ channel->is_seekable = S_ISREG (buffer.st_mode) || S_ISCHR (buffer.st_mode)
+ || S_ISBLK (buffer.st_mode);
+ else /* Assume not seekable */
+ channel->is_seekable = FALSE;
+
+ g_io_unix_get_flags (channel); /* Sets is_readable, is_writeable */
+
return channel;
}