Miroir du site http://www14.brinkster.com/proxomitron
[Copie du site en format ZIP: mirroir.zip]

logo titre

 
Accueil
Présentation
Pour commencer
      Télécharger/Installer
      Fenêtre Principale
      Fenêtre Config.
      Fenêtre Filtres HTML
      Fenêtre Filtres HTTP
      Fenêtre Log
      Fenêtre Proxy.
Travailler avec les filtres
      Introduction
      Editeur Filtres HTML
      Editeur Filtres HTTP
      Fenêtre Test
      Importer des filtres
      Trucs & Astuces
      Caractères Spéciaux
Détails
      Block List
      Filtre d'URL
      Commandes d'URL
      Comm. de recherche
      Conn. Sec.
      Proxies CGI
      Pile
Mise en œuvre
      JavaScript
      Exercices
      Aide mémoire (.pdf)
      Menus déroulants
FAQ
Version Beta
Misc
Liens
Fil d'infos (RSS)
 


Trucs et Astuces

Maitriser l'emploi et la combinaison des meta caratères du Proxomitron pourra vous paraître ardu dans un premier temps. Mais ne désespérez pas, vous apprendrez rapidement. De toute façon vous découvrirez que même des filtres simples peuvent être très efficaces. Allez-y progressivement, étape par étape, et bientôt tout cela vous apparaîtra bien facile. Voici quelques conseils pour commencer.

Mettre en forme vos filtres

Les filtres complexes peuvent être difficile à lire. Pour les rendre plus lisible, les textes présents dans les zones "matching expression" et "replacement text" peuvent être divisés en plusieurs lignes. Ces retours à la ligne seront ignorés par votre logiciel de navigation, il seront uniquement visible lorsque vous afficherez le code source. Pour insérer un retour à la ligne dans le résultat, utilisez le symbole \n .
De même, les espaces étant toujours "absorbés", vous pouvez les utiliser librement dans la formulation de vos expressions à rechercher.

Un bon conseil

Au début, lorsque vous concevez un nouveau filtre, il est courant que ça ne filtre rien du tout. Commencez toujours simplement, puis complexifiez votre filtre par étapes, jusqu'à ce qu'il fasse exactement ce que vous voulez. Ainsi, lorsque le filtre ne fait pas ce que vous pensiez qu'il allait faire, vous savez exactement quelle portion du filtre est en cause.

Pour voir les effets du filtre sur le code HTML, utilisez la Fenêtre de Test . Si le résultat correspond à ce que vous attendez, testez le filtre sur une page en ligne. Si ça ne marche pas, ouvrez la Fenêtre Log et observez si le filtre est sollicité ; pour voir ce qu'il a changé, servez-vous de l'option "voir source" de votre logiciel de navigation.

Couper et Coller du code HTML

Souvent, la meilleure manière de commencer un nouveau filtre est de copier la partie de code HTML, que vous voulez modifier, dans la zone de recherche ("Matching Expression"). Votre attention doit alors être attirée sur la façon dont se terminent les lignes. Les retours à la ligne étant ignorés, un code HTML qui ressemble à ceci :
<br>
<p>

est compris par le Proxomitron comme étant <br><p> . Cela peut parfois poser des problèmes, le premier bout de code ayant dans ce cas une ligne de plus que le deuxième. Il est donc préférable de placer un espace à la fin ou au début de chaque ligne (s'il n'y en a pas déjà) cela permettra d'attraper touts les espaces vides, aussi bien que les retours à la ligne.

Désactiver un tag ou l'élément d'un tag

Comme les logiciels de navigation ignorent les tags qu'ils ne comprennent pas, une manière rapide et quelque peu brutale de rendre inopérant un tag ou l'un de ses éléments est de le renommer. Cela peut même devenir très intéressant si le même élément est utilisé par différents tags. Prenez "onload" par exemple, cet élément lance automatiquement un Script Java. Souvent présent dans le tag <Body...>, il peut également apparaître ailleurs dans un document. Pour vous en débarrasser, vous pouvez efficacement procéder ainsi :

Matching : onload=
Replace : loadoff=

Cela transformera un tag comme :

<body background="fond.gif" onload= "window.open(unepub);"> en
<body background="fond.gif" loadoff= "window.open(unepub);">

Remarquez comme c'est simple ! Cest un peu risqué aussi, puisqu'il y a peut être un risque que le bout de phrase "onload=" n'apparaisse dans un texte à lire (dans le cas d'un article sur le JavaScript par exemple) de page web. Mais si c'est le cas, ce n'est pas vraiment un problème, si vous comprenez ce qui ce passe, tout va bien. (Si vous lisez un texte sur le JavaScript et que vous voyez apparaître loadoff=, vous devriez comprendre assez vite que c'est votre filtre, prévu pour désactiver un tag, qui a transformé les mots du texte. Vous saurez alors quoi faire : désactiver votre filtre pour lire la page sans parasitage).

Faire d'une pierre deux coups

Voici un truc assez simple pour changer d'un même coup un tag de début et de fin. Ce truc est utilisé entre autres par le filtre "Blink to Bold". On veut dans ce cas transformer <blink> en <bold> , regardons de plus prêt comment est fait ce filtre :

Matching : <1\blink>
Replace : <\1b>

En utilisant le meta caractère \1, on va attraper à la fois le tag de début <blink> et de fin </blink>. Dans le même temps, le \1 capture le slash et l'utilise dans le texte de remplacement. Une version plus complexe mais plus sûre du même filtre pourrait être :

Matching : <(/|)1\blink>
Replace : <\1b>

Comprenez vous pourquoi ? Si vous ne savez pas lisez "Effectuer un test ça ou pas"

Capturer le contenu d'un tag

Souvent vous voudrez changer seulement un élément dans un tag et conserver le reste. Vous aurez alors besoin d'utiliser la meta caractère \# . Prenez l'exemple du filtre suivant, qui vise à supprimer une image de fond :

Matching : <body \1 background=\w\2>
Replace : <body \1 \2>

Quand elles ne suivent pas directement des parenthèses ( ... ) , les variables \# se comportent exactement comme un astérisque * . Ici, Le \1 capture tout ce qui se trouve devant background , alors que \2 capture tout ce qui trouve après. Dans le texte de remplacement, l'élément background est abandonné, mais vous pourriez tout aussi bien, si vous le désiriez, y placer celui de votre choix.

Ajouter un nouvel élément à un tag

Voici une façon rapide d'ajouter un élément à un tag. Bien que la méthode "appropriée" soit de capturer et replacer un élement s'il existe déjà et de l'ajouter seulement s'il n'est pas présent dans le tag d'origine, cela s'avère parfois difficile. Il est souvent plus simple d'ajouter simplement cet élément. Nous avons juste besoin d'être sur que le logiciel de navigation utilisera notre tag à la place du tag pré-existant. Par exemple, pour ajouter un cadre ("border") d'épaisseur 1 à tous les tags <img...> vous pouvez procéder ainsi :

Matching : <img\1>
Replace : <img border=1 \1 border=1>

Pourquoi ajouter un cadre 2 fois ? Si un logiciel de navigation trouve un élément dupliqué, il doit théoriquement utiliser le premier et ignorer le reste. C'est en fait ce que fait Netscape, mais le problème c'est qu'Internet Explorer fait exactement le contraire. En plaçant l'élément au début et à la fin du tag, ça marche avec les deux. Mais en général vous n'aurez pas à vous soucier de faire des filtres qui marchent avec tous les logiciels de navigation, vous ferez des filtres pour le ou les logiciel de navigation que vous utilisez.

Capturer la valeur spécifique d'un symbole de tag

La valeur d'un symbole de tag peut souvent être compliquer à attrapper. Prenez <a href=...> : href indique une URL, mais l'URL peut être encadrée par des guillemets simples, des guillemets doubles, ou rien du tout. C'est là que le méta caractère \w devient utile. Il capturera tout, que les guillemets soient là ou non, jusqu'à ce qu'il tombe sur un espace ou la fin du tag. Par exemple si vous voulez attrapez l'URL dans la variable \1 vous pouvez utiliser :

<a*href=(\w)\1*>

Rappelez vous que lorsqu'un \# suit directement une parenthèse, il capture l'ensemble du texte qui se trouve entre parenthèse. Un exemple plus intéressant est celui-ci :

<a*href=(\w(banner|advert|cgi)\w)\1*>

Qui devrait capturer simplement les URLs contenant les mots "banner", "advert", ou "cgi". Nous avons alors ce qui ressemble au début d'un filtre du type dépubeur .

Effectuer un test ça ou pas

Souvent vous vous appercevrez que vous voudrez une expression qui marche si une valeur particulière est là ou si elle ne l'est pas. Pour le faire, utilisez ceci ( quelquechose |)
Cela va dans un premier temps voir si le mot "quelquechose" est présent, mais s'il ne l'est pas le test sera tout de même positif. Pourquoi ? Remarquez la présence du symbol OU (la barre verticale) avec rien derrière. Cela crée une expression vide, et une expression vide est toujours vrai et ne consomme aucun caractère. Lisez cela comme "trouve quelquechose OU pas".
Remarquez que si l'expression avait été écrite de la sorte : (| quelquechose ) , le mot "quelquechose" n'aurait jamais été trouvé, parce que les OU sont traités de gauche à droite, l'expression vide marcherait toujours avant que le mot "quelquechose" n'ai une chance d'être attrapé.
Un exemple concrêt est celui ci : ("|)*("|)
qui cherche quelque chose qui peut ou non être encadré de guillemets.
Voici maintenant un exemple plus élaboré qui attrapera la valeur de "border" d'un tag <img...> s'il existe et le placera dans la variable \1 :
<img(*(border=\w)\1|)*>
Soyez attentifs à la place qu'occupent les astérisques, par exemple :
<img*(border=\w|)\1*> pourrait ne pas produire ce que vous souhaitiez. Après avoir scanné le premier caractère après <img , s'il n'y a pas "border", la sous expression sera toujours trouvée. Donc quand "border" apparaîtra plus tard dans la chaîne, il sera trouvé par le deuxième astérisque, puisque le premier test aura déjà été effectué

Utiliser ET pour capturer les multiples attributs d'un tag

En utilisant le signe & vous pouvez attraper certains attributs de tags suivant l'ordre dans lequel ils apparaissent. Par exemple, imaginons que vous vouliez réécrire un tag <img...> afin d'y placer une image de votre crû, tout en conservant la hauteur ("height") et la largeur ("height") d'origine. Vous devrez alors procéder ainsi :

Matching : <img ( (*(height=\w\1*| )&(*(width=\w\2*| ) )>
Replace : <img src="file://c|mesimages/shonen.gif" \1\2>

Remarquez que la hauteur est capturée dans la variable \1 et la largeur dans la variable \2 . Donc en utilisant la syntaxe " ça ou pas " vu précédemment, l'expression sera toujours rencontrée même si la largeur et la hauteur sont absentes du tag. Dans ce cas les variables \# seront simplement vides.

Utiliser intelligemment les guillemets

La plupart du temps \w marche bien pour capturer les attributs de tags. Cependant il peut arriver que vous ayez besoin de quelque chose de plus sophistiqué. Dans un tag <img...> l'élément alt contient souvent des espaces, comme dans alt="ceci est du texte" ou alt='encore un peu de texte' . Pour capturer ceci utilisez les doubles guillemets :

Matching : alt=( " * ")\1

Une situation plus complexe se produit avec l'entrée en jeu de Scripts Java. Voici un cas courant de "guillemets entre guillemets" :

onmouseover="javascript:window.open( 'mywindow.html' );"

Capturer cela peut sembler difficile parceque ça aurait tout aussi bien pu s'écrire :

onmouseover='javascript:window.open( "mywindow.html" );'

C'est la que le guillemet simple entre en jeu, il cherche le bon type de guillemet "fermant" correspondant au guillemet ouvrant. Prenez l'exemple suivant, il peut être employé pour venir à bout de tous les types de guillemets qu'il rencontre :

Matching : onmouseover=( " * '|\w)\1

Cela attrapera les guillemets doubles, les simples, les guillemets imbriqués et même les guillemets absents.

Utiliser l'URL d'un fichier pour ajouter vos propres affaires

Un "URL de fichier" est un URL qui pointe un fichier sur votre disque dur plutot qu'un endroit sur l'Internet. Les logiciels de navigation utilisent les URL de fichiers pour afficher des pages web stockées sur votre disque dur, mais c'est aussi une méthode très pratique pour insérer vos propres images, scripts java, ou autres sur les pages que vous voyer.
Le Proxomitron rend désormais facile l'insertion d'un URL de fichier dans le texte de remplacement. Premièrement placez votre curseur à l'endroit où vous voulez insérer l'URL, puis effectuez un clic-droit et sélectionner "Insert File URL" à partir du menu contextuel. Un panneau de sélection apparaîtra, vous permettant de choisir le fichier à insérer.
Voici l'exemple d'un filtre de type "remplaceur de fond", qui utilise un URL de fichier :

Matching : <body (\1 background=\w| ) \2>
Replace : <body \1 background="file://c|/pictures/imagedefond.gif" \2>

Remarquez que l'expression "matching" possède un espace entre la parenthèse ) et le \2 – C'est une erreur courante d'oublier cet espace ! Si tel était le cas cela conduirait le \2 à capturer ce qu'il y a entre parenthèse (...) alors que nous voulons qu'il capture ce qui suit l'attribut de background.

Inserrer un Script Java ou d'autres éléments dans toutes les pages que vous voyez

Voici un truc pour prendre sérieusement le contrôle d'une page web. Les Scripts Java peuvent être des outils très puissants lorsqu'ils se trouvent placés entre de bonnes mains... Maintenant ces mains peuvent être les vôtres. Pour insérer un Script Java, ou quoique ce soit d'autre, dans toutes les pages que vous consultez, cherchez un tag dont vous savez qu'il sera toujours présent. <html> , <head> , ou <body> sont de bons choix. Considérons par exemple un filtre qui viserait à empêcher l'apparition d'une fenêtre de message d'erreur de type JavaScript. Avec Netscape nous devrons exécuter ce script sur toutes les pages : <script> this.onerror=null;</script> , le script ressemblerait à ça :

Matching : <html>
Replace : <html>\n<script> this.onerror=null;</script>

Cela insert directement le script après le tag <html> . Notez la présence du \n qui provoque un retour à la ligne entre le <html> et le début du script. Bien que non indispensable, il rend la lecture du code source de la page plus lisible. Lorsque vous utilisez ce type de filtre, il est bien venue de cocher " Allow For Multiple Matches " pour permettre à tous les autres filtres qui utilisent le même principe d'être également efficaces. Attention : n'essayer pas d'insérer quelque chose avant un tag lorsque vous activez " Allow For Multiple Matches " cela entraînerait un processus récursif. Des scripts courts comme ci-dessus peuvent aisément être insérés dans le texte de remplacement, mais pour des Scripts plus importants cela peut-être encombrant. Une solution plus adaptée est alors de placer un tag <script...> contenant un URL de fichier pointant vers un fichier contenant le Script Java. Par exemple :

<html>\n<script src="file://c|/scripts/monscriptjava.js">

Une solution pratique pour insérer des éléments dans toutes les pages

J'ai décrit en premier la méthode ci-dessus parce qu'elle est utile lorsque vous avez besoin d'insérer quelque chose dans une ère définie d'un document (comme après un tag <body> par exemple). Cependant, si ce que vous voulez c'est placer un élément au début ou à la fin d'un document, il y a une solution bien plus facile. La zone où vous entrez l'expression à rechercher peut accueillir deux valeurs spécifique <start> et <end> – Cela insère le texte de remplacement, respectivement, au début ou à la fin d'un document. C'est très facile à employer et très efficace puisque ça n'effectue pas de test de recherche. Cela peut s'écrire ainsi :

Matching : <start>
Replace : <script> onerror=null; </script>

Cela marche très bien pour insérer des Scripts Java et il n'y a pas à se préoccuper du " Allow for multiple matches ".

Neutraliser des fonctions JavaScripts grace aux vôtres

Dans Netscape et Internet Explorer 4.0 et ultérieur, il y a une méthode très simple pour manipuler des Scripts Java. Toutes les foncions JavaScript - même celles qui sont implantées - peuvent être redéfinient de manière à agir comme nous l'entendons. Disons que nous voulions venir à bout de ces messages "alert(...)" et "confirm(...)" . Nous pouvons le faire simplement en insérant le script suivant au début de la page (en utilisant la technique avec <start> décrite ci-dessus)...

<script>
     function alert( ){return(1);}
     function confirm( ){return(1);}
</script>

Ainsi, chaque fois qu'un script de la page essaiera d'appeler un boite alert/confirm, notre fonction sera appelée. En renvoyant un 1 , nous faisons croire au script que nous avons répondu oui à sa demande.
C'est vraiment un concept très puissant. La fonction dans cet exemple est très basique, mais vous pouvez créer des fonctions bien plus complexes (filtrez dans certains cas uniquement, ou faire tout à fait autre chose). Il n'y a vraiment pas de limite...
Malheureusement, si ça marche très bien avec les versions d'Internet explorer 4.0 et supérieures, ça ne marchera pas si vous utilisez IE 3.x. dans ce cas, utilisez le filtre spécifique pour ce logiciel, basé sur du rechercher/remplacer.

Utiliser une requête récursive

La récursivité se produit lorsque le filtre se trouve activer par son propre résultat. Normalement c'est quelque chose à bannir, cela pouvant entraîner une récursivité infinie. Cependant, dans certains cas, ce peut être une technique très efficace. Prenons ce cas de figure : vous voulez éliminer toutes les fenêtres pop-up qui se trouvent entre les tags <script ... et </script> . Comme les Scripts java utilisent la commande " open(...) " pour ouvrir une fenêtre, le filtre devrait ressembler à ceci :

Matching : <script\1 open \(*\) \2</script>
Replace : <script \1 \2 </script>

(Dans cet exemple, vous pourriez vouloir utiliser le scope , mais nous en parlerons un peu plus bas – notez la présence du \ pour signifier qu'il ne faut pas utiliser, ici, les parenthèses comme meta caractères). Cet exemple devrait marcher s'il n'y a qu'une commande open, mais s'il y en avait plusieurs, seule la première pourrait être éliminée. La solution ? Eh bien elle tient en deux points, premièrement cocher "Allow for Multiple Matches", deuxièmement nous avons besoin de modifier le texte de remplacement de la sorte :

Replace :\n<script\1 \2 </script>

Pourquoi ? Pour éviter de provoquer une récursivité infinie, le Proxomitron décale toujours la recherche d'un caractère après que tous les filtres sélectionnés aient effectuées leur test. Cela veut dire que la deuxième fois, le filtre verra script et non plus <script . Pour éviter cela, nous ajoutons juste une nouvelle ligne (vide) avant le tag <script . Cela n'a aucune incidence sur l'affichage de la page par le logiciel de navigation, mais permet au filtre de voir <script la deuxième fois qu'il le rencontre. Utiliser un espace à la place du \n aurait également fait l'affaire : le principe est simplement de déplacer d'un caractère le texte de remplacement. Une fois que toutes les commandes "open(...)" auront été supprimées, le filtre ne trouvera plus ce qu'il cherche, il s'arrêtera donc et il n'y aura pas de danger de récursivité infinie.

Un mot à propos des restrictions de champs

Pour être simple, nous n'avons pas utilisé les paramètres Scope Bounds des filtres web. Ces bornes peuvent être utilisées pour contrôler jusqu'où le Proxomitron scanne une page web avant de retourner sa réponse.
Ces bornes représentent en général le premier et dernier point entre lesquels chercher. Réutilisons un exemple déjà employé, prenons :

Matching : <script \1 open\(*\) \2</script>
Replace : <script \1 \2</script>

En utilisant les bornes, il s'écrirait ainsi :

Bounds : </script>          Byte Limit : 4096
Matching : \1 open\(*\) \2
Replace : \1 \2

Notez que nous avons juste placé le texte de début et de fin de la zone matching dans la zone bounds. Le byte Limit est le nombre de caractères à chercher avant de renvoyer la réponse au logiciel de navigation. Nous avons utilisé \1 et \2 pour capturer ce qu'il y a avant et après open( ... ) , y compris <script et </script> . Donc nous n'avons plus besoin de les placer dans le texte de remplacement.

C'est tout pour l'instant

Pour vous exercer pensez aux filtres qui sont fournis avec le Proxomitron, souvent ils peuvent vous servir de point de départ, s'ils ne font pas exactement ce que vous voulez, étudiez les et transformez les...

     


The Proxomitron is Copyrighted to Scott R. Lemmon