dbus KDE · 7 min read · Jan 03, 2026

Intégration de dbus et KDE : démarrer et arrêter la partie session de dbus avec KDM.

Intégration de dbus et KDE : démarrer et arrêter la partie session de dbus avec KDM.

Contenu

  1. Introduction
  2. Ajustement de la configuration de KDM
  3. Démarrer le sessiondaemon de dbus et rendre les variables d’environnement disponibles.
    2.1 À propos des fichiers de démarrage de Bash.
    2.2 Démarrer la partie sessionbus de dbus
    2.3 Arrêter la partie sessionbus de dbus
    2.4 Un utilisateur est connecté plus d’une fois

0. Introduction

Depuis quelque temps, de nombreuses applications utilisent D-BUS. C’est le cas avec KDE 3.5, la version stable actuelle de KDE. Avec le prochain KDE 4, D-BUS devient de plus en plus important, remplaçant DCOP.

Dans ce guide, je souhaite décrire une méthode pour démarrer et arrêter la partie dépendante de l’utilisateur et de la session de dbus. Les principaux objectifs que j’ai en tête avec cette approche sont :

  • rendre les variables d’environnement importantes pour les applications conscientes de d-bus disponibles ;
  • s’assurer que la partie session de dbus n’est pas démarrée plus d’une fois pour un seul utilisateur ;
  • s’assurer que la partie session de dbus est arrêtée lorsqu’une session d’un utilisateur se termine ;

Je suppose que l’utilisateur se connecte avec KDM, le gestionnaire de connexion pour KDE 3.5. La construction pourrait très bien être utilisée avec d’autres gestionnaires de connexion (XDM, GDM) également.
KDM a la capacité d’exécuter des scripts au début d’une session (au démarrage) et à la fin (réinitialisation). L’un d’eux peut démarrer (et arrêter) la partie session de dbus.

1. KDM : les fichiers

KDM utilise certains fichiers pour démarrer et arrêter :

. Xstartup
exécuté en tant que root, après qu’un utilisateur se soit connecté avec succès.

. Xsession
fonctionne avec les autorisations de l’utilisateur autorisé, pour démarrer la session souhaitée (KDE).

. Xreset
exécuté en tant que root, après la fin de la session utilisateur.

Où Xstartup est l’endroit pour démarrer les choses, Xreset est l’endroit pour annuler ces commandes.

Pour plus d’informations sur ces fichiers, consultez le manuel de KDM.

En ajoutant le code suivant au fichier Xstartup : 

-- snip --
for script in /etc/session.d/kdm/startup/*.sh; do
    if [ -x $script ]; then
        eval $script $USER kdm
    fi;
done;

et le code au fichier Xreset :

-- snip --
for script in /etc/session.d/kdm/reset/*.sh; do
    if [ -x $script ]; then
        eval $script $USER kdm
    fi;
done;

Créez les répertoires où les scripts vont : 

install -m755 -d /etc/session.d/kdm/startup  
install -m755 -d /etc/session.d/kdm/reset  
install -m755 -d /etc/session.d/scripts/start  
install -m755 -d /etc/session.d/scripts/stop

Les fichiers dans ces répertoires doivent être accessibles à chaque utilisateur ordinaire : donc les permissions sont 755.
Tous les scripts dans ces répertoires devraient avoir les mêmes permissions : 755.

Chaque utilisateur devrait être en mesure d’exécuter le script, mais seul root peut les modifier.

1. Démarrer le sessiondaemon de dbus et rendre les variables d’environnement disponibles

Le paquet dbus est divisé en deux parties : une partie système et une pour (chaque) session/utilisateur. La partie système (un démon) est démarrée au démarrage, avec des privilèges spéciaux d’un utilisateur dédié. La partie de session (également un démon) doit être démarrée lorsqu’une session pour un utilisateur commence, et arrêtée lorsque la session se termine.

La construction avec kdm que j’utilise ici est idéale pour cela. Un script dans le répertoire de démarrage pour démarrer le sessiondaemon pour un utilisateur, fonctionnant avec les privilèges de cet utilisateur, et un autre script dans le répertoire de réinitialisation doit arrêter ce démon.

Mais ce n’est pas si simple. Certaines variables (DBUS_SESSION_BUS_ADDRESS et DBUS_SESSION_BUS_PID) doivent être disponibles dans l’environnement pour chaque application qui fonctionne avec dbus. À mon avis, le réglage de ces variables devrait se faire dans les scripts de démarrage bash. Ensuite, quel que soit le script ou l’application que vous exécutez, ces variables sont définies sur la bonne valeur.

1.1 À propos des fichiers de démarrage de Bash

Le sessiondaemon de dbus crée un fichier qui contient les variables d’environnement. Comme indiqué ci-dessus, ce fichier doit être lu (sourcé) par bash lorsqu’il démarre pour cet utilisateur.

Lorsque bash est démarré par “login” en tant que shell de connexion interactif, il lit /etc/profile et ~/.bash_profile. Bash est également démarré par “kdm”, et les fichiers /etc/profile et ~/.bash_profile sont sourcés.

Mon idée est de stocker la sortie de la commande 

dbus-launch --auto-syntax

dans le fichier

$HOME/.dbus-session

Ce fichier est “sourcé” lorsque bash démarre. Cela ne se produit pas automatiquement, mais vous devrez ajouter le script suivant à /etc/profile.d :

cat >> /etc/profile.d/dbus-session.sh << "EOF"
if [ -f $HOME/.dbus-session ]; then
        . $HOME/.dbus-session
fi;
EOF

De cette manière, les variables d’environnement sont rendues disponibles lorsque Bash démarre.

1.2 Démarrer la partie sessionbus de dbus

Je suppose que dbus est installé et qu’il est démarré au démarrage.

Créez un script dans le répertoire /etc/session.d/scripts/start dbus-session-start.sh :

cd /etc/session.d/scripts/start  

cat >> dbus-session-start.sh << "EOF"
#!/bin/bash
retcode=0;
userid=$1
userproperties=$(getent passwd | grep -m 1 -E "^$userid")
homedir=$(echo $userproperties | cut -d ":" -f 6);
gidnr=$(echo $userproperties | cut -d ":" -f 4);
uidnr=$(echo $userproperties | cut -d ":" -f 3);
if [ -d $homedir ]; then
    #
    # faire une vérification pour savoir si dbus-daemon est déjà en cours d'exécution
    # dbus-daemon doit être démarré par l'utilisateur (uidnr) se connectant
    #
    
    if [ -f $homedir/.dbus-session ]; then
        # faire une vérification que le dbus-daemon pour cet utilisateur est en cours d'exécution avec le pid
        # dans le fichier .dbus-session
 
        # pid selon la commande ps
        ps_dbus_session_pid=$(ps aux | grep -m 1 -E "^$userid.*dbus-daemon.*session.*" 
        | grep -v "grep" | sed 's@[[:space:]][[:space:]]*@ @g' | cut -d " " -f 2)
        
        # lire le pid du fichier .dbus-session
        . $homedir/.dbus-session
        # vérifier s'ils sont les mêmes       
        if [ -z "$ps_dbus_session_pid" ]; then
        
            # dbus pour cet utilisateur n'est pas en cours d'exécution
            rm $homedir/.dbus-session
            
        elif [ $DBUS_SESSION_BUS_PID -ne $ps_dbus_session_pid ]; then
        
            # il y a quelque chose qui ne va pas : arrêter dbus-daemon pour cet utilisateur 
            # et supprimer le fichier .dbus-session
            if [ $(id -u) -eq 0 ]; then
                sudo -H -u $userid sh -c "kill $ps_dbus_session_pid"
            elif [ $(id -u) -eq $uidnr ]; then
                kill -SIGTERM $ps_dbus_session_pid;
            fi
            rm $homedir/.dbus-session
            
        fi
    
    fi  
    if [ ! -f $homedir/.dbus-session ]; then
        # ne démarrer une session dbus que si le fichier .dbus-session n'est pas trouvé
        # dans le répertoire personnel de l'utilisateur  
  
        if [ $(id -u) -eq 0 ]; then
            sudo -u $userid -H /bin/sh -c "dbus-launch --auto-syntax > $homedir/.dbus-session"
            retcode=$?
            chown $uidnr:$gidnr $homedir/.dbus-session
        elif [ $(id -u) -eq $uidnr ]; then 
            dbus-launch --auto-syntax > $homedir/.dbus-session
            retcode=$?
        fi
    fi
fi;
if [ $retcode -ne 0 ]; then
    echo "Une erreur avec dbus ($retcode)."
fi;
exit $retcode
EOF

chmod --verbose --mode 755 /etc/session.d/scripts/start/dbus-session-start.sh  
ln -v -sf ../../scripts/start/dbus-session-start.sh /etc/session.d/kdm/startup/10dbus.sh

Ce script, exécuté par KDM au démarrage, démarrera le démon de session dbus pour cet utilisateur et créera le fichier .dbus-session dans le répertoire personnel de cet utilisateur, contenant toutes les variables dbus.
Il ne le fera que lorsque dbus n’est pas déjà en cours d’exécution pour cet utilisateur.

Maintenant, lorsque bash démarre à la connexion, il lit (sourcé) ce fichier.

Comme vous pouvez le voir, j’ai divisé le démarrage de dbus en deux parties :

  • dbus-session-start.sh, s’exécute lorsqu’une session (kdm) commence
  • .dbus-session, sourcé lorsqu’une session (bash) commence, pourrait être sourcé plusieurs fois

De plus, j’utilise le paramètre –auto-syntax, où je suppose que Bash est utilisé. Donc je pourrais utiliser ici –sh-syntax, mais ça fonctionne.

Et Sudo est nécessaire pour exécuter dbus-launcher en tant qu’utilisateur qui se connecte, car KDM exécute ce script en tant que root. (en fait, le script vérifie l’identifiant du compte exécutant ce script. Si c’est root (id = 0), alors sudo est utilisé pour changer à l’utilisateur démarrant une session. Lorsque l’identifiant et l’identifiant de l’utilisateur se connectant sont les mêmes, rien n’a à être fait.

2.3 Arrêter la partie sessionbus de dbus

Créer le script dbus-session-stop.sh dans le répertoire de réinitialisation :

cd /etc/session.d/scripts/stop  

cat >> dbus-session-stop.sh << "EOF"
#!/bin/bash
retcode=0;
userid=$1
userproperties=$(getent passwd | grep -m 1 -E "^$userid")
homedir=$(echo $userproperties | cut -d ":" -f 6);
gidnr=$(echo $userproperties | cut -d ":" -f 4);
uidnr=$(echo $userproperties | cut -d ":" -f 3);
        
if [ -f $homedir/.dbus-session ]; then
        
        . $homedir/.dbus-session
        
        if [ -n "$DBUS_SESSION_BUS_PID" ]; then
                if [ $(id -u) -eq 0 ]; then
                    sudo -u $userid -H /bin/sh -c "kill $DBUS_SESSION_BUS_PID"
                    retcode=$?
                    rm $homedir/.dbus-session
                elif [ $(id -u) -eq $uidnr ]; then
                    kill $DBUS_SESSION_BUS_PID
                    retcode=$?
                    rm $homedir/.dbus-session
                fi
        
        fi
fi;
if [ $retcode -ne 0 ]; then
    echo "Une erreur avec dbus ($retcode)."
fi;
exit $retcode
EOF

chmod --verbose --mode 755 dbus-session-stop.sh  
ln -v -sf ../../scripts/stop/dbus-session-stop.sh /etc/session.d/kdm/reset/90dbus.sh

Ce script arrête la partie session du dbus-daemon.

2.4 Un utilisateur est connecté plus d’une fois

Pour la plupart des situations, cette construction est suffisamment bonne. La plupart des utilisateurs ont une session à la fois. Maintenant, que se passe-t-il lorsqu’un utilisateur a plus d’une session en même temps ? Est-il nécessaire de démarrer la partie session de dbus pour chaque session, ou une seule instance est-elle suffisante ?

Cette construction ne permet pas plus d’un dbus-daemon par utilisateur. Je pense que cela devrait être suffisant.

CHANGELOG :

[2006-01-18]

  • Guide initial
    [2006-07-18]
  • Changé les scripts bash
    [2006-09-09]
  • ajout d’une vérification pour voir si dbus-daemon est déjà en cours d’exécution pour cet utilisateur et si les informations trouvées dans .dbus-session sont correctes
Share: X/Twitter LinkedIn
#dbus KDE

Recevez de nouveaux articles dans votre boîte de réception.

Aucun spam. Désabonnez-vous à tout moment.