# En qué display estoy?? (medio cerrado)

## aj2r

Mi pregunta no es exactamente la del título, es si conocéis algún comando que diga qué tty o display está siendo mostrado en ese momento por pantalla. GraciasLast edited by aj2r on Mon Sep 19, 2005 11:28 am; edited 2 times in total

----------

## 2lopez

Simplemente teclea

```
$ tty

/dev/tty1
```

y te indicará la consola en que te encuentras.

Un saludo

----------

## aj2r

Ya, pero eso en mi caso no sirve. Me explico, si lo meto en un script del ACPI por ejemplo, al ejecutarse no se encuentra en ningún tty, y yo lo que quiero saber es que tty se está mostrando por pantalla.

----------

## psm1984

¿y para que quieres saber en que display estas?   :Rolling Eyes: 

----------

## aj2r

Porque si sé en que display estoy, puedo saber si se están ejecutando o no las X en ese display.

----------

## LinuxBlues

Pues realmente es algo muy sencillo, pero a la vez muy complicado... Depende de varias cosas.

En primer lugar yo no optaría por saber si estoy ejecutando las X con el DISPLAY, 

echo $DISPLAY

mostrará :0.0 (u otra dependiendo de si ejecuta en otros o no) bajo una xterm y todas sus variantes gnome-terminal, konsole, etc., pero si pulsamos CTRL+ALT+F1 no devolverá ningún resultado aunque las X se estén ejecutando.

Probaría con otras opciones, pero depende de las pretensiones de tu script:

Comprobar si existe /tmp/.X0-lock ; si existe las X se están ejecutando, y ese archivo contiene su PID; lamentablemente Gentoo no borra por defecto /tmp/ (y no conozco otra distro que lo haga), a no ser que tengamos en /etc/conf.d/bootmisc la opción: WIPE_TMP="yes". Por lo tanto es muy probable que ese archivo esté presente en todos los sistemas si no se borra /tmp/ (se re-escribe cada vez que se inician las X).

Otra opción, esta más segura, pero depende de cada escritorio, sería comprobar si existe /var/run/gdm.pid; si existe, un usuario de gdm está ejecutando las X, si no, estamos en modo texto... Se abren muchas posibilidades... kdm.pid etc.

La forma más sensata que se me ocurre de mirar si las X se están ejecutando es esa... buscar PIDs ("ps aux" también los muestra). Porque con lo del tty o el DISPLAY no lo termino de ver muy claro...

echo $WINDOWID también devuelve resultados si estamos en las X, y no si cambiamos con CTRL+ALT+F1 (aunque las X se sigan ejecutando) a otra terminal.

----------

## aj2r

Gracias por tu respuesta LinuxBlues, pero no es lo que ando buscando, me tendré que explicar mejor. Mi idea es que en el script que uso con ACPI que se lanza cuando pulso el botón de apagado de mi portátil pueda distinguir si en ese momento en pantalla se está mostrando un entorno X o un terminal para así hacer una cosa u otra.

----------

## pcmaster

Para saber si se están ejecutando las X... ¿qué tal este comando?:

```
ps -e | grep xinit
```

o también

```
ps -e | grep X
```

Si las X están en ejecución, devolverá el proceso de dicho programa (X o xinit) si no, no devolverá nada. Y te dará el mismo resultado en cualquier consola de modo texto o terminal en modo gráfico.

----------

## aj2r

Ya, pero no me basta con saber si se están ejecutando las X, lo que necesito saber es si se están ejecutando en el terminal que se está mostrando en pantalla en ese momento con un comando que sea ejecutado en un terminal diferente al que se está mostrando en pantalla.

----------

## pcmaster

Ya entiendo: quieres que si estás en modo texto, al pulsar el interruptor se apague directamente, pero que si estás en modo gráfico te salga una ventanita pidiéndote salir ¿verdad?

Suena bien, pero ¿Qué quieres que haga cuando aprietes el interruptor, si las X están cargadas pero estás en modo texto (por haber cambiado pulsando <alt><F1-F6>)? Lo lógico sería, que, estando cargadas las X, cambiase al terminal 7 (el gráfico) y también te preguntase. Recuerda además que, aunque por defecto sean 6 terminales y el séptimo el gráfico, puede cambiarse.

----------

## aj2r

Pues tienes razón, pero para el que quiera saberlo he encontrado el comando que buscaba

```
fgconsole
```

devuelve el numero de la consola activa.

----------

## pcmaster

Por si te sirve.

Acabo de encontrar el comando para cambiar el terminal activo:

chvt 1 para ir a la consola 1

chvt 2 para ir a la 2, etc

si pongo chvt 7 me vuelve al modo gráfico, pero desde una consola de modo grafico, chvt 1 no vuelve al modo texto como usuario, sólo si lo ejecuto como root.

Así, que el algoritmo de tu script podría ser algo así:

```

if estan activas las x, 

 then ir al terminal grafico, 

      pregunta si quieres salir.

      if respuesta= "no"

         then salir del script

      fi

fi

apagar
```

o algo parecido

----------

## aj2r

Ahora mi problema está en saber en qué tty se están ejecutando las X, alguien sabe como hacerlo?

----------

## aj2r

Me respondo a mi mismo (pero si alguien conoce un método mejor será bienvenido   :Wink:  )

```

DISPLAYS=`ls /tmp/.X*-lock | cut -b 8`

for D in $DISPLAYS; do

   CONSOLES="$CONSOLES `cat /var/log/Xorg.$D.log | grep -i 'using vt number' | cut -f 5 -d ' '` "

done

echo $CONSOLES

```

----------

## aj2r

Ya tengo casi el script, lo único que me falla ya es que no sé como averiguar qué session-manager está en que tty. Alguien sabe como descubrir la relación entre los socket que hay en el interior de la carpeta /tmp/.ICE-unix y los tty??

----------

## pcmaster

Bueno, con eso  ¿quieres que el script haga algo especial con varios monitores, teniendo cada uno un session-manager diferente?.

Porque si supones que el el sistema sólo habrá un session-manager, podrías hacer algo así:

```
$ ps -e | grep session
```

para averiguar cuál es (en mi equipo, sale que se está ejecutando xfce4-session)

Ya has conseguido averiguar en qué VT están las X y ya dije antes cómo cambiar al vt que quieras.

----------

## aj2r

Otra vez no me he explicado bien   :Laughing: 

Bueno, a ver, yo uso gnome y para que cuando pulso el botón de power me muestre el menú de logout en el script debo tener algo parecido a esto:

```

su - $USER -c "( 

       export DISPLAY=$DISPLAY SESSION_MANAGER=$SESSION_MANAGER

       xscreensaver-command -deactivate

       gnome-session-save --kill

   )"

```

donde $SESSION_MANAGER es algo del estilo

```

local/$HOSTNAME:/tmp/.ICE-unix/$SID

```

Mi problema es que si hay varias sesiones X abiertas a la vez por un mismo usuario pues hay varios socket ($SID) en la carpeta /tmp/.ICE-unix pertenecientes a este, y no soy capaz de decir que socket corresponde a que display.

Alguien sabe como conocer con qué display está relacionado cada socket???

----------

## pcmaster

Mientras escribías he estado haciendo pruebas...

Prueba este script:

```
#!/bin/bash

for D in `ls /tmp/.ICE-unix`; do

  TEMP=`ps -ej|grep $D`

  MANAGER=`echo $TEMP|cut -d " " -f 1,6`

  echo $MANAGER

done

```

Claro que yo sólo tengo una sesión X abierta. Pero me funciona:

```
AthlonXP ~/programas/scripts $ ls -l /tmp/.ICE-unix

total 0

srwxrwxrwx  1 user users 0 sep 19 12:48 10281

AthlonXP ~/programas/scripts $ ./procesos.sh

10281 xfce4-session

AthlonXP ~/programas/scripts $ 
```

¿Es lo que querías? El cut lo que hace es que muestre el socket y el proceso. También puedes obtener el PID del proceso (prueba sin el cut).

----------

## aj2r

Pero con eso sigo sin saber con qué display está relacionado el socket   :Sad: 

Lo que llevo de momento es esto:

```

#!/bin/sh

THIS=$0

MAX_WAIT=20 #segundos de espera

PATH_TO_SESSIONS=/tmp/.ICE-unix

LOCK=/var/run/console

ENCODE=nonexisting

if [ $# -eq 0 ]; then

   

    #la primera vez

    chmod a-x $THIS

    find $LOCK -type f -exec mv {} {}nonexisting \;

    #reparto con otros

    LIST=`who | grep -v tty | grep -v pts | cut -f "1 3" -d ' ' | tac `

    if [ "$LIST""X" != "X" ]; then

   logger "Lanzándo una nueva rama"

        sh $THIS $LIST

    else

   #listo para apagar

   logger "Apagando el sistema"

   chmod a+x $THIS

   cd $LOCK

   rename s/$ENCODE// *

   /sbin/init 0

    fi

else

    #seleccionando usuario y display

    USER=$1

    shift

    DISPLAY=$1

    shift

    D=`echo $DISPLAY | cut -b 2`

    #determinando la consola

   CONSOLE=`cat /var/log/Xorg.$D.log | grep -i 'using vt number' | cut -f 5 -d ' '`

    #comprobando si el usuario está en una sesión de gnome

   IN_GNOME=`ps aux | grep gnome-session | grep -v grep | grep -v ssh-agent | grep $USER | wc -l`

    if [ $IN_GNOME = 1 ]; then

   #determinando SESSION_MANAGER

   SESSIONS=`ls $PATH_TO_SESSIONS`

   for PID in $SESSIONS; do

       if [ `ls -l $PATH_TO_SESSIONS | grep $USER | grep $PID | wc -l` -eq 1 ];

then

      SESSION_MANAGER=local/$HOSTNAME:$PATH_TO_SESSIONS/$PID

      break;

       fi

   done

   chvt $CONSOLE

   logger "Cerrando sesión de gnome del usuario $USER"

   BEFORE=`ps -A | grep $PID | wc -l`

   su - $USER -c "( 

       export DISPLAY=$DISPLAY SESSION_MANAGER=$SESSION_MANAGER

       xscreensaver-command -deactivate

       gnome-session-save --kill

   )"

   INDEX=0

   while [ $INDEX -lt $MAX_WAIT ]; do

       if [ `ps -A | grep " $PID " | wc -l` -lt $BEFORE ]; then

      break

       fi

       INDEX=$(($INDEX+1))

       logger "Esperando"

       sleep 1

   done

   if [ `ps -A | grep " $PID " | wc -l` -ge $BEFORE ]; then

       logger "Cerrando - no ha sido posible cerrar la sesión de gnome para el usuario $USER"

       chvt $CONSOLE

       su - $USER -c "env DISPLAY=$DISPLAY zenity --info --text \"Cierre abortado\""

       chmod a+x $THIS

       cd $LOCK

       rename s/$ENCODE// *

       exit 1

   fi

    else

   #Gestor de ventanas desconocido

   logger "Gestor desconocido"

   chvt $CONSOLE

   su - $USER -c "env DISPLAY=$DISPLAY zenity --info --text \"Gestor desconocido\""

   chmod a+x $THIS

   cd $LOCK

   rename s/$ENCODE// *

   exit 1

    fi

    

    #continúa

    if [ $# -gt 0 ]; then

   logger "Lanzándo una nueva rama"

   #continúa con el siguiente usuario

   sh $THIS $@

    else

   logger "Sesiones de entorno gráfico cerradas"

   chmod a+x $THIS

   cd $LOCK

   rename s/$ENCODE// *

    fi

fi

```

Se me ha liao un poco la cosa   :Laughing: 

Si un usuario tiene abiertas varias sesiones X no funciona, y de momento tampoco funciona si no usas un xdm y has iniciado el entorno gráfico con startx por ejemplo (esto si puedo arreglarlo, pero toi liao con lo otro :s )

----------

## pcmaster

A ver si te entiendo.

Estás intentando averiguar cuántas sesiones X hay abiertas, y entonces quieres saber en qué terminal se muestra cada una.

¿Por qué no lees /tmp/.X11-unix? Yo es ese directorio tengo un archivo llamado X0. Supongo que habrá uno para cada sesión X. Seguramente los números (0, 1, etc) se corresponderán con los de los logs. 

Es decir, que el archivo X0 pertenezca a la misma sesión X que el log /var/log/Xorg.0.log, y que el archivo X1 a la misma sesión que /var/log/Xorg.1.log, y así sucesivamente.

A ver si acierto esta vez...

```
AthlonXP /tmp $ ls -l /tmp/.X*lock

-r--r--r--  1 root users 11 sep 19 12:48 /tmp/.X0-lock

AthlonXP /tmp $ cat /tmp/.X*lock

     10112

AthlonXP /tmp $ cat /var/log/Xorg.0.log|grep "using VT"

(--) using VT number 7

AthlonXP /tmp $ ps -ej| grep 10112

10112 10112 10096 ?        00:03:06 X

AthlonXP /tmp $

```

El terminal es el 7, y el 10096 es el SID que buscas ¿no?

Si haces un ps -ej verás que la primera columna es el PID de los procesos, la segunda es el PGID y la tercera el SID.

A ver si esta vez te sirve, o estoy más perdido que la aguja del pajar  :Smile:   :Smile:   :Smile: 

----------

## aj2r

Le he añadido para que finalice el XFCE4. Pruébalo a ver, que no estoy seguro de si se hace así   :Laughing: 

```

#!/bin/sh

THIS=$0

MAX_WAIT=20 #segundos de espera

PATH_TO_SESSIONS=/tmp/.ICE-unix

LOCK=/var/run/console

ENCODE=nonexisting

if [ $# -eq 0 ]; then

   

    #la primera vez

    chmod a-x $THIS

    find $LOCK -type f -exec mv {} {}nonexisting \;

    #reparto con otros

    LIST=`who | grep -v tty | grep -v pts | cut -f "1 3" -d ' ' | tac `

    if [ "$LIST""X" != "X" ]; then

   logger "Lanzándo una nueva rama"

        sh $THIS $LIST

    else

   #listo para apagar

   logger "Apagando el sistema"

   chmod a+x $THIS

   cd $LOCK

   rename s/$ENCODE// *

   /sbin/init 0

    fi

else

    #seleccionando usuario y display

    USER=$1

    shift

    DISPLAY=$1

    shift

    D=`echo $DISPLAY | cut -b 2`

    #determinando la consola

   CONSOLE=`cat /var/log/Xorg.$D.log | grep -i 'using vt number' | cut -f 5 -d ' '`

    #comprobando si el usuario está en una sesión de gnome

   IN_GNOME=`ps aux | grep gnome-session | grep -v grep | grep -v ssh-agent | grep $USER | wc -l`

    #comprobando si el usuario está en una sesión de XFCE4

   IN_XFCE4=`ps aux | grep xfce4-session | grep -v grep | grep -v ssh-agent | grep $USER | wc -l`

    if [ $IN_GNOME = 1 ] || [ $IN_XFE4 = 1]; then

   #determinando SESSION_MANAGER

   SESSIONS=`ls $PATH_TO_SESSIONS`

   for PID in $SESSIONS; do

       if [ `ls -l $PATH_TO_SESSIONS | grep $USER | grep $PID | wc -l` -eq 1 ];

then

      SESSION_MANAGER=local/$HOSTNAME:$PATH_TO_SESSIONS/$PID

      break;

       fi

   done

   chvt $CONSOLE

   BEFORE=`ps -A | grep $PID | wc -l`

   if [ $IN_GNOME = 1 ]; then

      logger "Cerrando sesión de gnome del usuario $USER"

      su - $USER -c "( 

          export DISPLAY=$DISPLAY SESSION_MANAGER=$SESSION_MANAGER

          xscreensaver-command -deactivate

          gnome-session-save --kill

      )"

   elif [ $IN_XFCE4 = 1 ]; then

      logger "Cerrando sesión de XFCE4 del usuario $USER"

      su - $USER -c "( 

          export DISPLAY=$DISPLAY SESSION_MANAGER=$SESSION_MANAGER

          xfce4-session-logout

      )"

      fi

   INDEX=0

   while [ $INDEX -lt $MAX_WAIT ]; do

       if [ `ps -A | grep " $PID " | wc -l` -lt $BEFORE ]; then

      break

       fi

       INDEX=$(($INDEX+1))

       logger "Esperando"

       sleep 1

   done

   if [ `ps -A | grep " $PID " | wc -l` -ge $BEFORE ]; then

       logger "Cerrando - no ha sido posible cerrar la sesión de gnome para el usuario $USER"

       chvt $CONSOLE

       su - $USER -c "env DISPLAY=$DISPLAY zenity --info --text \"Cierre abortado\""

       chmod a+x $THIS

       cd $LOCK

       rename s/$ENCODE// *

       exit 1

   fi

    else

   #Gestor de ventanas desconocido

   logger "Gestor desconocido"

   chvt $CONSOLE

   su - $USER -c "env DISPLAY=$DISPLAY zenity --info --text \"Gestor desconocido\""

   chmod a+x $THIS

   cd $LOCK

   rename s/$ENCODE// *

   exit 1

    fi

    

    #continúa

    if [ $# -gt 0 ]; then

   logger "Lanzándo una nueva rama"

   #continúa con el siguiente usuario

   sh $THIS $@

    else

   logger "Sesiones de entorno gráfico cerradas"

   chmod a+x $THIS

   cd $LOCK

   rename s/$ENCODE// *

    fi

fi

```

----------

## pcmaster

Por cierto, tras hacer eso, si haces un grep de ese SID te salen muchos procesos:

```
AthlonXP /tmp $ ps -ej | grep 10096

10096 10096 10096 tty1     00:00:00 bash

10099 10099 10096 tty1     00:00:00 startx

10111 10099 10096 tty1     00:00:00 xinit

10112 10112 10096 ?        00:03:14 X

10166 10166 10096 tty1     00:00:00 sh

10265 10166 10096 tty1     00:00:00 sh

10278 10166 10096 tty1     00:00:00 dbus-launch

10281 10166 10096 tty1     00:00:02 xfce4-session

10286 10166 10096 tty1     00:00:04 xfwm4

10288 10166 10096 tty1     00:00:05 xftaskbar4

10290 10166 10096 tty1     00:00:03 xfdesktop

10292 10166 10096 tty1     00:00:01 xfce4-panel

10294 10166 10096 tty1     00:00:06 gkrellm2

10301 10166 10096 tty1     00:00:00 gkrellm2

10320 10166 10096 tty1     00:00:00 mozilla-launche

10334 10166 10096 tty1     00:09:55 firefox-bin

10338 10166 10096 tty1     00:00:00 firefox-bin

10339 10166 10096 tty1     00:00:01 firefox-bin

10341 10166 10096 tty1     00:00:00 gconfd-2

10343 10166 10096 tty1     00:00:07 firefox-bin

10367 10166 10096 tty1     00:00:00 netstat <defunct>

13597 10166 10096 tty1     00:00:00 urxvt

```

todos con el mismo SID, y si le haces un grep session, adivina qué sale:

```

AthlonXP /tmp $ ps -ej | grep 10096| grep session

10281 10166 10096 tty1     00:00:02 xfce4-session

AthlonXP /tmp $ ls /tmp/.ICE-unix

10281

AthlonXP /tmp $ 
```

Creo que he cerrado el círculo  :Smile: 

----------

## pcmaster

Vaya, nos estamos cruzando los mensajes  :Smile: 

Probaré tu script. ¿Está acabado? ¿debería apagar correctamente?

----------

## aj2r

En general debería funcionar... Es cuestión de probarlo, mirálo y retócalo un poco si quieres. Yo ya lo dejo hasta la noche   :Rolling Eyes: 

----------

## aj2r

Mi problema ahora es saber lo que ya había dicho antes, qué sesion manager está relacionado con que display

----------

## aj2r

Lo encontré!!!

```
utmp
```

Esta noche o mañana pondré el nuevo script   :Very Happy: 

----------

## aj2r

Aquí va la nueva versión del script, pero mi gozo en un pozo porque, aunque ahora es más bonito, utmp no muestra la relación entre display y session_manager cuando la sesión se lanza con startx por ejemplo y no a partir de un xdm :'(

```

#!/bin/sh

THIS=$0

MAX_WAIT=20 #segundos de espera

PATH_TO_SESSIONS=/tmp/.ICE-unix

LOCK=/var/run/console

ENCODE=nonexisting

if [ $# -eq 0 ]; then

   

    #la primera vez

    chmod a-x $THIS

    find $LOCK -type f -exec mv {} {}$ENCODE \;

    #reparto con otros

    LIST=`who | grep -v tty | grep -v pts | cut -f "1 3" -d ' ' `

    if [ "$LIST""X" != "X" ]; then

   logger "Lanzándo una nueva rama"

        sh $THIS $LIST

    else

   #listo para apagar

   logger "Apagando el sistema"

   chmod a+x $THIS

   cd $LOCK

   rename s/$ENCODE// *

   /sbin/init 0

    fi

else

    #seleccionando usuario y display

    USER=$1

    shift

    DISPLAY=$1

    shift

    D=`echo $DISPLAY | cut -b 2`

    #determinando la consola

   CONSOLE=`cat /var/log/Xorg.$D.log | grep -i 'using vt number' | cut -f 5 -d ' '`

    #comprobando si el usuario está en una sesión de gnome

   IN_GNOME=`ps aux | grep gnome-session | grep -v grep | grep -v ssh-agent | grep -c $USER`

    #comprobando si el usuario está en una sesión de XFCE4

   IN_XFCE4=`ps aux | grep xfce4-session | grep -v grep | grep -v ssh-agent | grep -c $USER`

    #comprobando si el usuario está en una sesión de XFCE4

   IN_KDE=`ps aux | grep [k]desktop | grep -v grep | grep -v ssh-agent | grep -c $USER`

    if [ $IN_GNOME = 1 ] || [ $IN_XFE4 = 1] || [ $IN_KDE = 1 ]; then

   #determinando SESSION_MANAGER

   SESSION=`utmp | grep /dev/$DISPLAY | cut -f 4 -d ' '`

   SESSION_MANAGER=local/$HOSTNAME:$PATH_TO_SESSIONS/$SESSION

   chvt $CONSOLE

   BEFORE=`ps -A | grep -c $SESSION`

   if [ $IN_GNOME = 1 ]; then

      logger "Cerrando sesión de gnome del usuario $USER"

      su - $USER -c "(

          export DISPLAY=$DISPLAY SESSION_MANAGER=$SESSION_MANAGER

          xscreensaver-command -deactivate

          gnome-session-save --kill

      )"

   elif [ $IN_XFCE4 = 1 ]; then

      logger "Cerrando sesión de XFCE4 del usuario $USER"

      su - $USER -c "( 

          export DISPLAY=$DISPLAY SESSION_MANAGER=$SESSION_MANAGER

          xfce4-session-logout

      )"

   elif [ $IN_KDE = 1 ]; then

      logger "Cerrando sesión de KDE del usuario $USER"

      su - $USER -c "( 

          export DISPLAY=$DISPLAY SESSION_MANAGER=$SESSION_MANAGER

          dcop kdesktop default logout

      )"

      fi

   INDEX=0

   while [ $INDEX -lt $MAX_WAIT ]; do

       if [ `ps -A | grep -c " $SESSION "` -lt $BEFORE ]; then

      break

       fi

       INDEX=$(($INDEX+1))

       logger "Esperando"

       sleep 1

   done

   if [ `ps -A | grep -c " $SESSION "` -ge $BEFORE ]; then

       logger "Cerrando - no ha sido posible cerrar la sesión X para el usuario $USER"

       chvt $CONSOLE

       su - $USER -c "env DISPLAY=$DISPLAY zenity --info --text \"Cierre abortado\""

       chmod a+x $THIS

       cd $LOCK

       rename s/$ENCODE// *

       exit 1

   fi

    else

   #Gestor de ventanas desconocido

   logger "Gestor desconocido"

   chvt $CONSOLE

   su - $USER -c "env DISPLAY=$DISPLAY zenity --info --text \"Gestor desconocido\""

   chmod a+x $THIS

   cd $LOCK

   rename s/$ENCODE// *

   exit 1

    fi

    

    #continúa

    if [ $# -gt 0 ]; then

   logger "Lanzándo una nueva rama"

   #continúa con el siguiente usuario

   sh $THIS $@

    else

   logger "Sesiones de entorno gráfico cerradas"

   chmod a+x $THIS

   cd $LOCK

   rename s/$ENCODE// *

    fi

fi

```

----------

## pcmaster

Pues entonces o utmp tiene algún parámetro que te olvidas o bien no te sirve.

Prueba este script:

```

#!/bin/bash

DISPLAYS=`ls /tmp/.X*-lock | cut -b 8`

for D in $DISPLAYS; do

   CONSOLE="`cat /var/log/Xorg.$D.log | grep -i 'using vt number' | cut -f 5 -d ' '`"

   PID=`cat /tmp/.X$D-lock`

   LINEA=`ps -ej|grep $PID`

   SID=`ps -ej|grep $PID|cut -d " " -f 3`

   SESSION_MANAGER=`ps -ej|grep $SID|grep session`

   SESSION_MANAGER_NOMBRE=`echo $SESSION_MANAGER|cut -d " " -f 6`

   SESSION_MANAGER_PID=`echo $SESSION_MANAGER|cut -d " " -f 1`

    

   echo $CONSOLE

   echo $LINEA

   echo $SID

   echo $SESSION_MANAGER

   echo $SESSION_MANAGER_NOMBRE

   echo $SESSION_MANAGER_PID

   if `test -a /tmp/.ICE-unix/$SESSION_MANAGER_PID`;

     then echo "Exito con $SESSION_MANAGER_PID que está en terminal $CONSOLE."

     else echo "Mierda con $SESSION_MANAGER_PID que no lo encuentro."

   fi

done
```

a ver qué tal. En XFCE4, con una sola consola, me funciona.

----------

## aj2r

OK!! Vale sólo para las sesiones que no se han iniciado a partir de un xdm, pero mi código era para las que se iniciaban desde un xdm, así que los combinaré y ya está!!!  :Very Happy: 

----------

## pcmaster

Vaya, ese script lo hice ayer por la tarde, y no sabía que no funcionase si habías iniciado desde xdm. De todas formas, me extraña, ya que el script comprueba los logs del servidor X, supuse que serían los mismos se inicie desde donde se inicie.

Yo inicio las X con startx (tengo el login en modo texto).

Por lo menos te ha servido en combinación con el otro.  :Smile: 

----------

## aj2r

Si, lo que pasa es que con tu método si has iniciado sesión a partir de un xdm, no obtines el sesion_manager y su pid sino el del xdm xD

----------

## aj2r

A ver si esta vez rulaaa!!!!! Lo he probao con gnome, a ver si con XFCE4 rula   :Wink: 

```

#!/bin/sh

THIS=$0

MAX_WAIT=20 #segundos de espera

PATH_TO_SESSIONS=/tmp/.ICE-unix

LOCK=/var/run/console

ENCODE=nonexisting

if [ $# -eq 0 ]; then

   

   #la primera vez

   chmod a-x $THIS

   find $LOCK -type f -exec mv {} {}$ENCODE \;

   XLOCK=`ls /tmp/.X*-lock`

   if [ "$XLOCK""L"!="L" ]; then

      USUARIOS=`who | cut -f 1 -d " "| sort -u`

      for USUARIO in $USUARIOS; do

              sh $THIS $USUARIO

      done

      logger "Sesiones de entorno gráfico cerradas"

      chmod a+x $THIS

      cd $LOCK

      rename s/$ENCODE// *

   else

      #listo para apagar

      logger "Apagando el sistema"

      chmod a+x $THIS

      cd $LOCK

      rename s/$ENCODE// *

      /sbin/init 0

   fi

else

   USUARIO=$1

   SESIONES_X=`ls /tmp/.X*-lock | cut -b 8`

   if [ "$SESIONES_X""X" != "X" ]; then

      logger "Cerrando sesiones para el usuario $USUARIO"

logger $SESIONES_X

      for D in $SESIONES_X; do

logger $D

         DISPLAY=":$D"

      #determinando la consola

         CONSOLE=`cat /var/log/Xorg.$D.log | grep -i 'using vt number' | cut -f 5 -d ' '`

      #sesion XDM

         SESSIONS=`utmp | grep /dev/$DISPLAY`

         if [ "$SESSIONS""S" != "S" ]; then

            SESSION=`echo $SESSIONS | cut -f 2 -d ' '`

         #comprobando si el usuario está en una sesión de gnome

            IN_GNOME=`ps aux | grep gnome-session | grep -v ssh-agent | grep -v grep | grep -c $USUARIO`

         #comprobando si el usuario está en una sesión de XFCE4

            IN_XFCE4=`ps aux | grep xfce4-session | grep -v ssh-agent | grep -v grep | grep -c $USUARIO`

         #comprobando si el usuario está en una sesión de KDE

            IN_KDE=`ps aux | grep [k]desktop | grep -v ssh-agent | grep -v grep | grep -c $USUARIO`

            if [ $IN_GNOME = 1 ] || [ $IN_XFCE4 = 1] || [ $IN_KDE = 1 ]; then

            #determinando SESSION_MANAGER

               SESSION_MANAGER=local/$HOSTNAME:$PATH_TO_SESSIONS/$SESSION

               chvt $CONSOLE

               if [ $IN_GNOME = 1 ]; then

                  logger "Cerrando sesión de gnome del usuario $USUARIO"

                  su - $USUARIO -c "(

                     export DISPLAY=$DISPLAY SESSION_MANAGER=$SESSION_MANAGER

                     xscreensaver-command -deactivate

                     gnome-session-save --kill

                     )"

               elif [ $IN_XFCE4 = 1 ]; then

                  logger "Cerrando sesión de XFCE4 del usuario $USUARIO"

                  su - $USUARIO -c "( 

                     export DISPLAY=$DISPLAY SESSION_MANAGER=$SESSION_MANAGER

                     xfce4-session-logout

                     )"

               elif [ $IN_KDE = 1 ]; then

                  logger "Cerrando sesión de KDE del usuario $USUARIO"

                  su - $USUARIO -c "( 

                     export DISPLAY=$DISPLAY SESSION_MANAGER=$SESSION_MANAGER

                     dcop kdesktop default logout

                     )"

               fi

               INDEX=0

               while `test -e $PATH_TO_SESSIONS/$SESSION` && $INDEX -lt $MAX_WAIT; do

                  INDEX=$(($INDEX+1))

                  logger "Esperando"

                  sleep 1

               done

               if `test -e $PATH_TO_SESSIONS/$SESSION`; then

                  logger "Cerrando - no ha sido posible cerrar la sesión X para el usuario $USUARIO"

                  chvt $CONSOLE

                  su - $USUARIO -c "env DISPLAY=$DISPLAY zenity --info --text \"Cierre abortado\""

               fi

            else

            #Gestor de ventanas desconocido

               logger "Gestor desconocido"

               chvt $CONSOLE

               su - $USUARIO -c "env DISPLAY=$DISPLAY zenity --info --text \"Gestor desconocido\""

            fi

         else

            PID=`cat /tmp/.X$D-lock`

            LINEA=`ps -ej | grep $PID`

            SID=`echo $LINEA | cut -d " " -f 3`

            GNOME=`ps -ej | grep $SID | grep gnome-session`

            KDE=`ps -ej | grep $SID | grep [k]desktop`

            XFCE4=`ps -ej | grep $SID | grep xfce4-session`

            

            SESSION_MANAGER_PID="0"

            if [ "$GNOME""G" != "G" ] || [ "$XFCE4""X" != "X"  ] || [ "$KDE""K" != "K" ]; then

               chvt $CONSOLE

               if [ "$GNOME""G" != "G" ]; then

                  SESSION_MANAGER_PID=`echo $GNOME |cut -d " " -f 1`

echo $SESSION_MANAGER_PID

                  logger "Cerrando sesión de gnome del usuario $USUARIO"

                  su - $USUARIO -c "(

                     export DISPLAY=$DISPLAY SESSION_MANAGER=local/$HOSTNAME:$PATH_TO_SESSIONS/$SESSION_MANAGER_PID

                     xscreensaver-command -deactivate

                     gnome-session-save --kill

                     )"

               elif [ "$XFCE4""X" != "X" ]; then

                  SESSION_MANAGER_PID=`echo $XFCE4 |cut -d " " -f 1`

                  logger "Cerrando sesión de XFCE4 del usuario $USUARIO"

                  su - $USUARIO -c "( 

                     export DISPLAY=$DISPLAY SESSION_MANAGER=local/$HOSTNAME:$PATH_TO_SESSIONS/$SESSION_MANAGER_PID

                     xfce4-session-logout

                     )"

               elif [ "$KDE""K" != "K" ]; then

                  SESSION_MANAGER_PID=`echo $KDE |cut -d " " -f 1`

                  logger "Cerrando sesión de KDE del usuario $USUARIO"

                  su - $USUARIO -c "( 

                     export DISPLAY=$DISPLAY SESSION_MANAGER=local/$HOSTNAME:$PATH_TO_SESSIONS/$SESSION_MANAGER_PID

                     dcop kdesktop default logout

                     )"

               fi

               INDEX=0

               while `test -e $PATH_TO_SESSIONS/$SESSION_MANAGER_PID` && $INDEX -lt $MAX_WAIT ; do

                  INDEX=$(($INDEX+1))

                  logger "Esperando"

                  sleep 1

               done

               if `test -e $PATH_TO_SESSIONS/$SESSION_MANAGER_PID`; then

                  logger "Cerrando - no ha sido posible cerrar la sesión X para el usuario $USUARIO"

                  chvt $CONSOLE

                  su - $USUARIO -c "env DISPLAY=$DISPLAY zenity --info --text \"Cierre abortado\""

               fi

            else

            #Gestor de ventanas desconocido

               logger "Gestor desconocido"

               chvt $CONSOLE

               su - $USUARIO -c "env DISPLAY=$DISPLAY zenity --info --text \"Gestor desconocido\""

            fi

         fi

      done

   fi

fi   

```

----------

