Detector.py

"""
Módulo de detección y utilidades de red.

Este módulo proporciona funciones para detectar interfaces de red activas,
obtener direcciones MAC, y realizar conversiones entre formatos de direcciones.
También incluye utilidades para detectar entornos containerizados.

Funcionalidades principales:
- Detección automática de interfaces Wi-Fi y Ethernet activas
- Obtención de direcciones MAC usando ioctl
- Conversión entre formatos string y bytes para direcciones MAC
- Detección de entornos Docker
"""

import os
import socket
import fcntl
import struct
import threading
import time
import tempfile
import shutil


# Funcion para detectar interfaces de wifi o ethernet activas
def get_active_network_interfaces():
    """
    Detecta y devuelve las interfaces de red activas (Wi-Fi y Ethernet).
    
    Examina las interfaces en /sys/class/net y filtra solo aquellas que:
    - Tienen estado operativo 'up'
    - Tienen carrier activo (si aplica)
    - Son interfaces físicas (no virtuales, excepto en contenedores)
    - Son de tipo Wi-Fi o Ethernet
    
    Returns:
        list: Lista de nombres de interfaces activas
    """
    """
    Devuelve un dict con las interfaces activas clasificadas:
      {
        'wifi': ['wlp2s0', ...],
        'ethernet': ['enp3s0', ...]
      }
    Solo considera interfaces físicas y activas (operstate=up y, si existe, carrier=1).
    """
    base = "/sys/class/net"
    result = []
    is_container = running_in_docker()

    if not os.path.isdir(base):
        return result

    for name in sorted(os.listdir(base)):
        if name == "lo":
            continue

        iface_path = os.path.join(base, name)
        if not os.path.isdir(iface_path):
            continue

        if not is_container:
            # Saltar interfaces que no tienen dispositivo físico (virtuales)
            if not os.path.exists(os.path.join(iface_path, "device")):
                continue

        # Comprobar estado operativo
        try:
            with open(os.path.join(iface_path, "operstate")) as f:
                oper = f.read().strip()
        except FileNotFoundError:
            continue
        if oper != "up":
            continue

        # Si existe 'carrier', requerir que sea 1 (enlace activo)
        carrier_path = os.path.join(iface_path, "carrier")
        if os.path.exists(carrier_path):
            try:
                with open(carrier_path) as f:
                    if f.read().strip() != "1":
                        continue
            except OSError:
                continue

        # Determinar si es Wi‑Fi
        is_wifi = os.path.isdir(os.path.join(iface_path, "wireless"))
        uevent_path = os.path.join(iface_path, "uevent")
        if not is_wifi and os.path.exists(uevent_path):
            try:
                with open(uevent_path) as f:
                    uev = f.read()
                if "DEVTYPE=wlan" in uev:
                    is_wifi = True
            except OSError:
                pass

        if is_wifi:
            result.append(name)
            continue

        # Determinar si es Ethernet (ARPHRD_ETHER => type == 1)
        try:
            with open(os.path.join(iface_path, "type")) as f:
                if f.read().strip() == "1":
                    result.append(name)
        except OSError:
            pass

    return result


# Funcion para obtener la MAC de una interfaz dada
def get_mac_address(interface: str) -> str:
    """
    Obtiene la dirección MAC de una interfaz de red específica.
    
    Utiliza el comando SIOCGIFHWADDR a través de ioctl para obtener
    la dirección MAC a nivel de enlace de datos.
    
    Args:
        interface (str): Nombre de la interfaz de red (ej: 'eth0', 'wlan0')
    
    Returns:
        str: Dirección MAC en formato 'aa:bb:cc:dd:ee:ff'
    
    Raises:
        ValueError: Si el nombre de interfaz es inválido
        FileNotFoundError: Si no se puede obtener la MAC de la interfaz
    """
    """
    Devuelve la MAC de la interfaz usando solo capa de enlace (SIOCGIFHWADDR).
    Formato 'aa:bb:cc:dd:ee:ff'.
    """
    if not interface or "/" in interface:
        raise ValueError("Nombre de interfaz inválido")

    SIOCGIFHWADDR = 0x8927
    # AF_PACKET asegura operar a nivel de enlace
    s = socket.socket(socket.AF_PACKET, socket.SOCK_RAW, socket.htons(0x0003))  # ETH_P_ALL
    try:
        ifreq = struct.pack("256s", interface.encode("utf-8")[:15])
        res = fcntl.ioctl(s.fileno(), SIOCGIFHWADDR, ifreq)
        hw = res[18:24]  # ifr_hwaddr.sa_data
        mac = ":".join(f"{b:02x}" for b in hw)
        if mac == "00:00:00:00:00:00":
            raise FileNotFoundError(f"No se pudo obtener la MAC de '{interface}'")
        return mac
    finally:
        s.close()


# Convierte MAC de string a bytes
def mac_to_bytes(mac: str) -> bytes:
    """
    Convierte una dirección MAC de formato string a bytes.
    
    Acepta formatos con o sin separadores de dos puntos.
    
    Args:
        mac (str): Dirección MAC en formato 'aa:bb:cc:dd:ee:ff' o 'aabbccddeeff'
    
    Returns:
        bytes: Dirección MAC en formato binario (6 bytes)
    """
    """Convierte 'aa:bb:cc:dd:ee:ff' o 'aabbccddeeff' a b'\xaa\xbb\xcc\xdd\xee\xff'"""
    mac = mac.replace(":", "")
    aux = bytes(int(mac[i:i+2], 16) for i in range(0, 12, 2))
    return aux



# Convierte MAC de bytes a string
def mac_bytes_to_str(mac: bytes) -> str:
    """
    Convierte una dirección MAC de formato bytes a string.
    
    Args:
        mac (bytes): Dirección MAC en formato binario (6 bytes)
    
    Returns:
        str: Dirección MAC en formato 'aa:bb:cc:dd:ee:ff'
    """
    aux = ':'.join(f"{b:02x}" for b in mac)
    return aux

# Detecta si el programa se está ejecutando dentro de un contenedor Docker
def running_in_docker() -> bool:
    """
    Detecta si el programa se está ejecutando dentro de un contenedor Docker.
    
    Verifica la existencia del archivo /.dockerenv que Docker crea automáticamente
    en todos los contenedores.
    
    Returns:
        bool: True si está ejecutándose en Docker, False en caso contrario
    """
    return os.path.exists("/.dockerenv")