1. Introdução

Quem tem computadores para uso dedicado (servidores, roteadores, etc...) sabe o tanto que é chato quando é necessário executar algum comando na máquina. Apenas duas opções, ou manter o conjunto monitor/teclado/mouse para o computador no armário ou fazer uma conexão de rede (SSH, Telnet, etc...) apenas para executar o tal comando.

Pensei em uma terceira solução para o meu roteador doméstico, uma solução que ocupe menos espaço e seja simples tanto de implementar como de usar. Resolvi utilizar o mouse para executar os principais comandos:

1. Ativar a Conexão Discada
2. Desativar a Conexão Discada
3. Desligar o Computador

Coincidentemente, existem 3 botões no mouse -:). E, um mouse ocupa muito menos espaço que um teclado (falar de monitor é covardia). Sem contar que clicar em um botão é uma tarefa simples, qualquer um pode fazer, basta saber qual dos botões apertar.

Com isso, quem quiser usar a internet liga o roteador e usa internet, quando quiser usar a linha para outra coisa, clica o botão 2 e pode usar o telefone, quando quiser navegar de novo é só clicar o botão 1. Mais simples que conectar no roteador para cada uma dessas operações.

2. Ingredientes...

Para colocar esta solução em prática você vai precisar de alguns softwares instalados:

• gpm;
• mev e
• awk

Os dois primeiros se encontram no pacote gpm-1.19.6-i486-6.tgz e o segundo está no gawk-3.1.3-i486-1.tgz. Ambos pertencem a série A do Slackware, a versão do pacote pode mudar de uma versão do Slackware para outra.

A maior parte das distribuições Linux possuem esses comandos, mas os pacotes devem ter outros nomes. Este artigo utiliza como base o Slackware, mas pode ser facilmente adaptado para outras distribuições.

3. Preparando o terreno

Uma das primeiras coisas a fazer depois dos pacotes instalados é configurar o seu mouse. Isso pode ser feito de diferentes maneiras (iremos passar duas)

3.1. O jeito fácil

Utilize o comando "mouseconfig". É só selecionar o tipo do seu mouse e deixar com que o rc.gpm seja executado na inicialização do sistema.

O programa irá editar o arquivo /etc/rc.d/rc.gpm e fazer um link do /dev/mouse para o dispositivo correto para o seu tipo de mouse. Particularmente, esta é uma ótima maneira de configurar o seu mouse e não compensa fazer o "jeito difícil", talvez apenas para saber como as coisas são feitas...

3.2. O jeito difícil

Para quem quer fazer isso na mão, os dispositivos para o mouse são:

• /dev/ttyS* - para mouses seriais
• /dev/psaux - para mouse PS/2
• /dev/input/mouse* - para mouse USB

Onde está "*" você deve substituir pela porta correta. Normalmente os mouses seriais estão conectados na ttyS0 (COM1) e, para o mouse USB, você pode utilizar o /dev/input/mice que é uma união de todos os mouse*.

O link é feito da seguinte maneira:

	# ln -s /dispositivo/do/seu/mouse /dev/mouse

Dentro do arquivo /etc/rc.d/rc.gpm o importante é a linha de comando para a execução do gpm, esta linha especifica o dispositivo a ser utilizado e o tipo do mouse:

	gpm -m /dev/mouse -t imps2

Este comando irá usar o /dev/mouse (por isso fizemos aquele link) e o tipo do mouse será IMPS/2 (mouse com "rodinha"). Os tipos mais comuns de mouse são:

• ms, bare, pnp - mouses seriais (tente nesta ordem)
• ps2 - mouse PS/2 e USB (sem rodinha)
• imps2 - mouse PS/2 e USB (com rodinha)

Claro, você pode dar azar e ter algum mouse que use outro protocolo, neste caso, uma leitura na página de manual do gpm pode ajudar (ou use logo o mouseconfig ao invés de ficar correndo atrás disso).

Você pode então criar o seu próprio /etc/rc.d/rc.gpm (ou editar o que já existe lá) com a linha de comando encontrada, ou colocar esta linha no seu /etc/rc.d/rc.local (ou onde achar melhor, mas que seja executado durante a inicialização da máquina). Um modelo rápido de rc.gpm:

	#!/bin/sh
	#
	# rc.gpm
	#
	case $1 in
		'stop')
			/usr/sbin/gpm -k
		;;
		*)
			/usr/sbin/gpm -m /dev/mouse -t imps2
		;;
	esac

Ok, é um modelo tosco, mas funciona. Lembre que este script deve ser um executável.

4. Botando a mão na massa

Depois do mouse configurado e da certeza de que o gpm está sendo executado, vamos à nossa solução.

A única coisa que nossa solução precisa fazer é executar um comando para cada botão do mouse. Para isso, vamos filtrar a saída do "mev" e, com o "awk" identificar o botão que foi pressionado e chamar o comando que queremos.

4.1. mev

Se quiser dar uma olhada, execute o comando "mev" e veja a saída dele (movimente o mouse e pressione os seus botões):

	# mev
	mouse: event 0x01, at 66,20 (delta  0, 0), buttons 0, modifiers 0x00
	mouse: event 0x14, at 66,20 (delta  0, 0), buttons 4, modifiers 0x00
	mouse: event 0x18, at 66,20 (delta  0, 0), buttons 4, modifiers 0x00
	mouse: event 0x14, at 66,20 (delta  0, 0), buttons 2, modifiers 0x00
	mouse: event 0x92, at 66,20 (delta  0, 0), buttons 2, modifiers 0x00
	mouse: event 0x98, at 66,20 (delta  0, 0), buttons 2, modifiers 0x00
	mouse: event 0x14, at 67,20 (delta  0, 0), buttons 1, modifiers 0x00
	mouse: event 0x18, at 67,20 (delta  0, 0), buttons 1, modifiers 0x00

CTRL+C sai do mev. Preste bastante atenção nestas linhas. Para cada botão pressionado temos duas linhas, uma indicando que o botão foi pressionado e outra avisando que ele foi solto.

Os botões possuem uma numeração em potências de dois, da direita para a esquerda. O botão direito é o 1, o do meio é o 2 e o da direita é o 4. Se forem utilizados em conjunto, será mostrada a soma dos botões, por exemplo:

	mouse: event 0x14, at 67,20 (delta  0, 0), buttons 5, modifiers 0x00
	mouse: event 0x18, at 67,20 (delta  0, 0), buttons 5, modifiers 0x00

Isto indica que foram pressionados os botões da esquerda e da direita ao mesmo tempo (4 + 1 = 5).

Agora que conhecemos o "mev", já temos uma idéia do que deve ser feito, em primeiro lugar iremos filtrar a saída dele, para que apenas o ato de pressionar o botão seja indicado, isso é feito utilizando a opção "-e".

A nossa segunda alteração, será fazer com que o "mev" apenas capture eventos que estejam ocorrendo na tty1 (que é onde os sistemas costumam ficar logo após o boot). Nossa linha de comando agora é:

	mev -C 1 -e press

4.2. awk

Agora vem a parte do "awk": identificar o botão e executar a ação que queremos de acordo com o botão selecionado. Isso é bem mais simples do que parece, já que o "awk" foi feito justamente para encontrar padrões e responder a estes padrões.

A sintaxe mais comum do "awk" é algo assim:

	awk '/padrao/ { comandos }'

O nosso padrão é a identificação de um determinado botão, olhando as linhas da saída do "mev" podemos saber exatamente o que estamos procurando: a palavra "buttons" e o número do botão logo em seguida. Com isso, o nosso programinha em "awk" seria:

	awk ' /buttons 1/ { system("shutdown -h now") }
	      /buttons 2/ { system("ppp-off") }
	      /buttons 4/ { system("ppp-on") }
	'

Com isso, quando for utilizado um dos botões, o "awk" irá chamar o comando do sistema que desejamos. O nosso último passo será juntar tudo...

4.3. Misturando tudo...

Vamos editar um script chamado "click", um bom lugar para colocá-lo é no /usr/local/bin, mas você pode colocá-lo onde quiser. O script está fartamente documentado, para que você possa saber tudo o que ele faz. Não é necessário copiar as linhas de comentário quando for escrever a sua própria versão do script (a única que deve ser preservada é a primeira, que indica a shell que deve ser executada).

	#!/usr/bin/bash
	#
	# Click
	#

	# Captura os sinais 2 e 15 (e não faz absolutamente nada). Isso
	# é necessário pq certos comandos enviam estes sinais quando terminam
	# de maneira abrupta e isso pode acabar derrubando o nosso pobre
	# script (um bom exemplo de comando que faz isso é o pppd)
	#
	trap true 2 15

	# Aguarda alguns instantes antes de começar. Isso é bom para garantir
	# que o gpm já esteja no ar e funcionando...
	#
	sleep 2

	# Um ciclo infinito, para no caso de algo dar errado, começar tudo de
	# novo...
	#
	while true; do
		#
		# Os nossos "mev" e "awk", juntos. A saída do "mev" é passada
		# através do pipe "|" para o awk
		#
		mev -C 1 -e press | awk '
			/buttons 1/ { system("shutdown -h now") }
			/buttons 2/ { system("ppp-off") }
			/buttons 4/ { system("ppp-on") }
			'
	done

Claro que os comandos a serem executados dependem das suas necessidades e podem ser alterados de acordo com elas. Coloque este pequeno script para ser executado no final da inicialização do seu sistema. O /etc/rc.d/rc.local parece ser um local muito apropriado, apenas insira a seguinte linha no final do arquivo:

	/usr/local/bin/click &

E pronto! O processo está concluído, agora é só nos deliciarmos com os resultados -:)

5. Conclusão

Indicamos neste artigo uma maneira simples, rápida e prática de enviar comandos para uma máquina sem monitor e teclado, através do mouse (que não ocupa espaço nenhum). Isto é útil para servidores dedicados, para iniciar e parar as suas funções, ou para o uso que cada um achar melhor.

Críticas, dúvidas e sugestões com relação a este artigo podem ser enviadas para o meu e-mail: piterpk@terra.com.br

PS> Quem gostou da idéia de executar comandos com o mouse e possui um monitor no local onde estão os computadores, pode utilizar o gpm-root ao invés da solução deste artigo. O gpm-root apresenta um menu na tela, e o usuário pode selecionar através deste menu qual ação será realizada. Obviamente, para isso, é necessário dispor de uma tela para ver o menu e escolher a opção.