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);
}