Como faço para restringir o tempo de computação de meus filhos?

53

O acesso ao nosso computador (não apenas à internet) precisa ser restrito para as contas dos meus filhos (7, 8) até que eles tenham idade suficiente para administrar isso por conta própria. Até lá, precisamos ser capazes de definir o seguinte:

  • as horas do dia quando a computação é o.k. (por exemplo, de cinco a nove horas)
  • os dias da semana em que a computação não é o.k. (por exemplo, segundas a sextas-feiras)
  • a quantidade de tempo permitida por dia (por exemplo, duas horas)

Em 11,10, todos os itens a seguir que costumavam fazer o trabalho não funcionam mais:

  • Timekpr : para & gt; 11.10 não mais disponível através do ppa.
  • Timeoutd : alternativa de linha de comando, mas a partir de 11.10 removido dos repositórios .
  • Gnome Nanny : Parece ótimo, mas falha repetidamente para forçar o reinício do X-server. Portanto, não podemos usar ou recomendar este programa no momento.

Existem outras alternativas?

    
por Takkat 18.10.2011 / 22:50

10 respostas

1

Temporizador de tela de bloqueio

Crie seu próprio Temporizador de bloqueio de tela em vez de aplicativos de terceiros

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

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

Use gedit para criar o script lock-screen-timer

Abra o Terminal usando Ctrl + Alt + T e digite:

gedit lock-screen-timer

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

Volte a 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="" # Optional parameter 1 when invoked from terminal.

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

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

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

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


while true ; do # loop until cancel

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

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

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

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

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

        sleep 60

    done

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

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

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

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

Em seguida, volte para a janela gedit vazia e cole o código usando Ctrl + V . Salve o arquivo e saia do editor de volta ao prompt de comando.

Marque lock-screen-timer como um executável

Agora, precisamos tornar o script executável digitando:

chmod +x lock-screen-timer

Teste-o!

Antes de chamar o script da GUI, nós o chamaremos do terminal para que possamos ver se alguma mensagem de erro é exibida:

~/lock-screen-timer

Você é solicitado a informar o número de minutos:

Defina o número desejado de minutos e clique em OK para iniciar o cronômetro. Quando há 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 é bloqueada, você precisa 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 de exibição de arquivos ou um link na área de trabalho. O comportamento normal é editar o script usando gedit . Queremos mudar esse comportamento de tal forma que ele seja executado.

Inicie o Nautilus e navegue até o diretório contendo lock-screen-timer . Esquerda clique nela uma vez para dar foco. Passe o mouse sobre a barra de menu superior até que o menu "File Edit ..." apareça, use:

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

Criar link de atalho na área de trabalho

Da seção anterior lock-screen-timer ainda tem foco. Se não, navegue até o script e clique nele uma vez para dar foco. Então use:

  • Clique com o botão direito no arquivo e as opções do menu de contexto são exibidas.
  • 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 sua área de trabalho.

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

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 scren lock ou clicar em Cancelar para nenhuma contagem regressiva.

Tempo de exibição restante na área do systray / notificação

Enquanto o temporizador da tela de bloqueio está sendo executado, ele registra quantos minutos restam no arquivo ~/.lock-screen-timer-remaining . Você pode olhar esse arquivo com o comando watch ou exibi-lo na barra do sistema 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 desta Q & amp; A: ( O BASH pode exibir na bandeja do sistema como indicador de aplicativo? ).

    
por WinEunuuchs2Unix 22.03.2018 / 02:06
37

Ubuntu & lt; = 11.10 O usuário segue este guia para o usuário do Ubuntu & gt; = 11,10 lê o aviso da página inferior:

Sim, todos esses programas estão desatualizados e todas as suas perguntas foram respondidas aqui e com boa aparência com o controle de seus pais .....

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

O Pluggable Authentication Module (PAM) é um mecanismo para autenticar usuários. Especificamente, usaremos o módulo pam_time para controlar o acesso temporizado de usuários a serviços.

Usando o módulo pam_time , 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, a hora do dia, o dia da semana, o serviço para o qual eles estão se candidatando e o terminal do qual eles estão fazendo a solicitação. .

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

Esta é a sintaxe de 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.

Veja 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 restringem o login do usuário entre as horas de 0800 e 2000 e também restringem o acesso à Internet durante essas horas. O Root seria capaz de fazer logon a qualquer momento e navegar na Internet durante todo o tempo também.

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

Com o Ubuntu Linux, é possível atribuir às restrições de tempo do 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 para seus filhos (um tipo de controle dos pais, em suma) , ou até mesmo proteger a conexão com o seu servidor durante certas horas. / p>

Configuração manual

Entenda o que você fará

Ao longo deste tutorial, usaremos o PAM (Pluggable Authentication Modules, Módulos de Autenticação Conectáveis em Inglês). Ele permite que você controle a autenticação do usuário quando eles se conectam. Em seguida, usaremos os arquivos de configuração de segurança para definir as horas de logon permitidas. 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, entre outros). Habilite horas de restrições através do módulo PAM

Primeiro, primeiro vá para o /etc/pam.d/ , onde todos os serviços são 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, teremos que alterar o serviço do gdm. Edite o arquivo para o gdm e adicione esta linha de código (no final do arquivo):

account required pam_time.so

GDM é a distribuição de tela de login do 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ê tiver um servidor, provavelmente não tem GUI. Neste 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 login do mesmo arquivo e adicionar a mesma linha de código que o reconhecido anteriormente. Esta ação também se aplica a pessoas que instalaram uma GUI e desejam bloquear o acesso à tela de login e terminais.

Configurar as horas de acesso

Agora que o serviço PAM foi ativado, só precisamos configurar os horários 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 (inglês) introduzindo o. Para definir horários 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, insira a conta de login que você deseja bloquear.

Se você quiser 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ê quiser bloquear o acesso ao sistema para todos os usuários, exceto um em particular, use o! antes da pessoa em causa. Por exemplo, se eu quiser que o acesso ao computador seja negado a todos os usuários, exceto Nicolas e Xavier:

Nicolas *;*;!|xavier;scheduler

Passando agora para as zonas de campo. Neste campo, a seleção de dias e horas será permitida a conexão.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 abreviações Wk e Wd são enganosas! particularmente mal identificado na Internet: você pode facilmente encontrar informações conflitantes!

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

*;*;marie;Tu1517-1834

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

As duas estrelas (curingas) no início da linha de código são, respectivamente, e tty campos de serviços. Como você quer bloquear todo o acesso ao sistema, não é necessário especificar qual serviço ou qual tty deseja bloquear. No entanto, se você quiser impedir o uso de um determinado serviço, 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 final de semana.

Alguns exemplos de cronograma de restrições

mathilde pode se conectar todos os dias a partir das 13h20. às 3:20 da tarde e a partir das 16:00 às 20h30:

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

Stone, Frank e Florian podem se conectar às 14:00. às 6: 45h durante os dias de semana e às 14:00 às 10:15 para o fim de semana:

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

A azeitona nunca é permitida para se conectar. jessica pode logar na quarta-feira a partir 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 em que o usuário já está conectado), o PAM pode alcançar o usuário. Enquanto mathilde se conecta durante as horas permitidas, é perfeitamente livre exceder essas horas! Para isso, vamos usar um novo programa:'cron '. Este aplicativo executa comandos em intervalos de tempo. No nosso caso, faremos uso do 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 agendamentos de campo Minutos e o tempo desejado. Em seguida, preencha o (s) dia (s) por (s) dia (s) proibido (s) ou simplesmente digite um asterisco (*) para indicar todos os dias da semana. Finalmente, mude o campo usado pela conta de login para ser bloqueado, e voilà!

Os dias não aparecem da mesma maneira com os trabalhos cron ! Aqui está a lista de abreviaturas 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 cron jobs (com exemplos de vezes na seção anterior)

jessica pode logar na quarta-feira a partir das 13:00 às 4:00 da manhã

  

- & gt; Desligue: terça-feira às 16:00.

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

mathilde pode se conectar todos os dias a partir das 13h20. às 3:20 da tarde e a partir das 16:00 às 20h30.

  

- & gt; Desconectando: diariamente, 20h30 às 3:20 da tarde ET.

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

Stone, Frank e Florian podem se conectar às 14:00. às 6: 45h durante os dias de semana e às 14:00 às 10:15 para o fim de semana

  

- & gt; Desconectar (1): Segunda, Terça, Quarta, Quinta e Sexta, às 18:45.   - & gt; Desligue (2): Sábado e Domingo às 10: 15h ..

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, assim 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. Seria, portanto, preferível impedir a instalação dos usuários deste dispositivo do computador ou da rede em questão!

É possível impedir que os usuários com um comando wall iniciado por cron alguns minutos antes do final do período , sejam exibidos nos terminais de todos os usuários.

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

Para evitar que usuários da GUI possam ser usados no lugar do comando wall notify-send está 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 porque é que a razão ??? é tão simples que o Ubuntu 11.10 não suporta mais o GDM o novo gerenciador de display é lightGDM o problema é o seguinte onde armazenar essa diretiva account required pam_time.so acho que está em /etc/pam.d/lightdm ou /etc/pam.d/lightdm-autologin mas bug como ???

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

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

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

  

LightDM --debug

ou relatar um bug:

  

ubuntu-bug lightdm

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

    
por hhlp 21.10.2011 / 17:32
10

TimeKpr

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

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

    
por Decio Lira 21.08.2010 / 18:25
7

Timekpr

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

account required pam_time.so

Podemos precisar remover libpam-smbpass para permitir que o usuário alterne até bug # 835310 está corrigido.

Todos os restritos definidos na janela do aplicativo funcionam conforme definido na GUI timekpr.

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

OnlyShowIn=GNOME;XFCE;KDE;Unity;

Para iniciar a contagem regressiva do tempo concedido, talvez tenhamos que iniciar o daemon timekpr com

/etc/init.d/timekpr start

para 14.04:

Um novo release / fork do timekpr foi publicado para o Ubuntu 14.04 por Eduards Bezverhijs em seu ppa:mjasnik/ppa .

    
por Takkat 27.10.2011 / 20:30
6

O logoff automático é extremamente frustrante se você estiver no meio de algo. É violento, é brutal, é simplesmente rude. E não importa quantos anos você tem. Uma coisa é quando você é viciado em computador e é muito diferente quando você está acompanhando 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 auto-kicker. Isso vai ensinar seus filhos a se respeitarem e permitir que o outro use o computador de bom grado.

Existe até uma alternativa mais leve. Comece rastreando a quantidade de tempo que cada criança passa usando o computador e disponibilizando os dados reunidos para todos eles, para que eles possam vê-lo. Essa coisa incrivelmente simples sozinha (aplicada à largura de banda da Internet gasta) salvou minha vida quando eu estava sendo o administrador da rede em um escritório cheio de adultos. As estatísticas públicas sobre o uso da largura de banda para cada computador (apenas a quantidade de bytes, não desanimando informações como listas de sites visitados, etc.) transformaram a situação de "eu - o malvado administrador contra eles - os pobres usuários de escritório" a "homem, você baixou 5 vezes mais do que eu, isso é ruim! " "desculpe, eu baixei de fato, eu assisti muito youtube durante os intervalos de almoço, não vou mais fazer isso a este ritmo" - eu estava simplesmente excluído do cenário de confronto.

    
por vh1 21.08.2010 / 13:41
6

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

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

    sudo kidtimer
    
  3. Execute:

    sudo kidtimer help
    
  4. Configure uma conta de usuário existente.

  5. Concluído.

Para ajuda:

sudo kidtimer addtime user minutes

Adicione tempo à conta de um usuário (somente naquele dia):

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

Recursos:

  • Permitir que o seu filho / a horas específicas do dia acesse o computador, tanto nos dias da semana quanto no final de semana.
  • Defina o tempo máximo, tanto nos dias da semana quanto nos finais de semana.

Arquivos-chave:

%pre%

Cronjobs:

  • Verifique cada minuto para ver se o usuário está logado. Em caso afirmativo, incremente o tempo total. Se atingir o tempo máximo, desative a conta e inicie a sequência de logoff (total de 5 minutos).
  • Verifique a cada hora para ver se o usuário tem permissão para efetuar login. Se sim, ative a conta.
  • À meia-noite, redefina a hora.

Nota:

O aplicativo usa notify-send para alertar que o tempo do usuário está se esgotando. Quando o tempo acabar, todos os processos do usuário serão encerrados, portanto, prepare o usuário.

    
por grover66 18.10.2013 / 04:48
5

timekpr - Este programa rastreará e controlará 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 efetuar 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 das crianças.

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:

Eu denuncio o erro do Bug aqui então cruze o dedo e espere ....

    
por hhlp 24.10.2011 / 23:01
3

Introdução

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

who -u

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, obtemos o pid do usuário de destino, que precisa ser interrompido se o tempo exceder o limite.

A solução

Supondo que seu usuário não tenha sudo privileges:

Esta solução é um pequeno script de fundo. Ele limita o uso por dia a um número definido de minutos, para definir o cabeçalho do script. Uma vez configurado (o que não é muito difícil), é muito fácil, e nenhuma ação adicional é necessária depois.

Para evitar a perda indesejada de dados de arquivos possivelmente abertos, 60 segundos antes de o limite de tempo do usuário-alvo expirar, uma mensagem será exibida em seu 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 sua á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 na cabeça do script o nome do usuário a ser limitado 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.local para fazer o script executá-lo como root na 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 por 10 segundos, o script procura se o usuário-alvo estiver logado. Em caso positivo, "adiciona" um "ponto" a um uso total, a ser registrado em um arquivo ( /opt/limit/uselog ). Se o limite diário for atingido, o script não permitirá mais o login do usuário, eliminando o processo, se existir.
  • Na alteração do dia (a data é gravada em um arquivo, portanto, a reinicialização não ajudará), o arquivo de log é excluído, permitindo que uma nova quantidade de tempo de uso seja acumulada.
  • Como o script é executado em inicialização , de rc.local apenas usuário (s) com privilégios sudo pode parar o script, mesmo assim, somente 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 sudo para fazer isso.

    
por Jacob Vlijm 17.03.2016 / 20:46
2

Eu tentei timekpr , mas não consegui trabalhar. Então fiz uma variante dele que funciona no meu Ubuntu. Isso é o que é necessário fazer para essa variante:

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

  2. Crie os direitos /usr/local/bin/timelimit.sh com root com os seguintes itens:

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

    sudo /usr/local/bin/timelimit.sh &
    
  4. Reinicie o Ubuntu

por Csaba 18.04.2014 / 22:57
2

Acabei de disponibilizar uma resposta facilmente. O código é explicado no tópico link . Resumindo: um limite configurado em minutos por dia, um cron job a cada minuto, uma mensagem ao 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 a tarefa cron, para copiar o script,…). De lá você será guiado por todos. Há também um ./uninstall.sh no mesmo lugar apenas no caso. É construído para funcionar com todas as distribuições baseadas no Ubuntu (Mint, etc ... provavelmente todas debian também). Se algum problema ocorrer, por favor me avise, incluindo a versão do sistema e o ambiente gráfico nos comentários:

uname -a
echo $XDG_CURRENT_DESKTOP

Thomas Baeckeroot

    
por Thomas Baeckeroot 10.09.2017 / 14:32