Derrubar usuário logado no sistema [RESOLVIDO]

elvanineto
(usa Red Hat)

Enviado em 15/03/2010 - 16:13h

Estou com um problema no meu sistema com usuários que ficam travados no login.
Utilizamos um servidor Linux como TS para acesso do sistema. Todo o sistema e banco de dados fica nesse servidor.

É criado um usuário para cada pessoa que utiliza o TS. O problema acontece é que do nada o o usuário fica travado no sistema e para liberar esse usuário eu tenho que dar um "kill -9 pid".

A solução pra esse problema seria a criação de um Shell Script que faria a verificação do usuário travado e mataria esse usuário do sistema automaticamente de 2 em 2 minutos, sendo controlado pelo crontab.

O problema é saber de um indicador para identificar que o usuário esteja travado. Com o usuário travado dando um "ps aux | grep usuárioxx" eu tenho o seguinte resultado:

root 25882 0.0 0.0 4604 1456 ? Ss 15:57 0:00 login -- usuarioxx
usuarioxx 25902 0.0 0.0 6192 1268 pts/10 Ss+ 15:57 0:00 -bash
usuarioxx 25945 0.0 0.0 5920 2648 pts/10 S+ 15:57 0:00 fglrun monitor

Dando um "who -u | grep usuarioxx" eu tenho o seguinte resultado:

usuarioxx pts/10 Mar 15 15:57 00:06 25882 (xxx.xxx.xxx.xxx)


Então como devo fazer? Caso não seja possível fazer um Shell Script existe alguma outra meneira de matar esse usuário, como por exemplo, fazer uma rotina para quando o usuário fazer o segundo login ele matar o primeiro login?

Desde já, obrigado!

elvanineto
(usa Red Hat)

Enviado em 16/03/2010 - 09:20h

Corrigindo.

Não é TS. O acesso é telnet.

elvanineto
(usa Red Hat)

Enviado em 18/03/2010 - 11:48h

Ninguém? Eu pensei em uma solução mas preciso desenvolver o script.
Aumentaria o maxlogins dos usuários para 2.

A rotina verificaria quando o usuário se conectasse pela segunda vez.
Analisaria o who -u, pegando o seu login mais antigo por horas e minutos e matando. Então quando um usuário ficasse travado no sistema era só ele logar novamente que ele teria uma sessão nova destravada e com a antiga kilada.

Tentei fazer utilizando AWK mas não consegui.

jefinho16v
(usa CentOS)

Enviado em 05/04/2010 - 13:23h

Acredito que não é possivel pois você tera que executar o script, não sendo possivel a execução do mesmo ao tentar logar pela segunda vez.

Daemonio
(usa Slackware)

Enviado em 05/04/2010 - 16:03h

Só para eu entender:

1) O usuário loga
2) Se o antigo processo travou então quando eu mandar um who -u, terei duas entradas para o mesmo usuário.
3) Se 2) é verdadeiro então mato o processo travado. Faço isso utilizando um ps aux e pego todos os PID referente aos processos do usuário. Como o primeiro PID é o do processo travado, então dou um kill nele.
4) Usuário loga normalmente, sendo que 3) pode ocorrer ou não.

É isso mesmo?

Abraços
t+

elvanineto
(usa Red Hat)

Enviado em 05/04/2010 - 22:23h

Sim, isso mesmo. Já até consegui desenvolver essa rotina.

Agora só preciso dar uma melhorada nela. Eu fiz por essa lógica: limitei o maxlogins pra 2 por usuário. Utilizei o seguinte pensamento que quando o usuário travar, deverá ser feito um novo login. O loop é verificado de 30 em 30 segundos se o úsuário tem dois processos de login. Se for verdade o primeiro login é matado, ou seja, o que está travado.

Deu certo pra mim, agora quero fazer a leitura desses usuários por um arquivo qualquer. O comando who -u joga o nome de todos os usuários em um arquivo qualquer e a rotina verifica esse arquivo. Eu fiz uma rotina pra cada usuário, ficou bem extenso o programa.

Se alguém tiver uma idéia eu agradeço.

Fabricio.Er
(usa Debian)

Enviado em 05/04/2010 - 23:58h

tente usar listas em conjunto com uma função while tipo esse pequeno scrit em python:

a = ('lista','dos', 'usuarios')

def test(b):

     i = 0

     while i < len(b):

             print b[i]

             i = i + 1

 

o python tem suporte a comandos do linux, mas faz um tempo que não mecho com isso então não lembro quais são.

Daemonio
(usa Slackware)

Enviado em 07/04/2010 - 14:41h

Não sei se você já resolveu o problema, mas uma dica que posso te dar é que para ver usuários duplicados em who -u, você pode fazer:

$ who -u | sort | uniq -d
joao
maria

Nessa caso, joao e maria tem mais de uma entrada no who, o que leva a crer que cada um deles está logado mais de uma vez.

Espero ter ajudado.
t+

arollim
(usa Suse)

Enviado em 07/05/2010 - 16:27h

Amigo o meu problema é inverso ao seu , eu gostaria de nao permitir que um usuario que esteja logado no servidor via (NETTERM) se logasse de novo na rede se o IP for o mesmo, no meu caso quando o usuario faz isso o corno , trava o sistema , ja vi alguns aqui com 4 logins na mesma maquina.

Quanto ao seu problema vou pesquisar se achar algo , te falo
Abraco

Alex

eduardoleandro
(usa Debian)

Enviado em 19/12/2012 - 15:55h

Uma maneira que achei pratica é o próprio usuario se derrubar em outras sessões quando este ultrapassar o limite estabelecido para ele.

Passo 1)


Criar arquivo com lista de usuarios e determinar o numero de logins para cada um
Eu criei um arquivo chamado usuarios.txt (sem permissão de escrita) no /home.
Dentro voce coloca o usuario=1 (quantidade de logins).
Para facilitar a criação do arquivo pode usar um laço como a seguir:
# cd /home
# for i in `ls -1`;do echo "$i=1" >> usuarios.txt;done


Passo 2)

Em seguida é criar o script que checa o conteúdo do limite do usuário que esta logado:
Pode colocá-lo em um diretorio /usr/bin por exemplo com o nome de LimitLogin.sh com o
seguinte conteudo:

# limite de logins do usuario
LIMIT=`grep $USER /home/usuarios.txt | cut -d "=" -f2`

# Rotina para checagem do limite estabelecido
trap "logout" 2 20
TTY=$(tty | sed 's/\/dev\///g')
nlog=$(w | cut -d ' ' -f1 | grep $USER | wc -l)

if [ $nlog -gt $LIMIT ]; then
clear;
echo -e '\e[33;1m'
echo -n "
==================================================================
Voce ja tem $((nlog-1)) sessao aberta. Deseja elimina-la? (s/n): "
read op
echo -e '\e[m'
case $op in [sS]) for i in `ps U $USER | grep -vw $TTY | \
awk '{print $1}'`; do kill -9 $i 2> /dev/null;
trap 2 20;
done;;
*) exit; logout;;
esac
fi



Passo 3)
Dê permissão de execução para todos os usuários:

# chmod 777 /usr/bin/LimitLogin.sh

Agora é executá-lo para todos os usuários, menos o root claro:

Voce teria que colocar o .profile de cada usuário para que fosse executa na
entrada do sistema, mas uma maneira fácil de fazer é usar o arquivo /etc/profile
que qualquer usuário lê assim que entram no sistema.

Edit o /etc/profile e Cole este conteúdo a seguir ao final:

if [ "${USER}" != "root" ]
then
source /usr/bin/LimitLogin.sh
fi


Pronto, esta é maneira que achei de controlar o limite de login dos usuários. Se por acaso alguma sessão ficar aberta por perda de conexão por exemplo, ou ele esquecer de fechar o login que deixou aberto em outra estação de trabalho, o próprio usuário poderá derrubá-la no próximo login.

Voce pode alterar a quantidade de logins permitidos para alguns usuários no usuarios.txt que criamos no inicio.

alexandregms
(usa Ubuntu)

Enviado em 19/12/2012 - 17:06h

Caramba..ressucitou uma questão de 05/2010?
De qualquer forma é válido, pois ninguem tinha chegado a uma solução! :-)

elvanineto
(usa Red Hat)

Enviado em 19/12/2012 - 17:08h

Pois é.. Vou marcar como resolvido. Mas foi uma boa, com certeza esse tópico vai ajudar alguém futuramente.

Obrigado!