El acceso a nuestra computadora (no solo a Internet) debe restringirse para las cuentas de mis hijos (7, 8) hasta que tengan la edad suficiente para manejar esto por sí mismos. Hasta entonces, debemos poder definir lo siguiente:

• las horas del día en que la informática está bien (por ejemplo, de 5 a 9 p. m.)
• los días de la semana cuando la informática no está bien (por ejemplo, de lunes a viernes)
• la cantidad de tiempo permitido por día (por ejemplo, 2 horas)

En 11.10, todo lo siguiente que solía hacer el trabajo ya no funciona:

• Timekpr : para> 11.10 no más disponible a través del ppa.
• Timeoutd : alternativa de línea de comando, pero a partir de 11.10 eliminado de los repositorios .
• Gnome Nanny : Se ve muy bien pero se bloquea repetidamente para forzar el reinicio del servidor X. Por lo tanto, no podemos usar o recomendar este programa en este momento.

¿Hay otras alternativas?

Temporizador de pantalla de bloqueo

Cree su propio temporizador de bloqueo de pantalla en lugar de aplicaciones de terceros

Aunque hay aplicaciones de terceros para hacer esto, puede crear las suyas propias. Resumen de pasos:

• Use geditpara crear scriptlock-screen-timer
• Copie y pegue el código de esta ventana a lock-screen-timer
• Marcar lock-screen-timercomo ejecutable
• ¡Pruébalo!
• Configure Nautilus para ejecutar scripts bash
• Crear enlace de acceso directo de escritorio
• Monitorear el tiempo restante

Use geditpara crear scriptlock-screen-timer

Abra el Terminaluso de Ctrl+ Alt+ Ty escriba:

gedit lock-screen-timer

Copie y pegue el código de la ventana de abajo para lock-screen-timer

Vuelva a esta pantalla y copie el siguiente código resaltándolo y presionando 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.

Luego vuelva a la geditventana vacía y pegue el código usando Ctrl+ V. Guarde el archivo y salga del editor nuevamente al símbolo del sistema.

Marcar lock-screen-timercomo ejecutable

Ahora necesitamos hacer que el script sea ejecutable escribiendo:

chmod +x lock-screen-timer

¡Pruébalo!

Antes de llamar al script desde la GUI, lo llamaremos desde la terminal para que podamos ver si se muestran mensajes de error:

~/lock-screen-timer

Se le solicita la cantidad de minutos:

Establezca el número deseado de minutos y haga clic en Aceptar para iniciar el temporizador. Cuando quedan 15, 10, 5, 3, 2 y 1 minuto (s), se escucha un sonido del sistema y aparece una burbuja de mensaje que le informa cuándo se bloqueará la pantalla. Después de bloquear la pantalla, debe ingresar su contraseña para desbloquearla.

Configure Nautilus para ejecutar scripts bash

Nautilus define lo que sucede cuando hacemos doble clic en un script ejecutable cuando se trata de la ventana de visualización de archivos o un enlace en el escritorio. El comportamiento normal es editar el script usando gedit. Queremos cambiar este comportamiento para que se ejecute.

Inicie Nautilus y navegue al directorio que contiene lock-screen-timer. Haga clic izquierdo sobre él una vez para enfocarlo. Pase el mouse sobre la barra de menú superior hasta que aparezca el menú "Editar archivo ...", use:

1. Haga clic en el Editmenú desplegable
2. Haga clic en la Propertiesopción
3. Haga clic en la Behaviorpestaña
4. Observe los botones de opción de radio debajo Executable Text Files
5. Comprobar botón de radio Run executable text files when they are opened

Crear enlace de acceso directo de escritorio

De la sección anterior lock-screen-timertodavía tiene foco. De lo contrario, navegue hasta el script y haga clic izquierdo sobre él una vez para enfocarlo. Luego use:

• Haga clic derecho en el archivo y aparecerán las opciones del menú contextual.
• Desde el menú seleccionar Make Link.
• Aparece un nuevo icono llamado Link to lock-screen-timer.
• Haga clic izquierdo en el nuevo icono y arrástrelo desde Nautilus a su escritorio.

Ahora puede hacer doble clic en el enlace de acceso directo del escritorio y se ejecuta el script. Aparece un cuadro de diálogo para obtener el número de minutos. Se presentan dos botones Cancely OK. Si hace clic en Xpara cerrar la ventana, es lo mismo que seleccionar Cancel.

Después de que el temporizador se esté ejecutando y haga doble clic en él nuevamente, la primera copia en ejecución se "eliminará". Ahora puede comenzar una nueva cuenta regresiva de bloqueo de scren o hacer clic Cancelpara que no haya una cuenta regresiva.

Mostrar tiempo restante en el área de bandeja del sistema / notificación

Mientras el temporizador de la pantalla de bloqueo se está ejecutando, registra cuántos minutos quedan en el archivo ~/.lock-screen-timer-remaining. Puede mirar este archivo con el watchcomando o mostrarlo en la barra indicadora de la aplicación / bandeja del sistema de Ubuntu como se muestra en la parte superior de esta respuesta. Para mostrar el tiempo restante en el área de notificación, siga las instrucciones de estas preguntas y respuestas: ( ¿Puede BASH mostrarse en la bandeja del sistema como indicador de la aplicación? ).

Ubuntu <= 11.10 Usuario sigue esta guía para el Usuario de Ubuntu> = 11.10 lee el aviso de la página inferior:

Sí, todos esos programas están desactualizados y todas sus preguntas se responden aquí y se ven bien con el control de sus padres .....

Cuando hablamos de obligar a un usuario a cerrar sesión, de lo que realmente estamos hablando es de implementar restricciones de tiempo en la cuenta para el acceso al sistema o los servicios. La forma más fácil que he encontrado para implementar restricciones de tiempo es usando un módulo de complemento llamado Linux-PAM .

El Módulo de autenticación conectable (PAM) es un mecanismo para autenticar a los usuarios. Específicamente, vamos a usar el pam_timemódulo para controlar el acceso temporizado de los usuarios a los servicios.

Usando el pam_timemódulo, podemos establecer restricciones de acceso a un sistema y / o aplicaciones específicas en varios momentos del día, así como en días específicos o en varias líneas de terminales. Dependiendo de la configuración, puede usar este módulo para denegar el acceso a usuarios individuales en función de su nombre, la hora del día, el día de la semana, el servicio que solicitan y su terminal desde el que realizan la solicitud. .

Al usar pam_time, debe terminar la sintaxis de cada línea (o regla) en el /etc/security/time.confarchivo con una nueva línea. Puede comentar cada línea con el signo de número [#], y el sistema ignorará ese texto hasta la nueva línea.

Aquí está la sintaxis de una regla:

servicios; ttys; usuarios; tiempos

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.

Aquí hay un ejemplo de un conjunto típico de reglas:

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

Estas reglas restringen el inicio de sesión del usuario entre las horas de 0800 y 2000, y también restringen el acceso a Internet durante estas horas. Root también podría iniciar sesión en cualquier momento y navegar por Internet en todo momento.

Nota: El sistema registra errores con estas reglas como syslog (3).

Con Ubuntu Linux, es posible asignar restricciones de tiempo a su computadora, para evitar la conexión de uno o más usuarios a su sistema. Con las restricciones de tiempo, puede, por ejemplo, limitar el acceso a la computadora de sus hijos (una especie de control parental, en resumen) , o incluso proteger la conexión a su servidor durante ciertas horas.

Configuración manual

Entiende lo que harás

A lo largo de este tutorial, utilizaremos PAM (módulos de autenticación conectables, módulos de autenticación conectables en inglés). Le permite controlar la autenticación del usuario cuando se conectan. Luego, utilizaremos los archivos de configuración de seguridad para definir las horas de inicio de sesión permitidas. Estas manipulaciones se pueden realizar en cualquier versión de Ubuntu y requieren solo un editor de texto simple (vim, emacs, nano, gedit, kate, por nombrar algunos). Habilite las horas de restricciones a través del módulo PAM

En primer lugar, primero vaya a /etc/pam.d/, donde se encuentran todos los servicios 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 queremos bloquear la conexión a la computadora, tendremos que cambiar el servicio gdm. Edite el archivo así que gdm y agregue esta línea de código (al final del archivo):

account required pam_time.so

GDM es la distribución de la pantalla de inicio de sesión Ubuntu, Edubuntu y Xubuntu. Para Kubuntu, que usa KDE, se llama al servicio kdm, será el archivo que abrirá. ¡Y ya está listo para configurar el PAM! Esto permitirá el control de horas en este servicio.

Si tiene un servidor, probablemente no tenga GUI. En este caso, GDM / KDM no está instalado y la conexión no se bloqueará. Para evitar la conexión a TTY, debe modificar el inicio de sesión del mismo archivo y agregar la misma línea de código que la reconocida anteriormente. Esta acción también se aplica a las personas que han instalado una GUI y desean bloquear el acceso a la pantalla de inicio de sesión y a los terminales.

Configurar horas de acceso

Ahora que el servicio PAM se ha activado, solo tenemos que configurar los tiempos de acceso. Abre el /etc/security. Varios archivos de configuración están disponibles:

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

Edita el archivo time.conf. Algunas explicaciones y ejemplos (inglés) que presentan el. Para establecer horarios de acceso, copie y pegue la siguiente línea de código (al final del archivo, como siempre):

*;*;user;scheduler

En lugar del campo de usuario, ingrese la cuenta de inicio de sesión que desea bloquear.

Si desea bloquear a múltiples usuarios, ingrese su inicio de sesión en una fila, separados por | operador. Por ejemplo, si quiero congelar las cuentas de Patrick, John y Emily:

*;*;Patrick|jean|emilie;scheduler

Por contra, si desea bloquear el acceso al sistema para todos los usuarios excepto uno en particular, use el! ante la persona interesada. Por ejemplo, si quiero que el acceso a la computadora sea denegado para todos los usuarios, excepto Nicolas y Xavier:

Nicolas *;*;!|xavier;scheduler

Pasando ahora a las zonas de campo. En este campo que la selección de días y horas se permitirá la conexión posible. Primero debe especificar el día de la semana, utilizando las siguientes abreviaturas:

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

¡Tenga cuidado de no confundir las abreviaturas Wk y Wd son engañosas! particularmente mal identificado en Internet: ¡puede encontrar fácilmente información contradictoria!

Luego, especificamos los plazos. Estos deben estar formateados 24H, que consisten en 4 dígitos. Por ejemplo, para restringir las 3:17 pm a las 6:34 pm, escribimos: 1517-1834. Para permitir que Marie se conecte solo el martes, de 3:17 pm a 6:34 pm, obtenemos el resultado:

*;*;marie;Tu1517-1834

Se prohibirán las conexiones fuera de este horario. En cuanto a los usuarios, es posible utilizar los operadores | ¡y! para indicar varias veces (el! luego indica que todas las horas de inicio de sesión están permitidas, excepto las que se muestran).

Las dos estrellas (comodines) al comienzo de la línea de código son, respectivamente, y campos de servicios tty. Como desea bloquear todo el acceso al sistema, no es necesario especificar qué servicio o qué tty desea bloquear. Sin embargo, si desea evitar el uso de un servicio en particular, simplemente especifíquelo como el siguiente ejemplo:

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

Por lo tanto, el usuario se casa no puede conectarse a un TTY, 4 y 5 durante el fin de semana.

Algunos ejemplos de horario de restricciones

Mathilde puede conectarse todos los días de 1:20 p.m. a 3:20 p.m. y de 4:00 p.m. a 8:30 p.m.:

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

Stone, Frank y Florian pueden conectarse de 2:00 p.m. a 6:45 p.m. entre semana y de 2:00 p.m. a 10:15 p.m. durante el fin de semana:

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

A Olive nunca se le permite conectarse. Jessica puede iniciar sesión el miércoles de 1:00 p.m. a 4:00 p.m.:

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

2 líneas diferentes, por dos tiempos diferentes para cada usuario Vencimiento de una sesión

Cuando una sesión expira (excede el tiempo mientras el usuario ya está conectado), el PAM puede llegar al usuario. Si bien Mathilde se conecta durante las horas permitidas, ¡es perfectamente gratuito exceder estas horas! Para esto, usaremos un nuevo programa: ´cron´. Esta aplicación ejecuta comandos a intervalos de tiempo. En nuestro caso, utilizaremos el comando ´skill-KILL-u´ para desconectar al usuario cuando finalice la sesión. El manejo es muy simple. Simplemente edite el archivo ´ / etc / crontab´. Luego agregue la siguiente línea de código:

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

Como antes, reemplazando los horarios de campo de minutos y el tiempo deseado. Luego complete el día (s) por (s) día (s) prohibido (s), o simplemente escriba un asterisco (*) para indicar todos los días de la semana. Finalmente, cambie el campo utilizado por la cuenta de inicio de sesión para bloquearlo, ¡y listo!

¡Los días no se notan de la misma manera con los crontrabajos! Aquí está la lista de abreviaturas que se utilizarán con este programa:

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

Algunos ejemplos de crontrabajos (con ejemplos de tiempos en la sección anterior)

Jessica puede iniciar sesión el miércoles de 1:00 p.m. a 4:00 p.m.

-> Desconectar: ​​martes a las 4:00 p.m.

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

Mathilde puede conectarse todos los días de 1:20 p.m. a 3:20 p.m. y de 4:00 p.m. a 8:30 p.m.

-> Desconexión: todos los días, de 8:30 p.m. a 3:20 p.m. ET.

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

Stone, Frank y Florian pueden conectarse de 2:00 p.m. a 6:45 p.m. entre semana y de 2:00 p.m. a 10:15 p.m. durante el fin de semana

-> Desconectar (1): lunes, martes, miércoles, jueves y viernes, a las 18:45. -> Desconectar (2): sábado y domingo a las 10:15 p.m.

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

El comando skill-KILL-u desconecta al usuario de la GUI, así como de TTY. Es perfectamente utilizable para los administradores del servidor. Sin embargo, este comando es inmediato y la desconexión se realizará sin previo aviso. Por lo tanto, sería preferible evitar la instalación de este dispositivo a los usuarios de la computadora o red en cuestión.

Es posible evitar que los usuarios ejecuten un wallcomando cronunos minutos antes del final del período de tiempo , que se mostrará en los terminales de todos los usuarios.

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

Para evitar que los usuarios de la GUI se puedan utilizar en lugar del comando de pared notify-sendestá en el paquete libnotify-bin

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

Usuario de Ubuntu 11.10

He visto que un usuario tiene problemas con Pam y vi muchos errores al respecto, ¿por qué la razón? es tan simple Ubuntu 11.10 ya no es compatible con GDM, el nuevo administrador de pantalla es lightGDM, el problema es el siguiente dónde almacenar esta directiva, account required pam_time.socreo que está /etc/pam.d/lightdmo /etc/pam.d/lightdm-autologinpero, ¿cómo?

así que por aquí puedes consultar estos 2 archivos de registro LightGdm:

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

o ejecuta LightGdm en modo de depuración:

LightDM --debug

o informar un error:

ubuntu-bug lightdm

Reporto que el insecto está aquí, así que cruza el dedo y espera ...

TimeKpr

Supongo que tiene todo lo que necesitas. Limite el tiempo de acceso por día por usuario, interfaz gráfica de usuario fácil para la configuración, capacidad de omitir durante un día, agregue algo de "tiempo de recompensa", notificación del tiempo restante para los usuarios, etc.

La página del proyecto está aquí . También tienen un PPA para Ubuntu, que se pueden agregar a sus Orígenes del software: deb http://ppa.launchpad.net/timekpr-maintainers/ppa/ubuntu lucid main. E instalar a través del Centro de Software o por medio de la CLI: sudo apt-get install timekpr.

Timekpr

se puede usar en 11.10 ejecutando LightDM para configurar restricciones para los usuarios agregando la siguiente línea a /etc/pam.d/lightdm

account required pam_time.so

^{Es posible que necesitemos eliminar libpam-smbpass para permitir el cambio de usuario hasta que se solucione el error # 835310 .}

Todas las restricciones definidas en la ventana de la aplicación funcionan como se define en la GUI de timekpr.

Para mostrar el icono de timekpr-client en Unity, necesitamos incluir 'timekpr' en la lista blanca la configuración del panel de Unity y, además, debemos agregar Unitya la siguiente línea /etc/xdg/autostart/timekpr-client.desktop:

OnlyShowIn=GNOME;XFCE;KDE;Unity;

Para comenzar la cuenta regresiva del tiempo otorgado, es posible que tengamos que iniciar el demonio timekpr con

/etc/init.d/timekpr start

para 14.04:

Eduards Bezverhijs publicó una nueva versión / fork de timekpr para Ubuntu 14.04 en su ppa:mjasnik/ppa.

El cierre de sesión automático es extremadamente frustrante si estás en medio de algo. Es violento, es brutal, es simplemente grosero. Y no importa la edad que tengas. Una cosa es que solo eres adicto a la computadora y es muy diferente cuando estás rastreando el tiempo y te expulsan 5 segundos antes de que puedas hacer clic en ese botón de envío o guardar tu documento. Le sugiero que considere usar un recordatorio automático en lugar de un pateador automático. Eso les enseñará a sus hijos a respetarse mutuamente y les permitirá usar la computadora voluntariamente.

Incluso hay una alternativa más ligera. Comience por rastrear la cantidad de tiempo que cada niño pasa usando la computadora y haga que los datos recopilados estén disponibles para que todos puedan verlos. Esta cosa increíblemente simple sola (aplicada al ancho de banda de Internet gastado) me ha salvado la vida cuando era el administrador de la red en una oficina llena de adultos. Las estadísticas públicas sobre el uso del ancho de banda para cada computadora (solo la cantidad de bytes, no desanonizar información como listas de sitios visitados, etc.) cambiaron la situación de "yo, el malvado y codicioso administrador en contra de ellos, los pobres usuarios de la oficina maltratados" a "hombre, descargaste 5 veces más que yo, ¡eso es malo! " "lo siento, lo descargué, vi mucho youtube durante las pausas para el almuerzo, ya no lo haré a este ritmo", simplemente fui excluido del escenario de confrontación.

También tuve este problema. Así que escribí el script kidtimer, que le permite definir tiempos de uso y totales. El proyecto se puede encontrar en Github en la siguiente ubicación:

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

Así es como instalarlo y usarlo:

1. Copie y pegue el código en un archivo llamado 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. Ejecutalo:

   sudo ./kidtimer.install

3. Ejecutarlo:

   sudo kidtimer

4. Configurar una cuenta de usuario existente.

5. Hecho.

Para ayuda:

sudo kidtimer help

Agregue tiempo a la cuenta de un usuario (solo para ese día):

sudo kidtimer addtime user minutes

caracteristicas:

• Permita que su hijo tenga acceso a la computadora en horas específicas del día, tanto de lunes a viernes como de fin de semana.
• Establezca la cantidad máxima de tiempo, tanto de lunes a viernes como de fin de semana.

Archivos clave:

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

Cronjobs:

• Verifique cada minuto para ver si el usuario ha iniciado sesión. Si es así, incremente el tiempo total. Si alcanza el tiempo máximo, deshabilite la cuenta y comience la secuencia de cierre de sesión (5 minutos en total).
• Verifique cada hora para ver si el usuario puede iniciar sesión. Si es así, habilite la cuenta.
• A medianoche, restablecer la hora.

Nota:

La aplicación utiliza notify-sendpara alertar al usuario que se está agotando el tiempo. Cuando se agota el tiempo, todos los procesos del usuario finalizan, así que prepare al usuario.

timekpr : este programa rastreará y controlará el uso de la computadora de sus cuentas de usuario. Puede limitar su uso diario en función de una duración de acceso programada y configurar períodos del día en los que pueden o no iniciar sesión. Con esta aplicación, los administradores pueden limitar la duración del tiempo de inicio de sesión o las horas de acceso a la cuenta. La aplicación funciona como un control del tiempo de los padres y será útil para los padres que desean limitar el tiempo de acceso de los niños.

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

Puede actualizar su sistema con paquetes no compatibles desde este PPA no confiable agregando ppa:timekpr-maintainers/ppaa las fuentes de software de su sistema.

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

Este paquete está disponible en:

• Problema onírico ver informe de error
• elegante
• Disidente
• lúcido
• Kármico
• Alegre
• Intrépido

• Resistente

• ¿Qué son los PPA y cómo los uso?

PROBLEMA

Reporto que el insecto está aquí, así que cruza el dedo y espera ...

Introducción

Podemos verificar si un usuario ha iniciado sesión con el comando:

who -u

lo que nos da una salida como:

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

En la salida obtenemos el pid del usuario objetivo, que debe detenerse si el tiempo excede el límite.

La solución

Asumiendo que su usuario no tiene sudoprivilegios:

Esta solución es un pequeño script de fondo. Limita el uso por día a un número definido de minutos, para establecer en el encabezado del script. Una vez configurado (que no es demasiado difícil), es muy fácil y no se necesita ninguna acción adicional después.

Para evitar la pérdida de datos no deseados de los archivos posiblemente abiertos, 60 segundos antes de que expire el límite de tiempo del usuario objetivo, aparecerá un mensaje en su DISPLAY:

La secuencia de comandos

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

Cómo utilizar

1. En su escritorio (o en cualquier otro lugar), cree una carpeta llamada: limit
2. Copie el script en un archivo vacío, guárdelo como limit_use(sin extensión) dentro de la carpeta y hágalo ejecutable

3. Edite en el encabezado del script el nombre de usuario a limitar y la cantidad máxima de minutos permitidos. En el ejemplo:

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

4. Copie la carpeta al directorio /opt:

   cp -r /path/to/limit /opt

5. Ahora edite /etc/rc.localpara que el script lo ejecute como rooten el inicio:

   sudo -i gedit /etc/rc.local

   Justo antes de la línea

   exit 0

   otra linea:

   /opt/limit/limit_use &

Explicación; cómo funciona

• Una vez cada 10 segundos, el script busca si el usuario objetivo ha iniciado sesión. Si es así, "agrega" un "punto" al uso total, que se registrará en un archivo ( /opt/limit/uselog). Si se alcanza el límite diario, la secuencia de comandos ya no permite que el usuario inicie sesión, elimina su proceso si existe.
• En el cambio del día (la fecha se registra en un archivo, por lo que reiniciar no ayudará), el archivo de registro se elimina, lo que permite acumular una nueva cantidad de tiempo de uso.
• Dado que la secuencia de comandos se ejecuta al arrancar , rc.localsolo los usuarios con privilegios de sudo pueden detener la secuencia de comandos, incluso si el usuario conoce el nombre del proceso.

Detener el guión

En caso de que quiera detener el script, use el comando:

sudo kill "$(pgrep limit_use)"

Pero necesitarías la contraseña de sudo para hacerlo.

Lo intenté timekprpero no lo hice funcionar. Luego hice una variante que funciona en mi Ubuntu. Esto es lo que hay que hacer para esta variante:

1. Agregar límite de tiempo en el /var/lib/timelimit/user_to_be_limited.limitarchivo solo con derechos de root. por ejemplo, 1800 por 1800 segundos (30 minutos) límite diario.

2. Cree /usr/local/bin/timelimit.shcon derechos de root con lo siguiente:

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

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

4. Reiniciar Ubuntu

Acabo de hacer una respuesta disponible fácilmente. El código se explica en el hilo http://forums.linuxmint.com/viewtopic.php?f=213&t=77687 . En resumen: un límite configurado en minutos por día, un trabajo cron cada minuto, un mensaje al usuario para mantenerlo informado y un cierre de sesión forzado.

Para descargar e instalar esto, abra una Terminal y ejecute los siguientes comandos:

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

Se solicitará una contraseña de administrador durante el proceso de instalación (para instalar el trabajo cron, para copiar el script, ...). Desde allí serás guiado por todos. También hay un ./uninstall.sh en el mismo lugar por si acaso. Está construido para funcionar con todas las distribuciones basadas en Ubuntu (Mint, etc ... probablemente todas debian también). Si ocurre algún problema, avíseme, incluida la versión del sistema y el entorno gráfico en los comentarios:

uname -a
echo $XDG_CURRENT_DESKTOP

Thomas Baeckeroot

Acabo de lanzar una versión beta de mi nueva aplicación LittleBrotherque puede monitorear el tiempo de reproducción en máquinas Linux. Los usuarios de prueba pueden probar el paquete Debian. Las instrucciones sobre cómo descargarlo y usarlo se pueden encontrar aquí: https://github.com/marcus67/little_brother . Sin embargo, la instalación aún puede ser un poco difícil. Estas son las características de la aplicación:

• Cualquier número de usuarios puede ser monitoreado.
• Cada usuario puede tener un conjunto específico de reglas que definen el tiempo de juego permitido.
• Las reglas se pueden adaptar a "contextos", como el día de la semana y / o un horario de vacaciones (actualmente solo se admiten los horarios alemanes).
• El tiempo de reproducción se puede restringir a una ventana de tiempo (de, a).
• Se puede definir un tiempo de juego máximo por día.
• Los usuarios pueden verse obligados a tomar un descanso después de un cierto tiempo máximo de sesión.
• Los usuarios pueden verse obligados a esperar un tiempo de descanso mínimo después de su actividad.
• Se puede monitorear cualquier cantidad de hosts de clientes Linux (actualmente esto requiere que los usuarios tengan el mismo inicio de sesión en todas las máquinas).
• Hay un host maestro con un historial de las actividades de todos los usuarios. Este host maestro verifica los conjuntos de reglas y solicita a los hosts del cliente que finalicen los procesos si es necesario.
• El host maestro ofrece una interfaz web simple para ver la actividad del usuario a lo largo de un historial configurado (por ejemplo, 7 días) y una página de administración para definir dinámicamente excepciones de reglas para un número configurado de días en el futuro.
• La aplicación web se puede ejecutar detrás de un proxy para que sea accesible desde lejos permitiendo la administración remota después de recibir llamadas de usuarios jóvenes que piden más tiempo de juego.
• La aplicación tiene soporte de idiomas internacionales. Actualmente se proporcionan traducciones al inglés y al alemán. Los usuarios están invitados a proporcionar traducciones para otros idiomas.
• La aplicación utiliza la generación de voz para informar al usuario sobre inminentes cierres forzosos. También estos mensajes hablados están internacionalizados.
• Además del tiempo dedicado a los hosts de Linux, la aplicación también puede monitorear el tiempo de actividad en otros dispositivos, como teléfonos inteligentes o mesas. Aprovecha el hecho de que la mayoría de los sistemas operativos modernos ponen a los dispositivos en algún tipo de modo de ahorro de energía mientras no se utilizan. De esta manera, la respuesta de red (mediante ping) se puede usar para determinar la actividad en esos dispositivos. A diferencia de los hosts Linux, la aplicación no podrá finalizar la actividad. Sin embargo, el tiempo de juego se agregará al tiempo de juego general y, por lo tanto, tendrá un impacto en el tiempo permitido y también en las reglas de tiempo de descanso en los hosts de Linux.

Algunas capturas de pantalla: