static void add_identities(GtkComboBox *combo, GList *identities) { GList *p; GtkCellRenderer *column; GtkListStore *store; store = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_OBJECT); for (p = identities; p != NULL; p = p->next) { gchar *str = NULL; PolkitIdentity *id = (PolkitIdentity *)p->data; if(POLKIT_IS_UNIX_USER(id)) { uid_t uid = polkit_unix_user_get_uid(POLKIT_UNIX_USER(id)); struct passwd *pwd = getpwuid(uid); str = g_strdup(pwd->pw_name); } else if(POLKIT_IS_UNIX_GROUP(id)) { gid_t gid = polkit_unix_group_get_gid(POLKIT_UNIX_GROUP(id)); struct group *grp = getgrgid(gid); str = g_strdup_printf(_("Group: %s"), grp->gr_name); } else { str = polkit_identity_to_string(id); } gtk_list_store_insert_with_values(store, NULL, -1, 0, str, 1, id, -1); g_free(str); } gtk_combo_box_set_model(combo, GTK_TREE_MODEL(store)); g_object_unref(store); column = gtk_cell_renderer_text_new(); gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(combo), column, TRUE); gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(combo), column, "text", 0, NULL); }
static void auth_request_initiate (AuthRequest *request) { gchar **user_names; GPtrArray *p; GList *l; p = g_ptr_array_new (); for (l = request->identities; l != NULL; l = l->next) { if (POLKIT_IS_UNIX_USER (l->data)) { PolkitUnixUser *user = POLKIT_UNIX_USER (l->data); gint uid; gchar buf[4096]; struct passwd pwd; struct passwd *ppwd; uid = polkit_unix_user_get_uid (user); if (getpwuid_r (uid, &pwd, buf, sizeof (buf), &ppwd) == 0) { if (!g_utf8_validate (pwd.pw_name, -1, NULL)) { g_warning ("Invalid UTF-8 in username for uid %d. Skipping", uid); } else { g_ptr_array_add (p, g_strdup (pwd.pw_name)); } } else { g_warning ("Error looking up user name for uid %d", uid); } } else { g_warning ("Unsupporting identity of GType %s", g_type_name (G_TYPE_FROM_INSTANCE (l->data))); } } g_ptr_array_add (p, NULL); user_names = (gchar **) g_ptr_array_free (p, FALSE); g_signal_emit (request->agent, signals[INITIATE_SIGNAL], 0, /* detail */ request->action_id, request->message, request->icon_name, request->cookie, user_names); g_strfreev (user_names); }
static gint compare_users (gconstpointer a, gconstpointer b) { char *user; int ret; if (POLKIT_IS_UNIX_USER (a)) user = g_strdup (polkit_unix_user_get_name (POLKIT_UNIX_USER (a))); else user = polkit_identity_to_string (POLKIT_IDENTITY (a)); ret = g_strcmp0 ((const char *) user, (const char *) b); g_free (user); return ret; }
static void cockpit_polkit_agent_initiate_authentication (PolkitAgentListener *listener, const gchar *action_id, const gchar *message, const gchar *icon_name, PolkitDetails *details, const gchar *cookie, GList *identities, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data) { CockpitPolkitAgent *self = COCKPIT_POLKIT_AGENT (listener); PolkitIdentity *identity = NULL; GSimpleAsyncResult *result = NULL; GString *unsupported = NULL; ReauthorizeCaller *caller; gchar *string; uid_t uid; GList *l; const gchar *argv[] = { PACKAGE_LIBEXEC_DIR "/cockpit-polkit", cookie, NULL, }; g_debug ("polkit is requesting authentication"); result = g_simple_async_result_new (G_OBJECT (self), callback, user_data, cockpit_polkit_agent_initiate_authentication); uid = getuid (); unsupported = g_string_new (""); for (l = identities; l != NULL; l = g_list_next (l)) { if (POLKIT_IS_UNIX_USER (l->data)) { if (polkit_unix_user_get_uid (l->data) == uid) { identity = g_object_ref (l->data); break; } } string = polkit_identity_to_string (l->data); g_string_append_printf (unsupported, "%s ", string); g_free (string); } if (!identity) { g_message ("cannot reauthorize identity(s): %s", unsupported->str); g_simple_async_result_set_error (result, POLKIT_ERROR, POLKIT_ERROR_FAILED, "Reauthorization not supported for identity"); g_simple_async_result_complete_in_idle (result); goto out; } string = polkit_identity_to_string (identity); g_message ("Reauthorizing %s", string); g_free (string); caller = g_new0 (ReauthorizeCaller, 1); caller->cookie = g_strdup (cookie); caller->helper = cockpit_pipe_spawn (argv, NULL, NULL, COCKPIT_PIPE_FLAGS_NONE); caller->read_sig = g_signal_connect (caller->helper, "read", G_CALLBACK (on_helper_read), caller); caller->close_sig = g_signal_connect (caller->helper, "close", G_CALLBACK (on_helper_close), caller); caller->cancellable = g_object_ref (cancellable); caller->cancel_sig = g_cancellable_connect (cancellable, G_CALLBACK (on_cancelled), caller, NULL); caller->result = g_object_ref (result); caller->self = self; g_hash_table_replace (self->callers, caller->cookie, caller); g_debug ("cockpit-polkit helper starting"); out: if (unsupported) g_string_free (unsupported, TRUE); g_object_unref (result); if (identity) g_object_unref (identity); }
static void initiate_authentication (PolkitAgentListener *listener, const char *action_id, const char *message, const char *icon_name, PolkitDetails *details, const char *cookie, GList *identities, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data) { NMPolkitListenerPrivate *priv = NM_POLKIT_LISTENER_GET_PRIVATE (listener); GSimpleAsyncResult *simple; PolkitIdentity *identity; simple = g_simple_async_result_new (G_OBJECT (listener), callback, user_data, initiate_authentication); if (priv->active_session != NULL) { g_simple_async_result_set_error (simple, POLKIT_ERROR, POLKIT_ERROR_FAILED, _("An authentication session is already underway.")); g_simple_async_result_complete_in_idle (simple); g_object_unref (simple); return; } /* Choose identity */ identity = choose_identity (identities); priv->active_session = polkit_agent_session_new (identity, cookie); g_signal_connect (priv->active_session, "completed", G_CALLBACK (on_completed), listener); g_signal_connect (priv->active_session, "request", G_CALLBACK (on_request), listener); g_signal_connect (priv->active_session, "show-info", G_CALLBACK (on_show_info), listener); g_signal_connect (priv->active_session, "show-error", G_CALLBACK (on_show_error), listener); priv->action_id = g_strdup (action_id); priv->message = g_strdup (message); priv->icon_name = g_strdup (icon_name); if (POLKIT_IS_UNIX_USER (identity)) priv->identity = g_strdup (polkit_unix_user_get_name (POLKIT_UNIX_USER (identity))); else priv->identity = polkit_identity_to_string (identity); priv->simple = simple; priv->cancellable = g_object_ref (cancellable); priv->cancel_id = g_cancellable_connect (cancellable, G_CALLBACK (on_cancelled), listener, NULL); polkit_agent_session_initiate (priv->active_session); }
static void initiate_authentication(PolkitAgentListener *listener, const gchar *action_id, const gchar *message, const gchar *icon_name, PolkitDetails *details, const gchar *cookie, GList *identities, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data) { GtkBuilder* b = gtk_builder_new(); GtkWidget *icon, *msg, *detail, *id_hbox; GList* l; DlgData* data = g_slice_new0(DlgData); DEBUG("init_authentication"); DEBUG("action_id = %s", action_id); #ifdef G_ENABLE_DEBUG char** p; for(p = polkit_details_get_keys(details);*p;++p) DEBUG("%s: %s", *p, polkit_details_lookup(details, *p)); #endif data->listener = (LXPolkitListener*)listener; data->result = g_simple_async_result_new(listener, callback, user_data, initiate_authentication); data->action_id = g_strdup(action_id); data->cancellable = (GCancellable*)g_object_ref(cancellable); data->callback = callback; data->user_data = user_data; data->cookie = g_strdup(cookie); /* create the dialog, load from GtkBuilder ui definition file. */ gtk_builder_add_from_file(b, PACKAGE_UI_DIR "/lxpolkit.ui", NULL); data->dlg = (GtkWidget*)gtk_builder_get_object(b, "dlg"); icon = (GtkWidget*)gtk_builder_get_object(b, "icon"); msg = (GtkWidget*)gtk_builder_get_object(b, "msg"); detail = (GtkWidget*)gtk_builder_get_object(b, "detail"); id_hbox = (GtkWidget*)gtk_builder_get_object(b, "id_hbox"); data->id = (GtkWidget*)gtk_builder_get_object(b, "id"); data->request = (GtkWidget*)gtk_builder_get_object(b, "request"); data->request_label = (GtkWidget*)gtk_builder_get_object(b, "request_label"); g_object_unref(b); g_signal_connect(data->dlg, "response", G_CALLBACK(on_dlg_response), data); g_signal_connect(cancellable, "cancelled", G_CALLBACK(on_cancelled), data); gtk_dialog_set_alternative_button_order(GTK_DIALOG(data->dlg), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL); gtk_dialog_set_default_response(GTK_DIALOG(data->dlg), GTK_RESPONSE_OK); gtk_window_set_icon_name(GTK_WINDOW(data->dlg), GTK_STOCK_DIALOG_AUTHENTICATION); /* set dialog icon */ if(icon_name && *icon_name) gtk_image_set_from_icon_name(GTK_IMAGE(icon), icon_name, GTK_ICON_SIZE_DIALOG); else gtk_image_set_from_stock(GTK_IMAGE(icon), GTK_STOCK_DIALOG_AUTHENTICATION, GTK_ICON_SIZE_DIALOG); /* set message prompt */ gtk_label_set_text(GTK_LABEL(msg), message); /* create combo box for user selection */ if( identities ) { GtkListStore* store = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_OBJECT); g_signal_connect(data->id, "changed", G_CALLBACK(on_user_changed), data); for(l = identities; l; l=l->next) { PolkitIdentity* id = (PolkitIdentity*)l->data; char* name; if(POLKIT_IS_UNIX_USER(id)) { struct passwd* pwd = getpwuid(polkit_unix_user_get_uid(POLKIT_UNIX_USER(id))); gtk_list_store_insert_with_values(store, NULL, -1, 0, pwd->pw_name, 1, id, -1); } else if(POLKIT_IS_UNIX_GROUP(id)) { struct group* grp = getgrgid(polkit_unix_group_get_gid(POLKIT_UNIX_GROUP(id))); char* str = g_strdup_printf(_("Group: %s"), grp->gr_name); gtk_list_store_insert_with_values(store, NULL, -1, 0, str, 1, id, -1); g_free(str); } else { /* FIXME: what's this? */ char* str = polkit_identity_to_string(id); gtk_list_store_insert_with_values(store, NULL, -1, 0, str, 1, id, -1); g_free(str); } } gtk_combo_box_set_model(data->id, GTK_TREE_MODEL(store)); g_object_unref(store); /* select the fist user in the list */ gtk_combo_box_set_active(data->id, 0); } else { DEBUG("no identities list, is this an error?"); gtk_widget_hide(id_hbox); g_simple_async_result_complete_in_idle(data->result); dlg_data_free(data); return; } gtk_window_present(GTK_WINDOW(data->dlg)); }