Versions Officielles: en
Anglais ou
Français
Mainteneur: David Relson <relson@osagesoftware.com>
Traducteur: Fabrice Prigent <Fabrice.Prigent@univ-tlse1.fr>
Ce document a pour but de répondre aux questions fréquemment posées sur Bogofilter.
Bogofilter est un filtre bayésien rapide basé sur les travaux de Paul Graham dans son article Un plan contre le Spam. Bogofilter utilise l'algorithme de moyenne géométrique de Gary Robinson avec la méthode modifiée de Fisher (khi2) pour classifier les spams et hams (N.D.T.: les mails autres que des spams).
La page web de Bogofilter chez SourceForge est le point central pour toutes les ressources sur Bogofilter.
Bogofilter a été créé par Eric S. Raymond le 19 Août 2002. Il a gagné en popularité depuis Septembre 2002, et un grand nombre de programmeurs ont commencé à participer au projet.
Le fichier NEWS décrit l'historique des versions de Bogofilter.
Bogofilter est une sorte de bogomètre (bogometer) ou filtre à bogues (bogon-filter), c'est à dire qu'il essaie d'identifier des mails bogués (bogus) en mesurant leur bogosité (bogosity).
Il existe actuellement 4 listes de diffusion pour Bogofilter (en anglais):
Adresse de la liste | Liens | Description |
---|---|---|
bogofilter-announce@aotto.com | [abonnement] [archive] | Une liste où sont annoncées les nouvelles versions. |
bogofilter@aotto.com | [abonnement] [archive] | Une liste de diffusion généraliste sur Bogofilter. |
bogofilter-dev@aotto.com | [abonnement] [archive] | Une liste pour des échanges de patches, le développement, et les discussions techniques. |
bogofilter-cvs@lists.sourceforge.net | [abonnement] [archive] | Une liste pour annoncer les changements de code sur l'archive CVS. |
Pour classifier les messages comme ham ou spam, Bogofilter
a besoin d'apprendre votre courrier. Pour commencer, le mieux est d'avoir
un corpus (aussi large que possible) de messages dont vous êtes sûr de
l'état de ham ou de spam. (Des erreurs à ce stade occasionneront des problèmes plus tard,
aussi, soyez attentifs ;-)
). Attention, n'utilisez que votre email. L'utilisation d'autres
corpus (tel qu'un corpus trouvé sur Internet), peut pousser
Bogofilter à tirer de mauvaises conclusions— après tout, votre but est de lui
faire comprendre votre courrier.
Une fois que vous avez vos corpus de spam et de ham, vous avez quatre choix possibles. Dans tous les cas, cela fonctionnera mieux si votre base d'apprentissage (les corpus ci-dessus) est conséquente. Plus un corpus est petit, plus grand sera le nombre d'erreurs que fera Bogofilter en production. Supposons que vos corpus se trouvent dans deux fichiers mbox: ham.mbx et spam.mbx.
Méthode 1) Entrainement complet: Entraînez Bogofilter avec tous vos messages. Dans notre example:
bogofilter -s < spam.mbx bogofilter -n < ham.mbx
Note: Le répertoire contrib de Bogofilter contient 2 scripts qui tous les deux utilisent une technique d'entrainement sur erreur. Cette technique évalue chaque message et n'ajoute à la base de données que les messages qui ont été mal évalués (messages marqués comme incertains, ham évalués en tant que spam ou inversement). Le but est de créer une base de données des mots réellement nécessaires pour classer correctement les messages. La base de données résultante est plus petite que celle de l'entrainement complet.
Méthode 2) Utilisez le script bogominitrain.pl (dans le répertoire contrib).
Il évalue les messages le même ordre que vos fichiers mailbox. Vous devriez utiliser
l'option -f qui va demander au script de répéter le travail, jusqu'à ce que tous
les messages soient classés correctement.
(Si nécessaire, vous pouvez même ajuster le niveau de certitude). Comme le script s'assure
que la base de données
connaît "tout" votre corpus d'entrainement (avec la précision de votre choix), cela
fonctionne très bien. Vous pouvez utiliser -o
pour créer une marge de
sécurité autour de "spam_cutoff"
Avec spam_cutoff=0.6 vous voudrez peut-être évaluer tous les hams
dans votre corpus en dessous de 0.3 et tous les spams au delà de 0.8. Notre exemple devient:
bogominitrain.pl -fnv ~/.bogofilter ham.mbx spam.mbx '-o 0.8,0.3'
Méthode 3) Utilisez le script randomtrain (dans le répertoire contrib). Le script génère une liste de tous les messages dans les mailbox, mélange la liste, puis évalue chaque message, suiv d'un entrainement si nécessaire. Dans notre exemple:
randomtrain -s spam.mbx -n ham.mbx
Comme pour la méthode 4, cela fonctionne mieux si vous commencer avec un corpus d'entrainement de plusieurs milliers de messages. Ceci vous donnera une base de données plus complète et significativement plus grande.
Méthode 4) Si vous avez suffisamment de spam et de ham dans votre corpus, "réservez" 10000 spams et 10000 hams dans des fichiers mbox séparés, puis utilisez ce corpus pour l'entraînement. Lancez alors Bogofilter pour classer les spams et hams restants. Prenez tout message incorrectement évalué ou ayant le statut incertain, et utilisez les pour un nouvel apprentissage. Cette méthode donne la meilleure méthode possible de discrimination. Voici deux petits scripts qui peuvent être utilisés pour classifier les messages "mauvais élèves".
#! /bin/sh # class3 -- classe un message en mauvais, bon ou incertain cat >msg.$$ bogofilter $* <msg.$$ res=$? if [ $res = 0 ]; then cat msg.$$ >>corpus.bad elif [ $res = 1 ]; then cat msg.$$ >>corpus.good elif [ $res = 2 ]; then cat msg.$$ >>corpus.unsure fi rm msg.$$
#! /bin/sh # classify -- Place tous les messages dans un fichier mbox à l'aide de class3 src=$1; shift formail -s class3 $* <$src
Dans notre exemple (après l'entrainement initial):
classify spam.mbx [bogofilter options] bogofilter -s < corpus.good rm -f corpus.* classify ham.mbx [bogofilter options] bogofilter -n < corpus.bad rm -f corpus.*
Il est important de comprendre les conséquences des méthodes que nous venons de décrire. Faire un entrainement complet, tel que dans les méthodes 1 et 4 produit une base de données plus grande que ne le ferait un entrainement avec les méthodes 2 ou 3. Si votre base de données doit être de petite taille (par exemple à cause de quotas), utilisez les méthodes 2 ou 3.
L'entrainement avec la méthode 1 est le plus rapide. L'entrainement sur erreur (tel que décrit dans les méthodes 2,3 et 4) est efficace, mais l'apprentissage est plutôt lent.
"L'entrainement sur erreur" implique l'analyse d'un corpus de messages dont le statut de spam ou ham est connu. Seuls ceux qui sont mal classés, ou dont le classement est incertain, seront intégrés dans la base de données d'apprentissage. Il a été montré que la sélection des seuls messages "mauvais élèves" était un moyen efficace d'entrainement. Si l'on entrainait Bogofilter avec tous les messages, il va réapprendre avec des spams ou hams évidents. L'apprentissage est un peu plus rapide si l'on a commencé avec une période d'entrainement "brut" de 10 000 spams et 10 000 hams.)
Cette méthode peut être améliorée en utilisant une "marge de sécurité". En augmentant la valeur "spam cutoff" et en diminuant la valeur "ham cutoff", les messages qui sont proches du seuil seront utilisés, pour l'entrainement. L'utilisation de cette marge de sécurité a montré son efficacité à améliorer les résultats dans l'entrainement sur erreur.
"L'entrainement sur épuisement" est la répétition de l'entrainement sur erreur, avec le même corpus de messages, jusqu'à ce que plus aucune erreur ne subsiste. Ceci a bien fonctionné sur plusieurs tests, mais peut être risqué.
Un des postulats de base de la théorie de Bayes est que les messages utilisés représentent un échantillon aléatoire des messages reçus. Ceci est en contradiction avec le fait de choisir des messages en les analysant en priorité. Mais, meme théoriquement faux, en pratique, "l'entrainement sur erreur" semble fonctionner.
L'intégration multipliée de messages (telle que décrite dans l'entrainement sur épuisement). crée une distribution des tokens dans la base de données qui diffère de celle des messages d'entrée. Ceci constitue une violation des postulats de la classification bayésienne, et peut donc aboutir à des résultats imprévisibles. Mais, même théoriquement faux, en pratique, "l'entrainement sur épuisement" semble fonctionner.
Les tokens qui apparaissent "normalement" de manière plus ou moins équitable dans les deux catégories, peuvent, s'ils sont présents dans un message d'une catégorie et avec le phénomène de répétition, faire pencher la balance. De tels effets sont temporaires, mais peuvent dégrader l'acuité pendant leur durée.
Note: bogominitrain.pl
possède une option -f
qui permet de réaliser
"l'entrainement sur épuisement". Si
vous choisissez de l'utiliser, soyez conscient des effets secondaires possibles. L'utilisation
de -fn
évite de répéter l'entrainement pour chaque message.
Bogofilter fera des erreurs de temps en temps. C'est pourquoi un apprentissage régulier est important. Il existe principalement deux méthodes pour le faire. Premièrement, vous pouvez l'entraîner avec chaque nouveau message (en utilisant l'option -u). Deuxièmement, vous pouvez ne l'entraîner que sur des erreurs.
De plus, vous pouvez reconstruire votre base à certains moments, par exemple quand une nouvelle fonctionnalité importante est ajoutée à Bogofilter. Il peut être alors fort utile de mettre à jour régulièrement votre corpus d'apprentissage.
Bogofilter fait toujours de son mieux avec les informations
disponibles. Cependant, il fera des erreurs, tel que classer des ham en spam
(faux positifs) ou spam en ham (faux négatifs). Pour réduire la probabilité d'un réapparition
de l'erreur, il sera nécessaire d'entrainer Bogofilter avec le message erroné. Si un message est
classé incorrectement spam, utilisez l'option -n
pour l'intégrer en tant que ham.
Utilisez l'option -s
pour l'intégrer en tant que spam.
Bogofilter a une option -u
qui, automagiquement, met à jour la liste des mots
après chaque évaluation de messages. Comme Bogofilter fait parfois des erreurs, cette méthode a
l'inconvénient de dégrader la base d'entrainement avec des entrées erronées. Vous aurez alors
besoin de la regarder et la corriger fréquemment.
La correction peut être faite en utilisant -Sn
pour changer la classification du message
de spam en ham et -Ns
pour changer de ham en spam.
Corriger un message incorrectement classé peut affecter la classification d'autres messages. Plus votre base de données sera petite, plus grande sera la probabilité qu'une erreur d'apprentissage créee des classifications incorrectes.
L'utilisation de la méthode 2 ou 3 (ci-dessus) peut compenser cet effet. Repéter l'entrainement avec le corpus complet (y compris les messages de corrections ajoutés depuis le précédent apprentissage). Ceci ajoutera des messages dans la base de données afin que d'atteindre un nouvel équilibre, annulant les effets éventuellement de "surcompensation".
Une stratégie alternative, basée sur la méthode 4 de la section précédente est la suivante: Périodiquement, prenez des blocs de messages et utilisez les scripts de la méthode 4 pour les classer. Analyser manuellement les spams, ham et incertains, corriger les erreurs, puis séparer les incertains en hams et spam. Jusqu'à ce que vous ayez 10000 spams et 10000 hams dans votre base d'apprentissage, entraînez avec les hams, les spams, puis les erreurs et enfin les incertains. Plus tard, vous n'entrainerez qu'avec les erreurs et les incertains, en ignorant les messagess que Bogofilter a correctement classé.
Notez que vous devrez régulièrement lancer:
bogoutil -d wordlist.db | bogoutil -l wordlist.db.new mv wordlist.db wordlist.db.prv mv wordlist.db.new wordlist.db
ou pour les fichiers spamlist.db et goodlist.db (si vous utilisez Bogofilter avec les listes de mots séparés). Ceci compressera les bases de données pour n'occuper que le minimum d'espace disque nécessaire.
Si vous avez un SpamAssassin actif (ou si vous voulez en créer un), vous pouvez utiliser ses codes de retour pour l'apprentissage de Bogofilter. Le moyen le plus simple est de créer un script pour votre MDA qui fait tourner SpamAssassin, tester l'état du code de retour spam/ham, et lancer Bogofilter pour valider le message. Le script procmail ci-dessous est un moyen de le faire:
BOGOFILTER = "/usr/bin/bogofilter" BOGOFILTER_DIR = "training" SPAMASSASSIN = "/usr/bin/spamassassin" :0 HBc * ? $SPAMASSASSIN -e #spam yields non-zero #non-spam yields zero | $BOGOFILTER -n -d $BOGOFILTER_DIR #else (E) :0Ec | $BOGOFILTER -s -d $BOGOFILTER_DIR :0fw | $BOGOFILTER -p -e :0: * ^X-Bogosity:.Yes spam :0: * ^X-Bogosity:.No non-spam
Bogofilter comprend les formats mbox traditionnel, Maildir et MH. Bogofilter ne soutient pas des sous-répertoires, vous devrez explicitement les lister si vous avez des répertoires Maildir++ ou MH - mentionnez seulement les noms absoluts des sous-répertoires.
Pour des formats non soutenus, vous devrez transformer le fichier en un format que Bogofilter comprend. Mbox est souvent commode parce qu'il peut être enovyé directement à bogofilter.
La liste suivante pourrait vous aider:
On peut dire à Bogofilter d'afficher des informations sur l'évaluation d'un message en le lançant avec les paramètres "-v", "-vv", "-vvv", or "-R".
X-Bogosity: No, tests=bogofilter, spamicity=0.500000
X-Bogosity: No, tests=bogofilter, spamicity=0.500000 int cnt prob spamicity histogram 0.00 29 0.000209 0.000052 ############################# 0.10 2 0.179065 0.003425 ## 0.20 2 0.276880 0.008870 ## 0.30 18 0.363295 0.069245 ################## 0.40 0 0.000000 0.069245 0.50 0 0.000000 0.069245 0.60 37 0.667823 0.257307 ##################################### 0.70 5 0.767436 0.278892 ##### 0.80 13 0.836789 0.334980 ############# 0.90 32 0.984903 0.499835 ################################
Chaque ligne présente un intervalle, le nombre de tokens (N.D.T. élément minimal pour le traitement, généralement un mot) avec le score dans cet intervalle, la moyenne de la probabilité de spam pour ces tokens, l'évaluation de la "spamicité" du message (pour les tokens de cet intervalle ou des précédents) et une barre correspondant au nombre de tokens.
Dans l'histogramme ci-dessus, il y a beaucoup de tokens à faible score et à haut score. Ils s'équilibrent pour donner une "spamicité" de 0.500000
X-Bogosity: No, tests=bogofilter, spamicity=0.500000 n pgood pbad fw U "which" 10 0.208333 0.000000 0.000041 + "own" 7 0.145833 0.000000 0.000059 + "having" 6 0.125000 0.000000 0.000069 + ... "unsubscribe.asp" 2 0.000000 0.095238 0.999708 + "million" 4 0.000000 0.190476 0.999854 + "copy" 5 0.000000 0.238095 0.999883 + N_P_Q_S_s_x_md 138 0.00e+00 0.00e+00 5.00e-01 1.00e-03 4.15e-01 0.100Les colonnes affichées donnent les informations suivantes:
La dernière ligne montre:
La sortie de "-R" est présentée pour être utilisé avec le langage R de calcul statistique. Plus d'information est disponible sur la page du projet R pour le calcul statistique http://www.r-project.org/.
Beaucoup de personnes reçoivent du mail non sollicité utilisant des caractères asiatiques. Comme ils ne pratiquent pas la langue et qu'ils ne connaissent personne là bas, ils supposent qu'il s'agit de spam.
La bonne nouvelle est que bogofilter les détecte de manière plutôt efficace. La mauvaise nouvelle est que cela peut être coûteux. Vous avez en gros trois possibilités:
Vous pouvez simplement laisser bogofilter gérer le problème. Entraînez le avec des messages asiatiques identifiés comme spam. Bogofilter analysera les messages du mieux qu'il peut et ajoutera des tokens à la liste des mots de spam. La liste des mots contiendra beaucoup de tokens qui n'auront pas de sens pour vous (puisque la table de caractères ne peut être affichée), mais Bogofilter peut travailler avec eux et identifier correctement du spam asiatique.
## Efface silencieusement tous les mails en langue asiatique UNREADABLE='[^?"]*big5|iso-2022-jp|ISO-2022-KR|euc-kr|gb2312|ks_c_5601-1987' :0: * 1^0 $ ^Subject:.*=\?($UNREADABLE) * 1^0 $ ^Content-Type:.*charset="?($UNREADABLE) spam-unreadable :0: * ^Content-Type:.*multipart * B?? $ ^Content-Type:.*^?.*charset="?($UNREADABLE) spam-unreadable
Avec un tel programme, Bogofilter ne verra jamais le message.
Pour trouver le nombre de spam et ham pour un token (mot), utiliser l'option '-w' de bogoutil. Par exemple, "bogoutil -w $BOGOFILTER_DIR example.com" fournit le nombre de ham et spam pour "example.com".
Si vous voulez le score de spamicité en plus du nombre de ham et spam pour un token, utilisez l'option '-p' de bogoutil. Par exemple, "bogoutil -p $BOGOFILTER_DIR example.com" fournit en plus des nombres ham et spam, le score du mot.
Pour trouver combien de messages sont dans votre liste de mots, faites une requête sur le pseudo-token ".MSG_COUNT" (avec le point devant NdT). Par exemple, lancez la commande "bogoutil -w $BOGOFILTER_DIR .MSG_COUNT".
Pour dire combien de tokens sont présents dans votre liste de mots, envoyez la sortie de la commande dump de bogoutil vers la commande "wc". Par exemple utilisez "bogoutil -d $BOGOFILTER_DIR/wordlist.db | wc -l " pour afficher le nombre d'apparitions des tokens (Si vous utilisez spamlist.db et goodlist.db, lancez la commande pour chacun d'eux).
Si vous pensez que vos listes de mots ont été dégradées, vous pouvez regarder ce qu'en dit BerkeleyDB en lançant:
db_verify wordlist.db
S'il y a un problème, vous pouvez récupérer tout ou partie des tokens et leur nombre avec la commande suivante:
bogoutil -d wordlist.db | bogoutil -l wordlist.db.new
ou - si la liste ne pourrait pas être récupérée par la commande précédente - avec:
db_dump -r wordlist.db > wordlist.txt db_load wordlist.new < wordlist.txt
Si vous ne faites que les lire, il n'y a pas de problème. Si vous les mettez à jour, vous devrez fournir les bonnes options de verrouillage pour éviter la corruption des données. Quand vous compilerez Bogofilter, vous aurez besoin de vérifier que le script configure a positionné "#define HAVE_FCNTL 1" dans votre fichier config.h. Les systèmes d'exploitation UNIX supporteront quasiment tous ceci. Si vous utilisez une version exotique ou particulièrement ancienne, assurez-vous qu'elle supporte fcntl(). Si "#define HAVE_FCNTL 1" est positionné, ce qui indique que votre système connaît la fonction fcntl(), alors décommentez "#define HAVE_FLOCK 1" afin que le système de verrouillage utilise fcntl() au lieu du verrouillage flock(). Si votre système ne supporte pas fcntl, alors vous ne pourrez partager les listes de mots en NFS sans risquer une corruption des données.
Ensuite, assurez-vous que NFS est correctement configuré avec "lockd" en fonctionnement. Référez vous à la documentation NFS à propos du lancement de "lockd" ou de "rpc.lockd". La plupart des systèmes avec NFS l'active par défaut.
Vraisemblablement les codes de retour ont été réécrits par
waitpid(2). En C utilisez WEXITSTATUS(status) dans sys/wait.h, ou
une macro comparable pour obtenir la valeur correcte. En Perl
utilisez 'system("bogofilter $input")>> 8'.
Si vous voulez plus d'information, lancez la commande
"man waitpid"
.
Avec la version 0.11, les options de Bogofilter pour enregistrer les ham ou les spam ont changé. Elles permettent désormais d'enregistrer (ou désenregistrer) les messages dans les listes de mots ham ou spam. Avant cette version, il était impossible de désenregistrer un message d'une liste sans l'enregistrer dans l'autre.
Bogofilter fournit quatre options de classement - '-s', '-n', '-S', and '-N'. Avec la version 0.11, le sens de '-N' et '-S' a changé pour permettre le "déclassement" des messages. La définition des quatre options est la suivante:
Avant la version 0.11, l'option '-S' était utilisée pour déplacer un message de la liste ham vers la liste spam. Il y avait deux actions. Maintenant, chacune des actions est appelée par sa propre option. Pour obtenir le même effet que l'ancien '-S', vous devez utiliser '-N -s' (ou '-Ns' qui est synonyme).
De la même manière, l'ancienne option '-N' équivaut à '-Sn' (ou '-S -n').
Les scripts MDA utilisent d'habitude '-s' et '-n' n'ont donc pas besoin de modification. Les autres scripts qui utilisaient '-S' et '-N' pour corriger les erreurs de classement doivent être changés.
Bogofilter-0.14 introduit des codes de retour complémentaires pour prendre en compte la troisième classification des mails (spam, ham et unsure). Avant la 0.14, les codes de retour étaient 0 pour spam, 1 pour ham, et 2 pour les erreurs. Désormais c'est 0 pour spam, 1 pour ham, 2 pour unsure et 3 pour toute erreur.
Avant la version 0.15.4, Bogofilter ajoutait des préfixes dédiés au marquage des en-têtes "Subject:", "From:", "To:" et "Return-Path". Depuis la version 0.15.4, les lignes "Received:" sont aussi traitées spécifiquement et toutes les autres lignes d'en-têtes ont un préfixe "head:". Comme Bogofilter n'a pas rencontré précédemment de tels préfixes, les tokens ainsi constitués ne peuvent plus contribuer, temporairement, à l'évaluation ham ou spam. Cette perte d'information va dégrader les performances de Bogofilter.
Il existe deux moyens de gérer ce problème. Le premier consiste à réentrainer Bogofilter avec tous vos anciens ham et spam. Cela créera les nouvelles entrées avec les entrées "head:" nécessaires, et tout sera correct.
Le second moyen est d'utiliser la nouvelle option header-degen ("-H"). Quand il classe un message, header-degen indique à Bogofilter de regarder à la fois "head:token" et "token" dans la base. Les deux scores ham et spam sont combinés pour donner un résultat cumulatif de l'évaluation. Enregistrer de tels messages créera les entrées "head:token" dans la base. Après un mois environ d'utilisation du "-H", la base devrait contenir suffisamment d'entrées avec le préfixe "head:" et l'utilisation du "-H" ne sera plus nécessaire.
Bogoutil vous permet de lister (dump) une wordlist et de charger les tokens dans une nouvelle wordlist. Avec l'aide d'outils tels que awk et grep, les nombres peuvent être mis à zéros et les tokens dont les comptes seraient à zéro pour les spams et les hams pourraient être détruits.
Les commandes suivantes vont détruire les tokens des messages spams:
bogoutil -d wordlist.db | \ awk '{print $1 " " $2 " 0"}' | grep -v " 0 0" | \ bogoutil -l wordlist.new.db
Les commandes suivantes vont détruire les tokens provenant des messages hams.
bogoutil -d wordlist.db | \ awk '{print $1 " 0 " $3}' | grep -v " 0 0" | \ bogoutil -l wordlist.new.db
Si vous n'avez pas déjà la version 3.0 ou plus de la BerkeleyDB, alors téléchargez la (prenez une des 4.2.X), décompactez la, et lancez les commandes suivantes dans le répertoire 'dist':
$ cd build_unix $ sh ../dist/configure $ make # make install
Puis, téléchargez la version portable de Bogofilter.
Décompactez la, puis faites:
$ ./configure --with-db=/usr/local/BerkeleyDB-4.2 $ make # make install-strip
Vous pourrez alors, soit mettre un lien symbolique sur libdb.so dans /usr/lib, ou utiliser une version modifiée de la variable d'environnement LD_LIBRARY_PATH avant de lancer Bogofilter.
$ LD_LIBRARY_PATH=/usr/lib:/usr/local/lib:/usr/local/BerkeleyDB-4.2
Notez que que certaines versions de make livrées avec Solaris bugguent quand vous essayez de compiler Bogofilter hors de son répertoire source. Soit vous compilez dans le répertoire source (comme suggéré ci-avant), soit vous utilisez GNU make (gmake).
Des paquetages existent avec des versions très récentes de Bogofilter. Cette approche utilise les paquetages très recommandés portupgrade et cvsup. Pour installer ces deux magnifiques outils (vous n'avez besoin de le faire qu'une seule fois):
# pkg_add -r portupgrade cvsup
Pour installer ou mettre à jour Bogofilter, il suffit de mettre à jour l'arbre de conversion (ports tree) avec cvsup puis de taper
# portupgrade -N bogofilter
Regardez le fichier doc/programmer/README.hp-ux dans la distribution des sources.