gboolean
xdg_app_builtin_build_export (int argc, char **argv, GCancellable *cancellable, GError **error)
{
gboolean ret = FALSE;
g_autoptr(GOptionContext) context = NULL;
g_autoptr(GFile) base = NULL;
g_autoptr(GFile) files = NULL;
g_autoptr(GFile) metadata = NULL;
g_autoptr(GFile) export = NULL;
g_autoptr(GFile) repofile = NULL;
g_autoptr(GFile) arg = NULL;
g_autoptr(GFile) root = NULL;
g_autoptr(OstreeRepo) repo = NULL;
const char *location;
const char *directory;
const char *branch;
g_autofree char *arch = NULL;
g_autofree char *full_branch = NULL;
g_autofree char *app_id = NULL;
g_autofree char *parent = NULL;
g_autofree char *commit_checksum = NULL;
g_autofree char *metadata_contents = NULL;
g_autofree char *format_size = NULL;
g_autoptr(OstreeMutableTree) mtree = NULL;
g_autoptr(GKeyFile) metakey = NULL;
gsize metadata_size;
g_autofree char *subject = NULL;
g_autofree char *body = NULL;
OstreeRepoTransactionStats stats;
OstreeRepoCommitModifier *modifier = NULL;
context = g_option_context_new ("LOCATION DIRECTORY [BRANCH] - Create a repository from a build directory");
if (!xdg_app_option_context_parse (context, options, &argc, &argv, XDG_APP_BUILTIN_FLAG_NO_DIR, NULL, cancellable, error))
goto out;
if (argc < 3)
{
usage_error (context, "LOCATION and DIRECTORY must be specified", error);
goto out;
}
location = argv[1];
directory = argv[2];
if (argc >= 4)
branch = argv[3];
else
branch = "master";
if (!xdg_app_is_valid_branch (branch))
{
xdg_app_fail (error, "'%s' is not a valid branch name", branch);
goto out;
}
base = g_file_new_for_commandline_arg (directory);
files = g_file_get_child (base, "files");
metadata = g_file_get_child (base, "metadata");
export = g_file_get_child (base, "export");
gboolean
xdg_app_builtin_dump_runtime (int argc, char **argv, GCancellable *cancellable, GError **error)
{
g_autoptr(GOptionContext) context = NULL;
g_autoptr(XdgAppDir) dir = NULL;
const char *runtime;
const char *branch = "master";
g_autofree char *ref = NULL;
OstreeRepo *repo;
g_autofree char *commit = NULL;
g_autoptr(GFile) root = NULL;
context = g_option_context_new ("RUNTIME BRANCH - Make branch of application current");
if (!xdg_app_option_context_parse (context, options, &argc, &argv, 0, &dir, cancellable, error))
return FALSE;
if (argc < 3)
return usage_error (context, "RUNTIME and BRANCH must be specified", error);
runtime = argv[1];
branch = argv[2];
if (!xdg_app_is_valid_name (runtime))
return xdg_app_fail (error, "'%s' is not a valid name", runtime);
if (!xdg_app_is_valid_branch (branch))
return xdg_app_fail (error, "'%s' is not a valid branch name", branch);
ref = xdg_app_build_runtime_ref (runtime, branch, opt_arch);
repo = xdg_app_dir_get_repo (dir);
if (!ostree_repo_read_commit (repo, ref,
&root, &commit, cancellable, error))
return FALSE;
#ifdef HAVE_LIBARCHIVE
return dump_runtime (root, cancellable, error);
#else
return xdg_app_fail (error, "Build without libarchive");
#endif
}
gboolean
xdg_app_builtin_make_current_app (int argc, char **argv, GCancellable *cancellable, GError **error)
{
g_autoptr(GOptionContext) context = NULL;
g_autoptr(XdgAppDir) dir = NULL;
g_autoptr(GFile) deploy_base = NULL;
const char *app;
const char *branch = "master";
g_autofree char *ref = NULL;
context = g_option_context_new ("APP BRANCH - Make branch of application current");
if (!xdg_app_option_context_parse (context, options, &argc, &argv, 0, &dir, cancellable, error))
return FALSE;
if (argc < 3)
return usage_error (context, "APP and BRANCH must be specified", error);
app = argv[1];
branch = argv[2];
if (!xdg_app_is_valid_name (app))
return xdg_app_fail (error, "'%s' is not a valid application name", app);
if (!xdg_app_is_valid_branch (branch))
return xdg_app_fail (error, "'%s' is not a valid branch name", branch);
ref = xdg_app_build_app_ref (app, branch, opt_arch);
deploy_base = xdg_app_dir_get_deploy_dir (dir, ref);
if (!g_file_query_exists (deploy_base, cancellable))
return xdg_app_fail (error, "App %s branch %s is not installed", app, branch);
if (!xdg_app_dir_make_current_ref (dir, ref, cancellable, error))
return FALSE;
if (!xdg_app_dir_update_exports (dir, app, cancellable, error))
return FALSE;
return TRUE;
}
gboolean
xdg_app_builtin_repo_update (int argc, char **argv, GCancellable *cancellable, GError **error)
{
g_autoptr(GOptionContext) context = NULL;
g_autoptr(GFile) repofile = NULL;
g_autoptr(OstreeRepo) repo = NULL;
const char *location;
GVariant *extra = NULL;
context = g_option_context_new ("LOCATION - Update repository metadata");
if (!xdg_app_option_context_parse (context, options, &argc, &argv, XDG_APP_BUILTIN_FLAG_NO_DIR, NULL, cancellable, error))
return FALSE;
if (argc < 2)
return usage_error (context, "LOCATION must be specified", error);
location = argv[1];
repofile = g_file_new_for_commandline_arg (location);
repo = ostree_repo_new (repofile);
if (!ostree_repo_open (repo, cancellable, error))
return FALSE;
if (opt_title)
{
GVariantBuilder builder;
g_variant_builder_init (&builder, G_VARIANT_TYPE_VARDICT);
g_variant_builder_add (&builder, "{sv}", "xa.title", g_variant_new_string (opt_title));
extra = g_variant_builder_end (&builder);
}
if (!ostree_repo_regenerate_summary (repo, extra, cancellable, error))
return FALSE;
/* TODO: appstream data */
return TRUE;
}
gboolean
xdg_app_builtin_update (int argc, char **argv, GCancellable *cancellable, GError **error)
{
g_autoptr(GOptionContext) context = NULL;
g_autoptr(XdgAppDir) dir = NULL;
const char *name;
const char *branch = NULL;
g_autofree char *ref = NULL;
g_autofree char *repository = NULL;
gboolean was_updated;
gboolean is_app;
g_auto(GLnxLockFile) lock = GLNX_LOCK_FILE_INIT;
context = g_option_context_new ("NAME [BRANCH] - Update an application or runtime");
if (!xdg_app_option_context_parse (context, options, &argc, &argv, 0, &dir, cancellable, error))
return FALSE;
if (argc < 2)
return usage_error (context, "NAME must be specified", error);
name = argv[1];
if (argc >= 3)
branch = argv[2];
if (!opt_app && !opt_runtime)
opt_app = opt_runtime = TRUE;
if (opt_appdata)
return update_appdata (dir, name, cancellable, error);
ref = xdg_app_dir_find_installed_ref (dir,
name,
branch,
opt_arch,
opt_app, opt_runtime, &is_app,
error);
if (ref == NULL)
return FALSE;
repository = xdg_app_dir_get_origin (dir, ref, cancellable, error);
if (repository == NULL)
return FALSE;
if (!opt_no_pull)
{
if (!xdg_app_dir_pull (dir, repository, ref, NULL,
cancellable, error))
return FALSE;
}
if (!opt_no_deploy)
{
if (!xdg_app_dir_lock (dir, &lock,
cancellable, error))
return FALSE;
if (!xdg_app_dir_deploy_update (dir, ref, opt_commit, &was_updated, cancellable, error))
return FALSE;
if (was_updated && is_app)
{
if (!xdg_app_dir_update_exports (dir, name, cancellable, error))
return FALSE;
}
glnx_release_lock_file (&lock);
}
if (was_updated)
{
if (!xdg_app_dir_prune (dir, cancellable, error))
return FALSE;
if (!xdg_app_dir_mark_changed (dir, error))
return FALSE;
}
xdg_app_dir_cleanup_removed (dir, cancellable, NULL);
return TRUE;
}
gboolean
xdg_app_builtin_build_init (int argc, char **argv, GCancellable *cancellable, GError **error)
{
g_autoptr(GOptionContext) context = NULL;
g_autoptr(GFile) var_deploy_base = NULL;
g_autoptr(GFile) var_deploy_files = NULL;
g_autoptr(GFile) base = NULL;
g_autoptr(GFile) files_dir = NULL;
g_autoptr(GFile) var_dir = NULL;
g_autoptr(GFile) var_tmp_dir = NULL;
g_autoptr(GFile) var_run_dir = NULL;
g_autoptr(GFile) metadata_file = NULL;
const char *app_id;
const char *directory;
const char *sdk;
const char *runtime;
const char *branch = "master";
g_autofree char *runtime_ref = NULL;
g_autofree char *var_ref = NULL;
g_autofree char *sdk_ref = NULL;
g_autofree char *metadata_contents = NULL;
context = g_option_context_new ("DIRECTORY APPNAME SDK RUNTIME [BRANCH] - Initialize a directory for building");
if (!xdg_app_option_context_parse (context, options, &argc, &argv, XDG_APP_BUILTIN_FLAG_NO_DIR, NULL, cancellable, error))
return FALSE;
if (argc < 5)
return usage_error (context, "RUNTIME must be specified", error);
directory = argv[1];
app_id = argv[2];
sdk = argv[3];
runtime = argv[4];
if (argc >= 6)
branch = argv[5];
if (!xdg_app_is_valid_name (app_id))
return xdg_app_fail (error, "'%s' is not a valid application name", app_id);
if (!xdg_app_is_valid_name (runtime))
return xdg_app_fail (error, "'%s' is not a valid runtime name", runtime);
if (!xdg_app_is_valid_name (sdk))
return xdg_app_fail (error, "'%s' is not a valid sdk name", sdk);
if (!xdg_app_is_valid_branch (branch))
return xdg_app_fail (error, "'%s' is not a valid branch name", branch);
runtime_ref = xdg_app_build_untyped_ref (runtime, branch, opt_arch);
sdk_ref = xdg_app_build_untyped_ref (sdk, branch, opt_arch);
base = g_file_new_for_commandline_arg (directory);
if (!gs_file_ensure_directory (base, TRUE, cancellable, error))
return FALSE;
files_dir = g_file_get_child (base, "files");
var_dir = g_file_get_child (base, "var");
var_tmp_dir = g_file_get_child (var_dir, "tmp");
var_run_dir = g_file_get_child (var_dir, "run");
metadata_file = g_file_get_child (base, "metadata");
if (g_file_query_exists (files_dir, cancellable))
return xdg_app_fail (error, "Build directory %s already initialized", directory);
if (opt_var)
{
var_ref = xdg_app_build_runtime_ref (opt_var, branch, opt_arch);
var_deploy_base = xdg_app_find_deploy_dir_for_ref (var_ref, cancellable, error);
if (var_deploy_base == NULL)
return FALSE;
var_deploy_files = g_file_get_child (var_deploy_base, "files");
}
if (!g_file_make_directory (files_dir, cancellable, error))
return FALSE;
if (var_deploy_files)
{
if (!gs_shutil_cp_a (var_deploy_files, var_dir, cancellable, error))
return FALSE;
}
else
{
if (!g_file_make_directory (var_dir, cancellable, error))
return FALSE;
}
if (!gs_file_ensure_directory (var_tmp_dir, FALSE, cancellable, error))
return FALSE;
if (!g_file_query_exists (var_run_dir, cancellable) &&
!g_file_make_symbolic_link (var_run_dir, "/run", cancellable, error))
return FALSE;
metadata_contents = g_strdup_printf("[Application]\n"
"name=%s\n"
"runtime=%s\n"
"sdk=%s\n",
app_id, runtime_ref, sdk_ref);
if (!g_file_replace_contents (metadata_file,
metadata_contents, strlen (metadata_contents), NULL, FALSE,
G_FILE_CREATE_REPLACE_DESTINATION,
NULL, cancellable, error))
return FALSE;
return TRUE;
}
gboolean
xdg_app_builtin_uninstall (int argc, char **argv, GCancellable *cancellable, GError **error)
{
g_autoptr(GOptionContext) context = NULL;
g_autoptr(XdgAppDir) dir = NULL;
const char *name = NULL;
const char *branch = NULL;
g_autofree char *ref = NULL;
g_autofree char *repository = NULL;
g_autofree char *current_ref = NULL;
gboolean was_deployed;
gboolean is_app;
g_auto(GLnxLockFile) lock = GLNX_LOCK_FILE_INIT;
context = g_option_context_new ("APP [BRANCH] - Uninstall an application");
if (!xdg_app_option_context_parse (context, options, &argc, &argv, 0, &dir, cancellable, error))
return FALSE;
if (argc < 2)
return usage_error (context, "APP must be specified", error);
name = argv[1];
if (argc > 2)
branch = argv[2];
if (!opt_app && !opt_runtime)
opt_app = opt_runtime = TRUE;
ref = xdg_app_dir_find_installed_ref (dir,
name,
branch,
opt_arch,
opt_app, opt_runtime, &is_app,
error);
if (ref == NULL)
return FALSE;
/* TODO: when removing runtimes, look for apps that use it, require --force */
if (!xdg_app_dir_lock (dir, &lock,
cancellable, error))
return FALSE;
repository = xdg_app_dir_get_origin (dir, ref, cancellable, NULL);
g_debug ("dropping active ref");
if (!xdg_app_dir_set_active (dir, ref, NULL, cancellable, error))
return FALSE;
if (is_app)
{
current_ref = xdg_app_dir_current_ref (dir, name, cancellable);
if (current_ref != NULL && strcmp (ref, current_ref) == 0)
{
g_debug ("dropping current ref");
if (!xdg_app_dir_drop_current_ref (dir, name, cancellable, error))
return FALSE;
}
}
if (!xdg_app_dir_undeploy_all (dir, ref, opt_force_remove, &was_deployed, cancellable, error))
return FALSE;
if (!opt_keep_ref)
{
if (!xdg_app_dir_remove_ref (dir, repository, ref, cancellable, error))
return FALSE;
}
glnx_release_lock_file (&lock);
if (!opt_keep_ref)
{
if (!xdg_app_dir_prune (dir, cancellable, error))
return FALSE;
}
xdg_app_dir_cleanup_removed (dir, cancellable, NULL);
if (is_app)
{
if (!xdg_app_dir_update_exports (dir, name, cancellable, error))
return FALSE;
}
if (repository != NULL &&
g_str_has_suffix (repository, "-origin") &&
xdg_app_dir_get_remote_noenumerate (dir, repository))
{
ostree_repo_remote_delete (xdg_app_dir_get_repo (dir), repository, NULL, NULL);
}
if (!xdg_app_dir_mark_changed (dir, error))
return FALSE;
if (!was_deployed)
return xdg_app_fail (error, "Nothing to uninstall");
return TRUE;
}
gboolean
xdg_app_builtin_install (int argc, char **argv, GCancellable *cancellable, GError **error)
{
gboolean ret = FALSE;
g_autoptr(GOptionContext) context = NULL;
g_autoptr(XdgAppDir) dir = NULL;
g_autoptr(GFile) deploy_base = NULL;
const char *repository;
const char *name;
const char *branch = NULL;
g_autofree char *ref = NULL;
g_autofree char *installed_ref = NULL;
gboolean is_app;
gboolean created_deploy_base = FALSE;
g_auto(GLnxLockFile) lock = GLNX_LOCK_FILE_INIT;
g_autoptr(GError) my_error = NULL;
context = g_option_context_new ("REPOSITORY NAME [BRANCH] - Install an application or runtime");
if (!xdg_app_option_context_parse (context, options, &argc, &argv, 0, &dir, cancellable, error))
return FALSE;
if (opt_bundle)
return install_bundle (dir, context, argc, argv, cancellable, error);
if (argc < 3)
return usage_error (context, "REPOSITORY and NAME must be specified", error);
repository = argv[1];
name = argv[2];
if (argc >= 4)
branch = argv[3];
if (!opt_app && !opt_runtime)
opt_app = opt_runtime = TRUE;
installed_ref = xdg_app_dir_find_installed_ref (dir,
name,
branch,
opt_arch,
opt_app, opt_runtime, &is_app,
&my_error);
if (installed_ref != NULL)
{
return xdg_app_fail (error, "%s %s, branch %s is already installed",
is_app ? "App" : "Runtime", name, branch ? branch : "master");
}
if (!g_error_matches (my_error, G_IO_ERROR, G_IO_ERROR_NOT_FOUND))
{
g_propagate_error (error, g_steal_pointer (&my_error));
return FALSE;
}
ref = xdg_app_dir_find_remote_ref (dir, repository, name, branch, opt_arch,
opt_app, opt_runtime, &is_app, cancellable, error);
if (ref == NULL)
return FALSE;
deploy_base = xdg_app_dir_get_deploy_dir (dir, ref);
if (g_file_query_exists (deploy_base, cancellable))
return xdg_app_fail (error, "Ref %s already deployed", ref);
if (!opt_no_pull)
{
if (!xdg_app_dir_pull (dir, repository, ref, NULL,
cancellable, error))
return FALSE;
}
/* After we create the deploy base we must goto out on errors */
if (!opt_no_deploy)
{
if (!xdg_app_dir_lock (dir, &lock,
cancellable, error))
goto out;
if (!g_file_make_directory_with_parents (deploy_base, cancellable, error))
goto out;
created_deploy_base = TRUE;
if (!xdg_app_dir_set_origin (dir, ref, repository, cancellable, error))
goto out;
if (!xdg_app_dir_deploy (dir, ref, NULL, cancellable, error))
goto out;
if (is_app)
{
if (!xdg_app_dir_make_current_ref (dir, ref, cancellable, error))
goto out;
if (!xdg_app_dir_update_exports (dir, name, cancellable, error))
goto out;
}
glnx_release_lock_file (&lock);
}
xdg_app_dir_cleanup_removed (dir, cancellable, NULL);
if (!xdg_app_dir_mark_changed (dir, error))
goto out;
ret = TRUE;
out:
if (created_deploy_base && !ret)
gs_shutil_rm_rf (deploy_base, cancellable, NULL);
return ret;
}
gboolean
xdg_app_builtin_repo_contents (int argc, char **argv, GCancellable *cancellable, GError **error)
{
gboolean ret = FALSE;
GOptionContext *context;
g_autoptr(XdgAppDir) dir = NULL;
OstreeRepo *repo = NULL;
g_autoptr(GHashTable) refs = NULL;
g_autofree char *title = NULL;
GHashTableIter iter;
gpointer key;
gpointer value;
g_autoptr(GPtrArray) names = NULL;
int i;
const char *repository;
g_autofree char *url = NULL;
g_autoptr(GBytes) bytes = NULL;
context = g_option_context_new (" REPOSITORY - Show available runtimes and applications");
if (!xdg_app_option_context_parse (context, options, &argc, &argv, 0, &dir, cancellable, error))
goto out;
if (argc < 2)
{
usage_error (context, "REPOSITORY must be specified", error);
goto out;
}
repository = argv[1];
repo = xdg_app_dir_get_repo (dir);
if (!ostree_repo_remote_get_url (repo, repository, &url, error))
goto out;
if (!ostree_repo_load_summary (url, &refs, &title, cancellable, error))
goto out;
names = g_ptr_array_new_with_free_func (g_free);
g_hash_table_iter_init (&iter, refs);
while (g_hash_table_iter_next (&iter, &key, &value))
{
const char *refspec = key;
const char *checksum = value;
g_autofree char *remote = NULL;
g_autofree char *ref = NULL;
char *name = NULL;
char *p;
if (!ostree_parse_refspec (refspec, &remote, &ref, error))
goto out;
if (remote != NULL && !g_str_equal (remote, repository))
continue;
if (opt_only_updates)
{
g_autofree char *deployed = NULL;
deployed = xdg_app_dir_read_active (dir, ref, cancellable);
if (deployed == NULL)
continue;
if (g_strcmp0 (deployed, checksum) == 0)
continue;
}
if (g_str_has_prefix (ref, "runtime/") && !opt_only_apps)
{
if (!opt_show_details)
{
name = g_strdup (ref + strlen ("runtime/"));
p = strchr (name, '/');
if (p)
*p = 0;
}
else
{
name = g_strdup (ref);
}
}
if (g_str_has_prefix (ref, "app/") && !opt_only_runtimes)
{
if (!opt_show_details)
{
name = g_strdup (ref + strlen ("app/"));
p = strchr (name, '/');
if (p)
*p = 0;
}
else
{
name = g_strdup (ref);
}
}
if (name)
{
gboolean found = FALSE;
for (i = 0; i < names->len; i++)
{
if (strcmp (name, g_ptr_array_index (names, i)) == 0)
found = TRUE;
break;
}
if (!found)
g_ptr_array_add (names, name);
else
g_free (name);
}
}
g_ptr_array_sort (names, (GCompareFunc)strcmp);
for (i = 0; i < names->len; i++)
g_print ("%s\n", (char *)g_ptr_array_index (names, i));
ret = TRUE;
out:
if (context)
g_option_context_free (context);
return ret;
}
gboolean
xdg_app_builtin_run (int argc, char **argv, GCancellable *cancellable, GError **error)
{
g_autoptr(GOptionContext) context = NULL;
g_autoptr(XdgAppDeploy) app_deploy = NULL;
g_autoptr(XdgAppDeploy) runtime_deploy = NULL;
g_autoptr(GFile) app_files = NULL;
g_autoptr(GFile) runtime_files = NULL;
g_autoptr(GFile) app_id_dir = NULL;
g_autoptr(GFile) app_cache_dir = NULL;
g_autoptr(GFile) app_data_dir = NULL;
g_autoptr(GFile) app_config_dir = NULL;
g_autoptr(GFile) home = NULL;
g_autoptr(GFile) user_font1 = NULL;
g_autoptr(GFile) user_font2 = NULL;
g_autoptr(XdgAppSessionHelper) session_helper = NULL;
g_autofree char *runtime = NULL;
g_autofree char *default_command = NULL;
g_autofree char *runtime_ref = NULL;
g_autofree char *app_ref = NULL;
g_autofree char *doc_mount_path = NULL;
g_autoptr(GKeyFile) metakey = NULL;
g_autoptr(GKeyFile) runtime_metakey = NULL;
g_autoptr(GPtrArray) argv_array = NULL;
g_auto(GStrv) envp = NULL;
g_autoptr(GPtrArray) dbus_proxy_argv = NULL;
g_autofree char *monitor_path = NULL;
const char *app;
const char *branch = "master";
const char *command = "/bin/sh";
int i;
int rest_argv_start, rest_argc;
int sync_proxy_pipes[2];
g_autoptr(XdgAppContext) arg_context = NULL;
g_autoptr(XdgAppContext) app_context = NULL;
g_autoptr(XdgAppContext) overrides = NULL;
g_autoptr(GDBusConnection) session_bus = NULL;
context = g_option_context_new ("APP [args...] - Run an app");
rest_argc = 0;
for (i = 1; i < argc; i++)
{
/* The non-option is the command, take it out of the arguments */
if (argv[i][0] != '-')
{
rest_argv_start = i;
rest_argc = argc - i;
argc = i;
break;
}
}
arg_context = xdg_app_context_new ();
g_option_context_add_group (context, xdg_app_context_get_options (arg_context));
if (!xdg_app_option_context_parse (context, options, &argc, &argv, XDG_APP_BUILTIN_FLAG_NO_DIR, NULL, cancellable, error))
return FALSE;
if (rest_argc == 0)
return usage_error (context, "APP must be specified", error);
app = argv[rest_argv_start];
if (opt_branch)
branch = opt_branch;
if (!xdg_app_is_valid_name (app))
return xdg_app_fail (error, "'%s' is not a valid application name", app);
if (!xdg_app_is_valid_branch (branch))
return xdg_app_fail (error, "'%s' is not a valid branch name", branch);
app_ref = xdg_app_build_app_ref (app, branch, opt_arch);
app_deploy = xdg_app_find_deploy_for_ref (app_ref, cancellable, error);
if (app_deploy == NULL)
return FALSE;
metakey = xdg_app_deploy_get_metadata (app_deploy);
argv_array = g_ptr_array_new_with_free_func (g_free);
dbus_proxy_argv = g_ptr_array_new_with_free_func (g_free);
g_ptr_array_add (argv_array, g_strdup (HELPER));
g_ptr_array_add (argv_array, g_strdup ("-l"));
if (!xdg_app_run_add_extension_args (argv_array, metakey, app_ref, cancellable, error))
return FALSE;
if (opt_runtime)
runtime = opt_runtime;
else
{
runtime = g_key_file_get_string (metakey, "Application", opt_devel ? "sdk" : "runtime", error);
if (*error)
return FALSE;
}
runtime_ref = g_build_filename ("runtime", runtime, NULL);
runtime_deploy = xdg_app_find_deploy_for_ref (runtime_ref, cancellable, error);
if (runtime_deploy == NULL)
return FALSE;
runtime_metakey = xdg_app_deploy_get_metadata (runtime_deploy);
app_context = xdg_app_context_new ();
if (!xdg_app_context_load_metadata (app_context, runtime_metakey, error))
return FALSE;
if (!xdg_app_context_load_metadata (app_context, metakey, error))
return FALSE;
overrides = xdg_app_deploy_get_overrides (app_deploy);
xdg_app_context_merge (app_context, overrides);
xdg_app_context_merge (app_context, arg_context);
if (!xdg_app_run_add_extension_args (argv_array, runtime_metakey, runtime_ref, cancellable, error))
return FALSE;
if ((app_id_dir = xdg_app_ensure_data_dir (app, cancellable, error)) == NULL)
return FALSE;
app_cache_dir = g_file_get_child (app_id_dir, "cache");
g_ptr_array_add (argv_array, g_strdup ("-B"));
g_ptr_array_add (argv_array, g_strdup_printf ("/var/cache=%s", gs_file_get_path_cached (app_cache_dir)));
app_data_dir = g_file_get_child (app_id_dir, "data");
g_ptr_array_add (argv_array, g_strdup ("-B"));
g_ptr_array_add (argv_array, g_strdup_printf ("/var/data=%s", gs_file_get_path_cached (app_data_dir)));
app_config_dir = g_file_get_child (app_id_dir, "config");
g_ptr_array_add (argv_array, g_strdup ("-B"));
g_ptr_array_add (argv_array, g_strdup_printf ("/var/config=%s", gs_file_get_path_cached (app_config_dir)));
app_files = xdg_app_deploy_get_files (app_deploy);
runtime_files = xdg_app_deploy_get_files (runtime_deploy);
default_command = g_key_file_get_string (metakey, "Application", "command", error);
if (*error)
return FALSE;
if (opt_command)
command = opt_command;
else
command = default_command;
session_helper = xdg_app_session_helper_proxy_new_for_bus_sync (G_BUS_TYPE_SESSION,
G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES | G_DBUS_PROXY_FLAGS_DO_NOT_CONNECT_SIGNALS,
"org.freedesktop.XdgApp",
"/org/freedesktop/XdgApp/SessionHelper",
NULL, NULL);
if (session_helper &&
xdg_app_session_helper_call_request_monitor_sync (session_helper,
&monitor_path,
NULL, NULL))
{
g_ptr_array_add (argv_array, g_strdup ("-m"));
g_ptr_array_add (argv_array, monitor_path);
}
else
g_ptr_array_add (argv_array, g_strdup ("-r"));
session_bus = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, NULL);
if (session_bus)
{
g_autoptr (GError) local_error = NULL;
g_autoptr (GDBusMessage) reply = NULL;
g_autoptr (GDBusMessage) msg = g_dbus_message_new_method_call ("org.freedesktop.portal.Documents",
"/org/freedesktop/portal/documents",
"org.freedesktop.portal.Documents",
"GetMountPoint");
g_dbus_message_set_body (msg, g_variant_new ("()"));
reply = g_dbus_connection_send_message_with_reply_sync (session_bus, msg,
G_DBUS_SEND_MESSAGE_FLAGS_NONE,
30000,
NULL,
NULL,
NULL);
if (reply)
{
if (g_dbus_message_to_gerror (reply, &local_error))
{
g_warning ("Can't get document portal: %s\n", local_error->message);
}
else
g_variant_get (g_dbus_message_get_body (reply),
"(^ay)", &doc_mount_path);
}
}
xdg_app_run_add_environment_args (argv_array, dbus_proxy_argv, doc_mount_path,
app, app_context, app_id_dir);
g_ptr_array_add (argv_array, g_strdup ("-b"));
g_ptr_array_add (argv_array, g_strdup_printf ("/run/host/fonts=%s", SYSTEM_FONTS_DIR));
if (opt_devel)
g_ptr_array_add (argv_array, g_strdup ("-c"));
home = g_file_new_for_path (g_get_home_dir ());
user_font1 = g_file_resolve_relative_path (home, ".local/share/fonts");
user_font2 = g_file_resolve_relative_path (home, ".fonts");
if (g_file_query_exists (user_font1, NULL))
{
g_autofree char *path = g_file_get_path (user_font1);
g_ptr_array_add (argv_array, g_strdup ("-b"));
g_ptr_array_add (argv_array, g_strdup_printf ("/run/host/user-fonts=%s", path));
}
else if (g_file_query_exists (user_font2, NULL))
{
g_autofree char *path = g_file_get_path (user_font2);
g_ptr_array_add (argv_array, g_strdup ("-b"));
g_ptr_array_add (argv_array, g_strdup_printf ("/run/host/user-fonts=%s", path));
}
/* Must run this before spawning the dbus proxy, to ensure it
ends up in the app cgroup */
xdg_app_run_in_transient_unit (app);
if (dbus_proxy_argv->len > 0)
{
char x;
if (pipe (sync_proxy_pipes) < 0)
{
g_set_error (error, G_IO_ERROR, g_io_error_from_errno (errno), "Unable to create sync pipe");
return FALSE;
}
g_ptr_array_insert (dbus_proxy_argv, 0, g_strdup (DBUSPROXY));
g_ptr_array_insert (dbus_proxy_argv, 1, g_strdup_printf ("--fd=%d", sync_proxy_pipes[1]));
g_ptr_array_add (dbus_proxy_argv, NULL); /* NULL terminate */
if (!g_spawn_async (NULL,
(char **)dbus_proxy_argv->pdata,
NULL,
G_SPAWN_SEARCH_PATH,
dbus_spawn_child_setup,
GINT_TO_POINTER (sync_proxy_pipes[1]),
NULL, error))
return FALSE;
close (sync_proxy_pipes[1]);
/* Sync with proxy, i.e. wait until its listening on the sockets */
if (read (sync_proxy_pipes[0], &x, 1) != 1)
{
g_set_error (error, G_IO_ERROR, g_io_error_from_errno (errno), "Failed to sync with dbus proxy");
return FALSE;
}
g_ptr_array_add (argv_array, g_strdup ("-S"));
g_ptr_array_add (argv_array, g_strdup_printf ("%d", sync_proxy_pipes[0]));
}
g_ptr_array_add (argv_array, g_strdup ("-a"));
g_ptr_array_add (argv_array, g_file_get_path (app_files));
g_ptr_array_add (argv_array, g_strdup ("-I"));
g_ptr_array_add (argv_array, g_strdup (app));
g_ptr_array_add (argv_array, g_file_get_path (runtime_files));
g_ptr_array_add (argv_array, g_strdup (command));
for (i = 1; i < rest_argc; i++)
g_ptr_array_add (argv_array, g_strdup (argv[rest_argv_start + i]));
g_ptr_array_add (argv_array, NULL);
envp = g_get_environ ();
envp = xdg_app_run_apply_env_default (envp);
envp = xdg_app_run_apply_env_vars (envp, app_context);
envp = xdg_app_run_apply_env_appid (envp, app_id_dir);
if (execvpe (HELPER, (char **)argv_array->pdata, envp) == -1)
{
g_set_error (error, G_IO_ERROR, g_io_error_from_errno (errno), "Unable to start app");
return FALSE;
}
/* Not actually reached... */
return TRUE;
}
gboolean
xdg_app_builtin_run (int argc, char **argv, GCancellable *cancellable, GError **error)
{
GOptionContext *context;
gboolean ret = FALSE;
g_autoptr(GVariantBuilder) optbuilder = NULL;
g_autoptr(GFile) deploy_base = NULL;
g_autoptr(XdgAppDeploy) app_deploy = NULL;
g_autoptr(XdgAppDeploy) runtime_deploy = NULL;
g_autoptr(GFile) app_files = NULL;
g_autoptr(GFile) runtime_files = NULL;
g_autoptr(GFile) app_id_dir = NULL;
g_autoptr(XdgAppSessionHelper) session_helper = NULL;
g_autofree char *runtime = NULL;
g_autofree char *default_command = NULL;
g_autofree char *runtime_ref = NULL;
g_autofree char *app_ref = NULL;
g_autofree char *path = NULL;
g_autoptr(GKeyFile) metakey = NULL;
g_autoptr(GKeyFile) runtime_metakey = NULL;
g_autoptr(GPtrArray) argv_array = NULL;
glnx_strfreev char **envp = NULL;
g_autoptr(GPtrArray) dbus_proxy_argv = NULL;
g_autofree char *monitor_path = NULL;
const char *app;
const char *branch = "master";
const char *command = "/bin/sh";
int i;
int rest_argv_start, rest_argc;
int sync_proxy_pipes[2];
context = g_option_context_new ("APP [args...] - Run an app");
rest_argc = 0;
for (i = 1; i < argc; i++)
{
/* The non-option is the command, take it out of the arguments */
if (argv[i][0] != '-')
{
rest_argv_start = i;
rest_argc = argc - i;
argc = i;
break;
}
}
if (!xdg_app_option_context_parse (context, options, &argc, &argv, XDG_APP_BUILTIN_FLAG_NO_DIR, NULL, cancellable, error))
goto out;
if (rest_argc == 0)
{
usage_error (context, "APP must be specified", error);
goto out;
}
app = argv[rest_argv_start];
if (opt_branch)
branch = opt_branch;
if (!xdg_app_is_valid_name (app))
{
g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED, "'%s' is not a valid application name", app);
goto out;
}
if (!xdg_app_is_valid_branch (branch))
{
g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED, "'%s' is not a valid branch name", branch);
goto out;
}
app_ref = xdg_app_build_app_ref (app, branch, opt_arch);
app_deploy = xdg_app_find_deploy_for_ref (app_ref, cancellable, error);
if (app_deploy == NULL)
goto out;
metakey = xdg_app_deploy_get_metadata (app_deploy);
argv_array = g_ptr_array_new_with_free_func (g_free);
dbus_proxy_argv = g_ptr_array_new_with_free_func (g_free);
g_ptr_array_add (argv_array, g_strdup (HELPER));
g_ptr_array_add (argv_array, g_strdup ("-l"));
if (!add_extension_args (metakey, app_ref, argv_array, cancellable, error))
goto out;
if (opt_runtime)
runtime = opt_runtime;
else
{
runtime = g_key_file_get_string (metakey, "Application", opt_devel ? "sdk" : "runtime", error);
if (*error)
goto out;
}
runtime_ref = g_build_filename ("runtime", runtime, NULL);
runtime_deploy = xdg_app_find_deploy_for_ref (runtime_ref, cancellable, error);
if (runtime_deploy == NULL)
goto out;
runtime_metakey = xdg_app_deploy_get_metadata (runtime_deploy);
if (!add_extension_args (runtime_metakey, runtime_ref, argv_array, cancellable, error))
goto out;
if ((app_id_dir = xdg_app_ensure_data_dir (app, cancellable, error)) == NULL)
goto out;
app_files = xdg_app_deploy_get_files (app_deploy);
runtime_files = xdg_app_deploy_get_files (runtime_deploy);
default_command = g_key_file_get_string (metakey, "Application", "command", error);
if (*error)
goto out;
if (opt_command)
command = opt_command;
else
command = default_command;
session_helper = xdg_app_session_helper_proxy_new_for_bus_sync (G_BUS_TYPE_SESSION,
G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES | G_DBUS_PROXY_FLAGS_DO_NOT_CONNECT_SIGNALS,
"org.freedesktop.XdgApp.SessionHelper",
"/org/freedesktop/XdgApp/SessionHelper",
NULL, NULL);
if (session_helper)
{
if (xdg_app_session_helper_call_request_monitor_sync (session_helper,
&monitor_path,
NULL, NULL))
{
g_ptr_array_add (argv_array, g_strdup ("-m"));
g_ptr_array_add (argv_array, monitor_path);
}
}
if (!xdg_app_run_verify_environment_keys ((const char **)opt_forbid, error))
goto out;
if (!xdg_app_run_verify_environment_keys ((const char **)opt_allow, error))
goto out;
xdg_app_run_add_environment_args (argv_array, dbus_proxy_argv,
app, runtime_metakey, metakey,
(const char **)opt_allow,
(const char **)opt_forbid);
g_ptr_array_add (argv_array, g_strdup ("-b"));
g_ptr_array_add (argv_array, g_strdup_printf ("/run/host/fonts=%s", SYSTEM_FONTS_DIR));
/* Must run this before spawning the dbus proxy, to ensure it
ends up in the app cgroup */
xdg_app_run_in_transient_unit (app);
if (dbus_proxy_argv->len > 0)
{
char x;
if (pipe (sync_proxy_pipes) < 0)
{
g_set_error (error, G_IO_ERROR, g_io_error_from_errno (errno), "Unable to create sync pipe");
goto out;
}
g_ptr_array_insert (dbus_proxy_argv, 0, g_strdup ("xdg-dbus-proxy"));
g_ptr_array_insert (dbus_proxy_argv, 1, g_strdup_printf ("--fd=%d", sync_proxy_pipes[1]));
g_ptr_array_add (dbus_proxy_argv, NULL); /* NULL terminate */
if (!g_spawn_async (NULL,
(char **)dbus_proxy_argv->pdata,
NULL,
G_SPAWN_SEARCH_PATH,
dbus_spawn_child_setup,
GINT_TO_POINTER (sync_proxy_pipes[1]),
NULL, error))
goto out;
close (sync_proxy_pipes[1]);
/* Sync with proxy, i.e. wait until its listening on the sockets */
if (read (sync_proxy_pipes[0], &x, 1) != 1)
{
g_set_error (error, G_IO_ERROR, g_io_error_from_errno (errno), "Failed to sync with dbus proxy");
goto out;
}
g_ptr_array_add (argv_array, g_strdup ("-S"));
g_ptr_array_add (argv_array, g_strdup_printf ("%d", sync_proxy_pipes[0]));
}
g_ptr_array_add (argv_array, g_strdup ("-a"));
g_ptr_array_add (argv_array, g_file_get_path (app_files));
g_ptr_array_add (argv_array, g_strdup ("-I"));
g_ptr_array_add (argv_array, g_strdup (app));
g_ptr_array_add (argv_array, g_file_get_path (runtime_files));
g_ptr_array_add (argv_array, g_strdup (command));
for (i = 1; i < rest_argc; i++)
g_ptr_array_add (argv_array, g_strdup (argv[rest_argv_start + i]));
g_ptr_array_add (argv_array, NULL);
envp = g_get_environ ();
envp = xdg_app_run_apply_env_default (envp);
envp = xdg_app_run_apply_env_vars (envp, runtime_metakey);
/* Load application environment overrides *after* runtime */
envp = xdg_app_run_apply_env_vars (envp, metakey);
envp = xdg_app_run_apply_env_appid (envp, app_id_dir);
if (execvpe (HELPER, (char **)argv_array->pdata, envp) == -1)
{
g_set_error (error, G_IO_ERROR, g_io_error_from_errno (errno), "Unable to start app");
goto out;
}
/* Not actually reached... */
ret = TRUE;
out:
if (context)
g_option_context_free (context);
return ret;
}
