Distribution EOLE » Modules » Scribe » controle-vnc

# -*- coding: utf-8 -*-

###########################################################################

# EOLE - 2011

# Copyright Pole de Competence Eole  (Ministere Education - Academie Dijon)

# Licence CeCill  cf /root/LicenceEole.txt

# eole@ac-dijon.fr

#

# modifié par Cadoles (http://www.cadoles.com/)

# contact@cadoles.com

#

###########################################################################

import time

import locale

from shutil import rmtree

from os import system, makedirs, symlink, remove, chown, chmod, listdir, fchmod

from os.path import join, islink, isfile, basename, isdir, getmtime

from datetime import datetime

import ldap

from scribe.cadolesldapconf import ROOT_DN, ldap_server, ldap_passwd, SUFFIX, \

        HOME_PATH, SMB_SERVEUR, USER_FILTER, GROUP_FILTER, SHARE_FILTER

PATH_SCRIPTS = '/home/netlogon/scripts'

SCRIPTS_EXT = '.txt'

def logon(user, ostype, machine, adresse_ip):

    def ldap_search(ldap_filter, attrib=None, one=False):

        result = ldap_conn.search_s(SUFFIX, ldap.SCOPE_SUBTREE,

                                    ldap_filter, attrib)

        if len(result) > 0 and len(result[0]) == 2:

            if one:

                return result[0][1]

            else:

                return result

        else:

            return {}

    ldap_conn = ldap.open(ldap_server)

    ldap_conn.simple_bind_s(ROOT_DN, ldap_passwd)

    user_attrib = ldap_search("(&%s(uid=%s))" % (USER_FILTER, user),

                ['objectClass', 'homeDirectory', 'sambaHomeDrive', 'uidNumber',

                'gidNumber'], True)

    userclass = get_userclass_name(user_attrib.get('objectClass', None))

    if not userclass:

        raise Exception("utilisateur %s inconnu" % user)

    if userclass not in ['administratif', 'eleve', 'enseignant']:

        raise Exception("l'utilisateur %s n'est pas autorisé à se connecter" % user)

    # si le fichier existe déjà et qu'il a moins de 1min on loggue juste la

    # connexion

    netlogon = '/home/netlogon/%s%s.txt' % (user, ostype)

    if isfile(netlogon):

        diff = time.time() - getmtime(netlogon)

    else:

        diff = 600

    prim_group = None

    gidnumber = user_attrib['gidNumber'][0].strip()

    if diff > 60:

        """ construction des scripts de connexion windows

        le fichier est du format .bat pour Win95 et .txt pour le reste

        """

        homedir = user_attrib['homeDirectory'][0].strip()

        homedrive = user_attrib['sambaHomeDrive'][0].strip()

        uid = int(user_attrib['uidNumber'][0].strip())

        groups = []

        group_filter = ''

        for dn, grp in ldap_search("(&%s(memberUid=%s))" % (GROUP_FILTER, user),

                attrib=['cn', 'gidNumber']):

            name = grp['cn'][0]

            if grp['gidNumber'][0] == gidnumber:

                prim_group = name

            groups.append(name)

            group_filter += '(sambaShareGroup=%s)' % name

        shares = []

        for share in ldap_search('(&%s(|%s))' % (SHARE_FILTER, group_filter),

                    ['sambaShareName', 'sambaFilePath', 'sambaShareURI',

                    'sambaShareDrive']):

            if share[1].has_key('sambaShareDrive'):

                drive = share[1]['sambaShareDrive'][0]

            else:

                drive = ''

            shares.append({'name': share[1]['sambaShareName'][0],

                            'path': share[1]['sambaFilePath'][0],

                            'uri': share[1]['sambaShareURI'][0],

                            'drive': drive})

        # génération du fichier client

        gen_fich(user, groups, shares, machine, ostype, homedrive, userclass,

                netlogon)

        # mise à jour de /home/u/user/.ftp/

        gen_ftpdir(uid, homedir, shares)

        # mise à jour de /home/u/user/groupes/

        gen_groupedir(uid, homedir, shares)

        # répertoire devoirs

        gen_devdir(user, uid, homedir, userclass)

    if not prim_group:

        prim_group = ldap_search("(&%s(gidNumber=%s))" % (GROUP_FILTER,

                gidnumber), ['displayName'], True)['displayName'][0]

    ldap_conn.unbind()

    # enregistrement de la connexion

    # après puisque si l'utilisateur n'est pas censé se connecter

    # le script n'arrive pas jusqu'à là

    log_connexion(user, prim_group, machine, ostype, adresse_ip)

def get_userclass_name(objectClass):

    """

        Renvoie le nom du module gérant les objets de classe : objectClass

    """

    if objectClass == None:

        return None

    users_objectClass = {

            'Eleves': 'eleve',

            'administrateur': 'enseignant',

            'responsable': 'responsable',

            'administratif': 'administratif',

            'autre': 'autre',

            }

    for objectclass, module in users_objectClass.items():

        if objectclass in objectClass:

            return module

    return None

def gen_devdir(login, uid, homedir, userclass):

    """

        Partie commune pour _gen_devoirdir

    """

    if userclass not in ['eleve', 'enseignant']:

        return

    perso = join(homedir, 'perso')

    # le partage "devoirs" /home/l/login/devoirs

    dev_part = join(homedir, 'devoirs')

    # le dossier U:\devoirs /home/l/login/perso/devoirs

    dev_perso = join(perso, 'devoirs')

    cmd = ""

    for rep in [dev_part, dev_perso]:

        if islink(rep):

            remove(rep)

        if not isdir(rep):

            makedirs(rep, 0750)

        else:

            cmd += '/bin/chmod -R 0750 %s;' % rep

        cmd += '/bin/chown -PR %s %s;' % (login, rep)

        cmd += '/usr/bin/setfacl -PRm u:%s:rwx %s;'%(uid, rep)

        cmd += '/usr/bin/setfacl -dPRm u:%s:rwx %s;'%(uid, rep)

    if userclass == 'enseignant':

        # dossier contenant les devoirs et les données à distribuer du prof

        # U:\devoirs\.distribues ou \\scribe\devoirs\.distribues

        dev_dist_dir = join(HOME_PATH, 'workgroups/devoirs', login)

        if not isdir(dev_dist_dir):

            makedirs(dev_dist_dir, 0755)

        else:

            cmd += '/bin/chmod -R 0755 %s;' % dev_dist_dir

        cmd += '/usr/bin/setfacl -PRbk %s;' % dev_dist_dir

        cmd += '/usr/bin/setfacl -PRm u:%s:rwx %s;' % (uid, dev_dist_dir)

        cmd += '/usr/bin/setfacl -dPRm u:%s:rwx %s;' % (uid, dev_dist_dir)

        for rep in [dev_part, dev_perso]:

            link = join(rep, '.distribues') # le cacher avec un "."

            if not islink(link):

                symlink(dev_dist_dir, link)

    system(cmd)

def gen_ftpdir(uid, homedir, shares):

    """

        Gestion du répertoire ".ftp"

    """

    ftpdir = join(homedir, '.ftp')

    if isdir(ftpdir):

        rmtree(ftpdir)

    makedirs(ftpdir, 0500)

    chown(ftpdir, uid, -1)

    #les ACLs ne sont pas mises

    #system('setfacl -bk %s' % ftpdir)

    #chmod(ftpdir, 0500)

    homedir = join(HOME_PATH, homedir[6:])

    symlink(join(homedir, 'perso'), join(ftpdir, 'perso'))

    for share in shares:

        if share['name'] not in ['icones$', 'groupes']:

            if HOME_PATH != '/home':

                share['path'] = share['path'].replace('/home',

                        HOME_PATH)

            symlink(share['path'], join(ftpdir, share['name']))

def gen_groupedir(uid, homedir, shares):

    """

        Gestion du répertoire "groupes"

    """

    groupedir = join(homedir, 'groupes')

    if isdir(groupedir):

        rmtree(groupedir)

    makedirs(groupedir, 0500)

    chown(groupedir, uid, -1)

    #les ACLs ne sont pas mise

    #system('setfacl -bk %s' % groupedir)

    for share in shares:

        # sinon partage avec lettre de lecteur

        if share['drive'] == "":

            # lien dans le répertoire "groupes"

            symlink(share['path'], join(groupedir, share['name']))

def log_connexion(user, primgrp, machine, ostype, adresse_ip):

    """

    Enregistrement de la connexion

    """

    locale.setlocale(locale.LC_ALL, '')

    try:

        sdate = datetime.now().strftime("%a %d %b %Y %H:%M").capitalize()

        cmd = 'echo CONNECTION %s %s %s %s %s %s' % (sdate, user,

                primgrp, machine, ostype, adresse_ip)

        system('%s >> /var/log/samba/%s.log' % (cmd, machine))

        system('%s >> /var/log/samba/connexions.log' % (cmd))

    except:

        pass

#############################################################

## Génération des fichiers de logon

#############################################################

def gen_fich(user, groups, shares, machine, ostype, homedrive, userclass,

        netlogon):

    """

    Génération du fichier lu par le client

    """

    script = ""

    # gestion des groupes et des partages

    for share in shares:

        # sinon créé un lien symbolique

        if share['drive'] != "":

            # partage avec lettre de lecteur

            if ostype == "Win95":

                script += gen_lecteur_bloc_win95(share['drive'],

                        share['uri'])

            else:

                script += gen_lecteur_bloc(share['drive'], share['uri'])

    # montage du répertoire personnel pour 9x et Samba

    #FIXME: pourquoi Samba ?

    if ostype in ['Win95', 'Samba']:

        script += gen_lecteur_bloc_win95(homedrive, '\\\\%s\\PERSO' %

                SMB_SERVEUR)

    if ostype == 'Win95':

        """Gestion "à l'ancienne" pour Win9x/Me

        exécuté par le service et logon.py(.exe) sur les clients

        """

        script += gen_vnc_line(userclass)

        script += gen_esu()

    # gestion des scripts additionnels

    debut, fin = get_scripts(user, machine, ostype, groups)

    # écriture du fichier

    write_fich(netlogon, debut + script + fin)

def gen_letter_share(lettre, share):

    """lettre : supprime les ":", juste la lettre

    share : le partage sans \ à la fin

    """

    while share[-1] == '\\':

        share = share[:-1]

    return lettre[:1], share

def gen_lecteur_bloc(lettre, share):

    """Génère un bloc de ligne pour le montage

    d'un lecteur réseau "share" sur la lettre "lettre"

    ou sur * sinon (sauf pour win95)

    """

    lettre, share = gen_letter_share(lettre, share)

    return 'lecteur,%s:,%s\r\n' % (lettre, share)

def gen_cmd_line(line, hide=False, nowait=False):

    """génère une ligne DOS (avec le bon retour chariot) (pas win95)

    """

    chaine = 'cmd,%s' % line

    if hide:

        chaine += ',HIDDEN'

    if nowait:

        chaine += ',NOWAIT'

    return chaine + '\r\n'

def get_scripts(user, machine, ostype, user_groups):

    """Gestion des scripts externes

    """

    # motif à rechercher dans les fichiers externes

    # (debut_script %motif% fin_script)

    motif_include = [ "%%NetUse%%", "%NetUse%" ]

    # chemin par défaut des scripts externes

    buffer_debut,  buffer_fin = '', ''

    # on traite ceux qui sont présents

    for chemin in get_scripts_list(user, machine, ostype, user_groups):

        if isfile(chemin):

            debut = 1

            for line in file(chemin,"r"):

                line = line.strip()

                if line in motif_include:

                    debut = 0

                else:

                    if debut == 1:

                        buffer_debut += parse_line(ostype, line)

                    else:

                        buffer_fin += parse_line(ostype, line)

    return (buffer_debut, buffer_fin)

def get_scripts_list(user, machine, ostype, user_groups):

    """On créé la liste des fichiers possibles

    +--PATH_SCRIPTS/users/<user>.txt

    +--PATH_SCRIPTS/groups/<group>.txt

    +--PATH_SCRIPTS/machines/<machine>.txt

    +--PATH_SCRIPTS/os/<os>.txt

    +--PATH_SCRIPTS/os/<os>/<group>.txt

    +--PATH_SCRIPTS/os/<os>/<user>.txt

    """

    chemins = [join(PATH_SCRIPTS, 'users', '%s%s' % (user, SCRIPTS_EXT))]

    chemins.append(join(PATH_SCRIPTS, 'machines', '%s%s' %

                (machine, SCRIPTS_EXT)))

    for group in user_groups:

        chemins.append(join(PATH_SCRIPTS, 'groups', '%s%s' %

                    (group, SCRIPTS_EXT)))

        chemins.append(join(PATH_SCRIPTS, 'os', '%s' % ostype, '%s%s' %

                    (group, SCRIPTS_EXT)))

    chemins.append(join(PATH_SCRIPTS, 'os', '%s%s' % (ostype, SCRIPTS_EXT)))

    chemins.append(join(PATH_SCRIPTS, 'os', ostype, '%s%s' %

                (user, SCRIPTS_EXT)))

    return chemins

def parse_line(ostype, line):

    items = [ i.strip() for i in line.split(',') ]

    if items[0] == 'cmd':

        # exécuter une commande

        if ostype == "Win95":

            return gen_cmd_line_win95(items[1])

        else:

            hide = 'HIDDEN' in items

            nowait = 'NOWAIT' in items

            return gen_cmd_line(items[1], hide, nowait)

    elif items[0] == 'lecteur':

        # monter un partage

        lettre, partage = items[1], items[2]

        if ostype == "Win95":

            return gen_lecteur_bloc_win95(lettre, partage)

        else:

            return gen_lecteur_bloc(lettre, partage)

    return ''

def write_fich(netlogon, lines):

    """Ecrit le fichier

    """

    fic = file(netlogon, 'w')

    fchmod(fic.fileno(), 0644)

    #convert to DOS format

    #lines = lines.replace('\n', '\r\n')

    lines = lines.decode('utf8').encode('cp437')

    fic.write(lines)

    fic.close()

#########

# Win9x #

#########

def test_esu():

    """

    vérifie si Esu est utilisé

    """

    for fic in listdir('/home/esu/Base'):

        if fic.lower() == 'esuclnt.exe':

            return True

    return False

def gen_esu():

    """Ajoute la ligne pour Esu pour win95

    """

    if test_esu():

        esuline = '\\\\%s\\ESU\\Base\\esuclnt.exe' % SMB_SERVEUR

        return gen_cmd_line_win95(esuline)

    return ''

def gen_vnc_line(userclass):

    """VNC utilise maintenant login/pass du domaine

    ce .reg spécifie le type de controle possible$

    (desactive, simple, controle) lors de l'observation pour les Win95

    """

    vnccontrole = 'regedit /s \\\\%s\\netlogon\\scripts\\os\\Win95\\vnc_controle.reg' % SMB_SERVEUR

    vnckill = '%windir%\\eole\\ultravnc\\winvnc -kill'

    vncservice = '%windir%\\eole\\ultravnc\\winvnc -service'

    bloc = gen_cmd_line_win95(vnccontrole)

    bloc += gen_cmd_line_win95(vnckill)

    if userclass == 'eleve':

        bloc += gen_cmd_line_win95(vncservice)

    return bloc

def gen_cmd_line_win95(line):

    """génère une ligne DOS Win95 (avec le bon retour chariot)

    """

    saut_ligne = chr(13)+chr(10)

    return '%s%s' % (line, saut_ligne)

def gen_lecteur_bloc_win95(lettre, share):

    """Génère un bloc de ligne pour le montage

    d'un lecteur réseau "share" sur la lettre "lettre"

    ou sur * sinon pour win95

    """

    lettre, share = gen_letter_share(lettre, share)

    sharename = share.split('\\')[-1].replace('$', '')

    # on définit la commande net use selon le type d'os (NT ou 9X)

    label = '%s%s' % (lettre, sharename)

    chaine_net_use = 'NET USE '

    bloc = gen_cmd_line_win95('IF EXIST %s:\\nul goto err%s' % (lettre, label))

    bloc += gen_cmd_line_win95('%s %s: %s'%(chaine_net_use, lettre, share))

    bloc += gen_cmd_line_win95('goto suit%s'%(label))

    bloc += gen_cmd_line_win95(':err%s'%(label))

    bloc += gen_cmd_line_win95('%s * %s'%(chaine_net_use, share))

    bloc += gen_cmd_line_win95(':suit%s'%(label))

    return bloc