/**
* cockpit_web_response_complete:
* @self: the response
*
* See cockpit_web_response_content() for easy to use stuff.
*
* Tell the response that all the data has been queued.
* The response will hold a reference to itself until the
* data is actually sent, so you can unref it.
*/
void
cockpit_web_response_complete (CockpitWebResponse *self)
{
GBytes *bytes;
g_return_if_fail (COCKPIT_IS_WEB_RESPONSE (self));
g_return_if_fail (self->complete == FALSE);
if (self->failed)
return;
/* Hold a reference until cockpit_web_response_done() */
g_object_ref (self);
self->complete = TRUE;
if (self->chunked)
{
bytes = g_bytes_new_static ("0\r\n\r\n", 5);
queue_bytes (self, bytes);
g_bytes_unref (bytes);
}
if (self->source)
{
g_debug ("%s: queueing complete", self->logname);
}
else
{
g_debug ("%s: complete closing io", self->logname);
g_output_stream_flush_async (G_OUTPUT_STREAM (self->out), G_PRIORITY_DEFAULT,
NULL, on_output_flushed, g_object_ref (self));
}
}
static void setup_async_write(struct ekg_connection *c) {
g_output_stream_flush_async(
G_OUTPUT_STREAM(c->outstream),
G_PRIORITY_DEFAULT,
c->cancellable, /* XXX */
done_async_write,
c);
}
static void
g_filter_output_stream_flush_async (GOutputStream *stream,
int io_priority,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer data)
{
GFilterOutputStream *filter_stream;
filter_stream = G_FILTER_OUTPUT_STREAM (stream);
g_output_stream_flush_async (filter_stream->base_stream,
io_priority,
cancellable,
callback,
data);
}
/* Called by gpgme to write data */
static ssize_t
vfs_data_write (void *handle, const void *buffer, size_t size)
{
VfsAsyncHandle* ah = (VfsAsyncHandle*)handle;
ssize_t sz = 0;
/* If the file isn't open yet, then do that now */
if (!ah->ostream && ah->state == VFS_ASYNC_READY)
vfs_data_open_helper (ah);
/* Just in case we have an operation, like open */
if (!vfs_data_wait_results(ah, TRUE))
return -1;
g_assert (ah->state == VFS_ASYNC_READY);
/* Start async operation */
ah->buffer = (gpointer)buffer;
ah->state = VFS_ASYNC_PROCESSING;
ah->operation = VFS_OP_WRITING;
g_output_stream_write_async (ah->ostream, buffer, size, G_PRIORITY_DEFAULT, ah->cancellable, vfs_data_write_done, ah);
/* Wait for it */
if (!vfs_data_wait_results(ah, TRUE))
return -1;
/* Return results */
sz = (ssize_t)ah->processed;
ah->buffer = NULL;
ah->processed = 0;
/* Sadly GPGME doesn't support errors on close, so we have to flush after each write */
ah->state = VFS_ASYNC_PROCESSING;
ah->operation = VFS_OP_FLUSHING;
g_output_stream_flush_async (ah->ostream, G_PRIORITY_DEFAULT, ah->cancellable, vfs_data_flush_done, ah);
/* Wait for it */
if (!vfs_data_wait_results(ah, TRUE))
return -1;
return sz;
}
static VALUE
rg_flush_async(int argc, VALUE *argv, VALUE self)
{
VALUE rbio_priority, rbcancellable, block;
int io_priority;
GCancellable *cancellable;
rb_scan_args(argc, argv, "02&", &rbio_priority, &rbcancellable, &block);
io_priority = RVAL2IOPRIORITYDEFAULT(rbio_priority);
cancellable = RVAL2GCANCELLABLE(rbcancellable);
SAVE_BLOCK(block);
g_output_stream_flush_async(_SELF(self),
io_priority,
cancellable,
rbgio_async_ready_callback,
(gpointer)block);
return self;
}
static gboolean
on_response_output (GObject *pollable,
gpointer user_data)
{
CockpitWebResponse *self = user_data;
GError *error = NULL;
const guint8 *data;
GBytes *block;
gssize count;
gsize len;
block = g_queue_peek_head (self->queue);
if (block)
{
data = g_bytes_get_data (block, &len);
g_assert (len == 0 || self->partial_offset < len);
data += self->partial_offset;
len -= self->partial_offset;
if (len > 0)
{
count = g_pollable_output_stream_write_nonblocking (self->out, data, len,
NULL, &error);
}
else
{
count = 0;
}
if (count < 0)
{
if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_WOULD_BLOCK))
{
g_error_free (error);
return TRUE;
}
if (!cockpit_web_should_suppress_output_error (self->logname, error))
g_message ("%s: couldn't write web output: %s", self->logname, error->message);
self->failed = TRUE;
cockpit_web_response_done (self);
g_error_free (error);
return FALSE;
}
if (count == len)
{
g_debug ("%s: sent %d bytes", self->logname, (int)len);
self->partial_offset = 0;
g_queue_pop_head (self->queue);
g_bytes_unref (block);
}
else
{
g_debug ("%s: sent %d partial", self->logname, (int)count);
g_assert (count < len);
self->partial_offset += count;
}
return TRUE;
}
else
{
g_source_destroy (self->source);
g_source_unref (self->source);
self->source = NULL;
if (self->complete)
{
g_debug ("%s: complete flushing output", self->logname);
g_output_stream_flush_async (G_OUTPUT_STREAM (self->out), G_PRIORITY_DEFAULT,
NULL, on_output_flushed, g_object_ref (self));
}
return FALSE;
}
}