static void on_join_response (GtkDialog *dialog, gint response, gpointer user_data) { GisAccountPageEnterprise *page = user_data; GisAccountPageEnterprisePrivate *priv = gis_account_page_enterprise_get_instance_private (page); GDBusConnection *connection; GError *error = NULL; gchar hostname[128]; const gchar *name; gtk_widget_hide (GTK_WIDGET (dialog)); if (response != GTK_RESPONSE_OK) { apply_complete (page, FALSE); return; } name = gtk_entry_get_text (GTK_ENTRY (priv->join_computer)); if (gethostname (hostname, sizeof (hostname)) == 0 && !g_str_equal (name, hostname)) { g_debug ("Setting StaticHostname to '%s'", name); connection = g_bus_get_sync (G_BUS_TYPE_SYSTEM, priv->cancellable, &error); if (error != NULL) { apply_complete (page, FALSE); g_warning ("Could not get DBus connection: %s", error->message); g_error_free (error); return; } g_dbus_connection_call (connection, "org.freedesktop.hostname1", "/org/freedesktop/hostname1", "org.freedesktop.hostname1", "SetStaticHostname", g_variant_new ("(sb)", name, TRUE), G_VARIANT_TYPE ("()"), G_DBUS_CALL_FLAGS_NONE, G_MAXINT, NULL, on_set_static_hostname, page); } else { name = gtk_entry_get_text (GTK_ENTRY (priv->join_name)); g_debug ("Logging in as admin user: %s", name); /* Prompted for some admin credentials, try to use them to log in */ um_realm_login (priv->realm, name, gtk_entry_get_text (GTK_ENTRY (priv->join_password)), NULL, on_join_login, page); } }
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_joined (GObject *source, GAsyncResult *result, gpointer user_data) { GisAccountPageEnterprise *page = user_data; GisAccountPageEnterprisePrivate *priv = gis_account_page_enterprise_get_instance_private (page); GError *error = NULL; um_realm_join_finish (priv->realm, result, &error); /* Yay, joined the domain, register the user locally */ if (error == NULL) { g_debug ("Joining realm completed successfully"); enterprise_permit_user_login (page, priv->realm); /* Credential failure while joining domain, prompt for admin creds */ } else if (g_error_matches (error, UM_REALM_ERROR, UM_REALM_ERROR_BAD_LOGIN) || g_error_matches (error, UM_REALM_ERROR, UM_REALM_ERROR_BAD_PASSWORD) || g_error_matches (error, UM_REALM_ERROR, UM_REALM_ERROR_BAD_HOSTNAME)) { g_debug ("Joining realm failed due to credentials or host name"); join_show_prompt (page, error); /* Other failure */ } else { show_error_dialog (page, _("Failed to join domain"), error); g_message ("Failed to join the domain: %s", error->message); apply_complete (page, FALSE); } g_clear_error (&error); }
static void on_permit_user_login (GObject *source, GAsyncResult *result, gpointer user_data) { GisAccountPageEnterprise *page = user_data; GisAccountPageEnterprisePrivate *priv = gis_account_page_enterprise_get_instance_private (page); UmRealmCommon *common; GError *error = NULL; gchar *login; common = UM_REALM_COMMON (source); um_realm_common_call_change_login_policy_finish (common, result, &error); if (error == NULL) { /* * Now tell the account service about this user. The account service * should also lookup information about this via the realm and make * sure all that is functional. */ login = um_realm_calculate_login (common, gtk_entry_get_text (GTK_ENTRY (priv->login))); g_return_if_fail (login != NULL); g_debug ("Caching remote user: %s", login); priv->act_user = act_user_manager_cache_user (priv->act_client, login, NULL); g_signal_emit (page, signals[USER_CACHED], 0, priv->act_user, gtk_entry_get_text (GTK_ENTRY (priv->password))); apply_complete (page, TRUE); g_free (login); } else { show_error_dialog (page, _("Failed to register account"), error); g_message ("Couldn't permit logins on account: %s", error->message); g_error_free (error); apply_complete (page, 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); }
/* * If given a '-p' flag, read encoded delta pieces from stdin or file * arguments, decode them and assemble any completed deltas. If given * a '-b' flag, pass any completed deltas to 'ctm' for application to * the source tree. The '-d' flag is mandatory, but either of '-p' or * '-b' can be omitted. If given the '-l' flag, notes and errors will * be timestamped and written to the given file. * * Exit status is 0 for success or 1 for indigestible input. That is, * 0 means the encode input pieces were decoded and stored, and 1 means * some input was discarded. If a delta fails to apply, this won't be * reflected in the exit status. In this case, the delta is left in * 'deltadir'. */ int main(int argc, char **argv) { char *log_file = NULL; int status = 0; int fork_ctm = 0; mask = umask(0); umask(mask); err_prog_name(argv[0]); OPTIONS("[-Dfuv] [-p piecedir] [-d deltadir] [-b basedir] [-l log] [file ...]") FLAG('D', delete_after) FLAG('f', fork_ctm) FLAG('u', set_time) FLAG('v', apply_verbose) STRING('p', piece_dir) STRING('d', delta_dir) STRING('b', base_dir) STRING('l', log_file) ENDOPTS if (delta_dir == NULL) usage(); if (piece_dir == NULL && (base_dir == NULL || argc > 1)) usage(); if (log_file != NULL) err_set_log(log_file); /* * Digest each file in turn, or just stdin if no files were given. */ if (argc <= 1) { if (piece_dir != NULL) status = read_piece(NULL); } else { while (*++argv != NULL) status |= read_piece(*argv); } /* * Maybe it's time to look for and apply completed deltas with ctm. * * Shall we report back to sendmail immediately, and let a child do * the work? Sendmail will be waiting for us to complete, delaying * other mail, and possibly some intermediate process (like MH slocal) * will terminate us if we take too long! * * If fork() fails, it's unlikely we'll be able to run ctm, so give up. * Also, the child exit status is unimportant. */ if (base_dir != NULL) if (!fork_ctm || fork() == 0) apply_complete(); return status; }