GSource *
soup_message_io_get_source (SoupMessage *msg, GCancellable *cancellable,
SoupMessageSourceFunc callback, gpointer user_data)
{
SoupMessagePrivate *priv = SOUP_MESSAGE_GET_PRIVATE (msg);
SoupMessageIOData *io = priv->io_data;
GSource *base_source, *source;
SoupMessageSource *message_source;
if (!io) {
base_source = g_timeout_source_new (0);
} else if (io->paused) {
base_source = NULL;
} else if (io->async_close_wait) {
base_source = g_cancellable_source_new (io->async_close_wait);
} else if (SOUP_MESSAGE_IO_STATE_POLLABLE (io->read_state)) {
GPollableInputStream *istream;
if (io->body_istream)
istream = G_POLLABLE_INPUT_STREAM (io->body_istream);
else
istream = G_POLLABLE_INPUT_STREAM (io->istream);
base_source = g_pollable_input_stream_create_source (istream, cancellable);
} else if (SOUP_MESSAGE_IO_STATE_POLLABLE (io->write_state)) {
GPollableOutputStream *ostream;
if (io->body_ostream)
ostream = G_POLLABLE_OUTPUT_STREAM (io->body_ostream);
else
ostream = G_POLLABLE_OUTPUT_STREAM (io->ostream);
base_source = g_pollable_output_stream_create_source (ostream, cancellable);
} else
base_source = g_timeout_source_new (0);
source = g_source_new (&message_source_funcs,
sizeof (SoupMessageSource));
g_source_set_name (source, "SoupMessageSource");
message_source = (SoupMessageSource *)source;
message_source->msg = g_object_ref (msg);
message_source->paused = io && io->paused;
if (base_source) {
g_source_set_dummy_callback (base_source);
g_source_add_child_source (source, base_source);
g_source_unref (base_source);
}
g_source_set_callback (source, (GSourceFunc) callback, user_data, NULL);
return source;
}
static gboolean do_console_raw_console_write(GObject *stream,
gpointer opaque)
{
GUnixOutputStream *consoleOutput = G_UNIX_OUTPUT_STREAM(stream);
GVirSandboxConsoleRaw *console = GVIR_SANDBOX_CONSOLE_RAW(opaque);
GVirSandboxConsoleRawPrivate *priv = console->priv;
GError *err = NULL;
gssize ret = g_pollable_output_stream_write_nonblocking
(G_POLLABLE_OUTPUT_STREAM(consoleOutput),
priv->consoleToLocal,
priv->consoleToLocalOffset,
NULL, &err);
if (ret < 0) {
g_debug("Error from console write %s", err ? err->message : "");
do_console_raw_close(console, err);
g_error_free(err);
goto cleanup;
}
if (priv->consoleToLocalOffset != ret)
memmove(priv->consoleToLocal,
priv->consoleToLocal + ret,
priv->consoleToLocalOffset - ret);
priv->consoleToLocalOffset -= ret;
priv->consoleOutputSource = NULL;
do_console_raw_update_events(console);
cleanup:
return FALSE;
}
static void
initialize_io (CockpitStream *self)
{
GInputStream *is;
GOutputStream *os;
g_return_if_fail (self->priv->in_source == NULL);
is = g_io_stream_get_input_stream (self->priv->io);
os = g_io_stream_get_output_stream (self->priv->io);
if (!G_IS_POLLABLE_INPUT_STREAM (is) ||
!g_pollable_input_stream_can_poll (G_POLLABLE_INPUT_STREAM (is)) ||
!G_IS_POLLABLE_OUTPUT_STREAM (os) ||
!g_pollable_output_stream_can_poll (G_POLLABLE_OUTPUT_STREAM (os)))
{
g_warning ("%s: stream is not pollable", self->priv->name);
close_immediately (self, "internal-error");
return;
}
if (self->priv->connecting)
{
g_object_unref (self->priv->connecting);
self->priv->connecting = NULL;
}
self->priv->in_source = g_pollable_input_stream_create_source (G_POLLABLE_INPUT_STREAM (is), NULL);
g_source_set_name (self->priv->in_source, "stream-input");
g_source_set_callback (self->priv->in_source, (GSourceFunc)dispatch_input, self, NULL);
g_source_attach (self->priv->in_source, self->priv->context);
start_output (self);
}
void SocketStreamHandle::connected(GRefPtr<GSocketConnection>&& socketConnection)
{
m_socketConnection = WTFMove(socketConnection);
m_outputStream = G_POLLABLE_OUTPUT_STREAM(g_io_stream_get_output_stream(G_IO_STREAM(m_socketConnection.get())));
m_inputStream = g_io_stream_get_input_stream(G_IO_STREAM(m_socketConnection.get()));
m_readBuffer = std::make_unique<char[]>(READ_BUFFER_SIZE);
RefPtr<SocketStreamHandle> protectedThis(this);
g_input_stream_read_async(m_inputStream.get(), m_readBuffer.get(), READ_BUFFER_SIZE, G_PRIORITY_DEFAULT, m_cancellable.get(),
reinterpret_cast<GAsyncReadyCallback>(readReadyCallback), protectedThis.leakRef());
m_state = Open;
m_client.didOpenSocketStream(*this);
}
static void
initialize_io (CockpitStream *self)
{
GInputStream *is;
GOutputStream *os;
g_return_if_fail (self->priv->in_source == NULL);
is = g_io_stream_get_input_stream (self->priv->io);
os = g_io_stream_get_output_stream (self->priv->io);
if (!G_IS_POLLABLE_INPUT_STREAM (is) ||
!g_pollable_input_stream_can_poll (G_POLLABLE_INPUT_STREAM (is)) ||
!G_IS_POLLABLE_OUTPUT_STREAM (os) ||
!g_pollable_output_stream_can_poll (G_POLLABLE_OUTPUT_STREAM (os)))
{
g_warning ("%s: stream is not pollable", self->priv->name);
close_immediately (self, "internal-error");
return;
}
if (self->priv->connecting)
{
cockpit_connectable_unref (self->priv->connecting);
self->priv->connecting = NULL;
}
self->priv->in_source = g_pollable_input_stream_create_source (G_POLLABLE_INPUT_STREAM (is), NULL);
g_source_set_name (self->priv->in_source, "stream-input");
g_source_set_callback (self->priv->in_source, (GSourceFunc)dispatch_input, self, NULL);
g_source_attach (self->priv->in_source, self->priv->context);
if (G_IS_TLS_CONNECTION (self->priv->io))
{
self->priv->sig_accept_cert = g_signal_connect (G_TLS_CONNECTION (self->priv->io),
"accept-certificate",
G_CALLBACK (on_rejected_certificate),
self);
}
else
{
self->priv->sig_accept_cert = 0;
}
start_output (self);
g_signal_emit (self, cockpit_stream_sig_open, 0);
}
static void
start_output (CockpitStream *self)
{
GOutputStream *os;
g_assert (self->priv->out_source == NULL);
if (self->priv->connecting || self->priv->out_closed || self->priv->closed)
return;
g_assert (self->priv->io);
os = g_io_stream_get_output_stream (self->priv->io);
self->priv->out_source = g_pollable_output_stream_create_source (G_POLLABLE_OUTPUT_STREAM (os), NULL);
g_source_set_name (self->priv->out_source, "stream-output");
g_source_set_callback (self->priv->out_source, (GSourceFunc)dispatch_output, self, NULL);
g_source_attach (self->priv->out_source, self->priv->context);
}
void SocketStreamHandle::connected(GSocketConnection* socketConnection, GError* error)
{
if (error) {
m_client->didFailSocketStream(this, SocketStreamError(error->code, error->message));
return;
}
m_socketConnection = socketConnection;
m_outputStream = G_POLLABLE_OUTPUT_STREAM(g_io_stream_get_output_stream(G_IO_STREAM(m_socketConnection.get())));
m_inputStream = g_io_stream_get_input_stream(G_IO_STREAM(m_socketConnection.get()));
m_readBuffer = new char[READ_BUFFER_SIZE];
g_input_stream_read_async(m_inputStream.get(), m_readBuffer, READ_BUFFER_SIZE, G_PRIORITY_DEFAULT, 0,
reinterpret_cast<GAsyncReadyCallback>(readReadyCallback), m_id);
m_state = Open;
m_client->didOpenSocketStream(this);
}
static gboolean
source_cancelled_cb (GObject *pollable_stream, gpointer user_data)
{
GMainLoop *main_loop = user_data;
/* Try and check that the callback was invoked due to cancellation rather than
* a poll() event on the socket itself. */
if (G_IS_POLLABLE_INPUT_STREAM (pollable_stream)) {
g_assert (
!g_pollable_input_stream_is_readable (
G_POLLABLE_INPUT_STREAM (pollable_stream)));
} else {
g_assert (
!g_pollable_output_stream_is_writable (
G_POLLABLE_OUTPUT_STREAM (pollable_stream)));
}
g_main_loop_quit (main_loop);
return FALSE;
}
/**
* g_pollable_stream_write:
* @stream: a #GOutputStream.
* @buffer: (array length=count) (element-type guint8): the buffer
* containing the data to write.
* @count: the number of bytes to write
* @blocking: whether to do blocking I/O
* @cancellable: (allow-none): optional #GCancellable object, %NULL to ignore.
* @error: location to store the error occurring, or %NULL to ignore
*
* Tries to write to @stream, as with g_output_stream_write() (if
* @blocking is %TRUE) or g_pollable_output_stream_write_nonblocking()
* (if @blocking is %FALSE). This can be used to more easily share
* code between blocking and non-blocking implementations of a method.
*
* If @blocking is %FALSE, then @stream must be a
* #GPollableOutputStream for which
* g_pollable_output_stream_can_poll() returns %TRUE or else the
* behavior is undefined. If @blocking is %TRUE, then @stream does not
* need to be a #GPollableOutputStream.
*
* Returns: the number of bytes written, or -1 on error.
*
* Since: 2.34
*/
gssize
g_pollable_stream_write (GOutputStream *stream,
const void *buffer,
gsize count,
gboolean blocking,
GCancellable *cancellable,
GError **error)
{
if (blocking)
{
return g_output_stream_write (stream,
buffer, count,
cancellable, error);
}
else
{
return g_pollable_output_stream_write_nonblocking (G_POLLABLE_OUTPUT_STREAM (stream),
buffer, count,
cancellable, error);
}
}
void SocketStreamHandle::connected(GSocketConnection* socketConnection, GError* error)
{
if (error) {
m_client->didFail(this, SocketStreamError(error->code));
return;
}
m_socketConnection = adoptGRef(socketConnection);
m_outputStream = G_POLLABLE_OUTPUT_STREAM(g_io_stream_get_output_stream(G_IO_STREAM(m_socketConnection.get())));
m_inputStream = g_io_stream_get_input_stream(G_IO_STREAM(m_socketConnection.get()));
m_readBuffer = new char[READ_BUFFER_SIZE];
g_input_stream_read_async(m_inputStream.get(), m_readBuffer, READ_BUFFER_SIZE, G_PRIORITY_DEFAULT, 0,
reinterpret_cast<GAsyncReadyCallback>(readReadyCallback), m_id);
// The client can close the handle, potentially removing the last reference.
RefPtr<SocketStreamHandle> protect(this);
m_state = Open;
m_client->didOpen(this);
if (!m_socketConnection) // Client closed the connection.
return;
}
static GSource *
soup_socket_create_watch (SoupSocketPrivate *priv, GIOCondition cond,
GPollableSourceFunc callback, gpointer user_data,
GCancellable *cancellable)
{
GSource *watch;
GMainContext *async_context;
if (cond == G_IO_IN)
watch = g_pollable_input_stream_create_source (G_POLLABLE_INPUT_STREAM (priv->istream), cancellable);
else
watch = g_pollable_output_stream_create_source (G_POLLABLE_OUTPUT_STREAM (priv->ostream), cancellable);
g_source_set_callback (watch, (GSourceFunc)callback, user_data, NULL);
if (priv->use_thread_context)
async_context = g_main_context_get_thread_default ();
else
async_context = priv->async_context;
g_source_attach (watch, async_context);
g_source_unref (watch);
return watch;
}
static void
test_zero_length_reads_writes (NiceAddress *addr)
{
NiceAgent *agent;
guint stream_id;
GIOStream *io_stream;
GInputStream *input_stream;
GOutputStream *output_stream;
GPollableInputStream *pollable_input_stream;
GPollableOutputStream *pollable_output_stream;
GError *error = NULL;
guint8 buf[1]; /* should never be accessed */
agent = nice_agent_new_reliable (NULL, NICE_COMPATIBILITY_RFC5245);
nice_agent_add_local_address (agent, addr);
/* Add a stream. */
stream_id = nice_agent_add_stream (agent, 1);
/* Try building an I/O stream around it. */
io_stream = nice_agent_get_io_stream (agent, stream_id, 1);
g_assert (G_IS_IO_STREAM (io_stream));
g_assert (NICE_IS_IO_STREAM (io_stream));
input_stream = g_io_stream_get_input_stream (G_IO_STREAM (io_stream));
output_stream = g_io_stream_get_output_stream (G_IO_STREAM (io_stream));
pollable_input_stream = G_POLLABLE_INPUT_STREAM (input_stream);
pollable_output_stream = G_POLLABLE_OUTPUT_STREAM (output_stream);
/* Check zero-length reads and writes complete immediately without error. */
g_assert (g_input_stream_read (input_stream, buf, 0, NULL, &error) == 0);
g_assert_no_error (error);
g_assert (g_output_stream_write (output_stream, buf, 0, NULL, &error) == 0);
g_assert_no_error (error);
g_assert (
g_pollable_input_stream_read_nonblocking (pollable_input_stream,
buf, 0, NULL, &error) == 0);
g_assert_no_error (error);
g_assert (
g_pollable_output_stream_write_nonblocking (pollable_output_stream,
buf, 0, NULL, &error) == 0);
g_assert_no_error (error);
/* Remove the component and check that zero-length reads and writes still
* result in a 0 response, rather than any error. */
nice_agent_remove_stream (agent, stream_id);
g_assert (g_io_stream_is_closed (G_IO_STREAM (io_stream)));
g_assert (g_input_stream_read (input_stream, buf, 0, NULL, &error) == 0);
g_assert_no_error (error);
g_assert (g_output_stream_write (output_stream, buf, 0, NULL, &error) == 0);
g_assert_no_error (error);
g_assert (
g_pollable_input_stream_read_nonblocking (pollable_input_stream,
buf, 0, NULL, &error) == 0);
g_assert_no_error (error);
g_assert (
g_pollable_output_stream_write_nonblocking (pollable_output_stream,
buf, 0, NULL, &error) == 0);
g_assert_no_error (error);
g_object_unref (io_stream);
g_object_unref (agent);
}
static void
test_pollable_cancellation (NiceAddress *addr)
{
NiceAgent *agent;
guint stream_id;
GIOStream *io_stream;
GInputStream *input_stream;
GOutputStream *output_stream;
GPollableInputStream *pollable_input_stream;
GPollableOutputStream *pollable_output_stream;
guint8 buf[65536];
GError *error = NULL;
GSource *stream_source;
GCancellable *cancellable;
agent = nice_agent_new_reliable (NULL, NICE_COMPATIBILITY_RFC5245);
nice_agent_add_local_address (agent, addr);
/* Add a stream. */
stream_id = nice_agent_add_stream (agent, 1);
/* Try building an I/O stream around it. */
io_stream = nice_agent_get_io_stream (agent, stream_id, 1);
g_assert (G_IS_IO_STREAM (io_stream));
g_assert (NICE_IS_IO_STREAM (io_stream));
/* Grab the input and output streams. */
input_stream = g_io_stream_get_input_stream (G_IO_STREAM (io_stream));
g_assert (G_IS_POLLABLE_INPUT_STREAM (input_stream));
pollable_input_stream = G_POLLABLE_INPUT_STREAM (input_stream);
output_stream = g_io_stream_get_output_stream (G_IO_STREAM (io_stream));
g_assert (G_IS_POLLABLE_OUTPUT_STREAM (output_stream));
pollable_output_stream = G_POLLABLE_OUTPUT_STREAM (output_stream);
/* Check the non-blocking read() and write() return immediately if called with
* a cancelled cancellable. */
cancellable = g_cancellable_new ();
g_cancellable_cancel (cancellable);
g_assert (
g_pollable_input_stream_read_nonblocking (pollable_input_stream,
buf, sizeof (buf), cancellable, &error) == -1);
g_assert_error (error, G_IO_ERROR, G_IO_ERROR_CANCELLED);
g_clear_error (&error);
g_assert (
g_pollable_output_stream_write_nonblocking (pollable_output_stream,
buf, sizeof (buf), cancellable, &error) == -1);
g_assert_error (error, G_IO_ERROR, G_IO_ERROR_CANCELLED);
g_clear_error (&error);
g_object_unref (cancellable);
/* Check the GSources invoke a callback when run with the cancellable
* cancelled. */
cancellable = g_cancellable_new ();
stream_source =
g_pollable_input_stream_create_source (pollable_input_stream,
cancellable);
check_pollable_source_cancellation (stream_source, cancellable);
g_source_unref (stream_source);
g_object_unref (cancellable);
/* And for the output stream. */
cancellable = g_cancellable_new ();
stream_source =
g_pollable_output_stream_create_source (pollable_output_stream,
cancellable);
check_pollable_source_cancellation (stream_source, cancellable);
g_object_unref (io_stream);
g_source_unref (stream_source);
g_object_unref (cancellable);
g_object_unref (agent);
}
static void
test_pollable_properties (NiceAddress *addr)
{
NiceAgent *agent;
guint stream_id;
GIOStream *io_stream;
GInputStream *input_stream;
GOutputStream *output_stream;
GPollableInputStream *pollable_input_stream;
GPollableOutputStream *pollable_output_stream;
guint8 buf[65536];
GError *error = NULL;
GSource *stream_source;
agent = nice_agent_new_reliable (NULL, NICE_COMPATIBILITY_RFC5245);
nice_agent_add_local_address (agent, addr);
/* Add a stream. */
stream_id = nice_agent_add_stream (agent, 1);
/* Try building an I/O stream around it. */
io_stream = nice_agent_get_io_stream (agent, stream_id, 1);
g_assert (G_IS_IO_STREAM (io_stream));
g_assert (NICE_IS_IO_STREAM (io_stream));
/* Check the input stream’s properties. */
input_stream = g_io_stream_get_input_stream (G_IO_STREAM (io_stream));
g_assert (G_IS_POLLABLE_INPUT_STREAM (input_stream));
pollable_input_stream = G_POLLABLE_INPUT_STREAM (input_stream);
g_assert (g_pollable_input_stream_can_poll (pollable_input_stream));
g_assert (!g_pollable_input_stream_is_readable (pollable_input_stream));
g_assert (
g_pollable_input_stream_read_nonblocking (pollable_input_stream,
buf, sizeof (buf), NULL, &error) == -1);
g_assert_error (error, G_IO_ERROR, G_IO_ERROR_WOULD_BLOCK);
g_clear_error (&error);
stream_source =
g_pollable_input_stream_create_source (pollable_input_stream, NULL);
g_assert (stream_source != NULL);
g_source_unref (stream_source);
/* Check the output stream’s properties. */
output_stream = g_io_stream_get_output_stream (G_IO_STREAM (io_stream));
g_assert (G_IS_POLLABLE_OUTPUT_STREAM (output_stream));
pollable_output_stream = G_POLLABLE_OUTPUT_STREAM (output_stream);
g_assert (g_pollable_output_stream_can_poll (pollable_output_stream));
g_assert (!g_pollable_output_stream_is_writable (pollable_output_stream));
g_assert (
g_pollable_output_stream_write_nonblocking (pollable_output_stream,
buf, sizeof (buf), NULL, &error) == -1);
g_assert_error (error, G_IO_ERROR, G_IO_ERROR_WOULD_BLOCK);
g_clear_error (&error);
stream_source =
g_pollable_output_stream_create_source (pollable_output_stream, NULL);
g_assert (stream_source != NULL);
g_source_unref (stream_source);
/* Remove the component and check that the I/O streams close. */
nice_agent_remove_stream (agent, stream_id);
g_assert (!g_pollable_input_stream_is_readable (pollable_input_stream));
g_assert (!g_pollable_output_stream_is_writable (pollable_output_stream));
g_assert (
g_pollable_input_stream_read_nonblocking (pollable_input_stream,
buf, sizeof (buf), NULL, &error) == 0);
g_assert_no_error (error);
g_assert (
g_pollable_output_stream_write_nonblocking (pollable_output_stream,
buf, sizeof (buf), NULL, &error) == -1);
g_assert_error (error, G_IO_ERROR, G_IO_ERROR_CLOSED);
g_clear_error (&error);
g_object_unref (io_stream);
g_object_unref (agent);
}
static void do_console_raw_update_events(GVirSandboxConsoleRaw *console)
{
GVirSandboxConsoleRawPrivate *priv = console->priv;
if (!priv->attached) /* Closed */
return;
if (priv->localStdin) {
if ((priv->localToConsoleOffset < priv->localToConsoleLength) &&
(!priv->localEOF)) {
if (priv->localStdinSource == NULL) {
priv->localStdinSource = g_pollable_input_stream_create_source
(G_POLLABLE_INPUT_STREAM(priv->localStdin), NULL);
g_source_set_callback(priv->localStdinSource,
(GSourceFunc)do_console_raw_local_read,
console,
NULL);
g_source_attach(priv->localStdinSource,
g_main_context_default());
}
} else {
if (priv->localStdinSource) {
g_source_destroy(priv->localStdinSource);
g_source_unref(priv->localStdinSource);
priv->localStdinSource = NULL;
}
}
}
/*
* With raw consoles we can't distinguish stdout/stderr, so everything
* goes to stdout
*/
if (priv->localStdout) {
if (priv->consoleToLocalOffset) {
if (priv->localStdoutSource == NULL) {
priv->localStdoutSource = g_pollable_output_stream_create_source
(G_POLLABLE_OUTPUT_STREAM(priv->localStdout), NULL);
g_source_set_callback(priv->localStdoutSource,
(GSourceFunc)do_console_raw_local_write,
console,
NULL);
g_source_attach(priv->localStdoutSource,
g_main_context_default());
}
} else {
if (priv->localStdoutSource) {
g_source_destroy(priv->localStdoutSource);
g_source_unref(priv->localStdoutSource);
priv->localStdoutSource = NULL;
}
}
} else {
if (priv->consoleToLocalOffset) {
if (priv->localStderrSource == NULL) {
priv->localStderrSource = g_pollable_output_stream_create_source
(G_POLLABLE_OUTPUT_STREAM(priv->localStderr), NULL);
g_source_set_callback(priv->localStderrSource,
(GSourceFunc)do_console_raw_local_write,
console,
NULL);
g_source_attach(priv->localStderrSource,
g_main_context_default());
}
} else {
if (priv->localStderrSource) {
g_source_destroy(priv->localStderrSource);
g_source_unref(priv->localStderrSource);
priv->localStderrSource = NULL;
}
}
}
if (priv->console) {
GVirStreamIOCondition cond = 0;
if (priv->localToConsoleOffset)
cond |= GVIR_STREAM_IO_CONDITION_WRITABLE;
if (priv->consoleToLocalOffset < priv->consoleToLocalLength)
cond |= GVIR_STREAM_IO_CONDITION_READABLE;
if (priv->consoleWatch) {
g_source_remove(priv->consoleWatch);
priv->consoleWatch = 0;
}
if (cond) {
priv->consoleWatch = gvir_stream_add_watch(priv->console,
cond,
do_console_raw_stream_readwrite,
console);
}
} else {
if (priv->consoleToLocalOffset < priv->consoleToLocalLength) {
if (priv->consoleInputSource == NULL) {
priv->consoleInputSource = g_pollable_input_stream_create_source
(G_POLLABLE_INPUT_STREAM(priv->consoleInput), NULL);
g_source_set_callback(priv->consoleInputSource,
(GSourceFunc)do_console_raw_console_read,
console,
NULL);
g_source_attach(priv->consoleInputSource,
g_main_context_default());
}
} else {
if (priv->consoleInputSource) {
g_source_destroy(priv->consoleInputSource);
g_source_unref(priv->consoleInputSource);
priv->consoleInputSource = NULL;
}
}
if (priv->localToConsoleOffset) {
if (priv->consoleOutputSource == NULL) {
priv->consoleOutputSource = g_pollable_output_stream_create_source
(G_POLLABLE_OUTPUT_STREAM(priv->consoleOutput), NULL);
g_source_set_callback(priv->consoleOutputSource,
(GSourceFunc)do_console_raw_console_write,
console,
NULL);
g_source_attach(priv->consoleOutputSource,
g_main_context_default());
}
} else {
if (priv->consoleOutputSource) {
g_source_destroy(priv->consoleOutputSource);
g_source_unref(priv->consoleOutputSource);
priv->consoleOutputSource = NULL;
}
}
}
}
static void
g_tls_connection_base_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
GTlsConnectionBase *tls = G_TLS_CONNECTION_BASE (object);
GInputStream *istream;
GOutputStream *ostream;
gboolean system_certdb;
GTlsBackend *backend;
switch (prop_id)
{
case PROP_BASE_IO_STREAM:
if (tls->base_io_stream)
{
g_object_unref (tls->base_io_stream);
tls->base_istream = NULL;
tls->base_ostream = NULL;
}
tls->base_io_stream = g_value_dup_object (value);
if (!tls->base_io_stream)
return;
istream = g_io_stream_get_input_stream (tls->base_io_stream);
ostream = g_io_stream_get_output_stream (tls->base_io_stream);
if (G_IS_POLLABLE_INPUT_STREAM (istream) &&
g_pollable_input_stream_can_poll (G_POLLABLE_INPUT_STREAM (istream)))
{
tls->base_istream = G_POLLABLE_INPUT_STREAM (istream);
tls->tls_istream = g_tls_input_stream_base_new (tls);
}
if (G_IS_POLLABLE_OUTPUT_STREAM (ostream) &&
g_pollable_output_stream_can_poll (G_POLLABLE_OUTPUT_STREAM (ostream)))
{
tls->base_ostream = G_POLLABLE_OUTPUT_STREAM (ostream);
tls->tls_ostream = g_tls_output_stream_base_new (tls);
}
break;
case PROP_REQUIRE_CLOSE_NOTIFY:
tls->require_close_notify = g_value_get_boolean (value);
break;
case PROP_REHANDSHAKE_MODE:
tls->rehandshake_mode = g_value_get_enum (value);
break;
case PROP_USE_SYSTEM_CERTDB:
system_certdb = g_value_get_boolean (value);
if (system_certdb != tls->is_system_certdb)
{
g_clear_object (&tls->database);
if (system_certdb)
{
backend = g_tls_backend_get_default ();
tls->database = g_tls_backend_get_default_database (backend);
}
tls->is_system_certdb = system_certdb;
tls->database_is_unset = FALSE;
}
break;
case PROP_DATABASE:
g_clear_object (&tls->database);
tls->database = g_value_dup_object (value);
tls->is_system_certdb = FALSE;
tls->database_is_unset = FALSE;
break;
case PROP_CERTIFICATE:
if (tls->certificate)
g_object_unref (tls->certificate);
tls->certificate = g_value_dup_object (value);
break;
case PROP_INTERACTION:
g_clear_object (&tls->interaction);
tls->interaction = g_value_dup_object (value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
}
}
