Dois scripts para facilitar a vida com o qmail freebsd

qmail-fila

qmail-adm

Créditos FreeBSD Brasil

#!/bin/sh

dominio=”@dominio.com.br”

main()
{
clear
echo “======= Gerenciamento auxiliar do MTA QMAIL =======”
echo “===================================================”
echo “Opcoes:”
echo
echo “1 – Listar todas as mensagens na fila.”
echo “2 – Listar todas as mensagens na fila Remota.”
echo “3 – Listar todas as mensagens na fila Local.”
echo “4 – Mostrar STATUS das filas do Qmail.”
echo “5 – Ver o conteudo de uma mensagem especifica.”
echo “6 – Apagar uma mensagem especifica da fila.”
echo “7 – Apagar mensagens com um Assunto (Subject: ) especifico.”
echo “8 – Apagar mensagens com Remetente (From: ) especifico.”
echo “9 – Apagar mensagens com Destinario (To: ) especifico.”
echo “10 – Apagar TODAS as mensagens das filas do Qmail.”
echo “11 – Sair.”
echo “15 – Avancado.”
echo -n “Qual opcao voce deseja? ”
read opcao
case $opcao in
1) listar_todas ;;
2) listar_r ;;
3) listar_l ;;
4) status ;;
5) ver_msg ;;
6) apaga_msg ;;
7) subject ;;
8) from ;;
9) to ;;
10) apagar_todas ;;
11) exit ;;
15) menu_avancado ;;
*) echo “Opcao desconhecida.” ; echo ; main ;;
esac
}

###### funcoes auxiliares

restart_qmail()
{
svc -k /service/qmail
svc -u /service/qmail
}

status ()
{
echo “”
echo “Status atual do Qmail: ”
echo “”
sleep 2
fila-qmail -s
echo “”
/var/qmail/bin/qmail-qstat
echo “”
svstat /service/qmail
echo “”
}

remotas_locais()
{
echo “”
echo -n ” Mensagens Remotas ou Locais? [R/L]: ”
read ROL

case ${ROL} in
[Rr])
ROLRESP=”R”
;;
[Ll])
ROLRESP=”L”
;;
*)
remotas_locais
;;
esac
}

#### funcoes principais

listar_todas()
{
echo “”
echo “Listando as mensagens nas filas Remota e Local: ”
fila-qmail -l
echo “”
}

listar_r()
{
echo””
echo “Listando as mensagens na fila Remota: ”
fila-qmail -R
echo “”
}

listar_l()
{
echo “”
echo “Listando as mensagens na fila Local: ”
fila-qmail -L
echo “”
}

ver_msg()
{
echo “”
echo ” O numero de Identificacao da mensagem – Msg ID – pode ser”
echo “identificado como o primeiro numero que precede um email,”
echo “quando as mensagens nas filas sao listadas.”
echo “”
echo ” Por exemplo:”
echo ” 762178 [14, R] – O primeiro numero, fora dos parenteses,”
echo ” indica o numero da mensagem. Nesse caso, 762178.”
echo “”
echo -n ” Deseja visualizar o conteudo da mensagem numero: ”
read NROMSG

echo “”
fila-qmail -v${NROMSG} | less

}

apaga_msg()
{
echo “”
echo ” O numero de Identificacao da mensagem – Msg ID – pode ser”
echo “identificado como o primeiro numero que precede um email,”
echo “quando as mensagens nas filas sao listadas.”
echo “”
echo ” Por exemplo:”
echo ” 762178 [14, R] – O primeiro numero, fora dos parenteses,”
echo ” indica o numero da mensagem. Nesse caso, 762178.”
echo “”
echo -n ” Deseja apagar qual mensagem da fila? ”
read NROMSG

fila-qmail -d${NROMSG}

restart_qmail
status

}

subject()
{
echo “”
echo ” Para maior praticidade, a pesquisa sera Case Insensitive,”
echo “nao diferenciando letras maiusculas de letras minusculas.”
echo “”
echo -n ” Deseja apagar todas as mensagens com qual Assunto [Subject: ] ”
read ASSUNTO

remotas_locais

fila-qmail -c -l | \
grep -i -B 4 “${ASSUNTO}” | \
grep “, ${ROLRESP}” | awk ‘{print “echo \”Apagando mensagem “$1″\” ; ” “fila-qmail -d”$1}’ > /tmp/XyZkPPty

sh /tmp/XyZkPPty
COUNT=”`cat /tmp/XyZkPPty | wc -l`”
rm -f /tmp/XyZkPPty

echo “”
echo ” Foram apagadas ${COUNT} mensagens que continham”
echo “a expressao ‘${ASSUNTO}’ como parte do Assunto…”
echo “”
echo “Reiniciando o Qmail…”

restart_qmail
status
}

from()
{
echo “”
echo ” Para maior praticidade, a pesquisa sera Case Insensitive,”
echo “nao diferenciando letras maiusculas de letras minusculas.”
echo “”
echo -n ” Deseja apagar todas as mensagens de qual Remetente [From: ] ”
read FROM

remotas_locais

fila-qmail -c -l | \
grep -i -B 2 “${FROM}” | \
grep “, ${ROLRESP}” | awk ‘{print “echo \”Apagando mensagem “$1″\” ; ” “fila-qmail -d”$1}’ > /tmp/XyZkPPty

sh /tmp/XyZkPPty
COUNT=”`cat /tmp/XyZkPPty | wc -l`”
rm -f /tmp/XyZkPPty

echo “”
echo ” Foram apagadas ${COUNT} mensagens que continham”
echo “a expressao ‘${FROM}’ como parte do endereco do Remetente…”
echo “”
echo “Reiniciando o Qmail…”

restart_qmail
status
}

to()
{
echo “”
echo ” Para maior praticidade, a pesquisa sera Case Insensitive,”
echo “nao diferenciando letras maiusculas de letras minusculas.”
echo “”
echo -n ” Deseja apagar todas as mensagens de qual Destinatario [To: ] ”
read TO

remotas_locais

fila-qmail -c -l | \
grep -i -B 3 “${TO}” | \
grep “, ${ROLRESP}” | awk ‘{print “echo \”Apagando mensagem “$1″\” ; ” “fila-qmail -d”$1}’ > /tmp/XyZkPPty

sh /tmp/XyZkPPty
COUNT=”`cat /tmp/XyZkPPty | wc -l`”
rm -f /tmp/XyZkPPty

echo “”
echo ” Foram apagadas ${COUNT} mensagens que continham”
echo “a expressao ‘${TO}’ como parte do endereco do Remetente…”
echo “”
echo “Reiniciando o Qmail…”

restart_qmail
status
}

apagar_todas()
{
echo “”
echo ” Todas as mensagens de todas as filas do QMail serao apagadas.”
echo “”
echo -n ” Deseja mesmo continuar? [S/N] ”

read SIMNAO

case ${SIMNAO} in
[Ss])

fila-qmail -D && \
restart_qmail && \
status
;;

*)
echo “”
echo “Saindo…”
;;
esac

}

virus_dat_version() {
echo “”
/usr/local/bin/uvscan –version | grep -v “EVALUATION”
echo “”
}

############## Menu Avancado ###############
## Nao tem nada de Avancado mas nao deve ##
## ser usado por quem nao sabe como ele ##
## funciona… enfim, leiam as man pages ##
## do svc, do svscan, svstat e o resto do ##
## Daemontools inteiro… ##
############################################

menu_avancado()
{
clear
echo “===== Controle dos servicos de e-mail =====”
echo “”
echo “Servico qmail-send [modulo nivel 1]:”
echo “”
echo “01 – Matar o qmail-send.”
echo “02 – Iniciar o qmail-send.”
echo “03 – Reprocessar as filas de email.”
echo “04 – STATUS do qmail-send e das filas de e-mail.”
echo “05 – Reiniciar o Qmail [qmail-send].”
echo “06 – Verificar os logs do qmail-send.”
echo “07 – Verificar os logs do qmail-queue.”
echo “”
echo “”
echo “Servico Qmail SMTP:”
echo “10 – Matar o daemon SMTP.”
echo “11 – Iniciar o daemon SMTP.”
echo “12 – STATUS do daemon SMTP.”
echo “13 – Reiniciar o daemon SMTP.”
echo “14 – Verificar os logs do SMTP.”
echo “”
echo “”
echo “Servico Qmail POP3:”
echo “20 – Matar o daemon POP3.”
echo “21 – Iniciar o daemon POP3.”
echo “22 – STATUS do daemon POP3.”
echo “23 – Reiniciar o daemon POP3.”
echo “24 – Verificar os logs do POP3.”
echo “”
echo “”
echo “Anti Virus:”
echo “30 – Logs dos ultimos virus encontrados.”
echo “31 – Logs do qmail-queue junto ao antivirus.”
echo “32 – Apagar todas as mensagens com virus do Quarantine.”
echo “33 – Apagar todas as mensagens com virus verificadas agora.”
echo “34 – Contar virus encontrados.”
echo “35 – Mostrar as definicoes (dat-version) de virus atuais.”
echo “”
echo “”
echo “Servico Courier-IMAP:”
echo “36 – Para o servico IMAP (caso instalado).”
echo “37 – Inicia o servico IMAP (caso instalado).”
echo “38 – Verificar os logs do IMAP (caso instalado).”
echo “”
echo “”
echo “50 – Sair.”
echo -n “Qual opcao voce deseja? ”
read opctao
case $opctao in
01) kill_qsend ;;
02) up_qsend ;;
03) alrm_queue ;;
04) status ;;
05) qmailrestart ;;
06) qsend_logs ;;
07) queue_logs ;;
10) kill_smtp ;;
11) up_smtp ;;
12) status_smtp ;;
13) restart_smtp ;;
14) qsmtp_logs ;;
20) kill_pop3 ;;
21) up_pop3 ;;
22) status_pop3 ;;
23) restart_pop3 ;;
24) qpop3_logs ;;
30) virus_log ;;
31) queue_logs ;;
32) rm_quarantine ;;
33) rm_working ;;
34) virus_count ;;
35) virus_dat_version ;;
36) stop_imapd ;;
37) start_imapd ;;
38) vlogs_imapd ;;
50) exit ;;
*) echo “Opcao desconhecida.” ; echo ; main ;;
esac
}

kill_qsend()
{
echo “”
echo -n ” Matando o Qmail [qmail-send]…”
svc -k /service/qmail
echo ” OK”
echo “”
exit
}

up_qsend()
{
echo “”
echo “Iniciando o Qmail [qmail-send]…”
svc -u /service/qmail
echo ” O qmail-send foi iniciado e esta supervisionado.”
echo “”
exit
}

alrm_queue()
{
echo “”
echo ” Reprocessando todas as mensagens nas filas Locais e Remotas”
svc -a /service/qmail
echo ” Pronto.”
exit
}

qmailrestart()
{
echo “”
echo -n ” Forcando a reinicializacao do Qmail… ”
restart_qmail
echo “OK”
echo “”
echo ” O Qmail foi reiniciado e deve estar no ar,”.
echo ” verifique o status do MTA:”
status
exit
}

qsend_logs()
{
echo “”
echo -n ” Quantas linhas de log do Qmail voce deseja analisar? ”
read linhaslog
echo “”
echo ” Analisando as ultimas ${linhaslog} linhas dos logs do qmail: ”
echo “”
tail -${linhaslog} /var/log/qmail/current
exit
}

queue_logs()
{
echo “”
echo -n ” Quantas linhas de log do qmail-queue voce deseja analisar? ”
read logqueue
echo “”
echo ” Analisando as ultimas ${logqueue} linhas dos logs do qmail-queue: ”
echo “”
tail -${logqueue} /var/spool/qmailscan/qmail-queue.log
exit
}

kill_smtp()
{
echo “”
echo -n ” Matando o Qmail SMTP [qmail-smtpd]…”
svc -k /service/smtpd
echo ” OK”
echo “”
exit
}

up_smtp()
{
echo “”
echo “Iniciando o Qmail SMTP [qmail-smtpd]…”
svc -u /service/smtpd
echo ” O qmail-smtpd foi iniciado e esta sendo supervisionado.”
echo “”
exit
}

status_smtp()
{
echo “”
echo ” Status do daemon SMTP [qmail-smtpd]: ”
svstat /service/smtpd
exit
}

restart_smtp()
{
echo “”
echo ” Forcando a reinicializacao do daemon SMTP [qmail-smtpd]… ”
kill_smtp
up_smtp
}

qsmtp_logs()
{
echo “”
echo -n ” Quantas linhas de logs do qmail-smtpd voce deseja analisar? ”
read smtplogs
echo ” Analisando as ultimas ${smtplogs} linhas de logs do qmail-smtpd: ”
echo “”
tail -${smtplogs} /service/smtpd/log/main/current
exit
}

kill_pop3()
{
echo “”
echo -n ” Matando o Qmail POP3 [qmail-pop3d]…”
svc -k /service/pop3d
echo ” OK”
echo “”
exit
}

up_pop3()
{
echo “”
echo “Iniciando o Qmail POP3 [qmail-pop3d]…”
svc -u /service/pop3d
echo ” O qmail-pop3d foi iniciado e esta sendo supervisionado.”
echo “”
exit
}

status_pop3()
{
echo “”
echo ” Status do daemon POP3 [qmail-pop3d]: ”
svstat /service/pop3d
exit
}

restart_pop3()
{
echo “”
echo “Forcando a reinicializacao do daemon POP3 [qmail-pop3d]… ”
kill_pop3
up_pop3
}

qpop3_logs()
{
echo “”
echo -n ” Quantas linhas de logs do qmail-pop3d voce deseja analisar? ”
read pop3logs
echo ” Analisando as ultimas ${pop3logs} linhas de logs do qmail-pop3d: ”
echo “”
tail -${pop3logs} /service/pop3d/log/main/current
exit
}

virus_log()
{
echo “”
echo -n ” Quantas linhas de logs de virus encontrados voce deseja analisar? ”
read viruslog
echo ” Analisando as ultimas ${viruslog} linhas de logs sobre virus encontrados:”
echo “”
tail -${viruslog} /var/spool/qmailscan/viruses.log
exit
}

rm_quarantine()
{
echo “”
echo ” Apagando todos os emails armazenados em quarentena… ”
find /var/spool/qmailscan/quarantine/ -name “*${dominio}*” -exec rm -f {} \;
echo ” Apagados!”
exit
}

rm_working()
{
echo “”
echo ” Apagando todas as mensagens verificadas por virus ha pouco…”
find /var/spool/qmailscan/working/ -name “*${dominio}*” -exec rm -f {} \;
echo ” Apagados!”
exit
}

virus_count()
{
echo “”
echo ” Total de virus interceptados segundo os logs recentes: ”
cat /var/spool/qmailscan/viruses.log | grep uvscan | wc -l
echo ” Virus!”
exit
}

stop_imapd()
{
echo “”
if [ -x /usr/local/etc/rc.d/imapd.sh ]; then
echo -n “Parando Courier-IMAP…”
/usr/local/etc/rc.d/imapd.sh stop
echo ” OK”
else
echo “O courier-imap nao parece estar corretamente”
echo “configurado via ports… Saindo.”
fi
echo “”
exit
}

start_imapd()
{
echo “”
if [ -x /usr/local/etc/rc.d/imapd.sh ]; then
echo -n “Iniciando Courier-IMAP…”
/usr/local/etc/rc.d/imapd.sh start
echo ” OK”
else
echo “O courier-imap nao parece estar corretamente”
echo “configurado via ports… Saindo.”
fi
echo “”
exit
}

vlogs_imapd()
{
echo “”
echo -n ” Quantas linhas de logs do courier-imap voce deseja analisar? ”
read imaplog
echo ” Analisando as ultimas ${imaplog} linhas de logs do courier-imap:”
echo “”
grep -i “imapd:” -C1 /var/log/maillog | tail -${imaplog}
echo “”
exit
}

# Inicia esse programa em shell
main

——————————

#!/usr/bin/perl
#
# fila-qmail – programa pra gerenciar a complexa e poderosa fila de mensagens
# locais e remotas do MTA Qmail.
##
# Baseado no script de Kasperv e Michelle algumacoisa…
##
# FreeBSD, Qmail, Vpopmail, Qmail-scanner, spamassassin, Daemontools,
# McAfee UVScan – Unix Virus Scanner, Mysql, e o necessario pra isso tudo funcionar junto.

use strict;
use diagnostics;

my ($CID) = ‘dominio.com.br';

#################### Variaveis que PODEM ser alteradas pela usuario.

#####
# Caminho completo pro seu diretorio de filas do qmail…
my ($queue) = ‘/var/qmail/queue/';

#####
# Se voce possuir algum script ou comando externo que inicie e mate
# o seu Qmail, entao defina-os nas variaveis $stopmail e $startmail
# NAO pode haver mais de uma variavel com esses nomes.

# Caso voce utilize o Daemontools…
my ($stopqmail) = ‘/usr/local/bin/svc -d /service/qmail';
my ($startqmail) = ‘/usr/local/bin/svc -u /service/qmail';

# Se preferir, deixe eu matar o qmail sozinho.
# my ($stopqmail) = ”;

#####
# Defina aqui o comando ou script que retorne o PID do qmail-send
# pidof pode ser instalado pelo Ports do FreeBSD
#my ($pidcmd) = ‘pidof qmail-send';

######################################################
# DAQUI PRA BAIXO COMECA O PROGRAMA. NAO MEXA MUITO #
# SE NAO SOUBER OQ ESTAS FAZENDO… #
######################################################

# Se nao existir protousuario input
if ($#ARGV == -1) {
&Usage();
}

# Define variaveis globais
my ($norestart) = 0;

# Cria as listas para e-mail nas filas local e remota
my (@queues) = (“remote”, “local”);
my (@msglist) = ();
my (%type) = ();

foreach my $currentqueue (@queues) {

# Lista as mensagens de cada fila
opendir(DIR,”${queue}$currentqueue”);
my (@dirlist) = grep !/\./, readdir DIR;
closedir DIR;
foreach my $dir (@dirlist) {
opendir (SUBDIR,”${queue}${currentqueue}/$dir”);
my (@files) = grep !/\./, map “$dir/$_”, readdir SUBDIR;
foreach my $file (@files) {
push @msglist, “$file”;
($currentqueue eq “remote”) ? ($type{“$file”} = ‘R’) : ($type{“$file”} = ‘L’);
}
closedir SUBDIR;
}

}

# Verifica user-level input
my ($color) = 1;
# Saida SEMPRE colorida.

my ($summary) = 0;
my (@actions) = ();
foreach my $arg (@ARGV) {
SWITCH: {
$arg eq ‘-l’ and do { push @actions, “&ListMsg(‘A’)”; last SWITCH; };
$arg eq ‘-R’ and do { push @actions, “&ListMsg(‘L’)”; last SWITCH; };
$arg eq ‘-L’ and do { push @actions, “&ListMsg(‘R’)”; last SWITCH; };
$arg eq ‘-N’ and do { $summary = 1; last SWITCH; };
$arg eq ‘-c’ and do { $color = 0; last SWITCH; };
$arg eq ‘-s’ and do { push @actions, “&Stats()”; last SWITCH; };
$arg =~ /^-v(.+)/ and do { push @actions, “&ViewMsg($1)”; last SWITCH; };
$arg =~ /^-d(.+)/ and do { push @actions, “&DelMsg($1)”; last SWITCH; };
$arg eq ‘-D’ and do { push @actions, “&DelAll()”; last SWITCH; };
&Usage();
}
}

foreach my $action(@actions) {
eval “$action”;
}

exit(0);

sub ListMsg {
my ($q) = shift;
my (%ret, %date, %from, %subj, %to, %cc, %fsize);

if ($summary == 0) {

foreach my $msg(@msglist) {

# Descobre o return-path
open (MSG, “${queue}info/$msg”);
$ret{$msg} = ;
substr($ret{$msg}, 0, 1) = ”;
chop ($ret{$msg});
close (MSG);

# Descobre o tamanho do e-mail em disco.
$fsize{$msg} = (stat(“${queue}mess/$msg”))[7];

# Pegar dados basicos do cabecalho do e-mail
open (MSG, “${queue}mess/$msg”);
while () {
if ($_ =~ /^Date: /) {
$date{$msg} = $';
chop ($date{$msg});
} elsif ( $_ =~ /^From: /) {
$from{$msg} = $';
chop ($from{$msg});
} elsif ( $_ =~ /^Subject: /) {
$subj{$msg} = $';
chop ($subj{$msg});
} elsif ( $_ =~ /^To: /) {
$to{$msg} = $';
chop ($to{$msg});
} elsif ( $_ =~ /^Cc: /) {
$cc{$msg} = $';
chop ($cc{$msg});
} elsif ( $_ eq “\n”) {
last;
}
}
}

}

if ($color == 1) {

foreach my $msg(@msglist) {
unless ($q eq $type{$msg}) {
my ($dir, $rmsg) = split (/\//, $msg);
print chr(27).”[01;34m$rmsg ($dir, $type{$msg})\n”;
if ($summary == 0) {
defined($ret{$msg}) and print ” \e[01;31mReturn-path\e[00m: $ret{$msg}\n”;
defined($from{$msg}) and print ” \e[01;31mFrom\e[00m: $from{$msg}\n”;
defined($to{$msg}) and print ” \e[01;31mTo\e[00m: $to{$msg}\n”;
defined($cc{$msg}) and print ” \e[01;31mCc\e[00m: $cc{$msg}\n”;
defined($subj{$msg}) and print ” \e[01;31mSubject\e[00m: $subj{$msg}\n”;
defined($date{$msg}) and print ” \e[01;31mDate\e[00m: $date{$msg}\n”;
defined($fsize{$msg}) and print ” \e[01;31mSize\e[00m: $fsize{$msg} bytes\n\n”;
}
}
}

} else {

foreach my $msg(@msglist) {
unless ($q eq $type{$msg}) {
my ($dir, $rmsg) = split (/\//, $msg);
print “$rmsg ($dir, $type{$msg})\n”;
if ($summary == 0) {
defined($ret{$msg}) and print ” Return-path: $ret{$msg}\n”;
defined($from{$msg}) and print ” From: $from{$msg}\n”;
defined($to{$msg}) and print ” To: $to{$msg}\n”;
defined($cc{$msg}) and print ” Cc: $cc{$msg}\n”;
defined($subj{$msg}) and print ” Subject: $subj{$msg}\n”;
defined($date{$msg}) and print ” Date: $date{$msg}\n”;
defined($fsize{$msg}) and print ” Size: $fsize{$msg} bytes\n\n”;
}
}
}

}
&Stats();
}

# Mostra conteudo da mensagem
sub ViewMsg {
my ($rmsg) = shift;

unless ($rmsg =~ /^\d+$/) {

print “$rmsg nao e’ um numero de e-mail valido!\n”;

} else {

# Encontra o email
my ($ok) = 0;
foreach my $msg(@msglist) {
if ($msg =~ /$rmsg$/) {
$ok = 1;
print “\n ————–\n NUMERO DO E-MAIL NA FILA: $rmsg \n ————–\n\n”;
open (MSG, “${queue}mess/$msg”);
while () {
print $_;
}
close (MSG);
last;
}
}

# Se nao encontrar a msg
if ($ok == 0) {
print “Mensagem numero $rmsg nao foi encontrada na fila!\n”;

}
}

}

# Deleta uma mensagem da fila
sub DelMsg {
my ($rmsg) = shift;

unless ($rmsg =~ /^\d+$/) {

print “$rmsg nao e’ uma mensagem valida!\n”;

} else {

# Mata o qmail
&stopQmail() or die “O processo qmail nao pode ser interrompido: $!”;

# Encontra o email
my ($ok) = 0;
foreach my $msg(@msglist) {
if ($msg =~ /$rmsg$/) {
$ok = 1;
unlink “${queue}mess/$msg”;
unlink “${queue}info/$msg”;
if ($type{$msg} eq ‘R’) {
unlink “${queue}remote/$msg”;
} else {
unlink “${queue}local/$msg”;
}
last;
}
}

# Se nao achar o email,
if ($ok == 0) {
print “O e-mail $rmsg nao foi encontrado!\n”;
}

# Ressuscita Qmail
&startQmail();

}
}

# Apaga todas as mensagens de ambas as filas.
sub DelAll {
my ($rmsg) = shift;

# Para o qmail
&stopQmail() or die “O processo qmail nao pode ser interrompido: $!”;

# Search messages
my ($ok) = 0;
foreach my $msg (@msglist) {
$ok = 1;
print “Apagando o email $msg…\n”;
unlink “${queue}mess/$msg”;
unlink “${queue}info/$msg”;
if ($type{$msg} eq ‘R’) {
unlink “${queue}remote/$msg”;
} else {
unlink “${queue}local/$msg”;
}
}

# Se nao houverem mensagens…
if ($ok == 0) {
print “Nao foram encontradas mensagens nas filas!\n”;
}

# Reinicia o Qmail…
&startQmail();
}

# Stats, oras…
sub Stats {
my ($l) = 0;
my ($r) = 0;

foreach my $msg(@msglist) {
if ($type{$msg} eq ‘R’) { $r++; }
else { $l++; }
}

if ($color == 1) {
print chr(27).”[01;31mMensagens na fila Local”.chr(27).”[00m: $l\n”;
print chr(27).”[01;31mMensagens na fila Remota”.chr(27).”[00m: $r\n”;
} else {
print “Mensagens na fila Local: $l\n”;
print “Mensagens na fila Remota: $r\n”;
}
}

# Pega o processo do qmail
sub qmailPid {
my $qmpid = `/bin/ps waux | /usr/bin/grep qmail-send | /usr/bin/grep -v “/bin/ps” | /usr/bin/awk ‘{print \$2}’`;
# my $qmpid = `$pidcmd`;
chomp ($qmpid);
if ($qmpid =~ /^\d+$/) { return $qmpid; }
return 0;
}

# Mata qmail
sub stopQmail {
my ($qmpid) = &qmailPid();

# Caso Exista o PID do Qmail, vamos mata-lo.
if ($qmpid != 0) {

# Se existir um script ou comando externo para mata-lo, vamos usa-lo.
if ($stopqmail ne ”) {

print “Chamando comando externo para parar o qmail…\n”;
if (system($stopqmail) > 0) {
return 0;
}

# Senao, vamos tentar matar nos mesmos!
} else {
print “Terminando qmail (pid $qmpid)… essa operacao pode levar algum tempo caso existam mensagens sendo entregues.\n”;
kill ‘TERM’, $qmpid;

while (&qmailPid() eq “$qmpid\n”){
sleep 1;
}
}

# Se o qmail nao estiver rodando, nao vamos querer reinicia-lo depois
# evitando alteracoes no ambiente externo.
} else {
print “Qmail nao esta no ar.\n”;
$norestart = 1;
}

return 1;
}

# Starta qmail
sub startQmail {
my ($qmpid) = &qmailPid();

if ($qmpid != 0) {
print “Qmail esta ativo novamente, por isso nao sera reiniciado.\n”;

} elsif ($norestart == 1) {
print “Qmail nao estava em execussao quando o fila-qmail foi chamado, por isso nao sera reiniciado \n”;

} else {
print “Reiniciando qmail… “;
system($startqmail);
print “OK (esperamos).\n”;
}

return 1;
}

sub Usage {
print “\n”;
print chr(27).”[01;39m\n\t\t\tQmail/FreeBSD Mail Service da $CID\n”.chr(27).”[00m”;
print “\n”;
print chr(27).”[01;33m”;
print ” __ _ _ _ _ \n”;
print ” / _(_) | __ _ __ _ _ __ ___ __ _(_) | \n”;
print ” | |_| | |/ _` | _____ / _` | ‘_ ` _ \\ / _` | | | \n”;
print ” | _| | | (_| | |_____| | (_| | | | | | | (_| | | | \n”;
print ” |_| |_|_|\\__,_| \\__, |_| |_| |_|\\__,_|_|_| \n”;
print ” |_| \n”;
print chr(27).”[00m”;
print “\n”;
print chr(27).”[01;31m\t\t\tEl Super fila-qmail v0.2 da $CID\n\n”.chr(27).”[00m”;

print “\n”;
print chr(27).”[01;34mOpcoes possiveis sao:\n”.chr(27).”[00m”;
print ” -l : lista todas as mensagens nas filas remota e local.\n”;
print ” -L : lista apenas mensagens na fila local.\n”;
print ” -R : lista apenas mensagens na fila remota.\n”;
print ” -s : mostra a saida do qmail-qstat.\n”;
print ” -vN : mostra o conteudo da mensagem numero N.\n”;
print ” -dN : apaga a mensagem numero N da fila.\n”;
print ” -D : deleta todas as mensagens nas filas remota e local.\n”;

print “\n”;
print chr(27).”[01;35mOpcoes adicionais:\n”.chr(27).”[00m”;
print ” -c : NAO imprime cores – ideal para criar scripts.\n”;
print ” -N : lista apenas o numero das mensagens nas respectivas filas.\n”;
print ” (pode ser usado com -l, -L ou -R – ex: fila-qmail -N -l)\n\n”;
print “NOTA: E’ possivel executar varios comandos simultaneamente.\n\n”;
exit 1;
}

Deixe uma resposta