#!/usr/bin/env python3
# Este script utiliza encoding: utf-8
# Este script foi desenvolvido por Mariana Melo, disponível em contato@mw-solucoes.com
# Todos os direitos reservados - Copyright © 2017-2026 MW Soluções

# ...==================================== Variáveis Globais ====================================...

VERSION = "1.3.0"  # Versão do script

CAMINHO_SOCKET       = "/run/dnstap.sock"                      # Socket que o Unbound conecta
CAMINHO_ESTATISTICAS = "/var/lib/unbound-dnstap/stats.json"    # Arquivo lido pelo external script
CAMINHO_VIGIADOS     = "/var/lib/unbound-dnstap/vigiados.txt"  # Domínios contados sempre, gravado pelo external script
JANELA_MINUTOS       = 5                                       # Tamanho da janela deslizante de agregação
INTERVALO_ESCRITA    = 30                                      # Intervalo de gravação do JSON, em segundos
TOTAL_TOP            = 15                                      # Quantidade de domínios em cada ranking
MIN_AMOSTRAS         = 5                                       # Mínimo de amostras para o domínio entrar no ranking de latência
MAX_DOMINIOS         = 20000                                   # Teto de domínios distintos guardados por minuto
MAX_PENDENTES        = 100000                                  # Teto de consultas aguardando resposta
TTL_PENDENTES        = 15                                      # Tempo de vida das consultas pendentes, em segundos
TAMANHO_MAX_FRAME    = 1048576                                 # Teto de tamanho de frame, proteção contra lixo no socket

# Caminhos usados pelos modos de instalação e desinstalação.
CAMINHO_INSTALACAO = "/usr/local/bin/unbound_dnstap_collector.py"
CONF_DNSTAP        = "/etc/unbound/unbound.conf.d/zz-mw-dnstap.conf"
UNIDADE_SYSTEMD    = "/etc/systemd/system/unbound-dnstap.service"
NOME_SERVICO       = "unbound-dnstap"
CAMINHO_TESTE      = "/tmp/unbound-dnstap-teste.json"          # Saída do modo testarColeta
ESPERA_INSTALACAO  = 20                                        # Tempo de espera pelo socket e pelo primeiro arquivo, em segundos

# Perfil do AppArmor que o pacote do Unbound instala no Debian e no Ubuntu. Ele só
# libera os caminhos do próprio Unbound, então a conexão no socket do coletor é negada.
PERFIL_APPARMOR    = "/etc/apparmor.d/usr.sbin.unbound"
LOCAL_APPARMOR     = "/etc/apparmor.d/local/usr.sbin.unbound"  # Incluído pelo perfil, não é sobrescrito na atualização do pacote
PERFIS_CARREGADOS  = "/sys/kernel/security/apparmor/profiles"
COMENTARIO_APPARMOR = "# Liberado pela MW Soluções para o Unbound conectar no socket do coletor dnstap."
REGRA_APPARMOR      = CAMINHO_SOCKET + " rw,"

# Tipos de mensagem do dnstap.
CLIENT_QUERY      = 5
CLIENT_RESPONSE   = 6
RESOLVER_QUERY    = 3
RESOLVER_RESPONSE = 4

# Tipos de frame de controle do protocolo Frame Streams.
CONTROLE_ACCEPT = 1
CONTROLE_START  = 2
CONTROLE_STOP   = 3
CONTROLE_READY  = 4
CONTROLE_FINISH = 5

TIPO_CONTEUDO = b"protobuf:dnstap.Dnstap"

# Sufixos de dois níveis, para que o agrupamento não devolva "com.br" como domínio.
SUFIXOS_COMPOSTOS = set([
    "com.br", "net.br", "org.br", "gov.br", "edu.br", "ind.br", "inf.br", "art.br",
    "eng.br", "esp.br", "adv.br", "med.br", "psi.br", "vet.br", "tur.br", "nom.br",
    "blog.br", "app.br", "dev.br", "srv.br", "jus.br", "leg.br", "mil.br",
    "co.uk", "org.uk", "ac.uk", "gov.uk", "co.jp", "co.in", "co.za", "co.nz",
    "com.ar", "com.mx", "com.co", "com.pt", "com.au", "com.cn", "com.tr",
    "com.es", "com.py", "com.uy", "com.ve", "com.pe", "com.ec", "com.bo",
    "net.ar", "org.ar", "gov.ar", "com.hk", "com.sg", "com.my", "com.vn",
])

# ...==================================== Bibliotecas ====================================...

import os
import sys
import json
import time
import errno
import shutil
import select
import socket
import signal
import struct
import tempfile
import subprocess

# ...==================================== Parâmetros ====================================...

modo    = sys.argv[1] if len(sys.argv) > 1 else "executar"  # Modo de execução
duracao = 60                                               # Duração do modo testarColeta, em segundos

if modo == "testarColeta" and len(sys.argv) > 2:
    try:
        duracao = int(sys.argv[2])
    except ValueError:
        print("ERRO: a duração do testarColeta precisa ser um número em segundos.")
        sys.exit(1)

# ...==================================== Funções Auxiliares ====================================...

# Imprime a versão do script.
def get_version():
    print(" Todos os direitos reservados - Copyright © 2017-2026 MW Soluções")
    print(sys.argv[0].replace('./', ' ') + "  " + VERSION)
    sys.exit(0)

# Escreve mensagem no journal, o serviço roda com a saída padrão redirecionada.
def registrar(mensagem):
    sys.stdout.write("[unbound-dnstap] " + mensagem + "\n")
    sys.stdout.flush()

# Lê um varint do protobuf a partir do índice informado.
def lerVarint(buffer, indice):
    resultado = 0
    deslocamento = 0
    tamanho = len(buffer)
    while indice < tamanho:
        byte = buffer[indice]
        indice += 1
        resultado |= (byte & 0x7F) << deslocamento
        if not byte & 0x80:
            return resultado, indice
        deslocamento += 7
    raise ValueError("varint incompleto")

# Decodifica uma mensagem protobuf em um dicionário {número do campo: valor}.
# O dnstap não usa campos repetidos nas mensagens que interessam aqui, então o último valor vence.
def decodificarProtobuf(buffer):
    campos = {}
    indice = 0
    tamanho = len(buffer)
    while indice < tamanho:
        chave, indice = lerVarint(buffer, indice)
        numero = chave >> 3
        tipoFio = chave & 7
        if tipoFio == 0:
            valor, indice = lerVarint(buffer, indice)
        elif tipoFio == 2:
            comprimento, indice = lerVarint(buffer, indice)
            valor = buffer[indice:indice + comprimento]
            indice += comprimento
        elif tipoFio == 5:
            valor = struct.unpack_from("<I", buffer, indice)[0]
            indice += 4
        elif tipoFio == 1:
            valor = struct.unpack_from("<Q", buffer, indice)[0]
            indice += 8
        else:
            break
        campos[numero] = valor
    return campos

# Lê o nome de domínio da seção de pergunta de uma mensagem DNS.
def lerNomeDns(buffer, indice):
    partes = []
    tamanho = len(buffer)
    while indice < tamanho:
        comprimento = buffer[indice]
        if comprimento == 0:
            indice += 1
            break
        # Ponteiro de compressão não ocorre na seção de pergunta, encerra por segurança.
        if comprimento & 0xC0 == 0xC0:
            indice += 2
            break
        indice += 1
        partes.append(buffer[indice:indice + comprimento].decode("ascii", "replace"))
        indice += comprimento
    return ".".join(partes), indice

# Extrai identificador e nome consultado de uma mensagem DNS crua.
def analisarDns(mensagem):
    if not mensagem or len(mensagem) < 12:
        return None
    try:
        identificador, _flags, quantidadePergunta = struct.unpack_from("!HHH", mensagem, 0)
        if not quantidadePergunta:
            return None
        nome, _indice = lerNomeDns(mensagem, 12)
    except (struct.error, ValueError, IndexError):
        return None
    return identificador, nome.lower().rstrip(".")

# Agrupa o nome consultado no domínio de registro, para que o ranking mostre
# "google.com" e não cada subdomínio separadamente.
def dominioBase(nome):
    if not nome:
        return ""
    if nome.endswith(".in-addr.arpa") or nome.endswith(".ip6.arpa"):
        return "arpa-reverso"
    partes = nome.split(".")
    if len(partes) <= 2:
        return nome
    if ".".join(partes[-2:]) in SUFIXOS_COMPOSTOS:
        return ".".join(partes[-3:])
    return ".".join(partes[-2:])

# Monta o instante em segundos a partir do par de campos segundo/nanossegundo do dnstap.
def montarInstante(mensagem, campoSegundo, campoNano):
    if campoSegundo not in mensagem:
        return None
    return mensagem[campoSegundo] + mensagem.get(campoNano, 0) / 1000000000.0

# ...==================================== Classes ====================================...

# Monta os frames do protocolo Frame Streams a partir do fluxo de bytes recebido no socket.
class LeitorFrameStream:
    def __init__(self):
        self.buffer = bytearray()

    def adicionar(self, dados):
        self.buffer.extend(dados)

    # Devolve ("controle"|"dados", conteúdo) ou (None, None) quando o frame ainda está incompleto.
    def proximoFrame(self):
        if len(self.buffer) < 4:
            return None, None
        tamanho = struct.unpack_from("!I", self.buffer, 0)[0]
        if tamanho == 0:
            if len(self.buffer) < 8:
                return None, None
            tamanhoControle = struct.unpack_from("!I", self.buffer, 4)[0]
            if tamanhoControle > TAMANHO_MAX_FRAME:
                raise ValueError("frame de controle acima do limite")
            if len(self.buffer) < 8 + tamanhoControle:
                return None, None
            conteudo = bytes(self.buffer[8:8 + tamanhoControle])
            del self.buffer[:8 + tamanhoControle]
            return "controle", conteudo
        if tamanho > TAMANHO_MAX_FRAME:
            raise ValueError("frame de dados acima do limite")
        if len(self.buffer) < 4 + tamanho:
            return None, None
        conteudo = bytes(self.buffer[4:4 + tamanho])
        del self.buffer[:4 + tamanho]
        return "dados", conteudo


# Guarda os contadores de um minuto da janela deslizante.
class Balde:
    def __init__(self):
        self.consultas       = {}  # domínio -> quantidade de consultas de cliente
        self.latenciaUp      = {}  # domínio -> [soma, quantidade, máximo] da latência de resolução
        self.latenciaCliente = {}  # domínio -> [soma, quantidade, máximo] da latência fim a fim
        self.totalConsultas  = 0
        self.totalRespostas  = 0
        self.somaLocal       = 0.0  # soma da latência que o Unbound levou para responder ao cliente
        self.qtdLocal        = 0    # quantidade de respostas ao cliente medidas
        self.maxLocal        = 0.0  # pior tempo de resposta ao cliente
        self.cacheHits       = 0    # consultas respondidas do cache, vindas do unbound-control
        self.cacheMiss       = 0    # consultas que precisaram sair para resolver

    # Registra o tempo que o Unbound levou para responder o cliente, cache ou não.
    def registrarLatenciaLocal(self, valor):
        self.somaLocal += valor
        self.qtdLocal += 1
        if valor > self.maxLocal:
            self.maxLocal = valor

    def registrarConsulta(self, dominio):
        self.totalConsultas += 1
        if dominio in self.consultas:
            self.consultas[dominio] += 1
        elif len(self.consultas) < MAX_DOMINIOS:
            self.consultas[dominio] = 1

    def registrarLatencia(self, colecao, dominio, valor):
        registro = colecao.get(dominio)
        if registro is None:
            if len(colecao) >= MAX_DOMINIOS:
                return
            colecao[dominio] = [valor, 1, valor]
            return
        registro[0] += valor
        registro[1] += 1
        if valor > registro[2]:
            registro[2] = valor


# Agrega as mensagens dnstap em uma janela deslizante de minutos e gera o JSON de saída.
class Agregador:
    def __init__(self):
        self.baldes             = {}     # minuto -> Balde
        self.pendentesCliente   = {}     # chave -> instante da consulta do cliente
        self.pendentesResolver  = {}     # chave -> instante da consulta ao servidor autoritativo
        self.framesDescartados  = 0
        self.iniciadoEm         = int(time.time())
        self.respostaTemInicio  = False  # indica se o CLIENT_RESPONSE já traz o query_time
        self.contadoresCache    = None   # última leitura do unbound-control, para o delta
        self.fonteCache         = "aguardando primeira leitura"
        self.vigiados           = {}     # domínio vigiado -> consultas desde o início do serviço
        self.carregarVigiados()

    # Relê a lista de domínios vigiados, mantendo a contagem dos que continuam nela.
    # A contagem é acumulada desde o início do serviço, e não na janela, para o Zabbix
    # tirar a diferença entre coletas sem perder nem repetir consulta.
    def carregarVigiados(self):
        try:
            with open(CAMINHO_VIGIADOS) as arquivo:
                nomes = arquivo.read().split()
        # Arquivo editado à mão com bytes inválidos não pode derrubar o serviço em laço.
        except (OSError, ValueError):
            nomes = []
        atual = {}
        for nome in nomes:
            dominio = dominioBase(nome.lower().rstrip("."))
            if dominio:
                atual[dominio] = self.vigiados.get(dominio, 0)
        self.vigiados = atual

    # Devolve o balde do minuto atual e descarta os minutos que saíram da janela.
    def baldeAtual(self):
        minuto = int(time.time()) // 60
        balde = self.baldes.get(minuto)
        if balde is None:
            balde = Balde()
            self.baldes[minuto] = balde
            for antigo in [chave for chave in self.baldes if chave <= minuto - JANELA_MINUTOS]:
                del self.baldes[antigo]
        return balde

    # Remove consultas que nunca receberam resposta, evitando crescimento infinito.
    def limparPendentes(self):
        limite = time.time() - TTL_PENDENTES
        for colecao in (self.pendentesCliente, self.pendentesResolver):
            for chave in [chave for chave, instante in colecao.items() if instante < limite]:
                del colecao[chave]

    def guardarPendente(self, colecao, chave, instante):
        if instante is None or chave is None:
            return
        if len(colecao) >= MAX_PENDENTES:
            self.framesDescartados += 1
            return
        colecao[chave] = instante

    # Processa uma mensagem dnstap já decodificada.
    def processar(self, envelope):
        conteudo = envelope.get(14)
        if not conteudo:
            return
        try:
            mensagem = decodificarProtobuf(conteudo)
        except (ValueError, struct.error, IndexError):
            self.framesDescartados += 1
            return

        tipo = mensagem.get(1, 0)
        if tipo == CLIENT_QUERY:
            self.processarConsultaCliente(mensagem)
        elif tipo == CLIENT_RESPONSE:
            self.processarRespostaCliente(mensagem)
        elif tipo == RESOLVER_QUERY:
            self.processarConsultaResolver(mensagem)
        elif tipo == RESOLVER_RESPONSE:
            self.processarRespostaResolver(mensagem)

    def processarConsultaCliente(self, mensagem):
        dns = analisarDns(mensagem.get(10))
        if dns is None:
            return
        identificador, nome = dns
        balde = self.baldeAtual()
        dominio = dominioBase(nome)
        balde.registrarConsulta(dominio)
        if dominio in self.vigiados:
            self.vigiados[dominio] += 1
        chave = (mensagem.get(4), mensagem.get(6), identificador, nome)
        self.guardarPendente(self.pendentesCliente, chave, montarInstante(mensagem, 8, 9))

    def processarRespostaCliente(self, mensagem):
        dns = analisarDns(mensagem.get(14))
        if dns is None:
            return
        identificador, nome = dns
        balde = self.baldeAtual()
        balde.totalRespostas += 1

        fim = montarInstante(mensagem, 12, 13)
        if fim is None:
            return

        # O Unbound pode entregar o query_time junto da resposta. Quando entrega,
        # não é preciso casar com a consulta guardada em memória.
        inicio = montarInstante(mensagem, 8, 9)
        if inicio is not None:
            self.respostaTemInicio = True
        else:
            chave = (mensagem.get(4), mensagem.get(6), identificador, nome)
            inicio = self.pendentesCliente.pop(chave, None)

        if inicio is not None and fim >= inicio:
            balde.registrarLatencia(balde.latenciaCliente, dominioBase(nome), fim - inicio)
            balde.registrarLatenciaLocal(fim - inicio)

    def processarConsultaResolver(self, mensagem):
        dns = analisarDns(mensagem.get(10))
        if dns is None:
            return
        identificador, nome = dns
        chave = (mensagem.get(5), identificador, nome)
        self.guardarPendente(self.pendentesResolver, chave, montarInstante(mensagem, 8, 9))

    def processarRespostaResolver(self, mensagem):
        dns = analisarDns(mensagem.get(14))
        if dns is None:
            return
        identificador, nome = dns

        # Nomes com um único rótulo vêm da minimização de QNAME e não representam
        # um domínio consultado, ficam fora do ranking de latência.
        if nome.count(".") < 1:
            return

        fim = montarInstante(mensagem, 12, 13)
        inicio = montarInstante(mensagem, 8, 9)
        if inicio is None:
            chave = (mensagem.get(5), identificador, nome)
            inicio = self.pendentesResolver.pop(chave, None)
        if inicio is None or fim is None or fim < inicio:
            return

        balde = self.baldeAtual()
        balde.registrarLatencia(balde.latenciaUp, dominioBase(nome), fim - inicio)

    # Lê os contadores de cache do Unbound e acumula o crescimento no balde do minuto.
    #
    # O dnstap não diz se uma consulta foi respondida do cache: acerto de cache gera
    # apenas o par CLIENT_QUERY/CLIENT_RESPONSE, sem nenhuma marca que o diferencie de
    # uma resolução rápida. Classificar por limiar de tempo seria chute. O unbound-control
    # entrega a contagem exata, então é dele que sai a divisão local/externo.
    #
    # É usado o stats_noreset para não zerar contador de quem já monitora o Unbound por
    # agente. O delta entre leituras é acumulado nos mesmos baldes das outras métricas,
    # para o percentual cobrir exatamente a mesma janela.
    def atualizarCache(self):
        control = localizarBinario("unbound-control")
        if not control:
            self.fonteCache = "unbound-control não encontrado"
            return

        codigo, saida = rodarComando([control, "stats_noreset"], timeout=15)
        if codigo != 0:
            self.fonteCache = "unbound-control falhou"
            return

        desejados = ("total.num.queries", "total.num.cachehits", "total.num.cachemiss")
        atual = {}
        for linha in saida.splitlines():
            chave, separador, valor = linha.partition("=")
            if separador and chave in desejados:
                try:
                    atual[chave] = int(float(valor))
                except ValueError:
                    pass

        if len(atual) != len(desejados):
            self.fonteCache = "contadores não encontrados na saída"
            return

        anterior = self.contadoresCache
        self.contadoresCache = atual

        if anterior is None:
            self.fonteCache = "aguardando segunda leitura"
            return

        # Reinício do Unbound, ou alguém chamando "stats" em vez de "stats_noreset",
        # zera os contadores e tornaria o delta negativo.
        if any(atual[chave] < anterior[chave] for chave in desejados):
            self.fonteCache = "contadores reiniciados"
            return

        hits = atual["total.num.cachehits"] - anterior["total.num.cachehits"]
        miss = atual["total.num.cachemiss"] - anterior["total.num.cachemiss"]
        if hits + miss <= 0:
            self.fonteCache = "unbound-control"
            return

        balde = self.baldeAtual()
        balde.cacheHits += hits
        balde.cacheMiss += miss
        self.fonteCache = "unbound-control"

    # Soma todos os baldes da janela em contadores únicos.
    def consolidar(self):
        consultas       = {}
        latenciaUp      = {}
        latenciaCliente = {}
        totalConsultas  = 0
        totalRespostas  = 0
        local           = [0.0, 0, 0.0]  # soma, quantidade e máximo da latência local
        cache           = [0, 0]         # acertos e faltas de cache

        for balde in self.baldes.values():
            totalConsultas += balde.totalConsultas
            totalRespostas += balde.totalRespostas
            local[0] += balde.somaLocal
            local[1] += balde.qtdLocal
            if balde.maxLocal > local[2]:
                local[2] = balde.maxLocal
            cache[0] += balde.cacheHits
            cache[1] += balde.cacheMiss
            for dominio, quantidade in balde.consultas.items():
                consultas[dominio] = consultas.get(dominio, 0) + quantidade
            for origem, destino in ((balde.latenciaUp, latenciaUp), (balde.latenciaCliente, latenciaCliente)):
                for dominio, registro in origem.items():
                    acumulado = destino.get(dominio)
                    if acumulado is None:
                        destino[dominio] = [registro[0], registro[1], registro[2]]
                    else:
                        acumulado[0] += registro[0]
                        acumulado[1] += registro[1]
                        if registro[2] > acumulado[2]:
                            acumulado[2] = registro[2]

        return consultas, latenciaUp, latenciaCliente, totalConsultas, totalRespostas, local, cache

    # Devolve a média em milissegundos e a quantidade de amostras de um domínio
    # dentro de uma coleção {domínio: [soma, quantidade, máximo]}.
    def mediaDominio(self, colecao, dominio):
        registro = colecao.get(dominio)
        if not registro or not registro[1]:
            return 0.0, 0
        return round(registro[0] * 1000 / registro[1], 2), registro[1]

    # Monta o ranking de domínios mais consultados, com o tempo de resolução de cada um.
    # Aqui não vale o MIN_AMOSTRAS: o domínio entra na lista por volume, não por latência,
    # e a quantidade de amostras vai junto para quem lê julgar a média.
    def montarTopConsultas(self, consultas, totalConsultas, latenciaCliente, latenciaUp):
        ordenado = sorted(consultas.items(), key=lambda item: (-item[1], item[0]))[:TOTAL_TOP]
        ranking = []
        posicao = 0
        for dominio, quantidade in ordenado:
            posicao += 1
            percentual = round(quantidade * 100.0 / totalConsultas, 2) if totalConsultas else 0.0
            latenciaLocal, amostrasLocal = self.mediaDominio(latenciaCliente, dominio)
            latenciaExterna, amostrasExterna = self.mediaDominio(latenciaUp, dominio)
            ranking.append({
                "posicao"         : posicao,
                "dominio"         : dominio,
                "consultas"       : quantidade,
                "percentual"      : percentual,
                "latenciaLocal"   : latenciaLocal,
                "amostrasLocal"   : amostrasLocal,
                "latenciaExterna" : latenciaExterna,
                "amostrasExterna" : amostrasExterna,
            })
        return ranking

    # Monta um ranking de domínios por latência média, a partir de uma coleção
    # {domínio: [soma, quantidade, máximo]}. Serve para os dois rankings de latência.
    def montarRankingLatencia(self, colecao):
        candidatos = []
        for dominio, registro in colecao.items():
            if registro[1] < MIN_AMOSTRAS:
                continue
            candidatos.append((registro[0] / registro[1], registro[2], registro[1], dominio))

        candidatos.sort(key=lambda item: (-item[0], item[3]))
        ranking = []
        posicao = 0
        for media, maximo, amostras, dominio in candidatos[:TOTAL_TOP]:
            posicao += 1
            ranking.append({
                "posicao"        : posicao,
                "dominio"        : dominio,
                "latenciaMedia"  : round(media * 1000, 2),
                "latenciaMaxima" : round(maximo * 1000, 2),
                "amostras"       : amostras,
            })
        return ranking

    # Gera o dicionário que vai para o arquivo JSON.
    def montarSaida(self):
        consultas, latenciaUp, latenciaCliente, totalConsultas, totalRespostas, local, cache = self.consolidar()

        # Dois rankings distintos, que respondem perguntas diferentes:
        #   externo - o servidor autoritativo do domínio está lento
        #   local   - o nosso DNS está demorando a entregar esse domínio ao cliente
        topLatencia      = self.montarRankingLatencia(latenciaUp)
        topLatenciaLocal = self.montarRankingLatencia(latenciaCliente)

        # Latência externa: tempo que os servidores autoritativos levaram para responder.
        somaExterna = sum(registro[0] for registro in latenciaUp.values())
        amostrasExterna = sum(registro[1] for registro in latenciaUp.values())
        latenciaExterna = round(somaExterna * 1000 / amostrasExterna, 2) if amostrasExterna else 0.0
        fonteLatencia = "resolucao" if amostrasExterna else "indisponivel"

        # Latência local: tempo que o Unbound levou para responder ao cliente, cache ou não.
        latenciaLocal = round(local[0] * 1000 / local[1], 2) if local[1] else 0.0

        # Divisão entre o que saiu do cache e o que precisou ser resolvido fora.
        totalCache = cache[0] + cache[1]
        percentualLocal = round(cache[0] * 100.0 / totalCache, 2) if totalCache else 0.0
        percentualExterno = round(cache[1] * 100.0 / totalCache, 2) if totalCache else 0.0

        janela = min(len(self.baldes), JANELA_MINUTOS) * 60
        return {
            "versao"                : VERSION,
            "geradoEm"              : int(time.time()),
            "iniciadoEm"            : self.iniciadoEm,
            "janelaSegundos"        : janela,
            "totalConsultas"        : totalConsultas,
            "totalRespostas"        : totalRespostas,
            "consultasPorSegundo"   : round(totalConsultas / float(janela), 2) if janela else 0.0,
            "dominiosDistintos"     : len(consultas),
            "latenciaLocal"         : latenciaLocal,
            "latenciaLocalMaxima"   : round(local[2] * 1000, 2),
            "amostrasLatenciaLocal" : local[1],
            "latenciaExterna"       : latenciaExterna,
            "amostrasLatenciaExterna": amostrasExterna,
            "consultasLocais"       : cache[0],
            "consultasExternas"     : cache[1],
            "percentualLocal"       : percentualLocal,
            "percentualExterno"     : percentualExterno,
            "fonteCache"            : self.fonteCache,
            "fonteLatencia"         : fonteLatencia,
            "respostaTemQueryTime"  : self.respostaTemInicio,
            "framesDescartados"     : self.framesDescartados,
            "topConsultas"          : self.montarTopConsultas(consultas, totalConsultas, latenciaCliente, latenciaUp),
            "topLatencia"           : topLatencia,
            "topLatenciaLocal"      : topLatenciaLocal,
            "consultasVigiadas"     : dict(self.vigiados),
        }


# Mantém uma conexão do Unbound, tratando o handshake do Frame Streams.
class Conexao:
    def __init__(self, socketCliente, agregador):
        self.socketCliente = socketCliente
        self.agregador     = agregador
        self.leitor        = LeitorFrameStream()

    def fileno(self):
        return self.socketCliente.fileno()

    def enviarControle(self, tipo, tipoConteudo=None):
        corpo = struct.pack("!I", tipo)
        if tipoConteudo:
            corpo += struct.pack("!II", 1, len(tipoConteudo)) + tipoConteudo
        try:
            self.socketCliente.sendall(struct.pack("!II", 0, len(corpo)) + corpo)
        except socket.error:
            pass

    # Lê o que estiver disponível no socket. Devolve False quando a conexão terminou.
    def ler(self):
        try:
            dados = self.socketCliente.recv(65536)
        except socket.error as erro:
            if erro.errno in (errno.EAGAIN, errno.EWOULDBLOCK, errno.EINTR):
                return True
            return False
        if not dados:
            return False

        self.leitor.adicionar(dados)
        while True:
            try:
                tipo, conteudo = self.leitor.proximoFrame()
            except ValueError as erro:
                registrar("fluxo inválido no socket, encerrando conexão: " + str(erro))
                return False
            if tipo is None:
                return True
            if tipo == "controle":
                if not self.tratarControle(conteudo):
                    return False
                continue
            try:
                self.agregador.processar(decodificarProtobuf(conteudo))
            except (ValueError, struct.error, IndexError):
                self.agregador.framesDescartados += 1

    # Responde aos frames de controle. Devolve False quando o cliente pediu o encerramento.
    def tratarControle(self, conteudo):
        if len(conteudo) < 4:
            return True
        tipo = struct.unpack_from("!I", conteudo, 0)[0]
        if tipo == CONTROLE_READY:
            self.enviarControle(CONTROLE_ACCEPT, TIPO_CONTEUDO)
        elif tipo == CONTROLE_STOP:
            self.enviarControle(CONTROLE_FINISH)
            return False
        return True

    def fechar(self):
        try:
            self.socketCliente.close()
        except socket.error:
            pass

# ...==================================== Funções de Instalação ====================================...

# Localiza um executável mesmo quando o PATH não traz /usr/sbin.
def localizarBinario(nome):
    caminho = shutil.which(nome)
    if caminho:
        return caminho
    for diretorio in ("/usr/sbin", "/sbin", "/usr/local/sbin", "/usr/bin", "/bin"):
        candidato = os.path.join(diretorio, nome)
        if os.path.isfile(candidato):
            return candidato
    return None

# Executa um comando do sistema e devolve o código de retorno e a saída.
def rodarComando(comando, timeout=90):
    try:
        processo = subprocess.Popen(comando, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
        saida, _erro = processo.communicate(timeout=timeout)
        return processo.returncode, saida.decode("utf-8", "replace")
    except OSError as erro:
        return 1, str(erro)
    except subprocess.TimeoutExpired:
        processo.kill()
        return 1, "o comando excedeu o tempo limite"

# Aguarda uma condição ficar verdadeira, devolvendo se conseguiu dentro do prazo.
def aguardar(condicao, segundos):
    prazo = time.time() + segundos
    while time.time() < prazo:
        if condicao():
            return True
        time.sleep(1)
    return condicao()

# Conteúdo da configuração do dnstap. O nome do arquivo começa com zz para ser o
# último include lido pelo Unbound.
def montarConfiguracaoDnstap():
    return (
        "# Habilitado pela MW Soluções para a coleta de domínios mais consultados e latência.\n"
        "dnstap:\n"
        "    dnstap-enable: yes\n"
        '    dnstap-socket-path: "' + CAMINHO_SOCKET + '"\n'
        "    dnstap-send-identity: yes\n"
        "    dnstap-send-version: no\n"
        "    dnstap-log-client-query-messages: yes\n"
        "    dnstap-log-client-response-messages: yes\n"
        "    dnstap-log-resolver-query-messages: yes\n"
        "    dnstap-log-resolver-response-messages: yes\n"
        "    dnstap-log-forwarder-query-messages: no\n"
        "    dnstap-log-forwarder-response-messages: no\n"
    )

# Conteúdo da unidade do systemd.
def montarUnidadeSystemd():
    interpretador = sys.executable if sys.executable and sys.executable.startswith("/") else "/usr/bin/python3"
    return (
        "[Unit]\n"
        "Description=Coletor dnstap do Unbound - MW Solucoes\n"
        "After=network.target\n"
        "Before=unbound.service\n"
        "\n"
        "[Service]\n"
        "Type=simple\n"
        "ExecStart=" + interpretador + " " + CAMINHO_INSTALACAO + " executar\n"
        "Restart=always\n"
        "RestartSec=5\n"
        "StandardOutput=journal\n"
        "StandardError=journal\n"
        "\n"
        "[Install]\n"
        "WantedBy=multi-user.target\n"
    )

# Recarrega o Unbound, preferindo o unbound-control para não derrubar o cache.
def recarregarUnbound(control, systemctl):
    if control:
        codigo, _saida = rodarComando([control, "reload"])
        if codigo == 0:
            return True
    codigo, _saida = rodarComando([systemctl, "reload-or-restart", "unbound"])
    return codigo == 0

# Exige root nos modos que alteram o servidor.
def exigirRoot(acao):
    if os.geteuid() != 0:
        print("ERRO: execute " + acao + " como root.")
        sys.exit(1)

# Confirma que o Unbound instalado tem suporte a dnstap compilado. O "-V" só existe a
# partir do Unbound 1.9.3. Antes disso, como no 1.9.0 do Debian 10, ele só imprime a
# ajuda e sai, então o suporte é conferido pela biblioteca do protobuf, que o Unbound
# usa apenas para o dnstap.
def exigirSuporteDnstap(unbound):
    _codigo, versao = rodarComando([unbound, "-V"])
    if "enable-dnstap" in versao:
        return
    ldd = localizarBinario("ldd")
    if ldd:
        _codigo, bibliotecas = rodarComando([ldd, unbound])
        if "libprotobuf-c" in bibliotecas:
            return
    print("ERRO: este Unbound não foi compilado com dnstap.")
    for linha in versao.splitlines():
        if "onfigure line" in linha:
            print(linha.strip())
    sys.exit(1)

# Indica se o perfil do Unbound está carregado no kernel. Só nesse caso ele é
# recarregado: recarregar um perfil desabilitado de propósito voltaria a aplicá-lo.
def perfilAppArmorCarregado():
    try:
        with open(PERFIS_CARREGADOS) as arquivo:
            for linha in arquivo:
                if linha.startswith("unbound (") or linha.startswith("/usr/sbin/unbound ("):
                    return True
    except (OSError, ValueError):
        pass
    return False

# Acrescenta ou remove a regra do socket no arquivo local do perfil do Unbound e
# recarrega o perfil, o que vale para o Unbound em execução sem reiniciá-lo.
# Devolve se o arquivo foi alterado.
def ajustarAppArmor(liberar):
    if not os.path.exists(PERFIL_APPARMOR):
        return False

    linhas = []
    if os.path.exists(LOCAL_APPARMOR):
        with open(LOCAL_APPARMOR) as arquivo:
            linhas = arquivo.read().splitlines()

    presente = REGRA_APPARMOR in [linha.strip() for linha in linhas]
    if liberar == presente:
        return False

    if liberar:
        linhas += [COMENTARIO_APPARMOR, REGRA_APPARMOR]
    else:
        linhas = [linha for linha in linhas if linha.strip() not in (COMENTARIO_APPARMOR, REGRA_APPARMOR)]

    diretorio = os.path.dirname(LOCAL_APPARMOR)
    if not os.path.isdir(diretorio):
        os.makedirs(diretorio, 0o755)
    with open(LOCAL_APPARMOR, "w") as arquivo:
        arquivo.write("".join(linha + "\n" for linha in linhas))

    parser = localizarBinario("apparmor_parser")
    if parser and perfilAppArmorCarregado():
        codigo, saida = rodarComando([parser, "-r", PERFIL_APPARMOR])
        if codigo != 0:
            print("ATENÇÃO: não foi possível recarregar o perfil do AppArmor do Unbound.")
            print(saida.strip())
    return True

# ...==================================== Funções Principais ====================================...

# Cria o socket unix que o Unbound conecta.
def criarSocketServidor():
    diretorio = os.path.dirname(CAMINHO_SOCKET)
    if diretorio and not os.path.isdir(diretorio):
        os.makedirs(diretorio, 0o755)
    if os.path.exists(CAMINHO_SOCKET):
        os.unlink(CAMINHO_SOCKET)
    servidor = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
    servidor.bind(CAMINHO_SOCKET)
    # O Unbound abandona privilégios e roda como o usuário unbound, precisa escrever no socket.
    os.chmod(CAMINHO_SOCKET, 0o666)
    servidor.listen(8)
    servidor.setblocking(False)
    return servidor

# Grava o JSON de forma atômica, para a leitura via SSH nunca pegar arquivo pela metade.
def gravarSaida(agregador):
    diretorio = os.path.dirname(CAMINHO_ESTATISTICAS)
    if diretorio and not os.path.isdir(diretorio):
        os.makedirs(diretorio, 0o755)
    conteudo = json.dumps(agregador.montarSaida(), ensure_ascii=False)
    descritor, temporario = tempfile.mkstemp(dir=diretorio, prefix=".stats-")
    try:
        with os.fdopen(descritor, "w") as arquivo:
            arquivo.write(conteudo)
        os.chmod(temporario, 0o644)
        os.rename(temporario, CAMINHO_ESTATISTICAS)
    except Exception:
        if os.path.exists(temporario):
            os.unlink(temporario)
        raise

# Laço principal do serviço. Com duração informada, encerra sozinho ao fim do tempo.
# O aposCriarSocket é chamado depois do socket existir, para quem precisa recarregar
# o Unbound sem que ele registre erro de conexão.
def executar(duracao=None, aposCriarSocket=None):
    servidor = criarSocketServidor()
    agregador = Agregador()
    conexoes = []
    encerrar = {"pedido": False}

    def tratarSinal(_numero, _quadro):
        encerrar["pedido"] = True

    signal.signal(signal.SIGTERM, tratarSinal)
    signal.signal(signal.SIGINT, tratarSinal)

    registrar("coletor iniciado, socket " + CAMINHO_SOCKET + ", saída " + CAMINHO_ESTATISTICAS)
    gravarSaida(agregador)

    if aposCriarSocket:
        aposCriarSocket()

    proximaEscrita = time.time() + INTERVALO_ESCRITA
    prazo = time.time() + duracao if duracao else None

    while not encerrar["pedido"]:
        if prazo and time.time() >= prazo:
            break
        espera = max(0.5, proximaEscrita - time.time())
        try:
            prontos, _escrita, _erro = select.select([servidor] + conexoes, [], [], espera)
        except select.error as erro:
            if erro.args[0] == errno.EINTR:
                continue
            raise

        for pronto in prontos:
            if pronto is servidor:
                try:
                    socketCliente, _endereco = servidor.accept()
                except socket.error:
                    continue
                socketCliente.setblocking(False)
                conexoes.append(Conexao(socketCliente, agregador))
                registrar("Unbound conectou ao socket dnstap")
                continue
            if not pronto.ler():
                pronto.fechar()
                conexoes.remove(pronto)
                registrar("conexão dnstap encerrada")

        if time.time() >= proximaEscrita:
            agregador.limparPendentes()
            agregador.atualizarCache()
            agregador.carregarVigiados()
            try:
                gravarSaida(agregador)
            except Exception as erro:
                registrar("falha ao gravar " + CAMINHO_ESTATISTICAS + ": " + str(erro))
            proximaEscrita = time.time() + INTERVALO_ESCRITA

    agregador.limparPendentes()
    agregador.atualizarCache()
    try:
        gravarSaida(agregador)
    except Exception as erro:
        registrar("falha ao gravar " + CAMINHO_ESTATISTICAS + ": " + str(erro))

    for conexao in conexoes:
        conexao.fechar()
    servidor.close()
    if os.path.exists(CAMINHO_SOCKET):
        os.unlink(CAMINHO_SOCKET)
    registrar("coletor encerrado")

# Coleta curta que imprime o JSON, sem instalar nada. Quando o dnstap ainda não está
# habilitado, habilita apenas durante o teste e desfaz ao terminar.
def testarColeta(duracao):
    global CAMINHO_ESTATISTICAS, INTERVALO_ESCRITA
    CAMINHO_ESTATISTICAS = CAMINHO_TESTE
    INTERVALO_ESCRITA = 10

    exigirRoot("o teste")

    checkconf = localizarBinario("unbound-checkconf")
    control   = localizarBinario("unbound-control")
    systemctl = localizarBinario("systemctl")
    if not checkconf or not systemctl:
        print("ERRO: não encontrei o unbound-checkconf ou o systemctl neste servidor.")
        sys.exit(1)

    # O serviço instalado já é dono do socket, os dois não podem disputar o mesmo caminho.
    codigo, _saida = rodarComando([systemctl, "is-active", "--quiet", NOME_SERVICO])
    if codigo == 0:
        print("ERRO: o serviço " + NOME_SERVICO + " está ativo e já é dono do socket " + CAMINHO_SOCKET + ".")
        print("Pare o serviço antes do teste: systemctl stop " + NOME_SERVICO)
        sys.exit(1)

    # Se o dnstap já está habilitado, a configuração existente é preservada.
    habilitarTemporario = not os.path.exists(CONF_DNSTAP)
    if habilitarTemporario:
        with open(CONF_DNSTAP, "w") as arquivo:
            arquivo.write(montarConfiguracaoDnstap())

        codigo, saida = rodarComando([checkconf])
        if codigo != 0:
            os.unlink(CONF_DNSTAP)
            print("ERRO: o unbound-checkconf reprovou a configuração. O arquivo foi removido e o Unbound não foi alterado.")
            print(saida.strip())
            sys.exit(1)
        print("dnstap habilitado temporariamente em " + CONF_DNSTAP)

    # Sem a regra, o AppArmor impede o Unbound de entregar qualquer mensagem no socket.
    liberouAppArmor = ajustarAppArmor(True)
    if liberouAppArmor:
        print("Socket liberado no AppArmor do Unbound em " + LOCAL_APPARMOR)

    print("Coletando por " + str(duracao) + " segundos...")
    try:
        # O Unbound só é recarregado depois do socket existir, para não registrar erro de conexão.
        executar(duracao, aposCriarSocket=lambda: recarregarUnbound(control, systemctl) if habilitarTemporario else None)
    finally:
        if habilitarTemporario:
            os.unlink(CONF_DNSTAP)
            recarregarUnbound(control, systemctl)
            if liberouAppArmor:
                ajustarAppArmor(False)
            print("dnstap desabilitado, o servidor voltou ao estado anterior.")

    with open(CAMINHO_ESTATISTICAS) as arquivo:
        print(json.dumps(json.load(arquivo), indent=2, ensure_ascii=False))
    sys.exit(0)

# Habilita o dnstap no Unbound e instala este script como serviço.
def instalar():
    exigirRoot("a instalação")

    unbound   = localizarBinario("unbound")
    checkconf = localizarBinario("unbound-checkconf")
    control   = localizarBinario("unbound-control")
    systemctl = localizarBinario("systemctl")

    for nome, caminho in (("unbound", unbound), ("unbound-checkconf", checkconf), ("systemctl", systemctl)):
        if not caminho:
            print("ERRO: não encontrei o executável " + nome + " neste servidor.")
            sys.exit(1)

    exigirSuporteDnstap(unbound)

    # Instala o coletor.
    origem = os.path.abspath(__file__)
    if origem != CAMINHO_INSTALACAO:
        shutil.copyfile(origem, CAMINHO_INSTALACAO)
    os.chmod(CAMINHO_INSTALACAO, 0o755)
    print("Coletor instalado em " + CAMINHO_INSTALACAO)

    diretorioSaida = os.path.dirname(CAMINHO_ESTATISTICAS)
    if not os.path.isdir(diretorioSaida):
        os.makedirs(diretorioSaida, 0o755)

    # Escreve a configuração do dnstap e valida antes de tocar no Unbound.
    with open(CONF_DNSTAP, "w") as arquivo:
        arquivo.write(montarConfiguracaoDnstap())
    print("Configuração do dnstap escrita em " + CONF_DNSTAP)

    codigo, saida = rodarComando([checkconf])
    if codigo != 0:
        os.unlink(CONF_DNSTAP)
        print("ERRO: o unbound-checkconf reprovou a configuração. O arquivo foi removido e o Unbound não foi alterado.")
        print(saida.strip())
        sys.exit(1)

    with open(UNIDADE_SYSTEMD, "w") as arquivo:
        arquivo.write(montarUnidadeSystemd())
    print("Serviço criado em " + UNIDADE_SYSTEMD)

    rodarComando([systemctl, "daemon-reload"])
    rodarComando([systemctl, "enable", NOME_SERVICO])
    codigo, saida = rodarComando([systemctl, "restart", NOME_SERVICO])
    if codigo != 0:
        print("ERRO: não foi possível iniciar o serviço " + NOME_SERVICO + ".")
        print(saida.strip())
        sys.exit(1)

    # O socket precisa existir antes do reload, senão o Unbound registra erro de conexão.
    if not aguardar(lambda: os.path.exists(CAMINHO_SOCKET), ESPERA_INSTALACAO):
        print("ERRO: o coletor não criou o socket " + CAMINHO_SOCKET + ".")
        print("Verifique com: journalctl -u " + NOME_SERVICO + " -n 30")
        sys.exit(1)

    # A regra precisa valer antes do reload, que é quando o Unbound conecta no socket.
    if ajustarAppArmor(True):
        print("Socket liberado no AppArmor do Unbound em " + LOCAL_APPARMOR)

    if not recarregarUnbound(control, systemctl):
        print("ERRO: não foi possível recarregar o Unbound. Recarregue manualmente e confira o arquivo de estatísticas.")
        sys.exit(1)
    print("Unbound recarregado.")

    if aguardar(lambda: os.path.exists(CAMINHO_ESTATISTICAS), ESPERA_INSTALACAO):
        print("Instalação concluída. Arquivo de estatísticas: " + CAMINHO_ESTATISTICAS)
        print("A janela de agregação leva " + str(JANELA_MINUTOS) + " minutos para encher. Confira com:")
        print("  cat " + CAMINHO_ESTATISTICAS)
    else:
        print("ATENÇÃO: o arquivo de estatísticas ainda não existe.")
        print("Verifique com: journalctl -u " + NOME_SERVICO + " -n 30")
    sys.exit(0)

# Remove o serviço e a configuração do dnstap, devolvendo o servidor ao estado anterior.
def desinstalar():
    exigirRoot("a desinstalação")

    control   = localizarBinario("unbound-control")
    systemctl = localizarBinario("systemctl")
    if not systemctl:
        print("ERRO: não encontrei o executável systemctl neste servidor.")
        sys.exit(1)

    rodarComando([systemctl, "disable", "--now", NOME_SERVICO])
    print("Serviço " + NOME_SERVICO + " parado e desabilitado.")

    for caminho in (CONF_DNSTAP, UNIDADE_SYSTEMD, CAMINHO_INSTALACAO, CAMINHO_ESTATISTICAS, CAMINHO_VIGIADOS):
        if os.path.exists(caminho):
            os.unlink(caminho)
            print("Removido " + caminho)

    rodarComando([systemctl, "daemon-reload"])

    if recarregarUnbound(control, systemctl):
        print("Unbound recarregado, o dnstap está desligado.")
    else:
        print("ATENÇÃO: recarregue o Unbound manualmente para desligar o dnstap.")

    if ajustarAppArmor(False):
        print("Regra do socket removida do AppArmor do Unbound.")
    sys.exit(0)

# ...==================================== Execução ====================================...

# ...============================== Modo Version ====================================...

if modo == "version":
    get_version()

# ...================================= Modos ====================================...

elif modo == "executar":
    executar()

elif modo == "instalar":
    instalar()

elif modo == "desinstalar":
    desinstalar()

elif modo == "testarColeta":
    testarColeta(duracao)

else:
    print("Modo de execução não encontrado.")
    print("Modos disponíveis: instalar, desinstalar, executar, testarColeta [segundos], version")
    sys.exit(1)
