static void
file_builder_add_value (FileBuilder *fb,
GVariant *value,
struct gvdb_pointer *pointer)
{
GVariant *variant, *normal;
gpointer data;
gsize size;
if (fb->byteswap)
{
value = g_variant_byteswap (value);
variant = g_variant_new_variant (value);
g_variant_unref (value);
}
else
variant = g_variant_new_variant (value);
normal = g_variant_get_normal_form (variant);
g_variant_unref (variant);
size = g_variant_get_size (normal);
data = file_builder_allocate (fb, 8, size, pointer);
g_variant_store (normal, data);
g_variant_unref (normal);
}
static void
send_response (FileDialogHandle *handle)
{
GVariantBuilder opt_builder;
GVariant *options;
g_variant_builder_init (&opt_builder, G_VARIANT_TYPE_VARDICT);
g_variant_builder_add (&opt_builder, "{sv}", "writable", g_variant_new_variant (g_variant_new_boolean (handle->allow_write)));
add_choices (handle, &opt_builder);
options = g_variant_builder_end (&opt_builder);
if (handle->action == GTK_FILE_CHOOSER_ACTION_SAVE ||
(handle->action == GTK_FILE_CHOOSER_ACTION_OPEN && !handle->multiple))
{
const char *signal_name;
if (handle->action == GTK_FILE_CHOOSER_ACTION_SAVE)
signal_name = "SaveFileResponse";
else
signal_name = "OpenFileResponse";
dialog_handler_emit_response (handle,
"org.freedesktop.impl.portal.FileChooser",
signal_name,
g_variant_new ("(sous@a{sv})",
handle->base.sender,
handle->base.id,
handle->response,
handle->uris ? (char *)handle->uris->data : "",
options));
}
else
{
g_auto(GStrv) uris = NULL;
GSList *l;
gint i;
uris = g_new (char *, g_slist_length (handle->uris) + 1);
for (l = handle->uris, i = 0; l; l = l->next)
uris[i++] = l->data;
uris[i] = NULL;
g_slist_free (handle->uris);
handle->uris = NULL;
dialog_handler_emit_response (handle,
"org.freedesktop.impl.portal.FileChooser",
"OpenFilesResponse",
g_variant_new ("(sou^as@a{sv})",
handle->base.sender,
handle->base.id,
handle->response,
uris,
options));
}
file_dialog_handle_close (handle);
}
static void
test_data_init (TestData *td)
{
GError *local_error = NULL;
GError **error = &local_error;
g_autofree char *http_address = NULL;
g_autofree char *repo_url = NULL;
td->repo = ot_test_setup_repo (NULL, error);
if (!td->repo)
goto out;
if (!ot_test_run_libtest ("setup_fake_remote_repo1 archive-z2", error))
goto out;
if (!g_file_get_contents ("httpd-address", &http_address, NULL, error))
goto out;
repo_url = g_strconcat (http_address, "/ostree/gnomerepo", NULL);
{ g_autoptr(GVariantBuilder) builder = g_variant_builder_new (G_VARIANT_TYPE ("a{sv}"));
g_autoptr(GVariant) opts = NULL;
g_variant_builder_add (builder, "{s@v}", "gpg-verify", g_variant_new_variant (g_variant_new_boolean (FALSE)));
opts = g_variant_ref_sink (g_variant_builder_end (builder));
if (!ostree_repo_remote_change (td->repo, NULL, OSTREE_REPO_REMOTE_CHANGE_ADD,
"origin", repo_url, opts, NULL, error))
goto out;
}
out:
g_assert_no_error (local_error);
}
static GVariant *
get_repo_pull_options (const gchar *url_override,
const gchar *ref)
{
g_auto(GVariantBuilder) builder;
g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{sv}"));
if (url_override != NULL)
g_variant_builder_add (&builder, "{s@v}", "override-url",
g_variant_new_variant (g_variant_new_string (url_override)));
g_variant_builder_add (&builder, "{s@v}", "flags",
g_variant_new_variant (g_variant_new_int32 (OSTREE_REPO_PULL_FLAGS_COMMIT_ONLY)));
g_variant_builder_add (&builder, "{s@v}", "refs",
g_variant_new_variant (g_variant_new_strv (&ref, 1)));
return g_variant_ref_sink (g_variant_builder_end (&builder));
};
static GVariant *
gkd_secret_create_encode_result (GkdSecretPrompt *base)
{
GkdSecretCreate *self = GKD_SECRET_CREATE (base);
const gchar *path;
path = self->result_path ? self->result_path : "/";
return g_variant_new_variant (g_variant_new_object_path (path));
}
char *
do_create_doc (struct stat *parent_st_buf, const char *path, gboolean reuse_existing, gboolean persistent)
{
g_autoptr(GVariant) data = NULL;
g_autoptr (XdgAppDbEntry) entry = NULL;
g_auto(GStrv) ids = NULL;
char *id = NULL;
guint32 flags = 0;
if (!reuse_existing)
flags |= XDP_ENTRY_FLAG_UNIQUE;
if (!persistent)
flags |= XDP_ENTRY_FLAG_TRANSIENT;
data =
g_variant_ref_sink (g_variant_new ("(^ayttu)",
path,
(guint64)parent_st_buf->st_dev,
(guint64)parent_st_buf->st_ino,
flags));
if (reuse_existing)
{
ids = xdg_app_db_list_ids_by_value (db, data);
if (ids[0] != NULL)
return g_strdup (ids[0]); /* Reuse pre-existing entry with same path */
}
while (TRUE)
{
g_autoptr(XdgAppDbEntry) existing = NULL;
g_clear_pointer (&id, g_free);
id = xdp_name_from_id ((guint32)g_random_int ());
existing = xdg_app_db_lookup (db, id);
if (existing == NULL)
break;
}
g_debug ("create_doc %s", id);
entry = xdg_app_db_entry_new (data);
xdg_app_db_set_entry (db, id, entry);
if (persistent)
xdg_app_permission_store_call_set (permission_store,
TABLE_NAME,
TRUE,
id,
g_variant_new_array (G_VARIANT_TYPE("{sas}"), NULL, 0),
g_variant_new_variant (data),
NULL, NULL, NULL);
return id;
}
static gboolean
handle_request_session (FlatpakSessionHelper *object,
GDBusMethodInvocation *invocation,
gpointer user_data)
{
GVariantBuilder builder;
g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{sv}"));
g_variant_builder_add (&builder, "{s@v}", "path",
g_variant_new_variant (g_variant_new_string (monitor_dir)));
if (p11_kit_server_socket_path)
g_variant_builder_add (&builder, "{s@v}", "pkcs11-socket",
g_variant_new_variant (g_variant_new_string (p11_kit_server_socket_path)));
flatpak_session_helper_complete_request_session (object, invocation,
g_variant_builder_end (&builder));
return TRUE;
}
/*****************************************************************************
* neardal_set_adapter_property: Set a property on a specific NEARDAL adapter
****************************************************************************/
errorCode_t neardal_set_adapter_property(const char *adpName,
int adpPropId, void *value)
{
errorCode_t err = NEARDAL_SUCCESS;
AdpProp *adpProp = NULL;
const gchar *propKey = NULL;
GVariant *propValue = NULL;
GVariant *variantTmp = NULL;
if (neardalMgr.proxy == NULL)
neardal_prv_construct(&err);
if (err != NEARDAL_SUCCESS || adpName == NULL)
goto exit;
err = neardal_mgr_prv_get_adapter((gchar *) adpName, &adpProp);
if (err != NEARDAL_SUCCESS)
goto exit;
switch (adpPropId) {
case NEARD_ADP_PROP_POWERED:
propKey = "Powered";
variantTmp = g_variant_new_boolean(GPOINTER_TO_UINT(value));
g_variant_ref_sink(variantTmp);
break;
default:
break;
}
propValue = g_variant_new_variant(variantTmp);
g_variant_ref_sink(propValue);
NEARDAL_TRACE_LOG("Sending:\n%s=%s\n", propKey,
g_variant_print(propValue, TRUE));
properties_call_set_sync(adpProp->props, "org.neard.Adapter",
propKey, propValue, 0, &neardalMgr.gerror);
if (neardalMgr.gerror == NULL)
err = NEARDAL_SUCCESS;
else {
NEARDAL_TRACE_ERR(
"DBUS Error (%d): %s\n",
neardalMgr.gerror->code,
neardalMgr.gerror->message);
err = NEARDAL_ERROR_DBUS_INVOKE_METHOD_ERROR;
}
exit:
neardal_tools_prv_free_gerror(&neardalMgr.gerror);
neardalMgr.gerror = NULL;
g_variant_unref(propValue);
g_variant_unref(variantTmp);
return err;
}
void ofono_connection_manager_set_roaming_allowed(struct ofono_connection_manager *cm, bool roaming_allowed,
ofono_base_result_cb cb, void *data)
{
struct cb_data *cbd;
GVariant *value;
cbd = cb_data_new(cb, data);
value = g_variant_new_variant(g_variant_new_boolean(roaming_allowed));
ofono_base_set_property(cm->base, "RoamingAllowed",
value, set_roaming_allowed_cb, cbd);
}
gboolean connman_service_set_nameservers(connman_service_t *service, GStrv dns)
{
if(NULL == service || NULL == dns)
return FALSE;
GError *error = NULL;
connman_interface_service_call_set_property_sync(service->remote, "Nameservers.Configuration",
g_variant_new_variant(g_variant_new_strv((const gchar * const*)dns, g_strv_length(dns))), NULL, &error);
if (error)
{
WCA_LOG_CRITICAL("Error: %s", error->message);
g_error_free(error);
return FALSE;
}
return TRUE;
}
int ofono_modem_set_online(struct ofono_modem *modem, gboolean online, ofono_base_result_cb cb, gpointer user_data)
{
GVariant *value = NULL;
if (!modem)
return -EINVAL;
/* check wether we're already in the desired state */
if (online == modem->online) {
cb(NULL, user_data);
return 0;
}
value = g_variant_new_variant(g_variant_new_boolean(online));
ofono_base_set_property(modem->base, "Online", value, cb, user_data);
return -EINPROGRESS;
}
void post(SoupServer *server,
SoupMessage *msg,
const char *path)
{
JsonParser *parser = json_parser_new ();
GError *err = NULL;
g_debug("POST\n path= %s\nbody = '%s'", path, msg->request_body->data);
if (json_parser_load_from_data (parser, msg->request_body->data, -1, &err)) {
g_debug("parsed sucessfully");
GVariant *gv = json_gvariant_deserialize(json_parser_get_root(parser), NULL, NULL);
if (gv) {
char *debug = g_variant_print (gv, TRUE);
g_debug ("converted to %s", debug);
g_free (debug);
//We need to store the signature, so package in a v
GVariant *packaged = g_variant_new_variant(gv);
struct btval key;
key.data = (void*)path+1;
key.size = strlen(path)-1;
key.free_data = FALSE;
key.mp = NULL;
struct btval val;
val.data =(void*) g_variant_get_data(packaged);
val.size = g_variant_get_size(packaged);
val.free_data = FALSE;
val.mp = NULL;
g_debug ("inserting with key %s", (char*)key.data);
g_debug ("data checksum is %s", g_compute_checksum_for_data(G_CHECKSUM_MD5, val.data, val.size));
int success = btree_put(btree, &key, &val,0);
if (0!=success) {
g_debug("put failed: %s)", strerror(errno));
}
g_variant_unref (packaged);
g_variant_unref (gv);
}
} else {
g_debug("failed to parse json: %s", err->message);
g_error_free(err);
}
soup_message_set_status (msg, SOUP_STATUS_OK);
}
gboolean connman_service_set_autoconnect(connman_service_t *service, gboolean value)
{
if(NULL == service)
return FALSE;
GError *error = NULL;
connman_interface_service_call_set_property_sync(service->remote,
"AutoConnect",
g_variant_new_variant(g_variant_new_boolean(value)),
NULL, &error);
if (error)
{
WCA_LOG_CRITICAL("%s", error->message);
g_error_free(error);
return FALSE;
}
return TRUE;
}
static GVariant *
get_properties (Server * server)
{
RdpServer * rserver = RDP_SERVER(server);
GVariantBuilder propbuilder;
g_variant_builder_init(&propbuilder, G_VARIANT_TYPE_ARRAY);
GVariantBuilder namebuilder;
g_variant_builder_init(&namebuilder, G_VARIANT_TYPE_TUPLE);
g_variant_builder_add_value(&namebuilder, g_variant_new_string("username"));
g_variant_builder_add_value(&namebuilder, g_variant_new_boolean(TRUE));
if (rserver->username == NULL) {
g_variant_builder_add_value(&namebuilder, g_variant_new_variant(g_variant_new_string("")));
} else {
g_variant_builder_add_value(&namebuilder, g_variant_new_variant(g_variant_new_string(rserver->username)));
}
g_variant_builder_add_value(&namebuilder, g_variant_parse(G_VARIANT_TYPE_VARDICT, "{}", NULL, NULL, NULL));
g_variant_builder_add_value(&propbuilder, g_variant_builder_end(&namebuilder));
GVariantBuilder passbuilder;
g_variant_builder_init(&passbuilder, G_VARIANT_TYPE_TUPLE);
g_variant_builder_add_value(&passbuilder, g_variant_new_string("password"));
g_variant_builder_add_value(&passbuilder, g_variant_new_boolean(TRUE));
if (rserver->password == NULL) {
g_variant_builder_add_value(&passbuilder, g_variant_new_variant(g_variant_new_string("")));
} else {
g_variant_builder_add_value(&passbuilder, g_variant_new_variant(g_variant_new_string(rserver->password)));
}
g_variant_builder_add_value(&passbuilder, g_variant_parse(G_VARIANT_TYPE_VARDICT, "{}", NULL, NULL, NULL));
g_variant_builder_add_value(&propbuilder, g_variant_builder_end(&passbuilder));
GVariantBuilder domainbuilder;
g_variant_builder_init(&domainbuilder, G_VARIANT_TYPE_TUPLE);
g_variant_builder_add_value(&domainbuilder, g_variant_new_string("domain"));
g_variant_builder_add_value(&domainbuilder, g_variant_new_boolean(rserver->domain_required));
if (rserver->domain == NULL) {
g_variant_builder_add_value(&domainbuilder, g_variant_new_variant(g_variant_new_string("")));
} else {
g_variant_builder_add_value(&domainbuilder, g_variant_new_variant(g_variant_new_string(rserver->domain)));
}
g_variant_builder_add_value(&domainbuilder, g_variant_parse(G_VARIANT_TYPE_VARDICT, "{}", NULL, NULL, NULL));
g_variant_builder_add_value(&propbuilder, g_variant_builder_end(&domainbuilder));
return g_variant_builder_end(&propbuilder);
}
static GVariant *
parse_json_with_sig (JsonObject *object,
GError **error)
{
GVariantType *inner_type;
GVariant *inner;
JsonNode *val;
const gchar *sig;
val = json_object_get_member (object, "val");
if (val == NULL)
{
g_set_error (error, G_IO_ERROR, G_IO_ERROR_INVALID_DATA,
"JSON did not contain a 'val' field");
return NULL;
}
if (!cockpit_json_get_string (object, "sig", NULL, &sig) || !sig)
{
g_set_error (error, G_IO_ERROR, G_IO_ERROR_INVALID_DATA,
"JSON did not contain valid 'sig' fields");
return NULL;
}
if (!g_variant_type_string_is_valid (sig))
{
g_set_error (error, G_IO_ERROR, G_IO_ERROR_INVALID_DATA,
"JSON 'sig' field '%s' is invalid", sig);
return NULL;
}
inner_type = g_variant_type_new (sig);
inner = parse_json (val, inner_type, error);
g_variant_type_free (inner_type);
if (!inner)
return NULL;
return g_variant_new_variant (inner);
}
gboolean
ot_admin_builtin_set_origin (int argc, char **argv, GCancellable *cancellable, GError **error)
{
gboolean ret = FALSE;
GOptionContext *context;
const char *remotename = NULL;
const char *url = NULL;
const char *branch = NULL;
gs_unref_object OstreeRepo *repo = NULL;
gs_unref_object OstreeSysroot *sysroot = NULL;
OstreeDeployment *target_deployment = NULL;
context = g_option_context_new ("REMOTENAME URL [BRANCH]");
if (!ostree_admin_option_context_parse (context, options, &argc, &argv,
OSTREE_ADMIN_BUILTIN_FLAG_SUPERUSER,
&sysroot, cancellable, error))
goto out;
if (argc < 3)
{
ot_util_usage_error (context, "REMOTENAME and URL must be specified", error);
goto out;
}
remotename = argv[1];
url = argv[2];
if (argc > 3)
branch = argv[3];
if (!ostree_sysroot_load (sysroot, cancellable, error))
goto out;
if (!ostree_sysroot_get_repo (sysroot, &repo, cancellable, error))
goto out;
if (opt_index == -1)
{
target_deployment = ostree_sysroot_get_booted_deployment (sysroot);
if (target_deployment == NULL)
{
g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_FAILED,
"Not currently booted into an OSTree system");
goto out;
}
}
else
{
target_deployment = ot_admin_get_indexed_deployment (sysroot, opt_index, error);
if (!target_deployment)
goto out;
}
{ char **iter;
gs_unref_variant_builder GVariantBuilder *optbuilder =
g_variant_builder_new (G_VARIANT_TYPE ("a{sv}"));
for (iter = opt_set; iter && *iter; iter++)
{
const char *keyvalue = *iter;
gs_free char *subkey = NULL;
gs_free char *subvalue = NULL;
if (!ot_parse_keyvalue (keyvalue, &subkey, &subvalue, error))
goto out;
g_variant_builder_add (optbuilder, "{s@v}",
subkey, g_variant_new_variant (g_variant_new_string (subvalue)));
}
if (!ostree_repo_remote_change (repo, NULL,
OSTREE_REPO_REMOTE_CHANGE_ADD_IF_NOT_EXISTS,
remotename, url,
g_variant_builder_end (optbuilder),
cancellable, error))
goto out;
}
{ GKeyFile *old_origin = ostree_deployment_get_origin (target_deployment);
gs_free char *origin_refspec = g_key_file_get_string (old_origin, "origin", "refspec", NULL);
gs_free char *new_refspec = NULL;
gs_free char *origin_remote = NULL;
gs_free char *origin_ref = NULL;
if (!ostree_parse_refspec (origin_refspec, &origin_remote, &origin_ref, error))
goto out;
{ gs_free char *new_refspec = g_strconcat (remotename, ":", branch ? branch : origin_ref, NULL);
gs_unref_keyfile GKeyFile *new_origin = NULL;
gs_unref_object GFile *origin_path = NULL;
new_origin = ostree_sysroot_origin_new_from_refspec (sysroot, new_refspec);
if (!ostree_sysroot_write_origin_file (sysroot, target_deployment, new_origin,
cancellable, error))
goto out;
}
}
ret = TRUE;
out:
if (context)
g_option_context_free (context);
return ret;
}
gboolean connman_service_set_ipv4(connman_service_t *service, ipv4info_t *ipv4)
{
if(NULL == service || NULL == ipv4)
return FALSE;
GVariantBuilder *ipv4_b;
GVariant *ipv4_v;
ipv4_b = g_variant_builder_new (G_VARIANT_TYPE ("a{sv}"));
if(NULL != ipv4->method)
g_variant_builder_add (ipv4_b, "{sv}", "Method", g_variant_new_string(ipv4->method));
if(NULL != ipv4->address)
g_variant_builder_add (ipv4_b, "{sv}", "Address", g_variant_new_string(ipv4->address));
if(NULL != ipv4->netmask)
g_variant_builder_add (ipv4_b, "{sv}", "Netmask", g_variant_new_string(ipv4->netmask));
if(NULL != ipv4->gateway)
g_variant_builder_add (ipv4_b, "{sv}", "Gateway", g_variant_new_string(ipv4->gateway));
ipv4_v = g_variant_builder_end (ipv4_b);
GError *error = NULL;
connman_interface_service_call_set_property_sync(service->remote, "IPv4.Configuration", g_variant_new_variant(ipv4_v), NULL, &error);
if (error)
{
WCA_LOG_CRITICAL("Error: %s", error->message);
g_error_free(error);
return FALSE;
}
return TRUE;
}
/* TODO: Add a man page. */
gboolean
ostree_builtin_create_usb (int argc,
char **argv,
OstreeCommandInvocation *invocation,
GCancellable *cancellable,
GError **error)
{
g_autoptr(GOptionContext) context = NULL;
g_autoptr(OstreeAsyncProgress) progress = NULL;
g_auto(GLnxConsoleRef) console = { 0, };
context = g_option_context_new ("MOUNT-PATH COLLECTION-ID REF [COLLECTION-ID REF...]");
/* Parse options. */
g_autoptr(OstreeRepo) src_repo = NULL;
if (!ostree_option_context_parse (context, options, &argc, &argv, invocation, &src_repo, cancellable, error))
return FALSE;
if (argc < 2)
{
ot_util_usage_error (context, "A MOUNT-PATH must be specified", error);
return FALSE;
}
if (argc < 4)
{
ot_util_usage_error (context, "At least one COLLECTION-ID REF pair must be specified", error);
return FALSE;
}
if (argc % 2 == 1)
{
ot_util_usage_error (context, "Only complete COLLECTION-ID REF pairs may be specified", error);
return FALSE;
}
/* Open the USB stick, which must exist. Allow automounting and following symlinks. */
const char *mount_root_path = argv[1];
struct stat mount_root_stbuf;
glnx_autofd int mount_root_dfd = -1;
if (!glnx_opendirat (AT_FDCWD, mount_root_path, TRUE, &mount_root_dfd, error))
return FALSE;
if (!glnx_fstat (mount_root_dfd, &mount_root_stbuf, error))
return FALSE;
/* Read in the refs to add to the USB stick. */
g_autoptr(GPtrArray) refs = g_ptr_array_new_full (argc, (GDestroyNotify) ostree_collection_ref_free);
for (gsize i = 2; i < argc; i += 2)
{
if (!ostree_validate_collection_id (argv[i], error) ||
!ostree_validate_rev (argv[i + 1], error))
return FALSE;
g_ptr_array_add (refs, ostree_collection_ref_new (argv[i], argv[i + 1]));
}
/* Open the destination repository on the USB stick or create it if it doesn’t exist.
* Check it’s below @mount_root_path, and that it’s not the same as the source
* repository.
*
* If the destination file system supports xattrs (for example, ext4), we use
* a BARE_USER repository; if it doesn’t (for example, FAT), we use ARCHIVE.
* In either case, we want a lossless repository. */
const char *dest_repo_path = (opt_destination_repo != NULL) ? opt_destination_repo : ".ostree/repo";
if (!glnx_shutil_mkdir_p_at (mount_root_dfd, dest_repo_path, 0755, cancellable, error))
return FALSE;
OstreeRepoMode mode = OSTREE_REPO_MODE_BARE_USER;
if (TEMP_FAILURE_RETRY (fgetxattr (mount_root_dfd, "user.test", NULL, 0)) < 0 &&
(errno == ENOTSUP || errno == EOPNOTSUPP))
mode = OSTREE_REPO_MODE_ARCHIVE;
g_debug ("%s: Creating repository in mode %u", G_STRFUNC, mode);
g_autoptr(OstreeRepo) dest_repo = ostree_repo_create_at (mount_root_dfd, dest_repo_path,
mode, NULL, cancellable, error);
if (dest_repo == NULL)
return FALSE;
struct stat dest_repo_stbuf;
if (!glnx_fstat (ostree_repo_get_dfd (dest_repo), &dest_repo_stbuf, error))
return FALSE;
if (dest_repo_stbuf.st_dev != mount_root_stbuf.st_dev)
{
ot_util_usage_error (context, "--destination-repo must be a descendent of MOUNT-PATH", error);
return FALSE;
}
if (ostree_repo_equal (src_repo, dest_repo))
{
ot_util_usage_error (context, "--destination-repo must not be the source repository", error);
return FALSE;
}
if (!ostree_ensure_repo_writable (dest_repo, error))
return FALSE;
if (opt_disable_fsync)
ostree_repo_set_disable_fsync (dest_repo, TRUE);
/* Copy across all of the collection–refs to the destination repo. */
GVariantBuilder refs_builder;
g_variant_builder_init (&refs_builder, G_VARIANT_TYPE ("a(sss)"));
for (gsize i = 0; i < refs->len; i++)
{
const OstreeCollectionRef *ref = g_ptr_array_index (refs, i);
g_variant_builder_add (&refs_builder, "(sss)",
ref->collection_id, ref->ref_name, "");
}
{
GVariantBuilder builder;
g_autoptr(GVariant) opts = NULL;
OstreeRepoPullFlags flags = OSTREE_REPO_PULL_FLAGS_MIRROR;
glnx_console_lock (&console);
if (console.is_tty)
progress = ostree_async_progress_new_and_connect (ostree_repo_pull_default_console_progress_changed, &console);
g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{sv}"));
g_variant_builder_add (&builder, "{s@v}", "collection-refs",
g_variant_new_variant (g_variant_builder_end (&refs_builder)));
g_variant_builder_add (&builder, "{s@v}", "flags",
g_variant_new_variant (g_variant_new_int32 (flags)));
g_variant_builder_add (&builder, "{s@v}", "depth",
g_variant_new_variant (g_variant_new_int32 (0)));
opts = g_variant_ref_sink (g_variant_builder_end (&builder));
g_autofree char *src_repo_uri = g_file_get_uri (ostree_repo_get_path (src_repo));
if (!ostree_repo_pull_with_options (dest_repo, src_repo_uri,
opts,
progress,
cancellable, error))
{
ostree_repo_abort_transaction (dest_repo, cancellable, NULL);
return FALSE;
}
if (progress != NULL)
ostree_async_progress_finish (progress);
}
/* Ensure a summary file is present to make it easier to look up commit checksums. */
/* FIXME: It should be possible to work without this, but find_remotes_cb() in
* ostree-repo-pull.c currently assumes a summary file (signed or unsigned) is
* present. */
struct stat stbuf;
if (!glnx_fstatat_allow_noent (ostree_repo_get_dfd (dest_repo), "summary", &stbuf, 0, error))
return FALSE;
if (errno == ENOENT &&
!ostree_repo_regenerate_summary (dest_repo, NULL, cancellable, error))
return FALSE;
/* Add the symlinks .ostree/repos.d/@symlink_name → @dest_repo_path, unless
* the @dest_repo_path is a well-known one like ostree/repo, in which case no
* symlink is necessary; #OstreeRepoFinderMount always looks there. */
if (!g_str_equal (dest_repo_path, "ostree/repo") &&
!g_str_equal (dest_repo_path, ".ostree/repo"))
{
if (!glnx_shutil_mkdir_p_at (mount_root_dfd, ".ostree/repos.d", 0755, cancellable, error))
return FALSE;
/* Find a unique name for the symlink. If a symlink already targets
* @dest_repo_path, use that and don’t create a new one. */
GLnxDirFdIterator repos_iter;
gboolean need_symlink = TRUE;
if (!glnx_dirfd_iterator_init_at (mount_root_dfd, ".ostree/repos.d", TRUE, &repos_iter, error))
return FALSE;
while (TRUE)
{
struct dirent *repo_dent;
if (!glnx_dirfd_iterator_next_dent (&repos_iter, &repo_dent, cancellable, error))
return FALSE;
if (repo_dent == NULL)
break;
/* Does the symlink already point to this repository? (Or is the
* repository itself present in repos.d?) We already guarantee that
* they’re on the same device. */
if (repo_dent->d_ino == dest_repo_stbuf.st_ino)
{
need_symlink = FALSE;
break;
}
}
/* If we need a symlink, find a unique name for it and create it. */
if (need_symlink)
{
/* Relative to .ostree/repos.d. */
g_autofree char *relative_dest_repo_path = g_build_filename ("..", "..", dest_repo_path, NULL);
guint i;
const guint max_attempts = 100;
for (i = 0; i < max_attempts; i++)
{
g_autofree char *symlink_path = g_strdup_printf (".ostree/repos.d/%02u-generated", i);
int ret = TEMP_FAILURE_RETRY (symlinkat (relative_dest_repo_path, mount_root_dfd, symlink_path));
if (ret < 0 && errno != EEXIST)
return glnx_throw_errno_prefix (error, "symlinkat(%s → %s)", symlink_path, relative_dest_repo_path);
else if (ret >= 0)
break;
}
if (i == max_attempts)
return glnx_throw (error, "Could not find an unused symlink name for the repository");
}
}
/* Report success to the user. */
g_autofree char *src_repo_path = g_file_get_path (ostree_repo_get_path (src_repo));
g_print ("Copied %u/%u refs successfully from ‘%s’ to ‘%s’ repository in ‘%s’.\n", refs->len, refs->len,
src_repo_path, dest_repo_path, mount_root_path);
return TRUE;
}
gboolean
flatpak_builtin_build_commit_from (int argc, char **argv, GCancellable *cancellable, GError **error)
{
g_autoptr(GOptionContext) context = NULL;
g_autoptr(GFile) dst_repofile = NULL;
g_autoptr(OstreeRepo) dst_repo = NULL;
g_autoptr(GFile) src_repofile = NULL;
g_autoptr(OstreeRepo) src_repo = NULL;
g_autofree char *src_repo_uri = NULL;
const char *dst_repo_arg;
const char **dst_refs;
int n_dst_refs = 0;
g_autoptr(FlatpakRepoTransaction) transaction = NULL;
g_autoptr(GPtrArray) src_refs = NULL;
g_autoptr(GPtrArray) resolved_src_refs = NULL;
OstreeRepoCommitState src_commit_state;
struct timespec ts;
guint64 timestamp;
int i;
context = g_option_context_new (_("DST-REPO [DST-REF…] - Make a new commit from existing commits"));
g_option_context_set_translation_domain (context, GETTEXT_PACKAGE);
if (!flatpak_option_context_parse (context, options, &argc, &argv, FLATPAK_BUILTIN_FLAG_NO_DIR, NULL, cancellable, error))
return FALSE;
if (argc < 2)
return usage_error (context, _("DST-REPO must be specified"), error);
dst_repo_arg = argv[1];
dst_refs = (const char **) argv + 2;
n_dst_refs = argc - 2;
if (opt_src_repo == NULL && n_dst_refs != 1)
return usage_error (context, _("If --src-repo is not specified, exactly one destination ref must be specified"), error);
if (opt_src_ref != NULL && n_dst_refs != 1)
return usage_error (context, _("If --src-ref is specified, exactly one destination ref must be specified"), error);
if (opt_src_repo == NULL && opt_src_ref == NULL)
return flatpak_fail (error, _("Either --src-repo or --src-ref must be specified."));
/* Always create a commit if we're eol:ing, even though the app is the same */
if (opt_endoflife != NULL || opt_endoflife_rebase != NULL)
opt_force = TRUE;
if (opt_endoflife_rebase)
{
opt_endoflife_rebase_new = g_new0 (char *, g_strv_length (opt_endoflife_rebase));
for (i = 0; opt_endoflife_rebase[i] != NULL; i++)
{
char *rebase_old = opt_endoflife_rebase[i];
char *rebase_new = strchr (rebase_old, '=');
if (rebase_new == NULL) {
return usage_error (context, _("Invalid argument format of use --end-of-life-rebase=OLDID=NEWID"), error);
}
*rebase_new = 0;
rebase_new++;
if (!flatpak_is_valid_name (rebase_old, error))
return glnx_prefix_error (error, _("Invalid name %s in --end-of-life-rebase"), rebase_old);
if (!flatpak_is_valid_name (rebase_new, error))
return glnx_prefix_error (error, _("Invalid name %s in --end-of-life-rebase"), rebase_new);
opt_endoflife_rebase_new[i] = rebase_new;
}
}
if (opt_timestamp)
{
if (!parse_datetime (&ts, opt_timestamp, NULL))
return flatpak_fail (error, _("Could not parse '%s'"), opt_timestamp);
}
dst_repofile = g_file_new_for_commandline_arg (dst_repo_arg);
if (!g_file_query_exists (dst_repofile, cancellable))
return flatpak_fail (error, _("'%s' is not a valid repository"), dst_repo_arg);
dst_repo = ostree_repo_new (dst_repofile);
if (!ostree_repo_open (dst_repo, cancellable, error))
return FALSE;
if (opt_disable_fsync)
ostree_repo_set_disable_fsync (dst_repo, TRUE);
if (opt_src_repo)
{
src_repofile = g_file_new_for_commandline_arg (opt_src_repo);
if (!g_file_query_exists (src_repofile, cancellable))
return flatpak_fail (error, _("'%s' is not a valid repository"), opt_src_repo);
src_repo_uri = g_file_get_uri (src_repofile);
src_repo = ostree_repo_new (src_repofile);
if (!ostree_repo_open (src_repo, cancellable, error))
return FALSE;
}
else
{
src_repo = g_object_ref (dst_repo);
}
src_refs = g_ptr_array_new_with_free_func (g_free);
if (opt_src_ref)
{
g_assert (n_dst_refs == 1);
g_ptr_array_add (src_refs, g_strdup (opt_src_ref));
}
else
{
g_assert (opt_src_repo != NULL);
if (n_dst_refs == 0)
{
g_autofree const char **keys = NULL;
g_autoptr(GHashTable) all_src_refs = NULL;
if (!ostree_repo_list_refs (src_repo, NULL, &all_src_refs,
cancellable, error))
return FALSE;
keys = (const char **) g_hash_table_get_keys_as_array (all_src_refs, NULL);
for (i = 0; keys[i] != NULL; i++)
{
if (g_str_has_prefix (keys[i], "runtime/") ||
g_str_has_prefix (keys[i], "app/"))
g_ptr_array_add (src_refs, g_strdup (keys[i]));
}
n_dst_refs = src_refs->len;
dst_refs = (const char **) src_refs->pdata;
}
else
{
for (i = 0; i < n_dst_refs; i++)
g_ptr_array_add (src_refs, g_strdup (dst_refs[i]));
}
}
resolved_src_refs = g_ptr_array_new_with_free_func (g_free);
for (i = 0; i < src_refs->len; i++)
{
const char *src_ref = g_ptr_array_index (src_refs, i);
char *resolved_ref;
if (!ostree_repo_resolve_rev (src_repo, src_ref, FALSE, &resolved_ref, error))
return FALSE;
g_ptr_array_add (resolved_src_refs, resolved_ref);
}
if (src_repo_uri != NULL)
{
OstreeRepoPullFlags pullflags = 0;
GVariantBuilder builder;
g_autoptr(OstreeAsyncProgress) progress = NULL;
g_auto(GLnxConsoleRef) console = { 0, };
g_autoptr(GVariant) options = NULL;
gboolean res;
if (opt_untrusted)
pullflags |= OSTREE_REPO_PULL_FLAGS_UNTRUSTED;
glnx_console_lock (&console);
if (console.is_tty)
progress = ostree_async_progress_new_and_connect (ostree_repo_pull_default_console_progress_changed, &console);
g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{sv}"));
g_variant_builder_add (&builder, "{s@v}", "flags",
g_variant_new_variant (g_variant_new_int32 (pullflags)));
g_variant_builder_add (&builder, "{s@v}", "refs",
g_variant_new_variant (g_variant_new_strv ((const char * const *) resolved_src_refs->pdata,
resolved_src_refs->len)));
g_variant_builder_add (&builder, "{s@v}", "depth",
g_variant_new_variant (g_variant_new_int32 (0)));
options = g_variant_ref_sink (g_variant_builder_end (&builder));
res = ostree_repo_pull_with_options (dst_repo, src_repo_uri,
options,
progress,
cancellable, error);
if (progress)
ostree_async_progress_finish (progress);
if (!res)
return FALSE;
}
/* By now we have the commit with commit_id==resolved_ref and dependencies in dst_repo. We now create a new
* commit based on the toplevel tree ref from that commit.
* This is equivalent to:
* ostree commit --skip-if-unchanged --repo=${destrepo} --tree=ref=${resolved_ref}
*/
transaction = flatpak_repo_transaction_start (dst_repo, cancellable, error);
if (transaction == NULL)
return FALSE;
for (i = 0; i < resolved_src_refs->len; i++)
{
const char *dst_ref = dst_refs[i];
const char *resolved_ref = g_ptr_array_index (resolved_src_refs, i);
g_autofree char *dst_parent = NULL;
g_autoptr(GFile) dst_parent_root = NULL;
g_autoptr(GFile) src_ref_root = NULL;
g_autoptr(GVariant) src_commitv = NULL;
g_autoptr(GVariant) dst_commitv = NULL;
g_autoptr(OstreeMutableTree) mtree = NULL;
g_autoptr(GFile) dst_root = NULL;
g_autoptr(GVariant) commitv_metadata = NULL;
g_autoptr(GVariant) metadata = NULL;
const char *subject;
const char *body;
g_autofree char *commit_checksum = NULL;
GVariantBuilder metadata_builder;
gint j;
const char *dst_collection_id = NULL;
const char *main_collection_id = NULL;
g_autoptr(GPtrArray) collection_ids = NULL;
if (!ostree_repo_resolve_rev (dst_repo, dst_ref, TRUE, &dst_parent, error))
return FALSE;
if (dst_parent != NULL &&
!ostree_repo_read_commit (dst_repo, dst_parent, &dst_parent_root, NULL, cancellable, error))
return FALSE;
if (!ostree_repo_read_commit (dst_repo, resolved_ref, &src_ref_root, NULL, cancellable, error))
return FALSE;
if (!ostree_repo_load_commit (dst_repo, resolved_ref, &src_commitv, &src_commit_state, error))
return FALSE;
if (src_commit_state & OSTREE_REPO_COMMIT_STATE_PARTIAL)
return flatpak_fail (error, _("Can't commit from partial source commit."));
/* Don't create a new commit if this is the same tree */
if (!opt_force && dst_parent_root != NULL && g_file_equal (dst_parent_root, src_ref_root))
{
g_print (_("%s: no change\n"), dst_ref);
continue;
}
mtree = ostree_mutable_tree_new ();
if (!ostree_repo_write_directory_to_mtree (dst_repo, src_ref_root, mtree, NULL,
cancellable, error))
return FALSE;
if (!ostree_repo_write_mtree (dst_repo, mtree, &dst_root, cancellable, error))
return FALSE;
commitv_metadata = g_variant_get_child_value (src_commitv, 0);
g_variant_get_child (src_commitv, 3, "&s", &subject);
if (opt_subject)
subject = (const char *) opt_subject;
g_variant_get_child (src_commitv, 4, "&s", &body);
if (opt_body)
body = (const char *) opt_body;
dst_collection_id = ostree_repo_get_collection_id (dst_repo);
collection_ids = g_ptr_array_new_with_free_func (g_free);
if (dst_collection_id)
{
main_collection_id = dst_collection_id;
g_ptr_array_add (collection_ids, g_strdup (dst_collection_id));
}
if (opt_extra_collection_ids != NULL)
{
for (j = 0; opt_extra_collection_ids[j] != NULL; j++)
{
const char *cid = opt_extra_collection_ids[j];
if (main_collection_id == NULL)
main_collection_id = cid; /* Fall back to first arg */
if (g_strcmp0 (cid, dst_collection_id) != 0)
g_ptr_array_add (collection_ids, g_strdup (cid));
}
}
g_ptr_array_sort (collection_ids, (GCompareFunc) flatpak_strcmp0_ptr);
/* Copy old metadata */
g_variant_builder_init (&metadata_builder, G_VARIANT_TYPE ("a{sv}"));
/* Bindings. xa.ref is deprecated but added anyway for backwards compatibility. */
g_variant_builder_add (&metadata_builder, "{sv}", "ostree.collection-binding",
g_variant_new_string (main_collection_id ? main_collection_id : ""));
if (collection_ids->len > 0)
{
g_autoptr(GVariantBuilder) cr_builder = g_variant_builder_new (G_VARIANT_TYPE ("a(ss)"));
for (j = 0; j < collection_ids->len; j++)
g_variant_builder_add (cr_builder, "(ss)", g_ptr_array_index (collection_ids, j), dst_ref);
g_variant_builder_add (&metadata_builder, "{sv}", "ostree.collection-refs-binding",
g_variant_builder_end (cr_builder));
}
g_variant_builder_add (&metadata_builder, "{sv}", "ostree.ref-binding",
g_variant_new_strv (&dst_ref, 1));
g_variant_builder_add (&metadata_builder, "{sv}", "xa.ref", g_variant_new_string (dst_ref));
/* Record the source commit. This is nice to have, but it also
means the commit-from gets a different commit id, which
avoids problems with e.g. sharing .commitmeta files
(signatures) */
g_variant_builder_add (&metadata_builder, "{sv}", "xa.from_commit", g_variant_new_string (resolved_ref));
for (j = 0; j < g_variant_n_children (commitv_metadata); j++)
{
g_autoptr(GVariant) child = g_variant_get_child_value (commitv_metadata, j);
g_autoptr(GVariant) keyv = g_variant_get_child_value (child, 0);
const char *key = g_variant_get_string (keyv, NULL);
if (strcmp (key, "xa.ref") == 0 ||
strcmp (key, "xa.from_commit") == 0 ||
strcmp (key, "ostree.collection-binding") == 0 ||
strcmp (key, "ostree.collection-refs-binding") == 0 ||
strcmp (key, "ostree.ref-binding") == 0)
continue;
if (opt_endoflife &&
strcmp (key, OSTREE_COMMIT_META_KEY_ENDOFLIFE) == 0)
continue;
if (opt_endoflife_rebase &&
strcmp (key, OSTREE_COMMIT_META_KEY_ENDOFLIFE_REBASE) == 0)
continue;
g_variant_builder_add_value (&metadata_builder, child);
}
if (opt_endoflife && *opt_endoflife)
g_variant_builder_add (&metadata_builder, "{sv}", OSTREE_COMMIT_META_KEY_ENDOFLIFE,
g_variant_new_string (opt_endoflife));
if (opt_endoflife_rebase)
{
g_auto(GStrv) dst_ref_parts = g_strsplit (dst_ref, "/", 0);
for (j = 0; opt_endoflife_rebase[j] != NULL; j++)
{
const char *old_prefix = opt_endoflife_rebase[j];
if (flatpak_has_name_prefix (dst_ref_parts[1], old_prefix))
{
g_autofree char *new_id = g_strconcat (opt_endoflife_rebase_new[j], dst_ref_parts[1] + strlen(old_prefix), NULL);
g_autofree char *rebased_ref = g_build_filename (dst_ref_parts[0], new_id, dst_ref_parts[2], dst_ref_parts[3], NULL);
g_variant_builder_add (&metadata_builder, "{sv}", OSTREE_COMMIT_META_KEY_ENDOFLIFE_REBASE,
g_variant_new_string (rebased_ref));
break;
}
}
}
timestamp = ostree_commit_get_timestamp (src_commitv);
if (opt_timestamp)
timestamp = ts.tv_sec;
metadata = g_variant_ref_sink (g_variant_builder_end (&metadata_builder));
if (!ostree_repo_write_commit_with_time (dst_repo, dst_parent, subject, body, metadata,
OSTREE_REPO_FILE (dst_root),
timestamp,
&commit_checksum, cancellable, error))
return FALSE;
g_print ("%s: %s\n", dst_ref, commit_checksum);
if (!ostree_repo_load_commit (dst_repo, commit_checksum, &dst_commitv, NULL, error))
return FALSE;
/* This doesn't copy the detached metadata. I'm not sure if this is a problem.
* The main thing there is commit signatures, and we can't copy those, as the commit hash changes.
*/
if (opt_gpg_key_ids)
{
char **iter;
for (iter = opt_gpg_key_ids; iter && *iter; iter++)
{
const char *keyid = *iter;
g_autoptr(GError) my_error = NULL;
if (!ostree_repo_sign_commit (dst_repo,
commit_checksum,
keyid,
opt_gpg_homedir,
cancellable,
&my_error) &&
!g_error_matches (my_error, G_IO_ERROR, G_IO_ERROR_EXISTS))
{
g_propagate_error (error, g_steal_pointer (&my_error));
return FALSE;
}
}
}
if (dst_collection_id != NULL)
{
OstreeCollectionRef ref = { (char *) dst_collection_id, (char *) dst_ref };
ostree_repo_transaction_set_collection_ref (dst_repo, &ref, commit_checksum);
}
else
{
ostree_repo_transaction_set_ref (dst_repo, NULL, dst_ref, commit_checksum);
}
if (opt_extra_collection_ids)
{
for (j = 0; opt_extra_collection_ids[j] != NULL; j++)
{
OstreeCollectionRef ref = { (char *) opt_extra_collection_ids[j], (char *) dst_ref };
ostree_repo_transaction_set_collection_ref (dst_repo, &ref, commit_checksum);
}
}
/* Copy + Rewrite any deltas */
{
const char *from[2];
gsize j, n_from = 0;
if (dst_parent != NULL)
from[n_from++] = dst_parent;
from[n_from++] = NULL;
for (j = 0; j < n_from; j++)
{
g_autoptr(GError) local_error = NULL;
if (!rewrite_delta (src_repo, resolved_ref, dst_repo, commit_checksum, dst_commitv, from[j], &local_error))
g_debug ("Failed to copy delta: %s", local_error->message);
}
}
}
if (!ostree_repo_commit_transaction (dst_repo, NULL, cancellable, error))
return FALSE;
if (opt_update_appstream &&
!flatpak_repo_generate_appstream (dst_repo, (const char **) opt_gpg_key_ids, opt_gpg_homedir, 0, cancellable, error))
return FALSE;
if (!opt_no_update_summary &&
!flatpak_repo_update (dst_repo,
(const char **) opt_gpg_key_ids,
opt_gpg_homedir,
cancellable,
error))
return FALSE;
return TRUE;
}
gboolean
ostree_builtin_pull (int argc, char **argv, GCancellable *cancellable, GError **error)
{
GOptionContext *context;
gs_unref_object OstreeRepo *repo = NULL;
gboolean ret = FALSE;
gs_free char *remote = NULL;
OstreeRepoPullFlags pullflags = 0;
GSConsole *console = NULL;
gs_unref_ptrarray GPtrArray *refs_to_fetch = NULL;
gs_unref_object OstreeAsyncProgress *progress = NULL;
context = g_option_context_new ("REMOTE [BRANCH...] - Download data from remote repository");
if (!ostree_option_context_parse (context, options, &argc, &argv, OSTREE_BUILTIN_FLAG_NONE, &repo, cancellable, error))
goto out;
if (argc < 2)
{
ot_util_usage_error (context, "REMOTE must be specified", error);
goto out;
}
if (opt_disable_fsync)
ostree_repo_set_disable_fsync (repo, TRUE);
if (opt_mirror)
pullflags |= OSTREE_REPO_PULL_FLAGS_MIRROR;
if (strchr (argv[1], ':') == NULL)
{
remote = g_strdup (argv[1]);
if (argc > 2)
{
int i;
refs_to_fetch = g_ptr_array_new ();
for (i = 2; i < argc; i++)
g_ptr_array_add (refs_to_fetch, argv[i]);
g_ptr_array_add (refs_to_fetch, NULL);
}
}
else
{
char *ref_to_fetch;
refs_to_fetch = g_ptr_array_new ();
if (!ostree_parse_refspec (argv[1], &remote, &ref_to_fetch, error))
goto out;
/* Transfer ownership */
g_ptr_array_add (refs_to_fetch, ref_to_fetch);
g_ptr_array_add (refs_to_fetch, NULL);
}
console = gs_console_get ();
if (console)
{
gs_console_begin_status_line (console, "", NULL, NULL);
progress = ostree_async_progress_new_and_connect (ostree_repo_pull_default_console_progress_changed, console);
}
{
GVariantBuilder builder;
g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{sv}"));
if (opt_subpath)
g_variant_builder_add (&builder, "{s@v}", "subdir",
g_variant_new_variant (g_variant_new_string (opt_subpath)));
g_variant_builder_add (&builder, "{s@v}", "flags",
g_variant_new_variant (g_variant_new_int32 (pullflags)));
if (refs_to_fetch)
g_variant_builder_add (&builder, "{s@v}", "refs",
g_variant_new_variant (g_variant_new_strv ((const char *const*) refs_to_fetch->pdata, -1)));
g_variant_builder_add (&builder, "{s@v}", "depth",
g_variant_new_variant (g_variant_new_int32 (opt_depth)));
if (!ostree_repo_pull_with_options (repo, remote, g_variant_builder_end (&builder),
progress, cancellable, error))
goto out;
}
if (progress)
ostree_async_progress_finish (progress);
ret = TRUE;
out:
if (console)
gs_console_end_status_line (console, NULL, NULL);
if (context)
g_option_context_free (context);
return ret;
}
static void update_metadata (void * data, GObject * object)
{
char * title = NULL, * artist = NULL, * album = NULL, * file = NULL;
int length = 0;
int playlist = aud_playlist_get_playing ();
int entry = (playlist >= 0) ? aud_playlist_get_position (playlist) : -1;
if (entry >= 0)
{
aud_playlist_entry_describe (playlist, entry, & title, & artist, & album, TRUE);
file = aud_playlist_entry_get_filename (playlist, entry);
length = aud_playlist_entry_get_length (playlist, entry, TRUE);
}
/* pointer comparison works for pooled strings */
if (title == last_title && artist == last_artist && album == last_album &&
file == last_file && length == last_length)
{
str_unref (title);
str_unref (artist);
str_unref (album);
str_unref (file);
return;
}
if (file != last_file)
{
if (image_file)
aud_art_unref (last_file);
image_file = file ? aud_art_get_file (file) : NULL;
}
str_unref (last_title);
str_unref (last_artist);
str_unref (last_album);
str_unref (last_file);
last_title = title;
last_artist = artist;
last_album = album;
last_file = file;
last_length = length;
GVariant * elems[7];
int nelems = 0;
if (title)
{
GVariant * key = g_variant_new_string ("xesam:title");
GVariant * str = g_variant_new_string (title);
GVariant * var = g_variant_new_variant (str);
elems[nelems ++] = g_variant_new_dict_entry (key, var);
}
if (artist)
{
GVariant * key = g_variant_new_string ("xesam:artist");
GVariant * str = g_variant_new_string (artist);
GVariant * array = g_variant_new_array (G_VARIANT_TYPE_STRING, & str, 1);
GVariant * var = g_variant_new_variant (array);
elems[nelems ++] = g_variant_new_dict_entry (key, var);
}
if (album)
{
GVariant * key = g_variant_new_string ("xesam:album");
GVariant * str = g_variant_new_string (album);
GVariant * var = g_variant_new_variant (str);
elems[nelems ++] = g_variant_new_dict_entry (key, var);
}
if (file)
{
GVariant * key = g_variant_new_string ("xesam:url");
GVariant * str = g_variant_new_string (file);
GVariant * var = g_variant_new_variant (str);
elems[nelems ++] = g_variant_new_dict_entry (key, var);
}
if (length > 0)
{
GVariant * key = g_variant_new_string ("mpris:length");
GVariant * val = g_variant_new_int64 ((int64_t) length * 1000);
GVariant * var = g_variant_new_variant (val);
elems[nelems ++] = g_variant_new_dict_entry (key, var);
}
if (image_file)
{
GVariant * key = g_variant_new_string ("mpris:artUrl");
GVariant * str = g_variant_new_string (image_file);
GVariant * var = g_variant_new_variant (str);
elems[nelems ++] = g_variant_new_dict_entry (key, var);
}
GVariant * key = g_variant_new_string ("mpris:trackid");
GVariant * str = g_variant_new_string ("/org/mpris/MediaPlayer2/CurrentTrack");
GVariant * var = g_variant_new_variant (str);
elems[nelems ++] = g_variant_new_dict_entry (key, var);
if (! metadata_type)
metadata_type = g_variant_type_new ("{sv}");
GVariant * array = g_variant_new_array (metadata_type, elems, nelems);
g_object_set (object, "metadata", array, NULL);
}
gboolean
ostree_builtin_pull_local (int argc, char **argv, OstreeCommandInvocation *invocation, GCancellable *cancellable, GError **error)
{
gboolean ret = FALSE;
g_autoptr(GOptionContext) context = NULL;
g_autoptr(OstreeRepo) repo = NULL;
int i;
const char *src_repo_arg;
g_autofree char *src_repo_uri = NULL;
g_autoptr(OstreeAsyncProgress) progress = NULL;
g_autoptr(GPtrArray) refs_to_fetch = NULL;
OstreeRepoPullFlags pullflags = 0;
context = g_option_context_new ("SRC_REPO [REFS...]");
if (!ostree_option_context_parse (context, options, &argc, &argv, invocation, &repo, cancellable, error))
goto out;
if (!ostree_ensure_repo_writable (repo, error))
goto out;
if (argc < 2)
{
gchar *help = g_option_context_get_help (context, TRUE, NULL);
g_printerr ("%s\n", help);
g_free (help);
g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_FAILED,
"DESTINATION must be specified");
goto out;
}
src_repo_arg = argv[1];
if (src_repo_arg[0] == '/')
src_repo_uri = g_strconcat ("file://", src_repo_arg, NULL);
else
{
g_autofree char *cwd = g_get_current_dir ();
src_repo_uri = g_strconcat ("file://", cwd, "/", src_repo_arg, NULL);
}
if (opt_untrusted)
pullflags |= OSTREE_REPO_PULL_FLAGS_UNTRUSTED;
if (opt_bareuseronly_files)
pullflags |= OSTREE_REPO_PULL_FLAGS_BAREUSERONLY_FILES;
if (opt_disable_fsync)
ostree_repo_set_disable_fsync (repo, TRUE);
if (argc == 2)
{
g_autoptr(GFile) src_repo_path = g_file_new_for_path (src_repo_arg);
g_autoptr(OstreeRepo) src_repo = ostree_repo_new (src_repo_path);
g_autoptr(GHashTable) refs_to_clone = NULL;
refs_to_fetch = g_ptr_array_new_with_free_func (g_free);
if (!ostree_repo_open (src_repo, cancellable, error))
goto out;
/* FIXME: This should grow support for pulling refs from refs/mirrors on
* a local repository, using ostree_repo_list_collection_refs(). */
if (!ostree_repo_list_refs (src_repo, NULL, &refs_to_clone,
cancellable, error))
goto out;
{ GHashTableIter hashiter;
gpointer hkey, hvalue;
g_hash_table_iter_init (&hashiter, refs_to_clone);
while (g_hash_table_iter_next (&hashiter, &hkey, &hvalue))
g_ptr_array_add (refs_to_fetch, g_strdup (hkey));
}
g_ptr_array_add (refs_to_fetch, NULL);
}
else
{
refs_to_fetch = g_ptr_array_new ();
for (i = 2; i < argc; i++)
{
const char *ref = argv[i];
g_ptr_array_add (refs_to_fetch, (char*)ref);
}
g_ptr_array_add (refs_to_fetch, NULL);
}
{ GVariantBuilder builder;
g_autoptr(GVariant) opts = NULL;
g_auto(GLnxConsoleRef) console = { 0, };
glnx_console_lock (&console);
g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{sv}"));
g_variant_builder_add (&builder, "{s@v}", "flags",
g_variant_new_variant (g_variant_new_int32 (pullflags)));
g_variant_builder_add (&builder, "{s@v}", "refs",
g_variant_new_variant (g_variant_new_strv ((const char *const*) refs_to_fetch->pdata, -1)));
if (opt_remote)
g_variant_builder_add (&builder, "{s@v}", "override-remote-name",
g_variant_new_variant (g_variant_new_string (opt_remote)));
g_variant_builder_add (&builder, "{s@v}", "require-static-deltas",
g_variant_new_variant (g_variant_new_boolean (opt_require_static_deltas)));
if (opt_gpg_verify)
g_variant_builder_add (&builder, "{s@v}", "gpg-verify",
g_variant_new_variant (g_variant_new_boolean (TRUE)));
if (opt_gpg_verify_summary)
g_variant_builder_add (&builder, "{s@v}", "gpg-verify-summary",
g_variant_new_variant (g_variant_new_boolean (TRUE)));
g_variant_builder_add (&builder, "{s@v}", "depth",
g_variant_new_variant (g_variant_new_int32 (opt_depth)));
if (console.is_tty)
progress = ostree_async_progress_new_and_connect (ostree_repo_pull_default_console_progress_changed, &console);
else
progress = ostree_async_progress_new_and_connect (noninteractive_console_progress_changed, &console);
opts = g_variant_ref_sink (g_variant_builder_end (&builder));
if (!ostree_repo_pull_with_options (repo, src_repo_uri,
opts,
progress,
cancellable, error))
goto out;
if (!console.is_tty)
{
g_assert (progress);
const char *status = ostree_async_progress_get_status (progress);
if (status)
g_print ("%s\n", status);
}
ostree_async_progress_finish (progress);
}
ret = TRUE;
out:
if (repo)
ostree_repo_abort_transaction (repo, cancellable, NULL);
return ret;
}
gboolean
ot_remote_builtin_add (int argc, char **argv, GCancellable *cancellable, GError **error)
{
GOptionContext *context;
glnx_unref_object OstreeRepo *repo = NULL;
const char *remote_name;
const char *remote_url;
char **iter;
g_autofree char *target_name = NULL;
g_autoptr(GFile) target_conf = NULL;
g_autoptr(GVariantBuilder) optbuilder = NULL;
gboolean ret = FALSE;
context = g_option_context_new ("NAME [metalink=|mirrorlist=]URL [BRANCH...] - Add a remote repository");
if (!ostree_option_context_parse (context, option_entries, &argc, &argv,
OSTREE_BUILTIN_FLAG_NONE, &repo, cancellable, error))
goto out;
if (argc < 3)
{
ot_util_usage_error (context, "NAME and URL must be specified", error);
goto out;
}
remote_name = argv[1];
remote_url = argv[2];
optbuilder = g_variant_builder_new (G_VARIANT_TYPE ("a{sv}"));
if (argc > 3)
{
g_autoptr(GPtrArray) branchesp = g_ptr_array_new ();
int i;
for (i = 3; i < argc; i++)
g_ptr_array_add (branchesp, argv[i]);
g_ptr_array_add (branchesp, NULL);
g_variant_builder_add (optbuilder, "{s@v}",
"branches",
g_variant_new_variant (g_variant_new_strv ((const char*const*)branchesp->pdata, -1)));
}
/* We could just make users use --set instead for this since it's a string,
* but e.g. when mirrorlist support is added, it'll be kinda awkward to type:
* --set=contenturl=mirrorlist=... */
if (opt_contenturl != NULL)
g_variant_builder_add (optbuilder, "{s@v}",
"contenturl", g_variant_new_variant (g_variant_new_string (opt_contenturl)));
for (iter = opt_set; iter && *iter; iter++)
{
const char *keyvalue = *iter;
g_autofree char *subkey = NULL;
g_autofree char *subvalue = NULL;
if (!ot_parse_keyvalue (keyvalue, &subkey, &subvalue, error))
goto out;
g_variant_builder_add (optbuilder, "{s@v}",
subkey, g_variant_new_variant (g_variant_new_string (subvalue)));
}
if (opt_no_gpg_verify)
g_variant_builder_add (optbuilder, "{s@v}",
"gpg-verify",
g_variant_new_variant (g_variant_new_boolean (FALSE)));
if (!ostree_repo_remote_change (repo, NULL,
opt_if_not_exists ? OSTREE_REPO_REMOTE_CHANGE_ADD_IF_NOT_EXISTS :
OSTREE_REPO_REMOTE_CHANGE_ADD,
remote_name, remote_url,
g_variant_builder_end (optbuilder),
cancellable, error))
goto out;
/* This is just a convenience option and is not as flexible as the full
* "ostree remote gpg-import" command. It imports all keys from a file,
* which is likely the most common case.
*
* XXX Not sure this interacts well with if-not-exists since we don't
* know whether the remote already existed. We import regardless. */
if (opt_gpg_import != NULL)
{
g_autoptr(GFile) file = NULL;
g_autoptr(GInputStream) input_stream = NULL;
guint imported = 0;
file = g_file_new_for_path (opt_gpg_import);
input_stream = (GInputStream *) g_file_read (file, cancellable, error);
if (input_stream == NULL)
goto out;
if (!ostree_repo_remote_gpg_import (repo, remote_name, input_stream,
NULL, &imported, cancellable, error))
goto out;
/* XXX If we ever add internationalization, use ngettext() here. */
g_print ("Imported %u GPG key%s to remote \"%s\"\n",
imported, (imported == 1) ? "" : "s", remote_name);
}
ret = TRUE;
out:
g_option_context_free (context);
return ret;
}
void
test_service_setup (TestService *test)
{
GError *error = NULL;
GVariant *retval;
GVariant *output;
gchar **env;
const gchar *args[] = {
BUILDDIR "/gnome-keyring-daemon",
"--foreground",
"--control-directory",
"/tmp/keyring-test",
"--components",
"secrets",
NULL,
};
test->bus_name = g_strdup_printf ("org.gnome.keyring.Test.t%d", getpid ());
test->watch_id = g_bus_watch_name (G_BUS_TYPE_SESSION, test->bus_name,
G_BUS_NAME_WATCHER_FLAGS_NONE,
on_test_service_appeared,
on_test_service_vanished,
test, NULL);
test->directory = egg_tests_create_scratch_directory (
SRCDIR "/daemon/dbus/fixtures/test.keyring",
NULL);
env = gkd_test_launch_daemon (test->directory, args, &test->pid,
"GNOME_KEYRING_TEST_SERVICE", test->bus_name,
test->mock_prompter ? "GNOME_KEYRING_TEST_PROMPTER" : NULL, test->mock_prompter,
NULL);
g_strfreev (env);
if (!test->available) {
egg_test_wait ();
if (!test->available) {
g_warning ("Couldn't start gnome-keyring-daemon test service. ");
g_assert_not_reached ();
}
}
/* Set by on_test_service_appeared */
g_assert (test->connection != NULL);
/* Establish a plain session with the daemon */
retval = g_dbus_connection_call_sync (test->connection,
test->bus_name,
SECRET_SERVICE_PATH,
SECRET_SERVICE_INTERFACE,
"OpenSession",
g_variant_new ("(s@v)", "plain",
g_variant_new_variant (g_variant_new_string (""))),
G_VARIANT_TYPE ("(vo)"),
G_DBUS_CALL_FLAGS_NO_AUTO_START,
-1, NULL, &error);
g_assert_no_error (error);
g_variant_get (retval, "(@vo)", &output, &test->session);
g_variant_unref (output);
g_variant_unref (retval);
}
gboolean
install_bundle (XdgAppDir *dir,
GOptionContext *context,
int argc, char **argv,
GCancellable *cancellable,
GError **error)
{
gboolean ret = FALSE;
g_autoptr(GFile) deploy_base = NULL;
g_autoptr(GFile) file = NULL;
g_autoptr(GFile) gpg_tmp_file = NULL;
const char *filename;
g_autofree char *ref = NULL;
g_autofree char *origin = NULL;
gboolean created_deploy_base = FALSE;
gboolean added_remote = FALSE;
g_autofree char *to_checksum = NULL;
g_auto(GStrv) parts = NULL;
g_autoptr(GBytes) gpg_data = NULL;
g_autofree char *remote = NULL;
OstreeRepo *repo;
g_autoptr(OstreeGpgVerifyResult) gpg_result = NULL;
g_autoptr(GError) my_error = NULL;
g_auto(GLnxLockFile) lock = GLNX_LOCK_FILE_INIT;
if (argc < 2)
return usage_error (context, "bundle filename must be specified", error);
filename = argv[1];
repo = xdg_app_dir_get_repo (dir);
if (!xdg_app_supports_bundles (repo))
return xdg_app_fail (error, "Your version of ostree is too old to support single-file bundles");
if (!xdg_app_dir_lock (dir, &lock,
cancellable, error))
goto out;
file = g_file_new_for_commandline_arg (filename);
{
g_autoptr(GVariant) delta = NULL;
g_autoptr(GVariant) metadata = NULL;
g_autoptr(GBytes) bytes = NULL;
g_autoptr(GVariant) to_csum_v = NULL;
g_autoptr(GVariant) gpg_value = NULL;
GMappedFile *mfile = g_mapped_file_new (gs_file_get_path_cached (file), FALSE, error);
if (mfile == NULL)
return FALSE;
bytes = g_mapped_file_get_bytes (mfile);
g_mapped_file_unref (mfile);
delta = g_variant_new_from_bytes (G_VARIANT_TYPE (OSTREE_STATIC_DELTA_SUPERBLOCK_FORMAT), bytes, FALSE);
g_variant_ref_sink (delta);
to_csum_v = g_variant_get_child_value (delta, 3);
if (!ostree_validate_structureof_csum_v (to_csum_v, error))
return FALSE;
to_checksum = ostree_checksum_from_bytes_v (to_csum_v);
metadata = g_variant_get_child_value (delta, 0);
if (!g_variant_lookup (metadata, "ref", "s", &ref))
return xdg_app_fail (error, "Invalid bundle, no ref in metadata");
if (!g_variant_lookup (metadata, "origin", "s", &origin))
origin = NULL;
gpg_value = g_variant_lookup_value (metadata, "gpg-keys", G_VARIANT_TYPE("ay"));
if (gpg_value)
{
gsize n_elements;
const char *data = g_variant_get_fixed_array (gpg_value, &n_elements, 1);
gpg_data = g_bytes_new (data, n_elements);
}
}
parts = xdg_app_decompose_ref (ref, error);
if (parts == 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, "%s branch %s already installed", parts[1], parts[3]);
if (opt_gpg_file != NULL)
{
/* Override gpg_data from file */
gpg_data = read_gpg_data (cancellable, error);
if (gpg_data == NULL)
return FALSE;
}
/* Add a remote for later updates */
if (origin != NULL)
{
g_auto(GStrv) remotes = ostree_repo_remote_list (repo, NULL);
int version = 0;
do
{
g_autofree char *name = NULL;
if (version == 0)
name = g_strdup_printf ("%s-origin", parts[1]);
else
name = g_strdup_printf ("%s-%d-origin", parts[1], version);
version++;
if (remotes == NULL ||
!g_strv_contains ((const char * const *) remotes, name))
remote = g_steal_pointer (&name);
}
while (remote == NULL);
}
if (!ostree_repo_prepare_transaction (repo, NULL, cancellable, error))
return FALSE;
ostree_repo_transaction_set_ref (repo, remote, ref, to_checksum);
if (!ostree_repo_static_delta_execute_offline (repo,
file,
FALSE,
cancellable,
error))
return FALSE;
if (gpg_data)
{
g_autoptr(GFileIOStream) stream;
GOutputStream *o;
gpg_tmp_file = g_file_new_tmp (".xdg-app-XXXXXX", &stream, error);
if (gpg_tmp_file == NULL)
return FALSE;
o = g_io_stream_get_output_stream (G_IO_STREAM (stream));
if (!g_output_stream_write_all (o, g_bytes_get_data (gpg_data, NULL), g_bytes_get_size (gpg_data), NULL, cancellable, error))
return FALSE;
}
gpg_result = ostree_repo_verify_commit_ext (repo,
to_checksum,
NULL, gpg_tmp_file, cancellable, &my_error);
if (gpg_tmp_file)
g_file_delete (gpg_tmp_file, cancellable, NULL);
if (gpg_result == NULL)
{
/* NOT_FOUND means no gpg signature, we ignore this *if* there
* is no gpg key specified in the bundle or by the user */
if (g_error_matches (my_error, G_IO_ERROR, G_IO_ERROR_NOT_FOUND) &&
gpg_data == NULL)
g_clear_error (&my_error);
else
{
g_propagate_error (error, g_steal_pointer (&my_error));
return FALSE;
}
}
else
{
/* If there is no valid gpg signature we fail, unless there is no gpg
key specified (on the command line or in the file) because then we
trust the source bundle. */
if (ostree_gpg_verify_result_count_valid (gpg_result) == 0 &&
gpg_data != NULL)
return xdg_app_fail (error, "GPG signatures found, but none are in trusted keyring");
}
if (!ostree_repo_commit_transaction (repo, NULL, cancellable, error))
return FALSE;
if (!g_file_make_directory_with_parents (deploy_base, cancellable, error))
return FALSE;
/* From here we need to goto out on error, to clean up */
created_deploy_base = TRUE;
if (remote)
{
g_autoptr(GVariantBuilder) optbuilder = g_variant_builder_new (G_VARIANT_TYPE ("a{sv}"));
g_autofree char *basename = g_file_get_basename (file);
g_variant_builder_add (optbuilder, "{s@v}",
"xa.title",
g_variant_new_variant (g_variant_new_string (basename)));
g_variant_builder_add (optbuilder, "{s@v}",
"xa.noenumerate",
g_variant_new_variant (g_variant_new_boolean (TRUE)));
g_variant_builder_add (optbuilder, "{s@v}",
"xa.prio",
g_variant_new_variant (g_variant_new_string ("0")));
if (!ostree_repo_remote_add (repo,
remote, origin, g_variant_builder_end (optbuilder), cancellable, error))
goto out;
added_remote = TRUE;
if (gpg_data)
{
g_autoptr(GInputStream) gpg_data_as_stream = g_memory_input_stream_new_from_bytes (gpg_data);
if (!ostree_repo_remote_gpg_import (repo, remote, gpg_data_as_stream,
NULL, NULL, cancellable, error))
goto out;
}
if (!xdg_app_dir_set_origin (dir, ref, remote, cancellable, error))
goto out;
}
if (!xdg_app_dir_deploy (dir, ref, to_checksum, cancellable, error))
goto out;
if (!xdg_app_dir_make_current_ref (dir, ref, cancellable, error))
goto out;
if (strcmp (parts[0], "app") == 0)
{
if (!xdg_app_dir_update_exports (dir, parts[1], 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);
if (added_remote && !ret)
ostree_repo_remote_delete (repo, remote, NULL, NULL);
return ret;
}
