O acesso ao nosso computador (não apenas à Internet) precisa ser restrito às contas dos meus filhos (7, 8) até que tenham idade suficiente para gerenciar isso sozinhos. Até lá, precisamos definir o seguinte:

• as horas do dia em que a computação está correta (por exemplo, das 17 às 21 horas)
• os dias da semana em que a computação não é boa (por exemplo, de segunda a sexta-feira)
• a quantidade de tempo permitida por dia (por exemplo, 2 horas)

Na 11.10, todos os seguintes itens que costumavam fazer o trabalho não funcionam mais:

• Timekpr : para> 11,10 não está mais disponível no ppa.
• Timeoutd : alternativa de linha de comando, mas a partir da 11.10 removida dos repositórios .
• Gnome Nanny : Parece ótimo, mas trava repetidamente para forçar a reinicialização do X-server. Portanto, não podemos usar ou recomendar este programa no momento.

Há alguma outra alternativa?

Temporizador da tela de bloqueio

Crie seu próprio Screen Lock Timer em vez de aplicativos de terceiros

Embora existam aplicativos de terceiros para fazer isso, você pode criar seus próprios. Resumo das etapas:

• Use geditpara criar scriptlock-screen-timer
• Copie e cole o código desta janela para lock-screen-timer
• Marcar lock-screen-timercomo executável
• Teste-o!
• Configure o Nautilus para executar scripts bash
• Criar link de atalho na área de trabalho
• Monitorar o tempo restante

Use geditpara criar scriptlock-screen-timer

Abra o Terminaluso de Ctrl+ Alt+ Te digite:

gedit lock-screen-timer

Copie e cole o código da janela abaixo para lock-screen-timer

Volte para esta tela e copie o seguinte código destacando-o e pressionando 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.

Volte para a geditjanela vazia e cole o código usando Ctrl+ V. Salve o arquivo e saia do editor de volta para o prompt de comando.

Marcar lock-screen-timercomo executável

Agora precisamos tornar o script executável digitando:

chmod +x lock-screen-timer

Teste-o!

Antes de chamar o script a partir da GUI, o chamaremos a partir do terminal para podermos ver se alguma mensagem de erro é exibida:

~/lock-screen-timer

Você é solicitado pelo número de minutos:

Defina o número desejado de minutos e clique em OK para iniciar o cronômetro. Quando restam 15, 10, 5, 3, 2 e 1 minuto (s), um som do sistema é ouvido e um balão de mensagem aparece avisando quando a tela será bloqueada. Depois que a tela estiver bloqueada, você precisará digitar sua senha para desbloquear a tela.

Configure o Nautilus para executar scripts bash

O Nautilus define o que acontece quando clicamos duas vezes em um script executável quando a janela é exibida ou um link na área de trabalho. O comportamento normal é editar o script usando gedit. Queremos mudar esse comportamento para que seja executado.

Inicie o Nautilus e navegue para o diretório que contém lock-screen-timer. Clique esquerdo uma vez para focar. Passe o mouse sobre a barra de menus superior até que o menu "Edição de arquivo ..." seja exibido, use:

1. Clique Editno menu suspenso
2. Clique na Propertiesopção
3. Clique na Behaviorguia
4. Observe os botões de opção de rádio em Executable Text Files
5. Verifique o botão de opção Run executable text files when they are opened

Criar link de atalho na área de trabalho

Da seção anterior lock-screen-timerainda tem foco. Caso contrário, navegue até o script e clique nele uma vez para focar. Então use:

• Clique com o botão direito do mouse no arquivo e as opções do menu de contexto aparecem.
• No menu, selecione Make Link.
• Um novo ícone aparece chamado Link to lock-screen-timer.
• Clique com o botão esquerdo no novo ícone e arraste-o do Nautilus para a área de trabalho.

Agora você pode clicar duas vezes no link de atalho da área de trabalho e o script é executado. Uma caixa de diálogo aparece para obter o número de minutos. Dois botões são apresentados Cancele OK. Se você clicar em Xpara fechar a janela, será o mesmo que selecionar Cancel.

Depois que o cronômetro estiver em execução e você clicar duas vezes nele novamente, a primeira cópia em execução será "eliminada". Agora você pode iniciar uma nova contagem regressiva de bloqueio de scren ou clicar Cancelem sem contagem regressiva.

Tempo de exibição restante na área da bandeja / notificação

Enquanto o temporizador da tela de bloqueio estiver em execução, ele registra quantos minutos restam no arquivo ~/.lock-screen-timer-remaining. Você pode ver esse arquivo com o watchcomando ou exibi-lo na barra de indicadores da bandeja do sistema / aplicativo do Ubuntu, como mostrado na parte superior desta resposta. Para exibir o tempo restante na área de notificação, siga as instruções nesta seção de perguntas e respostas: ( O BASH pode ser exibido no sistema como indicador de aplicativo? ).

Usuário do Ubuntu <= 11.10, siga este guia para Usuário do Ubuntu> = 11.10, leia o aviso na página inferior:

Sim, todos esses programas estão desatualizados e todas as suas perguntas são respondidas aqui e visualizadas com o controle dos pais .....

Quando falamos em forçar o logoff de um usuário, o que realmente estamos falando é implementar restrições de tempo na conta para acesso ou serviços do sistema. A maneira mais fácil de implementar restrições de tempo é usar um módulo de plug-in chamado Linux-PAM .

O Módulo de autenticação conectável (PAM) é um mecanismo para autenticação de usuários. Especificamente, vamos usar o pam_timemódulo para controlar o acesso cronometrado dos usuários aos serviços.

Usando o pam_timemódulo, podemos definir restrições de acesso a um sistema e / ou aplicativos específicos em vários momentos do dia, bem como em dias específicos ou em várias linhas de terminal. Dependendo da configuração, você pode usar este módulo para negar acesso a usuários individuais com base em seu nome, hora do dia, dia da semana, serviço para o qual está solicitando e terminal de onde está fazendo a solicitação. .

Ao usar pam_time, você deve encerrar a sintaxe de cada linha (ou regra) no /etc/security/time.confarquivo com uma nova linha. Você pode comentar cada linha com o sinal de cerquilha [#], e o sistema ignorará esse texto até a nova linha.

Aqui está a sintaxe para uma regra:

serviços; ttys; usuários; horários

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.

Aqui está um exemplo de um conjunto típico de regras:

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

Essas regras impedem que o bobby do usuário faça logon entre as horas de 0800 e 2000 e também restringem o acesso à Internet durante esse horário. O Root poderá fazer logon a qualquer momento e navegar na Internet também.

Nota: O sistema registra erros com essas regras como syslog (3).

Com o Ubuntu Linux, é possível atribuir restrições de tempo ao seu computador, para impedir a conexão de um ou mais usuários ao seu sistema. Com as restrições de tempo, você pode, por exemplo, limitar o acesso ao computador de seus filhos (uma espécie de controle dos pais, em suma) , ou até mesmo proteger a conexão com o servidor durante determinadas horas.

Configuração manual

Entenda o que você fará

Neste tutorial, usaremos o PAM (Módulos de autenticação conectáveis, Módulos de autenticação conectáveis ​​em inglês). Permite controlar a autenticação do usuário quando eles se conectam. Em seguida, usaremos os arquivos de configuração de segurança para definir o horário de logon permitido. Essas manipulações podem ser executadas em qualquer versão do Ubuntu e requerem apenas um editor de texto simples (vim, emacs, nano, gedit, kate, para citar alguns). Ativar horas de restrições através do módulo PAM

Primeiro de tudo, primeiro vá para /etc/pam.d/, onde estão todos os serviços configuráveis:

$ 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 quisermos bloquear a conexão com o computador, precisaremos alterar o serviço gdm. Edite o arquivo para gdm e adicione esta linha de código (no final do arquivo):

account required pam_time.so

GDM são as distribuições de tela de login Ubuntu, Edubuntu e Xubuntu. Para o Kubuntu, que usa o KDE, o serviço kdm é chamado, será o arquivo que será aberto. E você está pronto para configurar o PAM! Isso permitirá o controle de horas neste serviço.

Se você possui um servidor, provavelmente não possui GUI. Nesse caso, o GDM / KDM não está instalado e a conexão não será bloqueada. Para impedir a conexão com o TTY, você deve modificar o logon do mesmo arquivo e adicionar a mesma linha de código que o anteriormente reconhecido. Esta ação também se aplica a pessoas que instalaram uma GUI e desejam bloquear o acesso à tela de login e aos terminais.

Configurar horas de acesso

Agora que o serviço PAM foi ativado, precisamos apenas configurar os tempos de acesso. Abra o /etc/security. Vários arquivos de configuração estão disponíveis:

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

Edite o arquivo time.conf. Algumas explicações e exemplos (em inglês) que introduzem o. Para definir agendas de acesso, copie e cole a seguinte linha de código (no final do arquivo, como sempre):

*;*;user;scheduler

Em vez do campo do usuário, digite a conta de login que você deseja bloquear.

Se você deseja bloquear vários usuários, insira o login deles em uma linha, separado pelo | operador. Por exemplo, se eu quiser congelar as contas de Patrick, John e Emily:

*;*;Patrick|jean|emilie;scheduler

Por contras, se você deseja bloquear o acesso ao sistema para todos os usuários, exceto um em particular, use o! perante a pessoa em questão. Por exemplo, se eu quiser que o acesso ao computador seja negado a todos os usuários, exceto Nicolas e Xavier:

Nicolas *;*;!|xavier;scheduler

Voltando agora para as zonas de campo. Nesse campo, a seleção de dias e horas permitirá conexão possível. Você deve primeiro especificar o dia da semana, usando as seguintes abreviações:

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

Cuidado para não confundir as abreviaturas Wk e Wd são enganosas! particularmente mal identificado na Internet: você pode encontrar facilmente informações conflitantes!

Em seguida, especificamos os prazos. Estes devem ser formatados 24H, consistindo de 4 dígitos. Por exemplo, para restringir as 15:17 às 18:34, escrevemos: 1517-1834. Para permitir que Marie se conecte apenas na terça-feira, das 15h17 às 18h34, obtemos o resultado:

*;*;marie;Tu1517-1834

As conexões fora deste horário serão proibidas. Quanto aos usuários, é possível usar os operadores | e! para indicar várias vezes (o! indica que todas as horas de logon são permitidas, exceto as que serão mostradas).

As duas estrelas (caracteres curinga) no início da linha de código são, respectivamente, e tty services fields. Como você deseja bloquear todo o acesso ao sistema, não é necessário especificar qual serviço ou qual tty você deseja bloquear. No entanto, se você deseja impedir o uso de um serviço específico, basta especificá-lo como o exemplo a seguir:

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

Assim, o usuário casar não pode se conectar a um TTY, 4 e 5 durante o fim de semana.

Alguns exemplos de programação de restrições

mathilde tem permissão para se conectar todos os dias das 13:20 às 15:20 e das 16:00 às 20:30:

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

Stone, Frank e Florian podem se conectar às 14:00 às 18:45 durante os dias da semana e das 14:00 às 22:15 no fim de semana:

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

Olive nunca tem permissão para se conectar. jessica pode fazer logon na quarta-feira, das 13:00 às 16:00:

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

2 linhas diferentes, por dois tempos diferentes para cada usuário Expiração de uma Sessão

Quando uma sessão expira (excede o tempo enquanto o usuário já está conectado), o PAM pode alcançá-lo. Enquanto mathilde se conecta durante o horário permitido, é perfeitamente gratuito exceder esse horário! Para isso, usaremos um novo programa: ´cron´. Este aplicativo executa comandos em intervalos de tempo. No nosso caso, usaremos o comando ´skill-KILL-u´ para desconectar o usuário quando a sessão expirar. O manuseio é muito simples. Simplesmente edite o arquivo '/ etc / crontab'. Em seguida, adicione a seguinte linha de código:

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

Como antes, substituindo os planejamentos de campo Minuto e o tempo desejado. Em seguida, preencha o (s) dia (s) pelo (s) dia (s) banido (s) ou simplesmente digite um asterisco (*) para indicar todos os dias da semana. Por fim, altere o campo usado pela conta de login para ser bloqueado e pronto!

Os dias não percebem o mesmo com os crontrabalhos! Aqui está a lista de abreviações a serem usadas com este programa:

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

Alguns exemplos de crontrabalhos (com exemplos de horários na seção anterior)

jessica pode fazer logon na quarta-feira, das 13:00 às 16:00

-> Desconectar: ​​terça-feira às 16:00.

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

mathilde tem permissão para se conectar todos os dias das 13:20 às 15:20 e das 16:00 às 20:30.

-> Desconectando: diariamente, das 20:30 às 15:20 ET.

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

Stone, Frank e Florian têm permissão para se conectar às 14:00 às 18:45 durante os dias da semana e das 14:00 às 22:15 no fim de semana

-> Desconectar (1): segunda, terça, quarta, quinta e sexta, às 18:45. -> Desconectar (2): sábado e domingo às 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

O comando skill-KILL-u desconecta o usuário da GUI, bem como o TTY. É perfeitamente utilizável para administradores de servidores. No entanto, este comando é imediato e a desconexão será feita sem aviso prévio. Portanto, seria preferível impedir a instalação dos usuários deste dispositivo do computador ou rede em questão!

É possível impedir os usuários com um wallcomando iniciado por cronalguns minutos antes do final do período , que será exibido nos terminais de todos os usuários.

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

Para impedir que os usuários da GUI possam ser usados ​​no lugar do comando wall, notify-sendestá no pacote libnotify-bin

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

Usuário do Ubuntu 11.10

Eu vi em torno do usuário ter problemas com Pam e eu vi um monte de bug sobre isso, então por que razão? é tão simples O Ubuntu 11.10 não suporta mais o GDM, o novo gerenciador de exibição é lightGDM, o problema é o seguinte, onde armazenamos esta diretiva que account required pam_time.soeu acho que está /etc/pam.d/lightdmou /etc/pam.d/lightdm-autologinmas como?

então, por perto, você pode verificar esses 2 arquivos de log do LightGdm:

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

ou execute o LightGdm no modo de depuração:

LightDM --debug

ou relate um bug:

ubuntu-bug lightdm

Eu relato o Bug aqui, então cruze seu dedo e espere ....

TimeKpr

Eu acho que tem tudo que você precisa. Limite o tempo de acesso por dia por usuário, facilidade de configuração, capacidade de ignorar por um dia, adicione "tempo de recompensa", notificação do tempo restante para os usuários, etc.

A página do projeto está aqui . Eles também têm um PPA para o Ubuntu que você pode adicionar a suas fontes de software: deb http://ppa.launchpad.net/timekpr-maintainers/ppa/ubuntu lucid main. E instalar via Software Center ou via CLI: sudo apt-get install timekpr.

Timekpr

pode ser usado no 11.10, executando o LightDM para configurar restrições para usuários, adicionando a seguinte linha ao /etc/pam.d/lightdm

account required pam_time.so

^{Talvez seja necessário remover o libpam-smbpass para ativar a troca de usuário até que o bug # 835310 seja corrigido.}

Todos os restrições definidos na janela do aplicativo funcionam como definido na GUI do timekpr.

Para exibir o ícone timekpr-client no Unity, precisamos colocar na lista de permissões'timekpr' nas configurações do painel do Unity e, além disso, precisamos adicionar Unitya seguinte linha em /etc/xdg/autostart/timekpr-client.desktop:

OnlyShowIn=GNOME;XFCE;KDE;Unity;

Para iniciar a contagem regressiva do tempo concedido, talvez seja necessário iniciar o daemon timekpr com

/etc/init.d/timekpr start

para 14.04:

Um comunicado / fork mais recente do timekpr foi publicado para o Ubuntu 14.04 por Eduards Bezverhijs na sua ppa:mjasnik/ppa.

O logoff automático é extremamente frustrante se você estiver no meio de alguma coisa. É violento, é brutal, é rude. E não importa quantos anos você tem. Uma coisa é que você é viciado em computador e é muito diferente quando está rastreando o tempo e é expulso 5 segundos antes de clicar no botão enviar ou salvar o documento. Sugiro que você considere usar um lembrete automático em vez de um kicker automático. Isso ensinará seus filhos a respeitarem-se e a permitir que usem o computador de boa vontade.

Existe ainda uma alternativa mais leve. Comece acompanhando a quantidade de tempo que cada criança passa usando o computador e disponibilize os dados coletados para todos, para que eles possam vê-lo. Essa coisa incrivelmente simples por si só (aplicada à largura de banda da Internet gasta) salvou minha vida quando eu era administrador de rede em um escritório cheio de adultos. As estatísticas públicas sobre o uso da largura de banda de cada computador (apenas a quantidade de bytes, sem desanimizar informações como listas de sites visitados etc.) mudaram a situação de "eu - o administrador ganancioso contra eles - os pobres usuários abusados ​​do escritório" para "homem, você baixou 5 vezes mais que eu, isso é ruim! " "desculpe, baixei de fato, assisti muito youtube durante o almoço, não vou mais fazer isso nesse ritmo" - fui simplesmente excluído do cenário de confronto.

Eu também tive esse problema. Então, escrevi o script kidtimer, que permite definir tempos e totais de uso. O projeto pode ser encontrado no Github no seguinte local:

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

Isto é como instalá-lo e usá-lo:

1. Copie e cole o código em um arquivo chamado 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. Execute:

   sudo ./kidtimer.install

3. Executá-lo:

   sudo kidtimer

4. Configure uma conta de usuário existente.

5. Feito.

Para ajuda:

sudo kidtimer help

Adicione tempo à conta de um usuário (apenas para esse dia):

sudo kidtimer addtime user minutes

Recursos:

• Permita que seu filho horário específico do dia acesse o computador, tanto durante a semana quanto no fim de semana.
• Defina a quantidade máxima de tempo, dia da semana e fim de semana.

Arquivos principais:

/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 se o usuário está conectado. Se sim, aumente o tempo total. Se atingir o tempo máximo, desative a conta e inicie a sequência de logoff (5 minutos no total).
• Verifique a cada hora se o usuário tem permissão para fazer login. Nesse caso, ative a conta.
• À meia-noite, redefina a hora.

Nota:

O aplicativo usa notify-sendpara alertar que o tempo do usuário está acabando. Quando o tempo acabar, todos os processos do usuário serão encerrados; portanto, prepare o usuário.

timekpr - Este programa rastreia e controla o uso do computador de suas contas de usuário. Você pode limitar seu uso diário com base em uma duração de acesso cronometrada e configurar períodos do dia em que eles podem ou não podem fazer login. Com esse aplicativo, os administradores podem limitar a duração do tempo de login da conta ou as horas de acesso à conta. O aplicativo funciona como um controle de tempo dos pais e será útil para os pais que desejam limitar o tempo de acesso dos filhos.

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

Você pode atualizar seu sistema com pacotes não suportados deste PPA não confiável, adicionando ppa:timekpr-maintainers/ppaàs fontes de software do seu 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 pacote está disponível em:

• Problema onírico ver relatório de bug ....
• natty
• Maverick
• lúcido
• Karmic
• Jaunty
• Intrépido

• Hardy

• O que são PPAs e como os uso?

PROBLEMA:

Eu relato o Bug aqui, então cruze seu dedo e espere ....

Introdução

Podemos verificar se um usuário está logado pelo comando:

who -u

o que nos dá uma saída como:

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

Na saída, recebemos o pid do usuário alvo, que precisa ser interrompido se o tempo exceder o limite.

A solução

Supondo que seu usuário não tenha sudoprivilégios:

Esta solução é um pequeno script em segundo plano. Limita o uso por dia a um número definido de minutos, a ser definido no cabeçalho do script. Uma vez configurado (o que não é muito difícil), ele é executado com muita facilidade e nenhuma ação adicional é necessária posteriormente.

Para evitar a perda indesejada de dados de arquivos possivelmente abertos, 60 segundos antes do prazo limite do usuário de destino expirar, uma mensagem será exibida DISPLAY:

O 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

Como usar

1. Na área de trabalho (ou em qualquer outro lugar), crie uma pasta chamada: limit
2. Copie o script em um arquivo vazio, salve-o como limit_use(sem extensão) dentro da pasta e torne-o executável

3. Edite no cabeçalho do script o nome do usuário a limitar e o número máximo de minutos permitidos. No exemplo:

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

4. Copie a pasta para o diretório /opt:

   cp -r /path/to/limit /opt

5. Agora edite /etc/rc.localpara fazer o script executá-lo como rootna inicialização:

   sudo -i gedit /etc/rc.local

   Pouco antes da linha

   exit 0

   outra linha:

   /opt/limit/limit_use &

Explicação; como funciona

• Uma vez a cada 10 segundos, o script verifica se o usuário de destino está logado. Nesse caso, "adiciona" um "ponto" ao uso total, para ser gravado em um arquivo ( /opt/limit/uselog). Se o limite diário for atingido, o script não permitirá mais o login do usuário, encerrará seu processo, se existir.
• Na mudança do dia (a data é registrada em um arquivo, para que a reinicialização não ajude), o arquivo de log é excluído, permitindo que uma nova quantidade de tempo de uso seja acumulada.
• Como o script é executado na inicialização , rc.localsomente usuários com privilégios de sudo podem parar o script, mesmo assim, apenas se o usuário souber o nome do processo.

Pare o script

Caso você queira interromper o script, use o comando:

sudo kill "$(pgrep limit_use)"

Mas você precisaria da senha do sudo para fazer isso.

Eu tentei, timekprmas não funcionou. Então fiz uma variante dele que funciona no meu Ubuntu. É isso que é preciso fazer para esta variante:

1. Adicione limite de tempo no /var/lib/timelimit/user_to_be_limited.limitarquivo apenas com direitos de root. por exemplo, 1800 por 1800 segundos (30 minutos) de limite diário.

2. Crie /usr/local/bin/timelimit.shcom direitos de root com o seguinte:

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

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

4. Reinicie o Ubuntu

Acabei de disponibilizar uma resposta facilmente. O código é explicado no thread http://forums.linuxmint.com/viewtopic.php?f=213&t=77687 . Em resumo: um limite configurado em minutos por dia, um trabalho cron a cada minuto, uma mensagem para o usuário para mantê-lo informado e um logoff forçado.

Para baixar e instalar isso, abra um terminal e execute os comandos abaixo:

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

A senha do administrador será solicitada durante o processo de instalação (para instalar o trabalho cron, para copiar o script,…). De lá, você será guiado por todos. Também existe um ./uninstall.sh no mesmo local, apenas por precaução. É construído para funcionar com todas as distros baseadas no Ubuntu (Mint, etc ... provavelmente também com todos os debian). Se ocorrer algum problema, entre em contato, incluindo a versão do sistema e o ambiente gráfico nos comentários:

uname -a
echo $XDG_CURRENT_DESKTOP

Thomas Baeckeroot

Acabei de lançar uma versão beta do meu novo aplicativo LittleBrotherque é capaz de monitorar o tempo de reprodução em máquinas Linux. Usuários de teste são bem-vindos para experimentar o pacote Debian. Instruções sobre como fazer o download e usá-lo podem ser encontradas aqui: https://github.com/marcus67/little_brother . A instalação ainda pode ser um pouco difícil, no entanto. Estes são os recursos do aplicativo:

• Qualquer número de usuários pode ser monitorado.
• Cada usuário pode ter um conjunto específico de regras que definem o tempo de reprodução permitido.
• As regras podem ser adaptadas a "contextos", como o dia da semana e / ou uma programação de férias (atualmente apenas as agendas alemãs são suportadas).
• O tempo de reprodução pode ser restrito a uma janela de tempo (de, para).
• Pode ser definido um tempo máximo de reprodução por dia.
• Os usuários podem ser forçados a fazer uma pausa após um certo tempo máximo de sessão.
• Os usuários podem ser forçados a aguardar um intervalo mínimo após a atividade.
• Qualquer número de hosts clientes do Linux pode ser monitorado (atualmente, isso requer que os usuários tenham o mesmo login em todas as máquinas).
• Há um host mestre com um histórico das atividades de todos os usuários. Esse host principal verifica os conjuntos de regras e solicita que os hosts clientes finalizem os processos, se necessário.
• O host principal oferece uma interface da web simples para visualizar a atividade do usuário por um período de histórico configurado (por exemplo, 7 dias) e uma página de administração para definir dinamicamente exceções de regras para um número configurado de dias no futuro.
• O aplicativo da Web pode ser executado atrás de um proxy, para que fique acessível de longe, permitindo a administração remota após o recebimento de chamadas de usuários jovens que imploram por mais tempo de reprodução.
• O aplicativo tem suporte a idiomas internacionais. Atualmente, são fornecidas traduções em inglês e alemão. Os usuários são convidados a fornecer traduções para outros idiomas.
• O aplicativo usa a geração de voz para informar o usuário sobre logins forçados iminentes. Além disso, essas mensagens faladas são internacionalizadas.
• Além do tempo gasto em hosts Linux, o aplicativo também pode monitorar o tempo de atividade em outros dispositivos, como smartphones ou tabelas. Ele aproveita o fato de que os sistemas operacionais mais modernos colocam os dispositivos em algum tipo de modo de economia de energia enquanto não estão sendo usados. Dessa forma, a resposta da rede (executando ping) pode ser usada para determinar a atividade nesses dispositivos. Ao contrário dos hosts Linux, o aplicativo não poderá encerrar a atividade. O tempo de reprodução, no entanto, será adicionado ao tempo de reprodução geral e, portanto, terá um impacto no tempo permitido e também nas regras de tempo de pausa nos hosts Linux.

Algumas capturas de tela: