Consoles virtuais no Linux

Um console virtual, ou terminal virtual, é uma combinação conceitual de um dispositivo de entrada (teclado) e um dispositivo de saída (monitor) para interface usuário-computador. É uma funcionalidade de alguns sistemas operacionais como Unix, BSD e Linux, onde o usuário pode trocar de terminal, abrindo outra interface, estando no mesmo terminal físico.

No Linux, por padrão, os seis primeiros consoles virtuais são para terminais em modo texto e do sétimo console virtual em diante são para terminais em modo gráfico. Quando o usuário inicia o sistema Linux, em modo texto ou modo gráfico, e se loga, ele está conectado ao primeiro console virtual disponível. Mas os outros consoles também estão prontos para serem usados.

Para conectar-se a um outro console, mantenha pressionada a tecla Alt à esquerda enquanto pressiona uma das teclas de função, de F1 à F6. A cada tecla de função, uma nova tela com um prompt de conexão é apresentado. É possível manter-se conectado a vários consoles e ir trocando entre eles.

Para alternar entre os consoles virtuais, no ambiente modo texto usa-se a mesma combinação de teclas Alt + Fn. No ambiente gráfico do X Window usa-se a combinação Ctrl + Alt + Fn. De uma outra forma, a combinação Alt + Seta pra Esquerda alterna para o console virtual anterior e a combinação Alt + Seta pra Direita alterna para o próximo console virtual.

Os consoles ativos são especificados pelo arquivo de configuração '/etc/sysconfig/init'. O comando 'tty' retorna o nome do terminal em que está conectado.

Usando o msmtp com o Mutt para envio de anexos

O Mutt é um programa que permite aos usuários ler, salvar e compor mensagens de e-mail, em um ambiente em modo texto. Programas deste tipo são formalmente chamados de MUA (Mail User Agent).

Para o envio de e-mail pela linha de comando com arquivos binários em anexo, o resultado é mais garantido quando utiliza-se o Mutt para formatar a mensagem. O Mutt trata adequadamente os tipos MIME e assim o recebimento do arquivo binário é devidamente reconhecido pelo programa cliente do destinatário.

O Mutt pode trabalhar com o programa msmtp para o envio das mensagens, ao invés de sua função interna de SMTP ou do sendmail, para isso é necessária uma simples configuração no seu arquivo ~/.muttrc, desde que o programa msmtp esteja devidamente configurado (veja em: http://dan-scientia.blogspot.com/2010/08/enviando-email-pela-linha-de-comando.html).

Um exemplo de configuração para o ~/.muttrc é apresentado a seguir:

set sendmail = "/usr/bin/msmtp -a gmail"
set realname = "Nome do Usuario"
set from = usuario@gmail.com
set use_from=yes
set envelope_from=yes

Toda a construção do e-mail será agora pela linha de comando do Mutt. Os principais parâmetros de entrada são:

-a arquivo
     Anexa um arquivo na mensagem usando MIME.
-b endereço
     Especifica o endereço de e-mail para cópia oculta (Bcc).
-c endereço
     Especifica o endereço de e-mail para cópia (Cc).
-H rascunho
     Especifica um arquivo de rascunho com os dados do cabeçalho e corpo da mensagem.
-i arquivo
     Especifica um arquivo texto para incluir no corpo da mensagem.
-s assunto
     Especifica o assunto da mensagem.
--   Marca o final dos parâmetros. Obrigatório quando usa-se o parâmetro -a pois separa os nomes dos arquivos dos endereços de e-mail.

Para compor uma nova mensagem pode-se usar uma linha de comando semelhante a abaixo:

$ mutt -c fulano@provedor.com.br -i arquivo.txt -s "Assunto da mensagem" -a foto.jpg -- destinatario@provedor.com.br

Com o comando acima o Mutt abrirá um editor para confirmar os itens de cabeçalho e corpo da mensagem. Para automatizar o envio do e-mail e assim não abrir o editor do Mutt, podemos utilizar uma mensagem pré preparada em um arquivo texto, para compor o corpo da mensagem, e direcioná-la para o programa Mutt:

$ cat mensagem.txt | mutt -c fulano@provedor.com.br -s "Assunto da mensagem" -a foto.jpg -- destinatario@provedor.com.br

O próximo exemplo faz uso do parâmetro -i para inserir o texto no corpo da mensagem porém direciona o dispositivo nulo (ele retorna uma indicação de final de arquivo) na edição do Mutt, para automatizar o envio.

$ mutt -c fulano@provedor.com.br -i mensagem.txt -s "Assunto da mensagem" -a foto.jpg -- destinatario@provedor.com.br < /dev/null

E o exemplo a seguir utiliza o parâmetro -H que recebe um arquivo texto contendo toda a estrutura para o cabeçalho e corpo do e-mail, chamado arquivo de rascunho:

$ mutt -H email.txt -a foto.jpg < /dev/null

O conteúdo para este arquivo de rascunho segue o modelo abaixo:

To: fulano@provedor.com.br, sicrano@provedor.com.br
Cc: beltrano@provedor.com.br
Bcc: johndoe@provedor.com.br
From: usuario@gmail.com
Subject: Assunto do e-mail

Texto do corpo da mensagem.

Outra opção para automatizar o envio é redigir a mensagem na própria linha de comando:

$ echo "Texto do corpo da mensagem." | mutt -c fulano@provedor.com.br -s "Assunto da mensagem" -a foto.jpg -- destinatario@provedor.com.br

O Mutt é um programa cliente de e-mail completo, com diversas diretivas para configuração e personalização. Seu ambiente, em modo texto, é controlado completamente pelo teclado e possui tudo o que é necessário para um software cliente de e-mail. Como visto neste artigo, somente por sua linha de comando já é possível enviar um e-mail automaticamente, isto pode ser útil em um shell script.

Se você acabar entrando no ambiente de edição do Mutt, será necessário conhecer as teclas dos comandos para operar o ambiente. Quem sabe num próximo artigo.

Mais informações em http://www.mutt.org/ ou nas páginas manuais do Mutt.

Enviando email pela linha de comando usando o msmtp

O msmtp é um cliente de SMTP que em seu modo de operação padrão transmite um e-mail para um servidor SMTP, por exemplo para seu provedor, que faz a entrega. Pode ser usado por um programa cliente de e-mail (MUA) e é compatível com o programa sendmail. Dentre outros atributos o msmtp pode trabalhar com diversos métodos de autenticação e com múltiplas contas de e-mail.

O msmtp é executado pela linha de comando e pode ser configurado por arquivo alcançável em todo o sistema (/etc/msmtprc), por arquivo restrito ao usuário (~/.msmtprc) ou diretamente por parâmetros na linha de comando. Um exemplo de conteúdo para o arquivo de configuração é o apresentado a seguir:

account gmail
host smtp.gmail.com
port 587
timeout off
protocol smtp
auto_from off
from usuario@gmail.com
maildomain gmail.com
auth on
user usuario
password suasenha
tls on
tls_starttls on
tls_certcheck off
logfile ~/.msmtp.log
syslog LOG_MAIL

account default: gmail

Este exemplo serve para o servidor SMTP do Gmail. Múltiplas contas podem ser configuradas neste arquivo, identificadas pela linha "account nome_da_conta". É recomemdável proteger o arquivo de configuração do msmtp com permissões de leitura e escrita somente para o próprio usuário (0600, -rw-------), senão a senha ficará exposta aos outros usuários.

O msmtp possui muitas opções para sua linha de comando mas basicamente o comando pode ser "msmtp " se o arquivo de configuração existir. Com este comando simples o programa inicia um prompt para a entrada do conteúdo do e-mail, para o cabeçalho e corpo. A combinação de teclas "Ctrl+D" encerra esta edição. Entretanto, pode ser mais prático utilizar um arquivo texto contendo toda esta estrutura de mensagem e direcioná-lo para a entrada padrão do msmtp. Um exemplo de como pode ser este arquivo texto é apresentado abaixo:

To: fulano@provedor.com.br, sicrano@provedor.com.br
Cc: beltrano@provedor.com.br
Bcc: johndoe@provedor.com.br
From: usuario@gmail.com
Subject: Assunto do e-mail

Texto do corpo da mensagem.

A linha de comando do msmtp ficaria então desta forma:

$ msmtp --read-recipients < email.txt

Para não utilizar um arquivo de configuração é necessário passar todos os dados do servidor SMTP pela linha de comando do msmtp. Aproveitando o exemplo da conta do Gmail mostrado anteriormente, a seguir está o exemplo da linha de comando equivalente:

$ msmtp --host=smtp.gmail.com --port=587 --timeout=off --protocol=smtp --auto-from=off --from=usuario@gmail.com --maildomain=gmail.com --auth=on --user=usuario --tls=on --tls-starttls=on --tls-certcheck=off --syslog=LOG_MAIL --read-recipients < email.txt

A senha do servidor não é passada pela linha de comando, ela é solicitada pelo msmtp em um prompt semelhante ao abaixo:

password for usuario at smtp.gmail.com:

Outros parâmetros poderão ser úteis, o parâmetro --file=arquivo é usado para indicar outro arquivo de configuração ao invés do padrão e --account=nomedaconta para indicar outra conta de e-mail ao invés da conta padrão.

O conteúdo de uma mensagem de e-mail é sempre em texto ASCII, porém é possível anexar um conteúdo binário no corpo da mensagem. Um arquivo binário pode ser codificado para o formato ASCII por ferramentas como o uuencode ou o uuenview, este último mais poderoso. A linha de comando para um e-mail com anexo binário pode ser como no exemplo a seguir:

$ (cat email.txt; uuenview foto.jpg) | msmtp --read-recipients

Neste exemplo tanto o conteúdo do arquivo email.txt como o resultado da codificação do arquivo foto.jpg são canalizados para a entrada padrão do comando msmtp. Contudo, aqui tem uma ressalva, o programa msmtp não trata garantidamente os tipos MIME e, dependendo do programa cliente ou provedor que irá receber a mensagem, o arquivo anexo poderá não ser reconhecido no recebimento. Por exemplo, em testes feitos por mim, contas do Gmail e do Yahoo receberam adequadamente mas a conta do Terra não. A solução garantida é utilizar outra ferramenta para formatar o e-mail e trabalhar em parceria com o msmtp, no envio. Uma boa ferramenta para linha de comando é o Mutt, que será descrito em um próximo artigo.

Mais informações em http://msmtp.sourceforge.net/ ou nas páginas manuais do msmtp.

Teclado musical para PC speaker

Até o início dos anos 90, os micro-computadores compatíveis com o IBM PC utilizavam o PC speaker para reproduzir músicas polifônicas ou efeitos sonoros. Com a criação das placas de som, capazes de reproduzirem sons complexos independentemente da CPU, o PC speaker ficou com seu uso basicamente no processo de inicialização da máquina ou em terminais em modo texto, para comunicação de códigos de erro, avisos etc.

O PC speaker cria ondas sonoras usando o Intel 8253/8254, um chip Temporizador de Intervalo Programável (Programmable Interval Timer, PIT). O PIT é o mais antigo temporizador usado nos IBM PC compatíveis. É usado para execução de funções de contagem e cronometragem através de um oscilador de cristal de 1,193182 MHz e contém três contadores: o contador 0 é usado pelo sistema operacional para o tempo do sistema; o contador 1 foi usado historicamente para a RAM; e o contador 2 é usado pelo PC speaker. Nos PCs x86 modernos o PIT não está mais incluído em um chip separado, sua funcionalidade está incluída no chipset "southbridge" da placa mãe.

O programa abaixo explora um recurso disponível nos terminais que é a reprodução de "beep" pelo PC speaker. A função ioctl(), da linguagem C, fornece uma interface para a manipulação do terminal e o argumento "KIOCSOUND" desta função gera um som no PC speaker.

O código fonte apresentado a seguir é uma versão bem simplificada e foi baseado no programa Beep (http://www.johnath.com/beep/). Contém apenas o necessário para a reprodução dos sons e com uma interface básica para o usuário. Está adequado para ser compilado no ambiente Linux. Por razões de segurança do sistema, provavelmente somente o root tem permissão de acesso ao dispositivo "/dev/sonsole", sendo assim, um usuário comum não conseguirá reproduzir som, a não ser que faça algumas alterações no ambiente. Segue o código:

/*
  Teclado musical para o speaker interno, em ambiente Linux.
  Compilar com o camando: gcc teclado-musical.c -o teclado-musical
*/

#include <fcntl.h>       /* O_WRONLY */
#include <stdio.h>       /* fprintf, stderr, printf */
#include <stdlib.h>      /* exit */
#include <unistd.h>      /* STDIN_FILENO */
#include <linux/kd.h>    /* KIOCSOUND */
#include <termios.h>     /* ICANON, ECHO, TCSANOW */

#define CLOCK_TICK_RATE 1193182  /* Frequência do oscilador do chip i8254
da placa mãe, em Hz */
#define DURACAO_PADRAO  200  /* Em milisegundos */

#define DO  262  /* Frequências das notas */
#define RE  294
#define MI  330
#define FA  349
#define SOL 392
#define LA  440
#define SI  494

#define ESC 27  /* Valor decimal ASCII da tecla de saída do programa */

char meugetch() {  /* Função que substitui o getchar() para não emitir echo
na tela e ser necessário o <enter> */
  
  struct termios tant, tnovo; /* Cria as variáveis com a estrutura termios */
  
  char ch;
  
  tcgetattr( STDIN_FILENO, &tant );  /* Backup dos atributos do terminal
  atual */
  tnovo = tant;  /* Cópia dos atributos atuais para um novo terminal */
  tnovo.c_lflag &= ~( ICANON | ECHO );  /* Desativa caracteres especiais
  e o echo no modo local */
  tcsetattr( STDIN_FILENO, TCSANOW, &tnovo );  /* Usa imediatamente os
  novos atributos */
  ch = getchar();  /* Lê um caractere do teclado */
  tcsetattr( STDIN_FILENO, TCSANOW, &tant );  /* Usa de volta os
  atributos anteriores */
  
  return ch;
}

void toca_nota(int freq, int duracao) {  /* Reproduz o som no console */

  int console_fd;  /* Se a variável receber -1 significa que o arquivo não
  pode ser aberto */

  if((console_fd = open("/dev/console", O_WRONLY)) == -1) {  /* Abre o
    console para somente escrita e checa se não houve erro */
    fprintf(stderr, "Impossivel abrir /dev/console para escrita.\n");
    /* Imprime na saída de erro */
    perror("open");  /* Imprime a mensagem de erro na saída de erro
    padrão */
    exit(1);  /* Saída com erro */
  }

  if(ioctl(console_fd, KIOCSOUND, (int)(CLOCK_TICK_RATE/freq)) < 0) {
    /* Gera o som no console */
    perror("ioctl");  /* Imprime a mensagem de erro na saída de erro
    padrão */
  }
  
  usleep(1000*duracao);  /* Tempo de espera para a duração do som */
  ioctl(console_fd, KIOCSOUND, 0);  /* Encerra o som */
  close(console_fd);  /* Fecha o uso da escrita no console */

}

int main() {
  
  char tecla;

  printf("Digite teclas zxcvbnm para notas\nou ESC para sair\n");
  do{
    tecla = meugetch();
    switch(tecla){
      case 'z':
         toca_nota(DO,DURACAO_PADRAO);
         break;
      case 'x':
         toca_nota(RE,DURACAO_PADRAO);
         break;
      case 'c':
         toca_nota(MI,DURACAO_PADRAO);
         break;
      case 'v':
         toca_nota(FA,DURACAO_PADRAO);
         break;
      case 'b':
         toca_nota(SOL,DURACAO_PADRAO);
         break;
      case 'n':
         toca_nota(LA,DURACAO_PADRAO);
         break;
      case 'm':
         toca_nota(SI,DURACAO_PADRAO);
         break;
    }
  }while(tecla != ESC);
  
  return 0;
}

A função meugetch() não é necessária para a reprodução de som pelo PC speaker, o que ela faz é tratar a entrada pelo teclado para que não seja necessário pressionar a tecla Enter em cada nota. Caso prefira, com a biblioteca ncurses também é possível aprimorar esta entrada pelo teclado.

Enviando email pela linha de comando usando o sSMTP

O sSMTP é um programa para Linux capaz de enviar um e-mail via um agente de transporte de e-mail (MTA) externo, sendo uma opção para as mensagens de correio do sistema, como também para enviar mensagens pela linha de comando.

Primeiro instale, caso ainda não esteja, o pacote do sSMTP em seu sistema. Na distro Fedora pode ser com o comando "yum install ssmtp" digitado no prompt do console.

Edite o arquivo de configuração "/etc/ssmtp/ssmtp.conf" de acordo com o seu servidor SMTP. O exemplo abaixo serve para o Gmail.com:

root=seunome@gmail.com
mailhub=smtp.gmail.com:465
RewriteDomain=gmail.com
Hostname=localhost
FromLineOverride=YES
UseTLS=YES
AuthUser=seunome@gmail.com
AuthPass=suasenha

Uma recomendação é proteger o arquivo de configuração para que nenhum usuário em sua máquina consiga ler. Faça com o comando abaixo:

# chmod 600 /etc/ssmtp/ssmtp.conf

Para enviar um e-mail basta executar o comando "ssmtp" como super-usuário, ele apresentará um prompt para a entrada da mensagem. Digite como no modelo abaixo, sendo necessário pular uma linha entre o cabeçalho e o corpo da mensagem:

To: email-destino@dominio.com
From: seunome@gmail.com
Subject: Seu assunto

Pule uma linha e escreva aqui sua mensagem.
Pressionando Enter adiciona outra linha no corpo.

Para encerrar pressione as teclas "Ctrl+D". O sSMTP irá enviar então sua mensagem.

Outra opção para gerar o e-mail é criar um arquivo texto colocando em seu conteúdo a sua mensagem, respeitando a mesma estrutura. Desta forma direcione o arquivo texto para o comando do sSMTP em sua execução. Como abaixo:

# ssmtp email-destino@dominio.com < email.txt

Para que um usuário sem privilégios de administrador possa enviar e-mails com o sSMTP, é necessário que o usuário tenha o seu próprio arquivo de configuração do sSMTP e então acioná-lo na execução do comando. Veja exemplo:

$ ssmtp -C ssmtp.conf email-destino@dominio.com < email.txt

A utilidade deste uso do sSMTP pode estar, por exemplo, em fazer sua máquina enviar avisos automaticamente quando você estiver longe dela, simplesmente recebendo e-mails.