Changeset 855

ldm/trunk/fuentes/.pc/applied-patches

-                      r517
+                      r855
 remove-hackish-gettext-function
 lliurex-patches
 ldm_verbose_ssh.patch
 ldm_background.patch
 profiled_thinclients
 other_languages
+lliurex-patches_ported_from_2_2_13
+ldm_verbose_patch_integrated_from_2_2_13
+ldm_background_ported_from_2_2_13
+profiled_thinclients_ported_from_2_2_13
+other_languages_ported_from_2_2_13

ldm/trunk/fuentes/.pc/remove-hackish-gettext-function/share/ldm-script.in

r516	r855
60	60
61	61	for SCRIPT in $(find -L $RCDIRS -type f -name "$SCRIPTS" -printf '%f\n' \|
62		tr ' ' '\n' \| egrep ^[~~0-9a-zA-Z~~_\-]*$ \| sort -u)
	62	tr ' ' '\n' \| egrep ^[[:alnum:]_\-]*$ \| sort -u)
63	63	do
64	64	# only source the first instance of the script found

ldm/trunk/fuentes/ChangeLog

-                      r516
+                      r855
+Vagrant Cascadian 2016-02-07 {ldm-2.2.18}
+      Version 2.2.18
+Alkis Georgopoulos        2016-01-18
+      Display LDM only in the first monitor (LP: #693151).
+Alkis Georgopoulos        2015-12-08
+      DesktopNames replaced X-LightDM-DesktopName in xsession files
+      (GNOME: #727546).
+Alkis Georgopoulos        2015-12-05
+      "break" is not valid inside "case".
+Vagrant Cascadian 2015-10-08 {ldm-2.2.17}
+      Version 2.2.17
+Vagrant Cascadian 2015-10-08
+      screen.d/ldm: Rewrite test for LDM_DIRECTX to avoid using a negated
+      boolean_is_true check.
+Alkis Georgopoulos        2015-10-08
+      Xorg after 1.17 (not 1.16) needs `-listen tcp`.
+Alkis Georgopoulos        2015-10-03
+      Xorg after 1.16 needs `-listen tcp`.
+Alkis Georgopoulos        2015-09-22
+      ldm-script: fix regression from r1579, it needs [:alnum:], not
+      [:alpha:].
+Alkis Georgopoulos        2015-09-02
+      Replace [A-Za-z] with [:alpha:] to avoid locale issues (LP:
+      #1491066).
+Vagrant Cascadian 2015-08-19 {ldm-2.2.16}
+      Version 2.2.16
+Alkis Georgopoulos        2015-05-22
+      Export DESKTOP_SESSION and XDG_CURRENT_DESKTOP to the client
+      environment and try to avoid an empty LDM_SESSION.  These, along
+      with r2646 from ltsp-client, make Unity work for both thin and fat
+      clients in Ubuntu 14.04, and possibly fix other DE issues as well.
+      The /etc/X11/Xsession.d/40-ltsp-{client|server} workarounds were
+      not effective and can now be completely dropped from the Ubuntu
+      packaging.
+Alkis Georgopoulos        2015-05-18
+      Generalize LDM_12HOURCLOCK to LDM_CLOCK_FORMAT.
+Vagrant Cascadian 2015-02-01
+      Remove rc.d hook to set LIBGL_ALWAYS_INDIRECT=true, as it causes
+      problems with several common desktops, and can be enabled
+      on a per-client basis by setting CLIENT_ENV in lts.conf.
+      https://bugs.debian.org/767764
+Vagrant Cascadian 2014-10-21 {ldm-2.2.15}
+      Version 2.2.15
+Vagrant Cascadian 2014-09-23
+      dmrc-processing: Use do_ssh function rather than duplicating the
+      ssh call.
+Vagrant Cascadian 2014-09-23
+      dmrc-processing hook: Compare desktop session against local
+      /usr/share/xsessions/*.desktop when running as a fat client.
+      https://bugs.launchpad.net/ltsp/+bug/1272889
+Vagrant Cascadian 2014-09-23
+      Remove further traces of halt-check hook.
+Vagrant Cascadian 2014-09-23
+      Remove check for halting when SHUTDOWN_TIME is set, implemented
+      in LTSP instead.  https://bugs.launchpad.net/ltsp/+bug/604908
+Jakob Unterwurzacher      2014-09-22
+      ssh: Set ConnectTimeout=10
+      ConnectTimeout should be less than the timeout ssh_chat passes to
+      expect, so we get the error message from ssh before expect gives up
+      (30 seconds).
+      Also slightly increase the log level for spawning ssh to INFO.
+Jakob Unterwurzacher      2014-09-22
+      ssh: Make sure expect() notices if ssh dies after finding a match
+      Before this patch, the error message "ssh: connect to host server
+      port 22: Connection refused" was sometime mistaken as a prompt
+      because it contains a colon.  This caused a 30 second delay.
+Jakob Unterwurzacher      2014-09-22
+      ssh: expect() must handle EINTR
+      Otherwise, we do not capture the error message from ssh reliably as
+      select() may be interrupted by SIGCHLD before we read the message.
+Jakob Unterwurzacher      2014-09-22
+      ssh: Also log the error message from ssh
+Jakob Unterwurzacher      2014-09-22
+      ssh: De-duplicate message handling code
+      Clean-up step for the previous patch.
+Jakob Unterwurzacher      2014-09-22
+      ssh: Display specific error message if available
+      This way, we get a proper "Permission denied" for a wrong password.
+      Horrible code duplication is fixed in the next patch.
+Jakob Unterwurzacher      2014-09-22
+      ssh: Make expect() read all available data even if the child
+      has exited
+      Implemented by checking if the child has exited *after* reading
+      all data. That way, we capture the error message.
+Jakob Unterwurzacher      2014-09-22
+      ssh: Remove superfluous timeout.tv_sec check in expect()
+      Timeout is already handled earlier. Checking for timeout.tv_sec ==
+is a bug as it may be zero under normal circumstances.
+Vagrant Cascadian 2014-09-20
+      rc.d/I01-halt-check: Use poweroff instead of halt.
+Vagrant Cascadian 2014-09-20
+      rc.d/I01-halt-check: Return if SHUTDOWN_TIME is not set.
+Vagrant Cascadian 2014-09-20
+      rc.d/I01-halt-check: Explicitly return 0.
+Vagrant Cascadian 2014-09-11
+      Fix typo: conditionally enable "-nolisten tcp" based on LDM_DIRECTX.
+Vagrant Cascadian 2014-09-10
+      Disable listening on tcp, unless using LDM_DIRECTX. Thanks to
+      Denis Croombs for reporting the issue!
+Vagrant Cascadian 2014-09-10
+      Remove support for running without xinitrc.
+Vagrant Cascadian 2014-08-05 {ldm-2.2.14}
+      version 2.2.14
+ben-Nabiy Derush  2014-07-31
+      Updated according to vagrantc suggestions. Moved tests outside of
+      function, reduced variables, so on...
+ben-Nabiy Derush  2014-07-31
+      Added opt-in ssh_hashpass function
+ben-Nabiy Derush  2014-07-31
+      Added ldm_getenv_bool_default
+ben-Nabiy Derush  2014-07-28
+      Revised README-DEVELOPMENT-POLICY to clarify whitespace changes
+      in existing code needing a separate merge request.
+ben-Nabiy Derush  2014-07-28
+      indent -kr -i4 -nut -c50 -psl
+ben-Nabiy Derush  2014-07-28
+      indent -kr -i4 -nut -c50 -psl
+ben-Nabiy Derush  2014-07-28
+      indent -kr -i4 -nut -c50 -psl
+ben-Nabiy Derush  2014-07-28
+      indent -kr -i4 -nut -c50 -psl
+ben-Nabiy Derush  2014-07-28
+      indent -kr -i4 -nut -c50 -psl
+ben-Nabiy Derush  2014-07-28
+      indent -kr -i4 -nut -c50 -psl
 Vagrant Cascadian 2014-02-22 {ldm-2.2.13}
       version 2.2.13

ldm/trunk/fuentes/README-DEVELOPMENT-POLICY

-                      r516
+                      r855
      - Align inline comments on column 50
      - A newline after function definitions
+ - If you change whitespace or formatting of existing code, please do this in a
+   separate merge proposal. This includes running the above indent command on
+   existing code.
  - All if() else blocks will have {}'s, even if only 1 line long, or Ollie will break your thumbs.
  - Comments will be /* */ or Scott will break the rest of your fingers.

ldm/trunk/fuentes/configure.ac

r516	r855
4	4
5	5	PACKAGE=ldm
6		VERSION=2.2.13
	6	VERSION=2.2.18
7	7	AUTHOR=sbalneav@ltsp.org
8	8

ldm/trunk/fuentes/debian/changelog

-                      r518
+                      r855
+ldm (2:2.2.13-1+lliurex6) xenial; urgency=medium
+  * Release into xenial
+ -- M.Angel Juan <m.angel.juan@gmail.com>  Tue, 09 Feb 2016 17:37:06 +0100
+ldm (2:2.2.13-1+lliurex3) trusty; urgency=high
+  * Adding profile.d to thin-clients
+ -- Hector Garcia Huerta <hectorgh@gmail.com>  Mon, 03 Aug 2015 12:06:35 +0200
+ldm (2:2.2.13-1+lliurex2) trusty; urgency=medium
+  * Adding more descriptive messages when login fails
+ -- Hector Garcia Huerta <hectorgh@gmail.com>  Thu, 06 Nov 2014 12:51:54 +0100
+ldm (2:2.2.13-1+lliurex1) trusty; urgency=medium
+  * LliureX changes
+ -- Hector Garcia Huerta <hectorgh@gmail.com>  Tue, 07 Oct 2014 14:22:50 +0200
+ldm (2:2.2.18-1) unstable; urgency=medium
+  * New upstream version.
+    - Display LDM only in the first monitor (LP: #693151).
+    - DesktopNames replaced X-LightDM-DesktopName in xsession files
+      (GNOME: #727546).
+    - Fix invalid syntax in .dmrc parsing the default session.
+  * debian/control: Update Vcs-Browser to use https URL.
+ -- Vagrant Cascadian <vagrant@debian.org>  Sun, 07 Feb 2016 11:51:40 -0800
+ldm (2:2.2.17-1) unstable; urgency=medium
+  * New upstream version:
+    - ldm-script: Fix locale issues by matching against alphanumeric
+      characters (LP: #1491066).
+    - screen.d/ldm: Fix LDM_DIRECTX with Xorg 1.17+, which no longer opens
+      a listening TCP socket by default (LP: #1449282).
+ -- Vagrant Cascadian <vagrant@debian.org>  Thu, 08 Oct 2015 13:59:43 -0700
+ldm (2:2.2.16-1) experimental; urgency=medium
+  * New upstream version:
+    - Generalize LDM_12HOURCLOCK to LDM_CLOCK_FORMAT.
+    - Export DESKTOP_SESSION and XDG_CURRENT_DESKTOP to the client.
+  * Drop Remove-rc.d-hook-to-set-LIBGL_ALWAYS_INDIRECT-true-a.patch,
+    applied upstream.
+  * Use X-Vendor-Recommends to allow for variation between packages built
+    on Ubuntu and Debian.
+  * debian/copyright:
+    - Reorder to fix lintian warnings and better follow copyright-format
+.0.
+    - Updated with newer copyright holders.
+ -- Vagrant Cascadian <vagrant@debian.org>  Wed, 19 Aug 2015 12:01:03 +0200
+ldm (2:2.2.15-2) unstable; urgency=medium
+  * Add patch to remove hook to set LIBGL_ALWAYS_INDIRECT=true, as it
+    causes several common desktops to fail (Closes: #767764).
+ -- Vagrant Cascadian <vagrant@debian.org>  Sun, 08 Feb 2015 23:19:42 -0800
+ldm (2:2.2.15-1) unstable; urgency=medium
+  * New upstream version:
+    - Display error message on failed login (LP: #1325388).
+      Thanks to Jakob Unterwurzacher!
+    - Remove check for halting when SHUTDOWN_TIME is set, implemented in
+      LTSP instead (LP: #604908).
+    - Compare desktop session against available local sessions when
+      running as a fat client (LP: #1272889).
+  * debian/control: Update Standards-Version to 3.9.6, no changes needed.
+  * Remove patch to disable listening on tcp, applied upstream.
+  * Update debian/copyright.
+ -- Vagrant Cascadian <vagrant@debian.org>  Wed, 22 Oct 2014 00:45:45 -0700
+ldm (2:2.2.14-2) unstable; urgency=medium
+  * Add patch from upstream to disable listening on tcp when not using
+    LDM_DIRECTX.
+ -- Vagrant Cascadian <vagrant@debian.org>  Mon, 15 Sep 2014 14:09:56 -0500
+ldm (2:2.2.14-1) unstable; urgency=medium
+  * New upstream version:
+    - Add feature to hash passwords for use with localapps and fat clients.
+      Thanks to ben-Nabiy Derush.
+  * debian/rules:
+    - Use dpkg-vendor --derives-from Ubuntu to set VENDOR,
+      to better handle Debian/Ubuntu derivatives.
+    - Allow architecture independent builds to succeed even if some files
+      built by arch specific targets are missing.
+  * ldm-server: Recommend mate-desktop-environment in preference to other
+    sessions.
+ -- Vagrant Cascadian <vagrant@debian.org>  Tue, 05 Aug 2014 22:38:48 -0700
 ldm (2:2.2.13-1) unstable; urgency=low

ldm/trunk/fuentes/debian/control

-                      r516
+                      r855
 Build-Depends: debhelper (>= 9), flex, bison, libpopt-dev, libgtk2.0-dev,
   intltool, iso-codes, locales, python, dh-autoreconf, dctrl-tools
 Standards-Version: 3.9.5
+Standards-Version: 3.9.6
 Vcs-Bzr: nosmart+http://anonscm.debian.org/bzr/pkg-ltsp/ldm/ldm-debian-packaging/
 Vcs-Browser: http://anonscm.debian.org/loggerhead/pkg-ltsp/ldm/ldm-debian-packaging/files
+Vcs-Browser: https://anonscm.debian.org/loggerhead/pkg-ltsp/ldm/ldm-debian-packaging/files
 Homepage: http://ltsp.org/
 …
  openssh-server,
  update-inetd, openbsd-inetd | inet-superserver
 Recommends: ltspfs,
  gnome-session | x-session-manager | x-window-manager,
+Recommends: ${vendor:Recommends},
+ ltspfs,
  libasound2-plugins,
  xauth
+X-Debian-Recommends: mate-desktop-environment | gnome-session | x-session-manager | x-window-manager
+X-Ubuntu-Recommends: gnome-session | mate-desktop-environment | x-session-manager | x-window-manager
 Breaks: ltsp-server (<= 5.1.62)
 Replaces: ltsp-server (<= 5.1.62)

ldm/trunk/fuentes/debian/copyright

-                      r516
+                      r855
 Upstream-Source: http://bazaar.launchpad.net/~ltsp-upstream/ltsp/ldm-trunk/
+Files: *
+Copyright:
+-2015 Scott Balneaves and LTSP developers
+License: GPL-2+
 Files: debian/*
 Copyright: 2007-2012 Vagrant Cascadian <vagrant@freegeek.org>
+Copyright: 2007-2014 Vagrant Cascadian <vagrant@freegeek.org>
 Ryan Niebur <ryanryan52@gmail.com>
+License: GPL-2+
+Files: src/plugins/ssh/*
+Copyright: 2014 Jakob Unterwurzacher <jakobunt@gmail.com>
+ben-Nabiy Derush <bennabiy@parchmentpress.net>
+-2013 Alkis Georgopoulos <alkisg@gmail.com>
+Scott Balneaves <sbalneav@phobos.legalaid.mb.ca>
+-2012 Stéphane Graber <stgraber@ubuntu.com>
+Floris Bos / Maxnet <bos@je-eigen-domein.nl>
+Vagrant Cascadian <vagrant@debian.org>
+Warren Togami <warren@togami.com>
+Simon Poirier <spoirier@revolutionlinux.com>
+Vincent Vinet <vvinet@revolutionlinux.com>
 License: GPL-2+
 …
 Wolfgang Schweer <schweer@cityweb.de>
 Toshio Kuratomi
+Alkis Georgopoulos <alkisg@gmail.com>
 License: GPL-2
 …
 License: GPL-2+
-Files: src/sshutils.c
-Copyright: 2007-2008 Scott Balneaves <sbalneav@ltsp.org>
-Ryan Niebur <RyanRyan52@gmail.com>
-Warren Togami <wtogami@redhat.com>
-Vagrant Cascadian <vagrant@freegeek.org>
-Toshio Kuratomi
-License: GPL-2+
-Files: src/get_ip.c
-Copyright: 2007 Oliver Grawert <ogra@canonical.com>
-Scott Balneaves <sbalneav@ltsp.org>
-Warren Togami <wtogami@redhat.com>
-Toshio Kuratomi
--2009 Ryan Niebur <RyanRyan52@gmail.com>
-License: GPL-2
-Files: src/greeter_iface.c
-Copyright: 2007 Oliver Grawert <ogra@canonical.com>
--2008 Scott Balneaves <sbalneav@ltsp.org>
--2008 Vagrant Cascadian <vagrant@freegeek.org>
-Ryan Niebur <RyanRyan52@gmail.com>
-John Ellson <john.ellson@comcast.net>
-Gideon Romm <gadi@ltsp.org>
-Warren Togami <wtogami@redhat.com>
-Francis Giraldeau <francis.giraldeau@revolutionlinux.com>
-Toshio Kuratomi
-License: GPL-2+
 Files: src/ldminfo.c
 Copyright: 2007 Francis Giraldeau, <francis.giraldeau@revolutionlinux.com>
 -2008 Scott Balneaves <sbalneav@ltsp.org>
 -2009 Ryan Niebur <ryanryan52@gmail.com>
+License: GPL-2+
+Files: src/ldm-getenv-bool.c
+Copyright: 2007-2008 Scott Balneaves <sbalneav@ltsp.org>
+Ryan Niebur <RyanRyan52@gmail.com>
+Vagrant Cascadian <vagrant@freegeek.org>
+ben-Nabiy Derush <bennabiy@parchmentpress.net>
+Alkis Georgopoulos <alkisg@gmail.com>
 License: GPL-2+

ldm/trunk/fuentes/debian/patches/series

-                      r517
+                      r855
 remove-hackish-gettext-function
 lliurex-patches
 ldm_verbose_ssh.patch
 ldm_background.patch
 profiled_thinclients
 other_languages
+lliurex-patches_ported_from_2_2_13
+ldm_verbose_patch_integrated_from_2_2_13
+ldm_background_ported_from_2_2_13
+profiled_thinclients_ported_from_2_2_13
+other_languages_ported_from_2_2_13

ldm/trunk/fuentes/debian/rules

-                      r516
+                      r855
 export ENABLE_NLS=1
 VENDOR ?= $(shell dpkg-vendor --query Vendor)
+VENDOR ?= $(shell dpkg-vendor --derives-from Ubuntu && echo Ubuntu || echo Debian)
 %:
 …
 override_dh_install:
         dh_install
         rm debian/ldm/usr/lib/*/ldm/*.la
+        rm -f debian/ldm/usr/lib/*/ldm/*.la
 override_dh_fixperms:
         dh_fixperms
         # ensure ldm-script is executable to avoid lintian warning
         chmod +x debian/ldm/usr/share/ldm/ldm-script
+        test ! -f debian/ldm/usr/share/ldm/ldm-script || chmod +x debian/ldm/usr/share/ldm/ldm-script
 override_dh_autoreconf:

ldm/trunk/fuentes/gtkgreet/greeter.c

-                      r516
+                      r855
 GList *host_list = NULL;
 GIOChannel *g_stdout;           /* stdout io channel */
 gchar * ldm_theme_dir;
+gchar *ldm_theme_dir;
 int allowguest;
 …
 gchar *
 ldm_theme_file(char * file)
+{
     gchar * filename;
     gchar * filename_default;
+ldm_theme_file(char *file)
+{
+    gchar *filename;
+    gchar *filename_default;
     filename = g_strconcat("/", ldm_theme_dir, "/", file, NULL);
     filename_default = g_strconcat("/", LDM_THEME_DIR, "ltsp", "/", file, NULL);
     if (access(g_strconcat(filename, ".png", NULL), F_OK ) != -1)
+    {
+    filename_default =
+        g_strconcat("/", LDM_THEME_DIR, "ltsp", "/", file, NULL);
+    if (access(g_strconcat(filename, ".png", NULL), F_OK) != -1) {
         filename = g_strconcat(filename, ".png", NULL);
+    }
+    else if (access(g_strconcat(filename, ".jpg", NULL), F_OK ) != -1)
+    {
+    } else if (access(g_strconcat(filename, ".jpg", NULL), F_OK) != -1) {
         filename = g_strconcat(filename, ".jpg", NULL);
+    }
+    else if (access(g_strconcat(filename_default, ".png", NULL), F_OK ) != -1)
+    {
+    } else if (access(g_strconcat(filename_default, ".png", NULL), F_OK) !=
+               -1) {
         filename = g_strconcat(filename_default, ".png", NULL);
+    }
+    else if (access(g_strconcat(filename_default, ".jpg", NULL), F_OK ) != -1)
+    {
+    } else if (access(g_strconcat(filename_default, ".jpg", NULL), F_OK) !=
+               -1) {
         filename = g_strconcat(filename_default, ".jpg", NULL);
+    }
     return filename;
+}
+GdkPixmap* root_bg = 0;
+void load_root_background(const gchar* filename, gboolean scale, gboolean reload) {
+    if (root_bg != 0){
+void
+get_default_display_size(gint * width, gint * height)
+{
+    GdkDisplay *display = NULL;
+    GdkScreen *screen = NULL;
+    GdkRectangle my_rect;
+    display = gdk_display_get_default();
+    screen = gdk_display_get_default_screen(display);
+    gdk_screen_get_monitor_geometry(screen, 0, &my_rect);
+    *width = my_rect.width;
+    *height = my_rect.height;
+}
+GdkPixmap *root_bg = 0;
+void
+load_root_background(const gchar * filename, gboolean scale,
+                     gboolean reload)
+{
+    if (root_bg != 0) {
         if (reload) {
             g_object_unref(G_OBJECT (root_bg));
+            g_object_unref(G_OBJECT(root_bg));
             root_bg = 0;
         } else {
 …
+    }
     GtkWidget* image = gtk_image_new_from_file(filename);
     g_object_ref(G_OBJECT (image));
     GdkPixbuf* pixbuf = gtk_image_get_pixbuf(GTK_IMAGE (image));
     double img_width = (double)gdk_pixbuf_get_width(pixbuf);
     double img_height = (double)gdk_pixbuf_get_height(pixbuf);
     GdkWindow* root = gdk_get_default_root_window();
+    GtkWidget *image = gtk_image_new_from_file(filename);
+    g_object_ref(G_OBJECT(image));
+    GdkPixbuf *pixbuf = gtk_image_get_pixbuf(GTK_IMAGE(image));
+    double img_width = (double) gdk_pixbuf_get_width(pixbuf);
+    double img_height = (double) gdk_pixbuf_get_height(pixbuf);
+    GdkWindow *root = gdk_get_default_root_window();
     gint width, height;
     gdk_drawable_get_size(GDK_DRAWABLE (root), &width, &height);
+    get_default_display_size(&width, &height);
     // create pixmap
+    gdk_drawable_get_size(GDK_DRAWABLE (root), &width, &height);
+    root_bg = gdk_pixmap_new(GDK_DRAWABLE (root), width, height, -1);
+    g_object_ref(G_OBJECT (root_bg));
+    root_bg = gdk_pixmap_new(GDK_DRAWABLE(root), width, height, -1);
+    g_object_ref(G_OBJECT(root_bg));
     // paint pixmap onto bg
     cairo_t* ctx = gdk_cairo_create(GDK_DRAWABLE (root_bg));
+    cairo_t *ctx = gdk_cairo_create(GDK_DRAWABLE(root_bg));
     if (scale) {
         cairo_scale(ctx, width/img_width, height/img_height);
+        cairo_scale(ctx, width / img_width, height / img_height);
+    }
     gdk_cairo_set_source_pixbuf(ctx, pixbuf, 0, 0);
 …
     //g_object_unref(G_OBJECT (bg));
     g_object_unref(G_OBJECT (image));
+    g_object_unref(G_OBJECT(image));
+}
 void
+set_root_background() {
+    GdkWindow* root = gdk_get_default_root_window();
+    // bg needs to be set and painted, so it refreshes now and in the future
+    gdk_window_set_back_pixmap(GDK_WINDOW (root), GDK_PIXMAP (root_bg), 0);
+    gdk_draw_drawable(GDK_DRAWABLE (root),
+                      gdk_gc_new(GDK_DRAWABLE (root)),
+                      GDK_DRAWABLE (root_bg),
+, 0,
+, 0,
+                      -1, -1);
+}
+void
+draw_background(GtkWidget* widget, gpointer data) {
+    GdkWindow* window;
+draw_background(GtkWidget * widget, gpointer data)
+{
+    GdkWindow *window;
     gint width, height, x, y;
 …
         return;
+    }
+    gdk_drawable_get_size(GDK_DRAWABLE (window), &width, &height);
+    gdk_window_get_origin(GDK_WINDOW (window), &x, &y);
+    GdkPixmap* new_bg = gdk_pixmap_new(root_bg, width, height, -1);
+    g_object_ref(G_OBJECT (new_bg));
+    gdk_draw_drawable(GDK_DRAWABLE (new_bg),
+                    gdk_gc_new(GDK_DRAWABLE (new_bg)),
+                    GDK_DRAWABLE (root_bg),
+                    x, y,
+, 0,
+                    width, height);
+    gdk_window_set_back_pixmap(GDK_WINDOW (window), new_bg, 0);
+    gtk_widget_queue_draw(GTK_WIDGET (widget));
+    gdk_drawable_get_size(GDK_DRAWABLE(window), &width, &height);
+    gdk_window_get_origin(GDK_WINDOW(window), &x, &y);
+    GdkPixmap *new_bg = gdk_pixmap_new(root_bg, width, height, -1);
+    g_object_ref(G_OBJECT(new_bg));
+    gdk_draw_drawable(GDK_DRAWABLE(new_bg),
+                      gdk_gc_new(GDK_DRAWABLE(new_bg)),
+                      GDK_DRAWABLE(root_bg), x, y, 0, 0, width, height);
+    gdk_window_set_back_pixmap(GDK_WINDOW(window), new_bg, 0);
+    gtk_widget_queue_draw(GTK_WIDGET(widget));
+}
 …
 static void
 spawn_command(GtkWidget * widget, const gchar *command)
+spawn_command(GtkWidget * widget, const gchar * command)
+{
     GError **error = NULL;
 …
 update_time(GtkWidget * label)
+{
-    gchar *timestring = 0;
     time_t timet;
     struct tm *timePtr;
+    gchar *clock_format;
+    gchar label_markup[100];
     timet = time(NULL);
     timePtr = localtime(&timet);
+    // use 12 hour clock format if LDM_12HOURCLOCK is set to true
+    if (ldm_getenv_bool("LDM_12HOURCLOCK")) {
+        timestring = g_strdup_printf("<b>%.2d:%.2d</b>",
+                                   (timePtr->tm_hour % 12) ? (timePtr->tm_hour % 12) : 12,
+                                   timePtr->tm_min);
+    }
+    else {
+        timestring = g_strdup_printf("<b>%.2d:%.2d</b>",
+                                   timePtr->tm_hour, timePtr->tm_min);
+    }
+    gtk_label_set_markup((GtkLabel *) label, timestring);
+    g_free(timestring);
+    // Allow the users to customize the clock format including the GTK markup,
+    // for example in case they want the date non-bold and the time in bold.
+    clock_format=ldm_getenv_str_default("LDM_CLOCK_FORMAT", "%x, <b>%H:%M</b>");
+    if (strftime(label_markup, sizeof(label_markup), clock_format, timePtr))
+        gtk_label_set_markup((GtkLabel *) label, label_markup);
     return TRUE;
 …
     gchar *string;
     int entry_length;
     entry_length = strlen(gtk_entry_get_text((GtkEntry *)entry));
     if(entry_length == 0 && timeout_enabled) {
         if (timeout_left > 1){
+    entry_length = strlen(gtk_entry_get_text((GtkEntry *) entry));
+    if (entry_length == 0 && timeout_enabled) {
+        if (timeout_left > 1) {
             timeout_left--;
         } else if (timeout_left == 1) {
+            g_io_channel_write_chars(g_stdout, "@GUEST@\n", -1, NULL, NULL);
+            g_io_channel_write_chars(g_stdout, "@GUEST@\n", -1, NULL,
+                                     NULL);
             g_io_channel_flush(g_stdout, NULL);
             timeout_left = 0;
             timeout_enabled = FALSE;
         } else if (timeout_left == 0){
+        } else if (timeout_left == 0) {
             timeout_left = login_timeout;
+        }
+        string = g_strdup_printf(_("Automatic login in %d seconds"), timeout_left);
+        string =
+            g_strdup_printf(_("Automatic login in %d seconds"),
+                            timeout_left);
         gtk_label_set_markup((GtkLabel *) label, string);
         g_free(string);
 …
     gboolean result;
+    result=gdk_property_get(
+        gdk_get_default_root_window(),
+        gdk_atom_intern(property,TRUE),
+        GDK_NONE,
+,
+,
+        FALSE,
+        actual_property_type,
+        actual_format,
+        actual_length,
+        data);
+    result = gdk_property_get(gdk_get_default_root_window(),
+                              gdk_atom_intern(property, TRUE),
+                              GDK_NONE,
+,
+,
+                              FALSE,
+                              actual_property_type,
+                              actual_format, actual_length, data);
     return result;
+}
 …
     g_strstrip(buf->str);
     log_entry("gtkgreet",7,"Got command: %s",buf->str);
+    log_entry("gtkgreet", 7, "Got command: %s", buf->str);
     if (!g_ascii_strncasecmp(buf->str, "msg", 3)) {
 …
     } else if (!g_ascii_strncasecmp(buf->str, "userid", 6)) {
         timeout_enabled = login_timeout > 0;
         if(timeout_enabled) {
+        if (timeout_enabled) {
             gtk_widget_show(timeoutbox);
+        }
 …
         // choice;choice 1|choice 2|choice 3
         gchar** choices = g_strsplit(buf->str+7, "|", -1);
+        gchar **choices = g_strsplit(buf->str + 7, "|", -1);
         // drop combo box to drop model
         gtk_list_store_clear(choiceList);
         for (i=0; i<g_strv_length(choices); ++i) {
+        for (i = 0; i < g_strv_length(choices); ++i) {
             gtk_list_store_append(GTK_LIST_STORE(choiceList), &iter);
             gtk_list_store_set(GTK_LIST_STORE(choiceList), &iter, 0,
 …
         // pref choice;key;title;menu;icon;choice 1|choice 2|choice 3
         gchar** args = g_strsplit(buf->str, ";", 6);
         gchar** choices = g_strsplit(args[5], "|", -1);
+        gchar **args = g_strsplit(buf->str, ";", 6);
+        gchar **choices = g_strsplit(args[5], "|", -1);
         GreeterPref *pref = greeter_pref_new(g_strdup(args[1]));
 …
         pref->icon = g_strdup(args[4]);
+        for (i=0; i<g_strv_length(choices); ++i) {
+            pref->choices = g_list_append(pref->choices, g_strdup(choices[i]));
+        for (i = 0; i < g_strv_length(choices); ++i) {
+            pref->choices =
+                g_list_append(pref->choices, g_strdup(choices[i]));
+        }
 …
         buf->str[buf->len] = '\0';
+        valstr = g_strdup_printf("%s\n", greeter_pref_get_value(name).str_val);
+        valstr =
+            g_strdup_printf("%s\n", greeter_pref_get_value(name).str_val);
         g_io_channel_write_chars(g_stdout, valstr, -1, NULL, NULL);
         g_io_channel_flush(g_stdout, NULL);
         g_free(valstr);
     } else if (!g_ascii_strncasecmp(buf->str, "allowguest", 10)) {
         gchar* valstr = buf->str + 11;
+        gchar *valstr = buf->str + 11;
         allowguest = g_ascii_strncasecmp(valstr, "false", 2);
         if (!allowguest)
 …
 handle_choice(GtkComboBox * combo, GdkWindow * window)
+{
     gchar* selection;
     gchar* entrystr;
+    gchar *selection;
+    gchar *entrystr;
     selection = gtk_combo_box_get_active_text(GTK_COMBO_BOX(choiceCombo));
 …
     g_io_channel_flush(g_stdout, NULL);
     g_free(entrystr);
     if(gtk_entry_get_visibility(GTK_ENTRY(entry)))
+    if (gtk_entry_get_visibility(GTK_ENTRY(entry)))
         gtk_entry_set_text(entry, "");
+}
 static gboolean
+menu_append_pref(gpointer akey, gpointer avalue, gpointer adata) {
+    char* key = (char*)akey;
+    GreeterPref* pref = (GreeterPref*)avalue;
+    GtkWidget* menu = (GtkWidget*)adata;
+menu_append_pref(gpointer akey, gpointer avalue, gpointer adata)
+{
+    char *key = (char *) akey;
+    GreeterPref *pref = (GreeterPref *) avalue;
+    GtkWidget *menu = (GtkWidget *) adata;
     GtkWidget *pref_item, *prefico;
+    pref_item =
+        gtk_image_menu_item_new_with_mnemonic(_(pref->menu));
+    pref_item = gtk_image_menu_item_new_with_mnemonic(_(pref->menu));
     prefico = gtk_image_new_from_file(ldm_theme_file(pref->icon));
     gtk_image_menu_item_set_image((GtkImageMenuItem *) pref_item, prefico);
 …
     if (getenv("LDM_FORCE_LANGUAGE") == NULL) {
         lang_item =
+            gtk_image_menu_item_new_with_mnemonic(_("Select _Language ..."));
+            gtk_image_menu_item_new_with_mnemonic(_
+                                                  ("Select _Language ..."));
         langico = gtk_image_new_from_file(ldm_theme_file("language"));
+        gtk_image_menu_item_set_image((GtkImageMenuItem *) lang_item, langico);
+        gtk_image_menu_item_set_image((GtkImageMenuItem *) lang_item,
+                                      langico);
         g_signal_connect_swapped(G_OBJECT(lang_item), "activate",
                                  G_CALLBACK(langwin), window);
 …
     if (getenv("LDM_FORCE_SESSION") == NULL) {
         sess_item =
+            gtk_image_menu_item_new_with_mnemonic(_("Select _Session ..."));
+            gtk_image_menu_item_new_with_mnemonic(_
+                                                  ("Select _Session ..."));
         sessico = gtk_image_new_from_file(ldm_theme_file("session"));
+        gtk_image_menu_item_set_image((GtkImageMenuItem *) sess_item, sessico);
+        gtk_image_menu_item_set_image((GtkImageMenuItem *) sess_item,
+                                      sessico);
         g_signal_connect_swapped(G_OBJECT(sess_item), "activate",
                                  G_CALLBACK(sesswin), window);
 …
             gtk_image_menu_item_new_with_mnemonic(_("Select _Host ..."));
         hostico = gtk_image_new_from_file(ldm_theme_file("host"));
+        gtk_image_menu_item_set_image((GtkImageMenuItem *) host_item, hostico);
+        gtk_image_menu_item_set_image((GtkImageMenuItem *) host_item,
+                                      hostico);
         g_signal_connect_swapped(G_OBJECT(host_item), "activate",
                                  G_CALLBACK(hostwin), window);
 …
+    }
     for (i=0; i<=9; i++) {
+    for (i = 0; i <= 9; i++) {
         g_sprintf(custom_env_var, "LDM_MENU_ITEM_%d", i);
         custom_mnemonic=getenv(custom_env_var);
+        custom_mnemonic = getenv(custom_env_var);
         if (custom_mnemonic == NULL)
             continue;
 …
             gtk_image_menu_item_new_with_mnemonic(custom_mnemonic);
         g_sprintf(custom_env_var, "LDM_MENU_COMMAND_%d", i);
         custom_command=getenv(custom_env_var);
+        custom_command = getenv(custom_env_var);
         if (custom_command == NULL) {
             gtk_widget_destroy(custom_item);
 …
         customico = gtk_image_new_from_file(ldm_theme_file("backend"));
         gtk_image_menu_item_set_image((GtkImageMenuItem *) custom_item,
             customico);
+                                      customico);
         g_signal_connect(G_OBJECT(custom_item), "activate",
+                         G_CALLBACK(spawn_command), g_strdup(custom_command));
+                         G_CALLBACK(spawn_command),
+                         g_strdup(custom_command));
         gtk_menu_shell_append(GTK_MENU_SHELL(menu), custom_item);
+    }
 …
     else {
         strncpy(dest, source, MAXSTRSZ - 1);
         *(dest + MAXSTRSZ - 1) = '\0';     /* ensure null termination */
+        *(dest + MAXSTRSZ - 1) = '\0';           /* ensure null termination */
+    }
 …
  */
 static gboolean
 key_press_event(GtkWidget *widget, GdkEventKey *event, gpointer window)
+key_press_event(GtkWidget * widget, GdkEventKey * event, gpointer window)
+{
     if ((event->keyval == GDK_Tab ||
          event->keyval == GDK_KP_Tab) &&
+        (event->state & (GDK_CONTROL_MASK|GDK_MOD1_MASK|GDK_SHIFT_MASK)) == 0) {
+            handle_entry(GTK_ENTRY(entry), window);
+            return TRUE;
+        (event->
+         state & (GDK_CONTROL_MASK | GDK_MOD1_MASK | GDK_SHIFT_MASK)) ==
+) {
+        handle_entry(GTK_ENTRY(entry), window);
+        return TRUE;
+    }
 …
 main(int argc, char *argv[])
+{
     gint lw;
+    gint lw, lh;
     GtkWidget *loginWindow, *prefBar;
 …
     gint width, height;
     GIOChannel *g_stdin;
     char * ldm_theme;
+    char *ldm_theme;
 #ifdef ENABLE_NLS
     setlocale (LC_ALL, "");
     bindtextdomain (GETTEXT_PACKAGE, LOCALE_DIR);
     bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
     textdomain (GETTEXT_PACKAGE);
+    setlocale(LC_ALL, "");
+    bindtextdomain(GETTEXT_PACKAGE, LOCALE_DIR);
+    bind_textdomain_codeset(GETTEXT_PACKAGE, "UTF-8");
+    textdomain(GETTEXT_PACKAGE);
 #endif
     /* Init log settings */
+    log_init(ldm_getenv_bool("LDM_SYSLOG"),ldm_getenv_int("LDM_LOGLEVEL",-1));
+    log_init(ldm_getenv_bool("LDM_SYSLOG"),
+             ldm_getenv_int("LDM_LOGLEVEL", -1));
     gtk_init(&argc, &argv);
     ldm_theme = getenv("LDM_THEME");
+    if (ldm_theme)
+    {
+        if(*ldm_theme == '/')
+    if (ldm_theme) {
+        if (*ldm_theme == '/')
             ldm_theme_dir = g_strdup(ldm_theme);
         else
             ldm_theme_dir = g_strconcat(LDM_THEME_DIR, ldm_theme, NULL);
+    }
+    else
+    {
+    } else {
         ldm_theme_dir = g_strconcat(LDM_THEME_DIR, "default", NULL);
+    }
 …
     /* Set the background */
     load_root_background(ldm_theme_file("bg"), TRUE, FALSE);
+    set_root_background();
+    gdk_drawable_get_size(root, &width, &height);
+    get_default_display_size(&width, &height);
     /* Setup the time and system labels */
 …
 #ifdef K12LINUX
         hoststring =
+            g_strdup_printf("<b>%s</b> (%s)", get_sysname(), getenv("LDMINFO_IPADDR"));
+            g_strdup_printf("<b>%s</b> (%s)", get_sysname(),
+                            getenv("LDMINFO_IPADDR"));
 #else
         hoststring =
+            g_strdup_printf("<b>%s</b> (%s) //", get_sysname(), getenv("LDMINFO_IPADDR"));
+            g_strdup_printf("<b>%s</b> (%s) -", get_sysname(),
+                            getenv("LDMINFO_IPADDR"));
 #endif
         gtk_label_set_markup((GtkLabel *) syslabel, hoststring);
 …
     /**** Create the login window ****/
-    gtk_window_set_position(GTK_WINDOW(loginWindow), GTK_WIN_POS_CENTER_ALWAYS);
+    {
+        GtkWidget *guestbox, *guestspacer1, *guestspacer2, *vbox, *vbox2, *hbox;
+        GtkWidget *guestbox, *guestspacer1, *guestspacer2, *vbox, *vbox2,
+            *vbox2spacer, *hbox;
         GtkCellRenderer *renderer;
         g_signal_connect(G_OBJECT(loginWindow), "destroy", G_CALLBACK(destroy),
                          NULL);
+        g_signal_connect(G_OBJECT(loginWindow), "destroy",
+                         G_CALLBACK(destroy), NULL);
         gtk_widget_set_app_paintable(loginWindow, TRUE);
         g_signal_connect(loginWindow, "configure-event",
                         G_CALLBACK(draw_background), NULL);
         //gtk_widget_set_size_request(loginWindow, width/2, height/2);
         //gtk_widget_realize(loginWindow);
         gtk_window_set_decorated(GTK_WINDOW (loginWindow), FALSE);
+                         G_CALLBACK(draw_background), NULL);
+        gtk_widget_set_size_request(loginWindow, width, height);
+        gtk_widget_realize(loginWindow);
+        gtk_window_set_decorated(GTK_WINDOW(loginWindow), FALSE);
         logo = gtk_image_new_from_file(ldm_theme_file("logo"));
 #ifdef K12LINUX
         if(access(ldm_theme_file("bottom_right"), R_OK) == 0) {
             bottom_right = gtk_image_new_from_file(ldm_theme_file("bottom_right"));
             has_bottom_right_image=TRUE;
+        }
         else
             has_bottom_right_image=FALSE;
+        if (access(ldm_theme_file("bottom_right"), R_OK) == 0) {
+            bottom_right =
+                gtk_image_new_from_file(ldm_theme_file("bottom_right"));
+            has_bottom_right_image = TRUE;
+        } else
+            has_bottom_right_image = FALSE;
 #endif
         pix = gtk_image_get_pixbuf((GtkImage *) logo);
         lw = gdk_pixbuf_get_width(pix);
+        lh = gdk_pixbuf_get_height(pix);
         vbox = gtk_vbox_new(FALSE, 5);
+        vbox2 = gtk_vbox_new(FALSE, 0);
+        vbox2 = gtk_vbox_new(FALSE, ((height / 2) - lh));
+        vbox2spacer = gtk_vbox_new(FALSE, 5);
         EntryBox = gtk_hbox_new(FALSE, 5);
         hbox = gtk_hbox_new(FALSE, 0);
 …
         StatusMessages = gtk_label_new("");
         entry = gtk_entry_new();
         gtk_entry_set_width_chars(GTK_ENTRY(entry), 12);
+        gtk_entry_set_width_chars(GTK_ENTRY(entry), 20);
         g_signal_connect(G_OBJECT(entry), "activate",
                          G_CALLBACK(handle_entry), root);
 …
         choiceList = gtk_list_store_new(1, G_TYPE_STRING);
+        choiceCombo = gtk_combo_box_new_with_model(GTK_TREE_MODEL(choiceList));
+        choiceCombo =
+            gtk_combo_box_new_with_model(GTK_TREE_MODEL(choiceList));
         renderer = gtk_cell_renderer_text_new();
         gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(choiceCombo),
+                                                   GTK_CELL_RENDERER(renderer),
+                                                   TRUE);
+                                   GTK_CELL_RENDERER(renderer), TRUE);
         gtk_cell_layout_add_attribute(GTK_CELL_LAYOUT(choiceCombo),
                                       GTK_CELL_RENDERER(renderer),
 …
                          G_CALLBACK(handle_choice), root);
         if (getenv("LDM_LOGIN_TIMEOUT") != NULL ) {
+        if (getenv("LDM_LOGIN_TIMEOUT") != NULL) {
             login_timeout = atoi(getenv("LDM_LOGIN_TIMEOUT"));
         } else {
 …
         timeoutbox = gtk_hbox_new(FALSE, 0);
         gtk_box_pack_start(GTK_BOX(vbox), timeoutbox, FALSE, FALSE, 0);
+        gtk_box_pack_start(GTK_BOX(timeoutbox), timeoutspacer1, TRUE, FALSE, 0);
+        gtk_box_pack_start(GTK_BOX(timeoutbox), timeoutlabel, FALSE, FALSE, 0);
+        gtk_box_pack_start(GTK_BOX(timeoutbox), timeoutspacer2, TRUE, FALSE, 0);
+        gtk_box_pack_start(GTK_BOX(timeoutbox), timeoutspacer1, TRUE,
+                           FALSE, 0);
+        gtk_box_pack_start(GTK_BOX(timeoutbox), timeoutlabel, FALSE, FALSE,
+);
+        gtk_box_pack_start(GTK_BOX(timeoutbox), timeoutspacer2, TRUE,
+                           FALSE, 0);
         g_timeout_add(1000, (GSourceFunc) update_timeout, timeoutlabel);
         guestspacer1 = gtk_label_new("");
         guestspacer2 = gtk_label_new("");
         GuestButton = gtk_button_new_with_label (_("Login as Guest"));
+        GuestButton = gtk_button_new_with_label(_("Login as Guest"));
         g_signal_connect(G_OBJECT(GuestButton), "clicked",
             G_CALLBACK(handle_guestbutton), root);
         gtk_button_set_focus_on_click((GtkButton *)GuestButton, FALSE);
+                         G_CALLBACK(handle_guestbutton), root);
+        gtk_button_set_focus_on_click((GtkButton *) GuestButton, FALSE);
         guestbox = gtk_hbox_new(FALSE, 0);
+        gtk_box_pack_start(GTK_BOX(guestbox), guestspacer1, TRUE, FALSE, 0);
+        gtk_box_pack_start(GTK_BOX(guestbox), GuestButton, FALSE, FALSE, 0);
+        gtk_box_pack_start(GTK_BOX(guestbox), guestspacer2, TRUE, FALSE, 0);
+        gtk_box_pack_start(GTK_BOX(guestbox), guestspacer1, TRUE, FALSE,
+);
+        gtk_box_pack_start(GTK_BOX(guestbox), GuestButton, FALSE, FALSE,
+);
+        gtk_box_pack_start(GTK_BOX(guestbox), guestspacer2, TRUE, FALSE,
+);
         entryspacer1 = gtk_label_new("");
         entryspacer2 = gtk_label_new("");
+        gtk_box_pack_start(GTK_BOX(EntryBox), entryspacer1, TRUE, FALSE, 0);
+        gtk_box_pack_start(GTK_BOX(EntryBox), entryspacer1, TRUE, FALSE,
+);
         gtk_box_pack_start(GTK_BOX(EntryBox), UserPrompt, FALSE, FALSE, 0);
         gtk_box_pack_start(GTK_BOX(EntryBox), entry, FALSE, FALSE, 0);
+        gtk_box_pack_start(GTK_BOX(EntryBox), choiceCombo, FALSE, FALSE, 0);
+        gtk_box_pack_start(GTK_BOX(EntryBox), entryspacer2, TRUE, FALSE, 0);
+        gtk_box_pack_start(GTK_BOX(EntryBox), choiceCombo, FALSE, FALSE,
+);
+        gtk_box_pack_start(GTK_BOX(EntryBox), entryspacer2, TRUE, FALSE,
+);
         gtk_box_pack_start(GTK_BOX(vbox), logo, FALSE, FALSE, 5);
         gtk_box_pack_start(GTK_BOX(vbox), EntryBox, TRUE, FALSE, 0);
+        if(allowguest) gtk_box_pack_start(GTK_BOX(vbox), guestbox, FALSE, FALSE, 0);
+        if (allowguest)
+            gtk_box_pack_start(GTK_BOX(vbox), guestbox, FALSE, FALSE, 0);
         gtk_box_pack_start(GTK_BOX(vbox), timeoutbox, FALSE, FALSE, 0);
         gtk_box_pack_start(GTK_BOX(vbox), StatusMessages, TRUE, FALSE, 0);
         gtk_box_pack_start(GTK_BOX(hbox), vbox, TRUE, FALSE, 0);
+        gtk_box_pack_start(GTK_BOX(vbox2), vbox2spacer, FALSE, FALSE, 0);
         gtk_box_pack_start(GTK_BOX(vbox2), hbox, FALSE, FALSE, 0);
 …
         GtkWidget *BottomBarBox;
         gtk_widget_set_app_paintable(GTK_WIDGET (prefBar), TRUE);
+        gtk_widget_set_app_paintable(GTK_WIDGET(prefBar), TRUE);
         g_signal_connect(prefBar, "configure-event",
                         G_CALLBACK(draw_background), NULL);
         gtk_window_set_decorated(GTK_WINDOW (prefBar), FALSE);
+                         G_CALLBACK(draw_background), NULL);
+        gtk_window_set_decorated(GTK_WINDOW(prefBar), FALSE);
         gtk_widget_set_size_request(prefBar, width, BOTTOM_BAR_HEIGHT);
 …
         optionbutton_box = gtk_vbox_new(FALSE, 0);
         optionbutton_spacer = gtk_label_new("");
+        gtk_box_pack_start(GTK_BOX(optionbutton_box), GTK_WIDGET(optionbutton_spacer), TRUE, FALSE, 0);
+        gtk_box_pack_end(GTK_BOX(optionbutton_box), GTK_WIDGET(optionbutton), FALSE, FALSE, 5);
+        gtk_box_pack_start(GTK_BOX(optionbutton_box),
+                           GTK_WIDGET(optionbutton_spacer), TRUE, FALSE,
+);
+        gtk_box_pack_end(GTK_BOX(optionbutton_box),
+                         GTK_WIDGET(optionbutton), FALSE, FALSE, 5);
         gtk_box_pack_start(GTK_BOX(BottomBarBox),
                            GTK_WIDGET(optionbutton_box), FALSE, FALSE, 5);
         if(has_bottom_right_image == TRUE) {
+        if (has_bottom_right_image == TRUE) {
             bottom_right_box = gtk_vbox_new(FALSE, 0);
             bottom_right_spacer = gtk_label_new("");
+            gtk_box_pack_start(GTK_BOX(bottom_right_box), GTK_WIDGET(bottom_right_spacer), TRUE, FALSE, 0);
+            gtk_box_pack_end(GTK_BOX(bottom_right_box), GTK_WIDGET(bottom_right), FALSE, FALSE, 0);
+            gtk_box_pack_start(GTK_BOX(bottom_right_box),
+                               GTK_WIDGET(bottom_right_spacer), TRUE,
+                               FALSE, 0);
+            gtk_box_pack_end(GTK_BOX(bottom_right_box),
+                             GTK_WIDGET(bottom_right), FALSE, FALSE, 0);
             gtk_box_pack_end(GTK_BOX(BottomBarBox),
+                             GTK_WIDGET(bottom_right_box), FALSE, FALSE, 0);
+                             GTK_WIDGET(bottom_right_box), FALSE, FALSE,
+);
+        }
 #endif
         gtk_container_add(GTK_CONTAINER (prefBar), BottomBarBox);
+        gtk_container_add(GTK_CONTAINER(prefBar), BottomBarBox);
+    }
 …
         GtkWidget *TopBarBox;
         gtk_window_set_decorated(GTK_WINDOW (topBar), FALSE);
+        gtk_window_set_decorated(GTK_WINDOW(topBar), FALSE);
         gtk_widget_set_size_request(topBar, width, TOP_BAR_HEIGHT);
         TopBarBox = gtk_hbox_new(FALSE, 5);
         gtk_box_pack_start(GTK_BOX(TopBarBox),
                          GTK_WIDGET(syslabel), FALSE, FALSE, 5);
+                           GTK_WIDGET(syslabel), FALSE, FALSE, 5);
         gtk_box_pack_end(GTK_BOX(TopBarBox),
                          GTK_WIDGET(timelabel), FALSE, FALSE, 5);
 …
     gtk_widget_show_all(loginWindow);
     gtk_widget_show_all(prefBar);
+    gtk_window_move(GTK_WINDOW (prefBar), 0, height - BOTTOM_BAR_HEIGHT);
+    gtk_window_move(GTK_WINDOW(loginWindow), 0, 0);
+    gtk_window_move(GTK_WINDOW(prefBar), 0, height - BOTTOM_BAR_HEIGHT);
 #ifdef K12LINUX
     gtk_widget_show_all(topBar);
     gtk_window_move(GTK_WINDOW (topBar), 0, 0);
+    gtk_window_move(GTK_WINDOW(topBar), 0, 0);
 #endif
+    // Center the mouse pointer on the default display
+    GdkDisplay *display = gdk_display_get_default();
+    GdkScreen *screen = gdk_display_get_default_screen(display);
+    GdkRectangle bbox;
+    gdk_screen_get_monitor_geometry(screen, 0, &bbox);
+    gdk_display_warp_pointer(display, screen, bbox.width/2, bbox.height/2);
     gdk_window_set_cursor(root, normcursor);

ldm/trunk/fuentes/gtkgreet/langwin.c

-                      r516
+                      r855
         curr_host =
+            ldminfo_lookup(g_list_nth_data(host_list,
+                  selected_host_id));
+            ldminfo_lookup(g_list_nth_data(host_list, selected_host_id));
         l = curr_host->languages;
         g_strlcpy(language, g_list_nth_data(l, lang_selected - 1),
 …
      */
+    curr_host = ldminfo_lookup(g_list_nth_data(host_list, selected_host_id));
+    curr_host =
+        ldminfo_lookup(g_list_nth_data(host_list, selected_host_id));
     gtk_combo_box_append_text(GTK_COMBO_BOX(lang_select),
 …
     label = gtk_label_new("");
     gtk_label_set_markup((GtkLabel *) label,
+                         _("Select the language for your session to use:"));
+                         _
+                         ("Select the language for your session to use:"));
     gtk_box_pack_start((GtkBox *) vbox, (GtkWidget *) label, FALSE, FALSE,

ldm/trunk/fuentes/gtkgreet/prefs.c

-                      r516
+                      r855
 #include <sys/socket.h>
 static GTree* greeter_prefs = NULL;
+static GTree *greeter_prefs = NULL;
+static int g_strcmp(gconstpointer a, gconstpointer b) {
+    return strcmp((char*)a, (char*)b);
+static int
+g_strcmp(gconstpointer a, gconstpointer b)
+{
+    return strcmp((char *) a, (char *) b);
+}
+void greeter_pref_init() {
+void
+greeter_pref_init()
+{
     if (greeter_prefs) {
         g_tree_destroy(greeter_prefs);
 …
+}
+GreeterPref* greeter_pref_new(const gchar* name) {
+    GreeterPref* pref = g_malloc0(sizeof(GreeterPref));
+GreeterPref *
+greeter_pref_new(const gchar * name)
+{
+    GreeterPref *pref = g_malloc0(sizeof(GreeterPref));
     g_tree_replace(greeter_prefs, g_strdup(name), pref);
     pref->choices = g_list_alloc();
 …
+}
+void greeter_pref_destroy(const gchar* name) {
+void
+greeter_pref_destroy(const gchar * name)
+{
     gpointer key;
     gpointer valptr;
     GreeterPref* value;
+    GreeterPref *value;
     g_tree_lookup_extended(greeter_prefs, name, &key, &valptr);
     value = (GreeterPref*)valptr;
+    value = (GreeterPref *) valptr;
     if (value->choices) {
         g_list_foreach(value->choices, (GFunc)g_free, NULL);
+        g_list_foreach(value->choices, (GFunc) g_free, NULL);
         g_list_free(value->choices);
+    }
 …
+}
+void greeter_pref_prompt(const gchar* name) {
+void
+greeter_pref_prompt(const gchar * name)
+{
+}
+GreeterPref* greeter_pref_get_pref(const gchar* name) {
+    return (GreeterPref*)g_tree_lookup(greeter_prefs, name);
+GreeterPref *
+greeter_pref_get_pref(const gchar * name)
+{
+    return (GreeterPref *) g_tree_lookup(greeter_prefs, name);
+}
+PrefValue greeter_pref_get_value(const gchar* name) {
+    GreeterPref* value = (GreeterPref*) g_tree_lookup(greeter_prefs, name);
+PrefValue
+greeter_pref_get_value(const gchar * name)
+{
+    GreeterPref *value =
+        (GreeterPref *) g_tree_lookup(greeter_prefs, name);
     if (!value) {
+        return (PrefValue)"None";
+    } if (value->value.int_val == 0) {
+        return (PrefValue)"None";
+        return (PrefValue) "None";
+    }
+    if (value->value.int_val == 0) {
+        return (PrefValue) "None";
+    }
     return (PrefValue)(char*)g_list_nth_data(value->choices,
                                              value->value.int_val);
+    return (PrefValue) (char *) g_list_nth_data(value->choices,
+                                                value->value.int_val);
+}
+void greeter_pref_foreach(GTraverseFunc func, gpointer user_data) {
+void
+greeter_pref_foreach(GTraverseFunc func, gpointer user_data)
+{
     g_tree_foreach(greeter_prefs, func, user_data);
+}

ldm/trunk/fuentes/gtkgreet/prefwin.c

-                      r516
+                      r855
 #include "greeter.h"
 static GtkWidget* pref_combo = NULL;
+static GtkWidget *pref_combo = NULL;
 static gint choice_total = 0;
 …
 typedef struct {
     GtkWidget* prefwin;
     const gchar* prefname;
+    GtkWidget *prefwin;
+    const gchar *prefname;
 } PrefData;
 …
 static void
 prefwin_accept(GtkWidget * widget, PrefData* data)
+prefwin_accept(GtkWidget * widget, PrefData * data)
+{
     GreeterPref* pref = greeter_pref_get_pref(data->prefname);
     gchar* notif;
+    GreeterPref *pref = greeter_pref_get_pref(data->prefname);
+    gchar *notif;
+    pref->value.int_val = gtk_combo_box_get_active(GTK_COMBO_BOX(pref_combo));
+    pref->value.int_val =
+        gtk_combo_box_get_active(GTK_COMBO_BOX(pref_combo));
     gtk_widget_destroy(data->prefwin);
 …
+{
     GreeterPref* pref;
+    GreeterPref *pref;
     GtkWidget *prefwin, *label, *vbox, *buttonbox;
     GtkWidget *cancel, *accept, *frame;
 …
                    (GFunc) populate_pref_combo_box, pref_combo);
+    gtk_combo_box_set_active(GTK_COMBO_BOX(pref_combo), pref->value.int_val);
+    gtk_combo_box_set_active(GTK_COMBO_BOX(pref_combo),
+                             pref->value.int_val);
     /*
 …
     accept = gtk_button_new_from_stock("gtk-ok");
     PrefData* data = g_malloc0(sizeof(PrefData));
+    PrefData *data = g_malloc0(sizeof(PrefData));
     data->prefwin = prefwin;
     data->prefname = pref_name;
 …
     label = gtk_label_new("");
+    gtk_label_set_markup((GtkLabel *) label,
+                         _(pref->title));
+    gtk_label_set_markup((GtkLabel *) label, _(pref->title));
     gtk_box_pack_start((GtkBox *) vbox, (GtkWidget *) label, FALSE, FALSE,
 …
     return;
+}

ldm/trunk/fuentes/gtkgreet/sesswin.c

-                      r516
+                      r855
         GList *s = NULL;
+        curr_host = ldminfo_lookup(g_list_nth_data(host_list, selected_host_id));
+        curr_host =
+            ldminfo_lookup(g_list_nth_data(host_list, selected_host_id));
         s = curr_host->sessions;
         g_strlcpy(session, g_list_nth_data(s, sess_selected - 2),
 …
      */
+    curr_host = ldminfo_lookup(g_list_nth_data(host_list, current_host_id));
+    curr_host =
+        ldminfo_lookup(g_list_nth_data(host_list, current_host_id));
     gtk_combo_box_append_text(GTK_COMBO_BOX(sess_select),

ldm/trunk/fuentes/misc/ldm-dialog.c

-                      r516
+                      r855
 int auto_close;
+void yes_clicked(GtkWidget * widget, GtkWidget * mywin)
+void
+yes_clicked(GtkWidget * widget, GtkWidget * mywin)
+{
     gtk_main_quit();
 …
+}
+void no_clicked(GtkWidget * widget, GtkWidget * mywin)
+void
+no_clicked(GtkWidget * widget, GtkWidget * mywin)
+{
     gtk_main_quit();
 …
+}
+void link_clicked(GtkWidget * widget, GtkLabel * mywin)
+{
+    printf("url: %s\n",gtk_label_get_current_uri(GTK_LABEL(widget)));
+void
+link_clicked(GtkWidget * widget, GtkLabel * mywin)
+{
+    printf("url: %s\n", gtk_label_get_current_uri(GTK_LABEL(widget)));
     gtk_main_quit();
     exit(0);
+}
+void update_progressbar()
+{
+    gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(progress), current_number/100.0);
+    if(current_number < 100.0) {
+        if(yes)
+void
+update_progressbar()
+{
+    gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(progress),
+                                  current_number / 100.0);
+    if (current_number < 100.0) {
+        if (yes)
             gtk_widget_set_sensitive(yes, FALSE);
     } else {
         if(auto_close == TRUE)
+        if (auto_close == TRUE)
             yes_clicked(NULL, NULL);
         if(yes) {
+        if (yes) {
             gtk_widget_set_sensitive(yes, TRUE);
             gtk_widget_grab_focus(yes);
 …
+}
+void update_progressbar_from_channel(GIOChannel * channel)
+void
+update_progressbar_from_channel(GIOChannel * channel)
+{
     GString *buf;
 …
+}
+void usage(char * progname) {
+    printf("Usage: %s --message|--question|--progress [mode specific options] \"message\"\n", progname);
+void
+usage(char *progname)
+{
+    printf
+        ("Usage: %s --message|--question|--progress [mode specific options] \"message\"\n",
+         progname);
     printf("Progress mode options: --auto-close\n");
     exit(1);
 …
 #define USAGE() usage(argv[0])
+int main(int argc, char ** argv){
+    GtkWidget *mywin, *vbox, *hbox, *label, *spacer, *big_hbox, *ospacer, *o2spacer;
+int
+main(int argc, char **argv)
+{
+    GtkWidget *mywin, *vbox, *hbox, *label, *spacer, *big_hbox, *ospacer,
+        *o2spacer;
     int mode;
     int retval;
     char * message;
+    char *message;
     int has_no_button, has_yes_button;
     mode = NOTHING;
 …
     auto_close = FALSE;
     setlocale (LC_ALL, "");
     bindtextdomain (GETTEXT_PACKAGE, LOCALE_DIR);
     bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
     textdomain (GETTEXT_PACKAGE);
+    setlocale(LC_ALL, "");
+    bindtextdomain(GETTEXT_PACKAGE, LOCALE_DIR);
+    bind_textdomain_codeset(GETTEXT_PACKAGE, "UTF-8");
+    textdomain(GETTEXT_PACKAGE);
     // Option processing
 …
         {"progress", 0, 0, PROGRESS},
         {"auto-close", 0, 0, AUTO_CLOSE_OPTION},
         {0,0,0,0}
+        {0, 0, 0, 0}
     };
     while(1) {
+    while (1) {
         retval = getopt_long(argc, argv, "", longopts, NULL);
         if(retval == -1)
             break;
         switch(retval) {
+        if (retval == -1)
+            break;
+        switch (retval) {
         case MESSAGE:
         case QUESTION:
         case PROGRESS:
             if(mode != NOTHING)
+            if (mode != NOTHING)
                 USAGE();
             mode = retval;
 …
+        }
+    }
     if(mode == NOTHING)
+    if (mode == NOTHING)
         USAGE();
     if((argc - optind) != 1)
+    if ((argc - optind) != 1)
         USAGE();
     if(auto_close == TRUE && mode != PROGRESS)
+    if (auto_close == TRUE && mode != PROGRESS)
         USAGE();
     message = argv[optind];
     switch(mode) {
+    switch (mode) {
     case MESSAGE:
         has_no_button = FALSE;
 …
         break;
     case PROGRESS:
         if(auto_close == TRUE)
+        if (auto_close == TRUE)
             has_yes_button = FALSE;
         break;
 …
     // Theme
     char * ldm_theme;
     gchar * ldm_gtkrc;
+    char *ldm_theme;
+    gchar *ldm_gtkrc;
     ldm_theme = getenv("LDM_THEME");
+    if (ldm_theme)
+    {
+        if(*ldm_theme == '/')
+    if (ldm_theme) {
+        if (*ldm_theme == '/')
             ldm_gtkrc = g_strconcat(ldm_theme, "/greeter-gtkrc", NULL);
         else
+            ldm_gtkrc = g_strconcat(LDM_THEME_DIR, ldm_theme, "/greeter-gtkrc", NULL);
+            ldm_gtkrc =
+                g_strconcat(LDM_THEME_DIR, ldm_theme, "/greeter-gtkrc",
+                            NULL);
     } else
+        ldm_gtkrc = g_strconcat(LDM_THEME_DIR, "default", "/greeter-gtkrc", NULL);
+        ldm_gtkrc =
+            g_strconcat(LDM_THEME_DIR, "default", "/greeter-gtkrc", NULL);
     gtk_rc_add_default_file(ldm_gtkrc);
     g_free(ldm_gtkrc);
     // Finish setting up the basic stuff
     mywin = gtk_window_new(GTK_WINDOW_TOPLEVEL);
+    gdk_window_set_cursor(gdk_get_default_root_window(), gdk_cursor_new(GDK_LEFT_PTR));
+    gtk_window_set_title(GTK_WINDOW(mywin),"");
+    gtk_window_set_skip_taskbar_hint(GTK_WINDOW(mywin),TRUE);
+    gtk_window_set_resizable (GTK_WINDOW(mywin),0);
+    gdk_window_set_cursor(gdk_get_default_root_window(),
+                          gdk_cursor_new(GDK_LEFT_PTR));
+    gtk_window_set_title(GTK_WINDOW(mywin), "");
+    gtk_window_set_skip_taskbar_hint(GTK_WINDOW(mywin), TRUE);
+    gtk_window_set_resizable(GTK_WINDOW(mywin), 0);
     gtk_window_set_position(GTK_WINDOW(mywin), GTK_WIN_POS_CENTER_ALWAYS);
+    g_signal_connect(GTK_WINDOW(mywin), "destroy", G_CALLBACK(no_clicked), mywin);
+    g_signal_connect(GTK_WINDOW(mywin), "destroy", G_CALLBACK(no_clicked),
+                     mywin);
     hbox = gtk_hbox_new(FALSE, 3);
     spacer = gtk_label_new("");
 …
     // Make the yes button
     if(has_yes_button == TRUE) {
+    if (has_yes_button == TRUE) {
         yes = gtk_button_new_from_stock("gtk-ok");
+        g_signal_connect(G_OBJECT(yes), "clicked", G_CALLBACK(yes_clicked), mywin);
+        g_signal_connect(G_OBJECT(yes), "clicked", G_CALLBACK(yes_clicked),
+                         mywin);
         gtk_box_pack_start(GTK_BOX(hbox), yes, FALSE, FALSE, 0);
+    }
     // Make the no button
     if(has_no_button == TRUE) {
+    if (has_no_button == TRUE) {
         no = gtk_button_new_from_stock("gtk-cancel");
+        g_signal_connect(G_OBJECT(no), "clicked", G_CALLBACK(no_clicked), mywin);
+        g_signal_connect(G_OBJECT(no), "clicked", G_CALLBACK(no_clicked),
+                         mywin);
         gtk_box_pack_start(GTK_BOX(hbox), no, FALSE, FALSE, 0);
+    }
     // Create the label
     label = gtk_label_new(message);
 …
     gtk_label_set_line_wrap(GTK_LABEL(label), TRUE);
     gtk_window_set_default_size(GTK_WINDOW(mywin), 300, -1);
+    g_signal_connect(GTK_LABEL(label), "activate-link", G_CALLBACK(link_clicked), label);
+    g_signal_connect(GTK_LABEL(label), "activate-link",
+                     G_CALLBACK(link_clicked), label);
     vbox = gtk_vbox_new(FALSE, 0);
     GtkWidget * blah;
+    GtkWidget *blah;
     blah = gtk_alignment_new(0, 0.5, 0, 0);
     gtk_container_add(GTK_CONTAINER(blah), label);
     gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(blah), FALSE, FALSE, 10);
     if(mode == PROGRESS) {
+    if (mode == PROGRESS) {
         // Make the progress bar
         progress = gtk_progress_bar_new();
 …
         // Set up the hook that listens for input
         g_stdin = g_io_channel_unix_new(0);
         g_io_add_watch(g_stdin, G_IO_IN, (GIOFunc) update_progressbar_from_channel, g_stdin);
+    }
+        g_io_add_watch(g_stdin, G_IO_IN,
+                       (GIOFunc) update_progressbar_from_channel, g_stdin);
+    }
     // More basic GTK stuff
     gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);

ldm/trunk/fuentes/po/POTFILES.in

r516	r855
11	11	gtkgreet/langwin.c
12	12	gtkgreet/prefwin.c
13		~~rc.d/I01-halt-check~~
14	13	rc.d/I01-nbd-checkupdate
15	14	rc.d/S15-userLoginCheck

ldm/trunk/fuentes/rc.d/Makefile.am

r516	r855
1	1	EXTRA_DIST = $(rcd_DATA)
2	2	rcddir = $(datadir)/ldm/rc.d
3		rcd_DATA = I01-halt-check I01-nbd-checkupdate K99-ltsp-cluster P00-ltsp-cluster S01-setup-xauth S15-userLoginCheck S20-restrictUser S99-debug-terminal S99-ltsp-cluster X50-generate-env X50-dmrc-processing X50-printers X51-opengl X52-xcompmgr X95-run-x-session
	3	rcd_DATA = I01-nbd-checkupdate K99-ltsp-cluster P00-ltsp-cluster S01-setup-xauth S15-userLoginCheck S20-restrictUser S99-debug-terminal S99-ltsp-cluster X50-generate-env X50-dmrc-processing X50-printers X52-xcompmgr X95-run-x-session

ldm/trunk/fuentes/rc.d/X50-dmrc-processing

-                      r516
+                      r855
 # for code readability
+do_command(){
+    if boolean_is_true "$LTSP_FATCLIENT" ; then
+       eval "$@"
+    else
+       do_ssh "$@"
+    fi
+}
 do_ssh(){
     ssh -S "$LDM_SOCKET" "$LDM_SERVER" "$@" 2>/dev/null
 …
     if [ -n "$desktop" ]; then
         session_exec=$(do_ssh sed -n "s/^Exec=//p" "/usr/share/xsessions/$desktop.desktop")
+        session_exec=$(do_command sed -n "s/^Exec=//p" "/usr/share/xsessions/$desktop.desktop")
         if [ -n "$session_exec" ]; then
             LDM_SESSION="$session_exec"
 …
             ;;
         default|'')
+            ldm_session_from_desktop_file "$(get_dmrc_key "Session")" && break
+            ldm_session_from_desktop_file "$LDM_SESSION" && break
+            ldm_session_from_desktop_file "$(get_dmrc_key "Session")" ||
+                ldm_session_from_desktop_file "$LDM_SESSION" ||
+                true
             ;;
         *)
             LDM_SESSION="$LDM_SELECTED_SESSION"
             # If there's a corresponding xsession.desktop file, save its name to .dmrc
             dmrc_session=$(do_ssh "grep -lR '^Exec=$LDM_SESSION$' /usr/share/xsessions/ | sed -n '/\/usr\/share\/xsessions\/\(.*\)\.desktop/{s//\1/p;q}'")
+            dmrc_session=$(do_command "grep -lR '^Exec=$LDM_SESSION$' /usr/share/xsessions/ | sed -n '/\/usr\/share\/xsessions\/\(.*\)\.desktop/{s//\1/p;q}'")
             if [ -n "$dmrc_session" ]; then
                 put_dmrc_key "Session" "$dmrc_session"

ldm/trunk/fuentes/rc.d/X50-generate-env

-                      r516
+                      r855
 # -*- Shell-Script -*-
+# Set up the LTSP_CLIENT and LTSP_CLIENT_HOSTNAME environment variables.
+# We may not want to force set this:
+# Set up the LTSP_* environment variables.
+CLIENT_ENV="$CLIENT_ENV LTSP_CLIENT=$LDMINFO_IPADDR LTSP_CLIENT_HOSTNAME=$(hostname)"
+test -n "$LTSP_CLIENT_MAC" && CLIENT_ENV="$CLIENT_ENV LTSP_CLIENT_MAC=$LTSP_CLIENT_MAC"
+if boolean_is_true "$LTSP_FATCLIENT"; then
+    CLIENT_ENV="$CLIENT_ENV LTSP_FATCLIENT=$LTSP_FATCLIENT"
+fi
+CLIENT_ENV="$CLIENT_ENV LTSP_CLIENT=$LDMINFO_IPADDR LTSP_CLIENT_HOSTNAME=$(hostname)"
+test -n "$LTSP_FATCLIENT" && CLIENT_ENV="$CLIENT_ENV LTSP_FATCLIENT=$LTSP_FATCLIENT"
+test -n "$LTSP_CLIENT_MAC" && CLIENT_ENV="$CLIENT_ENV LTSP_CLIENT_MAC=$LTSP_CLIENT_MAC"
+# Some DEs *require* certain environment variables to be set by the DM,
+# notably DESKTOP_SESSION and XDG_CURRENT_DESKTOP. Let's try to set them here.
+# At this point, LDM_SESSION is either unset,
+# or it's set to the Exec= line of an xsession.desktop file,
+# or it's user-defined, in which case we don't need to set any vars.
+# do_command() was defined in X50-dmrc-processing.
+if [ -z "$LDM_SESSION" ]; then
+    default_session=$(basename "$(do_command "readlink -qs /etc/alternatives/x-session-manager")")
+    # If default_session is empty, we select the first one with an Exec= line
+    DESKTOP_SESSION=$(do_command "grep -lR '^Exec=$default_session' /usr/share/xsessions/ | sed -n '/\/usr\/share\/xsessions\/\(.*\)\.desktop/{s//\1/p;q}'")
+else
+    DESKTOP_SESSION=$(do_command "grep -lR '^Exec=$LDM_SESSION$' /usr/share/xsessions/ | sed -n '/\/usr\/share\/xsessions\/\(.*\)\.desktop/{s//\1/p;q}'")
+fi
+if [ -n "$DESKTOP_SESSION" ]; then
+    # We're setting the default LDM_SESSION instead of leaving it empty,
+    # only as a workaround for LP #1457730.
+    LDM_SESSION=$(do_command "sed -n 's/^Exec=//p' '/usr/share/xsessions/$DESKTOP_SESSION.desktop'")
+    # Match the deprecated X-LightDM-DesktopName and the newer DesktopNames.
+    XDG_CURRENT_DESKTOP=$(do_command "sed -n 's/^[^=]*DesktopName[^=]*=//p' '/usr/share/xsessions/$DESKTOP_SESSION.desktop'")
+    if [ -z "$XDG_CURRENT_DESKTOP" ]; then
+        XDG_CURRENT_DESKTOP=$(do_command "sed -n 's/^Name=//p' '/usr/share/xsessions/$DESKTOP_SESSION.desktop'")
+    fi
+    # DesktopNames is separated by ";" while XDG_CURRENT_DESKTOP by ":".
+    XDG_CURRENT_DESKTOP=$(echo "${XDG_CURRENT_DESKTOP%;}" | tr ';' ':')
+fi
+test -n "$DESKTOP_SESSION" && CLIENT_ENV="$CLIENT_ENV DESKTOP_SESSION='$DESKTOP_SESSION'"
+test -n "$XDG_CURRENT_DESKTOP" && CLIENT_ENV="$CLIENT_ENV XDG_CURRENT_DESKTOP='$XDG_CURRENT_DESKTOP'"
 export CLIENT_ENV
 # Set our language, if a different one is picked.
+if [ -z "$LDM_LANGUAGE" ]; then
     LDM_LANGUAGE=$LANG
+if [ -n "$LDM_LANGUAGE" ]; then
+    MY_LANG="LANG=$LDM_LANGUAGE"
+    export MY_LANG
 fi
 …
 # Set the DISPLAY env, if not running over encrypted ssh
 if boolean_is_true "$LDM_DIRECTX"; then
     MY_DISP="DISPLAY=${LDMINFO_IPADDR}${DISPLAY}"
 …
 # Handle sound
 if boolean_is_true "$SOUND"; then
     if [ -z "$SOUND_DAEMON" ]; then

ldm/trunk/fuentes/screen.d/ldm

-                      r516
+                      r855
 fi
+if [ -x /usr/share/ltsp/xinitrc ]; then
+    xinitrc=/usr/share/ltsp/xinitrc
+if boolean_is_true "$LDM_DIRECTX" ; then
+    if [ $({ echo "1.17"; X -version 2>&1 | sed -n 's/X.Org X Server //p';} | sort -V | head -n 1) = "1.17" ]; then
+        # Xorg after 1.17 needs `-listen tcp`, see
+        # http://cgit.freedesktop.org/xorg/xserver/commit/?id=cc59be38b7eff52a1d003b390f2994c73ee0b3e9
+        X_ARGS="-listen tcp $X_ARGS"
+    fi
+else
+    X_ARGS="-nolisten tcp $X_ARGS"
 fi
+xinitrc=/usr/share/ltsp/xinitrc

ldm/trunk/fuentes/share/ldm-script.in

r516	r855
50	50
51	51	for SCRIPT in $(find -L $RCDIRS -type f -name "$SCRIPTS" -printf '%f\n' \|
52		tr ' ' '\n' \| egrep ^[~~0-9a-zA-Z~~_\-]*$ \| sort -u)
	52	tr ' ' '\n' \| egrep ^[[:alnum:]_\-]*$ \| sort -u)
53	53	do
54	54	# only source the first instance of the script found

ldm/trunk/fuentes/src/ldm.c

-                      r516
+                      r855
  *  Setting up LDM env. variables
  */
+void get_ldm_env() {
+void
+get_ldm_env()
+{
     gchar *greeter_path, *wm_path;
 …
         greeter_path = g_strdup("ldmgtkgreet");
+    if(greeter_path[0] != '/') {
+        ldm.greeter_prog = g_strjoin("/", LDM_EXEC_DIR, greeter_path, NULL);
+    if (greeter_path[0] != '/') {
+        ldm.greeter_prog =
+            g_strjoin("/", LDM_EXEC_DIR, greeter_path, NULL);
         g_free(greeter_path);
     } else {
 …
     wm_path = g_strdup(getenv("LDM_WINMANAGER"));
     if(!wm_path)
+    if (!wm_path)
         wm_path = g_strdup("wwm");
     if(wm_path[0] != '/') {
+    if (wm_path[0] != '/') {
         ldm.wm_prog = g_strjoin("/", LDM_EXEC_DIR, wm_path, NULL);
         g_free(wm_path);
 …
  * main entry point
  */
+int main(int argc, char *argv[]) {
+int
+main(int argc, char *argv[])
+{
     /* decls */
     gchar *auth_plugin = NULL;
 …
     /* Init log settings */
+    log_init(ldm_getenv_bool("LDM_SYSLOG"),ldm_getenv_int("LDM_LOGLEVEL",-1));
+    log_init(ldm_getenv_bool("LDM_SYSLOG"),
+             ldm_getenv_int("LDM_LOGLEVEL", -1));
 #ifdef ENABLE_NLS
     setlocale (LC_ALL, "");
     bindtextdomain (GETTEXT_PACKAGE, LOCALE_DIR);
     bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
     textdomain (GETTEXT_PACKAGE);
+    setlocale(LC_ALL, "");
+    bindtextdomain(GETTEXT_PACKAGE, LOCALE_DIR);
+    bind_textdomain_codeset(GETTEXT_PACKAGE, "UTF-8");
+    textdomain(GETTEXT_PACKAGE);
 #endif
 …
     sigemptyset(&action.sa_mask);
     action.sa_flags = SA_SIGINFO;
     sigaction (SIGCHLD, &action, NULL);
+    sigaction(SIGCHLD, &action, NULL);
     /*
 …
     bzero(&ldm, sizeof ldm);
     ldm.pid = getpid();  /* Get our pid, to use in the command_socket */
+    ldm.pid = getpid();                          /* Get our pid, to use in the command_socket */
     ldm.display = g_strdup(getenv("DISPLAY"));
 …
      */
     get_ipaddr();
+    log_entry("ldm",6,"started on client with IP address: %s", ldm.ipaddr);
+    log_entry("ldm", 6, "started on client with IP address: %s",
+              ldm.ipaddr);
     /*
 …
      * Load plugins
      */
     if(ldm_load_plugins())
         log_entry("ldm",3,"unable to load plugins");
+    if (ldm_load_plugins())
+        log_entry("ldm", 3, "unable to load plugins");
     /*
      * Begin running display manager
      */
     log_entry("ldm",6,"calling rc.d init scripts");
     rc_files("init");                      /* Execute any rc files */
+    log_entry("ldm", 6, "calling rc.d init scripts");
+    rc_files("init");                            /* Execute any rc files */
     if (!ldm.autologin) {
 …
         gint rfd, wfd, rfd2, wfd2;
         log_entry("ldm",7,"spawning window manager: %s", ldm.wm_prog);
+        log_entry("ldm", 7, "spawning window manager: %s", ldm.wm_prog);
         ldm.wmpid = ldm_spawn(ldm.wm_prog, &rfd2, &wfd2, NULL);
         log_entry("ldm",7,"spawning greeter: %s", ldm.greeter_prog);
+        log_entry("ldm", 7, "spawning greeter: %s", ldm.greeter_prog);
         ldm.greeterpid = ldm_spawn(ldm.greeter_prog, &rfd, &wfd, NULL);
         set_greeter_pid(ldm.greeterpid);
 …
             /* allow choosing backend */
             backends = g_strjoinv("|", ldm_get_plugins());
+            cmd = g_strconcat("pref choice;backend;Authentication Backend;Select _Backend ...;session;",
+                              backends, "\n", NULL);
+            if(ask_greeter(cmd))
+            cmd =
+                g_strconcat
+                ("pref choice;backend;Authentication Backend;Select _Backend ...;session;",
+                 backends, "\n", NULL);
+            if (ask_greeter(cmd))
                 die("ldm", "%s from greeter failed", cmd);
             g_free(backends);
 …
             /* Init plugin */
             set_current_plugin(auth_plugin);
+            log_entry("ldm",6,"authenticating with backend: %s", auth_plugin);
+            log_entry("ldm", 6, "authenticating with backend: %s",
+                      auth_plugin);
             ldm_setup_plugin();
         } while (ldm_auth_plugin());
 …
         set_current_plugin(auth_plugin);
+        log_entry("ldm",6,"guest authenticating with backend: %s", auth_plugin);
+        log_entry("ldm", 6, "guest authenticating with backend: %s",
+                  auth_plugin);
         ldm_setup_plugin();
 …
      */
     log_entry("ldm",6,"X session ended");
     log_entry("ldm",6,"calling rc.d stop scripts");
     rc_files("stop");                       /* Execute any rc files */
+    log_entry("ldm", 6, "X session ended");
+    log_entry("ldm", 6, "calling rc.d stop scripts");
+    rc_files("stop");                            /* Execute any rc files */
     /* Closing plugin */
 …
     g_free(ldm.control_socket);
     g_free(ldm.ipaddr);
     g_list_foreach(host_list, (GFunc)g_free, NULL);
+    g_list_foreach(host_list, (GFunc) g_free, NULL);
     g_list_free(host_list);

ldm/trunk/fuentes/src/ldmgreetercomm.c

-                      r516
+                      r855
  * set_greeter_pid
  */
+void set_greeter_pid(GPid p) {
+void
+set_greeter_pid(GPid p)
+{
     greeterpid = p;
+}
 …
  * set_greeter_read_channel
  */
+void set_greeter_read_channel(GIOChannel *gr) {
+void
+set_greeter_read_channel(GIOChannel * gr)
+{
     greeterr = gr;
+}
 …
  * set_greeter_read_channel
  */
+void set_greeter_write_channel(GIOChannel *gw) {
+void
+set_greeter_write_channel(GIOChannel * gw)
+{
     greeterw = gw;
+}
 …
  *  Return 1 if fails, else 0
  */
+int ask_greeter(gchar *cmd) {
+int
+ask_greeter(gchar * cmd)
+{
     /* Write command to io channel of the greeter */
     GError *ge = NULL;
+    if(g_io_channel_write_chars(greeterw, cmd, -1, NULL, &ge) != G_IO_STATUS_NORMAL) {
+        log_entry("ldm",4,"%s", ge->message);
+    if (g_io_channel_write_chars(greeterw, cmd, -1, NULL, &ge) !=
+        G_IO_STATUS_NORMAL) {
+        log_entry("ldm", 4, "%s", ge->message);
         return 1;
+    }
     /* Flush buffer */
     if(g_io_channel_flush(greeterw, &ge) != G_IO_STATUS_NORMAL) {
         log_entry("ldm",4,"%s", ge->message);
+    if (g_io_channel_flush(greeterw, &ge) != G_IO_STATUS_NORMAL) {
+        log_entry("ldm", 4, "%s", ge->message);
         return 1;
+    }
 …
  *      s_ldm -- struct ldm_info
  */
+void close_greeter() {
+void
+close_greeter()
+{
     gboolean failed = 0;
     gchar *cmd = "quit\n";
 …
         return;
     if(ask_greeter(cmd))
+    if (ask_greeter(cmd))
         failed = 1;
     if(failed) {
         log_entry("ldm",3,"quit command failed. SIGTERM to greeter");
         if(kill(greeterpid, SIGTERM) < 0) {
             log_entry("ldm",3,"SIGTERM failed. SIGKILL to greeter");
+    if (failed) {
+        log_entry("ldm", 3, "quit command failed. SIGTERM to greeter");
+        if (kill(greeterpid, SIGTERM) < 0) {
+            log_entry("ldm", 3, "SIGTERM failed. SIGKILL to greeter");
             kill(greeterpid, SIGKILL);
+        }
 …
  *  Ask greeter to print a message to UI
  */
+int set_message(gchar *msg) {
+int
+set_message(gchar * msg)
+{
     gchar *cmd;
 …
     cmd = g_strconcat("msg ", msg, "\n", NULL);
     if(ask_greeter(cmd))
+    if (ask_greeter(cmd))
         return 1;
     g_free(cmd);
 …
  *  Return 1 if fails, else 0 and buffer with data in
  */
+int listen_greeter(gchar **buffer, gsize *buflen, gsize *end) {
+int
+listen_greeter(gchar ** buffer, gsize * buflen, gsize * end)
+{
     while (1) {
         /* Reads data from I/O channel of the greeter */
         GError *ge = NULL;
+        if(g_io_channel_read_line(greeterr, buffer, buflen, end, &ge) != G_IO_STATUS_NORMAL) {
+            log_entry("ldm",3,"%s", ge->message);
+        if (g_io_channel_read_line(greeterr, buffer, buflen, end, &ge) !=
+            G_IO_STATUS_NORMAL) {
+            log_entry("ldm", 3, "%s", ge->message);
             return 1;
+        }
         g_strstrip(*buffer);
         log_entry("ldm",7,"Got command: %s",*buffer);
+        log_entry("ldm", 7, "Got command: %s", *buffer);
         /* handle callbacks */
 …
  *      buffer -- buffer to write to answer
  */
+gchar *ask_value_greeter(gchar *cmd) {
+gchar *
+ask_value_greeter(gchar * cmd)
+{
     gsize len, end;
     gchar *buffer;
     if(ask_greeter(cmd))
+    if (ask_greeter(cmd))
         die("ldm", "%s from greeter failed", cmd);
     if(listen_greeter(&buffer, &len, &end))
+    if (listen_greeter(&buffer, &len, &end))
         die("ldm", "%s from greeter failed", cmd);

ldm/trunk/fuentes/src/ldminfo.c

-                      r516
+                      r855
 static GHashTable *ldminfo_hash = NULL;
+static void generate_hash_table(void) {
+static void
+generate_hash_table(void)
+{
     char buffer[1024];
+    FILE * file;
+    char ** ret;
+    display_names = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free);
+    FILE *file;
+    char **ret;
+    display_names =
+        g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free);
     file = fopen(RC_DIR "/locales", "r");
     if(file == NULL) {
+    if (file == NULL) {
         return;
+    }
     while(fgets(buffer, sizeof(buffer), file) != NULL) {
+    while (fgets(buffer, sizeof(buffer), file) != NULL) {
         ret = g_strsplit(buffer, " ", 2);
+        g_hash_table_insert(display_names, g_strdup(ret[0]), g_strdup(g_strchomp(ret[1])));
+        g_hash_table_insert(display_names, g_strdup(ret[0]),
+                            g_strdup(g_strchomp(ret[1])));
         g_strfreev(ret);
+    }
 …
+}
+static gchar * get_display_name(gchar * locale) {
+    gchar * compare_to;
+    char ** ret;
+    gchar * result;
+static gchar *
+get_display_name(gchar * locale)
+{
+    gchar *compare_to;
+    char **ret;
+    gchar *result;
     ret = g_strsplit(locale, ".", 2);
     compare_to = g_strdup(ret[0]);
     g_strfreev(ret);
     if(compare_to == NULL) {
+    if (compare_to == NULL) {
         return g_strdup(locale);
+    }
     result = g_hash_table_lookup(display_names, compare_to);
     if(result == NULL) {
+    if (result == NULL) {
         result = g_strdup(locale);
+    }
 …
  *  ldminfo struct freed
  */
+void ldminfo_free() {
+void
+ldminfo_free()
+{
     g_hash_table_destroy(ldminfo_hash);
+}
 …
  * ldminfo_lookup
  */
+ldminfo *ldminfo_lookup(gconstpointer key) {
+ldminfo *
+ldminfo_lookup(gconstpointer key)
+{
     return g_hash_table_lookup(ldminfo_hash, key);
+}
 …
  * ldminfo_size
  */
+int ldminfo_size() {
+int
+ldminfo_size()
+{
     return g_hash_table_size(ldminfo_hash);
+}
 …
  * ldminfo_init
  */
+void ldminfo_init(GList **host_list, const char *ldm_server) {
+void
+ldminfo_init(GList ** host_list, const char *ldm_server)
+{
     char **hosts_char = NULL;
     ldminfo *ldm_host_info = NULL;
 …
     /* Static hash table */
     ldminfo_hash = g_hash_table_new_full(g_str_hash, g_str_equal,
                                           g_free, g_free);
+                                         g_free, g_free);
     hosts_char = g_strsplit(ldm_server, " ", -1);
 …
  * etc. Things like nc -z hostname ssh, etc.
  */
+void _ldminfo_query_one(const char *hostname, ldminfo * ldm_host_info) {
+void
+_ldminfo_query_one(const char *hostname, ldminfo * ldm_host_info)
+{
     int filedes, numbytes;
     char buf[MAXBUFSIZE];
 …
  * split string by line and then construct the ldm_host_info
  */
+void _ldminfo_parse_string(const char *s, ldminfo * ldm_host_info) {
+void
+_ldminfo_parse_string(const char *s, ldminfo * ldm_host_info)
+{
     char **lines = NULL;
     int i;
 …
                 g_list_append(ldm_host_info->languages, g_strdup(val[1]));
             ldm_host_info->language_names =
+                g_list_append(ldm_host_info->language_names, get_display_name(val[1]));
+            g_strfreev(val);
+        } else if (!g_ascii_strncasecmp(lines[i], "session:", 8) && !g_strstr_len(s, -1, "session-with-name")) {
+                g_list_append(ldm_host_info->language_names,
+                              get_display_name(val[1]));
+            g_strfreev(val);
+        } else if (!g_ascii_strncasecmp(lines[i], "session:", 8)
+                   && !g_strstr_len(s, -1, "session-with-name")) {
             gchar **val;
             gchar *name;
             val = g_strsplit(lines[i], ":", 2);
             name = g_strrstr(val[1], "/");
             if(name) {
+            if (name) {
                 name++;
             } else {
                 name = val[1];
+            }
+            ldm_host_info->sessions = g_list_append(ldm_host_info->sessions, g_strdup(val[1]));
+            ldm_host_info->session_names = g_list_append(ldm_host_info->session_names, g_strdup(name));
+            ldm_host_info->sessions =
+                g_list_append(ldm_host_info->sessions, g_strdup(val[1]));
+            ldm_host_info->session_names =
+                g_list_append(ldm_host_info->session_names,
+                              g_strdup(name));
             g_strfreev(val);
         } else if (!g_ascii_strncasecmp(lines[i], "session-with-name:", 8)) {
             gchar **val;
             val = g_strsplit(lines[i], ":", 3);
+            ldm_host_info->sessions = g_list_append(ldm_host_info->sessions, g_strdup(val[2]));
+            ldm_host_info->session_names = g_list_append(ldm_host_info->session_names, g_strdup(val[1]));
+            ldm_host_info->sessions =
+                g_list_append(ldm_host_info->sessions, g_strdup(val[2]));
+            ldm_host_info->session_names =
+                g_list_append(ldm_host_info->session_names,
+                              g_strdup(val[1]));
             g_strfreev(val);
         } else if (!g_ascii_strncasecmp(lines[i], "rating:", 7)) {
 …
  *      name -- env. variable name
  */
+int ldm_getenv_bool(const char *name) {
+int
+ldm_getenv_bool(const char *name)
+{
     char *env = getenv(name);
     if(env) {
+    if (env) {
         if (*env == 'y' || *env == 't' || *env == 'T' || *env == 'Y')
             return 1;
 …
 /*
+ * ldm_getenv_bool_default
+ *  Return if env variable is set to true or false
+ *      name -- env. variable name
+ *      default_value -- int to return as default [0,1]
+ */
+int
+ldm_getenv_bool_default(const char *name, const int default_value)
+{
+    char *env = getenv(name);
+    if (env != NULL) {
+        if (*env == 'y' || *env == 't' || *env == 'T' || *env == 'Y') {
+            return 1;
+        } else {
+            return 0;
+        }
+    }
+    return default_value;
+}
+/*
  * ldm_getenv_int
  *  Return an int, will return default_value if not set
  */
+int ldm_getenv_int(const char *name,int default_value) {
+int
+ldm_getenv_int(const char *name, int default_value)
+{
     char *env = getenv(name);
     if(env) {
+    if (env) {
         return atoi(env);
+    }
     return default_value;
+}
+/*
+ * ldm_getenv_str_default
+ *  Return a string, will return default_value if not set
+ *  No malloc()s, caller should strdup the result if needed.
+ */
+const char *
+ldm_getenv_str_default(const char *name, const char *default_value)
+{
+    char *env = getenv(name);
+    if (env) {
+        return env;
+    }
+    return default_value;
+}

ldm/trunk/fuentes/src/ldminfo.h

-                      r516
+                      r855
 int ldm_getenv_bool(const char *name);
+int ldm_getenv_bool_default(const char *name, const int default_value);
 int ldm_getenv_int(const char *name, int default_value);
+const char *ldm_getenv_str_default(const char *name, const char *default_value);
 ldminfo *ldminfo_lookup(gconstpointer key);

ldm/trunk/fuentes/src/ldmplugin.c

-                      r516
+                      r855
 #include "logging.h"
 GTree* plugin_list = NULL;
 gchar** plugin_names = NULL;
+GTree *plugin_list = NULL;
+gchar **plugin_names = NULL;
 static jmp_buf auth_jmp_buf;
+static gchar* current_plugin = NULL;
+static int g_strcmp(gconstpointer a, gconstpointer b) {
+    return strcmp((char*)a, (char*)b);
+static gchar *current_plugin = NULL;
+static int
+g_strcmp(gconstpointer a, gconstpointer b)
+{
+    return strcmp((char *) a, (char *) b);
+}
 …
  *  Set current plugin name
  */
+void set_current_plugin(char *plug_name) {
+void
+set_current_plugin(char *plug_name)
+{
     current_plugin = plug_name;
+}
 …
  *  Iterate over plugin_list and start plugin
  */
+void ldm_start_plugin() {
+    LdmBackend *desc = (LdmBackend*) g_tree_lookup(plugin_list, current_plugin);
+    if(desc->start_cb)
+void
+ldm_start_plugin()
+{
+    LdmBackend *desc =
+        (LdmBackend *) g_tree_lookup(plugin_list, current_plugin);
+    if (desc->start_cb)
         desc->start_cb();
+}
 …
  *  Iterate over plugin_list and close plugin
  */
+void ldm_close_plugin() {
+    LdmBackend *desc = (LdmBackend*) g_tree_lookup(plugin_list, current_plugin);
+    if(desc->clean_cb)
+void
+ldm_close_plugin()
+{
+    LdmBackend *desc =
+        (LdmBackend *) g_tree_lookup(plugin_list, current_plugin);
+    if (desc->clean_cb)
         desc->clean_cb();
+}
 …
  *  Call setup callback function of plugin
  */
+void ldm_setup_plugin() {
+    log_entry("ldm",7,"setting up plugin: %s", current_plugin);
+    LdmBackend *desc = (LdmBackend*) g_tree_lookup(plugin_list, current_plugin);
+    if(desc->init_cb)
+void
+ldm_setup_plugin()
+{
+    log_entry("ldm", 7, "setting up plugin: %s", current_plugin);
+    LdmBackend *desc =
+        (LdmBackend *) g_tree_lookup(plugin_list, current_plugin);
+    if (desc->init_cb)
         desc->init_cb();
+}
 …
  *  Call setup guest authentication values of plugin
  */
+void ldm_guest_auth_plugin() {
+    log_entry("ldm",7,"guest auth plugin: %s", current_plugin);
+    LdmBackend *desc = (LdmBackend*) g_tree_lookup(plugin_list, current_plugin);
+    if(desc->guest_cb)
+void
+ldm_guest_auth_plugin()
+{
+    log_entry("ldm", 7, "guest auth plugin: %s", current_plugin);
+    LdmBackend *desc =
+        (LdmBackend *) g_tree_lookup(plugin_list, current_plugin);
+    if (desc->guest_cb)
         desc->guest_cb();
+}
 …
  *  Returns 0 on success, 1 otherwise
  */
+int ldm_auth_plugin() {
+    LdmBackend *desc = (LdmBackend*) g_tree_lookup(plugin_list, current_plugin);
+int
+ldm_auth_plugin()
+{
+    LdmBackend *desc =
+        (LdmBackend *) g_tree_lookup(plugin_list, current_plugin);
     if (desc->guest_cb)
 …
     switch (setjmp(auth_jmp_buf)) {
         case AUTH_EXC_NONE:
             if(desc->auth_cb)
                 desc->auth_cb();
             return 0;
         case AUTH_EXC_RELOAD_BACKEND:
             ldm_close_plugin();
             log_entry("ldm",7,"reloading backend");
             return 1;
         case AUTH_EXC_GUEST:
             if(desc->guest_cb)
                 desc->guest_cb();
             return 0;
+    case AUTH_EXC_NONE:
+        if (desc->auth_cb)
+            desc->auth_cb();
+        return 0;
+    case AUTH_EXC_RELOAD_BACKEND:
+        ldm_close_plugin();
+        log_entry("ldm", 7, "reloading backend");
+        return 1;
+    case AUTH_EXC_GUEST:
+        if (desc->guest_cb)
+            desc->guest_cb();
+        return 0;
+    }
     return 1;
 …
  */
 void __attribute__ ((visibility("default")))
+ldm_init_plugin(LdmBackend* descriptor) {
+    gchar** new_plugin_names;
+    ldm_init_plugin(LdmBackend * descriptor)
+{
+    gchar **new_plugin_names;
     int plugin_names_len;
     plugin_names_len = g_strv_length(plugin_names);
     new_plugin_names = g_realloc(plugin_names,
                                  (plugin_names_len+1)*sizeof(gchar*));
+                                 (plugin_names_len + 1) * sizeof(gchar *));
     if (new_plugin_names != plugin_names) {
         g_free(plugin_names);
 …
+    }
     plugin_names[plugin_names_len] = g_strdup(descriptor->name);
     plugin_names[plugin_names_len+1] = NULL;
+    plugin_names[plugin_names_len + 1] = NULL;
     g_tree_replace(plugin_list, descriptor->name, descriptor);
     log_entry("ldm",7,"%s initialized", descriptor->name);
+    log_entry("ldm", 7, "%s initialized", descriptor->name);
+}
 …
  *      path -- plugin path
  */
+void _load_plugin(const char *path) {
+void
+_load_plugin(const char *path)
+{
     void *handle = dlopen(path, RTLD_LAZY);
     if (handle) {
         log_entry("ldm",7,"loaded %s", path);
+        log_entry("ldm", 7, "loaded %s", path);
         return;
+    }
     log_entry("ldm",4,"%s: Invalid LDM plugin %s", dlerror(), path);
+    log_entry("ldm", 4, "%s: Invalid LDM plugin %s", dlerror(), path);
+}
 …
  *  Load all plugins at LDM_PLUG_DIR
  */
+int ldm_load_plugins() {
+int
+ldm_load_plugins()
+{
     plugin_list = g_tree_new(g_strcmp);
     g_tree_ref(plugin_list);
     plugin_names = g_malloc0(sizeof(gchar*));
     DIR* plugin_dir = opendir(LDM_PLUG_DIR);
+    plugin_names = g_malloc0(sizeof(gchar *));
+    DIR *plugin_dir = opendir(LDM_PLUG_DIR);
     if (!plugin_dir) {
         log_entry("ldm",3,"unable to open plugin dir: %s", LDM_PLUG_DIR);
+        log_entry("ldm", 3, "unable to open plugin dir: %s", LDM_PLUG_DIR);
         return 1;
+    }
+    struct dirent* entry;
+    while ( (entry = readdir(plugin_dir)) ) {
+        if ((entry->d_type == DT_REG || entry->d_type == DT_UNKNOWN) && (strstr(entry->d_name, ".so") != NULL)) {
+            int name_len = strlen(entry->d_name)+strlen(LDM_PLUG_DIR)+2;
+            char* plug_name = (char *) malloc(name_len);
+            snprintf(plug_name, name_len, "%s/%s", LDM_PLUG_DIR, entry->d_name);
+            log_entry("ldm",7,"loading: %s", plug_name);
+    struct dirent *entry;
+    while ((entry = readdir(plugin_dir))) {
+        if ((entry->d_type == DT_REG || entry->d_type == DT_UNKNOWN)
+            && (strstr(entry->d_name, ".so") != NULL)) {
+            int name_len =
+                strlen(entry->d_name) + strlen(LDM_PLUG_DIR) + 2;
+            char *plug_name = (char *) malloc(name_len);
+            snprintf(plug_name, name_len, "%s/%s", LDM_PLUG_DIR,
+                     entry->d_name);
+            log_entry("ldm", 7, "loading: %s", plug_name);
             _load_plugin(plug_name);
 …
+    }
+    if (errno) perror(strerror(errno));
+    if (errno)
+        perror(strerror(errno));
     closedir(plugin_dir);
     return 0;
 …
  * error before retrying.
  */
+void ldm_raise_auth_except(LdmAuthException n) {
+void
+ldm_raise_auth_except(LdmAuthException n)
+{
     longjmp(auth_jmp_buf, n);
+}
+gchar** ldm_get_plugins() {
+gchar **
+ldm_get_plugins()
+{
     return plugin_names;
+}

ldm/trunk/fuentes/src/ldmutils.c

-                      r516
+                      r855
  * Run startup commands.
  */
+void rc_files(char *action) {
+void
+rc_files(char *action)
+{
     GPid rcpid;
     gchar *command;
+    command = g_strjoin(" ", "/bin/sh",  RC_DIR "/ldm-script", action, NULL);
+    command =
+        g_strjoin(" ", "/bin/sh", RC_DIR "/ldm-script", action, NULL);
     rcpid = ldm_spawn(command, NULL, NULL, NULL);
 …
  *  Get ip address of host
  */
+void get_ipaddr() {
+void
+get_ipaddr()
+{
     int numreqs = 10;
     struct ifconf ifc;
     struct ifreq *ifr;    /* netdevice(7) */
+    struct ifreq *ifr;          /* netdevice(7) */
     struct ifreq info;
     struct sockaddr_in *sa;
 …
     skfd = socket(PF_INET, SOCK_DGRAM, IPPROTO_IP);
     if (skfd < 0)
         die("ldm","socket");
+        die("ldm", "socket");
     /*
 …
     while (TRUE) {
         ifc.ifc_len = sizeof(struct ifreq) * numreqs;
         ifc.ifc_buf = (char *)realloc(ifc.ifc_buf, ifc.ifc_len);
+        ifc.ifc_buf = (char *) realloc(ifc.ifc_buf, ifc.ifc_len);
         if (ifc.ifc_buf == NULL)
             die("ldm","out of memory");
+            die("ldm", "out of memory");
         if (ioctl(skfd, SIOCGIFCONF, &ifc) < 0) {
             log_entry("ldm",4,"SIOCGIFCONF");
+            log_entry("ldm", 4, "SIOCGIFCONF");
             goto out;
+        }
         if (ifc.ifc_len == (int)sizeof(struct ifreq) * numreqs){
+        if (ifc.ifc_len == (int) sizeof(struct ifreq) * numreqs) {
             /* assume it overflowed and try again */
             numreqs += 10;
 …
         strcpy(info.ifr_name, ifr->ifr_name);
         if (ioctl(skfd, SIOCGIFFLAGS, &info) < 0) {
             log_entry("ldm",4,"SIOCGIFFLAGS");
+            log_entry("ldm", 4, "SIOCGIFFLAGS");
             goto out;
+        }
 …
+    }
 out:
+  out:
     if (ifc.ifc_buf)
         free(ifc.ifc_buf);
     if (n == ifc.ifc_len)
         die("ldm","no configured interface found");
+        die("ldm", "no configured interface found");
+}
 …
  * Execute commands.  Prints nice error message if failure.
  */
+GPid ldm_spawn(gchar *command, gint *rfd, gint *wfd,  GSpawnChildSetupFunc setup) {
+GPid
+ldm_spawn(gchar * command, gint * rfd, gint * wfd,
+          GSpawnChildSetupFunc setup)
+{
     GPid pid;
     GError *error = NULL;
 …
     gchar **argv = NULL;
     g_shell_parse_argv (command, &argc, &argv, NULL);
+    g_shell_parse_argv(command, &argc, &argv, NULL);
     if (!wfd)
         flags |= G_SPAWN_STDOUT_TO_DEV_NULL;
+    g_spawn_async_with_pipes (
+            NULL,             /* Working directory: inherit */
+            argv,             /* Arguments, null term */
+            NULL,             /* Environment, inherit from parent */
+            flags,            /* Flags, set above */
+            setup,            /* Child setup function: passed to us */
+            NULL,             /* No user data */
+            &pid,             /* child pid */
+            wfd,              /* Pointer to in file descriptor */
+            rfd,              /* Pointer to out file descriptor */
+            NULL,             /* No stderr */
+            &error);          /* GError handler */
+    g_spawn_async_with_pipes(NULL,               /* Working directory: inherit */
+                             argv,               /* Arguments, null term */
+                             NULL,               /* Environment, inherit from parent */
+                             flags,              /* Flags, set above */
+                             setup,              /* Child setup function: passed to us */
+                             NULL,               /* No user data */
+                             &pid,               /* child pid */
+                             wfd,                /* Pointer to in file descriptor */
+                             rfd,                /* Pointer to out file descriptor */
+                             NULL,               /* No stderr */
+                             &error);            /* GError handler */
     g_strfreev(argv);
     if (error) {
+        log_entry("ldm",3,"ldm_spawn failed to execute: %s", error->message);
+        log_entry("ldm", 3, "ldm_spawn failed to execute: %s",
+                  error->message);
     } else {
         log_entry("ldm",7,"ldm_spawn: pid = %d", pid);
+        log_entry("ldm", 7, "ldm_spawn: pid = %d", pid);
+    }
 …
  * ldm_wait
  */
+void handle_sigchld(int signo) {
+void
+handle_sigchld(int signo)
+{
     /* do nothing */
     child_exited = TRUE;
 …
  * wait for child process
  */
+void ldm_wait(GPid pid) {
+void
+ldm_wait(GPid pid)
+{
     siginfo_t info;
     log_entry("ldm",7,"waiting for process: %d", pid);
+    log_entry("ldm", 7, "waiting for process: %d", pid);
     do {
         int res;
         res = waitid (P_PID, pid, &info, WEXITED | WSTOPPED);
+        res = waitid(P_PID, pid, &info, WEXITED | WSTOPPED);
         if (res == -1) {
             int temp;
             temp = errno;
+            log_entry("ldm",4,"waitid returned an error: %s", strerror(errno));
+            if(temp == ECHILD) {
+            log_entry("ldm", 4, "waitid returned an error: %s",
+                      strerror(errno));
+            if (temp == ECHILD) {
                 break;
+            }
 …
                 break;
             } else {
+                log_entry("ldm",4,"unexpected terminated process, pid: %d",
+                        info.si_pid);
+                log_entry("ldm", 4,
+                          "unexpected terminated process, pid: %d",
+                          info.si_pid);
                 unexpected_child = TRUE;
+            }
 …
     if (info.si_code == CLD_EXITED) {
         log_entry("ldm",7,"process %d exited with status %d", info.si_pid,
                 WEXITSTATUS(info.si_status));
+        log_entry("ldm", 7, "process %d exited with status %d",
+                  info.si_pid, WEXITSTATUS(info.si_status));
     } else if (info.si_code == CLD_KILLED) {
         log_entry("ldm",7,"process %d killed by signal %d", info.si_pid,
                 info.si_status);
+        log_entry("ldm", 7, "process %d killed by signal %d", info.si_pid,
+                  info.si_status);
+    }
+}
 …
  *  Close window manager by SIGKILL
  */
+void close_wm() {
+void
+close_wm()
+{
     if (!(ldm.wmpid)) {
         return;
+    }
     log_entry("ldm",7,"closing window manager");
+    log_entry("ldm", 7, "closing window manager");
     if (kill(ldm.wmpid, SIGKILL) < 0) {
         log_entry("ldm",3,"sending SIGKILL to window manager failed");
+        log_entry("ldm", 3, "sending SIGKILL to window manager failed");
+    }
     ldm_wait(ldm.wmpid);
     ldm.wmpid = 0;
+}

ldm/trunk/fuentes/src/logging.c

-                      r516
+                      r855
  *  the boolean LDM_SYSLOG.
  */
+void log_init(int syslog, int level) {
+void
+log_init(int syslog, int level)
+{
     if (level < 0 || level > 7) {
         loglevel = LOGLEVEL;
+    }
+    else {
+    } else {
         loglevel = level;
+    }
 …
     if (syslog) {
         openlog("ldm", LOG_PID | LOG_NOWAIT, LOG_DAEMON);
+    }
+    else {
+    } else {
         logfile = fopen(LOGFILE, "a");
         if (!logfile) {
 …
             exit(1);
+        }
         setbuf(logfile, NULL);  /* unbuffered writes to the log file */
+        setbuf(logfile, NULL);                   /* unbuffered writes to the log file */
+    }
+}
 …
  *  Close logging and clean exit
  */
+void log_close() {
+void
+log_close()
+{
     if (logfile)
         fclose(logfile);
 …
  * log_entry: log messages to file or syslog
  */
+void log_entry(char *component, int level, const char *format, ...) {
+void
+log_entry(char *component, int level, const char *format, ...)
+{
     if (level < 0 || level > 7 || level > loglevel)
         return;
 …
         strftime(timestr, sizeof(timestr), "%b %e %H:%M:%S", ptr);
+        fprintf(logfile, "%s: [%s] %s: ", timestr, component, LOG_LEVEL_NAMES[level]);
+        fprintf(logfile, "%s: [%s] %s: ", timestr, component,
+                LOG_LEVEL_NAMES[level]);
         vfprintf(logfile, format, ap);
         fprintf(logfile, "\n");
 …
  *      msg -- log message
  */
+void die(char *component, const char *format, ...) {
+void
+die(char *component, const char *format, ...)
+{
     va_list ap;
     va_start(ap, format);

ldm/trunk/fuentes/src/plugin.c

-                      r516
+                      r855
  *  Ask the greeter to check autologin or get username
  */
+void get_userid(gchar **username) {
+void
+get_userid(gchar ** username)
+{
     gchar *cmd;
 …
  * get_passwd
  */
+void get_passwd(gchar **password) {
+void
+get_passwd(gchar ** password)
+{
     gchar *cmd;
+    cmd = g_strconcat("prompts <b>", _("Password"), "</b>\npasswd\n", NULL);
+    *password = (gchar*) ask_value_greeter(cmd);
+    cmd =
+        g_strconcat("prompts <b>", _("Password"), "</b>\npasswd\n", NULL);
+    *password = (gchar *) ask_value_greeter(cmd);
+    set_message(g_strconcat("<b>", _("Verifying password.  Please wait."), "</b>", NULL));
+    set_message(g_strconcat
+                ("<b>", _("Verifying password.  Please wait."), "</b>",
+                 NULL));
     g_free(cmd);
+}
 …
  * get_host
  */
+void get_host(gchar **server) {
+void
+get_host(gchar ** server)
+{
     gchar *cmd = "hostname\n";
     gchar *host;
     host = (gchar*) ask_value_greeter(cmd);
     if(g_ascii_strncasecmp(host, "None", 4)) {
         if(*server)
+    host = (gchar *) ask_value_greeter(cmd);
+    if (g_ascii_strncasecmp(host, "None", 4)) {
+        if (*server)
             g_free(*server);
         *server = host;
 …
  * get_language
  */
+void get_language(gchar **language) {
+void
+get_language(gchar ** language)
+{
     gchar *cmd = "language\n";
     gchar *lang;
     lang = (gchar*) ask_value_greeter(cmd);
+    lang = (gchar *) ask_value_greeter(cmd);
     if(g_ascii_strncasecmp(lang, "None", 4)) {
         if(*language)
+    if (g_ascii_strncasecmp(lang, "None", 4)) {
+        if (*language)
             g_free(*language);
         *language = lang;
 …
  * get_session
  */
+void get_session(gchar **session) {
+void
+get_session(gchar ** session)
+{
     gchar *cmd = "session\n";
     gchar *sess;
     sess = (gchar*) ask_value_greeter(cmd);
+    sess = (gchar *) ask_value_greeter(cmd);
     if (g_ascii_strncasecmp(sess, "None", 4)) {
 …
  * Return to variable xsession the LDM_XSESSION info
  */
+void __attribute__ ((visibility("default"))) get_Xsession(gchar **xsession, gconstpointer server) {
+void __attribute__ ((visibility("default"))) get_Xsession(gchar **
+                                                          xsession,
+                                                          gconstpointer
+                                                          server)
+{
     ldminfo *curr_host = NULL;
     gchar *tmp_xsess = NULL;
 …
     if (!tmp_xsess || strlen(tmp_xsess) == 0) {
         curr_host = ldminfo_lookup(server);
         if(curr_host) {
+        if (curr_host) {
             tmp_xsess = curr_host->xsession;
             if (!tmp_xsess || strlen(tmp_xsess) == 0) {
                 tmp_xsess = g_strdup(getenv("LDM_DEFAULT_XSESSION"));
                 if (!tmp_xsess || strlen(tmp_xsess) == 0)
                     die("ldm","no Xsession");
+                    die("ldm", "no Xsession");
+            }
+        }
 …
  * Then run xsession script
  */
+void __attribute__ ((visibility("default"))) set_session_env(gchar *xsession, gchar *session) {
+    if (g_strcmp0(session,"default") != 0 || getenv("LDM_SESSION") == NULL) {
+        log_entry("ldm",7,"Export LDM_SELECTED_SESSION to environment: \"%s\"", session);
+void __attribute__ ((visibility("default"))) set_session_env(gchar *
+                                                             xsession,
+                                                             gchar *
+                                                             session)
+{
+    if (g_strcmp0(session, "default") != 0
+        || getenv("LDM_SESSION") == NULL) {
+        log_entry("ldm", 7,
+                  "Export LDM_SELECTED_SESSION to environment: \"%s\"",
+                  session);
         setenv("LDM_SELECTED_SESSION", session, 1);
+    }
+    else {
+        log_entry("ldm",7,"Using existing LDM_SESSION from environment: \"%s\"", getenv("LDM_SESSION"));
+    } else {
+        log_entry("ldm", 7,
+                  "Using existing LDM_SESSION from environment: \"%s\"",
+                  getenv("LDM_SESSION"));
+    }
 …
  *  Check for LTSP-Cluster. If true, contact loadbalancer for an IP
  */
+void __attribute__ ((visibility("default"))) get_ltsp_cfg(gchar **server) {
+void __attribute__ ((visibility("default"))) get_ltsp_cfg(gchar ** server)
+{
     /* Check for LTSP-Cluster, if true, contact the loadbalancer for an IP */
     if (access(LTSP_CLUSTER_CONFILE, F_OK) == 0) {
 …
         fp = popen("getltscfg-cluster -l ldm", "r");
         if (fp != NULL) {
+            log_entry("ltsp-cluster",6,"IP before load-balancing: %s", *server);
+            log_entry("ltsp-cluster", 6, "IP before load-balancing: %s",
+                      *server);
             if (fgets(*server, PATH_MAX, fp) == NULL)
+                log_entry("ltsp-cluster",4,"failed to get an IP from the load-balancer");
+                log_entry("ltsp-cluster", 4,
+                          "failed to get an IP from the load-balancer");
+            log_entry("ltsp-cluster",6,"IP after loadbalancing: %s", *server);
+            log_entry("ltsp-cluster", 6, "IP after loadbalancing: %s",
+                      *server);
+        }
         if (pclose(fp) == -1)
             log_entry("ltsp-cluster",3,"load-balancing failed");
+            log_entry("ltsp-cluster", 3, "load-balancing failed");
+    }
+}

ldm/trunk/fuentes/src/plugins/rdesktop/rdesktop.c

-                      r516
+                      r855
 RdpInfo *rdpinfo;
+void __attribute__((constructor)) initialize() {
+    descriptor = (LdmBackend*) malloc(sizeof(LdmBackend));
+void __attribute__ ((constructor)) initialize()
+{
+    descriptor = (LdmBackend *) malloc(sizeof(LdmBackend));
     bzero(descriptor, sizeof(LdmBackend));
 …
  *  Callback function for initialization
  */
+void init_rdesktop() {
+    rdpinfo = (RdpInfo*) malloc(sizeof(RdpInfo));
+void
+init_rdesktop()
+{
+    rdpinfo = (RdpInfo *) malloc(sizeof(RdpInfo));
     bzero(rdpinfo, sizeof(RdpInfo));
 …
  *  Callback function for starting rdesktop session
  */
+void start_rdesktop() {
+void
+start_rdesktop()
+{
     gboolean error = FALSE;
     /* Variable validation */
     if(!rdpinfo->username) {
         log_entry("rdesktop",3,"no username");
+    if (!rdpinfo->username) {
+        log_entry("rdesktop", 3, "no username");
         error = TRUE;
+    }
     if(!rdpinfo->password) {
         log_entry("rdesktop",3,"no password");
+    if (!rdpinfo->password) {
+        log_entry("rdesktop", 3, "no password");
         error = TRUE;
+    }
     if(!rdpinfo->server) {
         log_entry("rdesktop",3,"no server");
+    if (!rdpinfo->server) {
+        log_entry("rdesktop", 3, "no server");
         error = TRUE;
+    }
     if(!rdpinfo->domain) {
         log_entry("rdesktop",3,"no domain");
+    if (!rdpinfo->domain) {
+        log_entry("rdesktop", 3, "no domain");
         error = TRUE;
+    }
     if(error) {
         die("rdesktop","missing mandatory information");
+    if (error) {
+        die("rdesktop", "missing mandatory information");
+    }
 …
     close_greeter();
+    log_entry("rdesktop",6,"starting rdesktop session to '%s' as '%s'", rdpinfo->server, rdpinfo->username);
+    log_entry("rdesktop", 6, "starting rdesktop session to '%s' as '%s'",
+              rdpinfo->server, rdpinfo->username);
     rdesktop_session();
     log_entry("rdesktop",6,"closing rdesktop session");
+    log_entry("rdesktop", 6, "closing rdesktop session");
+}
 …
  * _get_domain
  */
+void _get_domain() {
+void
+_get_domain()
+{
     gchar *cmd = "value domain\n";
 …
  *  Callback function for authentication
  */
+void auth_rdesktop() {
+void
+auth_rdesktop()
+{
     gchar *cmd;
     /* Separator for domains : '|' */
     gchar *domains = getenv("RDP_DOMAIN");
+    cmd = g_strconcat("pref choice;domain;Domain;Select Domai_n ...;session;", domains, "\n", NULL);
+    cmd =
+        g_strconcat
+        ("pref choice;domain;Domain;Select Domai_n ...;session;", domains,
+         "\n", NULL);
     if (domains) {
         if(ask_greeter(cmd))
+        if (ask_greeter(cmd))
             die("rdesktop", "%s from greeter failed", cmd);
     } else {
+        log_entry("rdesktop",7,"RDP_DOMAIN isn't defined, rdesktop will connect on default domain");
+        log_entry("rdesktop", 7,
+                  "RDP_DOMAIN isn't defined, rdesktop will connect on default domain");
+    }
 …
     /* Get hostname */
     if(!rdpinfo->server)
+    if (!rdpinfo->server)
         get_host(&(rdpinfo->server));
 …
  *  Callback function for closing the plugins
  */
+void close_rdesktop() {
+    log_entry("rdesktop",7,"closing rdesktop session");
+void
+close_rdesktop()
+{
+    log_entry("rdesktop", 7, "closing rdesktop session");
     free(rdpinfo);
+}
 …
  *  Start a rdesktop session to server
  */
+void rdesktop_session() {
+void
+rdesktop_session()
+{
     gchar *cmd;
     cmd = g_strjoin(" ", "rdesktop", "-f",
             "-u", rdpinfo->username,
             "-p", rdpinfo->password, NULL);
+                    "-u", rdpinfo->username,
+                    "-p", rdpinfo->password, NULL);
     /* Only append the domain if it's set */
+    if (g_strcmp0(rdpinfo->domain,"None") != 0) {
+        cmd = g_strjoin(" ", cmd,
+            "-d", rdpinfo->domain, NULL);
+    if (g_strcmp0(rdpinfo->domain, "None") != 0) {
+        cmd = g_strjoin(" ", cmd, "-d", rdpinfo->domain, NULL);
+    }

ldm/trunk/fuentes/src/plugins/ssh/Makefile.am

r516	r855
4	4	libssh_la_CFLAGS = $(GLIB_CFLAGS) $(GOBJECT_CFLAGS)
5	5
6		libssh_la_LDFLAGS = $(GLIB_LIBS) $(GOBJECT_LIBS)
	6	libssh_la_LDFLAGS = -lcrypt $(GLIB_LIBS) $(GOBJECT_LIBS)
7	7	libssh_la_SOURCES = ssh.c

ldm/trunk/fuentes/src/plugins/ssh/ssh.c

-                      r516
+                      r855
 #include <sys/stat.h>
 #include <utmp.h>
+#include <crypt.h>
 #include <errno.h>
 …
 SSHInfo *sshinfo;
+void __attribute__((constructor)) initialize() {
+    descriptor = (LdmBackend*) malloc(sizeof(LdmBackend));
+void __attribute__ ((constructor)) initialize()
+{
+    descriptor = (LdmBackend *) malloc(sizeof(LdmBackend));
     bzero(descriptor, sizeof(LdmBackend));
 …
  *  Callback function for initialization
  */
+void init_ssh() {
+    sshinfo = (SSHInfo*) malloc(sizeof(SSHInfo));
+void
+init_ssh()
+{
+    sshinfo = (SSHInfo *) malloc(sizeof(SSHInfo));
     bzero(sshinfo, sizeof(SSHInfo));
 …
  *  Start ssh session
  */
+void start_ssh() {
+void
+start_ssh()
+{
     gboolean error = FALSE;
     /* Variable validation */
     if (!(sshinfo->username)) {
         log_entry("ssh",3,"no username");
+        log_entry("ssh", 3, "no username");
         error = TRUE;
+    }
     if (!(sshinfo->password)) {
         log_entry("ssh",3,"no password");
+        log_entry("ssh", 3, "no password");
         error = TRUE;
+    }
     if (!(sshinfo->server)) {
         log_entry("ssh",3,"no server");
+        log_entry("ssh", 3, "no server");
         error = TRUE;
+    }
 …
     if (error) {
         die("ssh","missing mandatory information");
+        die("ssh", "missing mandatory information");
+    }
 …
      * control sockets.
      */
+    sshinfo->ctl_socket = g_strdup_printf("/var/run/ldm_socket_%d_%s", ldm.pid, sshinfo->server);
+    sshinfo->ctl_socket =
+        g_strdup_printf("/var/run/ldm_socket_%d_%s", ldm.pid,
+                        sshinfo->server);
     /* Setting ENV variables for plugin */
 …
     /* Execute any rc files */
     log_entry("ssh",6,"calling rc.d pressh scripts");
+    log_entry("ssh", 6, "calling rc.d pressh scripts");
     rc_files("pressh");
     ssh_session();
+    log_entry("ssh",6,"established ssh session on '%s' as '%s'",sshinfo->server,sshinfo->username);
+    log_entry("ssh", 6, "established ssh session on '%s' as '%s'",
+              sshinfo->server, sshinfo->username);
     /* Greeter not needed anymore */
     close_greeter();
+    log_entry("ssh",6,"calling rc.d start scripts");
+    rc_files("start");                      /* Execute any rc files */
+    log_entry("ssh",6,"starting X session");
+    log_entry("ssh", 6, "calling rc.d start scripts");
+    rc_files("start");                           /* Execute any rc files */
+    /* ssh_hashpass - Defaults to opt-in (Must set LDM_PASSWORD_HASH to true) */
+    if (ldm_getenv_bool_default("LDM_PASSWORD_HASH", FALSE))
+    {
+        ssh_hashpass();
+    }
+    else
+    {
+        log_entry("hashpass", 6, "LDM_PASSWORD_HASH set to FALSE or unset, skipping hash function");
+    }
+    log_entry("hashpass", 6, "Freeing password as promised.");
+    g_free(sshinfo->password);
+    sshinfo->password = NULL;
+    log_entry("ssh", 6, "starting X session");
     set_session_env(sshinfo->xsession, sshinfo->session);
+}
 …
  *  Callback function for setting guest login
  */
+void get_guest() {
+    log_entry("ssh",6,"setting guest login");
+void
+get_guest()
+{
+    log_entry("ssh", 6, "setting guest login");
     /* Get credentials */
 …
         if (sshinfo->server) {
             i = 0;
             while(1) {
                 if(hosts_char[i] == NULL) {
+            while (1) {
+                if (hosts_char[i] == NULL) {
                     break;
+                }
                 if(!g_strcmp0(hosts_char[i], sshinfo->server)) {
+                if (!g_strcmp0(hosts_char[i], sshinfo->server)) {
                     good = TRUE;
                     break;
 …
  *  Set environment variables used by LDM and Greeter
  */
+void _set_env() {
+void
+_set_env()
+{
     setenv("LDM_SERVER", sshinfo->server, 1);
     setenv("LDM_USERNAME", sshinfo->username, 1);
 …
  *  Callback function for authentication
  */
+void get_auth() {
+void
+get_auth()
+{
     /* Get UserID */
     get_userid(&(sshinfo->username));
 …
  *  Callback function for closing the plugins
  */
+void close_ssh() {
+    log_entry("ssh",7,"closing ssh session");
+void
+close_ssh()
+{
+    log_entry("ssh", 7, "closing ssh session");
     ssh_endsession();
 …
+}
+int expect(int fd, char *p, int seconds, ...) {
+int
+expect(int fd, char *p, int seconds, ...)
+{
     fd_set set;
     struct timeval timeout;
 …
      * Main loop.
      */
     log_entry("ssh",7,"expect: entering main loop");
+    while(1) {
+    while (1) {
+//        timeout.tv_sec = (long) 1;               /* one second timeout */
+//        timeout.tv_usec = 0;
         timeout.tv_sec  = 0;
         timeout.tv_usec = 200000; /* 200ms timeout */
 …
         st = select(FD_SETSIZE, &set, NULL, NULL, &timeout);
+        log_entry("ssh", 7, "expect: select returned %d", st);
+        log_entry("ssh", 7, "expect: select returned %d", st);
+//        if (st == -1 && errno == EINTR)
+//        {
+//            continue;                            /* interrupted by signal -> retry */
+//        }
+//        if (st < 0) {                            /* bad thing */
+//            break;
+//        }
+//        if (loopcount == 0) {
+//            break;
+//        }
+//        if (!st) {                               /* timeout */
+//            loopcount--;                         /* We've not seen the data we want */
+//            continue;
+//        }
         /* There is data available - we want to read it in even if
 …
          * message
          */
+        if (st > 0)
+        {
+            size = read(fd, buffer, sizeof buffer);
+            if (size == -1) {
+                log_entry("ssh", 3, "expect: read returned error %d (%s)", errno, strerror(errno));
+                break;
+            }
+            if (size == 0) {
+                log_entry("ssh", 3, "expect: read returned 0 (EOF))");
+                break;
+            }
+            if ((total + size) < MAXEXP) {
+                strncpy(p + total, buffer, size);
+                total += size;
+                log_entry("ssh", 7, "expect: got %d bytes so far", total);
+            }
+            else
+            {
+                log_entry("ssh", 3, "expect: buffer full");
+                return ERROR;
+            }
+        }
+        else /* No data available */
+        if (st > 0)
+        {
+                size = read(fd, buffer, sizeof buffer);
+                if (size < 0) {
+                    log_entry("ssh", 3, "expect: read returned error %d (%s)", errno, strerror(errno));
+                    break;
+                }
+                if (size == 0) {
+                        log_entry("ssh", 3, "expect: read returned 0 (EOF))");
+                        break;
+                }
+                if ((total + size) < MAXEXP) {
+                    strncpy(p + total, buffer, size);
+                    total += size;
+                    log_entry("ssh", 7, "expect: got %d bytes so far", total);
+                }
+                else
+                {
+                        log_entry("ssh", 3, "expect: buffer full");
+                        return ERROR;
+                }
+        }
+        else /* No data available */
+        {
             /* select() was interrupted by a signal,
 …
                 break;
+            }
             for (i = 0; i < expects->len; i++) {
+                if (strstr(p, g_ptr_array_index(expects, i))) {
+                    log_entry("ssh", 7, "expect: found string %d \"%s\"", i, g_ptr_array_index(expects, i));
+                    loopend = TRUE;
+                    break;
+                }
+            }
+            loopcount--;            /* We've not seen the data we want */
+        }
+                if (strstr(p, g_ptr_array_index(expects, i))) {
+                        log_entry("ssh", 7, "expect: found string %d \"%s\"", i, g_ptr_array_index(expects, i));
+                        loopend = TRUE;
+                        break;
+                }
+            }
+            loopcount--;            /* We've not seen the data we want */
+        }
         if (loopend) {
 …
     log_entry("ssh",7,"expect: saw: %s", p);
     if (size < 0 || st < 0 || child_exited) {
         return ERROR;               /* error occured */
+    if (size < 0 || st < 0) {
+        return ERROR;                            /* error occured */
+    }
     if (loopcount == 0) {
+        return TIMED_OUT;           /* timed out */
+    } else {
+        return i;                   /* which expect did we see? */
+    }
+}
+void ssh_chat(gint fd) {
+        return TIMED_OUT;                        /* timed out */
+    }
+    /* Sleep a bit to make sure we notice if ssh died in the meantime */
+    usleep(100000);
+    if (child_exited)
+    {
+        return ERROR;
+    }
+    return i;                                    /* which expect did we see? */
+}
+void
+ssh_chat(gint fd)
+{
     int seen;
     size_t len;
 …
            end of the line */
         if (seen == 0) {
-            g_free(sshinfo->password);
-            sshinfo->password = NULL;
             return;
+        } else if (seen == 1) {
+            int i;
+            g_strdelimit(lastseen, "\r\n\t", ' ');
+            g_strchomp(lastseen);
+            i = strlen(lastseen);
+        }
+        int i;
+        g_strdelimit(lastseen, "\r\n\t", ' ');
+        g_strchomp(lastseen);
+        i = strlen(lastseen);
+        if (seen == 1) {
             /* If it's not the first time through, or the :'s not at the
              * end of a line (password expiry or error), set the message */
 …
+}
+void ssh_tty_init(void) {
+void
+ssh_tty_init(void)
+{
     (void) setsid();
     if (login_tty(sshinfo->sshslavefd) < 0 ) {
         die("ssh","login_tty failed");
+    if (login_tty(sshinfo->sshslavefd) < 0) {
+        die("ssh", "login_tty failed");
+    }
+}
 …
  * Start an ssh login to the server.
  */
+void ssh_session(void) {
+void
+ssh_session(void)
+{
     gchar *command;
     gchar *port = NULL;
 …
     /* Check for port Override */
     if(sshinfo->override_port)
         port = g_strconcat(" -p ", sshinfo->override_port, " ",  NULL);
+    if (sshinfo->override_port)
+        port = g_strconcat(" -p ", sshinfo->override_port, " ", NULL);
     openpty(&(sshinfo->sshfd), &(sshinfo->sshslavefd), NULL, NULL, NULL);
     command = g_strjoin(" ", "ssh", "-Y", "-t", "-M",
+            "-S", sshinfo->ctl_socket,
+            "-o", "NumberOfPasswordPrompts=1",
+             /* ConnectTimeout should be less than the timeout ssh_chat
+              * passes to expect, so we get the error message from ssh
+              * before expect gives up
+              */
+            "-o", "ConnectTimeout=10",
+            "-l", sshinfo->username,
+            port ? port : "",
+            sshinfo->sshoptions ? sshinfo->sshoptions : "",
+            sshinfo->server, "echo " SENTINEL "; exec /bin/sh -", NULL);
+                        "-S", sshinfo->ctl_socket,
+                        "-o", "NumberOfPasswordPrompts=1",
+                         /* ConnectTimeout should be less than the timeout ssh_chat
+                          * passes to expect, so we get the error message from ssh
+                          * before expect gives up
+                          */
+                        "-o", "ConnectTimeout=10",
+                        "-l", sshinfo->username,
+                        port ? port : "",
+                        sshinfo->sshoptions ? sshinfo->sshoptions : "",
+                        sshinfo->server,
+                        "echo " SENTINEL "; exec /bin/sh -", NULL);
     log_entry("ssh", 6, "ssh_session: %s", command);
 …
+}
+void ssh_endsession(void) {
+void
+ssh_endsession(void)
+{
     GPid pid;
     gchar *command;
 …
         /* socket still exists, so we need to shut down the ssh link */
+        command = g_strjoin(" ", "ssh", "-S", sshinfo->ctl_socket, "-O", "exit", sshinfo->server, NULL);
+        log_entry("ssh", 6, "closing ssh session: %s", command);
+        command =
+            g_strjoin(" ", "ssh", "-S", sshinfo->ctl_socket, "-O", "exit",
+                      sshinfo->server, NULL);
+        log_entry("ssh", 6, "closing ssh session: %s"), command;
         pid = ldm_spawn(command, NULL, NULL, NULL);
         ldm_wait(pid);
 …
+}
+void *eater() {
+/*
+ * ssh_hashpass()
+ * Set up password hash for client /etc/shadow using /dev/urandom
+ * rather than g_rand() due to developer recommendations at:
+ * https://developer.gnome.org/glib/stable/glib-Random-Numbers.html
+ */
+void
+ssh_hashpass(void)
+{
+    FILE *rand_fp;
+    FILE *shad_fp;
+    gchar salt[] = "$6$...............$";
+    gchar buf[16];
+    const gchar seedchars[] =
+        "./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+    gchar *shadowentry;
+    const gchar hashloc[] = "/var/cache/ltsp/shadow.sed";
+    size_t i = 0;
+    log_entry("hashpass", 6, "LDM_PASSWORD_HASH set to true, setting hash");
+    rand_fp = fopen("/dev/urandom", "r");
+    if (rand_fp == NULL)
+    {
+        log_entry("hashpass", 7, "Unable to read from /dev/urandom - Skipping HASH function");
+    }
+    else
+    {
+        fread(buf, sizeof buf, 1, rand_fp);
+        fclose(rand_fp);
+        for (; i < sizeof buf; i++)
+        {
+            salt[3 + i] = seedchars[buf[i] % (sizeof seedchars - 1)];
+        }
+        shadowentry = crypt(sshinfo->password, salt);
+        log_entry("hashpass", 6, "hash created");
+        /* generate dynamic file for writing hash to.
+        * Will remove anything in its way.
+        * This will be removed during rc.d script run.
+        */
+        shad_fp = fopen(hashloc, "w");
+        if (shad_fp == NULL)
+        {
+            log_entry("hashpass", 7, "Unable to open %s for hash entry.",
+                      hashloc);
+        }
+        else
+        {
+            fprintf(shad_fp,
+                    "# Generated by LTSP, for LDM rc.d script manipulation\n$s:!:%s:",
+                    shadowentry);
+            fclose(shad_fp);
+        }
+    }
+}
+void *
+eater()
+{
     fd_set set;
     struct timeval timeout;
 …
+        }
         timeout.tv_sec = (long)1;             /* one second timeout */
+        timeout.tv_sec = (long) 1;               /* one second timeout */
         timeout.tv_usec = 0;
         FD_ZERO(&set);

ldm/trunk/fuentes/src/plugins/ssh/ssh.h

r516	r855
30	30	void ssh_session(void);
31	31	void ssh_tty_init();
	32	void ssh_hashpass(void);
32	33
33	34	int expect(int, char*,int,...);

ldm/trunk/fuentes/wwm/client.c

-                      r516
+                      r855
     for (c = head_client; c; c = c->next)
         if (w == c->parent || w == c->window)
             return(c);
     return(NULL);
+            return (c);
+    return (NULL);
+}
 Client *
 next_client_on_vdesk(Client *c)
+next_client_on_vdesk(Client * c)
+{
     Client *newc = c, *marker = c;
 …
     while (newc != marker && newc->vdesk != v);
     return((newc == marker) ? NULL : newc);
+}
 void
 set_wm_state(Client *c, int state)
+    return ((newc == marker) ? NULL : newc);
+}
+void
+set_wm_state(Client * c, int state)
+{
     long data[2];
     data[0] = (long) state;
     data[1] = None;                         /* icon window */
+    data[1] = None;                              /* icon window */
     XChangeProperty(display, c->window, xa_wm_state, xa_wm_state,
 …
 void
 send_config(Client *c)
+send_config(Client * c)
+{
     XConfigureEvent ce;
     ce.type              = ConfigureNotify;
     ce.event             = c->window;
     ce.window            = c->window;
     ce.x                 = c->x;
     ce.y                 = c->y;
     ce.width             = c->width;
     ce.height            = c->height;
     ce.border_width      = c->border;
     ce.above             = None;
+    ce.type = ConfigureNotify;
+    ce.event = c->window;
+    ce.window = c->window;
+    ce.x = c->x;
+    ce.y = c->y;
+    ce.width = c->width;
+    ce.height = c->height;
+    ce.border_width = c->border;
+    ce.above = None;
     ce.override_redirect = False;
+    XSendEvent(display, c->window, False, StructureNotifyMask, (XEvent *) &ce);
+    XSendEvent(display, c->window, False, StructureNotifyMask,
+               (XEvent *) & ce);
     XSync(display, False);
+}
 void
 remove_client(Client *c, int from_cleanup)
+remove_client(Client * c, int from_cleanup)
+{
     Window root = ROOTWINDOW;
 …
         XFree(c->size);
     if (current == c)
         current = NULL;     /* an enter event should set this up again */
+        current = NULL;                          /* an enter event should set this up again */
     free(c);
 …
 void
 change_gravity(Client *c, int invert)
+change_gravity(Client * c, int invert)
+{
     int dx = 0, dy = 0;
     int gravity = (c->size->flags & PWinGravity) ?
                    c->size->win_gravity : NorthWestGravity;
+        c->size->win_gravity : NorthWestGravity;
     switch (gravity) {
         case CenterGravity:
         case StaticGravity:
         case NorthWestGravity:
         case NorthGravity:
         case WestGravity:
             dx = c->border;
             dy = c->border;
             break;
         case NorthEastGravity:
         case EastGravity:
             dx = -(c->border);
             dy = c->border;
             break;
         case SouthEastGravity:
             dx = -(c->border);
             dy = -(c->border);
             break;
         case SouthGravity:
         case SouthWestGravity:
             dx = c->border;
             dy = -(c->border);
             break;
+    case CenterGravity:
+    case StaticGravity:
+    case NorthWestGravity:
+    case NorthGravity:
+    case WestGravity:
+        dx = c->border;
+        dy = c->border;
+        break;
+    case NorthEastGravity:
+    case EastGravity:
+        dx = -(c->border);
+        dy = c->border;
+        break;
+    case SouthEastGravity:
+        dx = -(c->border);
+        dy = -(c->border);
+        break;
+    case SouthGravity:
+    case SouthWestGravity:
+        dx = c->border;
+        dy = -(c->border);
+        break;
+    }
 …
 void
 send_wm_delete(Client *c)
+send_wm_delete(Client * c)
+{
     int i, n, found = 0;
 …
     XEvent ev;
     ev.type                 = ClientMessage;
     ev.xclient.window       = w;
+    ev.type = ClientMessage;
+    ev.xclient.window = w;
     ev.xclient.message_type = a;
+    ev.xclient.format       = 32;
+    ev.xclient.data.l[0]    = x;
+    ev.xclient.data.l[1]    = CurrentTime;
+    return(XSendEvent(display, w, False, NoEventMask, &ev));
+}
+void
+set_shape(Client *c) {
+    int i, b;  unsigned int u;  /* dummies */
+    ev.xclient.format = 32;
+    ev.xclient.data.l[0] = x;
+    ev.xclient.data.l[1] = CurrentTime;
+    return (XSendEvent(display, w, False, NoEventMask, &ev));
+}
+void
+set_shape(Client * c)
+{
+    int i, b;
+    unsigned int u;             /* dummies */
     int bounding_shaped;
     Status retval;
 …
      */
+    retval = XShapeQueryExtents(display, c->window, &bounding_shaped, &i, &i,
+             &u, &u, &b, &i, &i, &u, &u);
+    retval =
+        XShapeQueryExtents(display, c->window, &bounding_shaped, &i, &i,
+                           &u, &u, &b, &i, &i, &u, &u);
     if (retval && bounding_shaped)
         XShapeCombineShape(display, c->parent, ShapeBounding,
+            c->border, c->border, c->window, ShapeBounding, ShapeSet);
+}
+                           c->border, c->border, c->window, ShapeBounding,
+                           ShapeSet);
+}

ldm/trunk/fuentes/wwm/events.c

-                      r516
+                      r855
 void
 handle_key_event(XKeyEvent *e)
+handle_key_event(XKeyEvent * e)
+{
     int i;
 …
     for (i = 0; keytab[i].key != 0; i++)
         if (keytab[i].key == key) {
             keytab[i].f(c);             /* dispatch the function */
+            keytab[i].f(c);                      /* dispatch the function */
             break;
+        }
 …
 void
 handle_button_event(XButtonEvent *e)
+handle_button_event(XButtonEvent * e)
+{
     // We want a minimal WM, so no mouse actions
 …
         return;
         switch (e->button) {
             case Button4:               /* Scrolly wheel up in root */
                 prev_vdesk((Client *) NULL);
                 return;
             case Button5:               /* Scrolly wheel down in root */
                 next_vdesk((Client *) NULL);
                 return;
+        case Button4:                           /* Scrolly wheel up in root */
+            prev_vdesk((Client *) NULL);
+            return;
+        case Button5:                           /* Scrolly wheel down in root */
+            next_vdesk((Client *) NULL);
+            return;
+        }
     } else if (c) {
         switch (e->button) {
             case Button1:               /* Left mouse = move */
                 move(c, 0);
                 return;
             case Button3:               /* Right mouse = resize */
                 resize(c, 0);
+        case Button1:                           /* Left mouse = move */
+            move(c, 0);
+            return;
+        case Button3:                           /* Right mouse = resize */
+            resize(c, 0);
             return;
+        }
 …
 void
+handle_shape_event(XShapeEvent *e) {
+handle_shape_event(XShapeEvent * e)
+{
     Client *c = find_client(e->window);
 …
 void
 handle_configure_request(XConfigureRequestEvent *e)
+handle_configure_request(XConfigureRequestEvent * e)
+{
     Client *c = find_client(e->window);
 …
 void
 handle_map_request(XMapRequestEvent *e)
+handle_map_request(XMapRequestEvent * e)
+{
     Client *c = find_client(e->window);
 …
 void
 handle_unmap_event(XUnmapEvent *e)
+handle_unmap_event(XUnmapEvent * e)
+{
     Client *c = find_client(e->window);
 …
 void
 handle_client_message(XClientMessageEvent *e)
+handle_client_message(XClientMessageEvent * e)
+{
     Client *c = find_client(e->window);
     if (c &&                                        /* Client exists */
         e->message_type == xa_wm_change_state &&    /* Changing state */
         e->format == sz_xInternAtomReply &&         /* Data is long */
         e->data.l[0] == IconicState)                /* We're now iconic */
+    if (c &&                                     /* Client exists */
+        e->message_type == xa_wm_change_state && /* Changing state */
+        e->format == sz_xInternAtomReply &&      /* Data is long */
+        e->data.l[0] == IconicState)             /* We're now iconic */
         hide(c);
+}
 void
 handle_property_change(XPropertyEvent *e)
+handle_property_change(XPropertyEvent * e)
+{
     Client *c = find_client(e->window);
 …
 void
 handle_enter_event(XCrossingEvent *e)
+handle_enter_event(XCrossingEvent * e)
+{
     Client *c = find_client(e->window);
     if (nomousefocus || !c)           /* Ignore focus follows mouse */
+    if (nomousefocus || !c)                      /* Ignore focus follows mouse */
         return;

ldm/trunk/fuentes/wwm/main.c

-                      r516
+                      r855
 #include "wwm.h"
 void handle_shape_event(XShapeEvent *e);
+void handle_shape_event(XShapeEvent * e);
 /*
 …
  */
 Client *head_client = NULL;    /* First client */
 Client *current = NULL;        /* "current" client */
 Display *display;            /* Our display */
 Atom xa_wm_state;            /* atoms for window manager functions */
+Client *head_client = NULL;     /* First client */
+Client *current = NULL;         /* "current" client */
+Display *display;               /* Our display */
+Atom xa_wm_state;               /* atoms for window manager functions */
 Atom xa_wm_change_state;
 Atom xa_wm_protos;
 Atom xa_wm_delete;
 XColor fg, bg, fc;            /* Forground, Background, and locked colours */
 int nomousefocus = 0;        /* focus follows mouse status */
 int passthrough = 0;        /* current passthrough state */
 char *term = NULL;          /* terminal to launch */
 int have_shape = 0;         /* Do we support shaped windows? */
 int ignore_xerror = 0;      /* Ignore X errors */
+XColor fg, bg, fc;              /* Forground, Background, and locked colours */
+int nomousefocus = 0;           /* focus follows mouse status */
+int passthrough = 0;            /* current passthrough state */
+char *term = NULL;              /* terminal to launch */
+int have_shape = 0;             /* Do we support shaped windows? */
+int ignore_xerror = 0;          /* Ignore X errors */
 struct wmkeys keytab[] = {
 …
     int shape_event;
     dpy = getenv("DISPLAY");            /* manage the display in $DISPLAY */
+    dpy = getenv("DISPLAY");                     /* manage the display in $DISPLAY */
     if (!dpy)
 …
     sigemptyset(&act.sa_mask);
 #ifdef SA_NOCLDSTOP
     act.sa_flags = SA_NOCLDSTOP;        /* don't care about STOP, CONT */
+    act.sa_flags = SA_NOCLDSTOP;                 /* don't care about STOP, CONT */
 #else
     act.sa_flags = 0;
 #endif
     sigaction(SIGTERM, &act, NULL);
     sigaction(SIGINT,  &act, NULL);
     sigaction(SIGHUP,  &act, NULL);
+    sigaction(SIGINT, &act, NULL);
+    sigaction(SIGHUP, &act, NULL);
     sigaction(SIGCHLD, &act, NULL);
 …
         XNextEvent(display, &ev);
         switch (ev.type) {
             case KeyPress:
                 handle_key_event(&ev.xkey);
                 break;
             case ButtonPress:
                 handle_button_event(&ev.xbutton);
                 break;
             case ConfigureRequest:
                 handle_configure_request(&ev.xconfigurerequest);
                 break;
             case MapRequest:
                 handle_map_request(&ev.xmaprequest);
                 break;
             case ClientMessage:
                 handle_client_message(&ev.xclient);
                 break;
             case EnterNotify:
                 handle_enter_event(&ev.xcrossing);
                 break;
             case PropertyNotify:
                 handle_property_change(&ev.xproperty);
                 break;
             case UnmapNotify:
                 handle_unmap_event(&ev.xunmap);
                 break;
             default:
                 if (have_shape && ev.type == shape_event) {
                     handle_shape_event((XShapeEvent *)&ev);
+                }
+        case KeyPress:
+            handle_key_event(&ev.xkey);
+            break;
+        case ButtonPress:
+            handle_button_event(&ev.xbutton);
+            break;
+        case ConfigureRequest:
+            handle_configure_request(&ev.xconfigurerequest);
+            break;
+        case MapRequest:
+            handle_map_request(&ev.xmaprequest);
+            break;
+        case ClientMessage:
+            handle_client_message(&ev.xclient);
+            break;
+        case EnterNotify:
+            handle_enter_event(&ev.xcrossing);
+            break;
+        case PropertyNotify:
+            handle_property_change(&ev.xproperty);
+            break;
+        case UnmapNotify:
+            handle_unmap_event(&ev.xunmap);
+            break;
+        default:
+            if (have_shape && ev.type == shape_event) {
+                handle_shape_event((XShapeEvent *) & ev);
+            }
+        }
+    }
     return(1);                          /* ?!?  shouldn't get here */
+    return (1);                                  /* ?!?  shouldn't get here */
+}
 …
     display = XOpenDisplay(dpy);
     if (!display)                           /* couldn't open display */
+    if (!display)                                /* couldn't open display */
         exit(1);
 …
      */
     xa_wm_state        = XInternAtom(display, "WM_STATE",         False);
     xa_wm_change_state = XInternAtom(display, "WM_CHANGE_STATE",  False);
     xa_wm_protos       = XInternAtom(display, "WM_PROTOCOLS",     False);
     xa_wm_delete       = XInternAtom(display, "WM_DELETE_WINDOW", False);
+    xa_wm_state = XInternAtom(display, "WM_STATE", False);
+    xa_wm_change_state = XInternAtom(display, "WM_CHANGE_STATE", False);
+    xa_wm_protos = XInternAtom(display, "WM_PROTOCOLS", False);
+    xa_wm_delete = XInternAtom(display, "WM_DELETE_WINDOW", False);
     XAllocNamedColor(display, colormap, DEF_FG, &fg, &dummy);
 …
     attr.event_mask = KeyPressMask | ChildMask | PropertyChangeMask |
                       EnterWindowMask | ButtonMask;
+        EnterWindowMask | ButtonMask;
     XChangeWindowAttributes(display, root, CWEventMask, &attr);
 …
     Window root = RootWindow(display, DefaultScreen(display));
     XGrabKey(display, XKeysymToKeycode(display, keycode),
          modifiers, root, True, GrabModeAsync, GrabModeAsync);
+             modifiers, root, True, GrabModeAsync, GrabModeAsync);
+}

ldm/trunk/fuentes/wwm/mapfunctions.c

-                      r516
+                      r855
 void
 move_win_up(Client *c)
+move_win_up(Client * c)
+{
     if (!c)
 …
 void
 move_win_down(Client *c)
+move_win_down(Client * c)
+{
     if (!c)
 …
 void
 move_win_left(Client *c)
+move_win_left(Client * c)
+{
     if (!c)
 …
 void
 move_win_right(Client *c)
+move_win_right(Client * c)
+{
     if (!c)
 …
 void
 expand_win_y(Client *c)
+expand_win_y(Client * c)
+{
     if (!c)
 …
 void
 contract_win_y(Client *c)
+contract_win_y(Client * c)
+{
     if (!c || c->height <= WMDELTA)
 …
 void
 expand_win_x(Client *c)
+expand_win_x(Client * c)
+{
     if (!c)
 …
 void
 contract_win_x(Client *c)
+contract_win_x(Client * c)
+{
     if (!c || c->width <= WMDELTA)
 …
 void
 kill_client(Client *c)
+kill_client(Client * c)
+{
     if (!c)
 …
 void
 raise_client(Client *c)
+raise_client(Client * c)
+{
     if (!c)
 …
 void
 lower_client(Client *c)
+lower_client(Client * c)
+{
     if (!c)
 …
 void
 horizontal_toggle(Client *c)
+horizontal_toggle(Client * c)
+{
     if (!c)
 …
 void
 vertical_toggle(Client *c)
+vertical_toggle(Client * c)
+{
     if (!c)
 …
 void
 maximize_toggle(Client *c)
+maximize_toggle(Client * c)
+{
     if (!c)
 …
 void
 lock_window(Client *c)
+lock_window(Client * c)
+{
     if (!c)
         return;
     XSetWindowBackground(display, c->parent,
              c->vdesk == LOCKED ? fg.pixel : fc.pixel);
+                         c->vdesk == LOCKED ? fg.pixel : fc.pixel);
     XClearWindow(display, c->parent);
     c->vdesk = c->vdesk == LOCKED ? vdesk_get() : LOCKED;
 …
 void
 new_term(Client *c)
+new_term(Client * c)
+{
     spawn(term);
 …
 void
 next_client(Client *c)
+next_client(Client * c)
+{
     next(current);
 …
 void
 quit_wm(Client *c)
+quit_wm(Client * c)
+{
     handle_signal(SIGHUP);
 …
 void
 start_passthrough(Client *c)
+start_passthrough(Client * c)
+{
     passthrough++;
 …
 void
 goto_vdesk_0(Client *c)
+goto_vdesk_0(Client * c)
+{
     switch_vdesk(0);
 …
 void
 goto_vdesk_1(Client *c)
+goto_vdesk_1(Client * c)
+{
     switch_vdesk(1);
 …
 void
 goto_vdesk_2(Client *c)
+goto_vdesk_2(Client * c)
+{
     switch_vdesk(2);
 …
 void
 goto_vdesk_3(Client *c)
+goto_vdesk_3(Client * c)
+{
     switch_vdesk(3);
 …
 void
 goto_vdesk_4(Client *c)
+goto_vdesk_4(Client * c)
+{
     switch_vdesk(4);
 …
 void
 goto_vdesk_5(Client *c)
+goto_vdesk_5(Client * c)
+{
     switch_vdesk(5);
 …
 void
 goto_vdesk_6(Client *c)
+goto_vdesk_6(Client * c)
+{
     switch_vdesk(6);
 …
 void
 goto_vdesk_7(Client *c)
+goto_vdesk_7(Client * c)
+{
     switch_vdesk(7);
 …
 void
 prev_vdesk(Client *c)
+prev_vdesk(Client * c)
+{
     int v = vdesk(VDESK_PREV, VDESK_NULL);
 …
 void
 next_vdesk(Client *c)
+next_vdesk(Client * c)
+{
     int v = vdesk(VDESK_NEXT, VDESK_NULL);
 …
 void
 top_left(Client *c)
+top_left(Client * c)
+{
     if (!c)
 …
 void
 top_right(Client *c)
+top_right(Client * c)
+{
     if (!c)
 …
 void
 bottom_left(Client *c)
+bottom_left(Client * c)
+{
     if (!c)
 …
 void
 bottom_right(Client *c)
+bottom_right(Client * c)
+{
     if (!c)
 …
 void
 toggle_focus(Client *c)
+toggle_focus(Client * c)
+{
     nomousefocus = (nomousefocus + 1) % 2;
 …
 void
 dummy_func(Client *c)
+dummy_func(Client * c)
+{
     return;

ldm/trunk/fuentes/wwm/misc.c

-                      r516
+                      r855
 int
 handle_xerror(Display *dpy, XErrorEvent *e)
+handle_xerror(Display * dpy, XErrorEvent * e)
+{
     Client *c = find_client(e->resourceid);
     if (ignore_xerror)
         return(0);
+        return (0);
     if (e->error_code == BadAccess &&
 …
         remove_client(c, NOT_QUITTING);
     return(0);
+    return (0);
+}
 int
 handle_xexit(Display *dpy)
+handle_xexit(Display * dpy)
+{
     exit(0);
 …
     switch (vdesk_command) {
         case VDESK_GET:
             return(my_vdesk);
         case VDESK_SET:
             my_vdesk = vdesk_option;
             return(my_vdesk);
         case VDESK_NEXT:
             return((my_vdesk + 1) % VDESK_MAX);
         case VDESK_PREV:
             return((my_vdesk ? my_vdesk - 1 : ( VDESK_MAX - 1)) % VDESK_MAX);
         default:
             return(my_vdesk);
+    case VDESK_GET:
+        return (my_vdesk);
+    case VDESK_SET:
+        my_vdesk = vdesk_option;
+        return (my_vdesk);
+    case VDESK_NEXT:
+        return ((my_vdesk + 1) % VDESK_MAX);
+    case VDESK_PREV:
+        return ((my_vdesk ? my_vdesk - 1 : (VDESK_MAX - 1)) % VDESK_MAX);
+    default:
+        return (my_vdesk);
+    }
+}

ldm/trunk/fuentes/wwm/new.c

-                      r516
+                      r855
     XGetWindowAttributes(display, c->window, &attr);
     c->x      = attr.x;
     c->y      = attr.y;
     c->width  = attr.width;
+    c->x = attr.x;
+    c->y = attr.y;
+    c->width = attr.width;
     c->height = attr.height;
     c->border = DEF_BW;
     c->oldw   = c->oldh = 0;
     c->vdesk  = vdesk_get();
+    c->oldw = c->oldh = 0;
+    c->vdesk = vdesk_get();
     /*
 …
+    }
     focus_client(c, RAISE);        /* new windows get focus */
+    focus_client(c, RAISE);                      /* new windows get focus */
+}
 void
 init_position(Client *c)
+init_position(Client * c)
+{
     int x, y;
 …
 void
 reparent(Client *c)
+reparent(Client * c)
+{
     XSetWindowAttributes p_attr;
 …
     p_attr.background_pixel = bg.pixel;
     p_attr.event_mask =
     ChildMask | ButtonPressMask | ExposureMask | EnterWindowMask;
+        ChildMask | ButtonPressMask | ExposureMask | EnterWindowMask;
     c->parent =
         XCreateWindow(display, root, c->x - c->border,
               c->y - c->border, c->width + (2 * c->border),
               c->height + (2 * c->border), 0, DefaultDepth(display,
                                    screen),
               CopyFromParent, DefaultVisual(display, screen),
               CWOverrideRedirect | CWBackPixel | CWEventMask,
               &p_attr);
+                      c->y - c->border, c->width + (2 * c->border),
+                      c->height + (2 * c->border), 0, DefaultDepth(display,
+                                                                   screen),
+                      CopyFromParent, DefaultVisual(display, screen),
+                      CWOverrideRedirect | CWBackPixel | CWEventMask,
+                      &p_attr);
     XAddToSaveSet(display, c->window);

ldm/trunk/fuentes/wwm/screen.c

-                      r516
+                      r855
 void
 draw_outline(Client *c)
+draw_outline(Client * c)
+{
     Window root = ROOTWINDOW;
 …
         gv.function = GXinvert;
         gv.subwindow_mode = IncludeInferiors;
         gv.line_width = DEF_BW; /* opt_bw */
+        gv.line_width = DEF_BW;                  /* opt_bw */
         invert_gc = XCreateGC(display, root,
+                              GCFunction | GCSubwindowMode | GCLineWidth, &gv);
+                              GCFunction | GCSubwindowMode | GCLineWidth,
+                              &gv);
+    }
 …
 void
 recalculate_sweep(Client *c, int x1, int y1, int x2, int y2)
+recalculate_sweep(Client * c, int x1, int y1, int x2, int y2)
+{
     int basex, basey;
 …
     if (c->size->flags & PResizeInc) {
         basex = (c->size->flags & PBaseSize) ? c->size->base_width :
                 (c->size->flags & PMinSize) ? c->size->min_width : 0;
+            (c->size->flags & PMinSize) ? c->size->min_width : 0;
         basey = (c->size->flags & PBaseSize) ? c->size->base_height :
                 (c->size->flags & PMinSize) ? c->size->min_height : 0;
+            (c->size->flags & PMinSize) ? c->size->min_height : 0;
         c->width -= (c->width - basex) % c->size->width_inc;
         c->height -= (c->height - basey) % c->size->height_inc;
 …
 void
 sweep(Client *c)
+sweep(Client * c)
+{
     Window root = ROOTWINDOW;
 …
     draw_outline(c);
+    XWarpPointer(display, None, c->window, 0, 0, 0, 0, c->width, c->height);
+    XWarpPointer(display, None, c->window, 0, 0, 0, 0, c->width,
+                 c->height);
     for (;;) {
         XMaskEvent(display, MouseMask, &ev);
         switch (ev.type) {
             case MotionNotify:
                 draw_outline(c);    /* clear */
                 XUngrabServer(display);
                 recalculate_sweep(c, old_cx, old_cy,
                                   ev.xmotion.x, ev.xmotion.y);
                 XSync(display, False);
                 XGrabServer(display);
                 draw_outline(c);
                 break;
             case ButtonRelease:
                 draw_outline(c);    /* clear */
                 XUngrabServer(display);
                 XUngrabPointer(display, CurrentTime);
                 return;
+        case MotionNotify:
+            draw_outline(c);                     /* clear */
+            XUngrabServer(display);
+            recalculate_sweep(c, old_cx, old_cy,
+                              ev.xmotion.x, ev.xmotion.y);
+            XSync(display, False);
+            XGrabServer(display);
+            draw_outline(c);
+            break;
+        case ButtonRelease:
+            draw_outline(c);                     /* clear */
+            XUngrabServer(display);
+            XUngrabPointer(display, CurrentTime);
+            return;
+        }
+    }
 …
 void
 drag(Client *c)
+drag(Client * c)
+{
     Window root = ROOTWINDOW;
 …
         XMaskEvent(display, MouseMask, &ev);
         switch (ev.type) {
             case MotionNotify:
                 draw_outline(c);    /* clear */
                 XUngrabServer(display);
                 c->x = old_cx + (ev.xmotion.x - x1);
                 c->y = old_cy + (ev.xmotion.y - y1);
                 XSync(display, False);
                 XGrabServer(display);
                 draw_outline(c);
                 break;
             case ButtonRelease:
                 draw_outline(c);    /* clear */
                 XUngrabServer(display);
                 XUngrabPointer(display, CurrentTime);
                 return;
             default:
                 break;
+        case MotionNotify:
+            draw_outline(c);                     /* clear */
+            XUngrabServer(display);
+            c->x = old_cx + (ev.xmotion.x - x1);
+            c->y = old_cy + (ev.xmotion.y - y1);
+            XSync(display, False);
+            XGrabServer(display);
+            draw_outline(c);
+            break;
+        case ButtonRelease:
+            draw_outline(c);                     /* clear */
+            XUngrabServer(display);
+            XUngrabPointer(display, CurrentTime);
+            return;
+        default:
+            break;
+        }
+    }
 …
 void
 move(Client *c, int set)
+move(Client * c, int set)
+{
     if (!set)
 …
 void
 resize(Client *c, int set)
+resize(Client * c, int set)
+{
     if (!set)
 …
 void
 maximise_horiz(Client *c)
+maximise_horiz(Client * c)
+{
     if (c->oldw) {
 …
 void
 maximise_vert(Client *c)
+maximise_vert(Client * c)
+{
     if (c->oldh) {
 …
 void
 hide(Client *c)
+hide(Client * c)
+{
     c->ignore_unmap = 2;
 …
 void
 unhide(Client *c, int raiseit)
+unhide(Client * c, int raiseit)
+{
     c->ignore_unmap = 0;
     XMapWindow(display, c->window);
+    raiseit ? XMapRaised(display, c->parent) : XMapWindow(display, c->parent);
+    raiseit ? XMapRaised(display, c->parent) : XMapWindow(display,
+                                                          c->parent);
     set_wm_state(c, NormalState);
+}
 …
 void
 next(Client *c)
+next(Client * c)
+{
     Client *newc;
     newc = next_client_on_vdesk(( c ? c : head_client));
+    newc = next_client_on_vdesk((c ? c : head_client));
     if (!newc)
         return;         /* couldn't find a next on this screen */
+        return;                                  /* couldn't find a next on this screen */
     focus_client(newc, RAISE);
 …
 void
 focus_client(Client *c, int raiseit)
+focus_client(Client * c, int raiseit)
+{
     Client *cp;
 …
 void
 unfocus_client(Client *c)
+unfocus_client(Client * c)
+{
     XSetInputFocus(display, PointerRoot, RevertToPointerRoot, CurrentTime);

ldm/trunk/fuentes/wwm/sendkey.c

-                      r516
+                      r855
 void
 key_to_event(KeySym key, XEvent *event, Window w, int type)
+key_to_event(KeySym key, XEvent * event, Window w, int type)
+{
     event->xkey.type    = type;
+    event->xkey.type = type;
     event->xkey.display = display;
     event->xkey.root    = RootWindow(display, DefaultScreen(display));
     event->xkey.time    = CurrentTime;
     event->xkey.x       = event->xkey.y = 0;
     event->xkey.x_root  = event->xkey.y_root = 0;
     event->xkey.state   = WMMODMASK;
     event->xkey.window  = w;
+    event->xkey.root = RootWindow(display, DefaultScreen(display));
+    event->xkey.time = CurrentTime;
+    event->xkey.x = event->xkey.y = 0;
+    event->xkey.x_root = event->xkey.y_root = 0;
+    event->xkey.state = WMMODMASK;
+    event->xkey.window = w;
     event->xkey.keycode = XKeysymToKeycode(display, key);
+}

Context Navigation

Legend:

Download in other formats: