int main(int argc, char **argv) {
const char *pty_path;
int pty_in_fd, pty_out_fd;
GInputStream *stdin, *instream;
GOutputStream *stdout, *outstream;
GMainLoop *loop;
GError *error = NULL;
if (argc != 2) {
g_printerr("Usage: gnome-hwtest-terminal-splice <pty>\n");
exit(1);
}
pty_path = argv[1];
pty_in_fd = open(pty_path, O_RDONLY);
if (pty_in_fd == -1)
die_errno("Opening PTY for reading");
pty_out_fd = open(pty_path, O_WRONLY);
if (pty_out_fd == -1)
die_errno("Opening PTY for writing");
make_raw (0);
make_raw (pty_in_fd);
stdin = g_unix_input_stream_new(0, FALSE);
stdout = g_unix_output_stream_new(1, FALSE);
instream = g_unix_input_stream_new(pty_in_fd, FALSE);
outstream = g_unix_output_stream_new(pty_out_fd, FALSE);
loop = g_main_loop_new (NULL, FALSE);
g_output_stream_splice_async(stdout, instream,
G_OUTPUT_STREAM_SPLICE_NONE,
G_PRIORITY_DEFAULT, NULL,
on_eof, loop);
check_error("Splicing stdout to PTY", error);
g_output_stream_splice_async(outstream, stdin,
G_OUTPUT_STREAM_SPLICE_NONE,
G_PRIORITY_DEFAULT, NULL,
on_eof, loop);
check_error("Splicing stdin from PTY", error);
g_main_loop_run (loop);
return 0;
}
static void
save_snapshot_get_message_cb (EMsgComposer *composer,
GAsyncResult *result,
GSimpleAsyncResult *simple)
{
SaveContext *context;
CamelMimeMessage *message;
GInputStream *input_stream;
CamelStream *camel_stream;
GByteArray *buffer;
GError *local_error = NULL;
context = g_simple_async_result_get_op_res_gpointer (simple);
message = e_msg_composer_get_message_draft_finish (
composer, result, &local_error);
if (local_error != NULL) {
g_warn_if_fail (message == NULL);
g_simple_async_result_take_error (simple, local_error);
g_simple_async_result_complete (simple);
g_object_unref (simple);
return;
}
g_return_if_fail (CAMEL_IS_MIME_MESSAGE (message));
/* Decode the message to an in-memory buffer. We have to do this
* because CamelStreams are synchronous-only, and using threads is
* dangerous because CamelDataWrapper is not reentrant. */
buffer = g_byte_array_new ();
camel_stream = camel_stream_mem_new ();
camel_stream_mem_set_byte_array (
CAMEL_STREAM_MEM (camel_stream), buffer);
camel_data_wrapper_decode_to_stream_sync (
CAMEL_DATA_WRAPPER (message), camel_stream, NULL, NULL);
g_object_unref (camel_stream);
g_object_unref (message);
/* Load the buffer into a GMemoryInputStream. */
input_stream = g_memory_input_stream_new ();
if (buffer->len > 0)
g_memory_input_stream_add_data (
G_MEMORY_INPUT_STREAM (input_stream),
buffer->data, (gssize) buffer->len,
(GDestroyNotify) g_free);
g_byte_array_free (buffer, FALSE);
/* Splice the input and output streams. */
g_output_stream_splice_async (
context->output_stream, input_stream,
G_OUTPUT_STREAM_SPLICE_CLOSE_SOURCE |
G_OUTPUT_STREAM_SPLICE_CLOSE_TARGET,
G_PRIORITY_DEFAULT, context->cancellable,
(GAsyncReadyCallback) save_snapshot_splice_cb,
simple);
g_object_unref (input_stream);
}
static VALUE
rg_splice_async(int argc, VALUE *argv, VALUE self)
{
VALUE rbsource, rbflags, rbio_priority, rbcancellable, block;
GInputStream *source;
GOutputStreamSpliceFlags flags;
int io_priority;
GCancellable *cancellable;
rb_scan_args(argc, argv, "12&", &rbsource, &rbflags, &rbio_priority, &rbcancellable, &block);
source = RVAL2GINPUTSTREAM(rbsource);
flags = RVAL2GOUTPUTSTREAMSPLICEFLAGSDEFAULT(rbflags);
io_priority = RVAL2IOPRIORITYDEFAULT(rbio_priority);
cancellable = RVAL2GCANCELLABLE(rbcancellable);
SAVE_BLOCK(block);
g_output_stream_splice_async(_SELF(self),
source,
flags,
io_priority,
cancellable,
rbgio_async_ready_callback,
(gpointer)block);
return self;
}
static void
photos_glib_file_copy_read (GObject *source_object, GAsyncResult *res, gpointer user_data)
{
GCancellable *cancellable;
GFile *source = G_FILE (source_object);
g_autoptr (GFileInputStream) istream = NULL;
g_autoptr (GTask) task = G_TASK (user_data);
PhotosGLibFileCopyData *data;
cancellable = g_task_get_cancellable (task);
data = (PhotosGLibFileCopyData *) g_task_get_task_data (task);
{
g_autoptr (GError) error = NULL;
istream = g_file_read_finish (source, res, &error);
if (error != NULL)
{
g_task_return_error (task, g_steal_pointer (&error));
goto out;
}
}
g_output_stream_splice_async (G_OUTPUT_STREAM (data->ostream),
G_INPUT_STREAM (istream),
G_OUTPUT_STREAM_SPLICE_CLOSE_SOURCE | G_OUTPUT_STREAM_SPLICE_CLOSE_TARGET,
data->io_priority,
cancellable,
photos_glib_file_copy_splice,
g_object_ref (task));
out:
return;
}
static void
cache_replace_ready_cb (GObject *source,
GAsyncResult *res,
gpointer user_data)
{
GFileOutputStream *cache_stream;
GError *error = NULL;
NemoPreviewCoverArtFetcher *self = user_data;
cache_stream = g_file_replace_finish (G_FILE (source),
res, &error);
if (error != NULL) {
g_warning ("Can't save the cover art image in the cache: %s\n", error->message);
g_error_free (error);
return;
}
g_seekable_seek (G_SEEKABLE (self->priv->input_stream), 0, G_SEEK_SET,
NULL, NULL);
g_output_stream_splice_async (G_OUTPUT_STREAM (cache_stream),
self->priv->input_stream,
G_OUTPUT_STREAM_SPLICE_CLOSE_SOURCE |
G_OUTPUT_STREAM_SPLICE_CLOSE_TARGET,
G_PRIORITY_DEFAULT,
NULL,
cache_splice_ready_cb, self);
g_object_unref (cache_stream);
}
static void
file_replace_ready_cb (GObject *source,
GAsyncResult *res,
gpointer user_data)
{
GFileOutputStream *os;
GError *error = NULL;
PdfLoadJob *job = user_data;
os = g_file_replace_finish (G_FILE (source), res, &error);
if (error != NULL) {
pdf_load_job_complete_error (job, error);
return;
}
g_output_stream_splice_async (G_OUTPUT_STREAM (os),
G_INPUT_STREAM (job->stream),
G_OUTPUT_STREAM_SPLICE_CLOSE_SOURCE |
G_OUTPUT_STREAM_SPLICE_CLOSE_TARGET,
G_PRIORITY_DEFAULT,
job->cancellable,
os_splice_ready_cb, job);
g_object_unref (os);
}
static void
gdav_request_send_cb (GObject *source_object,
GAsyncResult *result,
gpointer user_data)
{
GInputStream *input_stream;
GOutputStream *output_stream;
GTask *task = G_TASK (user_data);
GError *local_error = NULL;
input_stream = soup_request_send_finish (
SOUP_REQUEST (source_object), result, &local_error);
/* Sanity check */
g_warn_if_fail (
((input_stream != NULL) && (local_error == NULL)) ||
((input_stream == NULL) && (local_error != NULL)));
if (input_stream != NULL) {
GCancellable *cancellable;
GOutputStream *output_stream;
cancellable = g_task_get_cancellable (task);
output_stream = g_memory_output_stream_new_resizable ();
/* Don't close the input stream here, we'll
* need to perform some post-processing first. */
g_output_stream_splice_async (
output_stream, input_stream,
G_OUTPUT_STREAM_SPLICE_CLOSE_TARGET,
G_PRIORITY_DEFAULT, cancellable,
gdav_request_splice_cb,
g_object_ref (task));
g_object_unref (output_stream);
}
if (local_error != NULL) {
g_task_return_error (task, local_error);
}
g_object_unref (task);
}
static void
user_style_seet_read_cb (GFile *file,
GAsyncResult *result,
gpointer user_data)
{
GFileInputStream *input_stream;
GOutputStream *output_stream;
input_stream = g_file_read_finish (file, result, NULL);
if (!input_stream)
return;
output_stream = g_memory_output_stream_new_resizable ();
g_output_stream_splice_async (output_stream, G_INPUT_STREAM (input_stream),
G_OUTPUT_STREAM_SPLICE_CLOSE_SOURCE |
G_OUTPUT_STREAM_SPLICE_CLOSE_TARGET,
G_PRIORITY_DEFAULT,
NULL,
(GAsyncReadyCallback)user_style_sheet_output_stream_splice_cb,
NULL);
g_object_unref (input_stream);
g_object_unref (output_stream);
}
static void
tp_file_start_transfer (EmpathyTpFile *self)
{
gint fd, domain, res = 0;
GError *error = NULL;
struct sockaddr *my_addr = NULL;
size_t my_size = 0;
if (self->priv->socket_address_type == TP_SOCKET_ADDRESS_TYPE_UNIX)
{
domain = AF_UNIX;
}
else if (self->priv->socket_address_type == TP_SOCKET_ADDRESS_TYPE_IPV4)
{
domain = AF_INET;
}
else
{
error = g_error_new_literal (EMPATHY_FT_ERROR_QUARK,
EMPATHY_FT_ERROR_NOT_SUPPORTED, _("Socket type not supported"));
DEBUG ("Socket not supported, closing channel");
ft_operation_close_with_error (self, error);
g_clear_error (&error);
return;
}
fd = socket (domain, SOCK_STREAM, 0);
if (fd < 0)
{
int code = errno;
error = g_error_new_literal (EMPATHY_FT_ERROR_QUARK,
EMPATHY_FT_ERROR_SOCKET, g_strerror (code));
DEBUG ("Failed to create socket, closing channel");
ft_operation_close_with_error (self, error);
g_clear_error (&error);
return;
}
if (self->priv->socket_address_type == TP_SOCKET_ADDRESS_TYPE_UNIX)
{
struct sockaddr_un addr;
memset (&addr, 0, sizeof (addr));
addr.sun_family = domain;
strncpy (addr.sun_path, self->priv->socket_address->data,
self->priv->socket_address->len);
my_addr = (struct sockaddr *) &addr;
my_size = sizeof (addr);
}
else if (self->priv->socket_address_type == TP_SOCKET_ADDRESS_TYPE_IPV4)
{
struct sockaddr_in addr;
memset (&addr, 0, sizeof (addr));
addr.sin_family = domain;
inet_pton (AF_INET, self->priv->socket_address->data, &addr.sin_addr);
addr.sin_port = htons (self->priv->port);
my_addr = (struct sockaddr *) &addr;
my_size = sizeof (addr);
}
res = connect (fd, my_addr, my_size);
if (res < 0)
{
int code = errno;
error = g_error_new_literal (EMPATHY_FT_ERROR_QUARK,
EMPATHY_FT_ERROR_SOCKET, g_strerror (code));
DEBUG ("Failed to connect socket, closing channel");
ft_operation_close_with_error (self, error);
close (fd);
g_clear_error (&error);
return;
}
DEBUG ("Start the transfer");
self->priv->start_time = empathy_time_get_current ();
/* notify we're starting a transfer */
if (self->priv->progress_callback != NULL)
self->priv->progress_callback (self, 0, self->priv->progress_user_data);
if (self->priv->incoming)
{
GInputStream *socket_stream;
socket_stream = g_unix_input_stream_new (fd, TRUE);
g_output_stream_splice_async (self->priv->out_stream, socket_stream,
G_OUTPUT_STREAM_SPLICE_CLOSE_SOURCE |
G_OUTPUT_STREAM_SPLICE_CLOSE_TARGET,
G_PRIORITY_DEFAULT, self->priv->cancellable,
splice_stream_ready_cb, self);
g_object_unref (socket_stream);
}
else
{
GOutputStream *socket_stream;
socket_stream = g_unix_output_stream_new (fd, TRUE);
g_output_stream_splice_async (socket_stream, self->priv->in_stream,
G_OUTPUT_STREAM_SPLICE_CLOSE_SOURCE |
G_OUTPUT_STREAM_SPLICE_CLOSE_TARGET,
G_PRIORITY_DEFAULT, self->priv->cancellable,
splice_stream_ready_cb, self);
g_object_unref (socket_stream);
}
}
gboolean
builder_host_spawnv (GFile *dir,
char **output,
GError **error,
const gchar * const *argv)
{
guint32 client_pid;
GVariantBuilder *fd_builder = g_variant_builder_new (G_VARIANT_TYPE("a{uh}"));
GVariantBuilder *env_builder = g_variant_builder_new (G_VARIANT_TYPE("a{ss}"));
g_autoptr(GUnixFDList) fd_list = g_unix_fd_list_new ();
gint stdout_handle, stdin_handle, stderr_handle;
g_autoptr(GDBusConnection) connection = NULL;
g_autoptr(GVariant) ret = NULL;
g_autoptr(GMainLoop) loop = NULL;
g_auto(GStrv) env_vars = NULL;
guint subscription;
HostCommandCallData data = { NULL };
guint sigterm_id = 0, sigint_id = 0;
g_autofree gchar *commandline = NULL;
g_autoptr(GOutputStream) out = NULL;
int pipefd[2];
int i;
commandline = flatpak_quote_argv ((const char **) argv);
g_debug ("Running '%s' on host", commandline);
connection = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, error);
if (connection == NULL)
return FALSE;
loop = g_main_loop_new (NULL, FALSE);
data.connection = connection;
data.loop = loop;
data.refs = 1;
subscription = g_dbus_connection_signal_subscribe (connection,
NULL,
"org.freedesktop.Flatpak.Development",
"HostCommandExited",
"/org/freedesktop/Flatpak/Development",
NULL,
G_DBUS_SIGNAL_FLAGS_NONE,
host_command_exited_cb,
&data, NULL);
stdin_handle = g_unix_fd_list_append (fd_list, 0, error);
if (stdin_handle == -1)
return FALSE;
if (output)
{
g_autoptr(GInputStream) in = NULL;
if (pipe2 (pipefd, O_CLOEXEC) != 0)
{
glnx_set_error_from_errno (error);
return FALSE;
}
data.refs++;
in = g_unix_input_stream_new (pipefd[0], TRUE);
out = g_memory_output_stream_new_resizable ();
g_output_stream_splice_async (out,
in,
G_OUTPUT_STREAM_SPLICE_NONE,
0,
NULL,
output_spliced_cb,
&data);
stdout_handle = g_unix_fd_list_append (fd_list, pipefd[1], error);
close (pipefd[1]);
if (stdout_handle == -1)
return FALSE;
}
else
{
stdout_handle = g_unix_fd_list_append (fd_list, 1, error);
if (stdout_handle == -1)
return FALSE;
}
stderr_handle = g_unix_fd_list_append (fd_list, 2, error);
if (stderr_handle == -1)
return FALSE;
g_variant_builder_add (fd_builder, "{uh}", 0, stdin_handle);
g_variant_builder_add (fd_builder, "{uh}", 1, stdout_handle);
g_variant_builder_add (fd_builder, "{uh}", 2, stderr_handle);
env_vars = g_listenv ();
for (i = 0; env_vars[i] != NULL; i++)
{
const char *env_var = env_vars[i];
g_variant_builder_add (env_builder, "{ss}", env_var, g_getenv (env_var));
}
sigterm_id = g_unix_signal_add (SIGTERM, sigterm_handler, &data);
sigint_id = g_unix_signal_add (SIGINT, sigint_handler, &data);
ret = g_dbus_connection_call_with_unix_fd_list_sync (connection,
"org.freedesktop.Flatpak",
"/org/freedesktop/Flatpak/Development",
"org.freedesktop.Flatpak.Development",
"HostCommand",
g_variant_new ("(^ay^aay@a{uh}@a{ss}u)",
dir ? flatpak_file_get_path_cached (dir) : "",
argv,
g_variant_builder_end (fd_builder),
g_variant_builder_end (env_builder),
FLATPAK_HOST_COMMAND_FLAGS_CLEAR_ENV),
G_VARIANT_TYPE ("(u)"),
G_DBUS_CALL_FLAGS_NONE, -1,
fd_list, NULL,
NULL, error);
if (ret == NULL)
return FALSE;
g_variant_get (ret, "(u)", &client_pid);
data.client_pid = client_pid;
g_main_loop_run (loop);
g_source_remove (sigterm_id);
g_source_remove (sigint_id);
g_dbus_connection_signal_unsubscribe (connection, subscription);
if (!g_spawn_check_exit_status (data.exit_status, error))
return FALSE;
if (out)
{
if (data.splice_error)
{
g_propagate_error (error, data.splice_error);
return FALSE;
}
/* Null terminate */
g_output_stream_write (out, "\0", 1, NULL, NULL);
g_output_stream_close (out, NULL, NULL);
*output = g_memory_output_stream_steal_data (G_MEMORY_OUTPUT_STREAM (out));
}
return TRUE;
}
static gboolean
archive_spawnv (GFile *dir,
char **output,
GError **error,
const gchar * const *argv)
{
g_autoptr(GSubprocessLauncher) launcher = NULL;
g_autoptr(GSubprocess) subp = NULL;
GInputStream *in;
g_autoptr(GOutputStream) out = NULL;
g_autoptr(GMainLoop) loop = NULL;
SpawnData data = {0};
g_autofree gchar *commandline = NULL;
launcher = g_subprocess_launcher_new (G_SUBPROCESS_FLAGS_NONE);
if (output)
g_subprocess_launcher_set_flags (launcher, G_SUBPROCESS_FLAGS_STDOUT_PIPE);
if (dir)
{
g_autofree char *path = g_file_get_path (dir);
g_subprocess_launcher_set_cwd (launcher, path);
}
commandline = g_strjoinv (" ", (gchar **) argv);
g_debug ("Running '%s'", commandline);
subp = g_subprocess_launcher_spawnv (launcher, argv, error);
if (subp == NULL)
return FALSE;
loop = g_main_loop_new (NULL, FALSE);
data.loop = loop;
data.refs = 1;
if (output)
{
data.refs++;
in = g_subprocess_get_stdout_pipe (subp);
out = g_memory_output_stream_new_resizable ();
g_output_stream_splice_async (out,
in,
G_OUTPUT_STREAM_SPLICE_NONE,
0,
NULL,
spawn_output_spliced_cb,
&data);
}
g_subprocess_wait_async (subp, NULL, spawn_exit_cb, &data);
g_main_loop_run (loop);
if (data.error)
{
g_propagate_error (error, data.error);
g_clear_error (&data.splice_error);
return FALSE;
}
if (out)
{
if (data.splice_error)
{
g_propagate_error (error, data.splice_error);
return FALSE;
}
/* Null terminate */
g_output_stream_write (out, "\0", 1, NULL, NULL);
g_output_stream_close (out, NULL, NULL);
*output = g_memory_output_stream_steal_data (G_MEMORY_OUTPUT_STREAM (out));
}
return TRUE;
}