# [XDM] Sélecteur de sessions

## DidgeriDude

A la suite de plusieurs posts à propos de la possibilité avec XDM de créer un menu permettant de choisir la session (ou le gestionnaire de bureau et/ou de fenêtres), je me propose de vous fournir le résultat (même si tout n'est pas encore terminé) de mes idées à ce propos.

Ceci n'est en rien un tutorial, tout au plus quelques scripts que je vais essayer de vous détailler et qui répondent à mes besoins, juste au cas où certains parmi vous sont intéressés par cette idée qui se décline en 2 points : un menu pour choisir une session, et un moyen de s'en souvenir pour les connexions ultérieures.

Avant de commencer, le fond d'écran et la config complète

Tout d'abord, sachant que je répugne à toucher aux scripts par défaut qui sont succeptibles d'être écrasés par une mise à jour, j'ai modifié /etc/X11/xdm/xdm-config comme ci-après afin de définir les fichiers de config personnels que je vais utiliser :

/etc/X11/xdm/xdm-config :

```
! $Xorg: xdm-conf.cpp,v 1.3 2000/08/17 19:54:17 cpqbld Exp $

! $XdotOrg: $

!

!

!

!

! $XFree86: xc/programs/xdm/config/xdm-conf.cpp,v 1.10 2002/11/30 19:11:32 herrb

Exp $

!

!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

!!  Configuration perso de XDM  !!

!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

DisplayManager*resources:       /etc/X11/xdm/Xresources_perso

DisplayManager._0.setup:        /etc/X11/xdm/Xsetup_perso_0

DisplayManager._0.startup:      /etc/X11/xdm/GiveConsole_perso_0

DisplayManager._0.reset:        /etc/X11/xdm/TakeConsole_perso_0

DisplayManager*session:         /etc/X11/Sessions/Xsession_perso

!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

!  Configuration initiale de XDM  !

!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

! DisplayManager*resources:     /etc/X11/xdm/Xresources

! The following three resources set up display :0 as the console.

! DisplayManager._0.setup:      /usr/lib/X11/xdm/Xsetup_0

! DisplayManager._0.startup:    /usr/lib/X11/xdm/GiveConsole

! DisplayManager._0.reset:      /usr/lib/X11/xdm/TakeConsole

! DisplayManager*session:       /usr/lib/X11/xdm/Xsession

!---------------------------------!

DisplayManager.errorLogFile:    /var/log/xdm.log

DisplayManager.pidFile:         /var/run/xdm.pid

DisplayManager.keyFile:         /etc/X11/xdm/xdm-keys

DisplayManager.servers:         /etc/X11/xdm/Xservers

DisplayManager.accessFile:      /etc/X11/xdm/Xaccess

DisplayManager.willing:         /usr/lib/X11/xdm/Xwilling

! All displays should use authorization, but we cannot be sure

! X terminals may not be configured that way, so they will require

! individual resource settings.

DisplayManager*authorize:       true

DisplayManager*chooser:         /usr/lib/X11/xdm/chooser

DisplayManager*startup:         /usr/lib/X11/xdm/Xstartup

DisplayManager*reset:           /usr/lib/X11/xdm/Xreset

DisplayManager*authComplain:    true

DisplayManager*loginmoveInterval:       10

! SECURITY: do not listen for XDMCP or Chooser requests

! Comment out this line if you want to manage X terminals with xdm

DisplayManager.requestPort:     0
```

Il est maintenant temps de rentrer dans le vif du sujet et de présenter les fichiers de configuration correspondants.

Tou d'abord, /etc/X11/xdm/Xsetup_perso_0, qui est le fichier exécuté au démarrage d'XDM et qui va contenir toutes les actions à effectuer pour personnaliser l'affichage de celui-ci.

Le mien contient :

le chargement du fond d'écran

la création de deux boutons pour Redémarrer ou Arrêter la machine. Pour ceux-ci, j'utilise xmessage qui n'aime pas les accents d'où les codes zarbis pour les afficher... Il est possible que j'en vienne à utiliser Tcl pour ces boutons mais pour l'instant ça marche comme ça !

la création du sélecteur de Session (que je détaillerai juste après)

la commande pour prendre un screenshot 10 secondes après le chargement

/etc/X11/xdm/Xsetup_perso_0 :

```
#!/bin/sh

# Configuration perso de XDM

#----------------------------

# Affiche l'image de fond en plein écran

xsetroot -cursor_name left_ptr

xsetbg -fullscreen /etc/X11/xdm/.xdm.png

[ -f /var/tmp/wmrc_$DISPLAY.tmp ] && rm -f /var/tmp/wmrc_$DISPLAY.tmp

(

/etc/X11/xdm/menubuttons

)&

echo $! > /var/run/menubuttons_$DISPLAY.pid

# Affiche les boutons "Arrêter" et "Redémarrer"

(xmessage -buttons Arr$'\352'ter:101,Red$'\351'marrer:102 ""

  CONTROL=$?

  if [ "$CONTROL" = 101 ]

  then

    /etc/init.d/xdm stop && /sbin/shutdown -h now 2>/dev/console >/dev/console

  elif [ "$CONTROL" = 102 ]

  then

    /etc/init.d/xdm stop && /sbin/shutdown -r now 2>/dev/console >/dev/console

  else

    echo "Xmessage closed on $(date)"

  fi

)&

echo $! > /var/run/xdm_xmessage_$DISPLAY.pid

# Prend un screenshot de l'écran de connexion après 10 secondes

(import -pause 10 -window root -quality 100 /etc/X11/xdm/screenshot.png

)&
```

Voici maintenant le script /etc/X11/xdm/menubuttons qui crée le menu de sélection dont je vais essayer de détailler le fonctionnement.

Il est écrit en Tcl. Son rôle est de créer des boutons correspondant à chaque session (gestionnaires de bureau et/ou de fenêtres) disponible. Ces sessions sont lancées par les scripts présents dans /etc/X11/Sessions. Il me fallait donc un bouton par session, en excluant Xsession et Xsession_perso.

Plutôt que de créer des boutons avec un texte dedans, j'ai touvé plus sympa d'utiliser, quand c'était possible, le logo de chaque gestionnaire. J'ai donc créé des images et ce sont celles-ci qui sont affichées dans les boutons. La restriction de Tcl quant aux formats des images m'a fait choisir le format ppm, bien que celui-ci ne gère pas la transparence, mais vu que mon fond d'écran est blanc à l'endroit où les boutons sont affichés, cela n'est, à l'heure actuelle, pas un problème pour moi.

Le dossier /etc/X11/xdm/images contient toutes les images des sessions, ainsi que 2 autres : "default" et "failsafe". A partir de ces fichiers (qui sont numérotés afin de donner un ordre d'affichage), les boutons sont créés automatiquement (quelque soit leur nombre, et indépendamment des fichiers présents dans /etc/X11/Sessions). Une image /etc/X11/xdm/session.ppm affiche "Session :" en regard du menu de sélection. Elle pourrait être avec les autres images, mais pas envie de la changer de place pour le moment !

Le fichier gère l'affichage en fonction de la hauteur en pixels de l'écran (1024 pour moi) mais il faut le changer dans le script manuellement (j'ai pensé à xdpyinfo, mais avec Xinerama, ça ne marchait pas et je n'avais pas envie de me prendre la tête avec !).

Enfin, le script donne comme fonction aux boutons, en plus de leur affichage particulier (centré sur la dernière sélection), de mettre le nom de la session choisie dans un fichier temporaire /var/tmp/wmrc_$DISPLAY.tmp (le display est là car j'ai 2 serveurs X en même temps, mais ça marche bien avec un seul !). Ce fichier est utilisé par le script /etc/X11/chooser.sh.

/etc/X11/xdm/menubuttons :

```
#!/usr/bin/wish

##########################################################################

##  Définition des variables                                            ##

##  ------------------------                                            ##

##   liste_sessions : contient la liste récupérée à partir des          ##

##          images présentes dans le dossier './images'.                ##

##          Ces fichiers ont pour extension '.ppm' et                   ##

##          ont un nom commençant par un nombre 'xx'                    ##

##          afin de déterminer l'ordre d'affichage.                     ##

##   nbr_boutons :    nombre de boutons (donc de sessions).             ##

##   htr_boutons :    hauteur de chaque bouton (en pixels).             ##

##   lgr_boutons :    largeur de chaque bouton (en pixels).             ##

##   esp_boutons :    espace (vertical) inter-boutons (en pixels).      ##

#####                                                               ######

##   actif :       nom de la session '[0-9][0-9]-session' qui           ##

##          est affiché (bouton seul, après le choix).                  ##

##   index_actif :    rang de la session active dans la liste.          ##

##   actif_y :    ordonnée (en pixels) à laquelle afficher              ##

##          le bouton actif.                                            ##

#####                                                               ######

##   htr_totale :    hauteur totale de la fenêtre (container).          ##

##   lgr_totale :    largueur totale de la fenêtre (container).         ##

##                                                                      ##

##########################################################################

set display $env(DISPLAY)

set wmrc_tmp "/var/tmp/wmrc_$display.tmp"

set rep "/etc/X11/xdm"

set liste_sessions "[exec ls $rep/images | sed -e "s/\.ppm//g"]"

set nbr_boutons [llength $liste_sessions]

set htr_boutons 30

set lgr_boutons 100

set esp_boutons 10

set actif [lindex $liste_sessions 0]

set index_actif 0

set actif_y [expr ($nbr_boutons-1)*($htr_boutons+$esp_boutons)]

set htr_totale [expr (2*$nbr_boutons-1)*$htr_boutons+(2*$nbr_boutons-2)*$esp_boutons+4]

set lgr_totale [expr 2*$lgr_boutons+14]

set place_htr [expr round((1024-$htr_totale)/4)]

# Création des boutons

#----------------------

proc creer_boutons liste {

    global rep

    foreach session $liste {

        image create photo img_$session -file "$rep/images/$session.ppm"

        button .bouton_$session -image img_$session \

            -background white \

            -activebackground white \

            -highlightthickness 1 \

            -relief flat -overrelief raised \

            -borderwidth 0 \

            -command "commande $session"

    }

}

# Fonction associée aux boutons

#-------------------------------

proc commande item {

    global actif liste_sessions actif_y wmrc_tmp

    set actif $item

    foreach sess $liste_sessions {

        place forget .bouton_$sess

    }

    place .bouton_$actif -x 108 -y $actif_y -anchor nw -bordermode outside

    .bouton_$actif configure -command menu_sessions

    exec echo $item | sed -e "s/^\[0-9\]*-//" > $wmrc_tmp

}

# Fonction affichant toutes les sessions

#----------------------------------------

proc menu_sessions {} {

    global actif liste_sessions htr_boutons esp_boutons actif_y

    place forget .bouton_$actif

    set i [expr -[lsearch $liste_sessions $actif]]

    foreach sess $liste_sessions {

        place .bouton_$sess -x 108 -y [expr $actif_y+($htr_boutons+$esp_boutons)*$i] -anchor nw -bordermode outside

        incr i

    }

    .bouton_$actif configure -command "commande $actif"

}

# Corps du programme

#--------------------

wm geometry . ${lgr_totale}x${htr_totale}+20+$place_htr

. configure -background white -borderwidth 1

image create photo img_sessions -file "$rep/sessions.ppm"

        button .bouton_sessions -image img_sessions \

            -background white \

            -activebackground white \

            -highlightthickness 0 \

            -relief flat \

            -borderwidth 0

creer_boutons $actif

place .bouton_sessions -x 2 -y $actif_y -anchor nw -bordermode outside

place .bouton_$actif -x 108 -y $actif_y -anchor nw -bordermode outside

.bouton_$actif configure -command menu_sessions

creer_boutons [lreplace $liste_sessions $index_actif $index_actif]
```

Les deux fichiers suivants contiennent les commandes effectuées lorsqu'on se connecte (GiveConsole) et lorsqu'on retourne à XDM après sa session (TakeConsole).

/etc/X11/xdm/GiveConsole_perso_0 :

```
#!/bin/sh

# Assign ownership of the console to the invoking user

# $Xorg: GiveConsole,v 1.3 2000/08/17 19:54:17 cpqbld Exp $

#

# By convention, both xconsole and xterm -C check that the

# console is owned by the invoking user and is readable before attaching

# the console output.  This way a random user can invoke xterm -C without

# causing serious grief.

#

chown $USER /dev/console

# Enlève les boutons "Arrêter" et "Redémarrer", et le menu des sessions

#-----------------------------------------------------------------------

if test -r /var/run/xdm_xmessage_$DISPLAY.pid

then

    pkill -KILL -P $(cat /var/run/xdm_xmessage_$DISPLAY.pid) xmessage

    rm -f /var/run/xdm_xmessage_$DISPLAY.pid

fi

if test -r /var/run/menubuttons_$DISPLAY.pid

then

    kill -KILL $(cat /var/run/menubuttons_$DISPLAY.pid)

    rm -f /var/run/menubuttons_$DISPLAY.pid

fi
```

/etc/X11/xdm/TakeConsole_perso_0 :

```
#!/bin/sh

# Reassign ownership of the console to root, this should disallow

# assignment of console output to any random users's xterm

# $Xorg: TakeConsole,v 1.3 2000/08/17 19:54:17 cpqbld Exp $

#

chmod 622 /dev/console

chown root /dev/console

/usr/bin/sessreg -d -w "/var/log/wtmp" -u "/var/run/utmp" \

        -x "/etc/X11/xdm/Xservers" -l $DISPLAY -h "" $USER

[ -f /var/tmp/wmrc_$DISPLAY.tmp ] && rm -f /var/tmp/wmrc_$DISPLAY.tmp
```

Voici ensuite le fichier de ressources pour configurer l'affichage.

Je ne me suis pas encore trop penché sur le style à donner à mon écran de connexion, donc cela reste très basique, surtout pour les polices. A noter que depuis la version 1.2 de xorg-server, XDM utilise XFT pour les polices !

/etc/X11/xdm/Xresources_perso :

```

!------------------------------!

!  Configuration perso de XDM  !

!------------------------------!

! Raccourcis clavier

!--------------------

xlogin*login.translations: #override \

        Ctrl<Key>R: abort-display()\n\

        <Key>F1: set-session-argument(terminal) finish-field()\n\

        <Key>Delete: delete-character()\n\

        <Key>Left: move-backward-character()\n\

        <Key>Right: move-forward-character()\n\

        <Key>Home: move-to-begining()\n\

        <Key>End: move-to-end()\n\

        Ctrl<Key>KP_Enter: set-session-argument(terminal) finish-field()\n\

        <Key>KP_Enter: set-session-argument() finish-field()\n\

        Ctrl<Key>Return: set-session-argument(terminal) finish-field()\n\

        <Key>Return: set-session-argument() finish-field()

! Position

!----------

!xlogin*geometry: 220x160-0+0

! Couleurs

!----------

Xcursor.theme: Jimmac

xlogin*background: white

xlogin*foreground: black

xlogin*greetColor: black

xlogin*promptColor: grey80

xlogin*failColor: red

!xlogin*borderColor: grey50

!xlogin*shdColor: black

!xlogin*hiColor: black

! Prompts

!---------

xlogin*titleMessage:    Xlogin

xlogin*greeting:        Bienvenue sur CLIENTHOST

xlogin*namePrompt:      Utilisteur :\040

xlogin*passwdPrompt:    Mot de passe :\040

xlogin*fail:            Perdu ! Recommence...

! Polices

!---------

! xlogin*greetFont: -adobe-helvetica-bold-o-normal--24-240-75-75-p-138-iso8859-1

! xlogin*font: -adobe-helvetica-medium-r-normal--18-180-75-75-p-98-iso8859-1

! xlogin*promptFont:

-adobe-helvetica-bold-r-normal--18-180-75-75-p-103-iso8859-1

! xlogin*failFont: -adobe-helvetica-bold-r-normal--18-180-75-75-p-103-iso8859-1

! xlogin*greetFont:     -misc-fixed-medium-r-normal-*-14-*-iso10646-1

! xlogin*font:          -misc-fixed-medium-r-normal-*-12-*-iso10646-1

! xlogin*promptFont:    -misc-fixed-medium-r-normal-*-12-*-iso10646-1

! xlogin*failFont:      -misc-fixed-medium-r-normal-*-12-*-iso10646-1

xlogin*greetFace:       Fixed-14

xlogin*face:            Fixed-12

xlogin*promptFace:      Fixed-12

xlogin*failFace:        Fixed-12

! Bordures

!----------

xlogin*borderWidth:      0

xlogin*frameWidth:       0

xlogin*innerFramesWidth: 0

! Ressources pour Xmessage

!--------------------------

Xmessage*geometry:              210x30+532+460

Xmessage*background:            white

Xmessage*foreground:            darkgrey

Xmessage*Font:                  -misc-fixed-*-*-*-*-13-120-*-*-*-*-iso10646-1

Xmessage*borderWidth:           0

Xmessage*message.scrollVertical:        Never

Xmessage*message.scrollHorizontal:      Never

Xmessage*Text*background:       white

Xmessage*Text*foreground:       darkgrey

Xmessage*Text.borderColor:      white

Xmessage*Text.borderWidth:      0

Xmessage*Text*font:             -misc-fixed-*-*-*-*-15-140-*-*-*-*-iso10646-1

Xmessage*width:                 95
```

Enfin, voilà le c½ur de la sélection de session. 2 fichiers s'en chargent /etc/X11/Sessions/Xsession_perso et plus particulièrement /etc/X11/chooser.sh. Ce dernier fichier ne me semblait plus utilisé par la dernière version de XDM, mais je l'ai gardé plutôt que de surcharger de tests Xsession_perso (adapté du Xsession actuel).

Le fichier Xsession_perso est toujours exécuté à chaque connexion réussie. Il doit donc se charger de lancer le bon script, les bons fichiers de config (personnels ou généraux), etc., mais suivant un certain ordre, ce que se charge aussi de faire le script /etc/X11/chooser.sh.

Succintement (euh...), le premier fichier à prendre en compte pour la connexion est /var/tmp/wmrc_$DISPLAY.tmp s'il existe. Si oui, son contenu est copié dans le répertoire personnel de l'utilisateur afin d'être utilisé par la suite. Sinon, le fichier $HOME/.wmrc est utilisé s'il existe.

Il se pose alors le souci si ces fichiers contiennent "Default" ou "Failsafe" :

Dans le cas de "Default", les fichiers ou variables suivants sont pris en compte dans l'ordre de leur existence : $HOME/.xsession, $HOME/.Xclients, $XSESSION (définie dans rc.conf) et enfin /etc/X11/xinit/Xclients. Peut-être les 2 derniers seraient-ils mieux dans l'ordre inverse, mais bon...

Si rien de tout cela n'existe, xsm est lancé, tout comme dans le cas où "Failsafe" est sélectionné !

/etc/X11/Sessions/Xsession_perso :

```
#!/bin/sh

# $XConsortium: Xsession /main/10 1995/12/18 18:21:28 gildea $

source /etc/profile

case $# in

1)

   case $1 in

   terminal)

      exec xterm -geometry 80x24-0-0

      ;;

   esac

esac

# redirect errors to a file in user's home directory if we can

for errfile in "$HOME/.xsession-errors" "${TMPDIR-/tmp}/xses-$USER" "/tmp/xses-$USER"

do

   if ( cp /dev/null "$errfile" 2> /dev/null )

   then

      chmod 600 "$errfile"

      exec > "$errfile" 2>&1

      break

   fi

done

# clean up after xbanner

if which freetemp 2> /dev/null ; then

   freetemp

fi

startup=$HOME/.xsession

startup2=$HOME/.Xclients

userresources=$HOME/.Xresources 

usermodmap=$HOME/.Xmodmap 

userxkbmap=$HOME/.Xkbmap

sysresources=/etc/X11/Xresources 

sysmodmap=/etc/X11/Xmodmap 

sysxkbmap=/etc/X11/Xkbmap

rh6sysresources=/etc/X11/xinit/Xresources 

rh6sysmodmap=/etc/X11/xinit/Xmodmap 

# merge in defaults

if [ -f "$rh6sysresources" ]; then

    xrdb -merge "$rh6sysresources"

fi

if [ -f "$sysresources" ]; then

    xrdb -merge "$sysresources"

fi

if [ -f "$userresources" ]; then

    xrdb -merge "$userresources"

fi

# merge in keymaps

if [ -f "$sysxkbmap" ]; then

    setxkbmap `cat "$sysxkbmap"`

    XKB_IN_USE=yes

fi

if [ -f "$userxkbmap" ]; then

    setxkbmap `cat "$userxkbmap"`

    XKB_IN_USE=yes

fi

#

# Eeek, this seems like too much magic here

#

if [ -z "$XKB_IN_USE" -a ! -L /etc/X11/X ]; then

    if grep '^exec.*/Xsun' /etc/X11/X > /dev/null 2>&1 && [ -f /etc/X11/XF86Config ]; then

       xkbsymbols=`sed -n -e 's/^[     ]*XkbSymbols[   ]*"\(.*\)".*$/\1/p' /etc/X11/XF86Config`

       if [ -n "$xkbsymbols" ]; then

           setxkbmap -symbols "$xkbsymbols"

           XKB_IN_USE=yes

       fi

    fi

fi

# xkb and xmodmap don't play nice together

if [ -z "$XKB_IN_USE" ]; then

    if [ -f "$rh6sysmodmap" ]; then

       xmodmap "$rh6sysmodmap"

    fi

    if [ -f "$sysmodmap" ]; then

       xmodmap "$sysmodmap"

    fi

    if [ -f "$usermodmap" ]; then

       xmodmap "$usermodmap"

    fi

fi

unset XKB_IN_USE

if [ -f /var/tmp/wmrc_$DISPLAY.tmp ]

then

   [ "$(cat /var/tmp/wmrc_$DISPLAY.tmp)" = "failsafe" ] && startup="" && startup2=""

elif [ -f $HOME/.wmrc ]

then

   [ "$(cat $HOME/.wmrc)" = "failsafe" ] && startup="" && startup2=""

fi

# First run the system default.  Because KDE uses this

# to switch sessions, we MUST first check the system

# default, and then ~/.xsession.  If the user Do not

# want this, he should override XSESSION, or at least

# clear it.

if [ -n "`/etc/X11/chooser.sh`" ]

then

   exec "`/etc/X11/chooser.sh`"

elif [ -x "$startup" ]

then

   exec "$startup"

elif [ -x "$startup2" ]

then

   exec "$startup2"

elif [ -x /etc/X11/xinit/Xclients ]

then

   exec /etc/X11/xinit/Xclients

elif [ -x /etc/X11/Xclients ]

then

   exec /etc/X11/Xclients

else

   exec xsm

fi
```

/etc/X11/chooser.sh :

```
#!/bin/sh

# It may be useful to have $XSESSION defined

if [ -z "${XSESSION}" ]

then

   [ -f /etc/rc.conf ] && source /etc/rc.conf

fi

user_current_wm="/var/tmp/wmrc_$DISPLAY.tmp"

user_saved_wm="$HOME/.wmrc"

wm_tmp=""

choice_default=false

GENTOO_SESSION=""

if [ -f ${user_current_wm} ]

then

   wm_tmp="$(cat ${user_current_wm})"

   if [ ${wm_tmp} != "default" ]

   then

      for x in /etc/X11/Sessions/*

      do

         if [ "$(echo ${x##*/} | awk '{ print toupper($1) }')" \

            = "$(echo ${wm_tmp} | awk '{ print toupper($1) }')" ]

         then

            GENTOO_SESSION=${x}

            break

         fi

      done

   else

      choice_default=true

   fi

   mv -f $user_current_wm $user_saved_wm

elif [ -f ${user_saved_wm} ]

then

   wm_tmp="$(cat ${user_saved_wm})"

   if [ ${wm_tmp} != "default" ]

   then

      for x in /etc/X11/Sessions/*

      do

         if [ "$(echo ${x##*/} | awk '{ print toupper($1) }')" \

            = "$(echo ${wm_tmp} | awk '{ print toupper($1) }')" ]

         then

            GENTOO_SESSION=${x}

            break

         fi

      done

   else

      choice_default=true

   fi

fi

if [ -z "${GENTOO_SESSION}" ]

then

   # Find a match for $XSESSION in /etc/X11/Sessions

   # because of the choice of "default" in the menu 

   # or the "default" entry in $HOME/.wmrc

   # or if no choice has been made and no file $HOME/.wmrc

   for x in /etc/X11/Sessions/*

   do

      if [ "$(echo ${x##*/} | awk '{ print toupper($1) }')" \

         = "$(echo ${XSESSION} | awk '{ print toupper($1) }')" ]

      then

         GENTOO_SESSION=${x}

         choice_default=true

         break

      fi

   done

fi

GENTOO_EXEC=""

if [ -n "${GENTOO_SESSION}" ]

then

   if [ -x "${GENTOO_SESSION}" ]

   then

      GENTOO_EXEC="${GENTOO_SESSION}"

   else

      GENTOO_EXEC="/bin/sh ${GENTOO_SESSION}"

   fi

elif [ -n "${XSESSION}" ]

then

   x=""

   for x in "${XSESSION}" \

      "`echo ${XSESSION} | awk '{ print toupper($1) }'`" \

      "`echo ${XSESSION} | awk '{ print tolower($1) }'`"

   do

      # Fall through ...

      if [ -x "`which ${x} 2>/dev/null`" ]; then

         GENTOO_EXEC="`which ${x} 2>/dev/null`"

         break

      fi

   done

fi

[ ${choice_default} = true ] && [ -s "${HOME}/.xsession" -o -s "${HOME}/.Xclients" ] && GENTOO_EXEC=""

[ ! "${GENTOO_EXEC##*/}" = "Xsession_perso" -a ! "${GENTOO_EXEC##*/}" = "Xsession" ] && echo "${GENTOO_EXEC}" || echo ""
```

Le test de la dernière ligne est là dans le cas où la variable XSESSION contiendrait "Xsession_perso" ou "Xsession" (ce qui est débile, je le conçois !)

Voilà, en espérant que cela puisse être utile pour certains qui aimeraient se lancer dans la configuration de XDM.

Je pense sincèrement qu'on peut faire à peu près tout ce dont on a envie avec... Il suffit de mettre les mains dans le cambouis, et d'avoir du temps !

Amusez-vous bien, et surtout n'hésitez pas à porter ici vos remarques ou critiques éventuelles...

----------

## DidgeriDude

Ben rien de plus à ajouter, à part le fait que j'ai donné les liens vers la config...

----------

## 77T

Bonjour,

excellent tutoriel, fournit une bonne base à une personnalisation de XDM, que j'utilise pour ça légèreté...

J'ai toutefois un problème: pouvez vous connecter un utilisateur qui a un accent (é è ou à....) dans son mot de passe?

J'ai configuré les polices de Xresources, mais ça ne fonctionne pas! Mes locales sont fr_FR.UTF-8, avec un clavier pc105, fr, oss.

----------

## DidgeriDude

Je n'ai jamais fait le test...

Une idée naïve me souffle que cela ne devrait pas dépendre du gestionnaire de connexion mais après tout... pourquoi pas...

----------

