Minuterie d’écran de verrouillage

Créez votre propre minuterie de verrouillage d’écran au lieu d’applications tierces

Bien qu'il existe des applications tierces, vous pouvez créer vos propres applications. Résumé des étapes:

• Utilisez gedit pour créer le script lock-screen-timer
• Copiez et collez le code de cette fenêtre dans lock-screen-timer
• Marquer lock-screen-timer comme exécutable
• Testez-le!
• Configurez Nautilus pour exécuter des scripts bash
• Créer un lien de raccourci sur le bureau
• Surveiller le temps restant

Utilisez gedit pour créer le script lock-screen-timer

Ouvrez le Terminal en utilisant Ctrl + Alt + T et tapez:

gedit lock-screen-timer

Copiez et collez le code de la fenêtre ci-dessous dans lock-screen-timer

Revenez à cet écran et copiez le code suivant en le sélectionnant et en appuyant sur Ctrl + C :

#!/bin/bash

# NAME: lock-screen-timer
# PATH: $HOME/bin
# DESC: Lock screen in x minutes
# CALL: Place on Desktop or call from Terminal with "lock-screen-timer 99"
# DATE: Created Nov 19, 2016. Last revision Mar 22, 2018.
# UPDT: Updated to support WSL (Windows Subsystem for Linux)
#       Remove hotplugtv. Replace ogg with paplay.

# NOTE: Time defaults to 30 minutes.
#       If previous version is sleeping it is killed.
#       Zenity is used to pop up entry box to get number of minutes.
#       If zenity is closed with X or Cancel, no screen lock timer is launched.
#       Pending lock warning displayed on-screen at set intervals.
#       Write time remaining to ~/.lock-screen-timer-remaining

MINUTES="" # Optional parameter 1 when invoked from terminal.

# if no parameters set default MINUTES to 30
if [ $# == 0 ]; then
    MINUTES=30
fi

DEFAULT="$MINUTES" # When looping, minutes count down to zero. Save deafult for subsequent timers.

# Check if lock screen timer already running
pID=$(pgrep -f "${0##*/}") # All PIDs matching lock-screen-timer name
PREVIOUS=$(echo "$pID" | grep -v ^"$$") # Strip out this running copy ($$$)
if [ "$PREVIOUS" != "" ]; then
    kill "$PREVIOUS"
    rm ~/.lock-screen-timer-remaining
    zenity --info --title="Lock screen timer already running" --text="Previous lock screen timer has been terminated."
fi

# Running under WSL (Windows Subsystem for Linux)?
if cat /proc/version | grep Microsoft; then
    WSL_running=true
else
    WSL_running=false
fi


while true ; do # loop until cancel

    # Get number of minutes until lock from user
    MINUTES=$(zenity --entry --title="Lock screen timer" --text="Set number of minutes until lock" --entry-text="$DEFAULT")

    RESULT=$? # Zenity return code
    if [ $RESULT != 0 ]; then
        break ; # break out of timer lock screen loop and end this script.
    fi

    DEFAULT="$MINUTES" # Save deafult for subsequent timers.
    if [[ $MINUTES == 0 ]] || [[ $MINUTES == "" ]]; then
        break ; # zero minutes considered cancel.
    fi

    # Loop for X minutes, testing each minute for alert message.
    (( ++MINUTES )) 
    while (( --MINUTES > 0 )); do
        case $MINUTES in 1|2|3|5|10|15|30|45|60|120|480|960|1920)
            notify-send --urgency=critical --icon=/usr/share/icons/gnome/256x256/status/appointment-soon.png "Locking screen in ""$MINUTES"" minute(s)." ;
            if [[ $WSL_running == true ]]; then  
                powershell.exe -c '(New-Object Media.SoundPlayer "C:\Windows\Media\notify.wav").PlaySync();'
            else
               paplay /usr/share/sounds/freedesktop/stereo/complete.oga ;
            fi
           ;;
        esac;

        # Record number of minutes remaining to file other processes can read.
        echo "$MINUTES Minutes" > ~/.lock-screen-timer-remaining

        sleep 60

    done

    rm ~/.lock-screen-timer-remaining # Remove work file others can see our progress with

    if [[ $WSL_running == true ]]; then  
        # Call lock screen for Windows 10
        rundll32.exe user32.dll,LockWorkStation
    else
        # Call screen saver lock for Unbuntu versions > 14.04.
        dbus-send --type=method_call --dest=org.gnome.ScreenSaver /org/gnome/ScreenSaver org.gnome.ScreenSaver.Lock
    fi

done # End of while loop getting minutes to next lock screen

exit 0 # Closed dialog box or "Cancel" selected.

Revenez ensuite à la fenêtre gedit vide et collez le code en utilisant Ctrl + V . Enregistrez le fichier et quittez l'éditeur pour revenir à l'invite de commande.

Marquez lock-screen-timer comme un exécutable

Maintenant, nous devons rendre le script exécutable en tapant:

chmod +x lock-screen-timer

Testez-le!

Avant d’appeler le script depuis l’interface graphique, nous l’appellerons depuis le terminal pour voir si des messages d’erreur sont affichés:

~/lock-screen-timer

Vous êtes invité à indiquer le nombre de minutes:

Définissez le nombre de minutes souhaité et cliquez sur OK pour démarrer la minuterie. Lorsqu'il reste 15, 10, 5, 3, 2 et 1 minute (s), un son de système est entendu et une bulle de message s'affiche pour vous avertir lorsque l'écran sera verrouillé. Une fois l'écran verrouillé, vous devez entrer votre mot de passe pour déverrouiller l'écran.

Configurez Nautilus pour qu’il exécute les scripts bash

Nautilus définit ce qui se passe lorsque vous double-cliquez sur un script exécutable lorsque la fenêtre d’affichage des fichiers ou un lien sur le bureau. Le comportement normal consiste à modifier le script en utilisant gedit . Nous voulons changer ce comportement pour qu'il soit exécuté.

Lancez Nautilus et accédez au répertoire contenant lock-screen-timer . Clic gauche dessus une fois pour lui donner le focus. Passez la souris sur la barre de menus supérieure jusqu'à ce que le menu "File Edit ..." apparaisse, utilisez:

1. Cliquez sur le menu déroulant Edit
2. Cliquez sur l'option Properties
3. Cliquez sur l'onglet Behavior
4. Observez les boutons d’option radio sous Executable Text Files
5. Vérifiez le bouton radio Run executable text files when they are opened

Créer un lien de raccourci sur le bureau

De la section précédente, lock-screen-timer a toujours le focus. Sinon, naviguez jusqu'au script et cliquez dessus une fois pour lui donner le focus. Puis utilisez:

• Cliquez avec le bouton droit sur le fichier et les options du menu contextuel apparaissent.
• Dans le menu, sélectionnez Make Link .
• Une nouvelle icône apparaît appelée Link to lock-screen-timer .
• Cliquez avec le bouton gauche de la souris sur la nouvelle icône et faites-la glisser de Nautilus vers votre bureau.

Maintenant, vous pouvez double-cliquer sur le lien de raccourci du bureau et le script est exécuté. Une boîte de dialogue apparaît pour obtenir le nombre de minutes. Deux boutons sont présentés Annuler et OK . Si vous cliquez sur X pour fermer la fenêtre, cela revient à sélectionner Cancel .

Une fois que la minuterie est en cours d'exécution et que vous double-cliquez à nouveau dessus, la première copie en cours d'exécution est "supprimée". Vous pouvez maintenant lancer un nouveau compte à rebours ou cliquer sur Cancel pour aucun compte à rebours.

Temps d'affichage restant dans la zone de notification / dans la zone de notification

Lorsque le temporisateur de l'écran de verrouillage est en cours d'exécution, il enregistre le nombre de minutes restantes dans le fichier ~/.lock-screen-timer-remaining . Vous pouvez regarder ce fichier avec la commande watch ou l'afficher sur la barre des indicateurs de la barre d'état système / application d'Ubuntu, comme indiqué en haut de cette réponse. Pour afficher le temps restant dans la zone de notification, suivez les instructions de ce Q & A; ( BASH peut-il afficher dans la barre des tâches comme indicateur d'application? ).

Ubuntu & lt; = 11.10 Les utilisateurs suivent ce guide pour les utilisateurs d'Ubuntu & gt; = 11.10 Lisez l'avis de la page du bas:

Oui, tous ces programmes sont obsolètes et toutes vos questions ont reçu une réponse ici et une bonne vue de votre parent de contrôle .....

Lorsque nous parlons de forcer un utilisateur à fermer sa session, nous parlons en fait d'implémenter des restrictions de temps sur le compte pour l'accès au système ou les services. La manière la plus simple de mettre en œuvre des restrictions de temps consiste à utiliser un module de plug-in appelé Linux-PAM .

Le module d’authentification enfichable (PAM) est un mécanisme d’authentification des utilisateurs. Plus précisément, nous allons utiliser le module pam_time pour contrôler l'accès temporisé des utilisateurs aux services.

En utilisant le module pam_time , nous pouvons définir des restrictions d'accès à un système et / ou à des applications spécifiques à différents moments de la journée, ainsi que sur des jours spécifiques ou sur différentes lignes de terminal. Selon la configuration, vous pouvez utiliser ce module pour refuser l'accès aux utilisateurs individuels en fonction de leur nom, de l'heure, du jour de la semaine, du service demandé et de leur terminal à partir duquel ils font la demande. .

Lorsque vous utilisez pam_time , vous devez terminer la syntaxe de chaque ligne (ou règle) dans le fichier /etc/security/time.conf avec une nouvelle ligne. Vous pouvez commenter chaque ligne avec le signe dièse [#], et le système ignorera ce texte jusqu'à la nouvelle ligne.

Voici la syntaxe d'une règle:

  

services, ttys, utilisateurs, temps

The first field —  services — is a logic list of PAM service names.
The second field — tty — is a logic list of terminal names.
The third field — users — is a logic list of users or a netgroup of users.
The fourth field — times — indicates the applicable times.

Voici un exemple d’un ensemble typique de règles:

login ; * ; !bobby ; MoTuWeThFr0800-2000
login ; * ; !root ; !Al0000-2400
http ; * ; !bobby ; MoTuWeThFr0800-2000
http ; * ; !root; !Al0000-2400

Ces règles empêchent l'utilisateur bobby de se connecter entre 0800 et 2000, et restreignent également l'accès à Internet pendant ces heures. Root pourra se connecter à tout moment et naviguer sur Internet à tout moment.

Remarque: le système enregistre les erreurs avec ces règles sous la forme syslog (3).

Avec Ubuntu Linux, il est possible d’attribuer à votre ordinateur des restrictions de temps pour empêcher la connexion d’un ou plusieurs utilisateurs à votre système. Avec les restrictions de temps, vous pouvez, par exemple, limiter l'accès à l'ordinateur à vos enfants (une sorte de contrôle parental, en bref) ou même protéger la connexion à votre serveur pendant certaines heures.

Configuration manuelle

Comprendre ce que vous allez faire

Tout au long de ce didacticiel, nous utiliserons PAM (Modules d’authentification enfichables, modules d’authentification enfichables en anglais). Il vous permet de contrôler l'authentification des utilisateurs lorsqu'ils se connectent. Nous utiliserons ensuite les fichiers de configuration de sécurité pour définir les heures d'ouverture de session autorisées. Ces manipulations peuvent être effectuées sur n'importe quelle version d'Ubuntu et ne requièrent qu'un simple éditeur de texte (vim, emacs, nano, gedit, kate, etc.). Activer les restrictions par le biais du module PAM

Tout d'abord, allez d'abord dans /etc/pam.d/ , où sont tous les services configurables:

$ Ls /etc/pam.d/
atd common-account common-session gdm login ppp sudo
chfn common-auth cron gdm-autologin Other samba
chsh common-cupsys gnome-screensaver password passwd su

Si nous voulons bloquer la connexion à l’ordinateur, nous devrons changer le service gdm. Editez le fichier si gdm et ajoutez cette ligne de code (à la fin du fichier):

account required pam_time.so

GDM correspond aux distributions d’écran de connexion Ubuntu, Edubuntu et Xubuntu. Pour Kubuntu, qui utilise KDE, le service kdm est appelé, ce sera le fichier qu'il va ouvrir. Et vous avez fini de configurer le PAM! Cela permettra le contrôle des heures sur ce service.

Si vous avez un serveur, vous n'avez probablement pas d'interface graphique. Dans ce cas, GDM / KDM n'est pas installé et la connexion ne sera pas bloquée. Pour empêcher la connexion à TTY, vous devez modifier le login du même fichier et ajouter la même ligne de code que celle précédemment reconnue. Cette action s’applique également aux personnes ayant installé une interface graphique et souhaitant bloquer l’accès à l’écran de connexion et aux terminaux.

Configurer les heures d’accès

Maintenant que le service PAM est activé, il suffit de configurer les temps d’accès. Ouvrez le /etc/security . Plusieurs fichiers de configuration sont disponibles:

$ Ls /etc/security/
access.conf namespace.conf pam_env.conf
group.conf namespace.init time.conf
limits.conf opasswd time.conf.bak

Modifiez le fichier time.conf . Quelques explications et exemples (anglais) présentant le. Pour définir des planifications d'accès, copiez et collez la ligne de code suivante (à la fin du fichier, comme toujours):

*;*;user;scheduler

Au lieu du champ utilisateur, entrez le compte de connexion que vous souhaitez bloquer.

Si vous souhaitez bloquer plusieurs utilisateurs, saisissez leur identifiant à la suite, séparés par | opérateur. Par exemple, si je veux geler les comptes de Patrick, John et Emily:

*;*;Patrick|jean|emilie;scheduler

Par contre, si vous voulez bloquer l’accès au système pour tous les utilisateurs sauf un, utilisez le! devant la personne concernée. Par exemple, si je souhaite que l’accès à l’ordinateur soit refusé à tous les utilisateurs, sauf Nicolas et Xavier:

Nicolas *;*;!|xavier;scheduler

Passons maintenant aux zones de champ. Dans ce champ, la sélection des jours et des heures sera autorisée.Vous devez d'abord spécifier le jour de la semaine en utilisant les abréviations suivantes:

Mo : Monday     Fr : Friday     Wd : Sa/Su
Tu : Tuesday    Sa : Saturday   wk : Mo/Tu/We/Th/Fr
We : Wenesday   Su : Sunday
Th : Thursday   Al : All Days

Faites attention à ne pas confondre les abréviations Wk et Wd sont trompeuses! particulièrement mal identifiées sur Internet: vous pouvez facilement trouver des informations contradictoires!

Ensuite, nous spécifions les délais. Celles-ci doivent être formatées 24H, composées de 4 chiffres. Par exemple, limiter 15h17 à 18h34, nous écrivons: 1517-1834. Permettre à Marie de se connecter uniquement le mardi, à partir de 15h17 à 18h34, nous obtenons le résultat:

*;*;marie;Tu1517-1834

Les connexions en dehors de ces heures seront interdites. Comme pour les utilisateurs, il est possible d'utiliser les opérateurs | et! pour indiquer plusieurs fois (le! indique alors que toutes les heures de connexion sont autorisées, sauf celles à afficher).

Les deux étoiles (caractères génériques) au début de la ligne de code sont respectivement les champs tty services. Puisque vous voulez bloquer tout accès au système, il est inutile de spécifier quel service ou quel terminal vous souhaitez bloquer. Toutefois, si vous souhaitez empêcher l'utilisation d'un service particulier, spécifiez-le simplement comme suit:

login;tty1|tty4|tty5;marie;!Wd0000-2400

Ainsi, l’utilisateur ne peut pas se connecter à un ATS, 4 et 5 pendant le week-end.

Quelques exemples de calendrier des restrictions

mathilde est autorisée à se connecter tous les jours à partir de 13h20 à 15h20 et à partir de 16h00 à 20h30:

*;*;mathilde;Al1320-1520|Al1600-2030

Stone, Frank et Florian sont autorisés à se connecter à 14h00 à 18h45 en semaine et à 14h00 à 22h15 pour le week-end:

*;*;Stone|franck|florian;Wk1400-1845|Wd1400-2215

Olive n'est jamais autorisé à se connecter. Jessica peut se connecter mercredi à partir de 13h00 à 16h00:

*;*;olivier;!Al0000-2400
*;*;jessica;We1300-1600

2 lignes différentes, pour deux temps différents pour chaque utilisateur Expiration d'une session

Lorsqu'une session expire (elle dépasse le temps pendant que l'utilisateur est déjà connecté), le PAM peut atteindre l'utilisateur. Bien que mathilde se connecte pendant les heures autorisées, il est parfaitement libre de dépasser ces heures! Pour cela, nous utiliserons un nouveau programme:'cron '. Cette application exécute des commandes à intervalles de temps. Dans notre cas, nous utiliserons la commande'skill-KILL-u 'pour déconnecter l'utilisateur à l'expiration de la session. La manipulation est très simple. Editez simplement le fichier '/ etc / crontab'. Ajoutez ensuite la ligne de code suivante:

Minute Hour Day * * (s) root skill -KILL -u User

Comme précédemment, en remplaçant les horaires et le temps souhaités des champs Minute. Remplissez ensuite le ou les jour (s) par jour (s) interdit (s), ou tapez simplement un astérisque (*) pour indiquer tous les jours de la semaine. Enfin, modifiez le champ utilisé par le compte de connexion à bloquer, et le tour est joué!

Les jours ne sont pas identiques avec les travaux cron ! Voici la liste des abréviations à utiliser avec ce programme:

mon : monday    fri : friday
tue : tuesday   sat : saturday
wed : wednesady sun : sunday
thu : thursday   *  : all hours

Quelques exemples de travaux cron (avec des exemples de fois dans la section précédente)

  

- & gt; Déconnecter: mardi à 16h00 ..

00 16 * root * wed skill -KILL -u jessica

mathilde est autorisée à se connecter tous les jours à partir de 13h20 à 15h20 et à partir de 16h00 à 20h30 ..

  

- & gt; Déconnexion: Quotidien, 20h30 à 15h20 ET.

20 15 * * * root skill -KILL -u mathilde
30 20 * * * root skill -KILL -u mathilde

Stone, Frank et Florian sont autorisés à se connecter à 14h00 à 18h45 en semaine et à 14h00 à 22h15 pour le week-end

  

- & gt; Déconnexion (1): lundi, mardi, mercredi, jeudi et vendredi, à 18h45.   - & gt; Déconnexion (2): samedi et dimanche à 22h15.

45 18    * * mon,tue,wed,thu,fri   root    skill -KILL -u stone && skill -KILL -u franck && skill -KILL -u florian
15 22    * * sat,sun               root    skill -KILL -u stone && skill -KILL -u franck && skill -KILL -u florian

La commande skill-KILL-u déconnecte l'utilisateur de l'interface graphique, ainsi que TTY. Il est parfaitement utilisable pour les administrateurs de serveur. Cependant, cette commande est immédiate et la déconnexion se fera sans préavis. Il serait donc préférable d'empêcher l'installation de cet appareil utilisateurs de l'ordinateur ou du réseau en question!

Il est possible d’empêcher les utilisateurs avec une commande wall lancée par cron quelques minutes avant la fin du délai , qui sera affichée dans les terminaux de tous les utilisateurs.

40 18 * * Mon,Tue,wed,thu,fri root echo "end of session in 5 minutes" | wall

Pour éviter que les utilisateurs de l’interface graphique puissent être utilisés à la place de la commande murale, notify-send se trouve dans le package libnotify-bin

40 18 * * Mon,Tue,wed,thu,fri stone DISPLAY=:0 notify-send "end of session in 5 minutes"

Utilisateurs d'Ubuntu 11.10

J'ai vu des utilisateurs avoir des problèmes avec Pam et j'ai vu beaucoup de bugs à ce sujet alors pourquoi est-ce la raison ??? est si simple que Ubuntu 11.10 ne supporte plus GDM le nouveau gestionnaire d'affichage est lightGDM le problème est le suivant où stocker cette directive account required pam_time.so je pense est dans /etc/pam.d/lightdm ou /etc/pam.d/lightdm-autologin mais bogue comment ???

donc juste pour vous pouvez vérifier ces 2 fichiers journaux LightGdm:

• /var/log/lightdm/lightdm.log
• / var / log / lightdm / x-0.log

ou lancez LightGdm en mode débogage:

  

LightDM --debug

ou signaler un bogue:

  

ubuntu-bug lightdm

Je signale que le bogue "ici , alors passez votre doigt et attendez ....

TimeKpr

Je suppose qu'il a tout ce dont vous avez besoin. Limitez le temps d’accès par jour et par utilisateur, simplifiez la configuration, évitez les contournements pendant une journée, ajoutez du «temps de récompense», une notification du temps restant pour les utilisateurs, etc.

La page du projet est ici . Ils ont également un PPA pour Ubuntu que vous pouvez ajouter à vos sources de logiciels: deb http://ppa.launchpad.net/timekpr-maintainers/ppa/ubuntu lucid main . Et installer via Software Center ou via CLI: sudo apt-get install timekpr .

Timekpr

peut être utilisé en 11.10 en exécutant LightDM pour configurer des restrictions pour les utilisateurs en ajoutant la ligne suivante à /etc/pam.d/lightdm

account required pam_time.so

^{Nous devrons peut-être supprimer libpam-smbpass pour activer le changement d’utilisateur jusqu’à ce que le bogue n ° 835310 est corrigé.}

Toutes les restrictions définies dans la fenêtre de l’application sont définies dans l’interface graphique de timekpr.

Pour afficher l’icône timekpr-client dans Unity, nous devons liste blanche 'timekpr' dans les paramètres du panneau Unity et, en outre, nous devons ajouter Unity à la ligne suivante dans /etc/xdg/autostart/timekpr-client.desktop :

OnlyShowIn=GNOME;XFCE;KDE;Unity;

Pour démarrer le compte à rebours du temps imparti, il se peut que nous devions démarrer le démon timekpr avec

/etc/init.d/timekpr start

pour 14.04:

Une nouvelle version / fork de timekpr a été publiée pour Ubuntu 14.04 par Eduards Bezverhijs dans son ppa:mjasnik/ppa .

La déconnexion automatique est extrêmement frustrante si vous êtes au milieu de quelque chose. C'est violent, c'est brutal, c'est brutal. Et quel que soit votre âge. C'est une chose quand vous êtes simplement accro à l'ordinateur et que c'est très différent quand vous traquez du temps et que vous êtes expulsé 5 secondes avant que vous ne parveniez à cliquer sur ce bouton d'envoi ou à enregistrer votre document. Je vous suggère de penser à utiliser un rappel automatique au lieu d'un auto-kicker. Cela apprendra à vos enfants à se respecter mutuellement et à se permettre mutuellement d'utiliser l'ordinateur.

Il existe même une alternative plus légère. Commencez par suivre la quantité de temps que chaque enfant passe à utiliser l'ordinateur et rendre les données recueillies disponibles pour tous afin qu'ils puissent le voir. Cette chose incroyablement simple (appliquée à la bande passante Internet dépensée) m'a sauvé la vie quand j'étais l'administrateur du réseau dans un bureau rempli d'adultes. Les statistiques publiques sur l’utilisation de la bande passante pour chaque ordinateur (juste la quantité d’octets, pas les informations de dénomination comme les listes de sites visités, etc.) ont transformé la situation en «homme vous avez téléchargé 5 fois plus que moi, c'est mal! " "désolé, en effet j'ai téléchargé beaucoup de Youtube pendant les pauses déjeuner, je ne le ferai plus à ce rythme" - j'étais simplement exclu du scénario de la confrontation.

J'ai aussi eu ce problème. J'ai donc écrit le script kidtimer, qui vous permet de définir les temps d'utilisation et les totaux. Le projet peut être trouvé sur Github à l'emplacement suivant:

• lien

Voici comment l’installer et l’utiliser:

1. Copiez et collez le code dans un fichier appelé kidtimer.install .

   #!/bin/bash
   # Restrict kids computer access to specific hours and total time.
   # By: Michael Groves - grover66_at_gmail_dot_com
   
   #variables
   basedir="/usr/local/kidtimer"
   configdir="/etc/kidtimer"
   Cdate='/bin/date | awk '{ print " " }''
   TUI=0
   HOUR='/bin/date +%H'
   DOW='/bin/date +%u'
   WEEKEND="no"
   [ "$DOW" == "6" ] && WEEKEND="yes"
   [ "$DOW" == "7" ] && WEEKEND="yes"
   
   #arguments
   [ $# -eq 0 ] && TUI=1
   [ $# -eq 1 ] && COMMAND=
   [ $# -eq 2 ] && COMMAND= && KID=
   [ $# -eq 3 ] && COMMAND= && KID= && Time=
   
   ################# Subroutines ##################
   ################################################
   
   go_check_install () {
   if [ ! -e $basedir ]; then
       go_initialize
   fi
   }
   
   
   go_initialize () {
   /bin/mkdir -p $basedir/time
   /bin/mkdir -p $basedir/schedule
   /bin/cp 
   sudo ./kidtimer.install
    /usr/local/bin/kidtimer && chmod +x /usr/local/bin/kidtimer
   echo "0 * * * *     root    /usr/local/bin/kidtimer hourly" > /etc/cron.d/kidtimer
   echo "0 0 * * *     root    /usr/local/bin/kidtimer daily" >> /etc/cron.d/kidtimer
   echo "* * * * *     root    /usr/local/bin/kidtimer check" >> /etc/cron.d/kidtimer
   echo "@reboot       root    /usr/local/bin/kidtimer daily" >> /etc/cron.d/kidtimer
   echo "@reboot       root    /usr/local/bin/kidtimer hourly" >> /etc/cron.d/kidtimer
   /bin/mkdir $configdir
   /usr/bin/touch $configdir/kid.list
   go_create_message_files
   echo "Kidtimer is now installed. Run /usr/local/bin/kidtimer to configure."
   }
   
   
   go_create_message_files () {
   cat << EOF > $basedir/send5.sh
   #!/bin/bash
   Name=$1
   /bin/su -s /bin/bash -c 'DISPLAY=:0 /usr/bin/notify-send -i \
       /usr/share/pixmaps/gnome-set-time.png "ALERT" \
       "You will be logged out in 5 minutes."' $Name
   EOF
   chmod +x $basedir/send5.sh
   cat << EOF > $basedir/send4.sh
   #!/bin/bash
   Name=$1
   /bin/su -s /bin/bash -c 'DISPLAY=:0 /usr/bin/notify-send -i \
           /usr/share/pixmaps/gnome-set-time.png "ALERT" \
           "You will be logged out in 4 minutes."' $Name
   EOF
   chmod +x $basedir/send4.sh
   cat << EOF > $basedir/send3.sh
   #!/bin/bash
   Name=$1
   /bin/su -s /bin/bash -c 'DISPLAY=:0 /usr/bin/notify-send -i \
           /usr/share/pixmaps/gnome-set-time.png "ALERT" \
           "You will be logged out in 3 minutes."' $Name
   EOF
   chmod +x $basedir/send3.sh
   cat << EOF > $basedir/send2.sh
   #!/bin/bash
   Name=
   /bin/su -s /bin/bash -c 'DISPLAY=:0 /usr/bin/notify-send -i \
           /usr/share/pixmaps/gnome-set-time.png "ALERT" \
           "You will be logged out in 2 minutes."' $Name
   EOF
   chmod +x $basedir/send2.sh
   cat << EOF > $basedir/send1.sh
   #!/bin/bash
   Name=$1
   /bin/su -s /bin/bash -c 'DISPLAY=:0 /usr/bin/notify-send -i \
           /usr/share/pixmaps/gnome-set-time.png "ALERT" \
           "You will be logged out in 1 minute."' $Name
   EOF
   chmod +x $basedir/send1.sh
   cat << EOF > $basedir/logout.sh
   #!/bin/bash
   Name=$1
   /usr/bin/pkill -KILL -u $Name
   rm -rf /tmp/kidtimer.shutdown.$Name
   EOF
   chmod +x $basedir/logout.sh
   cat << EOF > $basedir/schedule/blank
   #hour weekday weekend (y/n)
   00 n n
   01 n n
   02 n n
   03 n n
   04 n n
   05 n n
   06 n n
   07 n n
   08 y y
   09 y y
   10 y y
   11 y y
   12 y y
   13 y y
   14 y y
   15 y y
   16 y y
   17 y y
   18 y y
   19 y y
   20 n n
   21 n n
   22 n n
   23 n n
   #minutes weekday weekend
   MAX 120 240
   EOF
   }
   
   
   go_check () {
   for I in 'cat $configdir/kid.list'; do
           /usr/bin/users | grep -q $I
           if [ $? -eq 0 ]; then
                   if [ -e $basedir/time/$I.ttl ]; then
                           C='cat $basedir/time/$I.ttl'
                           C=$((C + 1))
                           echo $C > $basedir/time/$I.ttl
                   else
                           echo 1 > $basedir/time/$I.ttl
                           C=1
                   fi
           else
           go_clean_jobs $I
           exit 0
       fi
           # check total time.
           W="no"
           [ $DOW -eq 6 ] && W="yes"
           [ $DOW -eq 7 ] && W="yes"
           [ "$W" == "no" ] && TIME_LIMIT='cat $basedir/schedule/$I | grep ^MAX | awk '{ print  }''
           [ "$W" == "yes" ] && TIME_LIMIT='cat $basedir/schedule/$I | grep ^MAX | awk '{ print  }''
           if [ $C -ge $TIME_LIMIT ]; then
                   if [ ! -e /tmp/kidtimer.shutdown.$I ]; then
                           /usr/bin/passwd $I -l
                           go_logout $I
                   fi
           fi
   done
   }
   
   
   go_clean_jobs () {
   K=
   for I in '/usr/bin/atq | awk '{ print  }' | sort'; do
       /usr/bin/at -c $I | grep kidtimer | grep -q $K
       [ $? -eq 0 ] && /usr/bin/at -d $I
   done
   [ -e /tmp/kidtimer.shutdown.$K ] && rm -rf /tmp/kidtimer.shutdown.$K
   }
   
   
   go_daily () {
   for I in 'cat $configdir/kid.list'; do
       ls -l $basedir/time/$I.ttl | grep -q "$Cdate"
       if [ ! $? -eq 0 ]; then
           echo "0" > $basedir/time/$I.ttl
       fi
   done
   }
   
   
   go_hourly () {
   if [ -s $configdir/kid.list ]; then
       for I in 'cat $configdir/kid.list'; do
           if [ -e $basedir/schedule/$I ]; then
               [ "$WEEKEND" == "no" ] && TL='cat $basedir/schedule/$I | grep ^MAX | awk '{ print  }''
               [ "$WEEKEND" == "yes" ] && TL='cat $basedir/schedule/$I | grep ^MAX | awk '{ print  }''
               [ -e $basedir/time/$I.ttl ] && C='cat $basedir/time/$I.ttl'
               [ $C -ge $TL ] && /usr/bin/passwd $I -l && exit 0
               [ "$WEEKEND" == "no" ] && R='grep ^$HOUR $basedir/schedule/$I | awk '{ print  }''
               [ "$WEEKEND" == "yes" ] && R='grep ^$HOUR $basedir/schedule/$I | awk '{ print  }''
               if [ "$R" == "y" ]; then
                   /usr/bin/passwd $I -u
               else
                   /usr/bin/passwd $I -l
                   /usr/bin/users | grep -q $I && /usr/local/bin/kidtimer shutdown $I
               fi
           fi
       done
   fi
   }
   
   
   go_logout () {
   K=
   echo "$basedir/send5.sh $K" | at now + 1 minutes
   echo "$basedir/send4.sh $K" | at now + 2 minutes
   echo "$basedir/send3.sh $K" | at now + 3 minutes
   echo "$basedir/send2.sh $K" | at now + 4 minutes
   echo "$basedir/send1.sh $K" | at now + 5 minutes
   echo "$basedir/logout.sh $K" | at now + 6 minutes
   touch /tmp/kidtimer.shutdown.$K
   }
   
   
   go_addtime () {
   U=$KID
   A=$Time
   if [ "$KID" == "reset" ]; then
       echo "0" > $basedir/time/$U.ttl
       echo "Done."
       exit 0
   elif [ "$KID" == "" ]; then
       echo "Error."
       echo "Syntax: addtime <user> <minutes|reset>"
       exit 1
   else    
       C='cat $basedir/time/$KID.ttl'
       C=$((C - Time))
       echo $C > $basedir/time/$KID.ttl
       echo "New total minutes is "$C"."
       echo "Done."
   fi
   
   /usr/bin/passwd $KID -u
   }
   
   
   go_tui () {
   go_command_list
   echo -n "Choose: "; read -e X
   case "$X" in
   1) go_setup_user
           ;;
   2) go_modify_user
           ;;
   3) go_remove_user
           ;;
   4) go_list_users
       ;;
   5) exit 0
           ;;
   esac
   go_tui
   }
   
   
   go_command_list () {
   echo
   echo "1) Setup user limits."
   echo "2) Modify user limits."
   echo "3) Remove user limits."
   echo "4) List configured users."
   echo "5) Quit."
   echo
   }
   
   
   go_list_users () {
   echo
   echo "Users configured for kidtimer:"
   if [ -s $configdir/kid.list ]; then
       cat $configdir/kid.list
   else
       echo "No configured users."
   fi
   }
   
   go_setup_user () {
   echo
   echo -n "Username: "; read -e U
   /usr/bin/id $U > /dev/null 2>&1
   if [ $? -eq 0 ]; then
       /bin/cp $basedir/schedule/blank $basedir/schedule/$U
       echo "0" > $basedir/time/$U.ttl
       echo $U >> $configdir/kid.list
       echo "Done."
       echo
       echo -n "Modify limits now ?(y/n): "; read -e M
       if [ "$M" == "y" ]; then
           if [ -e /usr/bin/nano ]; then
                       /usr/bin/nano $basedir/schedule/$U
                       echo "Done."
               else
                       /usr/bin/vi $basedir/schedule/$U
                       echo "Done."
               fi
       fi
   else
       echo "Error. User does not exist. Please create user using the useradd command first."
   fi
   }
   
   
   go_modify_user () {
   echo
   echo -n "Username: "; read -e U
   grep -q ^$U $configdir/kid.list
   if [ $? -eq 0 ]; then
       if [ -e /usr/bin/nano ]; then
           /usr/bin/nano $basedir/schedule/$U
           echo "Done."
       else
           /usr/bin/vi $basedir/schedule/$U
           echo "Done."
       fi
   else
       echo "Error. User not setup. Please setup user first."
   fi
   }
   
   
   go_remove_user () {
   echo
   echo -n "Username: "; read -e U
   grep -q ^$U $configdir/kid.list
   if [ $? -eq 0 ]; then
       grep -v ^$U $configdir/kid.list > /tmp/kidtimer.tmp
       cat /tmp/kidtimer.tmp > $configdir/kid.list
       echo "Done."
   else
       echo "Error. User is not setup."
   fi
   }
   
   
   go_help () {
   echo
   echo "Commands:"
   echo "--------------------------------------------------------------------------------"
   echo "addtime <user> <minutes> ... Increases allowed time for the day."
   echo "logout <user>            ... Starts logout sequence for user."
   echo "hourly                   ... Enables/disables user access based on the schedule."
   echo "daily                    ... Resets time for the new day."
   echo "help                     ... This list."
   echo "--------------------------------------------------------------------------------"
   }
   
   ###################### Code ####################
   ################################################
   
   go_check_install
   [ $TUI -eq 1 ] && go_tui
   
   case "$COMMAND" in
   addtime) go_addtime
       ;;
   logout) go_logout $KID
       ;;
   initialize) go_initialize
       ;;
   hourly) go_hourly
       ;;
   daily) go_daily
       ;;
   check)  go_check
       ;;
   -h) go_help
       ;;
   help) go_help
       ;;
   esac
   exit 0
   

2. Exécutez-le:

   sudo kidtimer
   

3. Exécutez-le:

   sudo kidtimer help
   

4. Configurez un compte d'utilisateur existant.

5. Fait.

Pour l’aide:

sudo kidtimer addtime user minutes

Ajouter du temps au compte d’un utilisateur (pour ce jour-là uniquement):

/etc/kidtimer/kid.list
/etc/cron.d/kidtimer
/usr/local/kidtimer/schedule/<user>
/usr/local/kidtimer/time/<user>.ttl
/usr/local/bin/kidtimer

Caractéristiques:

• Accordez à votre enfant des heures spécifiques de la journée pour accéder à l’ordinateur, en semaine et en week-end.
• Définissez la durée maximale, en semaine et en week-end.

Fichiers clés:

Cronjobs:

• Vérifiez chaque minute pour voir si l'utilisateur est connecté. Si c'est le cas, augmentez le temps total. Si la durée est atteinte, désactivez le compte et démarrez la séquence de déconnexion (5 minutes au total).
• Vérifiez chaque heure pour voir si l'utilisateur est autorisé à se connecter. Si oui, activez le compte.
• À minuit, réinitialiser l'heure.

Note:

L’application utilise notify-send pour alerter le temps utilisateur. Lorsque le temps imparti est écoulé, tous les processus utilisateur sont terminés. Veuillez donc préparer l'utilisateur.

timekpr - Ce programme va suivre et contrôler l'utilisation de l'ordinateur de vos comptes d'utilisateur. Vous pouvez limiter leur utilisation quotidienne en fonction d'une durée d'accès programmée et configurer des périodes de la journée pendant lesquelles ils peuvent ou non se connecter. Avec cette application, les administrateurs peuvent limiter la durée de connexion ou les heures d'accès au compte. L'application fonctionne comme un contrôle temporel parental et sera utile aux parents qui souhaitent limiter le temps d'accès des enfants.

Even Nedberg proposed the following answer:
Just started copying into the 11.10 version for the PPA. Should finish
in a few minutes.

Vous pouvez mettre à jour votre système avec des packages non pris en charge à partir de ce PPA non approuvé en ajoutant ppa:timekpr-maintainers/ppa aux sources de logiciels de votre système.

deb http://ppa.launchpad.net/timekpr-maintainers/ppa/ubuntu oneiric main 
deb-src http://ppa.launchpad.net/timekpr-maintainers/ppa/ubuntu oneiric main 

Ce paquet est disponible dans:

• Problème Oneiric voir le rapport de bogue ....
• natty
• Maverick
• lucid
• Karmic
• Jaunty
• Intrepid

• Hardy

• Que sont les PPA et comment les utiliser eux?

PROBLÈME:

Je signale que le bogue ici traverse le doigt et attend ....

Introduction

Nous pouvons vérifier si un utilisateur est connecté par la commande:

who -u

qui nous donne une sortie comme:

$ who -u
jacob    :0           2016-03-17 20:48   ?          2557 (:0)
newuser  :1           2016-03-17 20:50   ?          4466 (:1)

Dans la sortie, nous obtenons le pid de l’utilisateur ciblé, qui doit être arrêté si le temps dépasse la limite.

La solution

En supposant que votre utilisateur n’a pas les privilèges sudo :

Cette solution est un petit script d'arrière-plan. Il limite l'utilisation par jour à un nombre défini de minutes, à définir en tête du script. Une fois installé (ce qui n'est pas trop difficile), il fonctionne très facilement et aucune action supplémentaire n'est nécessaire par la suite.

Pour éviter toute perte de données indésirable de fichiers éventuellement ouverts, un délai de 60 secondes avant expire la limite de l’utilisateur ciblé, un message apparaîtra sur son DISPLAY :

Le script

#!/usr/bin/python3
import subprocess
import os
import sys
import time


#--- set the time limit below (minutes)
minutes = 120
#--- set the user name to limit below
user = "newuser"

uselog = "/opt/limit/uselog"
datefile = "/opt/limit/currdate"

def read(f):
    try:
        return int(open(f).read().strip())
    except FileNotFoundError:
        pass

def message(disp, user):
    return "DISPLAY="+disp+" su - "+user+" -c "+'"'+\
      "notify-send 'User "+user+\
      " will be logged off in 60 seconds'"+'"'


currday1 = read(datefile)

while True:
    time.sleep(10)
    currday2 = int(time.strftime("%d"))
    # check if the day has changed, to reset the used quantum
    if currday1 != currday2:
        open(datefile, "wt").write(str(currday2))
        try:
            os.remove(uselog)  
        except FileNotFoundError:
            pass
    # if the pid of the targeted process exists, add a "tick" to the used quantum
    check = subprocess.check_output(["who", "-u"]).decode("utf-8")
    pid = [l.split() for l in check.splitlines() if user in l]
    if pid:
        n = read(uselog)
        n = n + 1 if n != None else 0
        open(uselog, "wt").write(str(n))
        # when time exceeds the permitted amount, kill the process
        if n > minutes*6:
            disp = [d for d in [d[1] for d in pid] if all([":" in d, not "." in d])][0]
            subprocess.Popen(["/bin/bash", "-c", message(disp, user)])
            time.sleep(60)
            pids = [p[-2] for p in pid]
            for p in pids:
                subprocess.Popen(["kill", p])  

    currday1 = currday2

Comment utiliser

1. Sur votre bureau (ou ailleurs), créez un dossier nommé: limit
2. Copiez le script dans un fichier vide, enregistrez-le sous limit_use (sans extension) dans le dossier et rendez-le exécutable

3. Modifiez en tête du script le nom d'utilisateur à limiter et le nombre maximal de minutes autorisées. Dans l'exemple:

   #--- set the time limit below (minutes)
   minutes = 1
   #--- set the user name to limit below
   user = "jacob"
   

4. Copiez le dossier dans le répertoire /opt :

   cp -r /path/to/limit /opt
   

5. Maintenant, éditez /etc/rc.local pour que le script l'exécute sous la forme root au démarrage:

   sudo -i gedit /etc/rc.local
   

   Juste avant la ligne

   exit 0
   

   une autre ligne:

   /opt/limit/limit_use &
   

Explication comment ça marche

• Une fois toutes les 10 secondes, le script recherche si l'utilisateur ciblé est connecté. Si c'est le cas, il "ajoute" un "point" à une utilisation totale, à enregistrer dans un fichier ( /opt/limit/uselog ). Si la limite quotidienne est atteinte, le script n'autorise plus l'utilisateur à se connecter, détruit son processus s'il existe.
• Lors du changement du jour (la date est enregistrée dans un fichier, le redémarrage ne sera pas utile), le fichier journal est supprimé, ce qui permet de disposer d’une nouvelle durée d’utilisation.
• Comme le script s'exécute sur boot , à partir de rc.local , seuls les utilisateurs disposant des privilèges sudo peuvent arrêter le script, même si l'utilisateur connaît le nom du processus.

Arrêtez le script

Si vous souhaitez arrêter le script, utilisez la commande:

sudo kill "$(pgrep limit_use)"

Mais vous auriez besoin du mot de passe sudo pour le faire.

J'ai essayé timekpr mais je n'ai pas réussi à le faire fonctionner. Ensuite, en a fait une variante qui fonctionne sur mon Ubuntu. Voici ce que vous devez faire pour cette variante:

1. Ajouter une limite de temps dans le fichier /var/lib/timelimit/user_to_be_limited.limit avec les droits root uniquement. par exemple. 1800 pour 1800 secondes (30 minutes) limite quotidienne.

2. Créez /usr/local/bin/timelimit.sh avec les droits root avec les éléments suivants:

   #!/bin/bash
   
   pollTime=30
   export DISPLAY=:0
   
   while(true); do
       sleep $pollTime
       usersLogedIn=$( users|sed -e 's/\s\+/\n/g'|sort|uniq )
       for userName in $usersLogedIn; do
           if [[ -e "/var/lib/timelimit/$userName.limit" ]]
           then
               if [[ ! -e "/var/lib/timelimit/$userName.time" || '( stat -c '%z'  /var/lib/timelimit/$userName.time|cut -c9,10 )' != 'date +%d' ]]
               then 
                   echo $pollTime > /var/lib/timelimit/$userName.time
               else
                   timeUsed=$(( 'cat /var/lib/timelimit/$userName.time' + $pollTime ))
                   echo $timeUsed > /var/lib/timelimit/$userName.time
               fi
               if [[ 'cat /var/lib/timelimit/$userName.time' -gt 'cat /var/lib/timelimit/$userName.limit' ]]
               then
                   export XAUTHORITY=/home/$userName/.Xauthority
                   notify-send --icon=gtk-dialog-warning --urgency=critical -t 30000 "$userName" "You have 60 seconds left!"
                   sleep 60
                   pkill -u $userName
               fi
           fi
       done
   done
   

3. Ajouter à /etc/rc.local :

   sudo /usr/local/bin/timelimit.sh &
   

4. Redémarrer Ubuntu

Je viens de rendre une réponse facilement disponible. Le code est expliqué sur le lien . En bref: une limite configurée en minutes par jour, une tâche cron toutes les minutes, un message à l'utilisateur pour le tenir informé et une déconnexion forcée.

Pour télécharger et installer ceci, ouvrez un terminal et exécutez les commandes ci-dessous:

cd /tmp/
git clone https://github.com/Thomas-Baeckeroot/ParentalControl.git
cd ParentalControl/
./install.sh

Le mot de passe administrateur sera demandé lors de l'installation (pour installer le job cron, copier le script, ...). De là, vous serez guidé pour tous. Il y a aussi un fichier ./uninstall.sh au même endroit au cas où. Il est construit pour fonctionner avec toutes les distributions basées sur Ubuntu (Mint, etc ... probablement toutes les Debian également). Si un problème survient, faites-le moi savoir, y compris la version du système et l'environnement graphique dans les commentaires:

uname -a
echo $XDG_CURRENT_DESKTOP

Thomas Baeckeroot