"""

gettext initialization, in order to translate necessary strings at runtime.

This MUST be done before any import or usage of _() around strings.

"""

# Gettext pour adapter certaines chaines de caracteres a la langue du

# systeme (traduction en anglais ou francais)

# => DOIT etre fait avant toute constante chaine _("...") et tout import

import gettext, locale, os.path

# repertoire "locale": normalement un sous-repertoire du script principal

#locale_dir = os.path.join(plx.get_main_dir(), "locale")

# locale dir is a subfolder of this script's folder:

#TODO: fix this when compiled with py2exe...

locale_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'locale')

#print 'locale_dir =', locale_dir

# initialisation de la locale (cf. doc Python): est-ce toujours necessaire ?

locale.setlocale(locale.LC_ALL, '')

# langue du systeme: 2 premieres lettres de la locale/lang

try:

lang = locale.getdefaultlocale()[0][:2]

except:

# workaround if locale cannot be determined

lang = 'en'

#print 'lang =', lang

if lang != 'fr':

# ordre prefere des langues: 1) systeme, 2) english, 3) francais

languages=[lang, 'en', 'fr']

# On charge la langue correspondante depuis le repertoire locale:

try:

gt = gettext.translation("ExeFilter", locale_dir, languages)

# puis on installe la fonction de traduction _():

gt.install(unicode=True)

except:

# en cas d'erreur, on doit quand meme definir _() comme une fonction

# "builtin" qui renvoie la chaine inchangee:

__builtins__._ = lambda text: text

else:

# si la langue est 'fr', on n'utilise aucune traduction:

gettext.NullTranslations().install()

"""

Retourne le chemin du fichier journal securite.

Si le fichier journal n'est pas encore créé, renvoie None

@return: le chemin du fichier journal

@rtype: str

"""

"""

Retourne le chemin du fichier journal de débogage.

Si le fichier journal n'est pas encore créé, renvoie None

@return: le chemin du fichier journal

@rtype: str

"""

return path_debugfile

global nom_journal_debug

if nom_journal_debug == None:

#TODO: renvoyer une valeur par defaut ?

return None

else:

rep_journaux = path(p.parametres['rep_journaux'].valeur)

"""

Retourne le chemin d'accès au fichier contenant le rapport au format html

Si le fichier du rapport n'est pas encore créé, renvoie None

@return: chemin d'accès au fichier contenant le rapport au format html

@rtype: str

"""

if nom_rapport == None:

chemin_rapport = None

else:

#chemin_rapport = REP_RAPPORT + nom_rapport

chemin_rapport = path(p.parametres['rep_rapports'].valeur) / nom_rapport

chemin_rapport = chemin_rapport.abspath()

"""

Display HTML report in the web browser

"""

if get_rapport():

"""

Annule le transfert en cours

"""

"""

Retourne le nombre de fichiers à analyser ou None si le moteur

n'a pas encore commencé le transfert

@return: le nombre de fichiers à analyser

@rtype: int

"""

if commun.transfert_commence == True : return commun.nb_fichiers

"""

Retourne le nombre fichiers déjà analyser ou None si le moteur

n'a pas encore commencé le transfert

@return: le nombre de fichiers déjà analysés

@rtype: int

"""

if commun.transfert_commence == True : return commun.compteur_avancement

"""

Preparation du repertoire d'archivage avant transfert.

@param politique: objet Politique employe pour le transfert

@param taille_src: taille totale des fichiers source a nettoyer, en octets

"""

# si le repertoire d'archivage n'existe pas, on le cree:

chem_arc = path(politique.parametres['rep_archives'].valeur)

try:

os.makedirs(chem_arc)

except:

pass

# calcul de la taille actuelle du répertoire archivage

taille_arc = 0

for f in chem_arc.walkfiles():

taille_arc += f.size

# test si la taille des fichiers source est supérieure à celle du rép d'archivage

# si c'est le cas, on génère une exception

if taille_src > politique.parametres['taille_archives'].valeur:

msg = _(u"La taille des fichiers source est superieure a la taille du repertoire d'archivage.")

Journal.error(msg)

raise RuntimeError, msg

# boucle pour effacer les sous-rép les plus anciens dans le cas où il n'y a pas assez

# d'espace disque dans le rép archivage pour copier les fichiers source

while politique.parametres['taille_archives'].valeur < taille_arc + taille_src:

date_archive = 0

taille_rep_archive = 0

# boucle pour déterminer quel est le sous-rép archive le plus ancien

for rep in chem_arc.dirs():

if date_archive == 0:

# on récupère la date du 1er sous-rép archive lu

date_archive = os.path.getmtime(rep)

rep_archive = rep

# si la date du sous-rép archive lu est inférieure à date_archive,

# ce sous-rép devient le plus ancien

elif date_archive > os.path.getmtime(rep):

date_archive = os.path.getmtime(rep)

rep_archive = rep

if os.path.exists(rep_archive):

# calcul de la taille du sous-rép archive le plus ancien

for rep in rep_archive.walkfiles():

taille_rep_archive += rep.size

# on met à jour la taille du rép temp principal

taille_arc = taille_arc - taille_rep_archive

# on efface le sous-rép temp le plus ancien

rep_archive.rmtree()

else:

# s'il n'y a plus de sous-rép archive à effacer, on génère une exception

msg = _(u"repertoire d'archivage deja vide => taille source trop grande")

Journal.error(msg)

pol=None, dest_is_a_file=False, force_extension=None,

logfile=None):

"""

Main function to scan or clean files and directories.

(thread safe: uses a lock to make sure only one thread runs it)

Lance le transfert et l'analyse des répertoires et/ou fichiers source

@param liste_source: la liste des sources à transférer

@type liste_source: list

@param destination: destination directory, or None/'' for scan-only mode

@type destination: str

@param type_transfert: le type de transfert pour charger la politique de filtre

@type type_transfert: str

@param handle: le handle de connexion a utiliser pour exécuter le filtre

@type handle: pyHandle

#@param taille_temp: taille maximale du répertoire temporaire, en octets. Taille par défaut 10Go (DVD double couche)

#@type taille_temp: int

@param dest_is_a_file: False if destination is a dir (default),

True if it's a filename.

@type dest_is_a_file: bool

@param force_extension: if set, force filename extension to a specific value

(used to control which filters are applied)

Note: force_extension may be "" or must start with a dot

@type force_extension: str, unicode

"""

# run the function with a lock to make sure only one thread can run it at a

# time:

with lock_transfert:

exitcode = _transfert_not_threadsafe(liste_source, destination,

type_transfert, handle, pol, dest_is_a_file, force_extension,

logfile)

pol=None, dest_is_a_file=False, force_extension=None,

logfile=None):

"""

Main function to scan or clean files and directories.

Not thread safe: should not be called directly, use transfert() instead.

"""

global nom_journal_secu

global path_logfile

global nom_journal_debug

global path_debugfile

global nom_rapport

global p

# obsolete, to be removed?

if sys.platform == 'win32':

if handle != None :

win32security.ImpersonateLoggedOnUser(handle)

taille_src = 0

# on récupère le nom de l'utilisateur qui lance ExeFilter, avec nom de

# domaine (ou de machine) sous Windows:

try:

username = get_username()

username_withdomain = get_username(with_domain=True)

except:

# workaround if user name cannot be determined

username = username_withdomain = 'unknown'

# création du tronc commun pour les noms des journaux et des rapports:

nom_machine = socket.gethostname()

date = time.strftime("%Y-%m-%d", time.localtime())

heure = time.strftime("%Hh%Mm%Ss", time.localtime())

nom_commun = date + "_" + nom_machine + "_" + username + "_" + heure

# on transmet à transfert :

# soit un objet Politique déjà configuré,

# soit un nom de fichier de config directement,

# soit une liste de fichiers de config,

# soit un mot-clé " entree " ou " sortie " décrivant le type de transfert,

# afin de conserver la compatibilité avec l'IHM actuelle. Dans ce cas le fichier de config filtres.cfg doit être analysé correctement.

if pol != None:

if isinstance(pol, Politique.Politique):

p = pol

elif isinstance (pol, [file, str, unicode, list]):

p = Politique.Politique(pol)

# obsolete, to be removed?

elif type_transfert in ("entree", "sortie"):

# vérifier si le fichier existe

# si le fichier existe alors on le charge

# sinon politque par défaut

# p = Politique.Politique("politique_%s.cfg" % type_transfert)

p = Politique.Politique()

else:

# politique par défaut

p = Politique.Politique()

# store policy in a global variable: to be removed for multithreading

commun.politique = p

# nom des fichiers log = nom de la machine + date et heure du transfert

if logfile == 'auto':

print 'logfile=auto'

# generate log filename automatically (one per session):

nom_journal_secu = nom_commun + ".log"

# set full path in logs folder:

logs_folder = path(p.parametres['rep_journaux'].valeur)

# make sure the logs folder exists (if logging to file is enabled):

if (not os.path.exists(logs_folder)) and p.parametres['journal_securite'].valeur:

logs_folder.makedirs()

path_logfile = (logs_folder / nom_journal_secu).abspath()

elif logfile:

print 'logfile=%s' % logfile

# use provided log filename:

nom_journal_secu = logfile

# set full path directly:

path_logfile = path(nom_journal_secu).abspath()

else:

nom_journal_secu = None

path_logfile = None

# debug logfile: only handled via policy, auto name

nom_journal_debug = "debug_" + nom_commun + ".log"

# set full path in logs folder:

logs_folder = path(p.parametres['rep_journaux'].valeur)

# make sure the logs folder exists (if logging to file is enabled):

if (not os.path.exists(logs_folder)) and p.parametres['journal_debug'].valeur:

logs_folder.makedirs()

path_debugfile = (logs_folder / nom_journal_debug).abspath()

# création du journal d'évènements:

Journal.init_journal(p, journal_secu = path_logfile, journal_debug = path_debugfile)

# création des sous-répertoires temp et archivage:

commun.sous_rep_archive = "transfert_" + nom_commun

Journal.important(_(u"ExeFilter v%s lancé par utilisateur %s sur la machine %s") %

(XF_VERSION, username_withdomain, nom_machine))

# on ajoute la politique dans le journal:

p.journaliser()

Journal.info2(_(u"Début de l'analyse"))

Rapport.liste_resultats = []

# liste des répertoires et/ou fichiers source

liste_conteneurs_source = []

# initialisation des variables globales

commun.nb_fichiers = commun.compteur_avancement = 0

commun.continuer_transfert = True

commun.transfert_commence = False

# if destination is a single file, check if source is one file:

if dest_is_a_file:

assert(len(liste_source)==1)

assert(os.path.isfile(liste_source[0]))

# if destination is empty (None or ''), set mode to scan-only instead of clean:

if destination:

commun.clean_mode = True

Journal.debug('Analysis mode: clean')

else:

commun.clean_mode = False

Journal.debug('Analysis mode: scan only')

Journal.debug('clean_mode=%s' % commun.clean_mode)

# boucle pour lire chaque répertoire et/ou fichier contenu dans la liste

for source in liste_source :

# on vérifie le type de source: répertoire ou fichier ?

if os.path.isdir(source):

#rep_source = Conteneur_Repertoire.Conteneur_Repertoire (source, destination)

# si source est G:/tutu/tata, rep_relatif_source = tata

(head, tail) = os.path.split(source)

rep_relatif_source = tail

rep_source = Conteneur_Repertoire.Conteneur_Repertoire (source,

destination, rep_relatif_source, politique=p)

# calcul de la taille du répertoire source

taille_src += rep_source.compter_taille_rep()

else:

#rep_source = Conteneur_Fichier.Conteneur_Fichier (source, destination)

rep_relatif_source = ""

rep_source = Conteneur_Fichier.Conteneur_Fichier (source,

destination, rep_relatif_source, politique=p,

dest_is_a_file=dest_is_a_file, force_extension=force_extension)

# calcul de la taille du fichier source

taille_src += os.stat(source).st_size

# on ajoute les conteneurs source à la liste

liste_conteneurs_source.append(rep_source)

# on incrémente le compteur nombre de fichiers total

commun.nb_fichiers += rep_source.compter_nb_fichiers()

# test si la taille des fichiers source est supérieure à celle du rép temp

# si c'est le cas, on génère une exception

#if taille_src > taille_temp:

if taille_src > p.parametres['taille_temp'].valeur:

msg = "La taille des fichiers source est superieure a la taille du repertoire temporaire."

Journal.error(msg)

raise RuntimeError, msg

# initialisation de l'archivage:

if parametres['archive_after'].valeur:

init_archivage(p, taille_src)

commun.transfert_commence = True

# boucle d'analyse de chaque conteneur source contenu dans la liste

for conteneur_source in liste_conteneurs_source:

Journal.info2(u"Analyse de contenu de %s ..." % conteneur_source)

# ici il faudrait un try pour gérer toutes les exceptions, journaliser

# et nettoyer s'il y a des erreurs.

# ou alors lancer un thread...

# test de l'interruption de transfert par l'utilisateur

if commun.continuer_transfert == True:

# s'il n'y a pas d'interruption, on lance le nettoyage

liste_resultat = conteneur_source.nettoyer(p)

# s'il y a eu une interruption pendant nettoyer(), on s'arrête

if commun.continuer_transfert == False:

break

# génération du rapport

nom_rapport = "rapport_" + nom_commun

Journal.info2(u"Génération du rapport: %s ..." % nom_rapport)

chemin_rapport = p.parametres['rep_rapports'].valeur + nom_rapport

resume = Rapport.generer_rapport(chemin_rapport,

', '.join(liste_source), destination ,

XF_VERSION, XF_DATE, commun.continuer_transfert)

Journal.info2(u"Fin de l'analyse")

# log du résumé de la dépollution

Journal.important(_(u'Résumé : %d fichiers analysés ; '

u'%d fichiers acceptés ; %d fichiers nettoyés ; %d fichiers refusés ; %d erreurs')

% (resume[0], resume[1], resume[2], resume[3], resume[4]))

if commun.continuer_transfert == False:

Journal.warning(u"TRANSFERT ANNULE par l'utilisateur")

# return exit code according to results:

#TODO: use results from containers instead of this quick hack:

clean = resume[1]

cleaned = resume[2]

blocked = resume[3]

errors = resume[4]

if errors:

exitcode = p.parametres['exitcode_error'].valeur

elif (clean+cleaned>0) and (cleaned+blocked>0):

exitcode = p.parametres['exitcode_cleaned'].valeur

elif (clean>0) and (cleaned+blocked == 0):

exitcode = p.parametres['exitcode_clean'].valeur

elif (blocked>0) and (clean+cleaned == 0):

exitcode = p.parametres['exitcode_blocked'].valeur

else:

raise ValueError, 'Summary values look wrong...'

Journal.debug('Exit code: %d' % exitcode)

Journal.fermer_journal()

return exitcode

"""

Clean all files of a directory (source_dir) according to the specified

policy, store the result in dest_dir.

Optionally write log to logfile.

Return an exit code according to the overall result (see doc).

"""

# TODO: force logfile option in policy if logfile is set

exitcode = transfert([source_dir], dest_dir, pol=policy, logfile=logfile)

"""

Scan all files of a directory (source_dir) according to the specified

policy.

Optionally write log to logfile.

Return an exit code according to the overall result (see doc).

"""

exitcode = transfert([source_dir], None, pol=policy, logfile=logfile)

"""

Clean a single file (source_file) according to the specified policy,

store the result in dest_file.

Optionally write log to logfile.

Return an exit code according to the overall result (see doc).

"""

exitcode = transfert([source_file], dest_file, pol=policy, logfile=logfile,

dest_is_a_file=True)

"""

Clean a single file (source_file) according to the specified policy,

store the result in a file with the same name in a destination directory

(dest_dir).

Optionally write log to logfile.

Return an exit code according to the overall result (see doc).

"""

exitcode = transfert([source_file], dest_dir, pol=policy, logfile=logfile)

"""

Scan a single file (source_file) according to the specified policy.

Optionally write log to logfile.

Return an exit code according to the overall result (see doc).

"""

exitcode = transfert([source_file], None, pol=policy, logfile=logfile)

'application/msword': '.doc',

'application/pdf': '.pdf',

'application/rtf': '.rtf',

'application/soap+xml': '.xml',

'application/vnd.ms-excel': '.xls',

'application/vnd.ms-powerpoint': '.ppt',

#TODO: add also the macro enabled versions from IANA, just in case

'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet': '.xlsx',

'application/vnd.openxmlformats-officedocument.presentationml.presentation': '.pptx',

'application/vnd.openxmlformats-officedocument.wordprocessingml.document': '.docx',

'application/xhtml+xml': '.html',

'application/xml': '.xml',

'application/zip': '.zip',

'audio/mpeg': '.mp3',

'audio/vnd.wave': '.wav',

'image/gif': '.gif',

'image/jpeg': '.jpg',

'image/png': '.png',

'image/x-ms-bmp': '.bmp',

'message/rfc822': '.eml',

'text/html': '.html',

'text/plain': '.txt',

'text/xml': '.xml',

'video/x-msvideo': '.avi',

"""

Scan a string according to the specified policy. The filename and/or the

content-type may be provided (at least one of them is required).

It will be used to select the right filter(s).

If only the content-type is provided, a default file extension will be used.

If both filename and content-type are given, content-type is ignored.

The string will be written to a temporary file for analysis.

NOTE: this is a quick and dirty solution which will be improved in future

versions

Optionally write log to logfile.

Return an exit code according to the overall result (see doc).

"""

if filename is not None:

# only keep the filename, in case it contains a path with directories:

# (to avoid directory traversal and other issues)

fname = os.path.basename(filename)

#ext = os.path.splitext(filename)[1]

elif content_type is not None:

if content_type not in CT_to_ext:

#TODO: here we should return a "blocked" result rather than an exception

raise ValueError, 'Content-type not allowed: "%s"' % content_type

ext = CT_to_ext[content_type]

# use a temporary filename = temp.ext

fname = 'temp'+ext

else:

raise RuntimeError, 'Either filename or content-type is required'

# create a new temporary dir to store the file with its original filename

tempdir = tempfilemgr.newTempDir()

fpath = os.path.join(tempdir, fname)

#f, fname = tempfilemgr.newTempFile(suffix=ext)

f = open(fpath, 'wb')

f.write(data)

f.close()

exitcode = transfert([fpath], None, pol=policy, logfile=logfile)

# remove temp file and dir:

os.remove(fpath)

os.rmdir(tempdir)

"""

Clean a string according to the specified policy. The filename and/or the

content-type may be provided (at least one of them is required).

It will be used to select the right filter(s).

If only the content-type is provided, a default file extension will be used.

If both filename and content-type are given, content-type is ignored.

The string will be written to a temporary file for analysis.

NOTE: this is a quick and dirty solution which will be improved in future

versions

Optionally write log to logfile.

Return a tuple (exitcode, cleaned_data):

- exit code according to the overall result (see doc).

"""

if filename is not None:

# only keep the filename, in case it contains a path with directories:

# (to avoid directory traversal and other issues)

fname = os.path.basename(filename)

#ext = os.path.splitext(filename)[1]

elif content_type is not None:

if content_type not in CT_to_ext:

#TODO: here we should return a "blocked" result rather than an exception

raise ValueError, 'Content-type not allowed: "%s"' % content_type

ext = CT_to_ext[content_type]

# use a temporary filename = temp.ext

fname = 'temp'+ext

else:

raise RuntimeError, 'Either filename or content-type is required'

# create a new temporary dir to store the file with its original filename

tempdir = tempfilemgr.newTempDir()

fpath = os.path.join(tempdir, fname)

f = open(fpath, 'wb')

f.write(data)

f.close()

# temp file for the cleaned destination:

f, fdest = tempfilemgr.newTempFile()

f.close()

exitcode = transfert([fpath], fdest, pol=policy, logfile=logfile,

dest_is_a_file=True)

cleaned_data = open(fdest, 'rb').read()

# remove temp files and dir:

os.remove(fdest)

os.remove(fpath)

os.rmdir(tempdir)