glib/gio/gpollableoutputstream.c

393 lines
14 KiB
C
Raw Normal View History

/* GIO - GLib Input, Output and Streaming Library
*
* Copyright (C) 2010 Red Hat, Inc.
*
* SPDX-License-Identifier: LGPL-2.1-or-later
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General
2014-01-23 12:58:29 +01:00
* Public License along with this library; if not, see <http://www.gnu.org/licenses/>.
*/
#include "config.h"
#include <errno.h>
#include "gpollableoutputstream.h"
#include "gasynchelper.h"
#include "gfiledescriptorbased.h"
#include "glibintl.h"
/**
* GPollableOutputStream:
*
* `GPollableOutputStream` is implemented by [class@Gio.OutputStream]s that
* can be polled for readiness to write. This can be used when
2010-11-29 05:55:43 +01:00
* interfacing with a non-GIO API that expects
* UNIX-file-descriptor-style asynchronous I/O rather than GIO-style.
*
* Some classes may implement `GPollableOutputStream` but have only certain
* instances of that class be pollable. If [method@Gio.PollableOutputStream.can_poll]
* returns false, then the behavior of other `GPollableOutputStream` methods is
* undefined.
*
* Since: 2.28
*/
G_DEFINE_INTERFACE (GPollableOutputStream, g_pollable_output_stream, G_TYPE_OUTPUT_STREAM)
static gboolean g_pollable_output_stream_default_can_poll (GPollableOutputStream *stream);
static gssize g_pollable_output_stream_default_write_nonblocking (GPollableOutputStream *stream,
const void *buffer,
gsize count,
GError **error);
static GPollableReturn g_pollable_output_stream_default_writev_nonblocking (GPollableOutputStream *stream,
const GOutputVector *vectors,
gsize n_vectors,
gsize *bytes_written,
GError **error);
static void
g_pollable_output_stream_default_init (GPollableOutputStreamInterface *iface)
{
iface->can_poll = g_pollable_output_stream_default_can_poll;
iface->write_nonblocking = g_pollable_output_stream_default_write_nonblocking;
iface->writev_nonblocking = g_pollable_output_stream_default_writev_nonblocking;
}
static gboolean
g_pollable_output_stream_default_can_poll (GPollableOutputStream *stream)
{
return TRUE;
}
/**
* g_pollable_output_stream_can_poll:
* @stream: a #GPollableOutputStream.
*
* Checks if @stream is actually pollable. Some classes may implement
* #GPollableOutputStream but have only certain instances of that
* class be pollable. If this method returns %FALSE, then the behavior
* of other #GPollableOutputStream methods is undefined.
*
* For any given stream, the value returned by this method is constant;
* a stream cannot switch from pollable to non-pollable or vice versa.
*
* Returns: %TRUE if @stream is pollable, %FALSE if not.
*
* Since: 2.28
*/
gboolean
g_pollable_output_stream_can_poll (GPollableOutputStream *stream)
{
g_return_val_if_fail (G_IS_POLLABLE_OUTPUT_STREAM (stream), FALSE);
return G_POLLABLE_OUTPUT_STREAM_GET_INTERFACE (stream)->can_poll (stream);
}
/**
* g_pollable_output_stream_is_writable:
* @stream: a #GPollableOutputStream.
*
* Checks if @stream can be written.
*
* Note that some stream types may not be able to implement this 100%
* reliably, and it is possible that a call to g_output_stream_write()
* after this returns %TRUE would still block. To guarantee
* non-blocking behavior, you should always use
* g_pollable_output_stream_write_nonblocking(), which will return a
* %G_IO_ERROR_WOULD_BLOCK error rather than blocking.
*
* The behaviour of this method is undefined if
* g_pollable_output_stream_can_poll() returns %FALSE for @stream.
*
* Returns: %TRUE if @stream is writable, %FALSE if not. If an error
* has occurred on @stream, this will result in
* g_pollable_output_stream_is_writable() returning %TRUE, and the
* next attempt to write will return the error.
*
* Since: 2.28
*/
gboolean
g_pollable_output_stream_is_writable (GPollableOutputStream *stream)
{
g_return_val_if_fail (G_IS_POLLABLE_OUTPUT_STREAM (stream), FALSE);
return G_POLLABLE_OUTPUT_STREAM_GET_INTERFACE (stream)->is_writable (stream);
}
/**
* g_pollable_output_stream_create_source:
* @stream: a #GPollableOutputStream.
* @cancellable: (nullable): a #GCancellable, or %NULL
*
* Creates a #GSource that triggers when @stream can be written, or
* @cancellable is triggered or an error occurs. The callback on the
* source is of the #GPollableSourceFunc type.
*
* As with g_pollable_output_stream_is_writable(), it is possible that
* the stream may not actually be writable even after the source
2010-11-29 05:55:43 +01:00
* triggers, so you should use g_pollable_output_stream_write_nonblocking()
* rather than g_output_stream_write() from the callback.
*
* The behaviour of this method is undefined if
* g_pollable_output_stream_can_poll() returns %FALSE for @stream.
*
* Returns: (transfer full): a new #GSource
*
* Since: 2.28
*/
GSource *
g_pollable_output_stream_create_source (GPollableOutputStream *stream,
GCancellable *cancellable)
{
g_return_val_if_fail (G_IS_POLLABLE_OUTPUT_STREAM (stream), NULL);
return G_POLLABLE_OUTPUT_STREAM_GET_INTERFACE (stream)->
create_source (stream, cancellable);
}
static gssize
g_pollable_output_stream_default_write_nonblocking (GPollableOutputStream *stream,
const void *buffer,
gsize count,
GError **error)
{
if (!g_pollable_output_stream_is_writable (stream))
{
g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_WOULD_BLOCK,
g_strerror (EAGAIN));
return -1;
}
return G_OUTPUT_STREAM_GET_CLASS (stream)->
write_fn (G_OUTPUT_STREAM (stream), buffer, count, NULL, error);
}
static GPollableReturn
g_pollable_output_stream_default_writev_nonblocking (GPollableOutputStream *stream,
const GOutputVector *vectors,
gsize n_vectors,
gsize *bytes_written,
GError **error)
{
gsize _bytes_written = 0;
GPollableOutputStreamInterface *iface = G_POLLABLE_OUTPUT_STREAM_GET_INTERFACE (stream);
gsize i;
GError *err = NULL;
for (i = 0; i < n_vectors; i++)
{
gssize res;
/* Would we overflow here? In that case simply return and let the caller
* handle this like a short write */
if (_bytes_written > G_MAXSIZE - vectors[i].size)
break;
res = iface->write_nonblocking (stream, vectors[i].buffer, vectors[i].size, &err);
if (res == -1)
{
if (bytes_written)
*bytes_written = _bytes_written;
/* If something was written already we handle this like a short
* write and assume that the next call would either give the same
* error again or successfully finish writing without errors or data
* loss
*/
if (_bytes_written > 0)
{
g_clear_error (&err);
return G_POLLABLE_RETURN_OK;
}
else if (g_error_matches (err, G_IO_ERROR, G_IO_ERROR_WOULD_BLOCK))
{
g_clear_error (&err);
return G_POLLABLE_RETURN_WOULD_BLOCK;
}
else
{
g_propagate_error (error, err);
return G_POLLABLE_RETURN_FAILED;
}
}
_bytes_written += res;
/* if we had a short write break the loop here */
if ((gsize) res < vectors[i].size)
break;
}
if (bytes_written)
*bytes_written = _bytes_written;
return G_POLLABLE_RETURN_OK;
}
/**
* g_pollable_output_stream_write_nonblocking: (virtual write_nonblocking)
* @stream: a #GPollableOutputStream
* @buffer: (array length=count) (element-type guint8): a buffer to write
* data from
* @count: the number of bytes you want to write
* @cancellable: (nullable): a #GCancellable, or %NULL
* @error: #GError for error reporting, or %NULL to ignore.
*
* Attempts to write up to @count bytes from @buffer to @stream, as
* with g_output_stream_write(). If @stream is not currently writable,
* this will immediately return %G_IO_ERROR_WOULD_BLOCK, and you can
* use g_pollable_output_stream_create_source() to create a #GSource
* that will be triggered when @stream is writable.
*
* Note that since this method never blocks, you cannot actually
* use @cancellable to cancel it. However, it will return an error
* if @cancellable has already been cancelled when you call, which
* may happen if you call this method after a source triggers due
* to having been cancelled.
*
* Also note that if %G_IO_ERROR_WOULD_BLOCK is returned some underlying
* transports like D/TLS require that you re-send the same @buffer and
* @count in the next write call.
*
* The behaviour of this method is undefined if
* g_pollable_output_stream_can_poll() returns %FALSE for @stream.
*
* Returns: the number of bytes written, or -1 on error (including
* %G_IO_ERROR_WOULD_BLOCK).
*/
gssize
g_pollable_output_stream_write_nonblocking (GPollableOutputStream *stream,
const void *buffer,
gsize count,
GCancellable *cancellable,
GError **error)
{
gssize res;
g_return_val_if_fail (G_IS_POLLABLE_OUTPUT_STREAM (stream), -1);
g_return_val_if_fail (buffer != NULL, 0);
if (g_cancellable_set_error_if_cancelled (cancellable, error))
return -1;
if (count == 0)
return 0;
if (((gssize) count) < 0)
{
g_set_error (error, G_IO_ERROR, G_IO_ERROR_INVALID_ARGUMENT,
_("Too large count value passed to %s"), G_STRFUNC);
return -1;
}
if (cancellable)
g_cancellable_push_current (cancellable);
res = G_POLLABLE_OUTPUT_STREAM_GET_INTERFACE (stream)->
write_nonblocking (stream, buffer, count, error);
if (cancellable)
g_cancellable_pop_current (cancellable);
return res;
}
/**
* g_pollable_output_stream_writev_nonblocking: (virtual writev_nonblocking)
* @stream: a #GPollableOutputStream
* @vectors: (array length=n_vectors): the buffer containing the #GOutputVectors to write.
* @n_vectors: the number of vectors to write
* @bytes_written: (out) (optional): location to store the number of bytes that were
* written to the stream
* @cancellable: (nullable): a #GCancellable, or %NULL
* @error: #GError for error reporting, or %NULL to ignore.
*
* Attempts to write the bytes contained in the @n_vectors @vectors to @stream,
* as with g_output_stream_writev(). If @stream is not currently writable,
* this will immediately return %@G_POLLABLE_RETURN_WOULD_BLOCK, and you can
* use g_pollable_output_stream_create_source() to create a #GSource
* that will be triggered when @stream is writable. @error will *not* be
* set in that case.
*
* Note that since this method never blocks, you cannot actually
* use @cancellable to cancel it. However, it will return an error
* if @cancellable has already been cancelled when you call, which
* may happen if you call this method after a source triggers due
* to having been cancelled.
*
* Also note that if %G_POLLABLE_RETURN_WOULD_BLOCK is returned some underlying
* transports like D/TLS require that you re-send the same @vectors and
* @n_vectors in the next write call.
*
* The behaviour of this method is undefined if
* g_pollable_output_stream_can_poll() returns %FALSE for @stream.
*
* Returns: %@G_POLLABLE_RETURN_OK on success, %G_POLLABLE_RETURN_WOULD_BLOCK
* if the stream is not currently writable (and @error is *not* set), or
* %G_POLLABLE_RETURN_FAILED if there was an error in which case @error will
* be set.
*
* Since: 2.60
*/
GPollableReturn
g_pollable_output_stream_writev_nonblocking (GPollableOutputStream *stream,
const GOutputVector *vectors,
gsize n_vectors,
gsize *bytes_written,
GCancellable *cancellable,
GError **error)
{
GPollableOutputStreamInterface *iface;
GPollableReturn res;
gsize _bytes_written = 0;
if (bytes_written)
*bytes_written = 0;
g_return_val_if_fail (G_IS_POLLABLE_OUTPUT_STREAM (stream), G_POLLABLE_RETURN_FAILED);
g_return_val_if_fail (vectors != NULL || n_vectors == 0, G_POLLABLE_RETURN_FAILED);
g_return_val_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable), G_POLLABLE_RETURN_FAILED);
g_return_val_if_fail (error == NULL || *error == NULL, G_POLLABLE_RETURN_FAILED);
if (g_cancellable_set_error_if_cancelled (cancellable, error))
return G_POLLABLE_RETURN_FAILED;
if (n_vectors == 0)
return G_POLLABLE_RETURN_OK;
iface = G_POLLABLE_OUTPUT_STREAM_GET_INTERFACE (stream);
g_return_val_if_fail (iface->writev_nonblocking != NULL, G_POLLABLE_RETURN_FAILED);
if (cancellable)
g_cancellable_push_current (cancellable);
res = iface->
writev_nonblocking (stream, vectors, n_vectors, &_bytes_written, error);
if (cancellable)
g_cancellable_pop_current (cancellable);
if (res == G_POLLABLE_RETURN_FAILED)
g_warn_if_fail (error == NULL || (*error != NULL && !g_error_matches (*error, G_IO_ERROR, G_IO_ERROR_WOULD_BLOCK)));
else if (res == G_POLLABLE_RETURN_WOULD_BLOCK)
g_warn_if_fail (error == NULL || *error == NULL);
/* in case of not-OK nothing must've been written */
g_warn_if_fail (res == G_POLLABLE_RETURN_OK || _bytes_written == 0);
if (bytes_written)
*bytes_written = _bytes_written;
return res;
}