Solaris uses the gtk unlock dialog program originally written by

Ximian & Wipro, in order to provide a dialog box that works with

the GNOME accessibility framework. This was done as a fork of

the original xscreensaver because the maintainer would not allow

use of a toolkit in the lock dialog - he has since softened his

stance a bit, but this has not been presented to him to see if it

meets his requirements as spelled out at:

http://www.jwz.org/xscreensaver/toolkits.html

This patch also contains a fixes for:

Sun bug 6541240

Screen saver will lock user out of the system if they have no

password set

Sun bug 5077993/GNOME Bug 147639:

Gok cant automatically UI grab screensaver preferences

http://bugs.opensolaris.org/bugdatabase/view_bug.do?bug_id=5077993

http://bugzilla.gnome.org/show_bug.cgi?id=147639

Sun bug 5083155:

Unable to unlock screen when running dual-head magnification

http://bugs.opensolaris.org/bugdatabase/view_bug.do?bug_id=5083155

Sun bug 5059445:

screen kb and screen reader support

http://bugs.opensolaris.org/bugdatabase/view_bug.do?bug_id=5059445

Sun bug 5039878:

"Password:" field should be focused / have flashing caret

http://bugs.opensolaris.org/bugdatabase/view_bug.do?bug_id=5039878

Sun bug 6461887:

GNOME screen lock does not prevent access to other applications

via 'alt-tab'

Sun bug 6736157:

[A11Y] Security problem when desktop a11y support is turned on.

Sun bug 6573182:

after applying patch 120094-11 (or later), xscreensaver coredump

http://bugs.opensolaris.org/bugdatabase/view_bug.do?bug_id=6573182

---

config.h.in | 3 +

configure.in | 23 +-

driver/Makefile.in | 59 +++-

driver/auth.h | 4 +

driver/demo-Gtk.c | 18 +

driver/dialog-data.h | 122 ++++++

driver/lock-Gtk.c | 956 ++++++++++++++++++++++++++++++++++++++++++++

driver/lock.c | 1069 ++++++++++++++++++++++++++++++++++++++++++++-----

driver/passwd-pam.c | 207 +++++++++-

driver/passwd.c | 1 +

driver/setuid.c | 5 +-

driver/subprocs.c | 35 ++-

driver/timers.c | 114 ++++++-

driver/types.h | 18 +

driver/windows.c | 21 +-

driver/xscreensaver.c | 131 ++++++-

driver/xscreensaver.h | 6 +

17 files changed, 2654 insertions(+), 135 deletions(-)

create mode 100644 driver/dialog-data.h

create mode 100644 driver/lock-Gtk.c

diff --git xscreensaver-5.12/config.h.in xscreensaver-5.12/config.h.in

--- xscreensaver-5.12/config.h.in

+++ xscreensaver-5.12/config.h.in

@@ -405,6 +405,9 @@

make use of this if it is available. */

#undef HAVE_XPM

+/* Define this to build the external lock dialog */

+#undef HAVE_XSCREENSAVER_LOCK

+

/* Define this if you have the X Shared Memory Extension. */

#undef HAVE_XSHM_EXTENSION

diff --git xscreensaver-5.12/configure.in xscreensaver-5.12/configure.in

--- xscreensaver-5.12/configure.in

+++ xscreensaver-5.12/configure.in

@@ -2527,6 +2527,8 @@ if test "$with_gtk" = yes; then

pkg_check_version libglade-2.0 1.99.0

pkg_check_version gdk-pixbuf-2.0 2.0.0

pkg_check_version gdk-pixbuf-xlib-2.0 2.0.0

+ pkg_check_version gconf-2.0 2.6.1

+ pkg_check_version libloginhelper-1.0 1.0

have_gtk="$ok"

if test "$have_gtk" = no; then

@@ -2542,6 +2544,9 @@ if test "$with_gtk" = yes; then

fi

if test "$have_gtk" = yes; then

+#--- Begin SUNW addition

+ AC_DEFINE(HAVE_XSCREENSAVER_LOCK,[],[Define this to build the external lock dialog])

+#--- End SUNW addition

AC_CACHE_CHECK([for Gtk includes], ac_cv_gtk_config_cflags,

[ac_cv_gtk_config_cflags=`$pkg_config --cflags $pkgs`])

AC_CACHE_CHECK([for Gtk libs], ac_cv_gtk_config_libs,

@@ -3626,6 +3631,16 @@ if test "$have_gtk" = yes; then

ALL_DEMO_PROGRAMS="$PREFERRED_DEMO_PROGRAM $ALL_DEMO_PROGRAMS"

fi

+#--- Begin SUNW addition

+PREFERRED_LOCK_PROGRAM=

+ALL_LOCK_PROGRAMS=

+LOCK_PROGRAM=

+if test "$have_gtk" = yes; then

+ PREFERRED_LOCK_PROGRAM=xscreensaver-lock-Gtk

+ ALL_LOCK_PROGRAMS="$PREFERRED_LOCK_PROGRAM $ALL_LOCK_PROGRAMS"

+ LOCK_PROGRAM=xscreensaver-lock

+fi

+#--- End SUNW addition

if test "$have_kerberos" = yes; then

PASSWD_SRCS="$PASSWD_SRCS \$(KERBEROS_SRCS)"

@@ -3765,6 +3780,11 @@ AC_SUBST(INCLUDES)

AC_SUBST(PREFERRED_DEMO_PROGRAM)

AC_SUBST(ALL_DEMO_PROGRAMS)

+#--- Begin SUNW addition

+AC_SUBST(PREFERRED_LOCK_PROGRAM)

+AC_SUBST(ALL_LOCK_PROGRAMS)

+AC_SUBST(LOCK_PROGRAM)

+#--- End SUNW addition

AC_SUBST(SAVER_LIBS)

AC_SUBST(MOTIF_LIBS)

AC_SUBST(GTK_LIBS)

@@ -4244,7 +4264,8 @@ HACK_CONF_DIR=`echo "${HACK_CONF_DIR}" | sed 's@/$@@;s@//*@/@g'`

# Sanity check the hackdir

-for bad_choice in xscreensaver xscreensaver-demo xscreensaver-command ; do

+# SUNW addition: added xscreensaver-lock to list on next line

+for bad_choice in xscreensaver xscreensaver-demo xscreensaver-command xscreensaver-lock ; do

if test "${HACKDIR}" = "${bindir}/${bad_choice}" ; then

echo ""

AC_MSG_ERROR([\"--with-hackdir=${bindir}/${bad_choice}\" won't work.

@@ -42,6 +43,7 @@ SUBP_DEFS = $(DEFS) -DHACK_PATH='"@HACKDIR@"' \

GTK_DEFS = $(DEFS) -DDEFAULT_ICONDIR='"$(GTK_GLADEDIR)"' \

-DBINDIR='"$(bindir)"'

CONF_DEFS = -DHACK_CONFIGURATION_PATH='"$(HACK_CONF_DIR)"'

+ @if [ -n "@LOCK_PROGRAM@" -a ! -d $(install_prefix)$(LOCK_DIR) ]; then \

@inst="$(INSTALL_PROGRAM)" ; \

me=`PATH="$$PATH:/usr/ucb" whoami` ; \

+ @if [ -n "@LOCK_PROGRAM@" ]; then \

+#define KEY "/desktop/gnome/interface/accessibility"

+ putenv ("GTK_MODULES=gail:atk-bridge");

+ * software for any purpose. It is provided "as is" without express or

+#include "types.h"

+#include "mlstring.h"

+ Bool show_stars_p; /* "I regret that I have but one asterisk for my country."

+ * software for any purpose. It is provided "as is" without express or

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+# include "config.h"

+#include "remote.h"

+#include "atoms.h"

+ "msg\n" if no data, otherwise "msg=data\n"

+ fprintf (stderr, "-->Child write_to_parent() string to send is: %s=%s\n",

+ msg, data ? data : "(null)");

+ len = fprintf (parent_file, "%s=%s\n", msg, data);

+ len = fprintf (parent_file, "%s\n", msg);

+ snprintf(s, sizeof(s), "0x%lx", w);

+ logofile = DEFAULT_ICONDIR "/unlock-logo.png";

+ logofile = DEFAULT_ICONDIR "/logo-180.gif"; /* fallback */

+ fprintf (stderr, "%s: no xscreensaver running on display %s, exiting.\n",

+ atk_object_set_description (atk_dialog, _("screen unlock dialog"));

+ _("Percent of time you have left to unlock the screen."));

+ s = g_markup_printf_escaped ("<span size=\"xx-large\"><b>%s </b></span>",

+ _("Screensaver"));

+ /* XScreenSaver foo label */

+ title_label = g_object_new (GTK_TYPE_LABEL,

+ "use-markup", TRUE,

+ "label", s,

+ NULL);

+ g_free (s);

+ gtk_box_pack_start (GTK_BOX (vbox2), title_label,

+ FALSE, FALSE, 0);

+ /* AT role = label prog name */

+ atk_title_label = gtk_widget_get_accessible (title_label);

+ atk_object_add_relationship (atk_title_label, ATK_RELATION_LABEL_FOR,

+ atk_dialog);

+ atk_object_add_relationship (atk_dialog, ATK_RELATION_LABELLED_BY,

+ atk_title_label);

+

+ /* This display is locked. */

+ msg_label = g_object_new (GTK_TYPE_LABEL,

+ "use-markup", TRUE,

+ "label", _("<b>This display is locked.</b>"),

+ NULL);

+ pwd->msg_label = msg_label;

+ gtk_box_pack_start (GTK_BOX (vbox2), msg_label,

+ FALSE, FALSE, 0);

+

+ /* User information */

+ s = g_strdup_printf (_("User: %s"), user ? user : "");

+ user_label = g_object_new (GTK_TYPE_LABEL,

+ "label", s,

+ "use_underline", TRUE,

+ NULL);

+ g_free(s);

+ gtk_label_set_width_chars (GTK_LABEL (user_label), 35);

+ gtk_box_pack_start (GTK_BOX (vbox2), user_label, FALSE, FALSE, 0);

+

+ /* User input */

+ hbox2 = gtk_widget_new (GTK_TYPE_HBOX,

+ "border_width", 5,

+ "visible", TRUE,

+ "homogeneous", FALSE,

+ "spacing", 1,

+ NULL);

+

+ /* PAM prompt */

+ prompt_label = g_object_new (GTK_TYPE_LABEL,

+ /* blank space for prompt */

+ "label", _(" "),

+ "use_underline", TRUE,

+ "use_markup", FALSE,

+ "justify", GTK_JUSTIFY_CENTER,

+ "wrap", FALSE,

+ "selectable", FALSE,

+ "xalign", 1.0,

+ "xpad", 0,

+ "ypad", 0,

+ "visible", FALSE,

+ NULL);

+ pwd->user_prompt_label = prompt_label;

+

+ entry = g_object_new (GTK_TYPE_ENTRY,

+ "activates-default", TRUE,

+ "visible", TRUE,

+ "editable", TRUE,

+ "visibility", FALSE,

+ "can_focus", TRUE,

+ NULL);

+ pwd->user_input_entry = entry;

+ /* gtk_widget_grab_focus (entry); */

+ atk_entry = gtk_widget_get_accessible (entry);

+ atk_object_set_role (atk_entry, ATK_ROLE_PASSWORD_TEXT);

+

+ /* AT role = label for input widget */

+ atk_prompt_label = gtk_widget_get_accessible (prompt_label);

+ atk_object_add_relationship (atk_prompt_label, ATK_RELATION_LABEL_FOR,

+ atk_entry);

+ atk_object_add_relationship (atk_entry, ATK_RELATION_LABELLED_BY,

+ atk_prompt_label);

+

+ gtk_box_pack_start (GTK_BOX (hbox2), prompt_label, FALSE, FALSE, 0);

+ gtk_box_pack_end (GTK_BOX (hbox2), entry, TRUE, TRUE, 0);

+ gtk_box_pack_start (GTK_BOX (vbox2), hbox2, FALSE, FALSE, 0);

+

+ pam_msg_label = g_object_new (GTK_TYPE_LABEL,

+ NULL);

+ pwd->pam_message_label = pam_msg_label;

+

+ gtk_box_pack_start (GTK_BOX (vbox2), pam_msg_label, FALSE, FALSE, 0);

+

+ /* date string */

+ tm = localtime (&now);

+ memset (buf, 0, sizeof (buf));

+ format_string_utf8 = _("%d-%b-%y (%a); %I:%M %p");

+ format_string_locale = g_locale_from_utf8 (format_string_utf8, -1,

+ NULL, NULL, NULL);

+ strftime (buf, sizeof (buf) - 1, format_string_locale, tm);

+ g_free (format_string_locale);

+

+ utf8_format = g_locale_to_utf8 (buf, -1, NULL, NULL, NULL);

+ s = g_markup_printf_escaped ("<small>%s</small>", utf8_format);

+ g_free (utf8_format);

+

+ date_label = g_object_new (GTK_TYPE_LABEL,

+ "use-markup", TRUE,

+ "label", s,

+ NULL);

+ g_free (s);

+ gtk_box_pack_start (GTK_BOX (vbox2), date_label,

+ FALSE, FALSE, 0);

+

+ /* button box */

+ bbox = g_object_new (GTK_TYPE_HBUTTON_BOX,

+ "layout-style", GTK_BUTTONBOX_END,

+ "spacing", 10,

+ NULL);

+

+ /* Ok button */

+ button = gtk_button_new_from_stock (GTK_STOCK_OK);

+ pwd->button = button;

+

+ gtk_box_pack_end (GTK_BOX (bbox), button,

+ FALSE, TRUE, 0);

+

+ free (user);

+ free (version);

+ free (host);

+

+ /* POP */

+ gtk_widget_pop_colormap ();

+

+ return pwd;

+}

+

+/* Callback for when user has finished entering input, even though

+static void

+ok_clicked_cb (GtkWidget *button, PasswdDialog *pwd)

+{

+ const char *s;

+

+ g_object_set (pwd->msg_label, "label", _("<b>Checking...</b>"), NULL);

+

+ s = gtk_entry_get_text (GTK_ENTRY (pwd->user_input_entry));

+ write_to_parent ("input", s, TRUE);

+

+ /* Reset password field to blank, else passwd field shows old passwd *'s,

+ gtk_editable_delete_text (GTK_EDITABLE (pwd->user_input_entry), 0, -1);

+ gtk_widget_hide (pwd->user_input_entry);

+ gtk_widget_hide (pwd->user_prompt_label);

+}

+

+static void

+connect_signals (PasswdDialog *pwd)

+{

+ g_signal_connect (pwd->button, "clicked",

+ G_CALLBACK (ok_clicked_cb),

+ pwd);

+

+ g_signal_connect (pwd->user_input_entry, "activate",

+ G_CALLBACK (ok_clicked_cb),

+ pwd);

+

+ g_signal_connect (pwd->dialog, "delete-event",

+ G_CALLBACK (gtk_main_quit),

+ NULL);

+}

+

+static GdkFilterReturn

+dialog_filter_func (GdkXEvent *xevent, GdkEvent *gevent, gpointer data)

+{

+ PasswdDialog *pwd = data;

+ XEvent *event = xevent;

+ gdouble ratio;

+

+ if ((event->xany.type != ClientMessage ||

+ event->xclient.message_type != XA_UNLOCK_RATIO))

+ return GDK_FILTER_CONTINUE;

+

+ ratio = event->xclient.data.l[0] / (gdouble)100.0;

+

+ /* CR 6176524 passwdTimeoutEnable for disabled user */

+ if (event->xclient.data.l[1] == 0)

+ g_object_set (pwd->progress, "fraction", ratio, NULL);

+

+ return GDK_FILTER_REMOVE;

+}

+

+static gboolean

+handle_input (GIOChannel *source, GIOCondition cond, gpointer data)

+{

+ PasswdDialog *pwd = data;

+ GIOStatus status;

+ char *str;

+ char *label;

+ char *hmsg = NULL; /* This is the heading of lock dialog..shows status */

+

+ if (cond & G_IO_HUP) /* daemon crashed/exited/was killed */

+ gtk_main_quit ();

+

+ do

+ {

+ status = g_io_channel_read_line (source, &str, NULL, NULL, NULL);

+ }

+ while (status == G_IO_STATUS_AGAIN);

+

+/* debug only

+

+ if (str)

+ {

+ /* strip trailing newline */

+ char *nl = strrchr(str, '\n');

+ if (nl)

+ *nl = 0;

+

+ /*

+

+ /* Handle commands from parent daemon */

+

+ if (((strncmp (str, "ul_", 3)) == 0))

+ {

+ /* search for =, and if found, split into two strings there */

+ char *msgstr = strchr(str, '='); /* Data sent with command */

+ if (msgstr)

+ *msgstr++ = 0;

+

+ if ((strcmp (str, "ul_ok") == 0))

+ {

+ hmsg = _("Authentication Successful!");

+ }

+ else if ((strcmp (str, "ul_acct_ok") == 0))

+ {

+ hmsg = _("PAM Account Management Also Successful!");

+ }

+ else if ((strcmp (str, "ul_setcred_fail") == 0))

+ {

+ hmsg = _("Just a Warning PAM Set Credential Failed!");

+ }

+ else if ((strcmp (str, "ul_setcred_ok") == 0))

+ {

+ hmsg = _("PAM Set Credential Also Successful!");

+ }

+ else if ((strcmp (str, "ul_acct_fail") == 0))

+ {

+ hmsg = _("Your Password has expired.");

+ }

+ else if ((strcmp (str, "ul_fail") == 0))

+ {

+ hmsg = _("Sorry!");

+ }

+ else if ((strcmp (str, "ul_read") == 0))

+ {

+ hmsg = _("Waiting for user input!");

+ }

+ else if ((strcmp (str, "ul_time") == 0))

+ {

+ hmsg = _("Timed Out!");

+ }

+ else if ((strcmp (str, "ul_null") == 0))

+ {

+ hmsg = _("Still Checking!");

+ }

+ else if ((strcmp (str, "ul_cancel") == 0))

+ {

+ hmsg = _("Authentication Cancelled!");

+ }

+ else if ((strcmp (str, "ul_pamprompt") == 0))

+ {

+ gtk_label_set_text (GTK_LABEL (pwd->user_prompt_label), msgstr);

+ gtk_widget_show (pwd->user_prompt_label);

+ msgstr = NULL; /* clear message so we don't show it twice */

+ }

+ else if ((strcmp (str, "ul_prompt_echo") == 0))

+ {

+ if ((strcmp (msgstr, "true") == 0))

+ {

+ gtk_entry_set_visibility

+ (GTK_ENTRY (pwd->user_input_entry), TRUE);

+ }

+ else

+ {

+ if ((strcmp (msgstr, "stars") == 0))

+ /* reset to default display of "*" or bullet */

+ gtk_entry_unset_invisible_char

+ (GTK_ENTRY (pwd->user_input_entry));

+ else

+ /* set to no display */

+ gtk_entry_set_invisible_char

+ (GTK_ENTRY (pwd->user_input_entry), 0);

+

+ gtk_entry_set_visibility

+ (GTK_ENTRY (pwd->user_input_entry), FALSE);

+ }

+ msgstr = NULL; /* clear message so we don't show it to user */

+ /* Show the entry field */

+ gtk_widget_show (pwd->user_input_entry);

+ gtk_widget_grab_focus (pwd->user_input_entry);

+ gdk_display_sync

+ (gtk_widget_get_display (pwd->user_input_entry));

+ }

+ else if ((strcmp (str, "ul_message") == 0))

+ {

+ hmsg = NULL; /* only show msg */

+ }

+ else

+ {

+ /* Should not be others, but if so just show it */

+ hmsg = str;

+ }

+

+ if (hmsg)

+ {

+ label = g_markup_printf_escaped ("<b>%s</b>", hmsg);

+ g_object_set (pwd->msg_label, "label", label, NULL);

+ g_free (label);

+ }

+

+ if (msgstr)

+ {

+ gtk_label_set_text (GTK_LABEL (pwd->pam_message_label), msgstr);

+ }

+ }

+ else if ((strcmp (str, "cmd_exit") == 0))

+ {

+ gtk_main_quit ();

+ }

+ else /* something came through that didn't start with ul_ */

+ {

+ gtk_label_set_text (GTK_LABEL (pwd->pam_message_label), str);

+ }

+

+ g_free (str);

+ }

+

+ return (status != G_IO_STATUS_EOF);

+}

+

+int

+main (int argc, char *argv[])

+{

+ GIOChannel *ioc;

+ PasswdDialog *pwd;

+ char *s;

+ char *real_progname = argv[0];

+ GConfClient *client;

+ const char *modulesptr = NULL;

+ int i;

+

+ gboolean at_enable = FALSE; /* accessibility mode enabled ? */

+ Bonobo_ServerInfoList *server_list = NULL;

+ CORBA_Environment ev;

+ Accessibility_LoginHelper helper;

+ Accessibility_LoginHelper *helper_list = NULL;

+ CORBA_boolean safe;

+ gboolean center_position = TRUE; /* center dialog on screen? */

+

+#ifdef ENABLE_NLS

+ bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR);

+ textdomain (GETTEXT_PACKAGE);

+

+#ifdef HAVE_GTK2

+ bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");

+#else /* ! HAVE_GTK2 */

+ if (!setlocale (LC_ALL, ""))

+ fprintf (stderr, "%s: locale not supported by C library\n", real_progname);

+#endif /* ! HAVE_GTK2 */

+#endif /* ENABLE_NLS */

+

+ s = strrchr (real_progname, '/');

+ if (s) real_progname = s+1;

+ progname = real_progname;

+

+ parent_file = fdopen(FD_TO_PARENT, "w");

+ if (!parent_file)

+ {

+ fprintf (stderr, "%s: can't communicate with parent, exiting.\n",

+ progname);

+ exit (1);

+ }

+

+ gtk_init (&argc, &argv);

+

+ /* Intern the atoms that xscreensaver_command() needs.

+ {

+ Display *dpy = gdk_x11_get_default_xdisplay();

+

+ const struct atom_request unlock_atoms[] =

+ {

+ { &XA_UNLOCK_RATIO, "UNLOCK_RATIO" },

+ { NULL, NULL } /* Must be last to terminate list */

+ };

+

+ const struct atom_request *atom_lists[3] = { NULL, NULL, NULL };

+ atom_lists[0] = remote_control_atoms;

+ atom_lists[1] = unlock_atoms;

+ request_atoms (dpy, atom_lists);

+ }

+

+ /* bugid 6346056(P1):

+ putenv ("GTK_IM_MODULE=gtk-im-context-simple");

+

+

+ /* accessibility mode enabled ? */

+ client = gconf_client_get_default ();

+ at_enable = gconf_client_get_bool (client,

+ "/desktop/gnome/interface/accessibility",

+ NULL);

+ if (at_enable)

+ {

+

+ /* GTK Accessibility Module initialized */

+ modulesptr = g_getenv ("GTK_MODULES");

+ if (!modulesptr || modulesptr [0] == '\0')

+ putenv ("GTK_MODULES=gail:atk-bridge");

+

+ CORBA_exception_init (&ev);

+ if (!bonobo_init (&argc, argv))

+ {

+ g_error ("Can't initialize Bonobo");

+ }

+

+ /* bonobo-activation query lists existing instances */

+ server_list = bonobo_activation_query (

+ "(repo_ids.has('IDL:Accessibility/LoginHelper:1.0')) AND _active",

+ NULL, &ev);

+

+ if (BONOBO_EX (&ev))

+ {

+ bonobo_debug_shutdown ();

+ g_error ("LoginHelper query failed : %s",

+ bonobo_exception_get_text (&ev));

+ /* not reached (below) because g_error exits */

+ CORBA_exception_free (&ev);

+ }

+

+ /*

+ if (server_list && server_list->_length)

+ center_position = FALSE;

+ } /* accessibility enabled */

+

+ pwd = make_dialog (center_position);

+ connect_signals (pwd);

+

+ gtk_widget_show_all (pwd->dialog);

+ gtk_window_present (GTK_WINDOW (pwd->dialog));

+ gtk_widget_map (pwd->dialog);

+

+ gdk_display_sync (gtk_widget_get_display (pwd->dialog));

+

+ gdk_window_add_filter (GET_WINDOW (pwd->dialog), dialog_filter_func, pwd);

+ write_windowid ("dialog_win", GDK_WINDOW_XID (GET_WINDOW (pwd->dialog)));

+

+ if (server_list && server_list->_length)

+ {

+ /* debug only

+

+ helper_list = g_new0 (Accessibility_LoginHelper, server_list->_length);

+

+ /* for each instance... */

+ for (i = 0; i < server_list->_length; i++)

+ {

+ Bonobo_Unknown server;

+ Bonobo_ServerInfo info = server_list->_buffer[i];

+

+ server = bonobo_activation_activate_from_id (

+ info.iid, Bonobo_ACTIVATION_FLAG_EXISTING_ONLY, NULL, &ev);

+

+ if (BONOBO_EX (&ev))

+ {

+ g_warning ("Error activating server %d: %s", i,

+ bonobo_exception_get_text (&ev));

+ CORBA_exception_free (&ev);

+ continue;

+ }

+ else if (server == CORBA_OBJECT_NIL)

+ {

+ g_warning ("Activated server %d is NIL!", i);

+ continue;

+ }

+

+ bonobo_activate ();

+

+ helper = Bonobo_Unknown_queryInterface

+ (server, "IDL:Accessibility/LoginHelper:1.0", &ev);

+

+ if (BONOBO_EX (&ev))

+ {

+ g_warning ("Error performing interface query: %s",

+ bonobo_exception_get_text (&ev));

+ CORBA_exception_free (&ev);

+ continue;

+ }

+ else if (helper == CORBA_OBJECT_NIL)

+ {

+ g_warning ("Activated an object which advertised LoginHelper but does not implement it!");

+ continue;

+ }

+

+ helper_list[i] = helper;

+ bonobo_object_release_unref (server, &ev);

+

+ if (helper && !BONOBO_EX (&ev))

+ {

+ /* ask the helper to go into safe mode */

+ safe = Accessibility_LoginHelper_setSafe (helper, TRUE, &ev);

+ if (BONOBO_EX (&ev))

+ {

+ g_warning ("setSafe(TRUE) failed: %s",

+ bonobo_exception_get_text (&ev));

+ CORBA_exception_free (&ev);

+ }

+

+ /* get the raise window list (if the program went into safe mode) */

+ if (safe)

+ {

+ int j;

+ gboolean needs_windows_raised = FALSE;

+ Accessibility_LoginHelper_DeviceReqList *list;

+

+ g_debug ("safe");

+

+ /* does this helper need to have windows raised? */

+ list = Accessibility_LoginHelper_getDeviceReqs (helper, &ev);

+

+ if (BONOBO_EX (&ev))

+ {

+ g_warning ("Bonobo exception getting Device Requirements: %s",

+ bonobo_exception_get_text (&ev));

+ CORBA_exception_free (&ev);

+ }

+ else

+ {

+ g_debug ("LoginHelper device requirements: ");

+ if (list->_length == 0)

+ g_debug (" - None.");

+

+ for (j = 0; j < list->_length; j++)

+ {

+ switch (list->_buffer[j])

+ {

+ case Accessibility_LoginHelper_GUI_EVENTS:

+ g_debug (" - Needs access to the GUI event subsystem (e.g. Xserver)");

+ break;

+ case Accessibility_LoginHelper_CORE_KEYBOARD:

+ g_debug (" - Needs access to core keyboard device");

+ write_to_parent("ungrab_keyboard", "true", FALSE);

+ break;

+ case Accessibility_LoginHelper_CORE_POINTER:

+ g_debug (" - Needs access to core pointer device");

+ write_to_parent("ungrab_pointer", "true", FALSE);

+ break;

+ case Accessibility_LoginHelper_EXT_INPUT:

+ g_debug (" - Reads XInput extended input devices");

+ break;

+ case Accessibility_LoginHelper_POST_WINDOWS:

+ g_debug (" - Posts windows");

+ needs_windows_raised = TRUE;

+ break;

+ case Accessibility_LoginHelper_AUDIO_OUT:

+ g_debug (" - Writes to audio device");

+ break;

+ case Accessibility_LoginHelper_AUDIO_IN:

+ g_debug (" - Reads from audio device");

+ break;

+ case Accessibility_LoginHelper_LOCALHOST:

+ g_debug (" - Needs LOCALHOST network connection");

+ break;

+ case Accessibility_LoginHelper_SERIAL_OUT:

+ g_debug (" - Needs to write to one or more serial ports");

+ break;

+ default:

+ break;

+ }

+ }

+ CORBA_free (list);

+ }

+

+ if (needs_windows_raised)

+ {

+ Accessibility_LoginHelper_WindowList *windows

+ = Accessibility_LoginHelper_getRaiseWindows

+ (helper, &ev);

+

+ if (BONOBO_EX (&ev))

+ {

+ g_warning ("getRaiseWindows failed: %s",

+ bonobo_exception_get_text (&ev));

+ CORBA_exception_free (&ev);

+ }

+

+ g_debug ("%d windows need raising", windows->_length);

+ for (j = 0; j < windows->_length; j++)

+ {

+ Window wid = windows->_buffer[j].winID;

+ g_debug ("Window ID = 0x%lx", wid);

+ if (wid)

+ write_windowid ("raise_win", wid);

+ }

+ }

+ }

+ else

+ {

+ g_warning ("LoginHelper %d did not go into safe mode", i);

+ }

+ }

+ else

+ {

+ if (BONOBO_EX (&ev))

+ {

+ g_warning ("Error activating %s: %s",

+ info.iid, bonobo_exception_get_text (&ev));

+ CORBA_exception_free (&ev);

+ }

+ else

+ {

+ g_warning ("no active instance of %s found", info.iid);

+ }

+ }

+ }

+ } /* accessibility helpers active */

+

+ /* Flush dialog window ids & any messages about login helpers to parent */

+ write_to_parent(NULL, NULL, TRUE);

+

+ gtk_widget_grab_focus (pwd->user_input_entry);

+

+ ioc = g_io_channel_unix_new (0);

+ g_io_add_watch (ioc, G_IO_IN | G_IO_HUP, handle_input, pwd);

+

+ gtk_main ();

+

+ /* Reset accessibility helpers back to non-safe mode now that we're done */

+ if (server_list)

+ {

+ for (i = 0; i < server_list->_length; i++)

+ {

+ helper = helper_list[i];

+ /* really no need to check the return value this time */

+ Accessibility_LoginHelper_setSafe (helper, FALSE, &ev);

+ if (BONOBO_EX (&ev))

+ {

+ g_warning ("setSafe(FALSE) failed: %s",

+ bonobo_exception_get_text (&ev));

+ CORBA_exception_free (&ev);

+ }

+ CORBA_Object_release (helper, &ev);

+ }

+ CORBA_free (server_list);

+ bonobo_debug_shutdown ();

+ }

+

+ return 0;

+}

+#endif /* HAVE_GTK2 */

+

diff --git xscreensaver-5.12/driver/lock.c xscreensaver-5.12/driver/lock.c

--- xscreensaver-5.12/driver/lock.c

+++ xscreensaver-5.12/driver/lock.c

@@ -21,8 +21,13 @@

#include <X11/Intrinsic.h>

#include <X11/cursorfont.h>

#include <X11/Xos.h> /* for time() */

+#include <X11/Xatom.h>

#include <time.h>

#include <sys/time.h>

+#include <errno.h>

+#include <gconf/gconf-client.h>

+#include "exec.h"

+#include "dialog-data.h"

#include "xscreensaver.h"

#include "resources.h"

#include "mlstring.h"

@@ -83,114 +88,631 @@ vms_passwd_valid_p(char *pw, Bool verbose_p)

typedef struct info_dialog_data info_dialog_data;

-struct passwd_dialog_data {

-

- saver_screen_info *prompt_screen;

- int previous_mouse_x, previous_mouse_y;

-

- char typed_passwd [80];

- XtIntervalId timer;

- int i_beam;

-

- float ratio;

- Position x, y;

- Dimension width;

- Dimension height;

- Dimension border_width;

-

- Bool echo_input;

- Bool show_stars_p; /* "I regret that I have but one asterisk for my country."

-

- char *heading_label;

- char *body_label;

- char *user_label;

- mlstring *info_label;

- /* The entry field shall only be displayed if prompt_label is not NULL */

- mlstring *prompt_label;

- char *date_label;

- char *passwd_string;

- Bool passwd_changed_p; /* Whether the user entry field needs redrawing */

- Bool caps_p; /* Whether we saw a keypress with caps-lock on */

- char *unlock_label;

- char *login_label;

- char *uname_label;

-

- Bool show_uname_p;

-

- XFontStruct *heading_font;

- XFontStruct *body_font;

- XFontStruct *label_font;

- XFontStruct *passwd_font;

- XFontStruct *date_font;

- XFontStruct *button_font;

- XFontStruct *uname_font;

-

- Pixel foreground;

- Pixel background;

- Pixel passwd_foreground;

- Pixel passwd_background;

- Pixel thermo_foreground;

- Pixel thermo_background;

- Pixel shadow_top;

- Pixel shadow_bottom;

- Pixel button_foreground;

- Pixel button_background;

-

- Dimension preferred_logo_width, logo_width;

- Dimension preferred_logo_height, logo_height;

- Dimension thermo_width;

- Dimension internal_border;

- Dimension shadow_width;

-

- Dimension passwd_field_x, passwd_field_y;

- Dimension passwd_field_width, passwd_field_height;

-

- Dimension unlock_button_x, unlock_button_y;

- Dimension unlock_button_width, unlock_button_height;

-

- Dimension login_button_x, login_button_y;

- Dimension login_button_width, login_button_height;

-

- Dimension thermo_field_x, thermo_field_y;

- Dimension thermo_field_height;

-

- Pixmap logo_pixmap;

- Pixmap logo_clipmask;

- int logo_npixels;

- unsigned long *logo_pixels;

-

- Cursor passwd_cursor;

- Bool unlock_button_down_p;

- Bool login_button_down_p;

- Bool login_button_p;

- Bool login_button_enabled_p;

- Bool button_state_changed_p; /* Refers to both buttons */

-

- Pixmap save_under;

- Pixmap user_entry_pixmap;

-};

+/* struct passwd_dialog_data moved to dialog-data.h */

+#ifndef HAVE_XSCREENSAVER_LOCK

static void draw_passwd_window (saver_info *si);

+#endif

static void update_passwd_window (saver_info *si, const char *printed_passwd,

float ratio);

static void destroy_passwd_window (saver_info *si);

+static int ignore_all_errors_ehandler (Display *dpy, XErrorEvent *error);

static void undo_vp_motion (saver_info *si);

+#ifndef HAVE_XSCREENSAVER_LOCK

static void finished_typing_passwd (saver_info *si, passwd_dialog_data *pw);

+#endif

static void cleanup_passwd_window (saver_info *si);

static void restore_background (saver_info *si);

extern void xss_authenticate(saver_info *si, Bool verbose_p);

+#ifdef HAVE_XSCREENSAVER_LOCK

+

+#define WIN_ALLOC_INCREMENT 8 /* allocate entries in the window lists in

+#define EXTRA_RAISE_WIN_SLOTS 4 /* Need to leave four extra slots free in

+

+extern Atom XA_UNLOCK_RATIO;

+

+Bool g_passwd_dialog_created = 0;

+

+GConfClient *client = NULL;

+

+static const char *switch_windows_gconf_key

+ = "/apps/metacity/global_keybindings/switch_windows";

+static char *global_switch_key = NULL;

+

+static const char *main_menu_gconf_key

+ = "/apps/metacity/global_keybindings/panel_main_menu";

+static char *global_menu_key = NULL;

+

+extern Bool safe_XDestroyWindow (Display *dpy, Window window);

+static Bool safe_XRestackWindows(Display *dpy, Window windows[], int nwindows);

+static Bool safe_XSendEvent(Display *dpy, Window w, Bool propagate,

+ long event_mask, XEvent *event_send);

+static void passwd_animate_timer (XtPointer closure, XtIntervalId *id);

+extern void swallow_unlock_typeahead_events (saver_info *si, XEvent *e);

+

+

+static saver_screen_info *

+find_screen_for_window (saver_info *si, Window wid)

+{

+ saver_screen_info *ssi;

+ Screen *screen;

+ Window root, root_ret, parent_ret, *children = NULL;

+ unsigned int nchildren = 0;

+ int screen_no, status;

+

+ status = XQueryTree (si->dpy, wid, &root_ret, &parent_ret,

+ &children, &nchildren);

+

+ if (status == 0) /* failed */

+ return NULL;

+

+ XFree(children);

+ children = NULL;

+

+ for (screen_no = 0; screen_no < si->nscreens; screen_no++)

+ {

+ ssi = &si->screens[screen_no];

+ screen = ssi->screen;

+ root = RootWindowOfScreen (screen);

+

+ if (root == root_ret)

+ return ssi;

+ }

+

+ return NULL; /* Didn't match the root on any screen we know of - PUNT! */

+}

+

+/*

+

+static Window

+check_raisedWid (saver_info *si, Window wid)

+{

+ saver_screen_info *ssi;

+ Screen *screen;

+ Window root, root_ret, parent_ret, *children = NULL;

+ unsigned int nchildren = 0;

+ int screen_no, status;

+

+ status = XQueryTree (si->dpy, wid, &root_ret, &parent_ret,

+ &children, &nchildren);

+

+ if (status == 0) /* failed */

+ return 0;

+

+ XFree(children);

+ children = NULL;

+

+ for (screen_no = 0; screen_no < si->nscreens; screen_no++)

+ {

+ ssi = &si->screens[screen_no];

+ screen = ssi->screen;

+ root = RootWindowOfScreen (screen);

+

+ if (root == root_ret)

+ break;

+ }

+

+ if ( screen_no >= si->nscreens ) /* Didn't match the root on any screen */

+ return 0; /* we know of - PUNT! */

+

+ /* Climb the tree until we find an ancestor that's a child of root */

+ while ( root_ret != parent_ret )

+ {

+ wid = parent_ret;

+

+ status = XQueryTree (si->dpy, wid, &root_ret, &parent_ret,

+ &children, &nchildren);

+

+ if (status == 0) /* failed */

+ return 0;

+

+ XFree(children);

+ children = NULL;

+ }

+

+ if ( ssi != si->pw_data->prompt_screen )

+ {

+ /* found in other screen (not the one with the unlock dialog),

+ Window screen_win[2] = { wid, ssi->screensaver_window };

+ safe_XRestackWindows(si->dpy, screen_win, 2);

+ return 0; /* no need to do the restack on prompt screen */

+ }

+

+ return wid;

+}

+

+/* Enforce window stacking order when a new window arrives.

+static void

+restack_my_windows (saver_info* si, saver_screen_info *ssi, Window newWin)

+{

+ int n = 0;

+ Window short_stack[EXTRA_RAISE_WIN_SLOTS];

+ Window *restack_list;

+ Bool allowed = False;

+

+ /* If window is on another screen than the unlock dialog,

+ if ((si->raise_wins == NULL) || (ssi != si->pw_data->prompt_screen))

+ {

+ restack_list = short_stack;

+ }

+ else

+ {

+ restack_list = si->raise_wins;

+ for (n = 0; n < si->num_raise_wins; n++)

+ {

+ if (si->raise_wins[n] == newWin)

+ allowed = True;

+ }

+ }

+

+ if (si->passwd_dialog && (ssi == si->pw_data->prompt_screen))

+ {

+ restack_list[n++] = si->passwd_dialog;

+ if (si->passwd_dialog == newWin)

+ allowed = True;

+ }

+

+ if (ssi->stderr_overlay_window)

+ {

+ restack_list[n++] = ssi->stderr_overlay_window;

+ if (ssi->stderr_overlay_window == newWin)

+ allowed = True;

+ }

+

+ if (ssi->screensaver_window)

+ {

+ restack_list[n++] = ssi->screensaver_window;

+ if (ssi->screensaver_window == newWin)

+ allowed = True;

+ }

+

+ /* If it's not in the allowed list, it goes behind

+ if (newWin && !allowed)

+ restack_list[n++] = newWin;

+

+ if (n > 1)

+ safe_XRestackWindows (si->dpy, restack_list, n);

+}

+

+/* Send a command to the xscreensaver-lock child process

+int

+write_to_child (saver_info* si, const char* msg, const char *data)

+{

+ if (msg == NULL)

+ {

+ fprintf (stderr, "Invalid null message written to child\n");

+ return -1;

+ }

+

+ if (si->external_passwd && g_passwd_dialog_created &&

+ si->pw_data->stdin_fd != -1)

+ {

+ int len;

+

+ if (si->prefs.verbose_p)

+ {

+ fprintf (stderr,

+ "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n"

+ "HAVE_SCRSVR_LOCK writing to fd:%d message is:\n%s=%s\n"

+ "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n",

+ si->pw_data->stdin_fd, msg, data ? data : "(null)");

+ }

+

+ if (data)

+ len = fprintf (si->pw_data->stdin_file, "%s=%s\n", msg, data);

+ else

+ len = fprintf (si->pw_data->stdin_file, "%s\n", msg);

+

+ fflush (si->pw_data->stdin_file);

+ return len;

+ }

+

+ return (0); /* if we didn't write anything return 0 */

+}

+

+static int

+sane_dup2 (int fd1, int fd2)

+{

+ int ret;

+

+ do

+ {

+ ret = dup2 (fd1, fd2);

+ }

+ while (ret < 0 && errno == EINTR);

+

+ return ret;

+}

+

+static int

+close_and_invalidate (int *fd)

+{

+ int ret;

+

+ ret = close (*fd);

+ *fd = -1;

+

+ return ret;

+}

+

+void

+handle_passwd_input (XtPointer xtdata, int *fd, XtInputId *id)

+{

+ saver_info *si = (saver_info *)xtdata;

+ saver_preferences *p = &si->prefs;

+ char buffer[1024];

+ char *msg, *data;

+ passwd_dialog_data *pw = si->pw_data;

+

+ if (p->verbose_p)

+ fprintf (stderr, "passwd input handler() fd=%d\n", *fd);

+

+ msg = fgets (buffer, sizeof (buffer), pw->stdout_file);

+ if (!msg) /* child closed pipe */

+ {

+ if (p->verbose_p)

+ {

+ fprintf (stderr, "done reading...\n");

+ fprintf (stderr, "removing input handler...\n");

+ }

+ XtRemoveInput (*id);

+ pw->stdout_input_id = 0;

+

+ if (p->verbose_p)

+ fprintf (stderr, "passwd input handler() returning...done reading\n");

+

+ return;

+ }

+

+ if (p->verbose_p)

+ fprintf (stderr, "Child sent message: %s\n", msg);

+

+ /* search for =, and if found, split msg & data into two strings there */

+ data = strchr(msg, '=');

+ if (data)

+ {

+ char *nl;

+

+ *data++ = 0;

+

+ /* strip trailing newline */

+ nl = strchr (data, '\n');

+ if (nl)

+ *nl = '\0';

+ }

+ else

+ {

+ /* All the messages we currently expect require data! */

+ if (p->verbose_p)

+ fprintf (stderr, "*** Invalid message: no data found, discarding\n");

+

+ return;

+ }

+

+ if ((strcmp(msg, "input") == 0)) /* User input */

+ {

+ si->unlock_state = ul_finished;

+ pw->got_passwd = TRUE;

+ pw->passwd_string = strdup (data);

+ memset (data, 0, strlen(data));

+ }

+ else if ((strcmp(msg, "ungrab_keyboard") == 0))

+ {

+ /* An accessibility helper needs to access the keyboard, so we have

+

+ if (client == NULL)

+ client = gconf_client_get_default();

+

+ if (global_switch_key == NULL)

+ {

+ global_switch_key =

+ gconf_client_get_string (client, switch_windows_gconf_key, NULL);

+

+ if (global_switch_key && strncmp (global_switch_key, "dis", 3))

+ gconf_client_set_string (client, switch_windows_gconf_key,

+ "disabled", NULL);

+ }

+

+ if (global_menu_key == NULL)

+ {

+ global_menu_key =

+ gconf_client_get_string (client, main_menu_gconf_key, NULL);

+

+ if (global_menu_key && strncmp(global_menu_key, "dis", 3))

+ gconf_client_set_string (client, main_menu_gconf_key,

+ "disabled", NULL);

+ }

+

+ XUngrabKeyboard (si->dpy, CurrentTime);

+ XFlush (si->dpy);

+ }

+ else if ((strcmp(msg, "ungrab_pointer") == 0))

+ {

+ /* An accessibility helper needs to access the mouse, so we have

+

+ XUngrabPointer (si->dpy, CurrentTime);

+ XFlush (si->dpy);

+ }

+ else /* Get a window id of an interesting window from the child */

+ {

+ Window window = strtoul (data, NULL, 0);

+ int status;

+

+ if ((strcmp (msg, "dialog_win") == 0))

+ {

+ /* The unlock dialog itself */

+ si->passwd_dialog = window;

+ pw->got_windowid = True;

+

+ move_mouse_grab (si, si->passwd_dialog, pw->passwd_cursor,

+ pw->prompt_screen->number);

+ undo_vp_motion (si);

+ passwd_animate_timer ((XtPointer) si, 0);

+

+ /* Flush queue of captured typeahead events */

+ if (si->typeahead_events && si->num_typeahead_events)

+ {

+ int i;

+

+ for (i = 0; i < si->num_typeahead_events; i++)

+ {

+ si->typeahead_events[i].window = window;

+ safe_XSendEvent (si->dpy, window, False, KeyPressMask,

+ (XEvent *) &si->typeahead_events[i]);

+ }

+ si->num_typeahead_events = 0;

+ }

+ XGrabKeyboard (si->dpy, window, True, GrabModeAsync, GrabModeAsync, CurrentTime);

+ XGrabPointer (si->dpy, window, True, 0, GrabModeAsync, GrabModeAsync, None, None, CurrentTime);

+ XFlush (si->dpy);

+ XSetInputFocus (si->dpy, window, RevertToPointerRoot, CurrentTime);

+ XSync (si->dpy, False);

+ }

+ else if ((strcmp (msg, "raise_win") == 0))

+ {

+ /* Accessibility helpers that need to be raised above the

+ Window *newlist;

+ Window overwin;

+

+ if ( (si->num_raise_wins + EXTRA_RAISE_WIN_SLOTS)

+ >= si->max_raise_wins)

+ {

+ int raise_alloc = si->max_raise_wins + WIN_ALLOC_INCREMENT;

+

+ newlist = realloc(si->raise_wins, raise_alloc * sizeof(Window));

+ if (newlist == NULL)

+ return;

+

+ si->raise_wins = newlist;

+ si->max_raise_wins = raise_alloc;

+ }

+

+ overwin = check_raisedWid (si, window);

+ if (overwin)

+ {

+ XWindowAttributes attrs;

+ status = XGetWindowAttributes (si->dpy, overwin, &attrs);

+

+ if ( status && !attrs.override_redirect )

+ {

+ unsigned long valuemask = CWOverrideRedirect;

+ XSetWindowAttributes setwinattr;

+ setwinattr.override_redirect = True;

+

+ XChangeWindowAttributes (si->dpy, overwin,

+ valuemask, &setwinattr);

+

+ if (si->num_override_wins >= si->max_override_wins)

+ {

+ int over_alloc

+ = si->max_override_wins + WIN_ALLOC_INCREMENT;

+

+ newlist = realloc(si->override_wins,

+ over_alloc * sizeof(Window));

+ if (newlist == NULL)

+ return;

+

+ si->override_wins = newlist;

+ si->max_override_wins = over_alloc;

+ }

+

+ si->override_wins[si->num_override_wins++] = overwin;

+ }

+ XMapSubwindows(si->dpy, overwin);

+ si->raise_wins[si->num_raise_wins++] = overwin;

+ }

+ else

+ si->raise_wins[si->num_raise_wins++] = window;

+ } /* "raise_win" */

+

+ restack_my_windows(si, si->pw_data->prompt_screen, 0);

+ }

+}

+

+/* returns successful fork/exec */

+Bool

+spawn_external_passwd_process (saver_info *si, passwd_dialog_data *pw)

+{

+ saver_preferences *p = &si->prefs;

+ pid_t forked;

+ const char *command = LOCKDIR "/xscreensaver-lock";

+ int stdin_pipe[2] = { -1, -1 };

+ int stdout_pipe[2] = { -1, -1 };

+

+ si->passwd_pid = 0;

+ pw->stdin_fd = pw->stdout_fd = -1;

+ pw->got_windowid = False;

+

+ if (si->prefs.verbose_p)

+ fprintf(stderr, "-->spawn_external_passwd()\n");

+

+ if (si->passwd_pid > 0)

+ {

+ if (si->prefs.verbose_p)

+ fprintf (stderr,"pid %ld still exists. Killing it with SIGKILL\n",

+ si->passwd_pid);

+ kill_job (si, si->passwd_pid, SIGKILL);

+ }

+ si->passwd_pid = 0;

+

+ if (pipe (stdin_pipe) < 0)

+ {

+ perror ("pipe(stdin_pipe) failed!");

+ return False;

+ }

+

+ if (pipe (stdout_pipe) < 0)

+ {

+ perror ("pipe(stdout_pipe) failed!");

+ close_and_invalidate (&stdin_pipe[0]);

+ close_and_invalidate (&stdin_pipe[1]);

+ return False;

+ }

+ switch ((int) (forked = fork ()))

+ {

+ case -1:

+ fprintf (stderr, "%s: ", blurb ());

+ perror ("couldn't fork");

+

+ close_and_invalidate (&stdin_pipe[0]);

+ close_and_invalidate (&stdin_pipe[1]);

+ close_and_invalidate (&stdout_pipe[0]);

+ close_and_invalidate (&stdout_pipe[1]);

+

+ return False;

+

+ case 0:

+ close (ConnectionNumber (si->dpy)); /* close display fd */

+ /* limit_subproc_memory (p->inferior_memory_limit, p->verbose_p); */

+ /* hack_subproc_environment (ssi); */ /* FIX $DISPLAY */

+

+ /* Inside Child Process */

+ if (p->verbose_p)

+ fprintf (stderr, "%s: spawning \"%s\" in pid %lu.\n",

+ blurb(), command, (unsigned long) getpid ());

+

+ close_and_invalidate (&stdin_pipe[1]);

+ close_and_invalidate (&stdout_pipe[0]);

+

+ sane_dup2 (stdin_pipe[0], 0); /* Listen to Parent from here */

+ sane_dup2 (stdout_pipe[1], 9); /* Talk to Parent from here */

+

+ /* Make sure we have relinquished setuid privs or lock dialog gtk

+ hack_uid (si);

+

+ exec_command (p->shell, command, 0);

+ /* print_path_error (command); */

+ fprintf (stderr, "%s: couldn't exec: %s\n",

+ blurb (), command);

+ abort ();

+

+ default:

+ /* In Parent */

+ make_job(forked, 0, command);

+ close_and_invalidate (&stdin_pipe[0]);

+ close_and_invalidate (&stdout_pipe[1]);

+

+ sane_dup2 (stdin_pipe[0], 0); /* Listen to Child from here */

+ sane_dup2 (stdout_pipe[1], 13); /* Talk to Child from here */

+

+ pw->stdin_fd = stdin_pipe[1]; /* Talk to child from here */

+ pw->stdout_fd = stdout_pipe[0]; /* Listen to Child from here */

+ si->passwd_pid = forked;

+

+ /* Messages to child dialog are sent through this pipe/fd */

+ pw->stdin_file = fdopen (pw->stdin_fd, "w");

+ write_to_child (si, "Hello", NULL); /* Send a test message to Child */

+

+ /* Password from child dialog comes through this pipe/fd */

+ pw->stdout_file = fdopen (pw->stdout_fd, "r");

+

+ pw->stdout_input_id = XtAppAddInput (si->app, pw->stdout_fd,

+ (XtPointer) XtInputReadMask,

+ handle_passwd_input, si);

+

+ /* Set global flag to indicate that lock dialog is visible */

+ g_passwd_dialog_created = True;

+ return True;

+ }

+

+ /* shouldn't reach */

+ abort ();

+ return False;

+}

+#endif /* HAVE_XSCREENSAVER_LOCK */

+

static int

new_passwd_window (saver_info *si)

{

passwd_dialog_data *pw;

+#ifndef HAVE_XSCREENSAVER_LOCK

Screen *screen;

Colormap cmap;

char *f;

+#endif

saver_screen_info *ssi = &si->screens [mouse_screen (si)];

+#ifdef HAVE_XSCREENSAVER_LOCK

+ /* si->pw_data is globally allocated and never freed when HAVE_XSS_LOCK */

+ pw = si->pw_data;

+ if (!spawn_external_passwd_process (si, pw))

+ return -1;

+ si->external_passwd = True;

+#else

pw = (passwd_dialog_data *) calloc (1, sizeof(*pw));

if (!pw)

return -1;

@@ -199,17 +716,21 @@ new_passwd_window (saver_info *si)

*/

pw->login_button_p = (si->prefs.new_login_command &&

*si->prefs.new_login_command);

+#endif

pw->passwd_cursor = XCreateFontCursor (si->dpy, XC_top_left_arrow);

pw->prompt_screen = ssi;

+#ifndef HAVE_XSCREENSAVER_LOCK

screen = pw->prompt_screen->screen;

cmap = DefaultColormapOfScreen (screen);

+#endif

pw->show_stars_p = get_boolean_resource(si->dpy, "passwd.asterisks",

"Boolean");

+#ifndef HAVE_XSCREENSAVER_LOCK

pw->heading_label = get_string_resource (si->dpy, "passwd.heading.label",

"Dialog.Label.Label");

pw->body_label = get_string_resource (si->dpy, "passwd.body.label",

@@ -358,6 +879,7 @@ new_passwd_window (saver_info *si)

if (pw->shadow_width == 0) pw->shadow_width = 4;

if (pw->thermo_width == 0) pw->thermo_width = pw->shadow_width;

+#endif /* ! HAVE_XSCREENSAVER_LOCK */

/* We need to remember the mouse position and restore it afterward, or

return -1;

+#ifdef HAVE_XSCREENSAVER_LOCK

+ /* si->pw_data is globally allocated and never freed when HAVE_XSS_LOCK */

+ if (!si->pw_data->got_windowid)

+#else

if (!si->pw_data)

+#endif

if (new_passwd_window (si) < 0)

return -1;

@@ -450,6 +981,29 @@ make_passwd_window (saver_info *si,

blurb(), pw->prompt_screen->number,

info_msg ? info_msg : "");

+#ifdef HAVE_XSCREENSAVER_LOCK

+ /* Wipe the old password, so we get prompted to enter new password. */

+ if (pw->passwd_string)

+ {

+ memset(pw->passwd_string, 0, strlen (pw->passwd_string));

+ free (pw->passwd_string);

+ pw->passwd_string = NULL;

+ }

+

+ if (info_msg)

+ write_to_child (si, "ul_message", info_msg);

+ if (prompt)

+ {

+ write_to_child (si, "ul_pamprompt", prompt);

+

+ if (echo)

+ write_to_child (si, "ul_prompt_echo", "true");

+ else if (pw->show_stars_p)

+ write_to_child (si, "ul_prompt_echo", "stars");

+ else

+ write_to_child (si, "ul_prompt_echo", "false");

+ }

+#else

screen = pw->prompt_screen->screen;

cmap = DefaultColormapOfScreen (screen);

@@ -687,11 +1241,13 @@ make_passwd_window (saver_info *si,

if (cmap)

XInstallColormap (si->dpy, cmap);

draw_passwd_window (si);

+#endif /* ! HAVE_XSCREENSAVER_LOCK */

return 0;

}

+#ifndef HAVE_XSCREENSAVER_LOCK

static void

draw_passwd_window (saver_info *si)

{

@@ -1035,17 +1591,48 @@ draw_button(Display *dpy,

draw_shaded_rectangle(dpy, dialog, x, y, width, height,

shadow_width, shadow_light, shadow_dark);

}

+#endif /* !HAVE_XSCREENSAVER_LOCK */

static void

update_passwd_window (saver_info *si, const char *printed_passwd, float ratio)

{

passwd_dialog_data *pw = si->pw_data;

+#ifndef HAVE_XSCREENSAVER_LOCK

XGCValues gcv;

GC gc1, gc2;

int x, y;

XRectangle rects[1];

+#endif

pw->ratio = ratio;

+

+#ifdef HAVE_XSCREENSAVER_LOCK

+ /* Send countdown timer ratio to child lock dialog */

+ if (si->passwd_dialog)

+ {

+ XEvent event;

+

+ event.xany.type = ClientMessage;

+ event.xclient.display = si->dpy;

+ event.xclient.window = si->passwd_dialog;

+ event.xclient.message_type = XA_UNLOCK_RATIO;

+ event.xclient.format = 32;

+ memset (&event.xclient.data, 0, sizeof (event.xclient.data));

+ event.xclient.data.l[0] = (long)(pw->ratio * 100);

+ event.xclient.data.l[1] = 0;

+ event.xclient.data.l[2] = 0;

+

+ if (!safe_XSendEvent (si->dpy, si->passwd_dialog, False, 0L, &event))

+ fprintf (stderr, "%s: error sending ratio to lock dialog\n", blurb ());

+ }

+ else

+ {

+ if (si->prefs.verbose_p)

+ fprintf (stderr,

+ "-->update_passwd_window() lockdialog not created, returning!!\n");

+ return;

+ }

+#else

gcv.foreground = pw->passwd_foreground;

gcv.font = pw->passwd_font->fid;

gc1 = XCreateGC (si->dpy, si->passwd_dialog, GCForeground|GCFont, &gcv);

@@ -1187,6 +1774,7 @@ update_passwd_window (saver_info *si, const char *printed_passwd, float ratio)

XFreeGC (si->dpy, gc1);

XFreeGC (si->dpy, gc2);

XSync (si->dpy, False);

+#endif /* !HAVE_XSCREENSAVER_LOCK */

}

@@ -1218,6 +1806,9 @@ cleanup_passwd_window (saver_info *si)

{

passwd_dialog_data *pw;

+ if (si->prefs.verbose_p)

+ fprintf (stderr, "cleanup_passwd_window\n");

+

if (!(pw = si->pw_data))

return;

@@ -1234,7 +1825,12 @@ cleanup_passwd_window (saver_info *si)

}

memset (pw->typed_passwd, 0, sizeof(pw->typed_passwd));

- memset (pw->passwd_string, 0, strlen(pw->passwd_string));

+ if (pw->passwd_string)

+ {

+ memset (pw->passwd_string, 0, strlen(pw->passwd_string));

+ free (pw->passwd_string);

+ pw->passwd_string = NULL;

+ }

if (pw->timer)

{

@@ -1257,8 +1853,10 @@ destroy_passwd_window (saver_info *si)

passwd_dialog_data *pw = si->pw_data;

saver_screen_info *ssi = pw->prompt_screen;

Colormap cmap = DefaultColormapOfScreen (ssi->screen);

+#ifndef HAVE_XSCREENSAVER_LOCK

Pixel black = BlackPixelOfScreen (ssi->screen);

Pixel white = WhitePixelOfScreen (ssi->screen);

+#endif

XEvent event;

cleanup_passwd_window (si);

@@ -1274,6 +1872,81 @@ destroy_passwd_window (saver_info *si)

si->cached_passwd = NULL;

}

+#ifdef HAVE_XSCREENSAVER_LOCK

+ /* reset global flag to indicate passwd dialog is no longer there */

+ g_passwd_dialog_created = False;

+

+ if (si->external_passwd)

+ {

+ /* kill the child etc. */

+ write_to_child (si, "cmd_exit", NULL);

+

+ if (pw->stdin_file)

+ fclose (pw->stdin_file);

+ if (pw->stdin_fd != -1)

+ close_and_invalidate (&pw->stdin_fd);

+ if (pw->stdout_input_id)

+ XtRemoveInput (pw->stdout_input_id);

+ if (pw->stdout_file)

+ fclose (pw->stdout_file);

+ else if (pw->stdout_fd != -1)

+ close_and_invalidate (&pw->stdout_fd);

+

+ if (si->passwd_pid)

+ {

+ kill_job (si, si->passwd_pid, SIGTERM);

+ si->passwd_pid = 0;

+ }

+

+ free (si->raise_wins);

+ si->raise_wins = NULL;

+ si->num_raise_wins = 0;

+ si->max_raise_wins = 0;

+

+ if (si->override_wins)

+ {

+ int n;

+

+ unsigned long valuemask = CWOverrideRedirect;

+ XSetWindowAttributes setwinattr;

+ setwinattr.override_redirect = False;

+

+ for (n = 0; n < si->num_override_wins; n++)

+ {

+ XChangeWindowAttributes (si->dpy, si->override_wins[n],

+ valuemask, &setwinattr);

+ }

+ free(si->override_wins);

+ si->override_wins = NULL;

+ }

+ si->num_override_wins = 0;

+ si->max_override_wins = 0;

+

+ si->pw_data->got_windowid = False;

+ si->external_passwd = False;

+

+ /* restore any metacity keys we temporarily disabled */

+ if (client)

+ {

+ if (global_switch_key)

+ {

+ gconf_client_set_string (client, switch_windows_gconf_key,

+ global_switch_key, NULL);

+ g_free(global_switch_key);

+ global_switch_key = NULL;

+ }

+

+ if (global_menu_key)

+ {

+ gconf_client_set_string (client, main_menu_gconf_key,

+ global_menu_key, NULL);

+ g_free(global_menu_key);

+ global_menu_key = NULL;

+ }

+ }

+ }

+#endif /* HAVE_XSCREENSAVER_LOCK */

+

move_mouse_grab (si, RootWindowOfScreen (ssi->screen),

ssi->cursor, ssi->number);

@@ -1308,7 +1981,14 @@ destroy_passwd_window (saver_info *si)

fprintf (stderr, "%s: %d: destroying password dialog.\n",

blurb(), pw->prompt_screen->number);

+#ifdef HAVE_XSCREENSAVER_LOCK

+ /* Ignore X error if window was already closed by the child,

+ safe_XDestroyWindow (si->dpy, si->passwd_dialog);

+#else

XDestroyWindow (si->dpy, si->passwd_dialog);

+#endif

si->passwd_dialog = 0;

}

@@ -1319,6 +1999,7 @@ destroy_passwd_window (saver_info *si)

pw->save_under = 0;

}

+#ifndef HAVE_XSCREENSAVER_LOCK

if (pw->heading_label) free (pw->heading_label);

if (pw->body_label) free (pw->body_label);

if (pw->user_label) free (pw->user_label);

@@ -1369,6 +2050,7 @@ destroy_passwd_window (saver_info *si)

pw->logo_pixels = 0;

pw->logo_npixels = 0;

}

+#endif /* ! HAVE_XSCREENSAVER_LOCK */

if (pw->save_under)

XFreePixmap (si->dpy, pw->save_under);

@@ -1376,9 +2058,12 @@ destroy_passwd_window (saver_info *si)

if (cmap)

XInstallColormap (si->dpy, cmap);

+#ifndef HAVE_XSCREENSAVER_LOCK

+ /* si->pw_data is globally allocated and never freed when HAVE_XSS_LOCK */

memset (pw, 0, sizeof(*pw));

free (pw);

si->pw_data = 0;

+#endif

}

@@ -1391,6 +2076,49 @@ ignore_all_errors_ehandler (Display *dpy, XErrorEvent *error)

return 0;

}

+#ifdef HAVE_XSCREENSAVER_LOCK

+/* Catch errors from XRestackWindows, since there's an inherent race

+static Bool

+safe_XRestackWindows(Display *dpy, Window windows[], int nwindows)

+{

+ XErrorHandler old_handler;

+ XSync (dpy, False);

+ error_handler_hit_p = False;

+ old_handler = XSetErrorHandler (ignore_all_errors_ehandler);

+

+ XRestackWindows (dpy, windows, nwindows);

+

+ XSync (dpy, False);

+ XSetErrorHandler (old_handler);

+ XSync (dpy, False);

+

+ return (!error_handler_hit_p);

+}

+

+static Bool

+safe_XSendEvent(Display *dpy, Window w, Bool propagate,

+ long event_mask, XEvent *event_send)

+{

+ Status status;

+ XErrorHandler old_handler;

+ XSync (dpy, False);

+ error_handler_hit_p = False;

+ old_handler = XSetErrorHandler (ignore_all_errors_ehandler);

+

+ status = XSendEvent (dpy, w, propagate, event_mask, event_send);

+

+ XSync (dpy, False);

+ XSetErrorHandler (old_handler);

+ XSync (dpy, False);

+

+ return (!error_handler_hit_p && status);

+}

+

+#endif

+

#ifdef HAVE_XHPDISABLERESET

/* This function enables and disables the C-Sh-Reset hot-key, which

+ if (!si->passwd_dialog)

+ {

+ if (si->prefs.verbose_p)

+ fprintf (stderr,

+ "-->passwd_animate_timer() returning..no dialog yet\n");

+ return;

+ }

+#endif

+

pw->ratio -= (1.0 / ((double) si->prefs.passwd_timeout / (double) tick));

if (pw->ratio < 0)

{

@@ -1611,6 +2350,7 @@ passwd_animate_timer (XtPointer closure, XtIntervalId *id)

idle_timer ((XtPointer) si, 0);

}

+#ifndef HAVE_XSCREENSAVER_LOCK

static XComposeStatus *compose_status;

@@ -1688,11 +2428,13 @@ finished_typing_passwd (saver_info *si, passwd_dialog_data *pw)

update_passwd_window (si, "", pw->ratio);

}

}

+#endif /* !HAVE_XSCREENSAVER_LOCK */

static void

handle_passwd_key (saver_info *si, XKeyEvent *event)

{

passwd_dialog_data *pw = si->pw_data;

+#ifndef HAVE_XSCREENSAVER_LOCK

int pw_size = sizeof (pw->typed_passwd) - 1;

char *typed_passwd = pw->typed_passwd;

char s[2];

@@ -1705,11 +2447,41 @@ handle_passwd_key (saver_info *si, XKeyEvent *event)

s[1] = 0;

pw->passwd_changed_p = True;

+#endif /* !HAVE_XSCREENSAVER_LOCK */

/* Add 10% to the time remaining every time a key is pressed. */

pw->ratio += 0.1;

if (pw->ratio > 1) pw->ratio = 1;

+#ifdef HAVE_XSCREENSAVER_LOCK

+ if (si->pw_data->got_windowid)

+ {

+ Bool status;

+

+ if (si->prefs.verbose_p)

+ fprintf (stderr, "event loop..gotwindowid..and keypress event...\n");

+

+ event->window = si->passwd_dialog;

+

+ status = safe_XSendEvent (si->dpy, si->passwd_dialog,

+ False, KeyPressMask, (XEvent *) event);

+

+ if (si->prefs.verbose_p)

+ {

+ if (status)

+ fprintf (stderr, "sent key...\n");

+ else

+ fprintf (stderr, "error %d sending key...\n", status);

+ }

+ update_passwd_window (si, NULL, pw->ratio);

+ }

+ else

+ {

+ swallow_unlock_typeahead_events (si, (XEvent *) event);

+ }

+

+#else /* !HAVE_XSCREENSAVER_LOCK */

+

switch (*s)

{

case '\010': case '\177': /* Backspace */

@@ -1779,6 +2551,7 @@ handle_passwd_key (saver_info *si, XKeyEvent *event)

{

update_passwd_window (si, "", pw->ratio);

}

+#endif /* !HAVE_XSCREENSAVER_LOCK */

}

@@ -1801,7 +2574,9 @@ passwd_event_loop (saver_info *si)

passwd_animate_timer ((XtPointer) si, 0);

- while (si->unlock_state == ul_read)

+ si->pw_data->got_passwd = FALSE;

+

+ while (si->unlock_state == ul_read && si->pw_data->got_passwd == FALSE)

{

XtAppNextEvent (si->app, &event.x_event);

@@ -1842,12 +2617,17 @@ passwd_event_loop (saver_info *si)

if (event.x_event.xany.window == si->passwd_dialog &&

event.x_event.xany.type == Expose)

+#ifdef HAVE_XSCREENSAVER_LOCK

+ XtDispatchEvent (&event.x_event);