static void
join_show_prompt (GisAccountPageEnterprise *page,
GError *error)
{
GisAccountPageEnterprisePrivate *priv = gis_account_page_enterprise_get_instance_private (page);
UmRealmKerberosMembership *membership;
UmRealmKerberos *kerberos;
gchar hostname[128];
const gchar *name;
gtk_entry_set_text (GTK_ENTRY (priv->join_password), "");
gtk_widget_grab_focus (GTK_WIDGET (priv->join_password));
kerberos = um_realm_object_get_kerberos (priv->realm);
membership = um_realm_object_get_kerberos_membership (priv->realm);
gtk_label_set_text (GTK_LABEL (priv->join_domain),
um_realm_kerberos_get_domain_name (kerberos));
if (gethostname (hostname, sizeof (hostname)) == 0)
gtk_entry_set_text (GTK_ENTRY (priv->join_computer), hostname);
clear_entry_validation_error (GTK_ENTRY (priv->join_name));
clear_entry_validation_error (GTK_ENTRY (priv->join_password));
if (!priv->join_prompted) {
name = um_realm_kerberos_membership_get_suggested_administrator (membership);
if (name && !g_str_equal (name, "")) {
g_debug ("Suggesting admin user: %s", name);
gtk_entry_set_text (GTK_ENTRY (priv->join_name), name);
} else {
gtk_widget_grab_focus (GTK_WIDGET (priv->join_name));
}
} else if (g_error_matches (error, UM_REALM_ERROR, UM_REALM_ERROR_BAD_HOSTNAME)) {
g_debug ("Bad host name: %s", error->message);
set_entry_validation_error (GTK_ENTRY (priv->join_computer), error->message);
} else if (g_error_matches (error, UM_REALM_ERROR, UM_REALM_ERROR_BAD_PASSWORD)) {
g_debug ("Bad admin password: %s", error->message);
set_entry_validation_error (GTK_ENTRY (priv->join_password), error->message);
} else {
g_debug ("Admin login failure: %s", error->message);
g_dbus_error_strip_remote_error (error);
set_entry_validation_error (GTK_ENTRY (priv->join_name), error->message);
}
g_debug ("Showing admin password dialog");
gtk_window_set_transient_for (GTK_WINDOW (priv->join_dialog),
GTK_WINDOW (gtk_widget_get_toplevel (GTK_WIDGET (page))));
gtk_window_set_modal (GTK_WINDOW (priv->join_dialog), TRUE);
gtk_window_present (GTK_WINDOW (priv->join_dialog));
priv->join_prompted = TRUE;
g_object_unref (kerberos);
g_object_unref (membership);
/* And now we wait for on_join_response() */
}
static void
on_realm_login (GObject *source,
GAsyncResult *result,
gpointer user_data)
{
UmAccountDialog *self = UM_ACCOUNT_DIALOG (user_data);
GError *error = NULL;
GBytes *creds;
um_realm_login_finish (result, &creds, &error);
if (error == NULL) {
/* Already joined to the domain, just register this user */
if (um_realm_is_configured (self->selected_realm)) {
g_debug ("Already joined to this realm");
enterprise_permit_user_login (self);
/* Join the domain, try using the user's creds */
} else if (!um_realm_join_as_user (self->selected_realm,
gtk_entry_get_text (self->enterprise_login),
gtk_entry_get_text (self->enterprise_password),
creds, self->cancellable,
on_realm_joined,
g_object_ref (self))) {
/* If we can't do user auth, try to authenticate as admin */
g_debug ("Cannot join with user credentials");
join_show_prompt (self, NULL);
}
g_bytes_unref (creds);
/* A problem with the user's login name or password */
} else if (g_error_matches (error, UM_REALM_ERROR, UM_REALM_ERROR_BAD_LOGIN)) {
g_debug ("Problem with the user's login: %s", error->message);
set_entry_validation_error (self->enterprise_login, error->message);
finish_action (self);
gtk_widget_grab_focus (GTK_WIDGET (self->enterprise_login));
} else if (g_error_matches (error, UM_REALM_ERROR, UM_REALM_ERROR_BAD_PASSWORD)) {
g_debug ("Problem with the user's password: %s", error->message);
set_entry_validation_error (self->enterprise_password, error->message);
finish_action (self);
gtk_widget_grab_focus (GTK_WIDGET (self->enterprise_password));
/* Other login failure */
} else {
g_dbus_error_strip_remote_error (error);
show_error_dialog (self, _("Failed to log into domain"), error);
g_message ("Couldn't log in as user: %s", error->message);
finish_action (self);
}
g_clear_error (&error);
g_object_unref (self);
}
static void
join_show_prompt (UmAccountDialog *self,
GError *error)
{
UmRealmKerberosMembership *membership;
UmRealmKerberos *kerberos;
const gchar *name;
gtk_entry_set_text (self->join_password, "");
gtk_widget_grab_focus (GTK_WIDGET (self->join_password));
kerberos = um_realm_object_get_kerberos (self->selected_realm);
membership = um_realm_object_get_kerberos_membership (self->selected_realm);
gtk_label_set_text (self->join_domain,
um_realm_kerberos_get_domain_name (kerberos));
clear_entry_validation_error (self->join_name);
clear_entry_validation_error (self->join_password);
if (!self->join_prompted) {
name = um_realm_kerberos_membership_get_suggested_administrator (membership);
if (name && !g_str_equal (name, "")) {
g_debug ("Suggesting admin user: %s", name);
gtk_entry_set_text (self->join_name, name);
} else {
gtk_widget_grab_focus (GTK_WIDGET (self->join_name));
}
} else if (g_error_matches (error, UM_REALM_ERROR, UM_REALM_ERROR_BAD_PASSWORD)) {
g_debug ("Bad admin password: %s", error->message);
set_entry_validation_error (self->join_password, error->message);
} else {
g_debug ("Admin login failure: %s", error->message);
g_dbus_error_strip_remote_error (error);
set_entry_validation_error (self->join_name, error->message);
}
g_debug ("Showing admin password dialog");
gtk_window_set_transient_for (GTK_WINDOW (self->join_dialog), GTK_WINDOW (self));
gtk_window_set_modal (GTK_WINDOW (self->join_dialog), TRUE);
gtk_window_present (GTK_WINDOW (self->join_dialog));
self->join_prompted = TRUE;
g_object_unref (kerberos);
g_object_unref (membership);
/* And now we wait for on_join_response() */
}
static void
on_realm_discover_input (GObject *source,
GAsyncResult *result,
gpointer user_data)
{
GisAccountPageEnterprise *page = user_data;
GisAccountPageEnterprisePrivate *priv = gis_account_page_enterprise_get_instance_private (page);
GError *error = NULL;
GList *realms;
realms = um_realm_manager_discover_finish (priv->realm_manager,
result, &error);
/* Found a realm, log user into domain */
if (error == NULL) {
g_assert (realms != NULL);
priv->realm = g_object_ref (realms->data);
enterprise_check_login (page);
g_list_free_full (realms, g_object_unref);
} else {
/* The domain is likely invalid */
g_dbus_error_strip_remote_error (error);
g_message ("Couldn't discover domain: %s", error->message);
gtk_widget_grab_focus (priv->domain_entry);
set_entry_validation_error (GTK_ENTRY (priv->domain_entry), error->message);
apply_complete (page, FALSE);
g_error_free (error);
}
}
static void
on_realm_discover_input (GObject *source,
GAsyncResult *result,
gpointer user_data)
{
UmAccountDialog *self = UM_ACCOUNT_DIALOG (user_data);
GError *error = NULL;
GList *realms;
realms = um_realm_manager_discover_finish (self->realm_manager,
result, &error);
/* Found a realm, log user into domain */
if (error == NULL) {
g_assert (realms != NULL);
self->selected_realm = g_object_ref (realms->data);
enterprise_check_login (self);
g_list_free_full (realms, g_object_unref);
/* The domain is likely invalid*/
} else {
finish_action (self);
g_message ("Couldn't discover domain: %s", error->message);
gtk_widget_grab_focus (GTK_WIDGET (self->enterprise_domain_entry));
g_dbus_error_strip_remote_error (error);
set_entry_validation_error (self->enterprise_domain_entry,
error->message);
g_error_free (error);
}
g_object_unref (self);
}
static gboolean
local_validate (UmAccountDialog *self)
{
gboolean valid_login;
gboolean valid_name;
GtkWidget *entry;
const gchar *name;
gchar *tip;
name = gtk_combo_box_text_get_active_text (GTK_COMBO_BOX_TEXT (self->local_username));
valid_login = is_valid_username (name, &tip);
entry = gtk_bin_get_child (GTK_BIN (self->local_username));
if (tip) {
set_entry_validation_error (GTK_ENTRY (entry), tip);
g_free (tip);
} else {
clear_entry_validation_error (GTK_ENTRY (entry));
}
name = gtk_entry_get_text (GTK_ENTRY (self->local_name));
valid_name = is_valid_name (name);
return valid_name && valid_login;
}
static gboolean
validate (GisPasswordPage *page)
{
GisPasswordPagePrivate *priv = gis_password_page_get_instance_private (page);
const gchar *password;
const gchar *verify;
gint strength_level;
const gchar *hint;
const gchar *long_hint;
if (priv->timeout_id != 0) {
g_source_remove (priv->timeout_id);
priv->timeout_id = 0;
}
password = gtk_entry_get_text (GTK_ENTRY (priv->password_entry));
verify = gtk_entry_get_text (GTK_ENTRY (priv->confirm_entry));
pw_strength (password, NULL, priv->username, &hint, &long_hint, &strength_level);
gtk_level_bar_set_value (GTK_LEVEL_BAR (priv->password_strength), strength_level);
gtk_label_set_label (GTK_LABEL (priv->password_explanation), long_hint);
if (strlen (password) > 0 && strength_level <= 0)
set_entry_validation_error (GTK_ENTRY (priv->password_entry), _("This is a weak password."));
else
clear_entry_validation_error (GTK_ENTRY (priv->password_entry));
gtk_label_set_label (GTK_LABEL (priv->confirm_explanation), "");
priv->valid_confirm = FALSE;
priv->valid_password = (strength_level > 0);
if (priv->valid_password)
set_entry_validation_checkmark (GTK_ENTRY (priv->password_entry));
if (strlen (password) > 0 && strlen (verify) > 0) {
priv->valid_confirm = (strcmp (password, verify) == 0);
if (!priv->valid_confirm) {
gtk_label_set_label (GTK_LABEL (priv->confirm_explanation), _("The passwords do not match."));
}
else {
set_entry_validation_checkmark (GTK_ENTRY (priv->confirm_entry));
}
}
update_page_validation (page);
return FALSE;
}
static void
auth_cb (PasswdHandler *handler,
GError *error,
UmPasswordDialog *um)
{
if (error) {
um->old_password_ok = FALSE;
set_entry_validation_error (GTK_ENTRY (um->old_password_entry),
_("Wrong password"));
}
else {
um->old_password_ok = TRUE;
clear_entry_validation_error (GTK_ENTRY (um->old_password_entry));
}
update_sensitivity (um);
}
static void
update_password_match (UmPasswordDialog *um)
{
const char *password;
const char *verify;
password = gtk_entry_get_text (GTK_ENTRY (um->password_entry));
verify = gtk_entry_get_text (GTK_ENTRY (um->verify_entry));
if (strlen (password) > 0 && strlen (verify) > 0) {
if (strcmp (password, verify) != 0) {
set_entry_validation_error (GTK_ENTRY (um->verify_entry),
_("Passwords do not match"));
}
else {
clear_entry_validation_error (GTK_ENTRY (um->verify_entry));
}
}
}
static gboolean
verify_entry_focus_out (GtkWidget *entry,
GdkEventFocus *event,
UmPasswordDialog *um)
{
const char *password;
const char *verify;
password = gtk_entry_get_text (GTK_ENTRY (um->password_entry));
verify = gtk_entry_get_text (GTK_ENTRY (um->verify_entry));
if (strlen (password) > 0 && strlen (verify) > 0) {
if (strcmp (password, verify) != 0) {
set_entry_validation_error (GTK_ENTRY (um->verify_entry),
_("Passwords do not match"));
}
else {
clear_entry_validation_error (GTK_ENTRY (um->verify_entry));
}
}
return FALSE;
}
static void
on_realm_login (GObject *source,
GAsyncResult *result,
gpointer user_data)
{
GisAccountPageEnterprise *page = user_data;
GisAccountPageEnterprisePrivate *priv = gis_account_page_enterprise_get_instance_private (page);
GError *error = NULL;
GBytes *creds = NULL;
um_realm_login_finish (priv->realm, result, &creds, &error);
/*
* User login is valid, but cannot authenticate right now (eg: user needs
* to change password at next login etc.)
*/
if (g_error_matches (error, UM_REALM_ERROR, UM_REALM_ERROR_CANNOT_AUTH)) {
g_clear_error (&error);
creds = NULL;
}
if (error == NULL) {
/* Already joined to the domain, just register this user */
if (um_realm_is_configured (priv->realm)) {
g_debug ("Already joined to this realm");
enterprise_permit_user_login (page, priv->realm);
/* Join the domain, try using the user's creds */
} else if (creds == NULL ||
!um_realm_join_as_user (priv->realm,
gtk_entry_get_text (GTK_ENTRY (priv->login)),
gtk_entry_get_text (GTK_ENTRY (priv->password)),
creds, priv->cancellable,
on_realm_joined,
page)) {
/* If we can't do user auth, try to authenticate as admin */
g_debug ("Cannot join with user credentials");
join_show_prompt (page, error);
}
g_bytes_unref (creds);
/* A problem with the user's login name or password */
} else if (g_error_matches (error, UM_REALM_ERROR, UM_REALM_ERROR_BAD_LOGIN)) {
g_debug ("Problem with the user's login: %s", error->message);
set_entry_validation_error (GTK_ENTRY (priv->login), error->message);
gtk_widget_grab_focus (priv->login);
apply_complete (page, FALSE);
} else if (g_error_matches (error, UM_REALM_ERROR, UM_REALM_ERROR_BAD_PASSWORD)) {
g_debug ("Problem with the user's password: %s", error->message);
set_entry_validation_error (GTK_ENTRY (priv->password), error->message);
gtk_widget_grab_focus (priv->password);
apply_complete (page, FALSE);
/* Other login failure */
} else {
show_error_dialog (page, _("Failed to log into domain"), error);
g_message ("Couldn't log in as user: %s", error->message);
apply_complete (page, FALSE);
}
g_clear_error (&error);
}