# Provar no log do Exim se o e-mail saiu ou foi recusado

Como reconstituir uma mensagem inteira pelo message ID de 16 caracteres com exigrep, e por que grep pelo endereço do destinatário perde as linhas que decidem o caso.

> sem medição própria aqui: o veredicto sai de três evidências no exim_mainlog. Linha `<=` prova que a mensagem entrou na fila, `=>` com `C="250 ..."` prova que o host remoto aceitou, `**` traz o código SMTP da recusa. Sem `<=`, a mensagem nunca saiu.

João Rizzon · 2026-10-29 · Servidores

---

## O que é o message ID de 16 caracteres e por que buscar pelo destinatário perde metade da história

Toda mensagem que entra na fila do Exim recebe um message ID no formato `1rXyZ0-0001aB-2C`: 16 caracteres, três blocos separados por hífen (6-6-2). Observação operacional antes de escrever qualquer regex: esse é o formato clássico da série 4.x até o 4.96, que é o que você encontra na maior parte dos servidores de hospedagem; a partir do 4.97 o Exim passou a poder gerar IDs mais longos, com mais entropia, e um `grep -E '[A-Za-z0-9]{6}-[A-Za-z0-9]{6}-[A-Za-z0-9]{2}'` deixa de casar. Rode `exim -bV` para saber a versão e confira um ID real no próprio log antes de fixar o padrão em script. Ele é gravado no terceiro campo de cada linha do `mainlog` relacionada àquela mensagem, do `<=` de entrada até o `Completed`.

O erro mais comum na auditoria é fazer `grep` pelo endereço do destinatário. Isso recupera a linha de entrada e as linhas de entrega que citam o endereço, mas perde tudo que o Exim registra sem repetir o envelope: os `==` de adiamento que só trazem o ID e o host, as linhas de `Completed`, as linhas de retry e, dependendo da configuração, as linhas de erro do transporte. Você termina com metade da história e conclui errado.

O caminho é de duas etapas: achar o ID pelo horário e pelo endereço, depois reconstituir a mensagem inteira pelo ID.

```bash
# 1) achar o ID: janela de horario primeiro, destinatario depois, ID no campo 3
grep '2026-10-07 14:' /var/log/exim_mainlog \
  | grep 'destinatario@exemplo.com' \
  | awk '{print $3}' | sort -u

# 2) reconstituir a mensagem inteira pelo ID
exigrep '1rXyZ0-0001aB-2C' /var/log/exim_mainlog
```

A ordem importa. Filtrar por hora depois do `exigrep` desfaz exatamente o que o `exigrep` faz: volta a cortar linha a linha e descarta linhas do mesmo ID que caíram fora da janela, inclusive o `<=` de uma mensagem que entrou na fila às 13h58 e só saiu às 14h12. Use `grep` só para descobrir o ID; a partir daí, nenhum filtro adicional sobre a saída do passo 2.

O `exigrep` não é um `grep` com outro nome. Ele casa o padrão e devolve **todas** as linhas do mesmo message ID, inclusive as que não contêm o padrão buscado. É exatamente a diferença que você precisa no passo 2. Em servidores com log rotacionado e comprimido, use `zcat` e mantenha a ordem cronológica dos arquivos.

## Os cinco flags do quarto campo e o que cada um prova (e não prova)

Fixe a convenção, porque ela vale para todo script daqui em diante: `$1` é a data, `$2` a hora, `$3` o message ID, `$4` o flag. Um `awk '{print $2}'` devolve a hora, não o ID. O quarto campo é o flag que diz o que aconteceu. Esses são os que decidem o veredicto:

| Marca | Evento | O que prova | O que NÃO prova |
|---|---|---|---||
| `<=` | Mensagem aceita e colocada na fila | Que o Exim recebeu a mensagem, com envelope-from, tamanho, IP de origem e, se houver, o `A=dovecot_login:usuario` | Nada sobre entrega. Só que entrou |
| `=>` | Entrega concluída para um destinatário | Que o host remoto aceitou a mensagem na sessão SMTP e devolveu código de aceite | Que a mensagem chegou à caixa de entrada. Pode ter ido para spam ou ser descartada depois |
| `->` | Destinatário adicional entregue na mesma conexão | Que mais de um RCPT seguiu o mesmo caminho da linha `=>` anterior | O mesmo que acima |
| `**` | Falha permanente (bounce) | Que o destino recusou definitivamente, normalmente com o texto SMTP devolvido pelo remoto | Que o problema é seu. O 5xx pode ser política do remoto |
| `==` | Adiamento (defer) | Que houve 4xx, timeout ou falha temporária e a mensagem continua na fila | Que falhou de vez. Pode entregar na próxima tentativa |

Há ainda o `Completed`, que marca o fim do processamento daquele ID, e linhas de rejeição na entrada (`rejected RCPT`, `rejected connection`) que nem sempre carregam message ID, porque a mensagem nunca chegou a ser enfileirada.

### Campos da linha `<=` que identificam quem enviou

- `H=` host de origem com IP e, quando resolve, PTR.
- `A=` método de autenticação e usuário. Se o `A=` está presente, o envio foi autenticado por aquela conta. É o campo que liga a mensagem a um usuário real, não ao `From:` do cabeçalho.
- `S=` tamanho em bytes.
- `id=` Message-ID do cabeçalho, útil para cruzar com o que o cliente mostra no Enviados.
- `T=` assunto, se o log estiver com `log_selector` incluindo `+subject`.

## Os três veredictos possíveis e a evidência que fecha cada um

### Saiu e foi aceito: `<=` mais `=>` com `C="250 ..."`

Existe `<=` e existe `=>` com host remoto e código de aceite. Exemplo de linha de entrega (fictício, para ilustrar o formato):

```
2026-10-07 14:12:31 1rXyZ0-0001aB-2C => destinatario@exemplo.com R=dkim_lookuphost T=dkim_remote_smtp
  H=mx.exemplo.com [203.0.113.25] C="250 2.0.0 OK 1rXyZ ..."
```

O `C=` é a resposta literal do servidor remoto. É a prova mais forte que existe do seu lado: o outro servidor assumiu a mensagem. Daqui em diante a responsabilidade é do destino, e o que acontecer com a mensagem (spam, regra de caixa, quarentena) não aparece mais no seu log. Diga isso ao cliente com essas palavras.

### Foi recusado: `**` e o que cada código 5xx significa

Existe `<=` e existe `**` com o texto do remoto. O conteúdo entre aspas é o veredicto do outro lado, não o seu. Separe o que o código diz:

- `550` com menção a usuário inexistente: endereço errado, acabou a conversa.
- `550`/`554` com menção a política, reputação ou bloqueio de IP: problema de reputação do IP de saída ou de autenticação de domínio (SPF, DKIM, DMARC).
- `552` com limite de tamanho: anexo acima do limite do destino.
- `451`/`421` aparecem como `==`, não como `**`: é defer, a mensagem ainda está na fila.

### Nunca entrou na fila: sem `<=` não existe ID para rastrear

Não existe `<=` para aquela mensagem. É o caso mais incompreendido, porque o cliente vê a mensagem em Enviados do cliente de e-mail e conclui que saiu. Procure, na janela de horário, por linhas de rejeição sem message ID: falha de autenticação SMTP, conexão recusada, limite de envio atingido, TLS que não fechou. Sem `<=`, o Exim nunca teve a mensagem. Não há o que rastrear por ID porque não existe ID.

```bash
# recusas e falhas de autenticacao na janela, sem passar pelo ID
grep '2026-10-07 14:' /var/log/exim_mainlog \
  | grep -E 'rejected|authenticator failed|Connection refused|TLS error'
```

## Por que ler o mainlog em ordem cronológica leva ao veredicto errado

O `mainlog` é um arquivo único para todas as mensagens em paralelo. As linhas de um mesmo ID aparecem intercaladas com as de dezenas de outros. Ler o arquivo em ordem cronológica e tentar montar a história visualmente é como ler uma transcrição de várias conversas simultâneas. Por isso o passo 2 com `exigrep` pelo ID não é conveniência: é o que torna a reconstituição auditável.

Um segundo detalhe: uma mensagem com vários destinatários pode ter `=>` para um e `**` para outro, no mesmo ID. O veredicto é por destinatário, não por mensagem. Ao responder ao cliente, cite o endereço junto com o resultado.

## Congelar a evidência antes do rotate, na ordem cronológica certa

O `exim_mainlog` rotaciona. Se a investigação começa dias depois, você pode estar lendo um arquivo que já perdeu o começo da história. Antes de qualquer coisa, congele a evidência:

```bash
mkdir -p /root/evidencia-1rXyZ0
cp -a /var/log/exim_mainlog* /root/evidencia-1rXyZ0/
cd /root/evidencia-1rXyZ0
# ls -tr: do arquivo mais antigo para o mais novo
zcat -f $(ls -tr exim_mainlog*) | exigrep '1rXyZ0-0001aB-2C' > mensagem.txt
sha256sum mensagem.txt > mensagem.sha256
```

O `ls -tr` existe aí por um motivo concreto: o glob `exim_mainlog*` sozinho expande em ordem lexicográfica, ou seja, `exim_mainlog` (o atual, mais novo) antes de `exim_mainlog.1.gz`, `.2.gz` e assim por diante. Isso entrega a história de trás para frente: o `Completed` e os `==` de retry aparecem acima do `<=` que os originou, e quem for ler o recorte vai montar a sequência errada. Com `ls -tr` a concatenação segue o mtime crescente, do rotacionado mais antigo até o log atual, e as linhas saem na ordem em que o Exim as escreveu. Se o `cp -a` não preservar o mtime na sua cópia, ordene explicitamente pelo número de rotação em vez de confiar no glob.

O `zcat -f` lê comprimido e não comprimido na mesma passada. O hash não prova nada sozinho, mas registra que o recorte não mudou depois que você o entregou. Se precisar subir a janela de retenção, ajuste a política de rotate do log, e saiba que o arquivo cresce rápido em servidor com volume de envio.

Em servidores cPanel, o painel de rastreio de entrega e as estatísticas de e-mail se apoiam no processamento do próprio `exim_mainlog`. A cPanel documenta um script dedicado a essa leitura, o `slurp_exim_mainlog`, em [The slurp_exim_mainlog Script](https://docs.cpanel.net/whm/scripts/the-slurp_exim_mainlog-script/). Vale ter isso claro: o relatório bonito do painel e o seu `exigrep` bebem da mesma fonte. Quando os dois discordam, o log bruto ganha.

## Como responder ao cliente amarrando cada frase a uma linha do log

Três frases, cada uma amarrada a uma linha do log:

- **Entrada.** Horário do `<=`, usuário autenticado no `A=` e IP de origem no `H=`. Isso responde "a mensagem saiu do meu computador".
- **Saída.** Horário do `=>`, host remoto e o `C=` com a resposta do destino. Isso responde "o servidor deles aceitou".
- **Limite.** Diga explicitamente que o log do seu servidor termina no aceite do remoto, e que filtro de spam, regra de caixa e quarentena do destino não geram linha no seu log.

Se não houver `<=`, a resposta muda de natureza: não é um problema de entrega, é um problema de envio, e o próximo passo é a autenticação SMTP ou o limite de envio da conta, não a reputação do IP.

## Checklist: do sintoma no log ao próximo passo

| Sintoma no log | Leitura | Próximo passo |
|---|---|---||
| Sem `<=` na janela | Mensagem nunca enfileirada | Verificar autenticação SMTP, limite de envio, porta e TLS do cliente |
| `<=` sem `=>` nem `**`, mas com `==` | Em fila, retry em andamento | Ver `exim -bp`, checar o motivo do defer no `==` |
| `<=` e `**` com 5xx de política | Recusa por reputação ou autenticação de domínio | Checar SPF, DKIM, DMARC e reputação do IP de saída |
| `<=` e `**` com 5xx de usuário inexistente | Endereço errado | Confirmar o destinatário com o remetente |
| `<=` e `=>` com `C="250 ..."` | Aceito pelo destino | Encerrar do seu lado, pedir ao destinatário que verifique spam e regras |
| `=>` para um RCPT e `**` para outro | Veredicto misto | Responder por destinatário, nunca por mensagem |

Não existe comando que prove que a mensagem chegou à caixa de entrada de outra empresa. O que existe é prova de que o servidor dela aceitou, com hora, host e código. Essa distinção é o que separa uma resposta técnica de uma promessa que você não pode cumprir.

