static gboolean method_change_lock_internal (GkdSecretService *self, GDBusMethodInvocation *invocation, const gchar *collection_path) { GkdSecretChange *change; const char *caller; const gchar *path; GckObject *collection; caller = g_dbus_method_invocation_get_sender (invocation); /* Make sure it exists */ collection = gkd_secret_objects_lookup_collection (self->objects, caller, collection_path); if (!collection) { g_dbus_method_invocation_return_error_literal (invocation, GKD_SECRET_ERROR, GKD_SECRET_ERROR_NO_SUCH_OBJECT, "The collection does not exist"); return TRUE; } g_object_unref (collection); change = gkd_secret_change_new (self, caller, collection_path); path = gkd_secret_dispatch_get_object_path (GKD_SECRET_DISPATCH (change)); gkd_secret_service_publish_dispatch (self, caller, GKD_SECRET_DISPATCH (change)); g_dbus_method_invocation_return_value (invocation, g_variant_new ("(o)", path)); g_object_unref (change); return TRUE; }
static DBusMessage* service_method_create_collection (GkdSecretService *self, DBusMessage *message) { DBusMessageIter iter, array; GckAttributes *attrs; GkdSecretCreate *create; DBusMessage *reply; const gchar *path; const gchar *alias; const char *caller; const gchar *coll; /* Parse the incoming message */ if (!dbus_message_has_signature (message, "a{sv}s")) return NULL; if (!dbus_message_iter_init (message, &iter)) g_return_val_if_reached (NULL); attrs = gck_attributes_new (); dbus_message_iter_recurse (&iter, &array); if (!gkd_secret_property_parse_all (&array, SECRET_COLLECTION_INTERFACE, attrs)) { gck_attributes_unref (attrs); return dbus_message_new_error_printf (message, DBUS_ERROR_INVALID_ARGS, "Invalid properties"); } if (!dbus_message_iter_next (&iter)) g_return_val_if_reached (NULL); dbus_message_iter_get_basic (&iter, &alias); /* Empty alias is no alias */ if (alias) { if (!alias[0]) { alias = NULL; } else if (!g_str_equal (alias, "default")) { gck_attributes_unref (attrs); return dbus_message_new_error (message, DBUS_ERROR_NOT_SUPPORTED, "Only the 'default' alias is supported"); } } gck_attributes_add_boolean (attrs, CKA_TOKEN, TRUE); /* Create the prompt object, for the password */ caller = dbus_message_get_sender (message); create = gkd_secret_create_new (self, caller, attrs, alias); gck_attributes_unref (attrs); path = gkd_secret_dispatch_get_object_path (GKD_SECRET_DISPATCH (create)); gkd_secret_service_publish_dispatch (self, caller, GKD_SECRET_DISPATCH (create)); coll = "/"; reply = dbus_message_new_method_return (message); dbus_message_append_args (reply, DBUS_TYPE_OBJECT_PATH, &coll, DBUS_TYPE_OBJECT_PATH, &path, DBUS_TYPE_INVALID); g_object_unref (create); return reply; }
static DBusMessage* service_method_change_lock (GkdSecretService *self, DBusMessage *message) { GkdSecretChange *change; DBusMessage *reply; const char *caller; const gchar *path; GckObject *collection; caller = dbus_message_get_sender (message); if (!dbus_message_get_args (message, NULL, DBUS_TYPE_OBJECT_PATH, &path, DBUS_TYPE_INVALID)) return NULL; /* Make sure it exists */ collection = gkd_secret_objects_lookup_collection (self->objects, caller, path); if (!collection) return dbus_message_new_error (message, SECRET_ERROR_NO_SUCH_OBJECT, "The collection does not exist"); g_object_unref (collection); change = gkd_secret_change_new (self, caller, path); path = gkd_secret_dispatch_get_object_path (GKD_SECRET_DISPATCH (change)); gkd_secret_service_publish_dispatch (self, caller, GKD_SECRET_DISPATCH (change)); reply = dbus_message_new_method_return (message); dbus_message_append_args (reply, DBUS_TYPE_OBJECT_PATH, &path, DBUS_TYPE_INVALID); g_object_unref (change); return reply; }
static DBusMessage* service_method_change_lock (GkdSecretService *self, DBusMessage *message) { GkdSecretChange *change; ServiceClient *client; DBusMessage *reply; const char *caller; const gchar *path; GP11Object *collection; caller = dbus_message_get_sender (message); if (!dbus_message_get_args (message, NULL, DBUS_TYPE_OBJECT_PATH, &path, DBUS_TYPE_INVALID)) return NULL; /* Make sure it exists */ collection = gkd_secret_objects_lookup_collection (self->objects, caller, path); if (!collection) return dbus_message_new_error (message, SECRET_ERROR_NO_SUCH_OBJECT, "The collection does not exist"); g_object_unref (collection); change = gkd_secret_change_new (self, caller, path); client = g_hash_table_lookup (self->clients, caller); g_return_val_if_fail (client, NULL); path = gkd_secret_dispatch_get_object_path (GKD_SECRET_DISPATCH (change)); g_hash_table_replace (client->prompts, (gpointer)path, g_object_ref (change)); reply = dbus_message_new_method_return (message); dbus_message_append_args (reply, DBUS_TYPE_OBJECT_PATH, &path, DBUS_TYPE_INVALID); g_object_unref (change); return reply; }
static DBusMessage* service_method_open_session (GkdSecretService *self, DBusMessage *message) { GkdSecretSession *session; ServiceClient *client; DBusMessage *reply = NULL; const gchar *caller; const gchar *path; if (!dbus_message_has_signature (message, "sv")) return NULL; caller = dbus_message_get_sender (message); /* Now we can create a session with this information */ session = gkd_secret_session_new (self, caller); reply = gkd_secret_session_handle_open (session, message); if (dbus_message_get_type (reply) == DBUS_MESSAGE_TYPE_METHOD_RETURN) { /* Take ownership of the session */ client = g_hash_table_lookup (self->clients, caller); g_return_val_if_fail (client, NULL); path = gkd_secret_dispatch_get_object_path (GKD_SECRET_DISPATCH (session)); g_return_val_if_fail (!g_hash_table_lookup (client->sessions, path), NULL); g_hash_table_replace (client->sessions, (gpointer)path, session); } else { g_object_unref (session); } return reply; }
static void unlock_or_complete_this_prompt (GkdSecretCreate *self) { GkdSecretUnlock *unlock; GkdSecretPrompt *prompt; g_object_ref (self); prompt = GKD_SECRET_PROMPT (self); unlock = gkd_secret_unlock_new (gkd_secret_prompt_get_service (prompt), gkd_secret_prompt_get_caller (prompt), gkd_secret_dispatch_get_object_path (GKD_SECRET_DISPATCH (self))); gkd_secret_unlock_queue (unlock, self->result_path); /* * If any need to be unlocked, then replace this prompt * object with an unlock prompt object, and call the prompt * method. */ if (gkd_secret_unlock_have_queued (unlock)) { gkd_secret_service_publish_dispatch (gkd_secret_prompt_get_service (prompt), gkd_secret_prompt_get_caller (prompt), GKD_SECRET_DISPATCH (unlock)); gkd_secret_unlock_call_prompt (unlock, gkd_secret_prompt_get_window_id (prompt)); } g_object_unref (unlock); g_object_unref (self); }
static gboolean service_method_create_collection (GkdExportedService *skeleton, GDBusMethodInvocation *invocation, GVariant *properties, gchar *alias, GkdSecretService *self) { GckBuilder builder = GCK_BUILDER_INIT; GckAttributes *attrs; GkdSecretCreate *create; const gchar *path; const char *caller; if (!gkd_secret_property_parse_all (properties, SECRET_COLLECTION_INTERFACE, &builder)) { gck_builder_clear (&builder); g_dbus_method_invocation_return_error_literal (invocation, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "Invalid properties"); return TRUE; } /* Empty alias is no alias */ if (alias) { if (!alias[0]) { alias = NULL; } else if (!g_str_equal (alias, "default")) { gck_builder_clear (&builder); g_dbus_method_invocation_return_error_literal (invocation, G_DBUS_ERROR, G_DBUS_ERROR_NOT_SUPPORTED, "Only the 'default' alias is supported"); return TRUE; } } gck_builder_add_boolean (&builder, CKA_TOKEN, TRUE); attrs = gck_attributes_ref_sink (gck_builder_end (&builder)); /* Create the prompt object, for the password */ caller = g_dbus_method_invocation_get_sender (invocation); create = gkd_secret_create_new (self, caller, attrs, alias); gck_attributes_unref (attrs); path = gkd_secret_dispatch_get_object_path (GKD_SECRET_DISPATCH (create)); gkd_secret_service_publish_dispatch (self, caller, GKD_SECRET_DISPATCH (create)); gkd_exported_service_complete_create_collection (skeleton, invocation, "/", path); return TRUE; }
void gkd_secret_service_close_session (GkdSecretService *self, GkdSecretSession *session) { ServiceClient *client; const gchar *caller; const gchar *path; g_return_if_fail (GKD_SECRET_IS_SERVICE (self)); g_return_if_fail (GKD_SECRET_IS_SESSION (session)); caller = gkd_secret_session_get_caller (session); client = g_hash_table_lookup (self->clients, caller); g_return_if_fail (client); path = gkd_secret_dispatch_get_object_path (GKD_SECRET_DISPATCH (session)); g_hash_table_remove (client->dispatch, path); }
static DBusMessage* service_method_unlock (GkdSecretService *self, DBusMessage *message) { GkdSecretUnlock *unlock; ServiceClient *client; DBusMessage *reply; const char *caller; const gchar *path; int n_objpaths, i; char **objpaths; if (!dbus_message_get_args (message, NULL, DBUS_TYPE_ARRAY, DBUS_TYPE_OBJECT_PATH, &objpaths, &n_objpaths, DBUS_TYPE_INVALID)) return NULL; caller = dbus_message_get_sender (message); unlock = gkd_secret_unlock_new (self, caller); for (i = 0; i < n_objpaths; ++i) gkd_secret_unlock_queue (unlock, objpaths[i]); dbus_free_string_array (objpaths); /* So do we need to prompt? */ if (gkd_secret_unlock_have_queued (unlock)) { client = g_hash_table_lookup (self->clients, caller); g_return_val_if_fail (client, NULL); path = gkd_secret_dispatch_get_object_path (GKD_SECRET_DISPATCH (unlock)); g_hash_table_replace (client->prompts, (gpointer)path, g_object_ref (unlock)); /* No need to prompt */ } else { path = "/"; } reply = dbus_message_new_method_return (message); objpaths = gkd_secret_unlock_get_results (unlock, &n_objpaths); dbus_message_append_args (reply, DBUS_TYPE_ARRAY, DBUS_TYPE_OBJECT_PATH, &objpaths, n_objpaths, DBUS_TYPE_OBJECT_PATH, &path, DBUS_TYPE_INVALID); gkd_secret_unlock_reset_results (unlock); g_object_unref (unlock); return reply; }
static DBusMessage* service_method_create_collection (GkdSecretService *self, DBusMessage *message) { DBusMessageIter iter, array; GP11Attributes *attrs; GkdSecretCreate *create; ServiceClient *client; DBusMessage *reply; const gchar *path; const char *caller; const gchar *coll; /* Parse the incoming message */ if (!dbus_message_has_signature (message, "a{sv}")) return NULL; if (!dbus_message_iter_init (message, &iter)) g_return_val_if_reached (NULL); attrs = gp11_attributes_new (); dbus_message_iter_recurse (&iter, &array); if (!gkd_secret_property_parse_all (&array, attrs)) { gp11_attributes_unref (attrs); return dbus_message_new_error_printf (message, DBUS_ERROR_INVALID_ARGS, "Invalid properties"); } gp11_attributes_add_boolean (attrs, CKA_TOKEN, TRUE); /* Create the prompt object, for the password */ caller = dbus_message_get_sender (message); create = gkd_secret_create_new (self, caller, attrs); gp11_attributes_unref (attrs); path = gkd_secret_dispatch_get_object_path (GKD_SECRET_DISPATCH (create)); client = g_hash_table_lookup (self->clients, caller); g_return_val_if_fail (client, NULL); g_hash_table_replace (client->prompts, (gpointer)path, create); coll = "/"; reply = dbus_message_new_method_return (message); dbus_message_append_args (reply, DBUS_TYPE_OBJECT_PATH, &coll, DBUS_TYPE_OBJECT_PATH, &path, DBUS_TYPE_INVALID); return reply; }
void gkd_secret_service_publish_dispatch (GkdSecretService *self, const gchar *caller, GkdSecretDispatch *object) { ServiceClient *client; const gchar *path; g_return_if_fail (GKD_SECRET_IS_SERVICE (self)); g_return_if_fail (caller); g_return_if_fail (GKD_SECRET_IS_DISPATCH (object)); /* Take ownership of the session */ client = g_hash_table_lookup (self->clients, caller); g_return_if_fail (client); path = gkd_secret_dispatch_get_object_path (object); g_return_if_fail (!g_hash_table_lookup (client->dispatch, path)); g_hash_table_replace (client->dispatch, (gpointer)path, g_object_ref (object)); }
static gboolean service_method_unlock (GkdExportedService *skeleton, GDBusMethodInvocation *invocation, gchar **objpaths, GkdSecretService *self) { GkdSecretUnlock *unlock; const char *caller; const gchar *path; int i, n_unlocked; gchar **unlocked; caller = g_dbus_method_invocation_get_sender (invocation); unlock = gkd_secret_unlock_new (self, caller, NULL); for (i = 0; objpaths[i] != NULL; ++i) gkd_secret_unlock_queue (unlock, objpaths[i]); /* So do we need to prompt? */ if (gkd_secret_unlock_have_queued (unlock)) { gkd_secret_service_publish_dispatch (self, caller, GKD_SECRET_DISPATCH (unlock)); path = gkd_secret_dispatch_get_object_path (GKD_SECRET_DISPATCH (unlock)); /* No need to prompt */ } else { path = "/"; } unlocked = gkd_secret_unlock_get_results (unlock, &n_unlocked); gkd_exported_service_complete_unlock (skeleton, invocation, (const gchar **) unlocked, path); gkd_secret_unlock_reset_results (unlock); g_object_unref (unlock); return TRUE; }