diff --git a/pressure-vessel/wrap-context.c b/pressure-vessel/wrap-context.c index dd711208e75810a0109df8766afacd7d9f8a7d99..8216431faebe3a48a4169b8cd0cf1ef470e2a534 100644 --- a/pressure-vessel/wrap-context.c +++ b/pressure-vessel/wrap-context.c @@ -98,9 +98,13 @@ pv_wrap_options_clear (PvWrapOptions *self) enum { PROP_0, + PROP_CURRENT_HOME, + PROP_CURRENT_ROOT, N_PROPERTIES }; +static GParamSpec *properties[N_PROPERTIES] = { NULL }; + struct _PvWrapContextClass { GObjectClass parent_class; @@ -120,6 +124,78 @@ pv_wrap_context_init (PvWrapContext *self) self->options.copy_runtime = self->is_flatpak_env; } +static void +pv_wrap_context_get_property (GObject *object, + guint prop_id, + GValue *value, + GParamSpec *pspec) +{ + PvWrapContext *self = PV_WRAP_CONTEXT (object); + + switch (prop_id) + { + case PROP_CURRENT_HOME: + g_value_set_string (value, self->current_home); + break; + + case PROP_CURRENT_ROOT: + g_value_set_object (value, self->current_root); + break; + + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + } +} + +static void +pv_wrap_context_set_property (GObject *object, + guint prop_id, + const GValue *value, + GParamSpec *pspec) +{ + PvWrapContext *self = PV_WRAP_CONTEXT (object); + + switch (prop_id) + { + case PROP_CURRENT_HOME: + /* Construct-only */ + g_return_if_fail (self->current_home == NULL); + self->current_home = g_value_dup_string (value); + break; + + case PROP_CURRENT_ROOT: + /* Construct-only */ + g_return_if_fail (self->current_root == NULL); + self->current_root = g_value_dup_object (value); + break; + + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + } +} + +static void +pv_wrap_context_constructed (GObject *object) +{ + PvWrapContext *self = PV_WRAP_CONTEXT (object); + + G_OBJECT_CLASS (pv_wrap_context_parent_class)->constructed (object); + + if (self->current_home == NULL) + self->current_home = g_strdup (g_get_home_dir ()); +} + +static void +pv_wrap_context_dispose (GObject *object) +{ + PvWrapContext *self = PV_WRAP_CONTEXT (object); + + g_clear_object (&self->current_root); + g_clear_object (&self->runtime); + + G_OBJECT_CLASS (pv_wrap_context_parent_class)->dispose (object); +} + static void pv_wrap_context_finalize (GObject *object) { @@ -127,9 +203,11 @@ pv_wrap_context_finalize (GObject *object) pv_wrap_options_clear (&self->options); + g_clear_pointer (&self->exports, flatpak_exports_free); g_clear_pointer (&self->paths_not_exported, g_hash_table_unref); g_strfreev (self->original_argv); g_strfreev (self->original_environ); + g_free (self->current_home); G_OBJECT_CLASS (pv_wrap_context_parent_class)->finalize (object); } @@ -139,13 +217,40 @@ pv_wrap_context_class_init (PvWrapContextClass *cls) { GObjectClass *object_class = G_OBJECT_CLASS (cls); + object_class->get_property = pv_wrap_context_get_property; + object_class->set_property = pv_wrap_context_set_property; + object_class->constructed = pv_wrap_context_constructed; + object_class->dispose = pv_wrap_context_dispose; object_class->finalize = pv_wrap_context_finalize; + + properties[PROP_CURRENT_HOME] = + g_param_spec_string ("current-home", "Current $HOME", + ("Path to real or mock home directory " + "within current-root"), + NULL, + (G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | + G_PARAM_STATIC_STRINGS)); + + properties[PROP_CURRENT_ROOT] = + g_param_spec_object ("current-root", "Current root", + ("Real or mock root directory for the current " + "filesystem namespace"), + SRT_TYPE_SYSROOT, + (G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | + G_PARAM_STATIC_STRINGS)); + + g_object_class_install_properties (object_class, N_PROPERTIES, properties); } PvWrapContext * -pv_wrap_context_new (GError **error) +pv_wrap_context_new (SrtSysroot *current_root, + const char *current_home, + GError **error) { + /* Can't actually fail right now */ return g_object_new (PV_TYPE_WRAP_CONTEXT, + "current-home", current_home, + "current-root", current_root, NULL); } @@ -1033,7 +1138,6 @@ export_not_allowed (PvWrapContext *self, /* * pv_wrap_context_export_if_allowed: * @self: The context - * @exports: List of exported paths * @export_mode: Mode with which to add @path * @path: The path we propose to export, as an absolute path within the * current execution environment @@ -1052,7 +1156,6 @@ export_not_allowed (PvWrapContext *self, */ gboolean pv_wrap_context_export_if_allowed (PvWrapContext *self, - FlatpakExports *exports, FlatpakFilesystemMode export_mode, const char *path, const char *host_path, @@ -1065,7 +1168,7 @@ pv_wrap_context_export_if_allowed (PvWrapContext *self, size_t i; g_return_val_if_fail (PV_IS_WRAP_CONTEXT (self), FALSE); - g_return_val_if_fail (exports != NULL, FALSE); + g_return_val_if_fail (self->exports != NULL, FALSE); g_return_val_if_fail (export_mode > FLATPAK_FILESYSTEM_MODE_NONE, FALSE); g_return_val_if_fail (export_mode <= FLATPAK_FILESYSTEM_MODE_LAST, FALSE); g_return_val_if_fail (g_path_is_absolute (path), FALSE); @@ -1106,7 +1209,7 @@ pv_wrap_context_export_if_allowed (PvWrapContext *self, /* This generally shouldn't fail in practice, because we already checked * against reserved_paths[] above */ - pv_exports_expose_or_log (exports, export_mode, path); + pv_exports_expose_or_log (self->exports, export_mode, path); return TRUE; } diff --git a/pressure-vessel/wrap-context.h b/pressure-vessel/wrap-context.h index 17d2db2c2821faf7654445fe116a51af3e1e9b35..68cc601a14f0b5cf366419f7b8ef353ba7eef463 100644 --- a/pressure-vessel/wrap-context.h +++ b/pressure-vessel/wrap-context.h @@ -13,6 +13,7 @@ #include "pressure-vessel/adverb-preload.h" #include "pressure-vessel/flatpak-exports-private.h" +#include "pressure-vessel/runtime.h" #include "pressure-vessel/wrap-interactive.h" @@ -92,9 +93,13 @@ struct _PvWrapContext { GObject parent_instance; + FlatpakExports *exports; GHashTable *paths_not_exported; + PvRuntime *runtime; + SrtSysroot *current_root; gchar **original_argv; gchar **original_environ; + gchar *current_home; PvWrapOptions options; @@ -118,7 +123,9 @@ struct _PvWrapContext GType pv_wrap_context_get_type (void); G_DEFINE_AUTOPTR_CLEANUP_FUNC (PvWrapContext, g_object_unref) -PvWrapContext *pv_wrap_context_new (GError **error); +PvWrapContext *pv_wrap_context_new (SrtSysroot *current_root, + const char *current_home, + GError **error); gboolean pv_wrap_options_parse_environment (PvWrapOptions *self, GError **error); @@ -138,7 +145,6 @@ gboolean pv_wrap_options_parse_environment_after_argv (PvWrapOptions *self, GError **error); gboolean pv_wrap_context_export_if_allowed (PvWrapContext *self, - FlatpakExports *exports, FlatpakFilesystemMode export_mode, const char *path, const char *host_path, diff --git a/pressure-vessel/wrap-setup.c b/pressure-vessel/wrap-setup.c index 8570ea535a2ff6ffc8c58689c535c2c3a887b41d..08c710134adf2040cd27f20dbc7c691e5eeb60cf 100644 --- a/pressure-vessel/wrap-setup.c +++ b/pressure-vessel/wrap-setup.c @@ -546,15 +546,13 @@ pv_wrap_move_into_scope (const char *steam_app_id) } static void -append_preload_internal (GPtrArray *argv, +append_preload_internal (PvWrapContext *context, + GPtrArray *argv, PvPreloadVariableIndex which, gsize abi_index, const char *export_path, const char *original_path, - GStrv env, - PvAppendPreloadFlags flags, - PvRuntime *runtime, - FlatpakExports *exports) + PvAppendPreloadFlags flags) { g_auto(PvAdverbPreloadModule) module = PV_ADVERB_PRELOAD_MODULE_INIT; g_autofree gchar *arg = NULL; @@ -563,7 +561,7 @@ append_preload_internal (GPtrArray *argv, module.index_in_preload_variables = which; module.abi_index = abi_index; - if (runtime != NULL + if (context->runtime != NULL && (g_str_has_prefix (original_path, "/usr/") || g_str_has_prefix (original_path, "/lib") || (flatpak_subsandbox && g_str_has_prefix (original_path, "/app/")))) @@ -578,9 +576,9 @@ append_preload_internal (GPtrArray *argv, module.name = g_strdup (original_path); g_debug ("%s -> unmodified", original_path); - if (exports != NULL && export_path != NULL && export_path[0] == '/') + if (context->exports != NULL && export_path != NULL && export_path[0] == '/') { - const gchar *steam_path = g_environ_getenv (env, "STEAM_COMPAT_CLIENT_INSTALL_PATH"); + const gchar *steam_path = g_environ_getenv (context->original_environ, "STEAM_COMPAT_CLIENT_INSTALL_PATH"); if (steam_path != NULL && flatpak_has_path_prefix (export_path, steam_path)) @@ -592,7 +590,7 @@ append_preload_internal (GPtrArray *argv, else { g_debug ("%s needs adding to exports", export_path); - pv_exports_expose_or_log (exports, + pv_exports_expose_or_log (context->exports, FLATPAK_FILESYSTEM_MODE_READ_ONLY, export_path); } @@ -620,13 +618,11 @@ append_preload_internal (GPtrArray *argv, * Arguments are the same as for pv_wrap_append_preload(). */ static void -append_preload_unsupported_token (GPtrArray *argv, +append_preload_unsupported_token (PvWrapContext *context, + GPtrArray *argv, PvPreloadVariableIndex which, const char *preload, - GStrv env, - PvAppendPreloadFlags flags, - PvRuntime *runtime, - FlatpakExports *exports) + PvAppendPreloadFlags flags) { g_autofree gchar *export_path = NULL; char *dollar; @@ -673,15 +669,13 @@ append_preload_unsupported_token (GPtrArray *argv, preload); } - append_preload_internal (argv, + append_preload_internal (context, + argv, which, PV_UNSPECIFIED_ABI, export_path, preload, - env, - flags, - runtime, - exports); + flags); } /* @@ -695,13 +689,11 @@ append_preload_unsupported_token (GPtrArray *argv, * Arguments are the same as for pv_wrap_append_preload(). */ static void -append_preload_per_architecture (GPtrArray *argv, +append_preload_per_architecture (PvWrapContext *context, + GPtrArray *argv, PvPreloadVariableIndex which, const char *preload, - GStrv env, - PvAppendPreloadFlags flags, - PvRuntime *runtime, - FlatpakExports *exports) + PvAppendPreloadFlags flags) { g_autoptr(SrtSystemInfo) system_info = srt_system_info_new (NULL); gsize n_supported_architectures = PV_N_SUPPORTED_ARCHITECTURES; @@ -775,15 +767,13 @@ append_preload_per_architecture (GPtrArray *argv, { g_debug ("Found %s version of %s at %s", multiarch_tuple, preload, path); - append_preload_internal (argv, + append_preload_internal (context, + argv, which, i, path, path, - env, - flags, - runtime, - exports); + flags); } else { @@ -794,18 +784,16 @@ append_preload_per_architecture (GPtrArray *argv, } static void -append_preload_basename (GPtrArray *argv, +append_preload_basename (PvWrapContext *context, + GPtrArray *argv, PvPreloadVariableIndex which, const char *preload, - GStrv env, - PvAppendPreloadFlags flags, - PvRuntime *runtime, - FlatpakExports *exports) + PvAppendPreloadFlags flags) { gboolean runtime_has_library = FALSE; - if (runtime != NULL) - runtime_has_library = pv_runtime_has_library (runtime, preload); + if (context->runtime != NULL) + runtime_has_library = pv_runtime_has_library (context->runtime, preload); if (flags & PV_APPEND_PRELOAD_FLAGS_IN_UNIT_TESTS) { @@ -832,15 +820,13 @@ append_preload_basename (GPtrArray *argv, "passing %s through as-is", preload, pv_preload_variables[which].variable); - append_preload_internal (argv, + append_preload_internal (context, + argv, which, PV_UNSPECIFIED_ABI, NULL, preload, - env, - flags, - runtime, - NULL); + flags); } else { @@ -851,50 +837,42 @@ append_preload_basename (GPtrArray *argv, g_debug ("Did not find \"%s\" in runtime or graphics stack provider, " "splitting architectures", preload); - append_preload_per_architecture (argv, + append_preload_per_architecture (context, + argv, which, preload, - env, - flags, - runtime, - exports); + flags); } } /** * pv_wrap_append_preload: + * @context: Context we are running in * @argv: (element-type filename): Array of command-line options to populate * @which: Either `LD_AUDIT` or `LD_PRELOAD` * @preload: (type filename): Path of preloadable module in current * namespace, possibly including special ld.so tokens such as `$LIB`, * or basename of a preloadable module to be found in the standard * library search path - * @env: (array zero-terminated=1) (element-type filename): Environment - * variables to be used instead of `environ` * @flags: Flags to adjust behaviour - * @runtime: (nullable): Runtime to be used in container - * @exports: (nullable): Used to configure extra paths that need to be - * exported into the container * * Adjust @preload to be valid for the container and append it * to @argv. */ void -pv_wrap_append_preload (GPtrArray *argv, +pv_wrap_append_preload (PvWrapContext *context, + GPtrArray *argv, PvPreloadVariableIndex which, const char *preload, - GStrv env, - PvAppendPreloadFlags flags, - PvRuntime *runtime, - FlatpakExports *exports) + PvAppendPreloadFlags flags) { SrtLoadableKind kind; SrtLoadableFlags loadable_flags; const char *variable; + g_return_if_fail (PV_IS_WRAP_CONTEXT (context)); g_return_if_fail (argv != NULL); g_return_if_fail (preload != NULL); - g_return_if_fail (runtime == NULL || PV_IS_RUNTIME (runtime)); g_return_if_fail (which >= 0); g_return_if_fail (which < G_N_ELEMENTS (pv_preload_variables)); @@ -907,7 +885,7 @@ pv_wrap_append_preload (GPtrArray *argv, return; } - if ((flags & PV_APPEND_PRELOAD_FLAGS_REMOVE_GAME_OVERLAY) + if (context->options.remove_game_overlay && g_str_has_suffix (preload, "/gameoverlayrenderer.so")) { g_info ("Disabling Steam Overlay: %s", preload); @@ -921,13 +899,11 @@ pv_wrap_append_preload (GPtrArray *argv, case SRT_LOADABLE_KIND_BASENAME: /* Basenames can't have dynamic string tokens. */ g_warn_if_fail ((loadable_flags & SRT_LOADABLE_FLAGS_DYNAMIC_TOKENS) == 0); - append_preload_basename (argv, + append_preload_basename (context, + argv, which, preload, - env, - flags, - runtime, - exports); + flags); break; case SRT_LOADABLE_KIND_PATH: @@ -935,40 +911,34 @@ pv_wrap_append_preload (GPtrArray *argv, if (loadable_flags & (SRT_LOADABLE_FLAGS_ORIGIN | SRT_LOADABLE_FLAGS_UNKNOWN_TOKENS)) { - append_preload_unsupported_token (argv, + append_preload_unsupported_token (context, + argv, which, preload, - env, - flags, - runtime, - exports); + flags); } else if (loadable_flags & SRT_LOADABLE_FLAGS_ABI_DEPENDENT) { g_debug ("Found $LIB or $PLATFORM in \"%s\", splitting architectures", preload); - append_preload_per_architecture (argv, + append_preload_per_architecture (context, + argv, which, preload, - env, - flags, - runtime, - exports); + flags); } else { /* All dynamic tokens should be handled above, so we can * assume that preload is a concrete filename */ g_warn_if_fail ((loadable_flags & SRT_LOADABLE_FLAGS_DYNAMIC_TOKENS) == 0); - append_preload_internal (argv, + append_preload_internal (context, + argv, which, PV_UNSPECIFIED_ABI, preload, preload, - env, - flags, - runtime, - exports); + flags); } break; @@ -1161,9 +1131,7 @@ static const EnvMount known_required_env[] = static void bind_and_propagate_from_environ (PvWrapContext *self, - SrtSysroot *sysroot, PvHomeMode home_mode, - FlatpakExports *exports, SrtEnvOverlay *container_env, const char *variable, EnvMountFlags flags, @@ -1171,14 +1139,18 @@ bind_and_propagate_from_environ (PvWrapContext *self, { g_auto(GStrv) values = NULL; FlatpakFilesystemMode mode = FLATPAK_FILESYSTEM_MODE_READ_WRITE; + SrtSysroot *sysroot; const char *value; const char *before; const char *after; gboolean changed = FALSE; gsize i; - g_return_if_fail (exports != NULL); + g_return_if_fail (PV_IS_WRAP_CONTEXT (self)); + g_return_if_fail (self->exports != NULL); g_return_if_fail (variable != NULL); + sysroot = self->current_root; + g_return_if_fail (sysroot != NULL); if (home_mode != PV_HOME_MODE_SHARED && (flags & ENV_MOUNT_FLAGS_IF_HOME_SHARED)) @@ -1232,7 +1204,6 @@ bind_and_propagate_from_environ (PvWrapContext *self, value_host = pv_current_namespace_path_to_host_path (canon); if (!pv_wrap_context_export_if_allowed (self, - exports, mode, canon, value_host, @@ -1260,15 +1231,9 @@ bind_and_propagate_from_environ (PvWrapContext *self, } } -/* - * @exports: (nullable): List of exported directories, or %NULL if running - * a Flatpak subsandbox - */ void pv_bind_and_propagate_from_environ (PvWrapContext *self, - SrtSysroot *sysroot, PvHomeMode home_mode, - FlatpakExports *exports, SrtEnvOverlay *container_env) { gsize i; @@ -1281,13 +1246,12 @@ pv_bind_and_propagate_from_environ (PvWrapContext *self, { const char *name = known_required_env[i].name; - if (exports != NULL) + if (self->exports != NULL) { /* If we're using bubblewrap directly, we can and must make * sure that all required directories are bind-mounted */ - bind_and_propagate_from_environ (self, sysroot, home_mode, - exports, container_env, - name, + bind_and_propagate_from_environ (self, home_mode, + container_env, name, known_required_env[i].flags, known_required_env[i].export_flags); } diff --git a/pressure-vessel/wrap-setup.h b/pressure-vessel/wrap-setup.h index 936314a4d0901c4947798b462bc6b112340518ba..26d1c7e40d59566bb944fe1b5369a50092fd1dc4 100644 --- a/pressure-vessel/wrap-setup.h +++ b/pressure-vessel/wrap-setup.h @@ -66,7 +66,6 @@ void pv_wrap_move_into_scope (const char *steam_app_id); * PvAppendPreloadFlags: * @PV_APPEND_PRELOAD_FLAGS_FLATPAK_SUBSANDBOX: The game will be run in * a Flatpak subsandbox - * @PV_APPEND_PRELOAD_FLAGS_REMOVE_GAME_OVERLAY: Disable the Steam Overlay * @PV_APPEND_PRELOAD_FLAGS_IN_UNIT_TESTS: Normalize $LIB and $PLATFORM, * for unit testing * @PV_APPEND_PRELOAD_FLAGS_ONE_ARCHITECTURE: Behave as though there is @@ -78,19 +77,16 @@ void pv_wrap_move_into_scope (const char *steam_app_id); typedef enum { PV_APPEND_PRELOAD_FLAGS_FLATPAK_SUBSANDBOX = (1 << 0), - PV_APPEND_PRELOAD_FLAGS_REMOVE_GAME_OVERLAY = (1 << 1), PV_APPEND_PRELOAD_FLAGS_IN_UNIT_TESTS = (1 << 2), PV_APPEND_PRELOAD_FLAGS_ONE_ARCHITECTURE = (1 << 3), PV_APPEND_PRELOAD_FLAGS_NONE = 0 } PvAppendPreloadFlags; -void pv_wrap_append_preload (GPtrArray *argv, +void pv_wrap_append_preload (PvWrapContext *context, + GPtrArray *argv, PvPreloadVariableIndex which, const char *preload, - GStrv env, - PvAppendPreloadFlags flags, - PvRuntime *runtime, - FlatpakExports *exports); + PvAppendPreloadFlags flags); gboolean pv_wrap_maybe_load_nvidia_modules (GError **error); @@ -100,7 +96,5 @@ void pv_wrap_detect_virtualization (SrtSysroot **interpreter_root_out, void pv_share_temp_dir (FlatpakExports *exports, SrtEnvOverlay *container_env); void pv_bind_and_propagate_from_environ (PvWrapContext *self, - SrtSysroot *sysroot, PvHomeMode home_mode, - FlatpakExports *exports, SrtEnvOverlay *container_env); diff --git a/pressure-vessel/wrap.c b/pressure-vessel/wrap.c index eddd59e0057a40e780ca0eb150dc2ba14c7c7560..de714d16c4a899563f1390c0d4300aa4bbdcacb7 100644 --- a/pressure-vessel/wrap.c +++ b/pressure-vessel/wrap.c @@ -86,7 +86,6 @@ main (int argc, g_autoptr(FlatpakBwrap) bwrap_home_arguments = NULL; g_autoptr(FlatpakBwrap) argv_in_container = NULL; g_autoptr(FlatpakBwrap) final_argv = NULL; - g_autoptr(FlatpakExports) exports = NULL; g_autoptr(SrtSysroot) real_root = NULL; g_autoptr(SrtSysroot) interpreter_root = NULL; g_autofree gchar *bwrap_executable = NULL; @@ -95,9 +94,7 @@ main (int argc, g_autofree gchar *cwd_l = NULL; g_autofree gchar *cwd_p_host = NULL; g_autofree gchar *private_home = NULL; - const gchar *home; g_autofree gchar *tools_dir = NULL; - g_autoptr(PvRuntime) runtime = NULL; glnx_autofd int original_stdout = -1; glnx_autofd int original_stderr = -1; const char *graphics_provider_mount_point = NULL; @@ -130,7 +127,18 @@ main (int argc, goto out; } - self = pv_wrap_context_new (error); + /* FEX-Emu transparently rewrites most file I/O to check its "rootfs" + * first, and only use the real root if the corresponding file + * doesn't exist in the "rootfs". In many places we actively don't want + * this, because we're inspecting paths in order to pass them to bwrap, + * which will use them to set up bind-mounts, which are not subject to + * FEX-Emu's rewriting; so bypass it here. */ + real_root = _srt_sysroot_new_real_root (error); + + if (real_root == NULL) + return FALSE; + + self = pv_wrap_context_new (real_root, g_get_home_dir (), error); if (self == NULL) goto out; @@ -232,8 +240,6 @@ main (int argc, else steam_app_id = _srt_get_steam_app_id (); - home = g_get_home_dir (); - if (self->options.share_home == TRISTATE_YES) { home_mode = PV_HOME_MODE_SHARED; @@ -250,7 +256,7 @@ main (int argc, else if (self->options.freedesktop_app_id) { home_mode = PV_HOME_MODE_PRIVATE; - private_home = g_build_filename (home, ".var", "app", + private_home = g_build_filename (self->current_home, ".var", "app", self->options.freedesktop_app_id, NULL); } @@ -259,7 +265,7 @@ main (int argc, home_mode = PV_HOME_MODE_PRIVATE; self->options.freedesktop_app_id = g_strdup_printf ("com.steampowered.App%s", steam_app_id); - private_home = g_build_filename (home, ".var", "app", + private_home = g_build_filename (self->current_home, ".var", "app", self->options.freedesktop_app_id, NULL); } @@ -438,17 +444,6 @@ main (int argc, goto out; } - /* FEX-Emu transparently rewrites most file I/O to check its "rootfs" - * first, and only use the real root if the corresponding file - * doesn't exist in the "rootfs". In many places we actively don't want - * this, because we're inspecting paths in order to pass them to bwrap, - * which will use them to set up bind-mounts, which are not subject to - * FEX-Emu's rewriting; so bypass it here. */ - real_root = _srt_sysroot_new_real_root (error); - - if (real_root == NULL) - return FALSE; - /* Invariant: we are in exactly one of these two modes */ g_assert (((flatpak_subsandbox != NULL) + (!self->is_flatpak_env)) @@ -461,7 +456,7 @@ main (int argc, g_assert (bwrap_executable != NULL); flatpak_bwrap_add_arg (bwrap, bwrap_executable); bwrap_filesystem_arguments = flatpak_bwrap_new (flatpak_bwrap_empty_env); - exports = flatpak_exports_new (); + self->exports = flatpak_exports_new (); } else { @@ -469,7 +464,7 @@ main (int argc, } /* Invariant: we have bwrap or exports iff we also have the other */ - g_assert ((bwrap != NULL) == (exports != NULL)); + g_assert ((bwrap != NULL) == (self->exports != NULL)); g_assert ((bwrap != NULL) == (bwrap_filesystem_arguments != NULL)); g_assert ((bwrap != NULL) == (bwrap_executable != NULL)); @@ -479,7 +474,7 @@ main (int argc, { FlatpakFilesystemMode sysfs_mode = FLATPAK_FILESYSTEM_MODE_READ_ONLY; - g_assert (exports != NULL); + g_assert (self->exports != NULL); g_assert (bwrap_filesystem_arguments != NULL); if ((_srt_util_get_log_flags () & SRT_LOG_FLAGS_LEVEL) @@ -678,21 +673,21 @@ main (int argc, goto out; } - runtime = pv_runtime_new (runtime_path, - self->options.variable_dir, - bwrap_executable, - graphics_provider, - interpreter_host_provider, - _srt_const_strv (self->original_environ), - flags, - workarounds, - error); - - if (runtime == NULL) + self->runtime = pv_runtime_new (runtime_path, + self->options.variable_dir, + bwrap_executable, + graphics_provider, + interpreter_host_provider, + _srt_const_strv (self->original_environ), + flags, + workarounds, + error); + + if (self->runtime == NULL) goto out; - if (!pv_runtime_bind (runtime, - exports, + if (!pv_runtime_bind (self->runtime, + self->exports, bwrap_filesystem_arguments, container_env, error)) @@ -700,8 +695,8 @@ main (int argc, if (flatpak_subsandbox != NULL) { - const char *app = pv_runtime_get_modified_app (runtime); - const char *usr = pv_runtime_get_modified_usr (runtime); + const char *app = pv_runtime_get_modified_app (self->runtime); + const char *usr = pv_runtime_get_modified_usr (self->runtime); flatpak_bwrap_add_args (flatpak_subsandbox, "--app-path", app == NULL ? "" : app, @@ -726,10 +721,10 @@ main (int argc, g_assert (!self->is_flatpak_env); g_assert (bwrap != NULL); g_assert (bwrap_filesystem_arguments != NULL); - g_assert (exports != NULL); + g_assert (self->exports != NULL); if (!pv_wrap_use_host_os (_srt_sysroot_get_fd (real_root), - exports, bwrap_filesystem_arguments, + self->exports, bwrap_filesystem_arguments, cmp, error)) goto out; } @@ -739,9 +734,9 @@ main (int argc, * so that it can be overridden by --filesystem=/home or * pv_wrap_use_home(), and so that it is sorted correctly with * respect to all the other home-directory-related exports. */ - if (exports != NULL + if (self->exports != NULL && g_file_test ("/home", G_FILE_TEST_EXISTS)) - pv_exports_mask_or_log (exports, "/home"); + pv_exports_mask_or_log (self->exports, "/home"); g_debug ("Making home directory available..."); @@ -766,12 +761,12 @@ main (int argc, g_assert (!self->is_flatpak_env); g_assert (bwrap != NULL); g_assert (bwrap_filesystem_arguments != NULL); - g_assert (exports != NULL); + g_assert (self->exports != NULL); bwrap_home_arguments = flatpak_bwrap_new (flatpak_bwrap_empty_env); - if (!pv_wrap_use_home (home_mode, home, private_home, - exports, bwrap_home_arguments, container_env, + if (!pv_wrap_use_home (home_mode, self->current_home, private_home, + self->exports, bwrap_home_arguments, container_env, error)) goto out; } @@ -793,8 +788,8 @@ main (int argc, } } - if (exports != NULL) - pv_share_temp_dir (exports, container_env); + if (self->exports != NULL) + pv_share_temp_dir (self->exports, container_env); if (flatpak_subsandbox != NULL) { @@ -821,9 +816,6 @@ main (int argc, adverb_preload_argv = g_ptr_array_new_with_free_func (g_free); - if (self->options.remove_game_overlay) - append_preload_flags |= PV_APPEND_PRELOAD_FLAGS_REMOVE_GAME_OVERLAY; - /* We need the LD_PRELOADs from Steam visible at the paths that were * used for them, which might be their physical rather than logical * locations. Steam doesn't generally use LD_AUDIT, but the Steam app @@ -842,19 +834,16 @@ main (int argc, g_assert (module->which >= 0); g_assert (module->which < G_N_ELEMENTS (pv_preload_variables)); - pv_wrap_append_preload (adverb_preload_argv, + pv_wrap_append_preload (self, + adverb_preload_argv, module->which, module->preload, - environ, - append_preload_flags, - runtime, - exports); + append_preload_flags); } } while (0); - pv_bind_and_propagate_from_environ (self, real_root, home_mode, - exports, container_env); + pv_bind_and_propagate_from_environ (self, home_mode, container_env); if (flatpak_subsandbox == NULL) { @@ -862,27 +851,27 @@ main (int argc, g_assert (bwrap != NULL); g_assert (bwrap_filesystem_arguments != NULL); - g_assert (exports != NULL); + g_assert (self->exports != NULL); /* Bind-mount /run/udev to support games that detect joysticks by using * udev directly. We only do that when the host's version of libudev.so.1 * is in use, because there is no guarantees that the container's libudev * is compatible with the host's udevd. */ - if (runtime != NULL) + if (self->runtime != NULL) { for (i = 0; i < PV_N_SUPPORTED_ARCHITECTURES; i++) { GStatBuf ignored; g_autofree gchar *override = NULL; - override = g_build_filename (pv_runtime_get_overrides (runtime), + override = g_build_filename (pv_runtime_get_overrides (self->runtime), "lib", pv_multiarch_tuples[i], "libudev.so.1", NULL); if (g_lstat (override, &ignored) == 0) { g_debug ("We are using the host's version of \"libudev.so.1\", trying to bind-mount /run/udev too..."); - pv_exports_expose_or_log (exports, + pv_exports_expose_or_log (self->exports, FLATPAK_FILESYSTEM_MODE_READ_ONLY, "/run/udev"); break; @@ -900,7 +889,7 @@ main (int argc, g_warning ("Not sharing %s with container to work around %s", framework_paths->path, framework_paths->bug); else - pv_exports_expose_or_log (exports, + pv_exports_expose_or_log (self->exports, FLATPAK_FILESYSTEM_MODE_READ_ONLY, framework_paths->path); } @@ -912,7 +901,7 @@ main (int argc, g_debug ("Processing --filesystem arguments..."); for (i = 0; self->options.filesystems[i] != NULL; i++) - pv_wrap_context_export_if_allowed (self, exports, + pv_wrap_context_export_if_allowed (self, FLATPAK_FILESYSTEM_MODE_READ_WRITE, self->options.filesystems[i], self->options.filesystems[i], @@ -926,7 +915,7 @@ main (int argc, cwd_p_host = pv_current_namespace_path_to_host_path (cwd_p); - if (_srt_is_same_file (home, cwd_p)) + if (_srt_is_same_file (self->current_home, cwd_p)) { g_info ("Not making physical working directory \"%s\" available to " "container because it is the home directory", @@ -941,7 +930,7 @@ main (int argc, * current namespace as well as in the host, because it's * either in our ~/.var/app/$FLATPAK_ID, or a --filesystem that * was exposed from the host. */ - pv_exports_expose_or_warn (exports, + pv_exports_expose_or_warn (self->exports, FLATPAK_FILESYSTEM_MODE_READ_WRITE, cwd_p_host); } @@ -961,7 +950,7 @@ main (int argc, /* Put Steam Runtime environment variables back, if /usr is mounted * from the host. */ - if (runtime == NULL) + if (self->runtime == NULL) { g_debug ("Making Steam Runtime available..."); @@ -977,10 +966,10 @@ main (int argc, /* $STEAM_RUNTIME is functionally necessary if used, so * always warn if it cannot be exposed */ - if (exports != NULL + if (self->exports != NULL && g_str_has_prefix (self->options.env_if_host[i], "STEAM_RUNTIME=/")) - pv_exports_expose_or_warn (exports, + pv_exports_expose_or_warn (self->exports, FLATPAK_FILESYSTEM_MODE_READ_ONLY, equals + 1); @@ -995,7 +984,7 @@ main (int argc, } /* Convert the exported directories into extra bubblewrap arguments */ - if (exports != NULL) + if (self->exports != NULL) { g_autoptr(FlatpakBwrap) exports_bwrap = flatpak_bwrap_new (flatpak_bwrap_empty_env); @@ -1014,9 +1003,10 @@ main (int argc, g_clear_pointer (&bwrap_home_arguments, flatpak_bwrap_free); } - flatpak_exports_append_bwrap_args (exports, exports_bwrap); + flatpak_exports_append_bwrap_args (self->exports, exports_bwrap); g_warn_if_fail (g_strv_length (exports_bwrap->envp) == 0); - if (!pv_bwrap_append_adjusted_exports (bwrap, exports_bwrap, home, + if (!pv_bwrap_append_adjusted_exports (bwrap, exports_bwrap, + self->current_home, interpreter_root, workarounds, error)) goto out; @@ -1035,11 +1025,12 @@ main (int argc, sharing_bwrap = pv_wrap_share_sockets (container_env, _srt_const_strv (self->original_environ), - (runtime != NULL), + (self->runtime != NULL), self->is_flatpak_env); g_warn_if_fail (g_strv_length (sharing_bwrap->envp) == 0); - if (!pv_bwrap_append_adjusted_exports (bwrap, sharing_bwrap, home, + if (!pv_bwrap_append_adjusted_exports (bwrap, sharing_bwrap, + self->current_home, interpreter_root, workarounds, error)) goto out; @@ -1049,9 +1040,9 @@ main (int argc, pv_wrap_set_icons_env_vars (container_env, _srt_const_strv (self->original_environ)); } - if (runtime != NULL) + if (self->runtime != NULL) { - if (!pv_runtime_use_shared_sockets (runtime, bwrap, container_env, + if (!pv_runtime_use_shared_sockets (self->runtime, bwrap, container_env, error)) goto out; } @@ -1143,11 +1134,11 @@ main (int argc, adverb_argv = flatpak_bwrap_new (flatpak_bwrap_empty_env); - if (runtime != NULL) + if (self->runtime != NULL) { /* This includes the arguments necessary to regenerate the * ld.so cache */ - if (!pv_runtime_get_adverb (runtime, adverb_argv, error)) + if (!pv_runtime_get_adverb (self->runtime, adverb_argv, error)) goto out; } else @@ -1338,11 +1329,11 @@ main (int argc, if (_srt_util_is_debugging ()) { - if (runtime != NULL && (pv_log_flags & PV_WRAP_LOG_FLAGS_OVERRIDES)) - pv_runtime_log_overrides (runtime); + if (self->runtime != NULL && (pv_log_flags & PV_WRAP_LOG_FLAGS_OVERRIDES)) + pv_runtime_log_overrides (self->runtime); - if (runtime != NULL && (pv_log_flags & PV_WRAP_LOG_FLAGS_CONTAINER)) - pv_runtime_log_container (runtime); + if (self->runtime != NULL && (pv_log_flags & PV_WRAP_LOG_FLAGS_CONTAINER)) + pv_runtime_log_container (self->runtime); g_debug ("Final command to execute:"); @@ -1366,8 +1357,8 @@ main (int argc, } /* Clean up temporary directory before running our long-running process */ - if (runtime != NULL) - pv_runtime_cleanup (runtime); + if (self->runtime != NULL) + pv_runtime_cleanup (self->runtime); flatpak_bwrap_finish (final_argv); diff --git a/tests/pressure-vessel/wrap-setup.c b/tests/pressure-vessel/wrap-setup.c index c238b8af06900e43ec96e1a75602aba15b34726b..0dfada91955d445b01be26a559cd48076dcad146 100644 --- a/tests/pressure-vessel/wrap-setup.c +++ b/tests/pressure-vessel/wrap-setup.c @@ -83,7 +83,6 @@ typedef struct gchar *tmpdir; gchar *mock_runtime; gchar *var; - GStrv env; int tmpdir_fd; int mock_runtime_fd; int var_fd; @@ -172,25 +171,26 @@ fixture_populate_dir (Fixture *f, } } -static FlatpakExports * +static void fixture_create_exports (Fixture *f) { - g_autoptr(FlatpakExports) exports = flatpak_exports_new (); glnx_autofd int fd = open_or_die (f->mock_host->path, O_RDONLY | O_DIRECTORY, 0755); - flatpak_exports_take_host_fd (exports, g_steal_fd (&fd)); - return g_steal_pointer (&exports); + g_return_if_fail (f->context->exports == NULL); + f->context->exports = flatpak_exports_new (); + flatpak_exports_take_host_fd (f->context->exports, g_steal_fd (&fd)); } -static PvRuntime * +static void fixture_create_runtime (Fixture *f, PvRuntimeFlags flags) { g_autoptr(GError) local_error = NULL; g_autoptr(PvGraphicsProvider) graphics_provider = NULL; - g_autoptr(PvRuntime) runtime = NULL; const char *gfx_in_container; + g_assert_null (f->context->runtime); + if (flags & PV_RUNTIME_FLAGS_FLATPAK_SUBSANDBOX) gfx_in_container = "/run/parent"; else @@ -201,20 +201,19 @@ fixture_create_runtime (Fixture *f, g_assert_no_error (local_error); g_assert_nonnull (graphics_provider); - runtime = pv_runtime_new (f->mock_runtime, - f->var, - NULL, - graphics_provider, - NULL, - _srt_peek_environ_nonnull (), - (flags - | PV_RUNTIME_FLAGS_VERBOSE - | PV_RUNTIME_FLAGS_SINGLE_THREAD), - PV_WORKAROUND_FLAGS_NONE, - &local_error); + f->context->runtime = pv_runtime_new (f->mock_runtime, + f->var, + NULL, + graphics_provider, + NULL, + _srt_peek_environ_nonnull (), + (flags + | PV_RUNTIME_FLAGS_VERBOSE + | PV_RUNTIME_FLAGS_SINGLE_THREAD), + PV_WORKAROUND_FLAGS_NONE, + &local_error); g_assert_no_error (local_error); - g_assert_nonnull (runtime); - return g_steal_pointer (&runtime); + g_assert_nonnull (f->context->runtime); } static void @@ -243,10 +242,16 @@ setup (Fixture *f, glnx_opendirat (AT_FDCWD, f->var, TRUE, &f->var_fd, &local_error); g_assert_no_error (local_error); - f->context = pv_wrap_context_new (&local_error); + f->context = pv_wrap_context_new (f->mock_host, "/home/me", &local_error); g_assert_no_error (local_error); f->bwrap = flatpak_bwrap_new (flatpak_bwrap_empty_env); - f->env = g_get_environ (); + + /* Some tests need to know where Steam is installed; + * pretend that we have it installed in /steam */ + f->context->original_environ = g_environ_setenv (f->context->original_environ, + "STEAM_COMPAT_CLIENT_INSTALL_PATH", + "/steam", + TRUE); } static void @@ -285,9 +290,6 @@ setup_ld_preload (Fixture *f, fixture_populate_dir (f, f->mock_host->fd, touch_i386, G_N_ELEMENTS (touch_i386)); #endif } - - f->env = g_environ_setenv (f->env, "STEAM_COMPAT_CLIENT_INSTALL_PATH", - "/steam", TRUE); } static void @@ -311,7 +313,6 @@ teardown (Fixture *f, g_clear_pointer (&f->mock_runtime, g_free); g_clear_pointer (&f->tmpdir, g_free); g_clear_pointer (&f->var, g_free); - g_clear_pointer (&f->env, g_strfreev); g_clear_pointer (&f->bwrap, flatpak_bwrap_free); tests_check_fd_leaks_leave (f->old_fds); @@ -376,15 +377,15 @@ test_bind_into_container (Fixture *f, gconstpointer context) { const Config *config = context; - g_autoptr(PvRuntime) runtime = NULL; g_autoptr(GError) error = NULL; gboolean ok; - runtime = fixture_create_runtime (f, config->runtime_flags); + fixture_create_runtime (f, config->runtime_flags); + g_assert_nonnull (f->context->runtime); /* Successful cases */ - ok = pv_runtime_bind_into_container (runtime, f->bwrap, + ok = pv_runtime_bind_into_container (f->context->runtime, f->bwrap, "/etc/machine-id", NULL, 0, "/etc/machine-id", PV_RUNTIME_EMULATION_ROOTS_BOTH, @@ -392,7 +393,7 @@ test_bind_into_container (Fixture *f, g_assert_no_error (error); g_assert_true (ok); - ok = pv_runtime_bind_into_container (runtime, f->bwrap, + ok = pv_runtime_bind_into_container (f->context->runtime, f->bwrap, "/etc/arm-file", NULL, 0, "/etc/arm-file", PV_RUNTIME_EMULATION_ROOTS_REAL_ONLY, @@ -400,7 +401,7 @@ test_bind_into_container (Fixture *f, g_assert_no_error (error); g_assert_true (ok); - ok = pv_runtime_bind_into_container (runtime, f->bwrap, + ok = pv_runtime_bind_into_container (f->context->runtime, f->bwrap, "/fex/etc/x86-file", NULL, 0, "/etc/x86-file", PV_RUNTIME_EMULATION_ROOTS_INTERPRETER_ONLY, @@ -410,7 +411,7 @@ test_bind_into_container (Fixture *f, /* Error cases */ - ok = pv_runtime_bind_into_container (runtime, f->bwrap, + ok = pv_runtime_bind_into_container (f->context->runtime, f->bwrap, "/nope", NULL, 0, "/nope", PV_RUNTIME_EMULATION_ROOTS_REAL_ONLY, @@ -420,7 +421,7 @@ test_bind_into_container (Fixture *f, g_test_message ("Editing /nope not allowed, as expected: %s", error->message); g_clear_error (&error); - ok = pv_runtime_bind_into_container (runtime, f->bwrap, + ok = pv_runtime_bind_into_container (f->context->runtime, f->bwrap, "/usr/foo", NULL, 0, "/usr/foo", PV_RUNTIME_EMULATION_ROOTS_BOTH, @@ -617,18 +618,20 @@ test_export_root_dirs (Fixture *f, "usr/local/", "var/tmp/", }; - g_autoptr(FlatpakExports) exports = fixture_create_exports (f); g_autoptr(GError) local_error = NULL; gboolean ret; + fixture_create_exports (f); + g_assert_nonnull (f->context->exports); fixture_populate_dir (f, f->mock_host->fd, paths, G_N_ELEMENTS (paths)); - ret = pv_export_root_dirs_like_filesystem_host (f->mock_host->fd, exports, + ret = pv_export_root_dirs_like_filesystem_host (f->mock_host->fd, + f->context->exports, FLATPAK_FILESYSTEM_MODE_READ_WRITE, _srt_dirent_strcmp, &local_error); g_assert_no_error (local_error); g_assert_true (ret); - flatpak_exports_append_bwrap_args (exports, f->bwrap); + flatpak_exports_append_bwrap_args (f->context->exports, f->bwrap); dump_bwrap (f->bwrap); @@ -1021,12 +1024,12 @@ test_make_symlink_in_container (Fixture *f, { const Config *config = context; g_autoptr(GError) error = NULL; - g_autoptr(PvRuntime) runtime = NULL; gboolean ok; SrtSysroot *mutable_sysroot; - runtime = fixture_create_runtime (f, config->runtime_flags); - mutable_sysroot = pv_runtime_get_mutable_sysroot (runtime); + fixture_create_runtime (f, config->runtime_flags); + g_assert_nonnull (f->context->runtime); + mutable_sysroot = pv_runtime_get_mutable_sysroot (f->context->runtime); if (config->runtime_flags & PV_RUNTIME_FLAGS_COPY_RUNTIME) g_assert_nonnull (mutable_sysroot); @@ -1035,7 +1038,7 @@ test_make_symlink_in_container (Fixture *f, /* Successful cases */ - ok = pv_runtime_make_symlink_in_container (runtime, f->bwrap, + ok = pv_runtime_make_symlink_in_container (f->context->runtime, f->bwrap, "../usr/lib/os-release", "/etc/os-release", PV_RUNTIME_EMULATION_ROOTS_BOTH, @@ -1043,7 +1046,7 @@ test_make_symlink_in_container (Fixture *f, g_assert_no_error (error); g_assert_true (ok); - ok = pv_runtime_make_symlink_in_container (runtime, f->bwrap, + ok = pv_runtime_make_symlink_in_container (f->context->runtime, f->bwrap, "/run/host/foo", "/var/foo", PV_RUNTIME_EMULATION_ROOTS_REAL_ONLY, @@ -1051,7 +1054,7 @@ test_make_symlink_in_container (Fixture *f, g_assert_no_error (error); g_assert_true (ok); - ok = pv_runtime_make_symlink_in_container (runtime, f->bwrap, + ok = pv_runtime_make_symlink_in_container (f->context->runtime, f->bwrap, "/run/x86/bar", "/var/bar", PV_RUNTIME_EMULATION_ROOTS_INTERPRETER_ONLY, @@ -1061,7 +1064,7 @@ test_make_symlink_in_container (Fixture *f, /* Conditionally OK, if there is an on-disk directory we can edit */ - ok = pv_runtime_make_symlink_in_container (runtime, f->bwrap, + ok = pv_runtime_make_symlink_in_container (f->context->runtime, f->bwrap, "/run/host/foo", "/usr/foo", PV_RUNTIME_EMULATION_ROOTS_REAL_ONLY, @@ -1090,7 +1093,7 @@ test_make_symlink_in_container (Fixture *f, } - ok = pv_runtime_make_symlink_in_container (runtime, f->bwrap, + ok = pv_runtime_make_symlink_in_container (f->context->runtime, f->bwrap, "/run/x86/bar", "/usr/bar", PV_RUNTIME_EMULATION_ROOTS_INTERPRETER_ONLY, @@ -1110,7 +1113,7 @@ test_make_symlink_in_container (Fixture *f, g_assert_true (ok); } - ok = pv_runtime_make_symlink_in_container (runtime, f->bwrap, + ok = pv_runtime_make_symlink_in_container (f->context->runtime, f->bwrap, "/run/baz", "/usr/baz", PV_RUNTIME_EMULATION_ROOTS_BOTH, @@ -1140,7 +1143,7 @@ test_make_symlink_in_container (Fixture *f, /* Error cases */ - ok = pv_runtime_make_symlink_in_container (runtime, f->bwrap, + ok = pv_runtime_make_symlink_in_container (f->context->runtime, f->bwrap, "/nope", "/nope", PV_RUNTIME_EMULATION_ROOTS_REAL_ONLY, @@ -1554,9 +1557,7 @@ test_passwd (Fixture *f, static void populate_ld_preload (Fixture *f, GPtrArray *argv, - PvAppendPreloadFlags flags, - PvRuntime *runtime, - FlatpakExports *exports) + PvAppendPreloadFlags flags) { static const struct { @@ -1589,6 +1590,11 @@ populate_ld_preload (Fixture *f, }; gsize i; + if (flags & PV_APPEND_PRELOAD_FLAGS_FLATPAK_SUBSANDBOX) + g_assert_null (f->context->exports); + else + g_assert_nonnull (f->context->exports); + for (i = 0; i < G_N_ELEMENTS (preloads); i++) { GLogLevelFlags old_fatal_mask = G_LOG_FATAL_MASK; @@ -1611,13 +1617,11 @@ populate_ld_preload (Fixture *f, preloads[i].warning); } - pv_wrap_append_preload (argv, + pv_wrap_append_preload (f->context, + argv, PV_PRELOAD_VARIABLE_INDEX_LD_PRELOAD, preloads[i].string, - f->env, - flags | PV_APPEND_PRELOAD_FLAGS_IN_UNIT_TESTS, - runtime, - exports); + flags | PV_APPEND_PRELOAD_FLAGS_IN_UNIT_TESTS); /* If we modified the fatal mask, put back the old value. */ if (preloads[i].warning != NULL) @@ -1694,10 +1698,9 @@ test_remap_ld_preload (Fixture *f, gconstpointer context) { const Config *config = context; - g_autoptr(FlatpakExports) exports = fixture_create_exports (f); + FlatpakExports *exports; g_autoptr(GPtrArray) argv = g_ptr_array_new_with_free_func (g_free); g_autoptr(GPtrArray) filtered = filter_expected_paths (config); - g_autoptr(PvRuntime) runtime = fixture_create_runtime (f, PV_RUNTIME_FLAGS_NONE); gsize i; gboolean expect_i386 = FALSE; @@ -1706,7 +1709,13 @@ test_remap_ld_preload (Fixture *f, expect_i386 = TRUE; #endif - populate_ld_preload (f, argv, config->preload_flags, runtime, exports); + fixture_create_exports (f); + exports = f->context->exports; + g_assert_nonnull (exports); + + fixture_create_runtime (f, PV_RUNTIME_FLAGS_NONE); + g_assert_nonnull (f->context->runtime); + populate_ld_preload (f, argv, config->preload_flags); g_assert_cmpuint (argv->len, ==, filtered->len); @@ -1786,13 +1795,13 @@ test_remap_ld_preload_flatpak (Fixture *f, const Config *config = context; g_autoptr(GPtrArray) argv = g_ptr_array_new_with_free_func (g_free); g_autoptr(GPtrArray) filtered = filter_expected_paths (config); - g_autoptr(PvRuntime) runtime = fixture_create_runtime (f, PV_RUNTIME_FLAGS_FLATPAK_SUBSANDBOX); gsize i; + fixture_create_runtime (f, PV_RUNTIME_FLAGS_FLATPAK_SUBSANDBOX); + g_assert_nonnull (f->context->runtime); populate_ld_preload (f, argv, (config->preload_flags - | PV_APPEND_PRELOAD_FLAGS_FLATPAK_SUBSANDBOX), - runtime, NULL); + | PV_APPEND_PRELOAD_FLAGS_FLATPAK_SUBSANDBOX)); g_assert_cmpuint (argv->len, ==, filtered->len); @@ -1818,8 +1827,7 @@ test_remap_ld_preload_flatpak (Fixture *f, /* * In addition to testing the rare case where there's no runtime, - * this one also exercises PV_APPEND_PRELOAD_FLAGS_REMOVE_GAME_OVERLAY, - * which is the implementation of --remove-game-overlay. + * this one also exercises --remove-game-overlay. */ static void test_remap_ld_preload_no_runtime (Fixture *f, @@ -1828,19 +1836,23 @@ test_remap_ld_preload_no_runtime (Fixture *f, const Config *config = context; g_autoptr(GPtrArray) argv = g_ptr_array_new_with_free_func (g_free); g_autoptr(GPtrArray) filtered = filter_expected_paths (config); - g_autoptr(FlatpakExports) exports = fixture_create_exports (f); + FlatpakExports *exports; gsize i, j; gboolean expect_i386 = FALSE; + f->context->options.remove_game_overlay = TRUE; + #if defined(__i386__) || defined(__x86_64__) if (!(config->preload_flags & PV_APPEND_PRELOAD_FLAGS_ONE_ARCHITECTURE)) expect_i386 = TRUE; #endif - populate_ld_preload (f, argv, - (config->preload_flags - | PV_APPEND_PRELOAD_FLAGS_REMOVE_GAME_OVERLAY), - NULL, exports); + fixture_create_exports (f); + exports = f->context->exports; + g_assert_nonnull (exports); + + g_assert_null (f->context->runtime); + populate_ld_preload (f, argv, config->preload_flags); g_assert_cmpuint (argv->len, ==, filtered->len - 1); @@ -1853,7 +1865,7 @@ test_remap_ld_preload_no_runtime (Fixture *f, argument += strlen("--ld-preload="); /* /steam/lib/gameoverlayrenderer.so is missing because we used the - * REMOVE_GAME_OVERLAY flag */ + * equivalent of --remove-game-overlay */ if (g_str_has_suffix (expected, "/gameoverlayrenderer.so")) { /* We expect to skip only one element */ @@ -1920,10 +1932,10 @@ test_remap_ld_preload_flatpak_no_runtime (Fixture *f, g_autoptr(GPtrArray) filtered = filter_expected_paths (config); gsize i; + g_assert_null (f->context->runtime); populate_ld_preload (f, argv, (config->preload_flags - | PV_APPEND_PRELOAD_FLAGS_FLATPAK_SUBSANDBOX), - NULL, NULL); + | PV_APPEND_PRELOAD_FLAGS_FLATPAK_SUBSANDBOX)); g_assert_cmpuint (argv->len, ==, filtered->len); @@ -2065,13 +2077,17 @@ test_use_home_shared (Fixture *f, NULL }; g_autoptr(FlatpakBwrap) env_bwrap = NULL; - g_autoptr(FlatpakExports) exports = fixture_create_exports (f); - g_autoptr(FlatpakExports) env_exports = fixture_create_exports (f); + FlatpakExports *exports; + FlatpakExports *env_exports; g_autoptr(GError) local_error = NULL; g_autoptr(SrtEnvOverlay) container_env = _srt_env_overlay_new (); GLogLevelFlags was_fatal; gboolean ret; + fixture_create_exports (f); + exports = f->context->exports; + g_assert_nonnull (exports); + fixture_populate_dir (f, f->mock_host->fd, paths, G_N_ELEMENTS (paths)); ret = pv_wrap_use_home (PV_HOME_MODE_SHARED, "/home/user", NULL, exports, f->bwrap, container_env, &local_error); @@ -2138,12 +2154,17 @@ test_use_home_shared (Fixture *f, g_clear_pointer (&f->context->original_environ, g_strfreev); f->context->original_environ = _srt_strdupv (mock_environ); + g_clear_pointer (&f->context->exports, flatpak_exports_free); + exports = NULL; + + fixture_create_exports (f); + env_exports = f->context->exports; + g_assert_nonnull (env_exports); + /* Don't crash on warnings here */ was_fatal = g_log_set_always_fatal (G_LOG_LEVEL_ERROR | G_LOG_LEVEL_CRITICAL); pv_bind_and_propagate_from_environ (f->context, - f->mock_host, PV_HOME_MODE_SHARED, - env_exports, container_env); g_log_set_always_fatal (was_fatal); @@ -2210,16 +2231,17 @@ test_use_host_os (Fixture *f, "usr/local/", "var/tmp/", }; - g_autoptr(FlatpakExports) exports = fixture_create_exports (f); g_autoptr(GError) local_error = NULL; gboolean ret; + fixture_create_exports (f); + g_assert_nonnull (f->context->exports); fixture_populate_dir (f, f->mock_host->fd, paths, G_N_ELEMENTS (paths)); - ret = pv_wrap_use_host_os (f->mock_host->fd, exports, f->bwrap, + ret = pv_wrap_use_host_os (f->mock_host->fd, f->context->exports, f->bwrap, _srt_dirent_strcmp, &local_error); g_assert_no_error (local_error); g_assert_true (ret); - flatpak_exports_append_bwrap_args (exports, f->bwrap); + flatpak_exports_append_bwrap_args (f->context->exports, f->bwrap); dump_bwrap (f->bwrap);