#!/bin/bash /usr/scripts/python.sh
# ⁻*- coding: utf-8 -*-
#
# Ce fichier contient la définition de plusieurs fonctions d'interface à freeradius
# qui peuvent être appelées (suivant les configurations) à certains moment de
# l'éxécution.
#

import logging
import traceback
import netaddr
import radiusd # Module magique freeradius (radiusd.py is dummy)

import lc_ldap.shortcuts
from lc_ldap.crans_utils import escape as escape_ldap
import lc_ldap.crans_utils
import lc_ldap.objets
from gestion.config.config import vlans
from gestion.gen_confs.trigger import trigger_generate_cochon as trigger_generate
import annuaires_pg

# Voilà, pour faire marcher le V6Only, il faut se retirer l'ipv4 de sa machine
# ou en enregistrer une nouvelle (sans ipv4) avec une autre mac. Moi j'ai la
# flemme donc je hardcode les MAC qui doivent toujours être placées sur le vlan v6only
test_v6 = [
   u'00:26:c7:a6:9e:16',  # cerveaulent (machine de b2moo)
]

USERNAME_SUFFIX = '.wifi.crans.org'

## -*- Logging -*-
# Initialisation d'un logger pour faire des stats etc
# pour l'instant, on centralise tout sur thot en mode debug
logger = logging.getLogger('auth.py')
logger.setLevel(logging.DEBUG)
formatter = logging.Formatter('%(name)s: [%(levelname)s] %(message)s')
handler = logging.handlers.SysLogHandler(address = '/dev/log')
try:
    handler.addFormatter(formatter)
except AttributeError:
    handler.formatter = formatter
logger.addHandler(handler)

## -*- Types de blacklists -*-
#: reject tout de suite
bl_reject = [u'bloq']

#: place sur le vlan isolement
bl_isolement = [u'virus', u'autodisc_virus', u'autodisc_p2p', u'ipv6_ra']

# TODO carte_etudiant: dépend si sursis ou non (regarder lc_ldap)
# TODO LOGSSSSS

#: place sur accueil
bl_accueil = [u'carte_etudiant', u'chambre_invalide', u'paiement']

## -*- Decorateurs -*-
# À appliquer sur les fonctions qui ont besoin d'une conn ldap
use_ldap_admin = lc_ldap.shortcuts.with_ldap_conn(retries=2, delay=5,
    constructor=lc_ldap.shortcuts.lc_ldap_admin)
use_ldap = lc_ldap.shortcuts.with_ldap_conn(retries=2, delay=5,
    constructor=lc_ldap.shortcuts.lc_ldap_anonymous)

def radius_event(f):
    """Décorateur pour les fonctions d'interfaces avec radius.
    Une telle fonction prend un uniquement argument, qui est une liste de tuples
    (clé, valeur) et renvoie un triplet dont les composantes sont :
     * le code de retour (voir radiusd.RLM_MODULE_* )
     * un tuple de couples (clé, valeur) pour les valeurs de réponse (accès ok
       et autres trucs du genre)
     * un tuple de couples (clé, valeur) pour les valeurs internes à mettre à
       jour (mot de passe par exemple)
    Voir des exemples plus complets ici:
    https://github.com/FreeRADIUS/freeradius-server/blob/master/src/modules/rlm_python/

    On se contente avec ce décorateur (pour l'instant) de convertir la liste de
    tuples en entrée en un dictionnaire."""

    def new_f(auth_data):
        data = dict()
        for (key, value) in auth_data or []:
            # Beware: les valeurs scalaires sont entre guillemets
            # Ex: Calling-Station-Id: "une_adresse_mac"
            data[key] = value.replace('"', '')
        return f(data)

    return new_f

@use_ldap
def get_machines(data, conn):
    """Obtient la liste de machine essayant actuellement de se connecter"""
    mac = data.get('Calling-Station-Id', None)
    if mac:
        try:
            mac = lc_ldap.crans_utils.format_mac(mac.decode('ascii', 'ignore'))
        except:
            radiusd.radlog(radiusd.L_ERR, 'Cannot format MAC !')
            mac = None
    username = data.get('User-Name', None)
    if username:
        username = escape_ldap(username.decode('ascii', 'ignore'))
        if username.endswith(USERNAME_SUFFIX):
            username = username[:-len(USERNAME_SUFFIX)]

    base = u'(objectclass=machine)'

    if mac is None:
        radiusd.radlog(radiusd.L_ERR, 'Cannot read client MAC from AP !')
    if username is None:
        radiusd.radlog(radiusd.L_ERR, 'Cannot read client User-Name !')

    # Sanitize all the things
    mac = escape_ldap(mac)
    username = escape_ldap(username)

    # Liste de filtres ldap à essayer
    search_strats = [
        # Case 1: Search by mac (reported by AP)
        u'(&%s(macAddress=%s))' % (base, mac),
        # Case 2: unregistered mac
        u'(&%s(macAddress=<automatique>)(host=%s%s))' %
                (base, username, USERNAME_SUFFIX),
    ]

    for filter_s in search_strats:
        res = conn.search(filter_s)
        if res:
            break

    return res

def get_prise_chbre(data):
    """Extrait la prise (filaire) et la chambre correspondante.
    Par convention, le nom d'une chambre commence (lettre du bâtiment) par une
    majuscule, tandis que la prise correspondante commence par une miniscule.
    """
    ## Filaire: NAS-Identifier => contient le nom du switch (batm-3.adm.crans.org)
    ##          Nas-Port => port du switch (ex 42)

    # Lettre du bâtiment (C, B, A, etc, en majuscule)
    bat_name = None

    # Numéro du switch
    bat_num = None

    # Port sur le switch
    port = None

    nas = data.get('Nas-Identifier', None)
    if nas:
        if nas.startswith('bat'):
            nas = value.split('.', 1)[0]
            try:
                bat_name = nas[3].upper()
                bat_num = int(nas.split('-', 1)[1])
            except IndexError, ValueError:
                pass
    port = data.get('Nas-Port', None)
    if port:
        port = int(value)

    if bat_num is not None and bat_name and port:
        prise = bat_name.lower() + "%01d%02d" % (bat_num, port)
        try:
            chbre = bat_name + annuaires_pg.reverse(bat_name, prise[1:])[0]
        except IndexError:
            chbre = None
        return prise, chbre

@use_ldap_admin
def register_mac(data, machine, conn):
    """Enregistre la mac actuelle sur une machine donnée."""
    mac = data.get('Calling-Station-Id', None)
    if mac is None:
        radiusd.radlog(radiusd.L_ERR, 'Cannot find MAC')
        return
    mac = mac.decode('ascii', 'ignore').replace('"','')
    try:
        mac = lc_ldap.crans_utils.format_mac(mac).lower()
    except:
        radiusd.radlog(radiusd.L_ERR, 'Cannot format MAC !')
        return

    with conn.search(unicode(machine.dn.split(',',1)[0]), mode='rw')[0] as machine:
        radiusd.radlog(radiusd.L_INFO, 'Registering mac %s' % mac)
        machine['macAddress'] = mac
        machine.history_add(u'auth.py', u'macAddress (<automatique> -> %s)' % mac)
        machine.validate_changes()
        machine.save()
        radiusd.radlog(radiusd.L_INFO, 'Mac set')
        radiusd.radlog(radiusd.L_INFO, 'Triggering komaz')
        trigger_generate('komaz')
        radiusd.radlog(radiusd.L_INFO, 'done ! (triggered komaz)')

@radius_event
@use_ldap_admin
@use_ldap
def instantiate(p, *conns):
    """Utile pour initialiser les connexions ldap une première fois (otherwise,
    do nothing)"""
    pass

@radius_event
def authorize_wifi(data):
    """Section authorize pour le wifi
    (NB: le filaire est en accept pour tout le monde)
    Éxécuté avant l'authentification proprement dite. On peut ainsi remplir les
    champs login et mot de passe qui serviront ensuite à l'authentification
    (MschapV2/PEAP ou MschapV2/TTLS)"""

    items = get_machines(data)

    if not items:
        radiusd.radlog(radiusd.L_ERR, 'lc_ldap: Nobody found')
        return radiusd.RLM_MODULE_NOTFOUND

    if len(items) > 1:
        radiusd.radlog(radiusd.L_ERR, 'lc_ldap: Too many results (took first)')

    machine = items[0]

    if '<automatique>' in machine['macAddress']:
        register_mac(data, machine)

    proprio = machine.proprio()
    if isinstance(proprio, lc_ldap.objets.AssociationCrans):
        radiusd.radlog(radiusd.L_ERR, 'Crans machine trying to authenticate !')
        return radiusd.RLM_MODULE_INVALID

    for bl in machine.blacklist_actif():
        if bl.value['type'] in bl_reject:
            return radiusd.RLM_MODULE_REJECT

    if not machine.get('ipsec', False):
        radiusd.radlog(radiusd.L_ERR, 'WiFi authentication but machine has no' +
            'password')
        return radiusd.RLM_MODULE_REJECT

    password = machine['ipsec'][0].value.encode('ascii', 'ignore')

    # TODO: feed cert here
    return (radiusd.RLM_MODULE_UPDATED,
	    (),
        (
          ("Cleartext-Password", password),
        ),
      )

@radius_event
def authorize_fil(data):
    """For now, do nothing.
    TODO: check bl_reject.
    TODO: check chap auth
    """
    return radiusd.RLM_MODULE_OK

@radius_event
def post_auth_wifi(data):
    """Appelé une fois que l'authentification est ok.
    On peut rajouter quelques éléments dans la réponse radius ici.
    Comme par exemple le vlan sur lequel placer le client"""

    port, vlan_name, reason = decide_vlan(data, True)
    mac = data.get('Calling-Station-Id', None)

    log_message = '(wifi) %s -> %s [%s%s]' % \
      (port, mac, vlan_name, (reason and u': ' + reason).encode('utf-8'))
    logger.info(log_message)
    radiusd.radlog(radiusd.L_AUTH, log_message)

    # Si NAS ayant des mapping particuliers, à signaler ici
    vlan_id = vlans[vlan_name]

    # WiFi : Pour l'instant, on ne met pas d'infos de vlans dans la réponse
    # les bornes wifi ont du mal avec cela
    return radiusd.RLM_MODULE_OK

@radius_event
def post_auth_fil(data):
    """Idem, mais en filaire.
    Pas testé."""

    port, vlan_name, reason = decide_vlan(data, False)
    mac = data.get('Calling-Station-Id', None)

    log_message = '(fil) %s -> %s [%s%s]' % \
      (port, mac, vlan_name, (reason and u': ' + reason).encode('utf-8'))
    logger.info(log_message)
    radiusd.radlog(radiusd.L_AUTH, log_message)

    # Si NAS ayant des mapping particuliers, à signaler ici
    vlan_id = vlans[vlan_name]

    # Filaire
    return (radiusd.RLM_MODULE_UPDATED,
        (
            ("Tunnel-Type", "VLAN"),
            ("Tunnel-Medium-Type", "IEEE-802"),
            ("Tunnel-Private-Group-Id", '%d' % vlan),
        ),
        ()
    )

@use_ldap
def decide_vlan(data, is_wifi, conn):
    """Décide du vlan non-taggué à assigner, et donne une raison
    à ce choix.
    Retourne un (port, vlan_name, reason)
    où port = est une prise réseau / chambre (si filaire)
              "wifi" si wifi
    """

    if is_wifi:
        decision = 'wifi', u''
        port = data.get('Called-Station-Id', '?')
    else:
        decision = 'adherent', u''
        prise, chbre = get_prise_chbre(data)
        port = "%s/%s" % (prise, chbre)

    items = get_machines(data)
    if not items:
        return (port, 'accueil', 'Machine inconnue')

    machine = items[0]
    proprio = machine.proprio()

    if not machine['ipHostNumber']:
        decision = 'v6only', u'No IPv4'
    elif unicode(machine['macAddress'][0]) in test_v6:
        decision = 'v6only', u'Test machine v6'
    elif machine['ipHostNumber'][0].value in netaddr.IPNetwork('10.2.9.0/24'):
        # Cas des personnels logés dans les appartements de l'ENS
        decision = 'appts', u'Personnel ENS'

    # Application des blacklists
    for bl in machine.blacklist_actif():
        if bl.value['type'] in bl_isolement:
            decision = 'isolement', unicode(bl)
        if bl.value['type'] in bl_accueil:
            decision = 'accueil', unicode(bl)

    # Filaire : protection anti-"squattage"
    if not is_wifi:
        # Si l'adhérent n'est pas membre actif, il doit se brancher depuis la
        # prise d'un autre adhérent à jour de cotisation
        force_ma = False
        if chbre is None and not proprio['droits']:
            decision =  "accueil", u"Chambre inconnue"
        elif chbre is not None:
            chbre = escape_ldap(chbre)
            hebergeurs = conn.search(u'(&(chambre=%s)(cid=*)(aid=*))' % chbre)
            for hebergeur in hebergeurs:
                if not hebergeur.blacklist_actif():
                    break
            else:
                # Si tous les hebergeurs sont blacklistés, autorisé
                # uniquement si MA
                if not proprio['droits']:
                    decision = "accueil", "Hébergeur blacklisté"
                else:
                    force_ma = True
        else:
            force_ma = True
        if force_ma:
            decision = decision[0], decision[1] + u' (force MA)'

    return (port,) + decision

@radius_event
def dummy_fun(p):
    return radiusd.RLM_MODULE_OK

def detach(p=None):
    """Appelé lors du déchargement du module (enfin, normalement)"""
    print "*** goodbye from example.py ***"
    return radiusd.RLM_MODULE_OK