L'accesso al nostro computer (non solo a Internet) deve essere limitato per gli account dei miei figli (7, 8) fino a quando non saranno abbastanza grandi per gestirlo da soli. Fino ad allora dobbiamo essere in grado di definire quanto segue:

• le ore del giorno in cui il calcolo è ok (ad esempio, dalle 17 alle 21)
• i giorni della settimana in cui il calcolo non è corretto (ad es. dal lunedì al venerdì)
• la quantità di tempo consentita al giorno (ad es. 2 ore)

In 11.10 tutto quanto segue che faceva il lavoro non funziona più:

• Timekpr : per> 11.10 non più disponibile tramite il ppa.
• Timeout : alternativa alla riga di comando, ma dall'11.10 rimosso dai repository .
• Gnome Nanny : Sembra eccezionale ma si blocca ripetutamente per forzare il riavvio di X-server. Quindi al momento non possiamo usare o raccomandare questo programma.

Ci sono altre alternative?

Blocco schermo timer

Crea il tuo timer di blocco schermo anziché applicazioni di terze parti

Sebbene ci siano applicazioni di terze parti per farlo, puoi crearne una tua. Riepilogo dei passaggi:

• Utilizzare geditper creare scriptlock-screen-timer
• Copia e incolla il codice da questa finestra in lock-screen-timer
• Segna lock-screen-timercome eseguibile
• Provalo!
• Configurare Nautilus per eseguire script bash
• Crea collegamento sul desktop
• Monitorare il tempo rimanente

Utilizzare geditper creare scriptlock-screen-timer

Apri Terminalutilizzando Ctrl+ Alt+ Te digita:

gedit lock-screen-timer

Copia e incolla il codice dalla finestra in basso a lock-screen-timer

Torna a questa schermata e copia il seguente codice evidenziandolo e premendo 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="$1" # 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 Ubuntu 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.

Quindi tornare alla geditfinestra vuota e incollare il codice usando Ctrl+ V. Salvare il file e uscire dall'editor al prompt dei comandi.

Segna lock-screen-timercome eseguibile

Ora dobbiamo rendere eseguibile lo script digitando:

chmod +x lock-screen-timer

Provalo!

Prima di chiamare lo script dalla GUI, lo chiameremo dal terminale in modo da poter vedere se vengono visualizzati messaggi di errore:

~/lock-screen-timer

Viene richiesto il numero di minuti:

Impostare il numero desiderato di minuti e fare clic su OK per avviare il timer. Quando mancano 15, 10, 5, 3, 2 e 1 minuto, viene emesso un suono di sistema e viene visualizzato un fumetto che avvisa quando lo schermo verrà bloccato. Dopo aver bloccato lo schermo, è necessario inserire la password per sbloccare lo schermo.

Configurare Nautilus per eseguire script bash

Nautilus definisce cosa succede quando facciamo doppio clic su uno script eseguibile quando si tratta della finestra di visualizzazione dei file o di un collegamento sul desktop. Il comportamento normale è modificare lo script usando gedit. Vogliamo cambiare questo comportamento in modo che venga eseguito.

Avviare Nautilus e navigare nella directory contenente lock-screen-timer. Fai clic sinistro su di esso una volta per dargli fuoco. Passa il mouse sulla barra dei menu in alto fino a quando appare il menu "Modifica file ...", usa:

1. Fai clic Editsul menu a discesa
2. Fare clic Propertiessull'opzione
3. Fare clic sulla Behaviorscheda
4. Osservare i pulsanti di opzione radio sotto Executable Text Files
5. Controlla il pulsante di opzione Run executable text files when they are opened

Crea collegamento sul desktop

Dalla sezione precedente è lock-screen-timerancora attivo. In caso contrario, vai allo script e fai clic con il pulsante sinistro del mouse una volta per attivarlo. Quindi utilizzare:

• Fare clic con il tasto destro sul file e vengono visualizzate le opzioni del menu contestuale.
• Dal menu selezionare Make Link.
• Viene visualizzata una nuova icona chiamata Link to lock-screen-timer.
• Fai clic con il pulsante sinistro del mouse sulla nuova icona e trascinala da Nautilus sul desktop.

Ora puoi fare doppio clic sul collegamento sul desktop e lo script viene eseguito. Viene visualizzata una finestra di dialogo per ottenere i minuti numerici. Sono presenti due pulsanti Cancele OK. Se si fa clic su Xper chiudere la finestra, equivale a selezionare Cancel.

Dopo che il timer è in esecuzione e fai di nuovo doppio clic su di esso, la prima copia in esecuzione viene "uccisa". Ora puoi avviare un nuovo conto alla rovescia per il blocco dello scren o fare clic Cancelper nessun conto alla rovescia.

Visualizza tempo rimanente nell'area systray / notifica

Mentre il timer della schermata di blocco è in esecuzione, registra quanti minuti rimangono nel file ~/.lock-screen-timer-remaining. Puoi guardare questo file con il watchcomando o visualizzarlo sulla barra delle applicazioni / barra degli indicatori dell'applicazione di Ubuntu come mostrato nella parte superiore di questa risposta. Per visualizzare il tempo rimanente nell'area di notifica, seguire le istruzioni in questo Q&A: ( BASH può essere visualizzato nel systray come indicatore dell'applicazione? ).

Ubuntu <= 11.10 L'utente segue questa guida per Ubuntu Utente> = 11.10 leggi l'avviso di fondo:

Sì, tutti questi programmi non sono aggiornati e tutte le tue domande hanno una risposta qui e un bell'aspetto con il controllo dei tuoi genitori .....

Quando parliamo di costringere un utente a disconnettersi, quello di cui stiamo veramente parlando è l'implementazione di limiti di tempo sull'account per l'accesso al sistema o ai servizi. Il modo più semplice che ho trovato per implementare i limiti di tempo è usare un modulo plug-in chiamato Linux-PAM .

Pluggable Authentication Module (PAM) è un meccanismo per l'autenticazione degli utenti. In particolare, utilizzeremo il pam_timemodulo per controllare l'accesso a tempo per gli utenti ai servizi.

Utilizzando il pam_timemodulo, possiamo impostare restrizioni di accesso a un sistema e / o applicazioni specifiche in vari momenti della giornata, nonché in giorni specifici o su varie linee terminali. A seconda della configurazione, è possibile utilizzare questo modulo per negare l'accesso ai singoli utenti in base al loro nome, all'ora del giorno, al giorno della settimana, al servizio a cui si applicano e al loro terminale dal quale stanno effettuando la richiesta .

Durante l'utilizzo pam_time, è necessario terminare la sintassi di ogni riga (o regola) nel /etc/security/time.conffile con una nuova riga. Puoi commentare ogni riga con il cancelletto [#] e il sistema ignorerà quel testo fino alla nuova riga.

Ecco la sintassi per una regola:

servizi; ttys, gli utenti, i tempi

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.

Ecco un esempio di un insieme tipico di regole:

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

Queste regole impediscono all'utente bobby di accedere tra le ore 0800 e 2000 e limitano anche l'accesso a Internet durante queste ore. Root sarebbe in grado di accedere in qualsiasi momento e navigare in Internet anche in ogni momento.

Nota: il sistema registra gli errori con queste regole come syslog (3).

Con Ubuntu Linux, è possibile assegnare al proprio computer limiti di tempo, per impedire la connessione di uno o più utenti al proprio sistema. Con le restrizioni temporali, ad esempio, puoi limitare l'accesso al computer per i tuoi figli (una specie di controllo parentale, in breve) , o persino proteggere la connessione al tuo server in determinate ore.

Configurazione manuale

Comprendi cosa farai

Durante questo tutorial, utilizzeremo PAM (moduli di autenticazione collegabili, moduli di autenticazione collegabili in inglese). Ti consente di controllare l'autenticazione dell'utente quando si connettono. Quindi, utilizzeremo i file di configurazione della sicurezza per definire le ore di accesso consentite. Queste manipolazioni possono essere eseguite su qualsiasi versione di Ubuntu e richiedono solo un semplice editor di testo (vim, emacs, nano, gedit, kate, solo per citarne alcuni). Abilita le ore di restrizione tramite il modulo PAM

Prima di tutto, prima vai su /etc/pam.d/, dove sono tutti i servizi configurabili:

$ 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

Se vogliamo bloccare la connessione al computer, dovremo cambiare il servizio gdm. Modifica il file in modo da gdm e aggiungi questa riga di codice (alla fine del file):

account required pam_time.so

GDM è la distribuzione delle schermate di accesso Ubuntu, Edubuntu e Xubuntu. Per Kubuntu, che usa KDE, viene chiamato il servizio kdm, sarà il file che si aprirà. E il gioco è fatto per la configurazione di PAM! Ciò consentirà il controllo delle ore su questo servizio.

Se hai un server, probabilmente non hai la GUI. In questo caso, GDM / KDM non è installato e la connessione non verrà bloccata. Per impedire la connessione a TTY, è necessario modificare il login dello stesso file e aggiungere la stessa riga di codice di quella precedentemente riconosciuta. Questa azione si applica anche alle persone che hanno installato una GUI e vogliono bloccare l'accesso alla schermata di accesso e ai terminali.

Configurare gli orari di accesso

Ora che il servizio PAM è stato attivato, dobbiamo solo configurare i tempi di accesso. Apri il /etc/security. Sono disponibili diversi file di configurazione:

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

Modifica il file time.conf. Alcune spiegazioni ed esempi (in inglese) che introducono il. Per impostare le pianificazioni di accesso, copia e incolla la seguente riga di codice (alla fine del file, come sempre):

*;*;user;scheduler

Invece del campo utente, inserisci l'account di accesso che desideri bloccare.

Se vuoi bloccare più utenti, inserisci il loro login in una riga, separato dal | operatore. Ad esempio, se voglio congelare i conti di Patrick, John ed Emily:

*;*;Patrick|jean|emilie;scheduler

Con contro, se si desidera bloccare l'accesso al sistema per tutti gli utenti, tranne uno in particolare, utilizzare! davanti all'interessato. Ad esempio, se voglio che l'accesso al computer sia negato a tutti gli utenti, tranne Nicolas e Xavier:

Nicolas *;*;!|xavier;scheduler

Passando ora alle zone di campo. In questo campo sarà consentita la selezione di giorni e ore di connessione. Devi prima specificare il giorno della settimana, usando le seguenti abbreviazioni:

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

Fare attenzione a non confondere le abbreviazioni Wk e Wd sono fuorvianti! particolarmente scarsamente identificato su Internet: puoi facilmente trovare informazioni contrastanti!

Quindi, specifichiamo le scadenze. Questi dovrebbero essere formattati 24H, composto da 4 cifre. Ad esempio, per limitare le 15:17 alle 18:34, scriviamo: 1517-1834. Per consentire a Marie di connettersi solo martedì, dalle 15:17 alle 18:34, otteniamo il risultato:

*;*;marie;Tu1517-1834

Le connessioni al di fuori di questi orari saranno vietate. Per quanto riguarda gli utenti, è possibile utilizzare gli operatori | e! per indicare più volte (il! indica quindi che sono consentite tutte le ore di accesso, tranne quelle da mostrare).

Le due stelle (caratteri jolly) all'inizio della riga di codice sono rispettivamente campi tty e servizi. Dal momento che si desidera bloccare tutti gli accessi al sistema, non è necessario specificare quale servizio o quale tty si desidera bloccare. Tuttavia, se si desidera impedire l'uso di un determinato servizio, è sufficiente specificarlo come nell'esempio seguente:

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

Pertanto, l'utente sposato non può connettersi a un TTY, 4 e 5 durante il fine settimana.

Alcuni esempi di pianificazione delle restrizioni

mathilde è autorizzata a connettersi ogni giorno dalle 13:20 alle 15:20 e dalle 16:00 alle 20:30:

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

Stone, Frank e Florian possono collegarsi alle 14:00 alle 18:45 durante i giorni feriali e dalle 14:00 alle 22:15 per il fine settimana:

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

Olive non può mai connettersi. jessica può accedere mercoledì dalle 13:00 alle 16:00:

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

2 righe diverse, per due tempi diversi per ogni utente Scadenza di una sessione

Quando una sessione scade (supera il tempo mentre l'utente è già connesso), la PAM può raggiungere l'utente. Mentre mathilde si collega durante le ore di tempo consentite, è perfettamente libero di superare queste ore! Per questo, useremo un nuovo programma: "cron". Questa applicazione esegue i comandi a intervalli di tempo. Nel nostro caso, utilizzeremo il comando "kill-KILL-u" per disconnettere l'utente alla scadenza della sessione. La gestione è molto semplice. Basta modificare il file ´ / etc / crontab´. Quindi aggiungere la seguente riga di codice:

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

Come prima, sostituendo le pianificazioni dei campi Minuti e il tempo desiderato. Quindi compilare il giorno (i) per (i) giorno (i) vietato (i) o semplicemente digitare un asterisco (*) per indicare tutti i giorni della settimana. Infine, modifica il campo utilizzato dall'account di accesso da bloccare e voilà!

I giorni non si notano allo stesso modo con i cronlavori! Ecco l'elenco delle abbreviazioni da utilizzare con questo programma:

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

Alcuni esempi di cronlavori (con esempi di volte nella sezione precedente)

jessica può accedere mercoledì dalle 13:00 alle 16:00

-> Disconnetti: martedì alle 16:00.

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

mathilde è autorizzata a connettersi ogni giorno dalle 13:20 alle 15:20 e dalle 16:00 alle 20:30.

-> Disconnessione: tutti i giorni, dalle 20:30 alle 15:20 ET.

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

Stone, Frank e Florian sono autorizzati a collegarsi alle 14:00 alle 18:45 durante i giorni feriali e dalle 14:00 alle 22:15 per il fine settimana

-> Disconnect (1): lunedì, martedì, mercoledì, giovedì e venerdì, alle 18:45. -> Disconnect (2): sabato e domenica alle 22:15.

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

Il comando skill-KILL-u disconnette l'utente dalla GUI, così come TTY. È perfettamente utilizzabile per gli amministratori di server. Tuttavia, questo comando è immediato e la disconnessione verrà effettuata senza preavviso. Sarebbe quindi preferibile impedire l'installazione di questo dispositivo agli utenti del computer o della rete in questione!

È possibile impedire agli utenti un wallcomando avviato cronpochi minuti prima della fine del periodo di tempo , che verrà visualizzato nei terminali di tutti gli utenti.

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

Per impedire che gli utenti della GUI possano essere usati al posto del comando wall notify-sendè nel pacchetto libnotify-bin

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

Utente Ubuntu 11.10

Ho visto un utente che ha avuto problemi con Pam e ho visto un sacco di bug a riguardo, quindi perché la ragione ??? Ubuntu 11.10 non supporta più GDM, il nuovo display manager è lightGDM il problema è il seguente in cui memorizzare questa direttiva account required pam_time.sopenso che sia /etc/pam.d/lightdmo /etc/pam.d/lightdm-autologinma bug come ???

quindi per i prossimi è possibile controllare questi 2 file di registro LightGdm:

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

o esegui LightGdm in modalità debug:

LightDM --debug

o segnala un bug:

ubuntu-bug lightdm

Riporto il bug qui, quindi incrocia il dito e aspetta ...

TimeKpr

Immagino che abbia tutto il necessario. Limitare il tempo di accesso al giorno per utente, interfaccia grafica semplice per la configurazione, abitlity da bypassare per un giorno, aggiungere un po 'di "tempo di ricompensa", notifica del tempo rimanente per gli utenti, ecc.

La pagina del progetto è qui . Essi hanno anche un PPA per Ubuntu che è possibile aggiungere ai vostri Sorgenti Software: deb http://ppa.launchpad.net/timekpr-maintainers/ppa/ubuntu lucid main. E installare tramite Software Center o tramite CLI: sudo apt-get install timekpr.

Timekpr

può essere utilizzato in 11.10 con LightDM per configurare le restrizioni per gli utenti aggiungendo la seguente riga a /etc/pam.d/lightdm

account required pam_time.so

^{Potrebbe essere necessario rimuovere libpam-smbpass per abilitare il cambio utente fino a quando il bug # 835310 non è stato corretto.}

Tutti i limiti definiti nella finestra dell'applicazione funzionano come definito nella GUI di timekpr.

Per visualizzare l'icona timekpr-client in Unity dobbiamo inserire nella whitelist le 'timekpr' impostazioni del pannello Unity, e inoltre dobbiamo aggiungere Unityalla seguente riga in /etc/xdg/autostart/timekpr-client.desktop:

OnlyShowIn=GNOME;XFCE;KDE;Unity;

Per iniziare il conto alla rovescia del tempo concesso, potremmo dover avviare il demone timekpr con

/etc/init.d/timekpr start

per 14.04:

Una nuova versione / fork di timekpr è stata pubblicata per Ubuntu 14.04 da Eduards Bezverhijs nel suo ppa:mjasnik/ppa.

La disconnessione automatica è estremamente frustrante se sei nel mezzo di qualcosa. È violento, è brutale, è chiaramente maleducato. E non importa quanti anni hai. È una cosa quando sei solo dipendente dal computer ed è molto diverso quando stai monitorando il tempo e sei espulso 5 secondi prima di riuscire a fare clic sul pulsante di invio o salvare il documento. Ti suggerisco di prendere in considerazione l'utilizzo di un promemoria automatico invece di un kicker automatico. Ciò insegnerà ai tuoi figli a rispettarsi l'un l'altro e a permettersi l'un l'altro di usare il computer volontariamente.

C'è anche un'alternativa più leggera. Inizia monitorando la quantità di tempo che ogni bambino trascorre utilizzando il computer e rendi i dati raccolti disponibili per tutti loro in modo che possano vederli. Questa cosa incredibilmente semplice da sola (applicata alla larghezza di banda di Internet spesa) mi ha salvato la vita quando ero l'amministratore di rete in un ufficio pieno di adulti. Le statistiche pubbliche sull'uso della larghezza di banda per ogni computer (solo la quantità di byte, non le informazioni di deanonimizzazione come elenchi di siti visitati ecc.) Hanno trasformato la situazione da "me - il malvagio avido amministratore contro di loro - i poveri utenti abusati dell'ufficio" a " hai scaricato 5 volte più di me, non va bene! " "scusa, ho scaricato davvero, ho guardato un sacco di youtube durante le pause pranzo, non lo farò più a questo ritmo" - Sono stato semplicemente escluso dallo scenario di confronto.

Ho avuto anche questo problema. Quindi ho scritto lo script kidtimer, che consente di definire tempi e totali di utilizzo. Il progetto può essere trovato su Github nella seguente posizione:

• https://github.com/grover66/kidtimer

Ecco come installarlo e usarlo:

1. Copia e incolla il codice in un file chiamato 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 $2" "$3 }'`
   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=$1
   [ $# -eq 2 ] && COMMAND=$1 && KID=$2
   [ $# -eq 3 ] && COMMAND=$1 && KID=$2 && Time=$3
   
   ################# 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 $0 /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=$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 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 $2 }'`
           [ "$W" == "yes" ] && TIME_LIMIT=`cat $basedir/schedule/$I | grep ^MAX | awk '{ print $3 }'`
           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=$1
   for I in `/usr/bin/atq | awk '{ print $1 }' | 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 $2 }'`
               [ "$WEEKEND" == "yes" ] && TL=`cat $basedir/schedule/$I | grep ^MAX | awk '{ print $3 }'`
               [ -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 $2 }'`
               [ "$WEEKEND" == "yes" ] && R=`grep ^$HOUR $basedir/schedule/$I | awk '{ print $3 }'`
               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=$1
   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. Eseguilo:

   sudo ./kidtimer.install

3. Eseguirlo:

   sudo kidtimer

4. Imposta un account utente esistente.

5. Fatto.

Per un aiuto:

sudo kidtimer help

Aggiungi tempo all'account di un utente (solo per quel giorno):

sudo kidtimer addtime user minutes

Caratteristiche:

• Consenti a tuo figlio ore specifiche della giornata di accedere al computer, sia nei giorni feriali che nei fine settimana.
• Imposta la quantità massima di tempo, sia nei giorni feriali che nei fine settimana.

File chiave:

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

cronjobs:

• Controlla ogni minuto per vedere se l'utente ha effettuato l'accesso. In tal caso, incrementa il tempo totale. Se viene raggiunto il tempo massimo, disabilitare l'account e avviare la sequenza di disconnessione (5 minuti in totale).
• Controlla ogni ora se l'utente è autorizzato ad accedere. In tal caso, abilita l'account.
• A mezzanotte, resettare l'ora.

Nota:

L'applicazione utilizza notify-sendper avvisare che il tempo dell'utente sta per scadere. Allo scadere del tempo, tutti i processi dell'utente vengono chiusi, quindi preparare l'utente.

timekpr : questo programma traccia e controlla l'utilizzo del computer degli account utente. È possibile limitare il loro uso quotidiano in base a una durata di accesso a tempo e configurare periodi del giorno in cui possono o non possono accedere. Con questa applicazione, gli amministratori possono limitare la durata del tempo di accesso all'account o le ore di accesso all'account. L'applicazione funziona come controllo del tempo dei genitori e sarà utile per i genitori che vogliono limitare il tempo di accesso dei bambini.

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

È possibile aggiornare il sistema con pacchetti non supportati da questo PPA non attendibile aggiungendo ppa:timekpr-maintainers/ppaalle fonti software del sistema.

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

Questo pacchetto è disponibile in:

• Problema onirico vedi segnalazione bug ....
• elegante
• Dissidente, anticonformista
• lucido
• Karmic
• disinvolto
• Intrepido

• ardito

• Cosa sono i PPA e come li uso?

PROBLEMA:

Riporto il bug qui, quindi incrocia il dito e aspetta ...

introduzione

Possiamo verificare se un utente ha effettuato l'accesso con il comando:

who -u

che ci dà un risultato come:

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

Nell'output otteniamo il pid dell'utente target, che deve essere interrotto se il tempo supera il limite.

La soluzione

Supponendo che il tuo utente non abbia sudoprivilegi:

Questa soluzione è un piccolo script in background. Limita l'utilizzo al giorno a un numero definito di minuti, da impostare nell'intestazione dello script. Una volta installato (il che non è troppo difficile) si esegue molto facilmente e non sono necessarie ulteriori azioni in seguito.

Per prevenire la perdita indesiderata di dati di file eventualmente aperti, 60 secondi prima della scadenza del limite di tempo dell'utente target, verrà visualizzato un messaggio sul suo DISPLAY:

Il copione

#!/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

Come usare

1. Sul desktop (o in qualsiasi altro luogo), crea una cartella denominata: limit
2. Copia lo script in un file vuoto, salvalo come limit_use(nessuna estensione) all'interno della cartella e rendilo eseguibile

3. Modifica nell'intestazione dello script il nome utente da limitare e il numero massimo di minuti consentiti. Nell'esempio:

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

4. Copia la cartella nella directory /opt:

   cp -r /path/to/limit /opt

5. Ora modifica /etc/rc.localper far funzionare lo script come rootall'avvio:

   sudo -i gedit /etc/rc.local

   Poco prima della linea

   exit 0

   un'altra linea:

   /opt/limit/limit_use &

Spiegazione; come funziona

• Una volta ogni 10 secondi, lo script verifica se l'utente target è connesso. In tal caso, "aggiunge" un "punto" a un utilizzo totale, da registrare in un file ( /opt/limit/uselog). Se viene raggiunto il limite giornaliero, lo script non consente più all'utente di accedere, interrompe il processo se esiste.
• Alla modifica del giorno (la data viene registrata in un file, quindi il riavvio non aiuta), il file di registro viene eliminato, consentendo l'accumulo di una nuova quantità di tempo di utilizzo.
• Poiché lo script viene eseguito all'avvio , rc.localsolo gli utenti con privilegi sudo possono interrompere lo script, anche solo se l'utente conosce il nome del processo.

Ferma la sceneggiatura

Nel caso in cui desideri interrompere lo script, utilizzare il comando:

sudo kill "$(pgrep limit_use)"

Ma avresti bisogno della password sudo per farlo.

Ci ho provato timekprma non ho funzionato. Poi ne ho fatto una variante che funziona sul mio Ubuntu. Questo è ciò che bisogna fare per questa variante:

1. Aggiungi il limite di tempo nel /var/lib/timelimit/user_to_be_limited.limitfile con solo i diritti di root. ad es. 1800 per 1800 secondi (30 minuti) limite giornaliero.

2. Crea /usr/local/bin/timelimit.shcon i diritti di root con il seguente:

   #!/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. Aggiungi a /etc/rc.local:

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

4. Riavvia Ubuntu

Ho appena reso disponibile una risposta facilmente. Il codice è spiegato nel thread http://forums.linuxmint.com/viewtopic.php?f=213&t=77687 . In breve: un limite configurato in minuti al giorno, un cron job ogni minuto, un messaggio all'utente per tenerlo informato e una disconnessione forzata.

Per scaricare e installare questo, aprire un Terminale ed eseguire i comandi seguenti:

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

La password dell'amministratore verrà richiesta durante il processo di installazione (per installare il processo cron, per copiare lo script, ...). Da lì sarai guidato per tutti. C'è anche un ./uninstall.sh nello stesso posto per ogni evenienza. È costruito per funzionare con tutte le distro basate su Ubuntu (Menta, ecc ... probabilmente anche tutte le debian). In caso di problemi, segnalacelo, inclusa la versione del sistema e l'ambiente grafico nei commenti:

uname -a
echo $XDG_CURRENT_DESKTOP

Thomas Baeckeroot

Ho appena rilasciato una versione beta della mia nuova applicazione in LittleBrothergrado di monitorare i tempi di riproduzione su macchine Linux. Gli utenti di prova sono invitati a provare il pacchetto Debian. Le istruzioni su come scaricarlo e utilizzarlo sono disponibili qui: https://github.com/marcus67/little_brother . L'installazione potrebbe essere comunque un po 'approssimativa. Queste sono le caratteristiche dell'applicazione:

• È possibile monitorare qualsiasi numero di utenti.
• Ogni utente può avere un insieme specifico di regole che definiscono il tempo di riproduzione consentito.
• Le regole possono essere adattate ai "contesti", come il giorno della settimana e / o un programma di ferie (attualmente sono supportati solo i programmi tedeschi).
• Il tempo di riproduzione può essere limitato a una finestra temporale (da, a).
• È possibile definire un tempo di riproduzione massimo giornaliero.
• Gli utenti possono essere costretti a fare una pausa dopo un certo tempo di sessione massimo.
• Gli utenti possono essere costretti ad attendere un minimo di pausa dopo la loro attività.
• È possibile monitorare qualsiasi numero di host client Linux (attualmente ciò richiede agli utenti di avere lo stesso accesso su tutte le macchine).
• Esiste un host principale con una cronologia delle attività di tutti gli utenti. Questo host principale controlla le serie di regole e richiede agli host client di terminare i processi, se necessario.
• L'host principale offre una semplice interfaccia Web per visualizzare l'attività dell'utente su una lunghezza della cronologia configurata (ad esempio 7 giorni) e una pagina di amministrazione per definire dinamicamente le eccezioni delle regole per un numero configurato di giorni nel futuro.
• L'applicazione Web può essere eseguita dietro un proxy in modo che sia accessibile da lontano consentendo l'amministrazione remota dopo aver ricevuto chiamate da giovani utenti che chiedono più tempo di gioco.
• L'applicazione ha il supporto linguistico internazionale. Attualmente vengono fornite traduzioni in inglese e tedesco. Gli utenti sono invitati a fornire traduzioni per altre lingue.
• L'applicazione utilizza la generazione vocale per informare l'utente in merito a disconnessioni forzate imminenti. Anche questi messaggi vocali sono internazionalizzati.
• Oltre al tempo dedicato agli host Linux, l'applicazione può anche monitorare il tempo di attività su altri dispositivi come smartphone o tabelle. Sfrutta il fatto che la maggior parte dei moderni sistemi operativi mettono i dispositivi in ​​una sorta di modalità di risparmio energetico mentre non vengono utilizzati. In questo modo, la risposta di rete (tramite ping) può essere utilizzata per determinare l'attività su tali dispositivi. A differenza degli host Linux, l'applicazione non sarà in grado di terminare l'attività. Il tempo di riproduzione, tuttavia, verrà aggiunto al tempo di riproduzione complessivo e quindi avrà un impatto sul tempo concesso e anche sulle regole del tempo di pausa sugli host Linux.

Alcuni screenshot: