static AuthContext * auth_context_new (TpChannel *channel, AgAccountService *service) { AuthContext *ctx; guint cred_id; ctx = g_slice_new0 (AuthContext); ctx->channel = g_object_ref (channel); ctx->service = g_object_ref (service); ctx->auth_data = ag_account_service_get_auth_data (service); if (ctx->auth_data == NULL) goto out; cred_id = ag_auth_data_get_credentials_id (ctx->auth_data); if (cred_id == 0) goto out; ctx->identity = signon_identity_new_from_db (cred_id); if (ctx->identity == NULL) goto out; ctx->session = signon_identity_create_session (ctx->identity, ag_auth_data_get_method (ctx->auth_data), NULL); if (ctx->session == NULL) goto out; out: return ctx; }
boost::shared_ptr<AuthProvider> createSignonAuthProvider(const InitStateString &username, const InitStateString &password) { // Expected content of parameter GVariant. boost::shared_ptr<GVariantType> hashtype(g_variant_type_new("a{sv}"), g_variant_type_free); // 'username' is the part after signon: which we can parse directly. GErrorCXX gerror; GVariantCXX parametersVar(g_variant_parse(hashtype.get(), username.c_str(), NULL, NULL, gerror), TRANSFER_REF); if (!parametersVar) { gerror.throwError(SE_HERE, "parsing 'signon:' username"); } GHashTableCXX parameters(Variant2HashTable(parametersVar)); // Extract the values that we expect in the parameters hash. guint32 signonID; const char *method; const char *mechanism; GVariant *value; value = (GVariant *)g_hash_table_lookup(parameters, "identity"); if (!value || !g_variant_type_equal(G_VARIANT_TYPE_UINT32, g_variant_get_type(value))) { SE_THROW("need 'identity: <numeric ID>' in 'signon:' parameters"); } signonID = g_variant_get_uint32(value); value = (GVariant *)g_hash_table_lookup(parameters, "method"); if (!value || !g_variant_type_equal(G_VARIANT_TYPE_STRING, g_variant_get_type(value))) { SE_THROW("need 'method: <string>' in 'signon:' parameters"); } method = g_variant_get_string(value, NULL); value = (GVariant *)g_hash_table_lookup(parameters, "mechanism"); if (!value || !g_variant_type_equal(G_VARIANT_TYPE_STRING, g_variant_get_type(value))) { SE_THROW("need 'mechanism: <string>' in 'signon:' parameters"); } mechanism = g_variant_get_string(value, NULL); value = (GVariant *)g_hash_table_lookup(parameters, "session"); if (!value || !g_variant_type_equal(hashtype.get(), g_variant_get_type(value))) { SE_THROW("need 'session: <hash>' in 'signon:' parameters"); } GHashTableCXX sessionData(Variant2HashTable(value)); SE_LOG_DEBUG(NULL, "using identity %u, method %s, mechanism %s", signonID, method, mechanism); SignonIdentityCXX identity(signon_identity_new_from_db(signonID), TRANSFER_REF); SE_LOG_DEBUG(NULL, "using signond identity %d", signonID); SignonAuthSessionCXX authSession(signon_identity_create_session(identity, method, gerror), TRANSFER_REF); boost::shared_ptr<AuthProvider> provider(new SignonAuthProvider(authSession, sessionData, mechanism)); return provider; }
END_TEST START_TEST(test_unregistered_auth_session) { g_debug("%s", G_STRFUNC); g_type_init (); SignonIdentity *idty = signon_identity_new(); fail_unless (idty != NULL); fail_unless (SIGNON_IS_IDENTITY (idty), "Failed to initialize the Identity."); main_loop = g_main_loop_new (NULL, FALSE); GError *err = NULL; SignonAuthSession *as = signon_identity_create_session(idty, "ssotest", &err); /* give time to register the objects */ g_timeout_add_seconds (2, test_quit_main_loop_cb, main_loop); g_main_loop_run (main_loop); /* * give the time for identity to became idle * */ sleep(SIGNOND_IDLE_TIMEOUT); SignonIdentity *idty2 = signon_identity_new(); /* * give time to handle unregistered signal * */ g_timeout_add_seconds (5, test_quit_main_loop_cb, main_loop); g_main_loop_run (main_loop); gchar* patterns[4]; patterns[0] = g_strdup("mech1"); patterns[1] = g_strdup("mech2"); patterns[2] = g_strdup("mech3"); patterns[3] = NULL; signon_auth_session_query_available_mechanisms(as, (const gchar**)patterns, test_auth_session_query_mechanisms_cb, (gpointer)patterns); g_main_loop_run (main_loop); g_object_unref (as); g_object_unref (idty); g_object_unref (idty2); g_free (patterns[0]); g_free (patterns[1]); g_free (patterns[2]); g_free (patterns[3]); }
static void uoa_get_account_password (TpAccount *tp_account, GSimpleAsyncResult *result) { AgAccountService *service; AgAuthData *auth_data; guint cred_id; SignonIdentity *identity; SignonAuthSession *session; GError *error = NULL; DEBUG ("Store password for %s in signond", tp_account_get_path_suffix (tp_account)); service = uoa_password_common (tp_account, result, &auth_data); if (service == NULL) return; cred_id = ag_auth_data_get_credentials_id (auth_data); if (cred_id == 0) { g_simple_async_result_set_error (result, TP_ERROR, TP_ERROR_INVALID_ARGUMENT, "AgAccount has no CredentialsId"); g_simple_async_result_complete_in_idle (result); goto out; } identity = signon_identity_new_from_db (cred_id); session = signon_identity_create_session (identity, ag_auth_data_get_method (auth_data), &error); g_object_unref (identity); if (session == NULL) { g_simple_async_result_set_from_error (result, error); g_simple_async_result_complete_in_idle (result); goto out; } signon_auth_session_process_async (session, ag_auth_data_get_login_parameters (auth_data, NULL), ag_auth_data_get_mechanism (auth_data), NULL, uoa_session_process_cb, g_object_ref (result)); g_object_unref (session); out: ag_auth_data_unref (auth_data); g_object_unref (service); }
END_TEST START_TEST(test_auth_session_process) { g_type_init(); gint state_counter = 0; GError *err = NULL; g_debug("%s", G_STRFUNC); SignonIdentity *idty = signon_identity_new(NULL, NULL); fail_unless (idty != NULL, "Cannot create Iddentity object"); SignonAuthSession *auth_session = signon_identity_create_session(idty, "ssotest", &err); fail_unless (auth_session != NULL, "Cannot create AuthSession object"); g_clear_error(&err); g_signal_connect(auth_session, "state-changed", G_CALLBACK(test_auth_session_states_cb), &state_counter); GHashTable* sessionData = g_hash_table_new(g_str_hash, g_str_equal); GValue* usernameVa = g_new0(GValue, 1); gchar* usernameKey = g_strdup(SIGNON_SESSION_DATA_USERNAME); g_value_init (usernameVa, G_TYPE_STRING); g_value_set_static_string(usernameVa, "test_username"); g_hash_table_insert (sessionData, usernameKey, usernameVa); GValue* passwordVa = g_new0(GValue, 1); gchar* passwordKey = g_strdup(SIGNON_SESSION_DATA_SECRET); g_value_init (passwordVa, G_TYPE_STRING); g_value_set_static_string(passwordVa, "test_username"); g_hash_table_insert (sessionData, passwordKey, passwordVa); signon_auth_session_process(auth_session, sessionData, "mech1", test_auth_session_process_cb, sessionData); if(!main_loop) main_loop = g_main_loop_new (NULL, FALSE); g_main_loop_run (main_loop); fail_unless (state_counter == 12, "Wrong numer of state change signals: %d", state_counter); state_counter = 0; signon_auth_session_process(auth_session, sessionData, "mech1", test_auth_session_process_cb, sessionData); g_main_loop_run (main_loop); fail_unless (state_counter == 12, "Wrong numer of state change signals: %d", state_counter); state_counter = 0; signon_auth_session_process(auth_session, sessionData, "mech1", test_auth_session_process_cb, sessionData); g_main_loop_run (main_loop); fail_unless (state_counter == 12, "Wrong numer of state change signals: %d", state_counter); state_counter = 0; g_object_unref (auth_session); g_object_unref (idty); g_value_unset(usernameVa); g_free(usernameVa); g_free(usernameKey); g_value_unset(passwordVa); g_free(passwordVa); g_free(passwordKey); }