gboolean
remmina_nx_session_invoke_proxy (RemminaNXSession *nx, gint display,
GChildWatchFunc exit_func, gpointer user_data)
{
gchar *argv[50];
gint argc;
GError *error = NULL;
gboolean ret;
gchar **envp;
gchar *s;
gint i;
/* Copy all current environment variable, but change DISPLAY. Assume we should always have DISPLAY... */
if (display >= 0)
{
envp = g_listenv ();
for (i = 0; envp[i]; i++)
{
if (g_strcmp0 (envp[i], "DISPLAY") == 0)
{
s = g_strdup_printf ("DISPLAY=:%i", display);
}
else
{
s = g_strdup_printf ("%s=%s", envp[i], g_getenv (envp[i]));
}
g_free (envp[i]);
envp[i] = s;
}
}
else
{
envp = NULL;
}
argc = 0;
argv[argc++] = g_strdup ("nxproxy");
argv[argc++] = g_strdup ("-S");
argv[argc++] = remmina_nx_session_get_proxy_option (nx);
argv[argc++] = NULL;
ret = g_spawn_async (NULL, argv, envp, G_SPAWN_SEARCH_PATH | G_SPAWN_DO_NOT_REAP_CHILD,
NULL, NULL, &nx->proxy_pid, &error);
g_strfreev (envp);
for (i = 0; i < argc; i++) g_free (argv[i]);
if (!ret)
{
remmina_nx_session_set_application_error (nx, "%s", error->message);
return FALSE;
}
if (exit_func)
{
nx->proxy_watch_source = g_child_watch_add (nx->proxy_pid, exit_func, user_data);
}
return TRUE;
}
static VALUE
rg_s_listenv(G_GNUC_UNUSED VALUE self)
{
gchar** c_list;
gchar** c_var;
VALUE r_list = rb_ary_new();
c_list = g_listenv();
c_var = c_list;
while(*c_var) {
rb_ary_push(r_list, CSTR2RVAL(*(c_var++)));
}
g_strfreev(c_list);
return r_list;
}
void playing_env_dump( void )
{
gchar **envp = g_listenv();
size_t i = 0;
while( envp[i] != NULL )
{
printf( "g_listenv[%2zu] %s => %s\n", i, envp[i], g_getenv( envp[i] ) );
i++;
}
envp = g_get_environ();
i = 0;
while( envp[i] != NULL )
{
printf( "g_get_environ[%zu] = %s\n", i, envp[i] );
i++;
}
}
static GPtrArray *
array_putenv (GPtrArray * env, char *variable)
{
guint i, keylen;
if (!env)
{
char **envp;
env = g_ptr_array_new ();
envp = g_listenv ();
for (i = 0; envp[i]; i++)
{
const char *value;
value = g_getenv (envp[i]);
g_ptr_array_add (env,
g_strdup_printf ("%s=%s", envp[i],
value ? value : ""));
}
g_strfreev (envp);
}
keylen = strcspn (variable, "=");
/* Remove old value of key */
for (i = 0; i < env->len; i++)
{
char *envvar = env->pdata[i];
if (!strncmp (envvar, variable, keylen) && envvar[keylen] == '=')
{
g_free (envvar);
g_ptr_array_remove_index_fast (env, i);
break;
}
}
/* Add new value */
g_ptr_array_add (env, g_strdup (variable));
return env;
}
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;
}
int
main (int argc, char *argv[])
{
NMDBusLibreswanHelper *proxy;
GVariantBuilder environment;
GError *err = NULL;
gchar **env;
gchar **p;
const char *bus_name = NM_DBUS_SERVICE_LIBRESWAN;
char *str = NULL;
char **i_env;
#if !GLIB_CHECK_VERSION (2, 35, 0)
g_type_init ();
#endif
/* support old command line arguments. The only reason for that is to
* support update of the plugin while being connected. */
switch (argc) {
case 1:
break;
case 4:
gl.log_level = _nm_utils_ascii_str_to_int64 (argv[1], 10, 0, LOG_DEBUG, 0);
gl.log_prefix_token = argv[2];
bus_name = argv[3];
break;
case 3:
if (strcmp (argv[1], "--bus-name") == 0) {
bus_name = argv[2];
break;
}
/* fallthrough */
default:
g_printerr ("Usage: %s <LEVEL> <PREFIX_TOKEN> <BUS_NAME>\n", argv[0]);
exit (1);
}
if (!g_dbus_is_name (bus_name)) {
g_printerr ("Not a valid bus name: '%s'\n", bus_name);
exit (1);
}
_LOGD ("command line: %s", (str = g_strjoinv (" ", argv)));
g_clear_pointer (&str, g_free);
for (i_env = environ; i_env && *i_env; i_env++)
_LOGD ("environment: %s", *i_env);
proxy = nmdbus_libreswan_helper_proxy_new_for_bus_sync (G_BUS_TYPE_SYSTEM,
G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES,
bus_name,
NM_DBUS_PATH_LIBRESWAN_HELPER,
NULL, &err);
if (!proxy) {
_LOGW ("Could not create a D-Bus proxy: %s", err->message);
g_error_free (err);
exit (1);
}
g_variant_builder_init (&environment, G_VARIANT_TYPE ("a{ss}"));
env = g_listenv ();
for (p = env; *p; p++) {
if (strncmp ("PLUTO_", *p, 6))
continue;
g_variant_builder_add (&environment, "{ss}", *p, g_getenv (*p));
}
g_strfreev (env);
if (!nmdbus_libreswan_helper_call_callback_sync (proxy,
g_variant_builder_end (&environment),
NULL, &err)) {
_LOGW ("Could not call the plugin: %s", err->message);
g_error_free (err);
g_object_unref (proxy);
exit (1);
}
g_object_unref (proxy);
exit (0);
}
void gfire_join_game(const gfire_game_data *p_game_data)
{
const gfire_game_configuration *gconf = gfire_game_config_by_id(p_game_data->id);
if(!gconf)
{
purple_debug_error("gfire", "gfire_join_game: Game not configured!\n");
return;
}
gchar *game_launch_command = gfire_game_config_get_command(gconf, p_game_data);
if (!game_launch_command)
{
purple_debug_error("gfire", "gfire_join_game: Couldn't generate game launch command!\n");
return;
}
GString *command = g_string_new(game_launch_command);
g_free(game_launch_command);
// Set environment if needed
gchar **env = NULL;
gint env_len = 0;
if(gconf->launch_prefix)
{
gchar *prefix = NULL;
GList *env_keys = NULL;
GList *env_values = NULL;
gfire_join_game_parse_prefix(gconf->launch_prefix, &prefix, &env_keys, &env_values);
if(prefix)
{
g_string_prepend_c(command, ' ');
g_string_prepend(command, prefix);
g_free(prefix);
}
if(env_keys)
{
gchar **cur_env = g_listenv();
gint i = 0;
for(; i < g_strv_length(cur_env); i++)
{
env_len++;
env = (gchar**)g_realloc(env, sizeof(gchar*) * (env_len + 1));
env[env_len - 1] = g_strdup_printf("%s=%s", cur_env[i], g_getenv(cur_env[i]));
env[env_len] = NULL;
}
GList *cur_key = env_keys;
GList *cur_value = env_values;
while(cur_key)
{
for(i = 0; i < g_strv_length(cur_env); i++)
{
if(g_strcmp0(cur_env[i], (gchar*)cur_key->data) == 0)
break;
}
if(i == g_strv_length(cur_env))
{
env_len++;
env = (gchar**)g_realloc(env, sizeof(gchar*) * (env_len + 1));
env[env_len - 1] = g_strdup_printf("%s=%s", (gchar*)cur_key->data, (gchar*)cur_value->data);
env[env_len] = NULL;
}
else
{
g_free(env[i]);
env[i] = g_strdup_printf("%s=%s", (gchar*)cur_key->data, (gchar*)cur_value->data);
}
cur_key = g_list_next(cur_key);
cur_value = g_list_next(cur_value);
}
g_strfreev(cur_env);
gfire_list_clear(env_keys);
gfire_list_clear(env_values);
}
}
// Launch command
gchar **argv = NULL;
if(!g_shell_parse_argv(command->str, NULL, &argv, NULL))
{
purple_debug_error("gfire", "g_shell_parse_argv failed!");
g_string_free(command, TRUE);
g_strfreev(env);
return;
}
purple_debug_misc("gfire", "Launching game and joining server: %s\n", command->str);
g_string_free(command, TRUE);
// Get working directory
gchar *wd = g_path_get_dirname(argv[0]);
// Launch
g_spawn_async(wd, argv, env, G_SPAWN_SEARCH_PATH, NULL, NULL, NULL, NULL);
g_free(wd);
g_strfreev(argv);
g_strfreev(env);
}
static void
name_lost_cb (GDBusConnection *connection,
const char *name,
gpointer user_data)
{
OwnData *data = (OwnData *) user_data;
GError *error = NULL;
char **envv;
int envc, i;
GVariantBuilder builder;
GVariant *value;
GString *string;
char *s;
gsize len;
_terminal_debug_print (TERMINAL_DEBUG_FACTORY,
"Lost the name %s on the session bus\n", name);
/* Couldn't get the connection? No way to continue! */
if (connection == NULL) {
data->exit_code = EXIT_FAILURE;
gtk_main_quit ();
return;
}
if (data->options == NULL) {
/* Already handled */
data->exit_code = EXIT_SUCCESS;
gtk_main_quit ();
return;
}
_terminal_debug_print (TERMINAL_DEBUG_FACTORY,
"Forwarding arguments to existing instance\n");
g_variant_builder_init (&builder, G_VARIANT_TYPE ("(ayayayayay)"));
g_variant_builder_add (&builder, "@ay", string_to_ay (data->options->default_working_dir));
g_variant_builder_add (&builder, "@ay", string_to_ay (data->options->display_name));
g_variant_builder_add (&builder, "@ay", string_to_ay (data->options->startup_id));
string = g_string_new (NULL);
envv = g_listenv ();
envc = g_strv_length (envv);
for (i = 0; i < envc; ++i)
{
const char *value;
value = g_getenv (envv[i]);
if (value == NULL)
continue;
if (i > 0)
g_string_append_c (string, '\0');
g_string_append_printf (string, "%s=%s", envv[i], value);
}
len = string->len;
s = g_string_free (string, FALSE);
g_variant_builder_add (&builder, "@ay",
g_variant_new_from_data (G_VARIANT_TYPE ("ay"), s, len, TRUE, g_free, s));
string = g_string_new (NULL);
for (i = 0; i < data->argc; ++i)
{
if (i > 0)
g_string_append_c (string, '\0');
g_string_append (string, data->argv[i]);
}
len = string->len;
s = g_string_free (string, FALSE);
g_variant_builder_add (&builder, "@ay",
g_variant_new_from_data (G_VARIANT_TYPE ("ay"), s, len, TRUE, g_free, s));
value = g_dbus_connection_call_sync (connection,
data->factory_name,
TERMINAL_FACTORY_SERVICE_PATH,
TERMINAL_FACTORY_INTERFACE_NAME,
"HandleArguments",
g_variant_builder_end (&builder),
G_VARIANT_TYPE ("()"),
G_DBUS_CALL_FLAGS_NONE,
-1,
NULL,
&error);
if (value == NULL) {
g_printerr ("Failed to forward arguments: %s\n", error->message);
g_error_free (error);
data->exit_code = EXIT_FAILURE;
gtk_main_quit ();
} else {
g_variant_unref (value);
data->exit_code = EXIT_SUCCESS;
}
terminal_options_free (data->options);
data->options = NULL;
gtk_main_quit ();
}
static void
dbus_daemon_notify_bus_address_cb (GObject *gobject, GParamSpec *pspec, MainData *data)
{
GPtrArray/*<string>*/ *test_program_envp;
gchar *envp_pair;
g_assert (data->dbus_address == NULL);
data->dbus_address = g_strdup (dsim_dbus_daemon_get_bus_address (data->dbus_daemon));
g_message (_("Note: Simulated bus has address: %s"), data->dbus_address);
/* Set up the test program ready for spawning. */
test_program_envp = g_ptr_array_new_with_free_func (g_free);
if (pass_through_environment == FALSE) {
guint i;
/* Set up a minimal environment with just the necessary environment variables required for things to function.
* Note that this list of necessary environment variables is probably incomplete, and is built on the basis of
* trial and error rather than research or standards. */
const gchar *forward_variables[] = {
"DISPLAY",
"XDG_DATA_HOME",
"XDG_CONFIG_HOME",
"XDG_DATA_DIRS",
"XDG_CONFIG_DIRS",
"XDG_CACHE_HOME",
"XDG_RUNTIME_DIR",
"HOME",
"USER",
"HOSTNAME",
"SSH_CLIENT",
"SSH_TTY",
"SSH_CONNECTION",
};
for (i = 0; i < G_N_ELEMENTS (forward_variables); i++) {
forward_envp_pair (test_program_envp, forward_variables[i]);
}
} else {
/* Forward everything from the simulator's environment to the test program's environment. This might make the test
* results slightly less reliable. */
gchar **env_variable_names;
const gchar * const *i;
env_variable_names = g_listenv ();
for (i = (const gchar * const *) env_variable_names; *i != NULL; i++) {
forward_envp_pair (test_program_envp, *i);
}
g_strfreev (env_variable_names);
}
if (system_bus) {
envp_pair = g_strdup_printf ("DBUS_SYSTEM_BUS_ADDRESS=%s", data->dbus_address);
} else {
envp_pair = g_strdup_printf ("DBUS_SESSION_BUS_ADDRESS=%s", data->dbus_address);
}
g_ptr_array_add (test_program_envp, envp_pair);
/* Copy the environment pairs set on the command line. */
if (test_program_environment != NULL) {
guint i;
for (i = 0; i < test_program_environment->len; i++) {
envp_pair = g_ptr_array_index (test_program_environment, i);
g_ptr_array_add (test_program_envp, g_strdup (envp_pair));
}
}
data->test_program = dsim_test_program_new (data->working_directory_file, data->test_program_name, data->test_program_argv, test_program_envp);
g_ptr_array_unref (test_program_envp);
/* Start building a D-Bus connection with our new bus address. */
g_dbus_connection_new_for_address (data->dbus_address,
G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT | G_DBUS_CONNECTION_FLAGS_MESSAGE_BUS_CONNECTION, NULL, NULL,
(GAsyncReadyCallback) connection_created_cb, data);
/* We don't want this to fire again. */
g_signal_handlers_disconnect_by_func (gobject, dbus_daemon_notify_bus_address_cb, data);
}
