static void
async_write_data_cb (GObject *object,
GAsyncResult *res,
gpointer user_data)
{
AsyncWriteData *write_data = user_data;
GError *error = NULL;
gsize bytes_written;
bytes_written = g_output_stream_write_finish (G_OUTPUT_STREAM (object),
res, &error);
if (error)
{
g_warning ("Error writing selection data: %s", error->message);
g_error_free (error);
async_write_data_free (write_data);
return;
}
write_data->index += bytes_written;
if (write_data->index <
write_data->selection->stored_selection.data_len)
{
/* Write the next chunk */
async_write_data_write (write_data);
}
else
async_write_data_free (write_data);
}
static void
write_ready_cb (GObject *source, GAsyncResult *result, SoupCacheInputStream *istream)
{
GOutputStream *ostream = G_OUTPUT_STREAM (source);
SoupCacheInputStreamPrivate *priv = istream->priv;
gssize write_size;
gsize pending;
GError *error = NULL;
write_size = g_output_stream_write_finish (ostream, result, &error);
if (error) {
notify_and_clear (istream, error);
g_object_unref (istream);
return;
}
/* Check that we have written everything */
pending = priv->current_writing_buffer->length - write_size;
if (pending) {
SoupBuffer *subbuffer = soup_buffer_new_subbuffer (priv->current_writing_buffer,
write_size, pending);
g_queue_push_head (priv->buffer_queue, subbuffer);
}
priv->bytes_written += write_size;
g_clear_pointer (&priv->current_writing_buffer, soup_buffer_free);
try_write_next_buffer (istream);
g_object_unref (istream);
}
static void
msg_write_cb(GObject *source_object,
GAsyncResult *res,
gpointer user_data)
{
SpiceVDAgent *self = SPICE_VDAGENT(user_data);
GError *error = NULL;
Msg *msg;
gssize ret;
msg = g_queue_peek_head(self->outq);
g_return_if_fail(msg != NULL);
ret = g_output_stream_write_finish(G_OUTPUT_STREAM(source_object), res, &error);
self->writing = FALSE;
if (ret == -1) {
g_warning("failed to write: %s", error->message);
g_clear_error(&error);
} else {
self->pos += ret;
g_assert(self->pos <= msg->size);
g_debug("wrote %" G_GSSIZE_FORMAT "/%" G_GSSIZE_FORMAT, self->pos, msg->size);
if (self->pos == msg->size) {
if (msg->free_func)
msg->free_func(msg->data);
g_slice_free(Msg, g_queue_pop_head(self->outq));
self->pos = 0;
}
kick_write(self);
}
}
static void
identd_write_ready (GOutputStream *stream, GAsyncResult *res, ident_info *info)
{
g_output_stream_write_finish (stream, res, NULL);
ident_info_free (info);
}
static void _write_ready(GObject *source_object, GAsyncResult *res, gpointer user_data) {
GOutputStream *output_stream = G_OUTPUT_STREAM(source_object);
GSimpleAsyncResult *result = G_SIMPLE_ASYNC_RESULT(user_data);
IdleServerConnection *conn = IDLE_SERVER_CONNECTION(g_async_result_get_source_object(G_ASYNC_RESULT(result)));
IdleServerConnectionPrivate *priv = IDLE_SERVER_CONNECTION_GET_PRIVATE(conn);
gssize nwrite;
GError *error = NULL;
g_object_unref(conn);
nwrite = g_output_stream_write_finish(output_stream, res, &error);
if (nwrite == -1) {
IDLE_DEBUG("g_output_stream_write failed : %s", error->message);
g_simple_async_result_set_error(result, TP_ERROR, TP_ERROR_NETWORK_ERROR, "%s", error->message);
g_error_free(error);
goto cleanup;
}
priv->nwritten += nwrite;
if (priv->nwritten < priv->count) {
g_output_stream_write_async(output_stream, priv->output_buffer + priv->nwritten, priv->count - priv->nwritten, G_PRIORITY_DEFAULT, priv->cancellable, _write_ready, result);
return;
}
cleanup:
if (priv->cancellable != NULL) {
g_object_unref(priv->cancellable);
priv->cancellable = NULL;
}
g_simple_async_result_complete(result);
g_object_unref(result);
}
static void
identd_write_ready (GOutputStream *stream, GAsyncResult *res, ident_info *info)
{
g_output_stream_write_finish (stream, res, NULL);
g_free (info->username);
g_object_unref (info->conn);
g_free (info);
}
static gssize
g_filter_output_stream_write_finish (GOutputStream *stream,
GAsyncResult *result,
GError **error)
{
GFilterOutputStream *filter_stream;
gssize nwritten;
filter_stream = G_FILTER_OUTPUT_STREAM (stream);
nwritten = g_output_stream_write_finish (filter_stream->base_stream,
result,
error);
return nwritten;
}
static void
tunnel_wrote_cb (GObject *object,
GAsyncResult *result,
gpointer user_data)
{
Tunnel *tunnel = user_data;
TunnelEnd *write_end, *read_end;
GError *error = NULL;
gssize nwrote;
nwrote = g_output_stream_write_finish (G_OUTPUT_STREAM (object), result, &error);
if (nwrote <= 0) {
if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) {
g_error_free (error);
return;
} else if (error) {
g_print ("Tunnel write failed: %s\n", error->message);
g_error_free (error);
}
tunnel_close (tunnel);
return;
}
if (object == (GObject *)tunnel->client.ostream) {
write_end = &tunnel->client;
read_end = &tunnel->server;
} else {
write_end = &tunnel->server;
read_end = &tunnel->client;
}
write_end->nwrote += nwrote;
if (write_end->nwrote < read_end->nread) {
g_output_stream_write_async (write_end->ostream,
read_end->buffer + write_end->nwrote,
read_end->nread - write_end->nwrote,
G_PRIORITY_DEFAULT, tunnel->cancellable,
tunnel_wrote_cb, tunnel);
} else {
g_input_stream_read_async (read_end->istream,
read_end->buffer, BUFSIZE,
G_PRIORITY_DEFAULT, tunnel->cancellable,
tunnel_read_cb, tunnel);
}
}
/* Called when a write completes */
static void
vfs_data_write_done (GObject *source, GAsyncResult *res, gpointer callback_data)
{
VfsAsyncHandle* ah = (VfsAsyncHandle*)callback_data;
if(ah->state == VFS_ASYNC_PROCESSING) {
g_assert (ah->operation == VFS_OP_WRITING);
g_clear_error (&ah->error);
ah->processed = g_output_stream_write_finish (ah->ostream, res, &ah->error);
ah->state = VFS_ASYNC_READY;
ah->total += ah->processed;
/* Call progress callback if setup */
if (ah->progcb && ah->total >= ah->last + PROGRESS_BLOCK)
(ah->progcb) (ah->gdata, ah->total, ah->userdata);
}
}
static void outputStreamWriteReadyCallback(GOutputStream* stream, GAsyncResult* result, gpointer userData)
{
std::unique_ptr<WriteAsyncData> asyncData(static_cast<WriteAsyncData*>(userData));
gssize bytesWritten = g_output_stream_write_finish(stream, result, nullptr);
if (bytesWritten == -1) {
asyncData->completionHandler(-1);
return;
}
gssize pendingBytesToWrite = asyncData->buffer->length - bytesWritten;
if (!pendingBytesToWrite) {
asyncData->completionHandler(0);
return;
}
asyncData->buffer = adoptGRef(soup_buffer_new_subbuffer(asyncData->buffer.get(), bytesWritten, pendingBytesToWrite));
// Use a local variable for the data buffer to pass it to g_output_stream_write_async(), because WriteAsyncData is released.
auto data = asyncData->buffer->data;
g_output_stream_write_async(stream, data, pendingBytesToWrite, G_PRIORITY_DEFAULT, nullptr,
reinterpret_cast<GAsyncReadyCallback>(outputStreamWriteReadyCallback), asyncData.release());
}
static void
on_outputstream_write_ready (GObject *source, GAsyncResult *res, gpointer user_data)
{
GcrCertificateExporter *self = GCR_CERTIFICATE_EXPORTER (user_data);
GOutputStream *os = G_OUTPUT_STREAM (source);
gssize written;
written = g_output_stream_write_finish (os, res, &self->pv->error);
if (self->pv->error) {
complete_async_result (self);
return;
}
g_return_if_fail (written >= 0);
g_return_if_fail (written <= self->pv->buffer->len - self->pv->buffer_at);
self->pv->buffer_at += written;
/* Write next bit, or finished */
write_to_outputstream (self, os);
}
//------------------------------------------------------------------------------
void onWritten(GObject* srcObject,
GAsyncResult *res,
gpointer userData)
{
GError *err = NULL;
int count;
count = g_output_stream_write_finish(ostream,
res,
&err);
if (count == -1) {
g_error ("Error when writing message");
if (err != NULL) {
g_error("%s", err->message);
g_clear_error(&err);
}
return;
}
if (count == 0) {
g_print("write connection closed");
return;
}
}
static void
connect_msg_write_cb (GObject *source,
GAsyncResult *result,
gpointer user_data)
{
GTask *task = user_data;
ConnectAsyncData *data = g_task_get_task_data (task);
GError *error = NULL;
gssize written;
written = g_output_stream_write_finish (G_OUTPUT_STREAM (source),
result, &error);
if (written < 0)
{
g_task_return_error (task, error);
g_object_unref (task);
return;
}
data->offset += written;
if (data->offset == data->length)
{
g_free (data->buffer);
data->buffer = g_malloc0 (SOCKS4_CONN_REP_LEN);
data->length = SOCKS4_CONN_REP_LEN;
data->offset = 0;
do_read (connect_reply_read_cb, task, data);
}
else
{
do_write (connect_msg_write_cb, task, data);
}
}
static void
write_all_cb (GObject *source_object,
GAsyncResult *res,
gpointer user_data)
{
GOutputStream *stream = G_OUTPUT_STREAM (source_object);
GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (user_data);
gssize bytes_written;
GError *err = NULL;
WriteAllData *write_data;
bytes_written = g_output_stream_write_finish (stream, res, &err);
if (bytes_written == -1)
{
g_simple_async_result_take_error (simple, err);
goto done;
}
write_data = g_simple_async_result_get_op_res_gpointer (simple);
write_data->bytes_written += bytes_written;
if (write_data->bytes_written < write_data->count)
{
g_output_stream_write_async (stream,
(const guint8 *)write_data->buffer + write_data->bytes_written,
write_data->count - write_data->bytes_written,
write_data->io_priority, write_data->cancellable,
write_all_cb, simple);
return;
}
done:
g_simple_async_result_complete (simple);
g_object_unref (simple);
}
