Restriction Horaire sur utilisateur

Restriction Horaire sur utilisateur [Réglé]

MG4-KDE Système et matériels / Installation et configuration

Tromb Membre non connecté

Le 21/11/2014 à 21h31

Salut,
Concernant le shutdown, je verrai à l'usage, sachant que je ne le ferai pas en semaine.

Merci, mais pour l'instant, je n'ose même pas ôter le préfixe de supernovice :o)…

En fait… Je n'ai pas fini… Je continue… Je recherche maintenant le moyen, dans la plage horaire autorisée, de limiter le temps de la session, exemple : dans la plage 14h00 - 22h00, autoriser 3h00 sur le PC…
Ca se complique.

J'ai trouvé plusieurs solutions, mais, pour l'instant, je ne vois pas comment en intégrer une à MG :

1 - le timeoutd, mais je ne l'ai pas trouvé sur la machine, ni dans CCM, cf. ce blog. Par contre, je pense que si le user se connecte de nouveau, cela repart à zéro.

2- un script permettant de récupérer le temps de connexion à intégrer dans un "autostart" que je n'ai pas trouvé, cf. ce forum KDE. De plus, le script n'est pas réellement adaptée au système (ex: /kde/sessao n'existe pas… jour de la date de la dernière connexion?).

3- en faisant peut-être activer en fond un script avec la commande sleep (cf. sur linuxpedia et également utilisé pour l'apparition des fenêtres dans la solution 2, ci-dessus - cf. forum KDE), mais je ne vois pas comment l'intégrer pour le faire démarrer en ouverture de session; et, de plus, comme la solution 1, si le user se connecte de nouveau, cela repart à zéro.

4- je me demandais s'il n'existait pas une variable d'environnement KDE donnant le temps de connexion dans la journée, et ainsi faire un script, avec une condition (si > à x heures alors déconnecter), intégré dans le crontab qui serait vérifiée tous le 5 ou 10 minutes. J'ai bien trouvé la variable SECONDS, mais elle ne marche que pour une session console.

J'avoue que ma solution préférée est la 2, car elle intègre la problématique des ouvertures multiples dans la journée.

Voilà, c'est reparti… Je continue à rechercher.
Après cela, nous aurons un package (très) complet de contrôle parental (filtres+horaires).
A+

Édité par Tromb Le 21/11/2014 à 22h48

Tromb
supernovice

Tromb Membre non connecté

Le 17/01/2015 à 22h41

#187886

Bonjour et Meilleurs voeux !!

Après deux mois de bricole quand le temps me le permettait, j'ai non sans mal écrit un jeu de scripts, qui marchotte à peu près bien et qui permet :

- d'imposer un temps de session maximal par jour en fonction du jour de la semaine,
- d'imposer une plage de connexion autorisée en fonction du jour de la semaine,
- de permettre à un adulte "responsable" (du groupe root) d'ajouter du temps sous les menaces de l'utilisateur enfant,
- d'alerter l'utilisateur 10 minutes avant la déconnexion,
- de permettre à l'utilisateur de savoir combien de temps il lui reste (en fait, ce dernier n'est pas terminé, je l'insèrerai ultérieurement).

Ce jeu est constitué de 5 scripts :
Vu "mon niveau avancé en matière de programmation bash", ces scripts sont améliorables... aux bonnes âmes...

TempsSession.sh

C'est le script principal qui va calculer le temps que l'utilisateur connecté va passer et qui donnera l'ordre de déconnexion.
La stratégie choisie est de lancer le script via le crontab système à une fréquence donnée. Il se base sur un fichier de configuration TS.conf qui fournit les temps de session maximals et les plages horaires autorisées par jour de la semaine et par utilisateur concerné.

TempsSessionConf.sh

Ce script permet de créer ou de modifier le fichier de configuration. Il se lance par le su dans une console.

TempsSessionAlert.sh

N'ayant pas réussi à faire apparaître une fenêtre sur l'écran de l'utilisateur connecté et concerné par une restriction horaire via le crontab système, j'ai dû écrire ce script lancé par le crontab utlisateur. Il l'alerte de la deconnexion 10 minutes avant via des fenêtres.
Je dois avouer que dans certains cas (connexion hors plage, reconnexion), ça bogue un peu, il a tendance à alerter pour rien.

TempsSessionAjout.sh

Ce script permet au su d'ajouter du temps à l'utilisateur dans la journée, il ne modifie pas la configuration de l'utilisateur dans le fichier de configuration TS.conf.

TempsSessionLect.sh à peine commencé

Ce script sera lancé par l'utlisateur et fera apparaître une fenêtre indiquant le temps qui lui reste.

**************************

Avant toute chose, il faut créer un répertoire /var/log/TempsSession. C'est essentiel, sinon cela ne marche pas.

1. TempsSession.sh

1.1 Localisation

J'ai localisé ce script dans /usr/bin:
-rwxr-xr-x 1 root root 5106 janv. 11 2016 TempsSession.sh*
Bien Veiller à ne pas l'autoriser en écriture et en exécution par les utilisateurs hors groupe "root".

1.2 La démarche

Dans le crontab système, en su via la commande vi crontab ou vi /etc/crontab, j'ai ajouté une ligne :

Code BASH :

*/5 * * * * root /bin/sh /usr/bin/TempsSession.sh

Le script va s'exécuter toutes les 5 minutes, la déconnexion sera donc à 5 minutes près, si vous souhaitez réduire ce temps d'incertitude, vous pouvez remplacer le "5" par un entier inférieur.
Au premier lancement, le script va chercher dans le fichier de configuration TS.conf s'il est concerné par une limitation. Si c'est le cas, il créera un fichier TSLogin_utilisateur.var dans le répertoire /var/log/TempsSession recenssant les données qu'il a besoin.
Ensuite, toutes les 5 minutes, il vérifiera si le temps n'est pas dépassé ou s'il est hors plage horaire autorisée et déconnectera. Si l'utilisateur se connecte hors plage horaire autorisée, il le déconnectera dans les 5 minutes.
Si le fichier de config est absent ou que l'utilisateur ne s'y trouve pas, il ne sera pas limité, à moins qu'il soit dans le group nommé child, il sera alors limité à 1 heure tous les jours et autorisé à se connecter de 10:00 à 20:30.
Le script va générer un journal : var/log/TempsSession/TS.log

1.3 Le script

Code BASH :

 
#!/bin/bash
 
# TempsSession.sh
# v.1.01
# TS.conf configuration des temps maximum pour chaque utilisateur concerné par jour de semaine
 
# test du login
i=0
 
until [ "$(who | grep " :${i}")" = "" ] ;
do
    set $(who | grep " :${i}")
    UserConnecte=$1
    NumDisplay=":$i"
    let "i=i+1"
 
# Test si UserConnecté est concerné par la limite de temps
    if [ "$(grep "$UserConnecte" /var/log/TempsSession/TS.conf)" != "" ] ; 
      then
# lecture et calcul des variables dans TS.var
  read jderniereconx HeureDebutConnexion TempsSessionMaxS HeureCtrlS laps tcumulS devnull HeureMin HeureMax < /var/log/TempsSession/TS${UserConnecte}.var
  HeureCtrlS=$(date +%s)
 
# Première connexion de la journée et calcul du temps de connexion
  if [ "$jderniereconx" != "$(date +%D)" ] ; 
    then
jderniereconx=$(date +%D)
 
set $(grep "/usr/bin/TempsSession.sh" /etc/crontab)
laps=$(echo $1 | cut --delimiter="/" -f2)
 
config=$(grep "$UserConnecte" /var/log/TempsSession/TS.conf)
for k in $(seq 2 8) ;
  do
    JourSemaine=$(echo $config | cut --delimiter="-" -f${k})
    set $JourSemaine
    if [ "$1" = "$(date +%a)" ] ;
      then
  TSMheure=$2
  TSMmin=$3
  HeureMin=$4
  HeureMax=$5
    fi
  done
 
tcumulS=0
HeureDebutConnexion=$(date +%R)
if [ "$TSMheure" = "" ] ;
  then
      echo "$(date +%a) non trouvé dans le fichier de configuration TS.conf pour $UserConnecte : 1 heure de temps de session appliquée par défaut" >> /var/log/TempsSession/TS.log
      TSMheure="1"
      TSMmin="0"
fi
let "TempsSessionMaxS = TSMheure * 3600 + TSMmin * 60 - 1"
 
    else
let "tcumulS = tcumulS + laps * 60"
 
  fi
 
# Archivage des variable dans TS${UserConnecte}.var
 
  echo "$jderniereconx $HeureDebutConnexion $TempsSessionMaxS $HeureCtrlS $laps $tcumulS $NumDisplay $HeureMin $HeureMax" > /var/log/TempsSession/TS${UserConnecte}.var
 
# Décision de l'ordre de déconnexion
  PlageHor="non autorisee"
  HeureMinH=$(echo $HeureMin | cut --delimiter=":" -f1)
  HeureMinM=$(echo $HeureMin | cut --delimiter=":" -f2)
 
  HeureMaxH=$(echo $HeureMax | cut --delimiter=":" -f1)
  HeureMaxM=$(echo $HeureMax | cut --delimiter=":" -f2)
 
  let "HeureMinM = HeureMinM + HeureMinH * 60"
  let "HeureMaxM = HeureMaxM + HeureMaxH * 60"
  let "HeureM = $(date +%M) + $(date +%H) * 60"
 
 
  if [ $HeureM -ge $HeureMinM ] && [ $HeureM -le $HeureMaxM ] ;
    then
PlageHor="autorisee"
  fi
 
  if [ $tcumulS -gt $TempsSessionMaxS ] || [ "$PlageHor" == "non autorisee" ] ;
    then
echo "$UserConnecte en DISPLAY$NumDisplay - $(date +%a) $jderniereconx - session de $HeureDebutConnexion à $(date +%R) $TempsSessionMaxS $tcumulS" >> /var/log/TempsSession/TS.log
echo "$jderniereconx $HeureDebutConnexion $TempsSessionMaxS $HeureCtrlS $laps $tcumulS $NumDisplay $HeureMin $HeureMax" > /var/log/TempsSession/TS${UserConnecte}.var
pkill -KILL -u $UserConnecte
  fi
 
# si le UserConnecte est identifié comme enfant (groupe "child") et non référencé dans le TS.conf, il n'aura qu'une heure de conexion par jour de 10:00 à 20:30
    else
  set $(groups $UserConnecte)
  for j in $@ ;
  do
if [ "$j" == "child" ] ;
  then
      HeureCtrlS=$(date +%s)
      if [ "$tcumulS" == "" ] ;
then
    jderniereconx=$(date +%D)
    HeureDebutConnexion=$(date +%R)
    echo "$(date) Anomalie : $UserConnecte en DISPLAY$NumDisplay appartient au groupe child et n'est pas déclaré dans le TS.conf : 1 heure max de connexion accordée entre 10:00 et 20:30." >> /var/log/TempsSession/TS.log
    tcumulS=0
    TempsSessionMaxS=3600
    laps=$(echo $1 | cut --delimiter="/" -f2)
    HeureMin="10:00"
    HeureMax="20:30"
else
    read jderniereconx HeureDebutConnexion TempsSessionMaxS HeureCtrlS laps tcumulS devnull HeureMin HeureMax < /var/log/TempsSession/TS${UserConnecte}.var
    let "tcumulS = tcumulS + laps * 60"
      fi
      echo "$jderniereconx $HeureDebutConnexion $TempsSessionMaxS $HeureCtrlS $laps $tcumulS $NumDisplay $HeureMin $HeureMax" > /var/log/TempsSession/TS${UserConnecte}.var
fi
  done
 
    fi
 
done

2. TempsSessionConf.sh

2.1 Localisation

J'ai localisé ce script dans /usr/bin :
-rwxr-x--- 1 root root 9807 janv. 16 15:21 TempsSessionConf.sh*
Bien Veiller à ne pas l'autoriser en écriture et en exécution par les utilisateurs hors groupe "root".

2.2 La démarche

Il est lancé en su via une console : ./usr/bin/TempsSessionConf.sh
Il suffit ensuite de suivre les instructions.
ATTENTION: bien vérifier la syntaxe, car si elle n'est pas correcte, l'utilisateur ne sera pas limité, TempsSession.sh dysfonctionnera.
Voici une des voies d'amélioration : vérifier la bonne syntaxe des données entrées.

2.3 Le script

Code BASH :

 
#!/bin/bash
 
# TempsSessionConf.sh
# v.1.00
#Configuration du fichier TS.conf
 
clear
 
declare -a UserConcerneT
declare -a DayT
declare -A TSMaxT
declare -A HeureMinT
declare -A HeureMaxT
 
if [ -e /var/log/TempsSession/TS.conf ] ;
  then
      creation="non"
      i=0
      while read line 
      do   
     let "i=i+1"
     UserConcerneT[$i]=$(echo $line | cut --delimiter="-" -f1)
     echo ; echo
     echo "***************${UserConcerneT[$i]}****************"
     echo " * Jour : Temps de Session -- Plage horaire autorisée"
     for k in $(seq 2 8) ;
 do
    JourSemaine=$(echo $line | cut --delimiter="-" -f${k})
    set $JourSemaine
    #DayT[$i]=$1
    Day=$1
    TSMaxT[$i:$1]="${2}h${3}"
    HeureMinT[$i:$1]=$4
    HeureMaxT[$i:$1]=$5
    case $1 in
    Mon) Jour="Lundi   " ;;
    Tue) Jour="Mardi   " ;;
    Wed) Jour="Mercredi" ;;
    Thu) Jour="Jeudi   " ;;
    Fri) Jour="Vendredi" ;;
    Sat) Jour="Samedi  " ;;
    Sun) Jour="Dimanche" ;;
    *)
echo "*********"
echo "ATTENTION"
echo "Erreur dans /var/log/TempsSession/TS.conf, vous devez l'effacer et relancer TempsSessionConf.sh"
echo "*********"
echo
exit 
    esac
    echo " * $Jour: ${TSMaxT[$i:$Day]} -- de $4 à $5"
  done
      done < /var/log/TempsSession/TS.conf
      NombreUser=$i
  else
      echo
      echo "Le fichier de Configuration (TS.conf) n'existe pas, nous allons le créer pour un Utilisateur."
      creation="oui"
fi
 
echo
 
until [ "$rep" == "m" ] || [ "$rep" == "a" ] || [ "$rep" == "s" ]
do
    if [ "$creation" == "oui" ] ;
      then
  rep="a"
      else
  echo "Souhaitez-vous :"
  echo "[m] modifier un utilisateur," 
  echo "[a] ajouter un nouvel utilisateur,"
  echo "[s] suprimer un utilisateur"
  echo "[q] quitter le script ?"
  read -n 1 -p "> " rep
  echo
  if [ "$rep" == "q" ] ; then exit ;  fi
  if [ "$rep" != "m" ] && [ "$rep" != "a" ] && [ "$rep" != "s" ] ;
    then
echo "Je n'ai pas compris."
  fi
    fi
done
 
echo 
 
if [ "$rep" == "m" ] ;
  then
      while [ "$rp" != "o" ]
      do
  if [ "${#UserConcerneT[*]}" == "1" ] ;
    then
mod="1"
    else
for i in $(seq 1 ${#UserConcerneT[*]}) ;
do
    echo "$i : ${UserConcerneT[$i]}"
done
echo
read -p "Indiquer le numéro de l'utilisateur concerné: " mod
  fi
  echo
  read -n 1 -p "Confirmation : vous désirez modifier ${UserConcerneT[$mod]} [o/n] " rp
  echo
      done
      echo
      echo "***************${UserConcerneT[$mod]}****************"
      until [ "$rp" == "s" ] || [ "$rp" == "lun" ] || [ "$rp" == "mar" ] || [ "$rp" == "mer" ] || [ "$rp" == "jeu" ] || [ "$rp" == "ven" ] || [ "$rp" == "sam" ] || [ "$rp" == "dim" ]
do
  echo " Désirez-vous modifier :"
  echo "    - la semaine complète [s] ;"
  echo "    - ou un jour en particulier de la semaine [lun, mar, mer, jeu, ven, sam, dim];"
  echo "[q] pour quitter."
  read -p "> " rp
  if [ "$rp" == "q" ] ; then exit ; fi
done
 
      if [ "$rp" == "s" ] ;
 then
      i=0
      for j in Lundi Mardi Mercredi Jeudi Vendredi Samedi Dimanche ;
      do
let "i=i+1"
case $j in
    Lundi) DayT[$i]="Mon" ;;
    Mardi) DayT[$i]="Tue" ;;
    Mercredi) DayT[$i]="Wed" ;;
    Jeudi) DayT[$i]="Thu" ;;
    Vendredi) DayT[$i]="Fri" ;;
    Samedi) DayT[$i]="Sat" ;;
    Dimanche) DayT[$i]="Sun" ;;
esac
echo "$j : "
if [ "$i" != "1" ] ;
  then
      echo "(Si vous entrez [idem] ci-dessous, le temps de Session et la Plage horaire seront identiques au jour précédent.)"
fi
read -p " - Temps de Session [HHhMM] :  " TSMaxT[$mod:${DayT[$i]}]
if [ "${TSMaxT[$mod:${DayT[$i]}]}" == "idem" ] ;
  then
      let "precedent=i-1"
      TSMaxT[$mod:${DayT[$i]}]=${TSMaxT[$mod:${DayT[$precedent]}]}
      HeureMinT[$mod:${DayT[$i]}]=${HeureMinT[$mod:${DayT[$precedent]}]}
      HeureMaxT[$mod:${DayT[$i]}]=${HeureMaxT[$mod:${DayT[$precedent]}]}
      echo " - Temps de Session [HHhMM] :  ${TSMaxT[$mod:${DayT[$i]}]}"
      echo " - Plage horaire autorisée"
      echo " * Heure de début [HH:MM] : " ${HeureMinT[$mod:${DayT[$i]}]}
      echo " * Heure de fin   [HH:MM] : " ${HeureMaxT[$mod:${DayT[$i]}]}
  else
      echo " - Plage horaire autorisée"
      read -p " * Heure de début [HH:MM] : " HeureMinT[$mod:${DayT[$i]}]
      read -p " * Heure de fin   [HH:MM] : " HeureMaxT[$mod:${DayT[$i]}]
  fi
done
  else
      until [ "$rp" == "n" ] 
      do
  case $rp in
    lun) Day="Mon" ;;
    mar) Day="Tue" ;;
    mer) Day="Wed" ;;
    jeu) Day="Thu" ;;
    ven) Day="Fri" ;;
    sam) Day="Sat" ;;
    dim) Day="Sun" ;;
  esac
  echo "$rp :"
  read -p " - Temps de Session [HHhMM] :  " TSMaxT[$mod:$Day]
  echo " - Plage horaire autorisée"
  read -p " * Heure de début [HH:MM] : " HeureMinT[$mod:$Day]
  read -p " * Heure de fin   [HH:MM] : " HeureMaxT[$mod:$Day]
  echo
  read -p "Désirez-vous changer un autre jour [n / lun/mar...] ? " rp
      done
      fi
      echo
      echo "Utilisateur ${UserConcerneT[$mod]} modifié."
fi
 
 
if [ "$rep" == "a" ] ;
  then
      let "mod=${#UserConcerneT[*]}+1"
      let "NombreUser = NombreUser + 1"
      read -p "Donnez le login de l'utilisateur : " UserConcerneT[$mod]
      echo
      echo "***************${UserConcerneT[$mod]}****************"
      i=0
      for j in Lundi Mardi Mercredi Jeudi Vendredi Samedi Dimanche ;
do
  let "i=i+1"
  case $j in
    Lundi) DayT[$i]="Mon" ;;
    Mardi) DayT[$i]="Tue" ;;
    Mercredi) DayT[$i]="Wed" ;;
    Jeudi) DayT[$i]="Thu" ;;
    Vendredi) DayT[$i]="Fri" ;;
    Samedi) DayT[$i]="Sat" ;;
    Dimanche) DayT[$i]="Sun" ;;
  esac
  echo "$j : "
  if [ "$i" != "1" ] ;
    then
echo "(Si vous entrez [idem] ci-dessous, le temps de Session et la Plage horaire seront identiques au jour précédent.)"
  fi
  read -p " - Temps de Session [HHhMM] :  " TSMaxT[$mod:${DayT[$i]}]
  if [ "${TSMaxT[$mod:${DayT[$i]}]}" == "idem" ] ;
    then
let "precedent=i-1"
TSMaxT[$mod:${DayT[$i]}]=${TSMaxT[$mod:${DayT[$precedent]}]}
HeureMinT[$mod:${DayT[$i]}]=${HeureMinT[$mod:${DayT[$precedent]}]}
HeureMaxT[$mod:${DayT[$i]}]=${HeureMaxT[$mod:${DayT[$precedent]}]}
echo " - Temps de Session [HHhMM] :  ${TSMaxT[$mod:${DayT[$i]}]}"
echo " - Plage horaire autorisée"
echo " * Heure de début [HH:MM] : " ${HeureMinT[$mod:${DayT[$i]}]}
echo " * Heure de fin   [HH:MM] : " ${HeureMaxT[$mod:${DayT[$i]}]}
    else
      echo " - Plage horaire autorisée"
      read -p " * Heure de début [HH:MM] : " HeureMinT[$mod:${DayT[$i]}]
      read -p " * Heure de fin   [HH:MM] : " HeureMaxT[$mod:${DayT[$i]}]
  fi
done
echo
echo "Utilisateur ${UserConcerneT[$mod]} ajouté."
fi
 
if [ "$rep" == "s" ] ;
  then
      while [ "$rp" != "o" ]
      do
  if [ "${#UserConcerneT[*]}" == "1" ] ;
    then
mod="1"
    else
for i in $(seq 1 ${#UserConcerneT[*]}) ;
do
    echo "$i : ${UserConcerneT[$i]}"
done
echo
read -p "Indiquer le numéro de l'utilisateur concerné: " mod
  fi
  echo
  echo "${UserConcerneT[$mod]} supprimé, son temps de session ne sera plus contrôlé, excepté s'il appartient au group "child", dans quel cas, il ne disposera que d'une heure de connexion."
  echo
  read -n 1 -p "Confirmation : vous désirez suprimer ${UserConcerneT[$mod]} [o/n] " rp
  echo
      done
      let "NombreUser = NombreUser - 1"
      UtilisateurSupprime=${UserConcerneT[$mod]}
      if [ "$mod" != "${#UserConcerneT[*]}" ] ;
then
    for i in $(seq $mod $NombreUser) ;
    do
let "suivant=i+1"
UserConcerneT[$i]=${UserConcerneT[$suivant]}
for Day in Mon Tue Wed Thu Fri Sat Sun ;
do
  TSMaxT[$i:$Day]=${TSMaxT[$suivant:$Day]}
  HeureMinT[$i:$Day]=${HeureMinT[$suivant:$Day]}
  HeureMaxT[$i:$Day]=${HeureMaxT[$suivant:$Day]}
done
    done
      fi
      echo
      echo "Utilisateur $UtilisateurSupprime supprimé."
fi
 
echo
 
#Ecriture dans TS.conf
 
for i in $(seq 1 $NombreUser) ;
do
    line="${UserConcerneT[$i]}"
    for Day in Mon Tue Wed Thu Fri Sat Sun ;
    do
TSmaxH=$(echo ${TSMaxT[$i:$Day]} | cut --delimiter="h" -f1)
TSmaxM=$(echo ${TSMaxT[$i:$Day]} | cut --delimiter="h" -f2)
line="${line}-${Day} $TSmaxH $TSmaxM ${HeureMinT[$i:$Day]} ${HeureMaxT[$mod:$Day]}"
    done
    echo $line
    if [ "$i" == "1" ] ;
      then
          echo $line > /var/log/TempsSession/TS.conf
      else
  echo $line >> /var/log/TempsSession/TS.conf
    fi
    let "i=i+1"
done
 
echo
echo "Nouveau fichier de configuration enregistré:"
echo
 
i=0
while read line 
do   
     let "i=i+1"
     UserConcerneT[$i]=$(echo $line | cut --delimiter="-" -f1)
     echo "***************${UserConcerneT[$i]}****************"
     echo " * Jour : Temps de Session -- Plage horaire autorisée"
     for k in $(seq 2 8) ;
 do
    JourSemaine=$(echo $line | cut --delimiter="-" -f${k})
    set $JourSemaine
    #DayT[$i]=$1
    Day=$1
    TSMaxT[$i:$1]="${2}h${3}"
    HeureMinT[$i:$1]=$4
    HeureMaxT[$i:$1]=$5
    case $1 in
    Mon) Jour="Lundi   " ;;
    Tue) Jour="Mardi   " ;;
    Wed) Jour="Mercredi" ;;
    Thu) Jour="Jeudi   " ;;
    Fri) Jour="Vendredi" ;;
    Sat) Jour="Samedi  " ;;
    Sun) Jour="Dimanche" ;;
    *)
echo "*********"
echo "ATTENTION"
echo "Erreur dans /var/log/TempsSession/TS.conf, vous devez l'effacer et relancer TempsSessionConf.sh"
echo "*********"
echo
exit 
    esac
    echo " * $Jour: ${TSMaxT[$i:$Day]} -- de $4 à $5"
  done
done < /var/log/TempsSession/TS.conf

3. TempsSessionAlert.sh

3.1 Localisation

J'ai localisé ce script dans /usr/bin :
-rwxr-xr-x 1 root root 5479 janv. 2 15:25 TempsSessionAlert.sh*
Bien veiller à l'autoriser en exécution par les utilisateurs hors groupe "root".

3.2 La démarche

Il est lancé via le crontab utilisateur.
Dans une console, sous l'invite de l'utilisateur concerné, il faut taper crontab -e et ajouter la ligne :

Code BASH :

*/5 * * * * /bin/sh /usr/bin/TempsSessionAlert.sh

Ici, il vérifie toutes les 5 minutes, juste après le calcul réalisé par TempsSession.sh.
Dès qu'il restera moins de 10 minutes, le script commencera à ouvrir des fenêtres d'alerte (le compte à rebours commence 15 minutes avant). Pendant cette durée de 15 minutes, ce même script redemmarera toutes les 5 minutes (par le crontab), mais sera automatiquement tué.

3.3 Le script

Code BASH :

 
#!/bin/bash
 
# TempsSessionAlert.sh
# v.1.00
 
UserConnecte=$(whoami)
 
if [ -e /var/log/TempsSession/TS${UserConnecte}.var ] ;
  then
      read jderniereconx HeureDebutConnexion TempsSessionMaxS HeureCtrlS laps tcumulS NumDisplay HeureMin HeureMax < /var/log/TempsSession/TS${UserConnecte}.var
      if [ "$jderniereconx" != "$(date +%D)" ] ; 
    then
exit
      fi
  else
      exit
fi
 
 
 
if [ $(ps x | grep "/bin/sh /usr/bin/TempsSessionAlert.sh" | wc -l) == "3"  ] ;
  then
      sleep 1s
 
# Calcul du temps restant
      t0=$(date +%s)
      let "delta = t0 - HeureCtrlS"
      let "declenchement = TempsSessionMaxS - tcumulS"
      let "TempsRestantS = (declenchement /(laps*60) +1)*laps*60 - delta"
 
      HeureMaxH=$(echo $HeureMax | cut --delimiter=":" -f1)
      HeureMaxM=$(echo $HeureMax | cut --delimiter=":" -f2)
      let "HeureMax = HeureMaxH * 60 * 60 + HeureMaxM * 60"
      let "Heure = $(date +%H) * 60 * 60 + $(date +%M) * 60 $(date +%S)"
      let "delta = HeureMax - Heure"
 
      if [ $delta -lt $TempsRestantS ] ;
then
    TempsRestantS=$delta
      fi
 
# Décision de déclencher l'alerte      
      if [ $TempsRestantS -ge "600" ] && [ $TempsRestantS -lt "900" ] ;
then
    let "TempsRestantS = TempsRestantS - 600"
    sleep ${TempsRestantS}s  
    DISPLAY=${NumDisplay} /usr/bin/kdialog --passivepopup "DECONNEXION dans 10 minutes" 5
    sleep 295s
    TempsRestantS="300"
      fi
 
      if [ $TempsRestantS -ge "300" ] && [ $TempsRestantS -lt "600" ] ;
then
    let "TempsRestantS = TempsRestantS - 300"
    sleep ${TempsRestantS}s
    DISPLAY=${NumDisplay} /usr/bin/kdialog --passivepopup "DECONNEXION dans 5 minutes" 5
    sleep 235s
    TempsRestantS="60"
      fi
 
      if [ $TempsRestantS -ge "60" ] && [ $TempsRestantS -lt "300" ] ;
then
    let "TempsRestantS = TempsRestantS - 60"
    sleep ${TempsRestantS}s
    DISPLAY=${NumDisplay} /usr/bin/kdialog --title "-ATTENTION-" --passivepopup "DECONNEXION DANS 1 MINUTE !" 5
    sleep 49s
    TempsRestantS="6"
      fi
 
      if [ $TempsRestantS -lt "60" ] ;
then
    let "TempsRestantS = TempsRestantS - 7"
    sleep ${TempsRestantS}s
    j=5
    s="S"
    for i in $(seq 1 5) ; do
if [ $j == "1" ] ; 
  then s=""
fi
DISPLAY=${NumDisplay} /usr/bin/kdialog --passivepopup "DECONNEXION DANS $j SECONDE${s} !" 1
let "j=j-1"
    done
    DISPLAY=${NumDisplay} /usr/bin/kdialog --passivepopup "-DECONNEXION-" 10
      fi
 
 
fi

4. TempsSessionAjout.sh

4.1 Localisation

J'ai localisé ce script dans /usr/bin :
-rwxr-x--- 1 root root 6712 janv. 13 2016 TempsSessionAjout.sh*
Bien Veiller à ne pas l'autoriser en écriture et en exécution par les utilisateurs hors groupe "root".

4.2 La démarche

Il est lancé en su via une console : ./usr/bin/TempsSessionAjout.sh
Il suffit ensuite de suivre les instructions, si vous ne mettez pas d'argument. Pour plus de rapidité, vous pouvez faire suivre d'arguments (cf. script ou tapez ./usr/bin/TempsSessionAjout.sh --help.
Vous avez le choix d'ajouter du temps ou de faire déconnecter la session à une heure (plus ou moins précise).

4.3 Le script

Code BASH :

 
#!/bin/bash
 
# TempsSessionAjout.sh
# v.1.00
 
clear
 
if [ "$1" == "--help" ] || [ "$1" == "-h" ] ;
  then
      echo "TempsSessionAjout.sh peut s'employer sans ou avec des arguments"
      echo "Veillez à utiliser la bonne la syntaxe, au quel cas des dysfonctionnements peuvent apparaître."
      echo
      echo "./TempsSessionAjout.sh"
      echo "       (conseillé) répondre aux questions posées."
      echo "./TempsSessionAjout.sh arg1 arg2 arg3"
      echo "   --> arg1: login de l'utilisateur concerné"
      echo "   --> arg2: durée de connexion à ajouter (syntaxe HHhMM) ou nouvelle heure de deconnexion (syntaxe HH:MM)"
      echo "   --> arg3: autorisation de dépassement de la plage horaire configurée pour l'utilisateur concerné (syntax o ou n)"
      echo "./TempsSessionAjout.sh arg1 arg2"
      echo "   --> arg1: durée de connexion à ajouter (syntaxe HHhMM) ou nouvelle heure de deconnexion (syntaxe HH:MM)"
      echo "   --> arg2: autorisation de dépassement de la plage horaire configurée pour l'utilisateur concerné (syntax o ou n)"
      echo "     L'utilisateur concerné sera celui de la session active."
      exit
fi
 
 
 
if [ "$#" == "2" ] || [ "$#" == "3" ] ;
  then
      if [ $# == "2" ] ;
then
    TSajout=$1
    PlageDep=$2
    set $(who)
    UserConnecte=$1
 
else
    UserConnecte=$1
    TSajout=$2
    PlageDep=$3
      fi
      read jderniereconx HeureDebutConnexion TempsSessionMaxS HeureCtrlS laps tcumulS NumDisplay HeureMin HeureMax devnull < /var/log/TempsSession/TS${UserConnecte}.var
      raccourci="pris"
fi
 
while [ "$ok" != "o" ] ; do
  if [ "$raccourci" != "pris" ] ;
    then
      set $(who)
      read -n 1 -p "L'utilisateur concerné est-il $1 ? [o/n] " rep
      if [ "$rep" == "o" ] ;
then
    UserConnecte=$1
else
    UserConnecte="unknown"
    until [ -e /var/log/TempsSession/TS${UserConnecte}.var ] ; do
echo
read -p "Donner le login de l'utilisateur concerné : " UserConnecte
if [ ! -e /var/log/TempsSession/TS${UserConnecte}.var ] ;
  then
      echo
      echo "L'utilisateur $UserConnecte n'est pas concerné par une limitation de temps de session ou n'existe pas, vérifier son orthographe."
      echo
      read -n 1 -p "Presser la barre d'espace pour donner un nouveau login ou "q" pour quitter le script : " rep
      echo
      if [ "$rep" == "q"  ] ;
then 
    exit
      fi
fi
    done
      fi
      read jderniereconx HeureDebutConnexion TempsSessionMaxS HeureCtrlS laps tcumulS NumDisplay HeureMin HeureMax devnull < /var/log/TempsSession/TS${UserConnecte}.var
      echo
      echo "Vous pouvez choisir soit:"
      echo " - d'ajouter du temps de connexion   sous la forme HHhMM (ex: 1h10 ou 0h30),"
      echo " - d'indiquer l'heure de déconnexion sous la forme HH:MM (ex: 20:15)."
      echo
      read -p "Indiquer votre durée ou votre heure : " TSajout
  fi  
  echo
  TSajoutH=$(echo $TSajout | cut --delimiter="h" -f1)
  TSajoutM=$(echo $TSajout | cut --delimiter="h" -f2)
  if [ "$TSajoutH" == "$TSajoutM" ] ; 
    then read -n 1 -p "Deconnecter $UserConnecte à $TSajout [o/n] ? " ok
    else read -n 1 -p "Ajouter $TSajout de connexion à $UserConnecte [o/n] ? " ok
  fi
  echo
  if [ "$ok" != "o" ] ;
     then
  raccourci="a ne pas prendre"
  fi
done
 
echo
 
HeureMaxH=$(echo $HeureMax | cut --delimiter=":" -f1)
HeureMaxM=$(echo $HeureMax | cut --delimiter=":" -f2)
let "HeureMaxS = HeureMaxH * 3600 + HeureMaxM * 60"
 
HeureMinH=$(echo $HeureMin | cut --delimiter=":" -f1)
HeureMinM=$(echo $HeureMin | cut --delimiter=":" -f2)
let "HeureMinS = HeureMinH * 3600 + HeureMinM * 60"
 
let "delta = ( HeureCtrlS + laps * 60 ) - $(date +%s)"
 
 
if [ "$TSajoutH" == "$TSajoutM" ] ;
  then
      # heure de deconnexion
      TSajoutH=$(echo $TSajout | cut --delimiter=":" -f1)
      TSajoutM=$(echo $TSajout | cut --delimiter=":" -f2)
      let "TSajoutS = TSajoutH * 3600 + TSajoutM * 60"
      let "HeureDeconS = TSajoutS"
      let "HeureDeconH = TSajoutH"
      let "HeureDeconM = TSajoutM"
      let "TempsSessionMaxS = HeureDeconS + tcumulS - HeureCtrlS + $(date +%s) - $(date +%H) * 3600 - $(date +%M) * 60 - $(date +%S)"
 
  else
      # temps à ajouter
      let "TSajoutS = TSajoutH * 3600 + TSajoutM * 60"
      let "TempsSessionMaxS = TempsSessionMaxS + TSajoutS"
      let "HeureDeconS = $(date +%H) * 3600 + $(date +%M) * 60 + TempsSessionMaxS - tcumulS + delta"
      let "HeureDeconH = HeureDeconS / 3600"
      let "HeureDeconM = ( HeureDeconS % 3600 ) / 60 + 1"
      if [ "$HeureDeconM" == "60" ] ;
then 
    HeureDeconM="00"
    let "HeureDeconH = HeureDeconH +1"
      fi
fi
 
if [ $HeureDeconS -gt $HeureMaxS ] ;
  then
      echo "La plage de connexion autorisée de $UserConnecte se termine normalement à $HeureMax."
      echo "La durée ajoutée dépasse cette heure de déconnexion habituelle."
      echo
      read -n 1 -p "Souhaitez-vous autoriser ce dépassement et programmer la déconnexion de $UserConnecte vers ${HeureDeconH}:${HeureDeconM} : [o/n] " PlageDep
      echo
      if [ "$PlageDep" == "o" ] ;
then
    HeureMax="${HeureDeconH}:${HeureDeconM}"
    echo "Dépassement autorisé."
 
else
    echo "Dépassement non autorisé."
      fi
   else
      if [ $HeureDeconS -lt $HeureMinS ] ;
then
    echo "La plage de connexion autorisée de $UserConnecte ne commence normalement qu'à $HeureMin."
    echo
    read -n 1 -p "Souhaitez-vous autoriser une connexion dès maintenant, il est $(date +%R) : [o/n] " PlageDep
    echo
    if [ "$PlageDep" == "o" ] ;
      then
  HeureMin=$(date +%R)
  echo "connexion autorisée."
      echo  
      else
  echo "Connexion non autorisée."
  echo
    fi
      fi
fi
 
 
if [ ${#HeureDeconM} == "1" ] ; then HeureDeconM="0${HeureDeconM}" ; fi
echo "$UserConnecte sera déconnectée vers ${HeureDeconH}:${HeureDeconM}."
echo
echo $jderniereconx $HeureDebutConnexion $TempsSessionMaxS $HeureCtrlS $laps $tcumulS $NumDisplay $HeureMin $HeureMax > /var/log/TempsSession/TS${UserConnecte}.var
 
 
# le processus TempsSessionAlert.sh est tué s'il est en cours d'exécution de compte à rebours
set $(ps ax | grep "TempsSessionAlert")
proc1=$1
set $(ps ax | grep "TempsSessionAlert")
proc2=$1
 
if [ "$proc1" == "$proc2" ] ;
  then
      kill $proc1
fi

5. TempsSessionLect.sh *à peine commencé*

5.1 Localisation

J'ai localisé ce script dans /usr/bin :
-rwxrwx--x 1 root root 709 janv. 16 15:27 TempsSessionLect.sh*
Bien veiller à l'autoriser en exécution par les utilisateurs hors groupe "root".

5.2 La démarche

Je souhaite le faire lancer via une icône sur le bureau de l'utilisateur. Il ouvrirait une fenêtre indiquant le temps restant.

***************************************

Alors, ça marche sur notre PC familliale, plus ou moins bien (des petits décalages entre les fenêtres d'alerte et la deconnexion des fois quand on ajoute du temps).

Avec ce jeu de script, plus besoin de configurer des autoriations du pam (cf. posts plus haut dans le sujet).
En revanche, c'est moins classe, au lieu d'avoir un beau "ECHEC A LA CONNEXION", vous avez la connexion qui est activée, puis désactivée (le temps que TempsSessionConf.sh fasse son petit calcul)...

Quant à son application à un réseau (cf. post de kalagani ), je ne sais pas comment faire. TempsSession.sh repère déjà sur quel DISPLAY est connecté l'utilisateur à limiter, c'est peut-être un début.

A vos remarques... prêt... PARTEZ !!

Édité par Tromb Le 27/11/2015 à 21h24

Tromb
supernovice

Répondre

Vous n'êtes pas autorisé à écrire dans cette catégorie

Notre Mission	Liens du site	Nous joindre	MLO est hébergé par
MLO est le forum francophone de la distribution Mageia et vous propose également un portail dédié aux débutants. MLO vous apporte un support sur la distribution grâce à son forum et vous offre des nouvelles de la distribution, des logiciels libres et de l'Open Source en général. Notre site a aussi pour but de vous montrer que Mageia est un système d'exploitation complet et facile à prendre en main. Vous apprendrez à installer simplement et à administrer efficacement votre système en un temps record.	Forum Documentation News du libre Mageia	Contacter MLO Mastodon MLO Flux RSS	MLO est un projet soutenu par Nos partenaires et amis
MLO est mis à disposition selon les termes de la licence Creative Commons.

Visiteur

Tromb Membre non connecté

kalagani Membre non connecté

Tromb Membre non connecté

kalagani Membre non connecté

Tromb Membre non connecté

Tromb Membre non connecté

kalagani Membre non connecté

fofo77 Membre non connecté

Tromb Membre non connecté

Tromb Membre non connecté