mod_lua.html.fr

<pre class="prettyprint lang-lua">r:htpassword(string [,algorithm [,cost]]) -- Gnre un hash de mot de passe  partir d'une chane.
                                          -- algorithm: 0 = APMD5 (dfaut), 1 = SHA, 2 = BCRYPT, 3 = CRYPT.
                                          -- cost: ne s'utilise qu'avec l'algorythme BCRYPT (dfaut = 5).</pre>


<pre class="prettyprint lang-lua">r:mkdir(dir [,mode]) -- Cre un rpertoire et dfinit son mode via le paramtre optionnel mode.</pre>


<pre class="prettyprint lang-lua">r:mkrdir(dir [,mode]) -- Cre des rpertoires de manire rcursive et dfinit
                      -- leur mode via le paramtre optionnel mode.</pre>


<pre class="prettyprint lang-lua">r:rmdir(dir) -- Supprime un rpertoire.</pre>


<pre class="prettyprint lang-lua">r:touch(file [,mtime]) -- Dfinit la date de modification d'un fichier  la date courante ou 
                       -- la valeur optionnelle mtime en msec.</pre>


<pre class="prettyprint lang-lua">r:get_direntries(dir) -- Renvoie une table contenant toutes les entres de rpertoires.

-- Renvoie un chemin sous forme clate en chemin, fichier, extension
function handle(r)
  local dir = r.context_document_root
  for _, f in ipairs(r:get_direntries(dir)) do
    local info = r:stat(dir .. "/" .. f)
    if info then
      local mtime = os.date(fmt, info.mtime / 1000000)
      local ftype = (info.filetype == 2) and "[dir] " or "[file]"
      r:puts( ("%s %s %10i %s\n"):format(ftype, mtime, info.size, f) )
    end
  end
end</pre>


<pre class="prettyprint lang-lua">r.date_parse_rfc(string) -- Interprte une chane date/heure et renvoie l'quivalent en secondes depuis epoche.</pre>


<pre class="prettyprint lang-lua">r:getcookie(key) -- Obtient un cookie HTTP</pre>


<pre class="prettyprint lang-lua">r:setcookie(key, value, secure, expires) -- Dfinit un cookie HTTP, par exemple :
r:setcookie("foo", "bar and stuff", false, os.time() + 86400)</pre>


<pre class="prettyprint lang-lua">r:wsupgrade() -- Met  jour une connexion vers les WebSockets si possible (et si demand) :
if r:wsupgrade() then -- si la mise  jour est possible :
    r:wswrite("Bienvenue dans les websockets!") -- crit quelque chose  l'intention du client
    r:wsclose()  -- Au revoir !
end</pre>


<pre class="prettyprint lang-lua">r:wsread() -- Lit un cadre de websocket depuis une connexion vers websocket mise  jour (voir ci-dessus) :
           
local line, isFinal = r:wsread() -- isFinal indique s'il s'agit du cadre final.
                                 -- dans le cas contraire, on peut lire les cadres suivants
r:wswrite("Vous avez crit : " .. line)</pre>


<pre class="prettyprint lang-lua">r:wswrite(line) -- crit un cadre vers un client WebSocket :
r:wswrite("Bonjour le Monde !")</pre>


<pre class="prettyprint lang-lua">r:wsclose() -- ferme une requte WebSocket et l'achve pour httpd :

if r:wsupgrade() then
    r:wswrite("Ecrire quelque chose : ")
    local line = r:wsread() or "nothing"
    r:wswrite("Vous avez crit : " .. line);
    r:wswrite("Au revoir !")
    r:wsclose()
end</pre>

</div><div class="top"><a href="#page-header"><img alt="top" src="../images/up.gif" /></a></div>
<div class="section">
<h2><a name="logging" id="logging">Fonctions de journalisation</a></h2>

<pre class="prettyprint lang-lua">	-- exemples de messages de journalisation
	r:trace1("Ceci est un message de journalisation de niveau
	trace") -- les niveaux valides vont de trace1  trace8 
        r:debug("Ceci est un message de journalisation de niveau debug")
        r:info("Ceci est un message de journalisation de niveau info")
        r:notice("Ceci est un message de journalisation de niveau notice")
        r:warn("Ceci est un message de journalisation de niveau warn")
        r:err("Ceci est un message de journalisation de niveau err")
        r:alert("Ceci est un message de journalisation de niveau alert")
        r:crit("Ceci est un message de journalisation de niveau crit")
        r:emerg("Ceci est un message de journalisation de niveau emerg")</pre>


</div><div class="top"><a href="#page-header"><img alt="top" src="../images/up.gif" /></a></div>
<div class="section">
<h2><a name="apache2" id="apache2">Paquet apache2</a></h2>
<p>Le paquet nomm <code>apache2</code> est fourni avec (au minimum) le
contenu suivant :</p>
<dl>
  <dt>apache2.OK</dt>
  <dd>Constante interne OK. Les gestionnaires renverront cette valeur
  s'ils ont trait la requte.</dd>
  <dt>apache2.DECLINED</dt>
  <dd>Constante interne DECLINED. Les gestionnaires renverront cette
  valeur s'ils n'ont pas l'intention de traiter la requte.</dd>
  <dt>apache2.DONE</dt>
  <dd>Constante interne DONE.</dd>
  <dt>apache2.version</dt>
  <dd>Chane contenant la version du serveur HTTP Apache</dd>
  <dt>apache2.HTTP_MOVED_TEMPORARILY</dt>
  <dd>Code d'tat HTTP</dd>
  <dt>apache2.PROXYREQ_NONE, apache2.PROXYREQ_PROXY, apache2.PROXYREQ_REVERSE, apache2.PROXYREQ_RESPONSE</dt>
  <dd>Constantes internes utilises par <code class="module"><a href="../mod/mod_proxy.html">mod_proxy</a></code></dd>
  <dt>apache2.AUTHZ_DENIED, apache2.AUTHZ_GRANTED, apache2.AUTHZ_NEUTRAL, apache2.AUTHZ_GENERAL_ERROR, apache2.AUTHZ_DENIED_NO_USER</dt>
  <dd>constantes internes utilises par <code class="module"><a href="../mod/mod_authz_core.html">mod_authz_core</a></code></dd>

</dl>
<p>Les autres codes d'tat HTTP ne sont pas encore implments.</p>
</div><div class="top"><a href="#page-header"><img alt="top" src="../images/up.gif" /></a></div>
<div class="section">
<h2><a name="modifying_buckets" id="modifying_buckets">Modification de contenu avec les filtres lua</a></h2>
    
    <p>
    Les fonctions de filtrage implmentes via les directives <code class="directive"><a href="#luainputfilter">LuaInputFilter</a></code> ou <code class="directive"><a href="#luaoutputfilter">LuaOutputFilter</a></code> sont conues comme des
    fonctions de 3me phase non blocantes utilisant des sous-routines
    pour suspendre et reprendre l'excution d'une fonction lorsque des
    paquets de donnes sont envoys  la chane de filtrage. La
    structure de base d'une telle fonction est :
    </p>
    <pre class="prettyprint lang-lua">function filter(r)
    -- Nous indiquons tout d'abord que nous sommes prts  recevoir des
    -- blocs de donnes.
    -- Avant ceci, nous pouvons dfinir notre environnement, tester
    -- certaines conditions, et, si nous le jugeons ncessaire, refuser le
    -- filtrage d'une requte :
    if something_bad then
        return -- Le filtrage est saut
    end
    -- Sans se proccuper des donnes que nous devons ventuellement ajouter, un arrt est ralis ici.
    -- Noter que les filtres de sortie sont les seuls capables d'ajouter des lments au dbut des donnes.
    -- Les filtres en entre peuvent ajouter des lments  la fin des donnes au stade final.

    coroutine.yield([optional header to be prepended to the content])

    -- Aprs cet arrt, nous allons recevoir d'autres blocs de donnes, un par un ;
    -- nous pouvons les traiter comme il nous plat et procder  la rponse.
    -- Ces blocs sont conservs dans la variable globale 'bucket', nous ralisons donc
    -- une boucle pour vrifier que 'bucket' n'est pas vide :
    while bucket ~= nil do
        local output = mangle(bucket) -- Do some stuff to the content
        coroutine.yield(output) -- Return our new content to the filter chain
    end

    -- Une fois les blocs de donnes puiss, 'bucket' est positionn  une valeur vide ('nil'),
    -- ce qui va nous faire sortir de cette boucle et nous amener  l'tape suivante.
    -- On peut ajouter ce qu'on veut  la fin des donnes  cette tape, qui constitue le dernier
    -- arrt. Les filtres d'entre comme de sortie peuvent servir  ajouter des lments  la fin
    --  des donnes  cette tape.
    coroutine.yield([optional footer to be appended to the content])
end</pre>

</div><div class="top"><a href="#page-header"><img alt="top" src="../images/up.gif" /></a></div>
<div class="section">
<h2><a name="databases" id="databases">Connectivit aux bases de donnes</a></h2>
    
    <p>Mod_lua implmente une fonctionnalit basique de connexion aux
bases de donnes permettant d'envoyer des requtes ou d'excuter des
commandes auprs des moteurs de base de donnes les plus courants
(mySQL, PostgreSQL, FreeTDS, ODBC, SQLite, Oracle), ainsi que mod_dbd.
    </p>
    <p>L'exemple suivant montre comment se connecter  une base de
donnes et extraire des informations d'une table :</p>
    <pre class="prettyprint lang-lua">function handle(r)
    -- connexion  la base de donnes
    local database, err = r:dbacquire("mysql", "server=localhost,user=someuser,pass=somepass,dbname=mydb")
    if not err then
        -- Slection de certaines informations
        local results, err = database:select(r, "SELECT `name`, `age` FROM `people` WHERE 1")
        if not err then
            local rows = results(0) -- extrait tous les enregistrements en mode synchrone
            for k, row in pairs(rows) do
                r:puts( string.format("Name: %s, Age: %s&lt;br/&gt;", row[1], row[2]) )
            end
        else
            r:puts("Database query error: " .. err)
        end
        database:close()
    else
        r:puts("Connexion  la base de donnes impossible : " .. err)
    end
end</pre>

    <p>
    Pour utiliser <code class="module"><a href="../mod/mod_dbd.html">mod_dbd</a></code>, spcifiez
<code>mod_dbd</code> comme type de base de donnes, ou laissez le champ
vide :
    </p>
    <pre class="prettyprint lang-lua">local database = r:dbacquire("mod_dbd")</pre>

    <h3><a name="database_object" id="database_object">L'objet database et ses mthodes</a></h3>
        
        <p>L'objet database renvoy par <code>dbacquire</code> possde
les mthodes suivantes :</p>
        <p><strong>Slection normale et requte vers une base de donnes
:</strong></p>
    <pre class="prettyprint lang-lua">-- Excution d'une requte et renvoie du nombre d'enregistrements
affects :
local affected, errmsg = database:query(r, "DELETE FROM `tbl` WHERE 1")

-- Excution d'une requte et renvoie du rsultat qui peut tre utilis
en mode synchrone ou asynchrone :
local result, errmsg = database:select(r, "SELECT * FROM `people` WHERE 1")</pre>

        <p><strong>Utilisation de requtes prpares (recommand) :</strong></p>
    <pre class="prettyprint lang-lua">-- Cration et excution d'une requte prpare :
local statement, errmsg = database:prepare(r, "DELETE FROM `tbl` WHERE `age` &gt; %u")
if not errmsg then
    local result, errmsg = statement:query(20) -- excute la requte pour age &gt; 20
end

-- Extrait une requte prpare depuis une directive DBDPrepareSQL :
local statement, errmsg = database:prepared(r, "someTag")
if not errmsg then
    local result, errmsg = statement:select("John Doe", 123) -- injecte les valeurs "John Doe" et 123 dans la requte
end</pre>

        <p><strong>Echappement de valeurs, fermeture de la base donnes,
etc...</strong></p>
    <pre class="prettyprint lang-lua">-- Echappe une valeur pour pouvoir l'utiliser dans une requte :
local escaped = database:escape(r, [["'|blabla]])

-- Ferme une base de donnes et libre les liens vers cette dernire :
database:close()

-- Vrifie si une connexion  une base de donnes est en service et
oprationnelle :
local connected = database:active()</pre>

    
    <h3><a name="result_sets" id="result_sets">Travail avec les jeux d'enregistrements renvoys par les requtes</a></h3>
    
    <p>Les jeux d'enregistrements renvoys par <code>db:select</code> ou par des
requtes prpares cres par <code>db:prepare</code> permettent de
slectionner des enregistrements en mode synchrone ou
asynchrone, selon le nombre d'enregistrements spcifi :<br />
    <code>result(0)</code> slectionne tous les enregistrements en mode
synchrone en renvoyant une table d'enregistrements.<br />
    <code>result(-1)</code> slectionne le prochain enregistrement disponible en
mode asynchrone.<br />
    <code>result(N)</code> slectionne l'enregistrement numro
<code>N</code> en mode asynchrone.
    </p>
    <pre class="prettyprint lang-lua">-- extrait un jeu d'enregistrements via une requte rgulire :
local result, err = db:select(r, "SELECT * FROM `tbl` WHERE 1")

local rows = result(0) -- slectionne tous les enregistrements en mode synchrone
local row = result(-1) -- slectionne le prochain enregistrement disponible en mode asynchrone
local row = result(1234) -- slectionne l'enregistrement 1234 en mode asynchrone
local row = result(-1, true) -- Lit l'enregistrement suivant en utilisant les noms d'enregistrements comme index.</pre>

    <p>Il est possible de construire une fonction qui renvoie une
fonction itrative permettant de traiter tous les enregistrement en mode
synchrone ou asynchrone selon la valeur de l'argument async :
    </p>
    <pre class="prettyprint lang-lua">function rows(resultset, async)
    local a = 0
    local function getnext()
        a = a + 1
        local row = resultset(-1)
        return row and a or nil, row
    end
    if not async then
        return pairs(resultset(0))
    else
        return getnext, self
    end
end

local statement, err = db:prepare(r, "SELECT * FROM `tbl` WHERE `age` &gt; %u")
if not err then
     -- slectionne des enregistrements en mode asynchrone :
    local result, err = statement:select(20)
    if not err then
        for index, row in rows(result, true) do
            ....
        end
    end

     -- slectionne des enregistrements en mode synchrone :
    local result, err = statement:select(20)
    if not err then
        for index, row in rows(result, false) do
            ....
        end
    end
end</pre>

    
    <h3><a name="closing_databases" id="closing_databases">Fermeture d'une connexion  une base de donnes</a></h3>
        

    <p>Lorsqu'elles ne sont plus utilises, les connexions aux bases de
donnes doivent tre fermes avec <code>database:close()</code>. Si vous
ne les fermez pas manuellement, mod_lua les fermera peut-tre en tant
que rsidus collects, mais si ce n'est pas le cas, vous pouvez finir
pas avoir trop de connexions vers la base de donnes inutilises. Les
deux mesures suivantes sont pratiquement identiques :
    </p>
    <pre class="prettyprint lang-lua">-- Mthode 1 : fermeture manuelle de la connexion
local database = r:dbacquire("mod_dbd")
database:close() -- c'est tout

-- Mthode 2 : on laisse le collecteur de rsidus la fermer
local database = r:dbacquire("mod_dbd")
database = nil -- on coupe le lien
collectgarbage() -- fermeture de la connexion par le collecteur de rsidus</pre>

    
    <h3><a name="database_caveat" id="database_caveat">Prcautions  prendre lorsque l'on travaille avec les bases
de donnes</a></h3>
    
    <p>Bien que les fonctions <code>query</code> et <code>run</code>
soient toujours disponibles, il est recommand d'utiliser des requtes
prpares chaque fois que possible, afin d'une part d'optimiser les
performances (si votre connexion reste longtemps en vie), et d'autre part
minimiser le risque d'attaques par injection SQL. Les fonctions
<code>run</code> et <code>query</code> ne doivent tre utilises que
lorsque la requte ne contient pas de variables (requte statique). Dans
le cas des requtes dynamiques, utilisez <code>db:prepare</code> ou
<code>db:prepared</code>.
    </p>
    

</div>
<div class="top"><a href="#page-header"><img alt="top" src="../images/up.gif" /></a></div>
<div class="directive-section"><h2><a name="luaauthzprovider" id="luaauthzprovider">Directive</a> <a name="LuaAuthzProvider" id="LuaAuthzProvider">LuaAuthzProvider</a></h2>
<table class="directive">
<tr><th><a href="directive-dict.html#Description">Description:</a></th><td>Branche une fonction fournisseur d'autorisation dans <code class="module"><a href="../mod/mod_authz_core.html">mod_authz_core</a></code>
</td></tr>
<tr><th><a href="directive-dict.html#Syntax">Syntaxe:</a></th><td><code>LuaAuthzProvider provider_name /path/to/lua/script.lua function_name</code></td></tr>
<tr><th><a href="directive-dict.html#Context">Contexte:</a></th><td>configuration du serveur</td></tr>
<tr><th><a href="directive-dict.html#Status">Statut:</a></th><td>Exprimental</td></tr>
<tr><th><a href="directive-dict.html#Module">Module:</a></th><td>mod_lua</td></tr>
<tr><th><a href="directive-dict.html#Compatibility">Compatibilit:</a></th><td>Disponible depuis la version 2.4.3 du serveur HTTP Apache</td></tr>
</table>
<p>Lorsqu'une fonction lua a t enregistre en tant que fournisseur
d'autorisation, elle peut tre appele via la directive <code class="directive"><a href="../mod/mod_authz_core.html#require">Require</a></code> :</p>


<pre class="prettyprint lang-config">LuaRoot "/usr/local/apache2/lua"
LuaAuthzProvider foo authz.lua authz_check_foo
&lt;Location "/"&gt;
  Require foo johndoe
&lt;/Location&gt;</pre>

<pre class="prettyprint lang-lua">require "apache2"
function authz_check_foo(r, who)
    if r.user ~= who then return apache2.AUTHZ_DENIED
    return apache2.AUTHZ_GRANTED
end</pre>



</div>
<div class="top"><a href="#page-header"><img alt="top" src="../images/up.gif" /></a></div>
<div class="directive-section"><h2><a name="luacodecache" id="luacodecache">Directive</a> <a name="LuaCodeCache" id="LuaCodeCache">LuaCodeCache</a></h2>
<table class="directive">
<tr><th><a href="directive-dict.html#Description">Description:</a></th><td>Configure le cache de code compil.</td></tr>
<tr><th><a href="directive-dict.html#Syntax">Syntaxe:</a></th><td><code>LuaCodeCache stat|forever|never</code></td></tr>
<tr><th><a href="directive-dict.html#Default">Dfaut:</a></th><td><code>LuaCodeCache stat</code></td></tr>
<tr><th><a href="directive-dict.html#Context">Contexte:</a></th><td>configuration du serveur, serveur virtuel, rpertoire, .htaccess</td></tr>
<tr><th><a href="directive-dict.html#Override">AllowOverride:</a></th><td>All</td></tr>
<tr><th><a href="directive-dict.html#Status">Statut:</a></th><td>Exprimental</td></tr>
<tr><th><a href="directive-dict.html#Module">Module:</a></th><td>mod_lua</td></tr>
</table><p>
    Cette directive permet de dfinir le comportement du cache de code
    en mmoire. La valeur par dfaut est stat ; dans ce cas, le script
    du niveau le plus haut (et pas les scripts inclus) est vrifi 
    chaque fois que ce fichier est ncessaire, et est recharg si la
    date de modification est plus rcente que celle du script dj
    charg. Les autres valeurs permettent respectivement de garder le
    fichier en cache perptuellement (forever - jamais vrifi ni
    remplac), ou de ne jamais le mettre en cache (never).</p>

    <p>En gnral, les valeurs stat et forever sont utilises pour un
    serveur en production, et les valeurs stat ou never pour un serveur
    en dveloppement.</p>

    <div class="example"><h3>Exemples :</h3><pre class="prettyprint lang-config">LuaCodeCache stat
LuaCodeCache forever
LuaCodeCache never</pre>
</div>


</div>
<div class="top"><a href="#page-header"><img alt="top" src="../images/up.gif" /></a></div>
<div class="directive-section"><h2><a name="luahookaccesschecker" id="luahookaccesschecker">Directive</a> <a name="LuaHookAccessChecker" id="LuaHookAccessChecker">LuaHookAccessChecker</a></h2>
<table class="directive">
<tr><th><a href="directive-dict.html#Description">Description:</a></th><td>Fournit un point d'entre pour la phase access_checker du
traitement de la requte</td></tr>
<tr><th><a href="directive-dict.html#Syntax">Syntaxe:</a></th><td><code>LuaHookAccessChecker  /chemin/vers/lua/script.lua  hook_function_name [early|late]</code></td></tr>
<tr><th><a href="directive-dict.html#Context">Contexte:</a></th><td>configuration du serveur, serveur virtuel, rpertoire, .htaccess</td></tr>
<tr><th><a href="directive-dict.html#Override">AllowOverride:</a></th><td>All</td></tr>
<tr><th><a href="directive-dict.html#Status">Statut:</a></th><td>Exprimental</td></tr>
<tr><th><a href="directive-dict.html#Module">Module:</a></th><td>mod_lua</td></tr>
<tr><th><a href="directive-dict.html#Compatibility">Compatibilit:</a></th><td>Le troisime argument optionnel est disponible depuis la
version 2.3.15 du serveur HTTP Apache.</td></tr>
</table>
<p>Ajoute votre fonction d'accroche  la phase access_checker. Une
fonction d'accroche access checker renvoie en gnral OK, DECLINED, ou
HTTP_FORBIDDEN.</p>
<div class="note"><h3>Ordonnancement</h3><p>Les arguments optionnels
   "early" ou "late" permettent de contrler le moment auquel ce script
   s'excute par rapport aux autres modules.</p></div>

</div>
<div class="top"><a href="#page-header"><img alt="top" src="../images/up.gif" /></a></div>
<div class="directive-section"><h2><a name="luahookauthchecker" id="luahookauthchecker">Directive</a> <a name="LuaHookAuthChecker" id="LuaHookAuthChecker">LuaHookAuthChecker</a></h2>
<table class="directive">
<tr><th><a href="directive-dict.html#Description">Description:</a></th><td>Fournit un point d'entre pour la phase auth_checker du
traitement de la requte</td></tr>
<tr><th><a href="directive-dict.html#Syntax">Syntaxe:</a></th><td><code>LuaHookAuthChecker  /chemin/vers/lua/script.lua hook_function_name [early|late]</code></td></tr>
<tr><th><a href="directive-dict.html#Context">Contexte:</a></th><td>configuration du serveur, serveur virtuel, rpertoire, .htaccess</td></tr>
<tr><th><a href="directive-dict.html#Override">AllowOverride:</a></th><td>All</td></tr>
<tr><th><a href="directive-dict.html#Status">Statut:</a></th><td>Exprimental</td></tr>
<tr><th><a href="directive-dict.html#Module">Module:</a></th><td>mod_lua</td></tr>
<tr><th><a href="directive-dict.html#Compatibility">Compatibilit:</a></th><td>Le troisime argument optionnel est disponible depuis la
version 2.3.15 du serveur HTTP Apache.</td></tr>
</table>
<p>Invoque une fonction lua au cours de la phase auth_checker du
traitement de la requte. Cette directive peut s'utiliser pour
implmenter une vrification arbitraire de l'authentification et de
l'autorisation. Voici un exemple trs simple :
</p>
<pre class="prettyprint lang-lua">require 'apache2'

-- fonction d'accroche authcheck fictive
-- Si la requte ne contient aucune donne d'authentification, l'en-tte
-- de la rponse est dfini et un code 401 est renvoy afin de demander au
-- navigateur d'effectuer une authentification basique. Si la requte
-- comporte des donnes d'authentification, elles ne sont pas vraiment
-- consultes, mais on admet la prise en compte de l'utilisateur 'foo' et
-- on la valide. On vrifie ensuite si l'utilisateur est bien 'foo' et on
-- accepte la requte.
function authcheck_hook(r)

   -- recherche des informations d'authentification
   auth = r.headers_in['Authorization']
   if auth ~= nil then
     -- dfinition d'un utilisateur par dfaut
     r.user = 'foo'
   end

   if r.user == nil then
      r:debug("authcheck: user is nil, returning 401")
      r.err_headers_out['WWW-Authenticate'] = 'Basic realm="WallyWorld"'
      return 401
   elseif r.user == "foo" then
      r:debug('user foo: OK')
   else
      r:debug("authcheck: user='" .. r.user .. "'")
      r.err_headers_out['WWW-Authenticate'] = 'Basic realm="WallyWorld"'
      return 401
   end
   return apache2.OK
end</pre>

<div class="note"><h3>Ordonnancement</h3><p>Les arguments optionnels
   "early" ou "late" permettent de contrler le moment auquel ce script
   s'excute par rapport aux autres modules.</p></div>

</div>
<div class="top"><a href="#page-header"><img alt="top" src="../images/up.gif" /></a></div>
<div class="directive-section"><h2><a name="luahookcheckuserid" id="luahookcheckuserid">Directive</a> <a name="LuaHookCheckUserID" id="LuaHookCheckUserID">LuaHookCheckUserID</a></h2>
<table class="directive">
<tr><th><a href="directive-dict.html#Description">Description:</a></th><td>Fournit un point d'entre pour la phase check_user_id du
traitement de la requte</td></tr>
<tr><th><a href="directive-dict.html#Syntax">Syntaxe:</a></th><td><code>LuaHookCheckUserID  /chemin/vers/lua/script.lua hook_function_name [early|late]</code></td></tr>
<tr><th><a href="directive-dict.html#Context">Contexte:</a></th><td>configuration du serveur, serveur virtuel, rpertoire, .htaccess</td></tr>
<tr><th><a href="directive-dict.html#Override">AllowOverride:</a></th><td>All</td></tr>
<tr><th><a href="directive-dict.html#Status">Statut:</a></th><td>Exprimental</td></tr>
<tr><th><a href="directive-dict.html#Module">Module:</a></th><td>mod_lua</td></tr>
<tr><th><a href="directive-dict.html#Compatibility">Compatibilit:</a></th><td>Le troisime argument optionnel est disponible depuis la
version 2.3.15 du serveur HTTP Apache.</td></tr>
</table><p>...</p>
   <div class="note"><h3>Ordonnancement</h3><p>Les arguments optionnels
   "early" ou "late" permettent de contrler le moment auquel ce script
   s'excute par rapport aux autres modules.</p></div>

</div>
<div class="top"><a href="#page-header"><img alt="top" src="../images/up.gif" /></a></div>
<div class="directive-section"><h2><a name="luahookfixups" id="luahookfixups">Directive</a> <a name="LuaHookFixups" id="LuaHookFixups">LuaHookFixups</a></h2>
<table class="directive">
<tr><th><a href="directive-dict.html#Description">Description:</a></th><td>Fournit un point d'entre pour la phase de correction du
traitement de la requte</td></tr>
<tr><th><a href="directive-dict.html#Syntax">Syntaxe:</a></th><td><code>LuaHookFixups  /chemin/vers/lua/script.lua hook_function_name</code></td></tr>
<tr><th><a href="directive-dict.html#Context">Contexte:</a></th><td>configuration du serveur, serveur virtuel, rpertoire, .htaccess</td></tr>
<tr><th><a href="directive-dict.html#Override">AllowOverride:</a></th><td>All</td></tr>
<tr><th><a href="directive-dict.html#Status">Statut:</a></th><td>Exprimental</td></tr>
<tr><th><a href="directive-dict.html#Module">Module:</a></th><td>mod_lua</td></tr>
</table>
<p>
    Idem LuaHookTranslateName, mais s'excute durant la phase de
    correction.
</p>

</div>
<div class="top"><a href="#page-header"><img alt="top" src="../images/up.gif" /></a></div>
<div class="directive-section"><h2><a name="luahookinsertfilter" id="luahookinsertfilter">Directive</a> <a name="LuaHookInsertFilter" id="LuaHookInsertFilter">LuaHookInsertFilter</a></h2>
<table class="directive">
<tr><th><a href="directive-dict.html#Description">Description:</a></th><td>Fournit un point d'entre pour la phase insert_filter du
traitement de la requte</td></tr>
<tr><th><a href="directive-dict.html#Syntax">Syntaxe:</a></th><td><code>LuaHookInsertFilter  /chemin/vers/lua/script.lua hook_function_name</code></td></tr>
<tr><th><a href="directive-dict.html#Context">Contexte:</a></th><td>configuration du serveur, serveur virtuel, rpertoire, .htaccess</td></tr>
<tr><th><a href="directive-dict.html#Override">AllowOverride:</a></th><td>All</td></tr>
<tr><th><a href="directive-dict.html#Status">Statut:</a></th><td>Exprimental</td></tr>
<tr><th><a href="directive-dict.html#Module">Module:</a></th><td>mod_lua</td></tr>
</table><p>Non encore implment</p>
</div>
<div class="top"><a href="#page-header"><img alt="top" src="../images/up.gif" /></a></div>
<div class="directive-section"><h2><a name="luahooklog" id="luahooklog">Directive</a> <a name="LuaHookLog" id="LuaHookLog">LuaHookLog</a></h2>
<table class="directive">
<tr><th><a href="directive-dict.html#Description">Description:</a></th><td>Permet une insertion dans la phase de journalisation du
traitement d'une requte</td></tr>
<tr><th><a href="directive-dict.html#Syntax">Syntaxe:</a></th><td><code>LuaHookLog  /path/to/lua/script.lua log_function_name</code></td></tr>
<tr><th><a href="directive-dict.html#Context">Contexte:</a></th><td>configuration du serveur, serveur virtuel, rpertoire, .htaccess</td></tr>
<tr><th><a href="directive-dict.html#Override">AllowOverride:</a></th><td>All</td></tr>
<tr><th><a href="directive-dict.html#Status">Statut:</a></th><td>Exprimental</td></tr>
<tr><th><a href="directive-dict.html#Module">Module:</a></th><td>mod_lua</td></tr>
</table>
<p>
    Ce dispositif d'insertion simple permet d'excuter une fonction
    lorsque httpd entre dans la phase de journalisation du traitement
    d'une requte. Vous pouvez ainsi ajouter des donnes  vos propres
    entres de journalisation, manipuler les entres du journal standard
    avant leur enregistrement ou empcher l'enregistrement d'une entre
    dans le journal. Pour empcher l'enregistrement normal des entres
    du journal, renvoyez simplement <code>apache2.DONE</code> dans votre
    gestionnaire de journalisation, ou au contraire, renvoyez
    <code>apache2.OK</code> pour que httpd effectue une journalisation
    normale.
</p>
<p>Exemple :</p>
<pre class="prettyprint lang-config">LuaHookLog "/path/to/script.lua" logger</pre>

<pre class="prettyprint lang-lua">-- /path/to/script.lua --
function logger(r)
    -- on joue  pile ou face :
    -- Si on obtient 1, on crit dans notre propre journal Lua et on dit
    --  httpd de ne pas enregistrer d'entre dans le journal standard..
    -- Si on obtient 2, on nettoie un peu les donnes avant que httpd ne
    -- les enregistre dans le journal standard.

    if math.random(1,2) == 1 then
        -- On effectue notre propre journalisation et le journal
	-- standard n'est pas aliment
        local f = io.open("/foo/secret.log", "a")
        if f then
            f:write("Quelque chose de secret est arriv  " .. r.uri .. "\n")
            f:close()
        end
        return apache2.DONE -- On dit  httpd de ne rien enregistrer
			    --dans le journal standard
    else
        r.uri = r.uri:gsub("somesecretstuff", "") -- nettoie les donnes
        return apache2.OK -- et httpd doit alors les enregistrer.
    end
end</pre>


</div>
<div class="top"><a href="#page-header"><img alt="top" src="../images/up.gif" /></a></div>
<div class="directive-section"><h2><a name="luahookmaptostorage" id="luahookmaptostorage">Directive</a> <a name="LuaHookMapToStorage" id="LuaHookMapToStorage">LuaHookMapToStorage</a></h2>
<table class="directive">
<tr><th><a href="directive-dict.html#Description">Description:</a></th><td>Fournit un point d'entre pour la phase map_to_storage du
traitement de la requte</td></tr>
<tr><th><a href="directive-dict.html#Syntax">Syntaxe:</a></th><td><code>LuaHookMapToStorage  /chemin/vers/lua/script.lua hook_function_name</code></td></tr>
<tr><th><a href="directive-dict.html#Context">Contexte:</a></th><td>configuration du serveur, serveur virtuel, rpertoire, .htaccess</td></tr>
<tr><th><a href="directive-dict.html#Override">AllowOverride:</a></th><td>All</td></tr>
<tr><th><a href="directive-dict.html#Status">Statut:</a></th><td>Exprimental</td></tr>
<tr><th><a href="directive-dict.html#Module">Module:</a></th><td>mod_lua</td></tr>
</table>
    <p>Identique  la directive
    <code class="directive">LuaHookTranslateName</code>, mais s'excute  la
    phase map-to-storage du traitement de la requte. Les modules comme
    mod_cache agissent pendant cette phase, ce qui permet de prsenter
    un exemple intressant de ce que l'on peut faire ici :</p>
    <pre class="prettyprint lang-config">LuaHookMapToStorage "/path/to/lua/script.lua" check_cache</pre>

    <pre class="prettyprint lang-lua">require"apache2"
cached_files = {}

function read_file(filename)
    local input = io.open(filename, "r")
    if input then
        local data = input:read("*a")
        cached_files[filename] = data
        file = cached_files[filename]
        input:close()
    end
    return cached_files[filename]
end

function check_cache(r)
    if r.filename:match("%.png$") then -- Ne concerne que les fichiers PNG
        local file = cached_files[r.filename] -- Vrifie les entres du cache
        if not file then
            file = read_file(r.filename)  -- Lit le fichier vers le cache
        end
        if file then -- Si le fichier existe, on l'envoie
            r.status = 200
            r:write(file)
            r:info(("%s a t envoy au client depuis le cache"):format(r.filename))
            return apache2.DONE -- cout-circuite le gestionnaire par dfaut des fichiers PNG
        end
    end
    return apache2.DECLINED -- Si nous n'avons rien eu  faire, nous laissons les autres s'en charger
end</pre>


    
</div>
<div class="top"><a href="#page-header"><img alt="top" src="../images/up.gif" /></a></div>
<div class="directive-section"><h2><a name="luahooktranslatename" id="luahooktranslatename">Directive</a> <a name="LuaHookTranslateName" id="LuaHookTranslateName">LuaHookTranslateName</a></h2>
<table class="directive">
<tr><th><a href="directive-dict.html#Description">Description:</a></th><td>Fournit un point d'entre  la phase du nom de
traduction du traitement de la requte</td></tr>
<tr><th><a href="directive-dict.html#Syntax">Syntaxe:</a></th><td><code>LuaHookTranslateName  /chemin/vers/lua/script.lua  nom_fonction_hook [early|late]</code></td></tr>
<tr><th><a href="directive-dict.html#Context">Contexte:</a></th><td>configuration du serveur, serveur virtuel</td></tr>
<tr><th><a href="directive-dict.html#Override">AllowOverride:</a></th><td>All</td></tr>
<tr><th><a href="directive-dict.html#Status">Statut:</a></th><td>Exprimental</td></tr>
<tr><th><a href="directive-dict.html#Module">Module:</a></th><td>mod_lua</td></tr>
<tr><th><a href="directive-dict.html#Compatibility">Compatibilit:</a></th><td>Le troisime argument optionnel est disponible depuis la
version 2.3.15 du serveur HTTP Apache.</td></tr>
</table><p>
    Cette directive permet d'ajouter un point d'entre (
    APR_HOOK_MIDDLE)  la phase du nom de traduction du traitement de la
    requte. La fonction hook accepte un seul argument, le request_rec,
    et doit renvoyer un code d'tat qui est soit un code d'erreur HTTP,
    ou une constante dfinie dans le module apache2 :  apache2.OK,
    apache2.DECLINED, ou apache2.DONE.</p>

    <p>Pour ceux qui ne sont pas familiers avec les points d'entre
    (hook), en gros, chaque hook sera invoqu jusqu' ce que l'un
    d'entre eux renvoie apache2.OK. Si un hook n'effectuer pas la
    traduction, il doit juste renvoyer apache2.DECLINED. Si le
    traitement de la requte doit tre interrompu, la valeur renvoye
    doit tre apache2.DONE.</p>

    <p>Exemple :</p>

<pre class="prettyprint lang-config"># httpd.conf
LuaHookTranslateName "/scripts/conf/hooks.lua" silly_mapper</pre>


<pre class="prettyprint lang-lua">-- /scripts/conf/hooks.lua --
require "apache2"
function silly_mapper(r)
    if r.uri == "/" then
        r.filename = "/var/www/home.lua"
        return apache2.OK
    else
        return apache2.DECLINED
    end
end</pre>


   <div class="note"><h3>Contexte</h3><p>Cette directive ne peut tre
   utilise ni  l'intrieur d'une section <code class="directive"><a href="../mod/core.html#directory">&lt;Directory&gt;</a></code> ou <code class="directive"><a href="../mod/core.html#files">&lt;Files&gt;</a></code>, ni dans un fichier htaccess.</p></div>

   <div class="note"><h3>Ordonnancement</h3><p>Les arguments optionnels
   "early" ou "late" permettent de contrler le moment auquel ce script
   s'excute par rapport aux autres modules.</p></div>

</div>
<div class="top"><a href="#page-header"><img alt="top" src="../images/up.gif" /></a></div>
<div class="directive-section"><h2><a name="luahooktypechecker" id="luahooktypechecker">Directive</a> <a name="LuaHookTypeChecker" id="LuaHookTypeChecker">LuaHookTypeChecker</a></h2>
<table class="directive">
<tr><th><a href="directive-dict.html#Description">Description:</a></th><td>Fournit un point d'entre pour la phase type_checker du
traitement de la requte</td></tr>
<tr><th><a href="directive-dict.html#Syntax">Syntaxe:</a></th><td><code>LuaHookTypeChecker  /chemin/vers/lua/script.lua hook_function_name</code></td></tr>
<tr><th><a href="directive-dict.html#Context">Contexte:</a></th><td>configuration du serveur, serveur virtuel, rpertoire, .htaccess</td></tr>
<tr><th><a href="directive-dict.html#Override">AllowOverride:</a></th><td>All</td></tr>
<tr><th><a href="directive-dict.html#Status">Statut:</a></th><td>Exprimental</td></tr>
<tr><th><a href="directive-dict.html#Module">Module:</a></th><td>mod_lua</td></tr>
</table><p>
    Cette directive fournit un point d'entre pour la phase
    type_checker du traitement de la requte. Cette phase
    correspond au moment o la requte se voit assigner un type et un
    gestionnaire de contenu, et peut donc tre utilise pour modifier le
    type et le gestionnaire en fonction de l'entre :
    </p>
    <pre class="prettyprint lang-config">LuaHookTypeChecker "/path/to/lua/script.lua" type_checker</pre>

    <pre class="prettyprint lang-lua">    function type_checker(r)
        if r.uri:match("%.to_gif$") then -- foo.png.to_gif convient
            r.content_type = "image/gif" -- affectation du type image/gif
            r.handler = "gifWizard"      -- force le traitement de la requte par le module gifWizard
            r.filename = r.uri:gsub("%.to_gif$", "") -- corrige le nom du fichier demand
            return apache2.OK
        end

        return apache2.DECLINED
    end</pre>

    
</div>
<div class="top"><a href="#page-header"><img alt="top" src="../images/up.gif" /></a></div>
<div class="directive-section"><h2><a name="luainherit" id="luainherit">Directive</a> <a name="LuaInherit" id="LuaInherit">LuaInherit</a></h2>
<table class="directive">
<tr><th><a href="directive-dict.html#Description">Description:</a></th><td>Contrle la manire dont les sections de configuration
parentes sont fusionnes dans les enfants</td></tr>
<tr><th><a href="directive-dict.html#Syntax">Syntaxe:</a></th><td><code>LuaInherit none|parent-first|parent-last</code></td></tr>
<tr><th><a href="directive-dict.html#Default">Dfaut:</a></th><td><code>LuaInherit parent-first</code></td></tr>
<tr><th><a href="directive-dict.html#Context">Contexte:</a></th><td>configuration du serveur, serveur virtuel, rpertoire, .htaccess</td></tr>
<tr><th><a href="directive-dict.html#Override">AllowOverride:</a></th><td>All</td></tr>
<tr><th><a href="directive-dict.html#Status">Statut:</a></th><td>Exprimental</td></tr>
<tr><th><a href="directive-dict.html#Module">Module:</a></th><td>mod_lua</td></tr>
<tr><th><a href="directive-dict.html#Compatibility">Compatibilit:</a></th><td>Versions 2.4.0 et suprieures</td></tr>
</table><p>Par dfaut, si des directives LuaHook* se trouvent dans
    des sections de configuration Directory ou Location qui se
    chevauchent, les scripts
    dfinis dans les sections les plus spcifiques s'excutent
    <em>aprs</em> ceux dfinis dans les sections plus gnriques
    (LuaInherit parent-first). Vous pouvez inverser cet ordre, ou faire
    en sorte que le contexte parent ne s'applique pas du tout.</p>

    <p>Jusqu'aux versions 2.3.x, le comportement par dfaut consistait 
    ignorer les directives LuaHook* situes dans les sections de
    configuration parentes.</p>
</div>
<div class="top"><a href="#page-header"><img alt="top" src="../images/up.gif" /></a></div>
<div class="directive-section"><h2><a name="luainputfilter" id="luainputfilter">Directive</a> <a name="LuaInputFilter" id="LuaInputFilter">LuaInputFilter</a></h2>
<table class="directive">
<tr><th><a href="directive-dict.html#Description">Description:</a></th><td>Fournit une fonction Lua pour le filtrage en entre</td></tr>
<tr><th><a href="directive-dict.html#Syntax">Syntaxe:</a></th><td><code>LuaInputFilter filter_name /path/to/lua/script.lua function_name</code></td></tr>
<tr><th><a href="directive-dict.html#Context">Contexte:</a></th><td>configuration du serveur</td></tr>
<tr><th><a href="directive-dict.html#Status">Statut:</a></th><td>Exprimental</td></tr>
<tr><th><a href="directive-dict.html#Module">Module:</a></th><td>mod_lua</td></tr>
<tr><th><a href="directive-dict.html#Compatibility">Compatibilit:</a></th><td>Disponible depuis la version 2.4.5 du serveur HTTP
Apache</td></tr>
</table>
<p>Cette directive permet d'ajouter un filtre en entre sous la forme
d'une fonction Lua. A l'instar des filtres en sorties, les filtres en
entre fonctionnent comme des sous-routines, intervenant dans un premier
temps avant l'envoi du contenu des tampons, puis chaque fois qu'un
paquet de donnes doit tre transmis  la chane, et ventuellement
produisant toute donne  ajouter aux donnes en entre. La variable
globale <code>bucket</code> contient les paquets de donnes tels qu'ils
sont transmis au script Lua :
</p>

<pre class="prettyprint lang-config">LuaInputFilter myInputFilter "/www/filter.lua" input_filter
&lt;Files "*.lua"&gt;
  SetInputFilter myInputFilter
&lt;/Files&gt;</pre>

<pre class="prettyprint lang-lua">--[[
    Exemple de filtre en entre qui convertit toutes les donnes POST en
    majuscules.
]]--
function input_filter(r)
    print("luaInputFilter called") -- pour dbogage
    coroutine.yield() -- attend des paquets de donnes
    while bucket do -- Pour chaque paquet, faire ...
        local output = string.upper(bucket) -- Convertit toutes les donnes POST en majuscules
        coroutine.yield(output) -- Envoie les donnes traites  la chane de filtrage
    end
    -- plus aucune donne  traiter.
    coroutine.yield("&amp;filterSignature=1234") -- Ajoute une signature  la fin
end</pre>

<p>
Le filtre en entre peut interdire ou sauter un filtre s'il est
considr comme indsirable :
</p>
<pre class="prettyprint lang-lua">function input_filter(r)
    if not good then
        return -- Empche tout simplement le filtrage et transmet le contenu original
    end
    coroutine.yield() -- attend des paquets de donnes
    ...               -- insert les filtres ici
end</pre>

<p>
Voir "<a href="#modifying_buckets">Modification de contenu avec les
filtres Lua</a>" pour plus de dtails.
</p>

</div>
<div class="top"><a href="#page-header"><img alt="top" src="../images/up.gif" /></a></div>
<div class="directive-section"><h2><a name="luamaphandler" id="luamaphandler">Directive</a> <a name="LuaMapHandler" id="LuaMapHandler">LuaMapHandler</a></h2>
<table class="directive">
<tr><th><a href="directive-dict.html#Description">Description:</a></th><td>Met en correspondance un chemin avec un gestionnaire lua</td></tr>
<tr><th><a href="directive-dict.html#Syntax">Syntaxe:</a></th><td><code>LuaMapHandler modele-uri /chemin/vers/lua/script.lua
[nom-fonction]</code></td></tr>
<tr><th><a href="directive-dict.html#Context">Contexte:</a></th><td>configuration du serveur, serveur virtuel, rpertoire, .htaccess</td></tr>
<tr><th><a href="directive-dict.html#Override">AllowOverride:</a></th><td>All</td></tr>
<tr><th><a href="directive-dict.html#Status">Statut:</a></th><td>Exprimental</td></tr>
<tr><th><a href="directive-dict.html#Module">Module:</a></th><td>mod_lua</td></tr>
</table>
    <p>Cette directive permet de faire correspondre un modle d'uri avec
    une fonction de gestionnaire situe dans un fichier spcifique. Elle
    utilise les expressions rationnelles PCRE pour mettre en
    correspondance l'uri, et supporte les groupes de correspondance
    d'interpolation dans le chemin du fichier et le nom de la fonction.
    Prenez garde aux problmes de scurit en crivant vos expressions
    rationnelles.</p>
   <div class="example"><h3>Exemples :</h3><pre class="prettyprint lang-config">LuaMapHandler "/(\w+)/(\w+)" "/scripts/$1.lua" "handle_$2"</pre>
</div>
        <p>Cette directive va faire correspondre des uri comme
	/photos/show?id=9 au fichier /scripts/photos.lua, et invoquera la
	fonction de gestionnaire handle_show au niveau de la vm lua
	aprs chargement de ce fichier.</p>

<pre class="prettyprint lang-config">LuaMapHandler "/bingo" "/scripts/wombat.lua"</pre>

        <p>Cette directive invoquera la fonction "handle" qui est la
	valeur par dfaut si aucun nom de fonction spcifique n'est
	spcifi.</p>

</div>
<div class="top"><a href="#page-header"><img alt="top" src="../images/up.gif" /></a></div>
<div class="directive-section"><h2><a name="luaoutputfilter" id="luaoutputfilter">Directive</a> <a name="LuaOutputFilter" id="LuaOutputFilter">LuaOutputFilter</a></h2>
<table class="directive">
<tr><th><a href="directive-dict.html#Description">Description:</a></th><td>Fournit une fonction Lua pour le filtrage de contenu en
sortie</td></tr>
<tr><th><a href="directive-dict.html#Syntax">Syntaxe:</a></th><td><code>LuaOutputFilter filter_name /path/to/lua/script.lua function_name</code></td></tr>
<tr><th><a href="directive-dict.html#Context">Contexte:</a></th><td>configuration du serveur</td></tr>
<tr><th><a href="directive-dict.html#Status">Statut:</a></th><td>Exprimental</td></tr>
<tr><th><a href="directive-dict.html#Module">Module:</a></th><td>mod_lua</td></tr>
<tr><th><a href="directive-dict.html#Compatibility">Compatibilit:</a></th><td>Disponible  partir de la version 2.4.5 du serveur HTTP
Apache</td></tr>
</table>
<p>&gt;Cette directive permet d'ajouter un filtre en sortie sous la forme
d'une fonction Lua. A l'instar des filtres en sorties, les filtres en
entre fonctionnent comme des sous-routines, intervenant dans un premier
temps avant l'envoi du contenu des tampons, puis chaque fois qu'un
paquet de donnes doit tre transmis  la chane, et ventuellement
produisant toute donne  ajouter aux donnes en sortie. La variable
globale <code>bucket</code> contient les paquets de donnes tels qu'ils
sont transmis au script Lua :
</p>

<pre class="prettyprint lang-config">LuaOutputFilter myOutputFilter "/www/filter.lua" output_filter
&lt;Files "*.lua"&gt;
  SetOutputFilter myOutputFilter
&lt;/Files&gt;</pre>

<pre class="prettyprint lang-lua">--[[
    Exemple de filtre en sortie qui chappe toutes les entits HTML en
    sortie
]]--
function output_filter(r)
    coroutine.yield("(Handled by myOutputFilter)&lt;br/&gt;\n") -- Ajoute des donnes au dbut de la sortie,
                                                                -- puis attend des paquets de donnes  traiter
    while bucket do -- Pour chaque paquet, faire ...
        local output = r:escape_html(bucket) -- Echappe les donnes en sortie
        coroutine.yield(output) -- Envoie les donnes traites  la chane
    end
    -- plus aucune donne  traiter.
end</pre>

<p>
Comme les filres en entre, le filtre en sortie peut interdire ou sauter un filtre s'il est
considr comme indsirable :
</p>
<pre class="prettyprint lang-lua">function output_filter(r)
    if not r.content_type:match("text/html") then
        return -- Empche tout simplement le filtrage et transmet le contenu original
    end
    coroutine.yield() -- attend des paquets de donnes
    ...               -- insert les filtres ici
end</pre>

<div class="note"><h3>Les filtres Lua avec <code class="module"><a href="../mod/mod_filter.html">mod_filter</a></code></h3>
<p>Lorsqu'on utilise un filtre Lua comme fournisseur sous-jacent via la
directive <code class="directive"><a href="../mod/mod_filter.html#filterprovider">FilterProvider</a></code>, le
filtrage ne fonctionnera que si <var>filter-name</var> est identique 
<var>provider-name</var>.
</p> </div>

<p>
Voir "<a href="#modifying_buckets">Modification de contenu avec les
filtres Lua</a>" pour plus de dtails.
</p>


</div>
<div class="top"><a href="#page-header"><img alt="top" src="../images/up.gif" /></a></div>
<div class="directive-section"><h2><a name="luapackagecpath" id="luapackagecpath">Directive</a> <a name="LuaPackageCPath" id="LuaPackageCPath">LuaPackageCPath</a></h2>
<table class="directive">
<tr><th><a href="directive-dict.html#Description">Description:</a></th><td>Ajoute un rpertoire au package.cpath de lua</td></tr>
<tr><th><a href="directive-dict.html#Syntax">Syntaxe:</a></th><td><code>LuaPackageCPath /chemin/vers/include/?.soa</code></td></tr>
<tr><th><a href="directive-dict.html#Context">Contexte:</a></th><td>configuration du serveur, serveur virtuel, rpertoire, .htaccess</td></tr>
<tr><th><a href="directive-dict.html#Override">AllowOverride:</a></th><td>All</td></tr>
<tr><th><a href="directive-dict.html#Status">Statut:</a></th><td>Exprimental</td></tr>
<tr><th><a href="directive-dict.html#Module">Module:</a></th><td>mod_lua</td></tr>
</table>
    <p>Cette directive permet d'ajouter un chemin  la liste des chemins
    de recherche des bibliothques partages de lua. Ceci modifie le
    package.cpath dans les vms lua.</p>


</div>
<div class="top"><a href="#page-header"><img alt="top" src="../images/up.gif" /></a></div>
<div class="directive-section"><h2><a name="luapackagepath" id="luapackagepath">Directive</a> <a name="LuaPackagePath" id="LuaPackagePath">LuaPackagePath</a></h2>
<table class="directive">
<tr><th><a href="directive-dict.html#Description">Description:</a></th><td>Ajoute un rpertoire au package.path de lua</td></tr>
<tr><th><a href="directive-dict.html#Syntax">Syntaxe:</a></th><td><code>LuaPackagePath /chemin/vers/include/?.lua</code></td></tr>
<tr><th><a href="directive-dict.html#Context">Contexte:</a></th><td>configuration du serveur, serveur virtuel, rpertoire, .htaccess</td></tr>
<tr><th><a href="directive-dict.html#Override">AllowOverride:</a></th><td>All</td></tr>
<tr><th><a href="directive-dict.html#Status">Statut:</a></th><td>Exprimental</td></tr>
<tr><th><a href="directive-dict.html#Module">Module:</a></th><td>mod_lua</td></tr>
</table><p>Cette directive permet d'ajouter un chemin  la liste des
    chemins de recherche du module lua. Elle suit les mmes conventions
    que lua. Ceci modifie le package.path dans les vms lua.</p>

    <div class="example"><h3>Exemples :</h3><pre class="prettyprint lang-config">LuaPackagePath "/scripts/lib/?.lua"
LuaPackagePath "/scripts/lib/?/init.lua"</pre>
</div>

</div>
<div class="top"><a href="#page-header"><img alt="top" src="../images/up.gif" /></a></div>
<div class="directive-section"><h2><a name="luaquickhandler" id="luaquickhandler">Directive</a> <a name="LuaQuickHandler" id="LuaQuickHandler">LuaQuickHandler</a></h2>
<table class="directive">
<tr><th><a href="directive-dict.html#Description">Description:</a></th><td>Fournit un point d'entre pour la gestion rapide du
traitement de la requte</td></tr>
<tr><th><a href="directive-dict.html#Syntax">Syntaxe:</a></th><td><code>LuaQuickHandler /path/to/script.lua hook_function_name</code></td></tr>
<tr><th><a href="directive-dict.html#Context">Contexte:</a></th><td>configuration du serveur, serveur virtuel, rpertoire, .htaccess</td></tr>
<tr><th><a href="directive-dict.html#Override">AllowOverride:</a></th><td>All</td></tr>
<tr><th><a href="directive-dict.html#Status">Statut:</a></th><td>Exprimental</td></tr>
<tr><th><a href="directive-dict.html#Module">Module:</a></th><td>mod_lua</td></tr>
</table>
    <p>Cette phase s'excute juste aprs l'attribution de la requte 
    un serveur virtuel, et permet d'effectuer certains traitements avant
    le droulement des autres phases, ou de servir une requte sans
    avoir  la traduire, l'associer  un espace de stockage, etc...
    Comme cette phase s'excute avant toute autre, les directives telles
    que <code class="directive"><a href="../mod/core.html#location">&lt;Location&gt;</a></code> ou
    <code class="directive"><a href="../mod/core.html#directory">&lt;Directory&gt;</a></code> ne
    sont pas encore prises en compte, car Les URI n'ont pas encore t
    entirement interprts.
    </p>
   <div class="note"><h3>Contexte</h3><p>Cette directive ne peut tre
   utilise ni  l'intrieur d'une section <code class="directive"><a href="../mod/core.html#directory">&lt;Directory&gt;</a></code> ou <code class="directive"><a href="../mod/core.html#files">&lt;Files&gt;</a></code>, ni dans un fichier htaccess.</p></div>

</div>
<div class="top"><a href="#page-header"><img alt="top" src="../images/up.gif" /></a></div>
<div class="directive-section"><h2><a name="luaroot" id="luaroot">Directive</a> <a name="LuaRoot" id="LuaRoot">LuaRoot</a></h2>
<table class="directive">
<tr><th><a href="directive-dict.html#Description">Description:</a></th><td>Spcifie le chemin de base pour la rsolution des chemins
relatifs dans les directives de mod_lua</td></tr>
<tr><th><a href="directive-dict.html#Syntax">Syntaxe:</a></th><td><code>LuaRoot /chemin/vers/un/rpertoire</code></td></tr>
<tr><th><a href="directive-dict.html#Context">Contexte:</a></th><td>configuration du serveur, serveur virtuel, rpertoire, .htaccess</td></tr>
<tr><th><a href="directive-dict.html#Override">AllowOverride:</a></th><td>All</td></tr>
<tr><th><a href="directive-dict.html#Status">Statut:</a></th><td>Exprimental</td></tr>
<tr><th><a href="directive-dict.html#Module">Module:</a></th><td>mod_lua</td></tr>
</table>
    <p>Cette directive permet de spcifier le chemin de base qui sera
    utilis pour valuer tous les chemins relatifs dans mod_lua. En
    l'absence de cette directive, les chemins relatifs sont rsolus par
    rapport au rpertoire de travail courant, ce qui ne sera pas
    toujours appropri pour un serveur.</p>

</div>
<div class="top"><a href="#page-header"><img alt="top" src="../images/up.gif" /></a></div>
<div class="directive-section"><h2><a name="luascope" id="luascope">Directive</a> <a name="LuaScope" id="LuaScope">LuaScope</a></h2>
<table class="directive">
<tr><th><a href="directive-dict.html#Description">Description:</a></th><td>Une valeur parmi once, request, conn, thread -- la valeur par dfaut est once</td></tr>
<tr><th><a href="directive-dict.html#Syntax">Syntaxe:</a></th><td><code>LuaScope once|request|conn|thread|server [min] [max]</code></td></tr>
<tr><th><a href="directive-dict.html#Default">Dfaut:</a></th><td><code>LuaScope once</code></td></tr>
<tr><th><a href="directive-dict.html#Context">Contexte:</a></th><td>configuration du serveur, serveur virtuel, rpertoire, .htaccess</td></tr>
<tr><th><a href="directive-dict.html#Override">AllowOverride:</a></th><td>All</td></tr>
<tr><th><a href="directive-dict.html#Status">Statut:</a></th><td>Exprimental</td></tr>
<tr><th><a href="directive-dict.html#Module">Module:</a></th><td>mod_lua</td></tr>
</table>
    <p>Cette directive permet de spcifier la dure de vie de
    l'interprteur Lua qui sera utilis dans ce "rpertoire". La valeur
    par dfaut est "once".</p>

   <dl>
    <dt>once:</dt> <dd>utilise l'interprteur une fois.</dd>

    <dt>request:</dt> <dd>utilise l'interprteur pour traiter tout ce
    qui est bas sur le mme fichier dans la requte, et qui se trouve
    aussi dans la porte de la requte.</dd>

    <dt>conn:</dt> <dd>idem request, mais attach  connection_rec</dd>

    <dt>thread:</dt> <dd>Utilise l'interprteur pendant toute la dure
    de vie du thread qui traite la requte (disponible seulement avec
    les MPMs threads).</dd>

    <dt>server:</dt>  <dd>Le comportement est ici diffrent, car la
    porte du serveur prsente une dure de vie assez longue, et
    plusieurs threads vont partager le mme server_rec. Pour grer tout
    ceci, les tats lua du serveur sont stocks dans une liste de ressources
    apr. Les arguments <code>min</code> et <code>max</code> permettent
    de spcifier les nombres minimaux et maximaux d'tats lua  stocker
    dans la liste.</dd>
   </dl>