% Do not remove the next line
% Synchronized with Rev. *

\chapter{Documentation pour développeur}


\section{Incompatibilité entre version 2.0 et 3.x}

En déplaçant les paquetages de la version 2.0 vers la version 3.x, vous devez 
faire attention aux choses suivantes~:

\begin{itemize}
\item La version 3.x utilise un autre format pour le fichier 
  opt/$<$paquetage$>$.txt (s'adapte en 2 minutes), voir 
  \jump{sec:opt_txt}{Liste des fichiers à copier}
\item Les programmes exécutables doivent être construits avec le récent 
  UClibc au lieu de libc5, voir \jump{sec:libc}{Compiler des programmes}
\item Les scriptes de démarrage doivent maintenant être nommès 
  rc$<$nummer$>$.$<$name$>$, autrement ils ne seront pas exportés, voir 
  \jump{sec:script_names}{autres fichiers}
  
\item Utiliser Iptables au lieu d'ipchains, les scriptes et les commandes 
  ipchains, doivent être réécrits
\item Utiliser Linux 2.4.x ou 2.6.x au lieu de linux 2.2.x, les modules 
  du kernel doivent être remplacés
\end{itemize}


\section{Règles générales}

Certaines règles doivent être respectées, lorsque vous ajoutez un nouveau 
paquetage dans la base de données OPT-fli4l, qui se trouve sur la page 
d'accueil du site fli4l. Le paquetage qui ne respectent pas à ces règles, 
sera supprimé de la base de données, sans avertissement préalable.

  \begin{enumerate}
    \item L'utilisateur ne doit faire, AUCUNE copie supplémentaire! sur le 
    site, fli4l propose un système sophistiqué, tous les fichiers 
    qui fait fonctionner le routeur, sont dans le répertoire opt/. Les 
    données des paquetages-fli4l sont empaqueté dans l'archive opt.img. 

    \item Empaqueter et compresser correctement des paquetages~: de telle sorte, 
    que les paquetages soient facilement décompresser dans le répertoire-fli4l.

    \item Les paquetages doivent être TOTALEMENT configurable dans le fichier de 
    configuration. L'utilisateur ne doit pas faire de modifications sur 
    d'autres fichiers de configurations. Vous ne devez pas mettre l'utilisateur 
    en difficulté, sur des décisions difficiles à prendre, par exemple 
    (à la fin du fichier de configuration avec une remarque en gros caractère~: 
    ONLY MODIFY IF YOU KNOW WHAT YOU DO). 

    \item Encore une remarque sur le fichier de configuration~: les nom des 
    variables doivent être claires et l'on doit savoir à quelle OPT elles 
    appartiennent, par exemple \var{OPT\_\-HTTPD} les nom des variables sont 
    \var{OPT\_\-HTTPD}, \var{HTTPD\_\-USER\_\-N}, etc.

    \item S'il vous plaît, si vous avez compilé vous-même de petits (Programmes) 
    binaire! N'oubliez pas qu'avec la commande suivante strip-en, de meilleur 
    résultat peuvent être réaliser, exemple~:
\begin{example}
\begin{verbatim}
      strip -R .comment -R .note <Nom du fichier>
\end{verbatim}
\end{example}
    Cette commande est parfois utilisé sur des programmes précompilés. Rien 
    n'est plus frustrant que de télécharger un fichier de 2 Mo, où l'on 
    aurait peu réduire ce fichier à 500 Ko, suffisant pour le téléchargement...

    \wichtig{Si vous avez libère judicieusement de la place pour les modules, 
    en utilisant la commande strip-en, si plus aucun module ne fonctionnent 
    après coup! Merci de lire le fichier kernel-2.4/mkkernel-strip.sh 
    dans le sous-répertoire src de votre fli4l.
    }

    \item Contrôler votre Copyright! Si vous utilisé un modèle de fichier, 
    merci de respecter les droit de l'auteur. Le copyright doit est remplacé 
    ici par votre propre nom si vous créez vos fichiers. vérifié en particulié, 
    les fichiers dans config-, Check- et les fichiers textes dans opt-. Si vous 
    copiez La documentation mot à mot, le copyright de l'auteur d'orgine 
    doit être naturellement gardé!

    \item Merci de diffuser seulement des types d'archivages, utilisant des 
    formats libres. Il s'agit notamment~:
    \begin{itemize}
      \item ZIP  (.zip)
      \item GZIP (.tgz ou .tar.gz)
    \end{itemize}
    Veuillez ne pas utiliser les formats suivants~:
    \begin{itemize}
      \item RAR
      \item ACE
      \item BlackHole
      \item LHA
      \item etc.
    \end{itemize}
    En outre, les fichiers d'installation Windows (.msi), les archives 
    auto-extractable et les fichier d'installer (.exe) ne doivent pas 
    être utilisés.
  \end{enumerate}


\marklabel{sec:libc}{
  \section{Compiler les programmes}
}

Pour pouvoir compiler des programmes, vous allez avoir besoin d'un programme. 
Pour ce faire, veuillez voir la description de l'archive src.tar.gz, qui est 
fournie séparément.


\section {Utiliser un Kernel modifié -- Compiler vos propres modules}

Si vous voulez modifier la configuration du Kernel 2.4 (par le Kernel 
analogique 2.6) pour fli4l, vous pouvez utiliser le script mkkernel.sh 
depuis le répertoire src/kernel-2.4 de l'archive-src src.tar.gz, ce script 
automatise la construction du Kernel.   

Comment cela fonctionne, vous pouvez le voir à l'aide du script~:

\begin{example}
\begin{verbatim}
    mkkernel.sh -h
\end{verbatim}
\end{example}

Si vous voulez modifier la configuration, les étapes suivantes sont nécessaires~:
\begin{enumerate}

      \item Tous les patchs supplémentaires, éventuellement nécessaires 
        sont à copier dans le dossier src/kernel-2.4. Les noms doivent être 
        comme ceci~:
\begin{example}
\begin{verbatim}
    patch_<patch name>_<kernel version>
\end{verbatim}
\end{example}

      \item L'essentiel pour préparer la configuration~:
\begin{example}
\begin{verbatim}
    cd src/kernel-2.4
    mkkernel.sh -fetch  # chercher le Kernel sur www.kernel.org
    mkkernel.sh -unpack # dépaqueter
    mkkernel.sh -patch  # utiliser le Patch
\end{verbatim}
\end{example}

           Si le Kernel se trouve déjà quelque part sur votre ordinateur local, 
           vous pouvez vous épargner de l'option -fetch avec mkkernel.sh, vous 
           pouvez alors indiquer le répertoire dans lequelle l'archive se trouve. 

         \item Configurer le Kernel~:
\begin{example}
\begin{verbatim}
    cd linux-<kernel version>
    make xconfig # autre config autre menuconfig
    cp .config ../dot-config
\end{verbatim}
\end{example}

           Si l'on a déjà en main un dot-config, on peut économiser les 
           démarches 2 et 3 

         \item Construire le Kernel~:
\begin{example}
\begin{verbatim}
    mkkernel.sh -remove # supprimer les anciens fichiers binaires
    mkkernel.sh -kernel # construire le Kernel et ses modules
    mkkernel.sh -hisax  # construire le module-Hisax
\end{verbatim}
\end{example}

            Ensuite, le Kernel et ces modules se trouvent dans le répertoire 
            structuré conforme à fli4l ./opt. Si la version du Kernel a 
            changé, vous devez paramétrer la nouvelle version du Kernel dans 
            la variable VERSION\_KERNEL du fichier config/base.txt, car mkfli4l 
            va chercher dans cette variable la version et les modules corrects 
            pour l'empaquetage.
\end{enumerate}

Voici d'autres options du programme mkkernel.sh~:

\begin{itemize}
\item {\bf -all} -- Effectue toutes les actions nécessaires
\item {\bf -nohisax} -- Tous les modules, sauf le module Hisax-isdn
\item {\bf -other} -- Construit les modules non contenus dans le Kernel
\item {\bf -header} -- Met à disposition les en-têtes Linux, dont on a 
   besoin pour construire les modules externes.
\end{itemize}


\section{Concept modulaire}

Depuis la version 2.0, fli4l est réparti en modules (paquetages), 
par exemple
\begin{itemize}
    \item fli4l-\version~~$<$--- paquetage base

    \item dns-dhcp
    \item dsl
    \item isdn
    \item sshd
\item et bien d'autres ...
\end{itemize}

Avec le paquetage base, fli4l est un simple routeur Ethernet. Pour RNIS 
et/ou DSL, vous devez décompacter le paquetage ISDN et/ou DSL dans le 
répertoire fli4l. Il en va de même pour les autres paquetages.


\marklabel{mkfli4l}{\subsection{mkfli4l}}

À partir des paquetages et en fonction des paramètres spécifiques aux fichiers 
de configurations, les fichiers suivants sont produits, un fichier avec 
les configurations, du nom rc.cfg et deux archives du nom rootfs.img et 
opt.img, ces fichiers sont produits à l'aide du programme mkfli4l, 
celui-ci lie les différents paquetages et contrôle les fichiers de 
configurations pour repérer d'éventuelles erreurs.   

Mkfli4l accepte les options indiqués dans le tableau \ref{tab:mkfli4l}. Si 
aucune valeur n'est indiquée, les valeurs par défaut entre les parenthèses 
seront prises en compte. Vous pouvez voir la liste complète des options avec 
le paramètre~: 

\begin{verbatim}
    mkfli4l -h
\end{verbatim}


\begin{table}[htbp]
  \centering
  \begin{tabular}{|lp{2cm}|p{9cm}|}
   \hline
    \multicolumn{1}{|c|}{\bf Option} & \multicolumn{2}{c|} {\bf Signification} \\
    \hline
    -c, -\,-config    & \multicolumn{2}{|p{11cm}|} { Avec cette option, on 
      défini le répertoire dans lequel mkfli4l recherche les fichiers 
      de config des paquetages; (par défaut: config)} \\
    -x, -\,-check     & \multicolumn{2}{|p{11cm}|} { On place ici la liste 
      des fichiers des paquets, dans le quel mkfli4l doit contrôler et 
      rechercher les erreurs ($<$paquetage$>$.txt, $<$paquetage$>$.exp et 
      $<$paquetage$>$.ext; (par défaut: check)} \\
    -l, -\,-log       & \multicolumn{2}{|p{11cm}|} { On place ici le 
      fichier jounal, dans le quel mkfli4l enregistre les messages 
      d'erreurs et les avertissements; (par défaut: img/mkfli4l.log)} \\
    -p, -\,-package   & \multicolumn{2}{|p{11cm}|} { On place ici le paquetage 
      qui doit être examiné, on peut indiquer dans cette option plusieurs paquetages 
      à la fois pour qu'ils soient examinés. Cependant si vous utilisez 
      l'option -p, l'option $<$check\_dir$>$/base.exp est en principe d'abord 
      vérifier, afin de gérer les paramètres général du paquetage de base.} \\
    -i, -\,-info       & \multicolumn{2}{|p{11cm}|} { Avec cette option, 
      on affiche des informations sur le déroulement de la construction 
      (lecture des fichiers, vérification des fichiers, les problèmes 
      rencontrés seront affichés lors du processus de contrôle).} \\
    -v, -\,-verbose    & \multicolumn{2}{|p{11cm}|} { Même signification que 
      la variante -i} \\
    -h, -\,-help       & \multicolumn{2}{|p{11cm}|} { Avec cette option, on 
      affiche l'aide} \\
    \html{\multirow{8}{*}{top}} \latex{\multirow{8}{*}{}}{-d, -\,-debug}  & \multicolumn{2}{|p{11cm}|}
      { Avec cette option, vous 
      pouvez déboguer le processus de construction. Cette option sert surtout 
      pour les développeurs de paquetage, qui souhaitent en savoir un peu plus, 
      sur le déroulement du contrôle des paquetages.} \\
    \cline{2-3}
    \latex{&} \multicolumn{1}{|c|}{\bf Debugoption} & \multicolumn{1}{c|}{\bf Signification} \\
    \cline{2-3}
    \latex{&} \multicolumn{1}{|l|}{check} & show check process \\
    \latex{&} \multicolumn{1}{|l|}{zip-list} & show generation of zip list \\
    \latex{&} \multicolumn{1}{|l|}{zip-list-skipped} & show skipped files \\
    \latex{&} \multicolumn{1}{|l|}{zip-list-regexp} & show regular expressions for ziplist \\
    \latex{&} \multicolumn{1}{|l|}{opt-files} & check all files in opt/$<$paquetage$>$.txt \\
    \latex{&} \multicolumn{1}{|l|}{ext-trace} & show trace of extended checks \\
    \hline
  \end{tabular}
  \caption{Paramètres pour mkfli4l}
  \label{tab:mkfli4l}
\end{table}


\subsection{Structure}

Un paquetage peut contenir plusieurs opts, mais si en général le paquetage contient 
seulement un opt, il est opportun de nommer le paquetage du même nom que l'OPT. 
Vous pourrez ensuite remplacer $<$PAQUETAGE$>$ par le nom des paquetages respectif. 
Un paquetage comprend les éléments suivants~:

\begin{itemize}
\item Gestionnaire de fichiers 
\item Documentation
\item Documentation du développeur
\item Programme client 
\item Code source
\item Autres fichiers
\end{itemize}

Les différentes parties sont détaillées ci-dessous.


\subsection{Configuration du paquetage}

Dans le fichier config/$<$PAQUETAGE$>$.txt, les modifications de la configuration 
du paquetage sont réalisées par l'utilisateur. Toutes les variables du 
fichier de configuration doivent commencer uniformèment par le nom 
de ou des OPTs, par exemple~:

\begin{example}
\begin{verbatim}
      #-------------------------------------------------------------------
      # Optional package: TELNETD
      #-------------------------------------------------------------------
      OPT_TELNETD='no'        # install telnetd: yes or no
      TELNETD_PORT='23'       # telnet port, see also FIREWALL_DENY_PORT_x
\end{verbatim}
\end{example}

Les commentaires et les lignes vide sont permis. Toutes les valeurs derrière 
le signe égale doivent être écrite entre des guillemets \footnote{Il est 
possible d'utiliser les guillemets simples ou les guillemets doubles. On peut 
donc écrire {\em FOO='bar'} ou \emph{FOO="bar"}. Cependant, l'utilisation des 
guillemets doubles doivent être exceptionnelle et vous devez absolument les.
indiquer à l'avance, dans le shell-Unix pour le changement des guillemets 
simples vers doubles}, autrement, lors du boot vous pouvez avoir des problèmes.

    Seul les variables utilisées, sont enregistrées dans le fichier rc.cfg, 
    toutes les autres sont ignorées. La seule exception est la variable qui 
    porte le nom $<$PAQUETAGE$>$\_DO\_DEBUG. Celle-ci sert pour déboguer des 
    paquetages et est enregistrée en globalitée.


\marklabel{sec:opt_txt}{
  \subsection{Liste des fichiers à copier}
}

    Le fichier opt/$<$PAQUETAGE$>$.txt doit contenir les instructions suivantes.
    
\begin{itemize}
\item Quels fichiers correspond, à quel OPT,
\item Quand opt.img est généré, à quelle endroit du rootfs les fichiers 
  doivent-ils être placés,
\item Quel droit les fichiers doivent-ils recevoir uid ou gid,
\item Quel Paramètre pour la convertion des fichiers tar.
\end{itemize}
    Pour que mkfli4l puisse construire la base, avec la liste de tous 
    les archives du Tarballe (archive sous format tar dont les 
    fichiers sont liés).

    Les lignes vides et les lignes qui commencent par le symbole '\#', seront 
    ignorées. Dans la première ligne, vous devez indiquer la version du format 
    du fichier-opt qui commence par~:

\begin{example}
\begin{verbatim}
<première colonne>   <deuxième colonne>   <troisième colonne>
opt_format_version        1                    -
\end{verbatim}
\end{example}

    Les autres lignes ont la syntaxe suivante~:

\begin{example}
\begin{verbatim}
<première colonne> <deuxième colonne> <troisième colonne> <colonne suivante>
 Variable           valeur             Fichier             Option
\end{verbatim}
\end{example}

    \begin{enumerate}
      \item Dans la première colonne se trouve le nom de la variable, 
        elle dépend du fichier appliqué dans la troisième colonne. Si le nom 
        de la variable apparait plusieurs fois dans la première colonne, 
        cela veut dire que plusieurs fichiers en dépendent. Chaque variable 
        qui est placée dans le fichier opt/$<$paquetage$>$.txt, est marqué 
        par mkfli4l.

      \item Dans la deuxième colonne est indiquée la valeur. Si la variable de 
        la première colonne correspond à la valeur indiqué dans la deuxième 
        colonne et si elle est activé (c'est-à-dire que opt-variable est 
        paramétrée sur 'yes'). De plus si vous avez dans la première colonne, 
        \%-Variable qui se répète pour chaque indice différent, ces variables 
        vérifient alors la valeur de la deuxième colonne, si elle correspond, 
        tous les fichiers de la troisième colonne seront copiés. Il est à noter 
        qu’en raison de la valeur actuelle des variables un seul fichier sera 
        copié.

      \item Dans la troisième colonne est indiqué le nom du fichier. Le chemin 
        est relatif au répertoire opt. Le fichier doit exister et être lisible, 
        sinon, il y aura une erreur et le programme mkfli4l qui génère 
        automatiquement la construction de la disquette s’arrêtera.

        Si le nom du fichier commence par {\tt rootfs:}- ou 
        {\tt rootfs:fichier/}-préfixe, le fichier sera copié dans la 
        liste et sera inclus dans le rootfs avec les autre fichiers. Si il y a 
        un préfixe au fichier il sera supprimé avant la copie.

        Si le fichier se trouve dans le sous répertoire-config, il sera ajouté 
        dans la liste des fichiers du répertoire-config, mais ce fichier ne 
        pourra pas avoir de {\tt rootfs:}-préfixe,comme les fichiers qui 
        proviennent du sous répertoire-opt.

        Si le fichier à copier est un module-kernel, on peut remplacer le nom 
        de la version du kernel par \${KERNEL\_VERSION}. mkfli4l prendra alors 
        la version configurée et l'intègrera. Cela permet d'avoir un paquetage de 
        module-kernel pour chaque versions différente, en plus la bonne version 
        du kernel sera toujours copiée sur le routeur. Au sujet des modules-kernel 
        le chemin peut être complètement omis, car mkfli4l trouve le chemin 
        des modules en utilisant les fichiers {\em modules.dep} et 
        {\em modules.alias}, (\jump{subsec:automatic-dependencies}{voir ici}).

        \begin{figure}[h!]
          \centering
          \begin{tabular}{|l|p{5cm}|p{7cm}|}
            \hline
            Option & Signification & Valeur standard \\
            \hline
            uid= & Propriété du fichier, soit numérique ou 
            mot de passwd & root \\
            gid= & Groupe de fichier, soit numérique ou nom 
            de group & root \\
            mode= & Droits d'accès du fichier & 644 (rw-r--r--) pour les 
            fichiers, 755 (rwxr-xr-x) pour les répertoires \\
            flags= & Conversion de nom de fichier-tar &
            \begin{itemize}
            \item {\em utxt} - Conversion au format-Unix 
            \item {\em dtxt} - Conversion au format-Dos 
            \item {\em sh} - Script-Shell, au format Unix, en supprimant 
              l'excédent de caractères 
            \end{itemize} \\
            name= & Nom alternatif sous lequel le fichier a été ajouté 
            dans l'archive & \\
            \hline
            
          \end{tabular}
          \caption{Options pour les fichiers}
          \label{fig:options}
        \end{figure}
        
      \item Vous pouvez voir dans la figure \ref{fig:options} et dans la colonne 
        option, les signification de uid/gid/ droits des fichiers et 
        des conversions.

    Quelques exemples~:
    \begin{itemize}
    \item Copie le fichier, si \var{OPT\_\-TELNETD}='yes', 
      met uid/gid sur root et met les droits sur 755 (rwxr-xr-x).
\begin{example}
\begin{verbatim}
telnetd     yes    files/usr/sbin/in.telnetd mode=755
\end{verbatim}
\end{example}

    \item Copie le fichier, met uid/gid sur root, les droits sur 555 (r-xr-xr-x) 
      et Converti le fichier dans le format Unix en même temps il supprime 
      tous les caractères superflus.
\begin{example}
\begin{verbatim}
base    yes     etc/rc0.d/rc500.killall mode=555 flags=sh
\end{verbatim}
\end{example}

         \item Copie le fichier, si \var{PCMCIA\_\-PCIC}='i822365', 
           met uid/gid sur root et met les droits sur 644 (rw--r--r)
\begin{example}
\begin{verbatim}
pcmcia_pcic i82365 files/lib/modules/${KERNEL_VERSION}/pcmcia/i82365.o
\end{verbatim}
\end{example}

         \item Copie le fichier, si l'une des variables *\_\%  correspond à la 
           deuxième partie, place uid/gid sur root et place les droits 
           sur 644 (rw--r--r) 
\begin{example}
\begin{verbatim}
net_drv_%   3c503  3c503.o
\end{verbatim}
\end{example}

    \end{itemize}

    Les fichiers sont uniquement copiés, si les conditions indiquées plus 
    haut sont remplies, si la variable est placé sur \var{OPT\_\-PAQUETAGE}='yes'. 
    Quelle Opt-variable est associée?, pour la vérification voir le fichier 
    check/$<$paquetage$>$.txt

    Si une variable est référencée dans le paquetage et que celle-ci n'est pas 
    définie, il peut arriver que le paquetage correspondant n’est pas installé. 
    Cela mènerait à un message d'erreur du programme mkfli4l, car mkfli4l attend 
    que toutes les variables référencées dans le fichier opt/$<$paquetage$>$.txt soient 
    définis.

    Pour gérer correctement cette situation, on introduit la fonction-"weak". 
    Avec le format suivant~:

\begin{example}
\begin{verbatim}
            weak        variable    -
\end{verbatim}
\end{example}

    Ainsi la variable est définie même si elle n’est pas disponible et sa valeur 
    est mise sur 'undefined'.
  \end{enumerate}


\marklabel{subsec:konfigspezdatei}{
\subsubsection{Fichiers de configurations spécifiques}
}

Dans certaine situations, on aimerait remplacer des fichiers de configurations 
originaux par des fichiers spécifiques, qui serait compacté dans l’archive opt.img, 
par exemple, ajouter une Key-hôte ou ajouter son propre Scripte-Firewall, ... . 
mkfli4l supporte ce scénario, il vérifie si un fichier est disponible dans le 
répertoire-config, dans ce cas, ce fichier sera ajouté dans la liste des 
fichiers de l’archive opt.img

Une autre façon d’ajouter des fichiers de configurations spécifiques dans 
l'archive Opt, est décrit dans le chapitre 
\jump{subsec:addtoopt}{Contrôle de la configuration avancée}.

\marklabel{subsec:automatic-dependencies}{
\subsubsection{Résolution automatique pour la traçabilité des modules-kernel}}

Dans certaine circonstance un module-kernel a parfois besoin d'autres modules-kernel. 
Ces modules doivent être chargés avant et serons également inclus dans l'archive. 
{\em mkfli4l} détermine la traçabilité des modules avec les fichiers 
{\em modules.dep} et {\em modules.alias} (les deux fichiers sont générés à la 
compilation du kernel) ainsi ils ajouteront automatiquement tous les modules 
nécessaires dans l’archive. Par exemple l’enregistrement peut être le suivant.

\begin{example}
\begin{verbatim}
net_drv_%   ne2k-pci    ne2k-pci.o
\end{verbatim}
\end{example}

Le pilote ne2k\_pci dépend des fichiers suivant 8390.o, et crc32.o ils seront 
ajoutés en premiers dans l'archive. 

L’enregistrement du {\em modules.dep} et du {\em modules.alias} dans le rootfs 
est nécessaire, ensuite {\em modprobe} utilise ces fichiers pour charger les pilotes.


\subsection{Analyse des variables de configuration}

A l'aide du contenus du fichier check/$<$PAQUETAGE$>$.txt les variables peuvent 
être contrôlés pour leurs validités. Ce contrôle était intégré dans les versions 
précédentes du programme MKFLI4L, mais les paquetages fli4l sont modulaire et 
nous avons du installé un fichier pour un second-contrôle. 
Dans ce fichier, une ligne est disponible pour chaque variable du fichier config. 
Ces lignes se composent de quatre colonnes avec les fonctions suivantes~:

\begin{enumerate}

\item Variable - Cette colonne indique le nom des variables à vérifier, qui sont 
  dans le fichier config. Si une variable apparait plusieurs fois avec des nombres 
  différents dans le fichier config, à la place du nombre le signe pourcentage (\%) 
  sera inséré dans la variable. Le signe sera toujours indiqué comme ceci '\_\%\_' 
  au milieu de la variable et comme ceci '\_\%' à la fin de la variable. La 
  variable peut contenir plusieurs signes pourcentages, de sorte à réaliser des 
  matrices multidimensionnels. Normalement vous ne serez pas amené à voir ces 
  variables un peut étranges avec deux signes pourcentage, tels que foo\_\%\_\_\%.

  Dans certaine situation, nous pouvons avoir besoin de variable optionnelle 
  supplémentaire dans le fichier config. Ces variables sont présentes dans le 
  fichier de contrôle, elles sont marquées et précédées du signe '+'. Dans le 
  tableau, vous pouvez voir aussi des variables précédées du signe '++'. Avec 
  le signe '+', ces variables sont présentes ou absente du fichier config. Avec 
  le signe '++', ces variables sont totalement absente du fichier config. Vous 
  pouvez les rajouter manuellement, si vous en avez besoin dans le fichier config.

\item \var{OPT\_\-VARIABLE} - Cette colonne indique, les variables OPT. Ces 
  variables sont seulement vérifiées pour leurs validitées, à savoir si 
  la variable est sur 'yes'. Si la variable de la colonne OPT\_variable n’a pas 
  de relation avec la variable de la colonne Variable, le signe '-' sera indiqué.

\item \var{VARIABLE\_\-N} - Si dans la première colonne, vous avez des variables 
  avec le signe \%, cela signifie que la variable peut être écrite plusieurs fois, 
  avec un nombre différent et croissant. les variables Opt sont proportionnelle à 
  la variable \var{VARIABLE\_\-N} et dépendent de celle-ci. Si la variable ne 
  dépend d'aucune Opt, la Variable\_n ne peut aussi dépendre aucune opt. Si la 
  variable de la colonne Variable\_n n’a pas de relation avec la variable de la 
  colonne Variable, le signe '-' sera indiqué.

\item VALUE - cette colonne donne les valeurs possibles que peut prendre la 
  variable. Vous pouvez par ex. avoir les informations suivant~:

  \begin{tabular}[h!]{|l|l|}
    \hline
    Nom & Signification \\
    \hline
    \hline
    NONE     &  ne déclenche aucun contrôle\\
    YESNO    &  La variable doit être sur "yes" ou sur "No"\\
    NOTEMPTY &  La variable ne peut pas être vide\\
    NOBLANK  &  La variable ne devrait pas contenir d'espaces\\
    NUMERIC  &  La variable doit être numérique\\
    IPADDR   &  La variable doit être une adresse IP\\
    DIALMODE &  La variable doit être sur "on", "off" ou "auto"\\
    \hline
  \end{tabular}

  Si vous indiquez le paramètre {\bf WARN\_}-préfixe, la valeur sera irrégulière 
  et sera indiqué par un message, mkfli4l ne s’arrêtera pas, mais affichera 
  seulement un avertissement.

  Le contrôle est défini par des expressions régulières dans le fichier 
  check/base.exp. Ce fichier à été récemment étendu, il contient maintenant des 
  contrôles complémentaires suivants~: HEX, NUMHEX, IP\_ROUTE, DISK et PARTITION.

  Si les développeurs-opt ont besoin de rajouter une entrée, le nombre de termes 
  peut, à tout moment être étendu.

  En outre, les expressions régulières peuvent être ajoutées directement dans 
  le fichier du répertoire check, on peut également se référer à des expressions 
  existantes. Par exemple au lieu d’utiliser YESNO on pourrait également écrire 
\begin{example}
\begin{verbatim}
        RE:yes|no
\end{verbatim}
\end{example}
cela est utile pour un test qui est effectué qu’une seule fois, il est 
relativement simple. Pour de plus amples informations, voir le chapitre suivant.

    La variable avec le signe pourcentage peut être mieux expliquée avec 
    un exemple. Voici une partie du  fichier check/base.txt~:
\begin{example}
\begin{verbatim}

      NET_DRV_N          -                  -                  NUMERIC
      NET_DRV_%          -                  NET_DRV_N          NONE
      NET_DRV_%_OPTION   -                  NET_DRV_N          NONE
\end{verbatim}
\end{example}

      En d'autres termes, en fonction de la valeur indiquée dans \var{NET\_\-DRV\_\-N} 
      les variables \var{NET\_\-DRV\_\-N}, \var{NET\_\-DRV\_\-1\_\-OPTION}, 
      \var{NET\_\-DRV\_\-2\_\-OPTION}, \var{NET\_\-DRV\_\-3\_\-OPTION}, 
      etc. seront vérifiées.


\subsection{Définitions pour contrôler les variables de configuration}


\subsubsection{Introduction sur les expressions régulières}

  Dans la version 2.0, il y a que 7 expressions, susceptibles d’examinées les 
  variables: None, NotEmpty, Numeric, IPAddr, YesNo, NoBlank, Dialmode. Ces 
  expressions ont été fixé dans mkfli4l pour la vérification, ils ne sont pas 
  extensibles et se limite à essentielle "types de données", avec juste se qu’il 
  faut pour pouvoir faire le contrôle. 

  Dans la version 2.1 un nouveau contrôle a été créé. L'objectif de cette 
  nouvelle création est de faite un contrôle plus flexible des variables, qui 
  sera en mesure d'examiner des expressions plus complexes. C'est la raison pour 
  laquelle les expressions régulières seront utilisées dans un ou plusieurs 
  fichiers séparés. Il sera possible, d'une part, de vérifier les variables 
  avant le contrôle par mkfli4l et d'autre part, les développeurs pourront 
  définir leurs propres expressions, pour la configuration et le contrôle de 
  leur paquetage.

  Vous pouvez trouver une description des expressions régulières, dans 
  "man 7 regex", ou par exemple ici~: \altlink{http://unixhelp.ed.ac.uk/CGI/man-cgi?regex+7}.

\subsubsection{Spécification des expressions régulières}

  On peut spécifier des expressions de deux manières différentes~: 

  \begin{enumerate}
  \item Extension *.exp spécifique au paquetage, dans le fichier check/$<$PAQUETAGE$>$.exp

    Ce fichier se trouve dans le répertoire-check et porte le même nom que son 
    paquetage, par ex. base.exp . Les expressions contiennent les définitions, qui 
    sont référencé dans le fichier *.txt . Ainsi, base.exp peut contrôler les 
    définitions. Bien connu le fichier isdn.exp qui contrôle la définition de 
    la variable \var{ISDN\_\-CIRC\_\-}?\_ROUTE (à l'origine le contrôle de cette 
    variable était absente cela a été modifié).

Chaque définition sera écrite entre deux apostrophes, la syntaxe est la suivante~:
\begin{example}
\begin{verbatim}
        Name = 'expression régulière' : 'le message d'erreur'
\end{verbatim}
\end{example}
Autre exemple de la base.exp~:
\begin{example}
\begin{verbatim}
NOTEMPTY = '.*[^ ]+.*'          : 'should not be empty'
YESNO    = 'yes|no'             : 'only yes or no are allowed'
NUMERIC  = '0|[1-9][0-9]*'      : 'should be numeric (decimal)'
OCTET    = '1?[0-9]?[0-9]|2[0-4][0-9]|25[0-5]'
         : 'should be a value between 0 and 255'
IPADDR   = '((RE:OCTET)\.){3}(RE:OCTET)' : 'no valid ip address'
EIPADDR  = '()|(RE:IPADDR)'
         : 'should be empty or contain a valid ip address'
NOBLANK  = '[^ ]+'              : 'should not contain spaces'
DIALMODE = 'auto|manual|off'    : 'only auto, manual or off are allowd'
NETWORKS = '(RE:NETWORK)([[:space:]]+(RE:NETWORK))*'
         : 'no valid network specification, should be one or more 
            network addresse(s) followed by a netmask, 
            for instance 192.168.6.0/24'
\end{verbatim}
\end{example}

Dans les expressions régulières, vous pouvez toujours rajouter une référence, 
dans une définition existante. Cela est plus facile que de construire une 
expression régulière. Il suffit simplement d’insérer la référence de 
cette manière '(RE:référence)'.

Les messages d'erreur ont tendance à être trop longs. Il est donc possible, de 
les écrire sur plusieurs lignes. Les lignes suivantes peuvent être commencées 
avec plusieurs blanc (espace, tabulation). Lors de la lecture du fichier 
$<$paquetage$>$.exp les espaces excédentaires seront remplacés et réduits par un seul 
espace. Une entrée dans le fichier *.exp pourrait alors ressembler à ce qui suit~:

\begin{example}
\begin{verbatim}
NUM_HEX         = '0x[[:xdigit:]]+'
                : 'should be a hexadecimal number
                   (a number starting with "0x")'
\end{verbatim}
\end{example}

\item Les expressions régulières sont directement installées dans le fichier 
  de contrôle check/*.txt

Certaines expressions sont utilisé qu’une seule fois, ce n’est pas la peine de 
définir ces expressions régulières dans le fichier *.exp. Nous pouvons alors, 
enregistrer simplement ces expressions dans le fichier-Check, par ex.~:

\begin{example}
\begin{verbatim}
        # Variable      OPT_VARIABLE    VARIABLE_N     VALUE
          MOUNT_BOOT          -             -          RE:ro|rw|no
\end{verbatim}
\end{example}

La variable \var{MOUNT\_\-BOOT} ne peut qu’accepter les valeurs 'ro', 'rw' ou 
'no' toutes les autres sont rejetées

Si vous voulez référencer une expression régulière existants, vous devez 
simplement ajouter la référence de cette manière '(RE:...)'.

\end{enumerate}


\subsubsection{Extension d’une expression régulière déjà existant}

Si vous ajoutez un paquetage optionnel supplémentaire, vous devez ajouter une 
expression régulière pour que la valeur de la variable soit examinée, 
l'expression régulière doit être agrandie, cela se passe simplement par l’ajout 
une nouvelle définition des valeurs dans l’expression régulière (comme décrit 
plus haut). Le complément de l'expression régulière existante est copié dans le 
fichier-check/$<$paquetage$>$.exp. L’expression existante sera modifiée, par 
le caractère '+' qui sera ajouté au premier plan. L’expression existante sera 
complétée par une nouvelle valeur, ainsi la nouvelle valeur est ajoutée comme 
l'alternative à la valeur existante. Si une autre expression utilise l'expression 
qui a été complétée, le complément de cette expression sera aussi valable. Vous 
pouvez indiquer un message d'erreur, il sera simplement ajouté après l’expression.

Voici un exemple pour les pilotes-Ethernet~:

\begin{itemize}
\item Le paquetage-base a un ensemble de pilotes Ethernet prédéfini, on sélectionne 
la variable \var{NET\_DRV\_x} avec l'expression régulière \var{NET\_DRV} pour 
que la variable soit contrôlée, voici ce qui est écrit dans le fichier de contrôle~:

\begin{example}
\begin{verbatim}
        NET_DRV         = '3c503|3c505|3c507|...'
                        : 'invalid ethernet driver, please choose one'
                          ' of the drivers in config/base.txt'
\end{verbatim}
\end{example}
\item Nous mettons à disposition le paquetage-PCMCIA pour avoir des pilotes de 
  périphérique supplémentaires, vous devez alors compléter la variable 
  \var{NET\_DRV}, pour avoir quelque chose comme ceci~:

\begin{example}
\begin{verbatim}
        PCMCIA_NET_DRV = 'pcnet_cs|xirc2ps_cs|3c574_cs|...' : ''
        +NET_DRV       = '(RE:PCMCIA_NET_DRV)' : ''
\end{verbatim}
\end{example}
\end{itemize}

Maintenant, vous pouvez également sélectionner les pilotes pcmcia supplémentaires.


\subsubsection{Regex définir la variable au moyen de YESNO}

Après avoir ajouté les pilotes PCMCIA dans NET\_DRV comme décrit plus haut. 
Si le paquetage PCMCIA est désactivé et si vous voulez quand même choisir 
un pilote PCMCIA dans base.txt, sans avoir de message d'erreur à la création 
de la disquette. Pour empêcher cela, vous pouvez modifier le Regex 
(ou expression régulière) pour que la variable dépende de la valeur YESNO du 
fichier-config. Il s'agit de coupler dans le Regex la variable 
\var{PCMCIA\_NET\_DRV}avec la variable \var{OPT\_PCMCIA} qui détermine si 
le paquetage est utilisé, et de placer celle-ci entre deux parenthèses 
directement derrière la première variable. Ainsi, si la variable est sur 'yes' 
on utilise Regex, sinon Regex ne sera pas défini.

\begin{example}
\begin{verbatim}
        PCMCIA_NET_DRV(OPT_PCMCIA) = 'pcnet_cs|xirc2ps_cs|3c574_cs|...' : ''
        +NET_DRV       = '(RE:PCMCIA_NET_DRV)' : ''
\end{verbatim}
\end{example}

Maintenant si on veut utiliser par ex. le pilote xirc2ps\_cs dans base.txt et 
si la variable est paramétré sur OPT\_PCMCIA ='no', il y aura un message 
d’erreur à la création de la disquette.


\marklabel{sec:regexp-dependencies}{
  \subsubsection{Définir Regex en fonction d'autres variables}
}

Vous pouvez alternativement utiliser toutes les valeurs de la variable, à 
condition, que la syntaxe apparaît comme indiquer ci-dessous~:

\begin{example}
\begin{verbatim}
	+NET_DRV(KERNEL_VERSION=~'^2\.4\..*$') = ...
\end{verbatim}
\end{example}

Si l'expression \var{KERNEL\_VERSION} correspond au donné, c'est-à-dire ici à 
utilisation du kernel version 2.4, alors la liste complète des pilotes réseaux 
qui tournent avec celui-ci seront autorisés.


\subsubsection{Message d'erreur}

Si pendant le contrôle, mkfli4l trouve une erreur, un message d'erreur 
apparaîtra exemple~:

\begin{example}
\begin{verbatim}
Error: wrong value of variable HOSTNAME: '' (may not be empty)
Error: wrong value of variable MOUNT_OPT: 'rx' (user supplied regular expression)
\end{verbatim}
\end{example}

La première erreur, a été définie dans le fichier *.exp, une indication sur 
l'erreur sera affichée. La deuxième erreur à été spécifié directement dans le 
fichier *.txt, il n'y a aucune indication supplémentaire sur la raison de l'erreur.


\subsubsection{Définition des expressions régulières}

Les expressions régulières sont définies comme indiqué ci-dessous~:

Expression régulière~: vous pouvez paramétrer une ou plusieurs options, vous 
devez les séparer par le signe '$|$', par ex. 'ro$|$rw$|$no'. Si l’une des 
options s'applique, alors l'expression sera appliquée (ici les expressions 
valides sont 'ro', 'rw' et 'no').

Une option est une concaténation de section, qui sont simplement reliés 
ensemble.

Une section est un "Atome", suivi pas un signe quantificateur '*', '+', '?' ou '\{min, max\}'. 
La signification de ces signes de ces "Atomes" sont les suivantes~:
\begin{itemize}
\item   'a*' - Capture le caractère a, zéro ou plusieurs fois
\item   'a+' - Capture le caractère a, une ou plusieurs fois
\item   'a?' - Capture le caractère a, zéro ou une fois
\item   'a\{2,5\} - Capture le caractère a, entre 2 et 5 fois
\item   'a\{5\} - Capture le caractère a, 5 fois
\item   'a\{2,\} - Capture le caractère a, au moins 2 fois
\end{itemize}
  
\begin{itemize}
\item Expression régulière entre parenthèses, par ex. (a$|$b)+ capture un groupe 
          de caractères, entre les parenthèses il y a un opérateur de choix pour 
          capturer au moins un a ou un b, avec le quantitateur pour capturer une 
          ou plusieurs fois.
        \item Une paire de parenthèses vide, représente une expression "vide"
        \item Une expression entre les crochets "[]" (voir ci-dessous) 
        \item Le point '.' remplace n'importe quel caractère, par ex. '.+' 
          s'applique à toute chaîne qui contient au moins un caractère.
        \item '\^\,' représentre le début d’une chaine de caractères, par ex. 
          '\^\,a.*' s'applique à une chaîne caractères qui commence par un a et 
          suivi par un caractère quelconque, 'a' ou 'adkadhashdkash'.
        \item '\$' fin d’une chaine de caractères, fin de ligne
        \item '$\backslash$' suivis par l'un des caractères spéciaux 
          '\^\,.[\$()$|$*+?\{' correspond au caractère réel sans sa 
          signification spéciale.
        \item un caractère écrit, est exactement un caractère normale, par ex. 
          'a' est le caractère alphabétique 'a'.
\end{itemize}

Signification d'une expression entre des crochets, lire la suite.
\begin{itemize}
                \item '[x-y]' - S'applique à tout les signes qui se situe 
                  entre x et y, par ex. '[0-9]' correspond à tous les caractères 
                  de 0-9, '[a-zA-Z]' correspond à toutes les lettres, qu'elles 
                  soient majuscule ou minuscule

                \item '[\^\,x-y]' - Correspond à n'importe quel signe qui est 
                  en dehors des crochets 

                \item '[:character\_class:]' - S'applique à une classe de 
                  caractère (ou catégories de caractères). Voici les classes de 
                  caractères standard~: alpha, blank, digit, lower, print, 
                  punct, space, upper, xdigit.
\end{itemize}


\subsubsection{Exemples d'expressions régulières}

Jetons un coup d'oeil sur quelques exemples~:

Numeric~: Valeur numérique qui est constitué d’au moins de un, mais aussi d'un 
nombre quelconque de chiffres. Avec le signe '+' la valeur peut être répéter au 
moins une ou plusieurs fois à partir d'un nombre, voici un exemple pour obtenir 
un nombre composé 
:

\begin{example}
\begin{verbatim}
        NUMERIC = '[0-9]+' autre alternative
        NUMERIC = '[[:digit:]]+'
\end{verbatim}
\end{example}

NOBLANK~: valeur qui ne contient pas d'espace, les caractères peuvent être 
quelconque (à l'exception de l'espace), voici un exemple avec divers caractères~:

\begin{example}
\begin{verbatim}
        NOBLANK = '[^ ]*'
\end{verbatim}
\end{example}

De plus cette valeur, ne doit pas être vide~:

\begin{example}
\begin{verbatim}
        NOBLANK = '[^ ]+'
\end{verbatim}
\end{example}

Disk et partition~: Voici les identificateurs pour démarrer sur un disque, 
hd pour le disque-IDE et sd pour le disque-SCSI. Vous avez ensuite les lettres 
de a-z (a pour le premier disque, b pour le 2ème, c ...). Pour terminer vous 
avez les partitions de 1-8 (1-4 pour les 4 première partitions primaire ou 
pour (une seul) partition étendue, 5-8 pour les partitions logiques dans une 
partition étendue). vous pouvez voir ci-dessous les paramètres de l'expression~:

\begin{example}
\begin{verbatim}
        DISK      = '(hd|sd)[a-z]'
        PARTITION = '(hd|sd)[a-z][1-8]'
\end{verbatim}
\end{example}

Une adresse IP se compose de 4 octet ils sont séparés par un "." point. Un octet 
peut être un nombre compris entre 0 et 255. Si nous voulons définir le première 
octet, il faut.

\begin{tabular}[h!]{lr}
  Avoir un chiffre entre 0 et 9: &       [0-9]\\
  un nombre compris entre 00 et 99: &     [0-9][0-9]\\
  un nombre compris entre 100 et 199:&   1[0-9][0-9]\\
  un nombre compris entre 200 et 249: &  2[0-4][0-9]\\
  Avoir un nombre entre 250 et 255: & 25[0-5]\\

\end{tabular}

Puisque les deux premières parties sont très similaires, on peut les résumer~:

\begin{itemize}
\item Un nombre entre 0 et 199: 1?[0-9]?[0-9] (les deux premières parties sont 
  sont créées, mais il manque quelque chose)

\end{itemize}

Suite de la solution, nous allons séparer tout simplement par le signe '$|$' 
chaque partie de l'adresse-IP avec l'expression~: 
'1?[0-9]?[0-9]$|$2[0-4][0-9]$|$25[0-5]' ainsi nous avons tous les octets. Cela 
nous permet désormais d'avoir notre adresse-IP de 4 octets séparé par un point 
(pour écrire un point vous devez placer un {\em backslash} (ou barre oblique 
invercé) sinon, il remplacera tout caractère). Vous pouvez voir ci-dessous la 
syntaxe tiré du fichier .Exp~:

\begin{example}
\begin{verbatim}
        OCTET  = '1?[0-9]?[0-9]|2[0-4][0-9]|25[0-5]'
        IPADDR = '((RE:OCTET)\.){3}(RE:OCTET)'
\end{verbatim}
\end{example}


\subsubsection{Aide à la conception des expressions régulières}

Si vous voulez créer et tester les expressions régulières, vous pouvez 
utiliser l'outil regexp pour l'expression rationnelle, qui ce trouve dans 
base/\{unix,window\}/regexp. Avec la syntaxe suivante~:

\begin{example}
\begin{verbatim}
        utiliser: regexp [-c <check dir>] regexp string
\end{verbatim}
\end{example}

Les paramètres sont les suivants:


\begin{itemize}
\item $<$check dir$>$ est le répertoire contenant les fichiers de contrôle et 
de vérification avec les fichiers *.exp, ainsi regexp pourra recourrir au 
expression déja définie.


\item regexp est une expression régulière (dans le doute, toujours indiquer 
l'expression entre deux guillemets simples '')


\item string est la chaîne à examiner
\end{itemize}

Voici quelques exemples~:
\begin{example}
\begin{verbatim}
        ./regexp -c ../check '[0-9]' 0
        ./regexp -c ../check '[0-9]' a
        Error: wrong value of variable command_line_term: 'a'
               (expression didn't match)
        ./regexp -c ../check IPADDR 192.168.0.1
        ./regexp -c ../check IPADDR 192.168.0.256
        Error: wrong value of variable command_line_term:
               '192.168.0.256' (no valid ip address)
\end{verbatim}
\end{example}

\end{enumerate}


\subsection{Contrôle détaillé de la configuration}

    Il est parfois nécessaire d'effectuer des contrôles plus ou moins complexes. 
    Exemple de choses complexe. Avoir une relation entre les paquetages ou avoir 
    une condition à remplir lorsque des variables prennent certaines valeurs. 
    Par ex. lors du choix d’un adaptateur-PCMCIA-ISDN dans le paquetage PCMCIA

    Pour effectuer ces contrôles, on peut écrire dans le fichier 
    check/$<$PAQUETAGE$>$.ext différent petit test. Ce langage se compose des 
    éléments suivants~:

    \begin{enumerate}
    \item Mot-clé~:

      \begin{itemize}
      \item Contrôle de flux~:

        \begin{itemize}
        \item if (expr) then statement else statement fi
        \item foreach var in set\_var do statement done
        \item foreach var in set\_var\_1 ... set\_var\_n do statement done
        \item foreach var in var\_n do statement done
        \end{itemize}

      \item
        Relation~:
        \begin{itemize}
        \item provides paquetage version x.y.z
        \item depends on paquetage version x.y[$<$expression régulière$>$]
        \end{itemize}

      \item Action~:
        \begin{itemize}
        \item warning "warning"
        \item error   "error"
        \item fatal\_error "fatal error"
        \item set var = value
        \item stat (filename, res)
        \item crypt (variable)
        \item split (string, set\_variable, character)
        \end{itemize}
      \end{itemize}
    \item Type de donnée~:      chaîne de caractère, valeur numérique, 
       numéros de version, matrice
    \item Opération logique~:    $<$, ==, $>$, !=, !, \&\&, $||$,
      =\verb?~?, copy\_pending, samenet, subnet
    \end{enumerate}


\subsubsection{Définition d'un identificateur de paquetage, en rapport avec 
    le numéro de version~: provides}

    Si l’on peut par exemple installer un paquetage pour un service d'impression 
    ou ajouter un paquetage httpd pour un serveur-Web. Chaque paquetage est fourni 
    avec un identifiant. Ainsi, cela évite que deux serveurs-Web soient 
    installés en parallèle, ce qui n’est pas surprenant, car deux serveurs sur 
    le Port 80 se feraient la guerre. En outre, si la version du paquetage est 
    indiquée, il sera plus facile d’actualiser celui-ci. Le numéro de version 
    est divisé en général en trois parties, les deux premières parties ont un 
    seul chiffre, la dernière partie a un chiffre ou un nombre, 
    par exemple, 2.1.23.

\begin{example}
\begin{verbatim}
        provides IDENTIFIER version VERSION_NUMBER
\end{verbatim}
\end{example}


\subsubsection{Définition d’une version spécifique, en rapport avec d'autres 
    versions de paquetages~: depends}

    Si vous avez besoin d’installer un paquetage supplémentaire pour un 
    fonctionnement spécifique (par ex. un serveur Web), on peut spécifier la 
    version du paquetage qui dépendra de la version déterminée de l’installation. 
    La version peut être indiquée avec de 2 chiffres (par ex. 2.1), 3 chiffres 
    (par ex. 2.1.11) ou 3 chiffres et une expression régulière 
    (par ex. 2.1.1 [12], ainsi la version 2.1.11 et la version 2.1.12 sera 
    acceptée).

\begin{example}
\begin{verbatim}
        depends on IDENTIFIER version VERSION
\end{verbatim}
\end{example}


\subsubsection{Message pour l'utilisateur~: warning, error, fatal\_error}

    Avec l'aide de ces trois fonctions, on peut avertir et signaler 
    l’utilisateur, d’une erreur ou interrompre immédiatement le traitement 
    de contrôle. Le format est le suivant~:

    \begin{itemize}
    \item   warning       "text"
    \item   error         "text"
    \item   fatal\_error  "text"
    \end{itemize}

    Dans le texte, on peut faire référence à une variable, en écrivant 
    simplement le nom de la variable précédé du caractère '\$' ou '\%', 
    (on peut éventuellement utiliser les accolades \{\}, pour inclure le nom 
    de la variable au milieu d'un texte). Ensuite mkfli4l interprète le texte 
    (chiffres, nombres, '\_') et lorsqu’il rencontre le préfixe '\$' mkfli4l 
    place le contenu de la variable préconfigurée à cet endroit, si vous avez 
    défini, le préfixe '\%' il place le nom complet \%-Variable. Si vous voulez 
    le caractère original, pour écrire le caractère '\$' ou le caractère '\%', 
    vous devez doubler celui-ci, par exemple '\$\$' ou '\%\%'.


\subsubsection{Affectation}

    Si vous avez besoin d’utiliser une variable temporaire pour une raison 
    quelconque, vous pouvez simplement la créer avec "set var [= value]". 
    Cette variable ne peut pas être une variable de configuration. Vous pouvez 
    omettre "= value", la variable sera alors simplement placée sur "yes", 
    ensuite vous pouvez tester facilement la variable avec l’instruction-if. 
    Vous pouvez spécifier les données suivantes après le signe égal, variable 
    normale, variable indexée, nombre, chaîne de caractère, versions.


\subsubsection{Matrices}

    Si vous souhaitez saisir des éléments individuels dans \%-variable, vous 
    pouvez le faire avec \%\_var[index], pour chaque 
    signe \% un [Index] doit apparaitre.


\subsubsection{Crypter un mot de passe - crypt}

Dans le fichier rc.cfg certaines variables contiennent des mots de passe qui 
ne doivent pas apparaitre en clair. Ces variables peuvent être cryptées en 
utilisant crypt et seront transférées dans un format qui est également utilisé 
par le routeur. On utilise pour cela~:

\begin{example}
\begin{verbatim}
    crypt (password)
\end{verbatim}
\end{example}


\marklabel{subsec:statdatei}{
\subsubsection{Contrôle des propriétés d'un fichier - stat}
}

    stat () vous permet de rechercher les propriétés d'un fichier. Il indique 
    pour l'instant que la taille du fichier, cependant on peut ajouter facilement 
    d'autres attributs. Si vous souhaitez tester des fichiers de configuration 
    dans le répertoire courant, vous devez utiliser la variable \$config\$ pour 
    accéder au répertoire config. Les requêtes sont les suivants (les 
    paramètres utilisés sont que des exemples)~:

\begin{example}
\begin{verbatim}
    stat ("unix/Makefile", test)

    foreach i in openvpn_%_secret
    do
       stat("$$config$$/etc/openvpn/$i.secret", keyfile)
       if (keyfile_res != "OK")
       then
          error "OpenVPN: missing secretfile <config>/etc/openvpn/$i.secret"
       fi
    done
\end{verbatim}
\end{example}

    Dans l'exemple de la boucle ci-dessus, on vérifie si le fichier existe 
    dans le répertoire config à partir du nom de la variable de configuration. 
    Ainsi, si OPENVPN\_1\_SECRET='test' est activée dans le fichier de 
    configuration, la première partie de la boucle vérifie si le fichier 
    etc/openvpn/test.secret est disponible pour la configuration. 

    Ensuite nous allons définir deux variables~:

    \begin{itemize}
    \item test\_res~: Résultat du système de réputation stat() ("OK", si le 
      système de réputation est réussi, sinon il y aura message d'erreur pour 
      le système de réputation)
    \item test\_size~: taille du fichier 
    \end{itemize}

    Cela pourrait alors ressembler à ceci~:

\begin{example}
\begin{verbatim}
        stat ("unix/Makefile", test)
        if ("$test_res" == "OK")
        then
                warning "test_size = $test_size"
        else
                error "Error '$test_res' while trying to get size of ..."
        fi
\end{verbatim}
\end{example}


\marklabel{subsec:fgrepdatei}{
\subsubsection{Utiliser grep pour un fichier - fgrep}
}

    Si vous voulez faire des recherches dans un fichier avec grep, vous avez à 
    disposition la commande fgrep() pour des recherches avec des motifs fixés. 
    La syntaxe de fgrep est ($<$nomdefichier$>$,$<$regex$>$). Si le $<$nomdefichier$>$ 
    n'existe pas alors mkfli4l s’arrête et affiche une erreur fatale! Si vous 
    n'êtes pas sûr que le fichier est toujours présent, avant vous utilisez la 
    commande stat() pour savoir si le $<$nomdefichier$>$ existe. Après vous 
    exécutez la commande fgrep(), le résultat de la recherche sera disponible, 
    comme indiqué ci-dessous~:

     \begin{itemize}

       \item FGREP\_MATCH\_N~: ici le nombre de résultats dans le tabeau de FGREP\_MATCH

       \item FGREP\_MATCH\_x~: quand x varie de 0 jusqu’à FGREP\_MATCH\_N. 
         Ici des différents résultat avec grep. 

     \end{itemize}

     L'exemple ci-dessous illustre l'utilisation de fgrep() tiré du fichier 
     base.ext. Ici on teste PF\_FORWARD\_x avec toutes les donné dans tmpl~: 
     références disponibles.

\begin{example}
\begin{verbatim}
foreach n in pf_forward_n
do
  set rule=pf_forward_%[n]
  if (rule =~ "tmpl:([^[:space:]]+)")
  then
    foreach m in match_%
    do
      stat("$config_dir/etc/fwrules.tmpl/$m", tmplfile)
      if(tmplfile_res == "OK")
      then
        add_to_opt "etc/fwrules.tmpl/$m"
      else
        stat("opt/etc/fwrules.tmpl/$m", tmplfile)
        if(tmplfile_res == "OK")
        then
          add_to_opt "etc/fwrules.tmpl/$m"
        else
          fgrep("opt/etc/fwrules.tmpl/templates", "^$m[[:space:]]+")
          if (fgrep_match_n == 0)
          then
            error "Can't find tmpl:$m for PF_FORWARD_${n}='$rule'!"
          fi
        fi
      fi
    done
  fi
done
\end{verbatim}
\end{example}


\subsubsection{Démontage des paramètres - split}

    Souvent plusieurs paramètres sont appliqués dans une variable, ensuite 
    dans le script de démarrage ces paramètres sont démontés séparément. 
    Si vous voulez effectuer des tests lorsqu’elle est désassemblée, 
    c’est la commande split qu’il vous faut.

\begin{example}
\begin{verbatim}
        split (string, %_var, character)
\end{verbatim}
\end{example}

    La chaîne de caractère peut-être remplacée par une variable, \%-Variable 
    est directement spécifiée comme une chaîne. mkfli4l décompose \%-variable 
    lorsqu’un caractère séparateur apparait, il produit un temps d’arrêt. Sur 
    ce temps d’arrêt, nous pouvons alors faire un test. Si rien ne se trouve 
    entre deux caractères séparateurs, une demande de chaîne de caractères vide 
    est générée comme valeur. A exception des guillemets simple ' ', ici tous 
    les espaces (ou blancs) sont éliminés et aucune demande de chaîne de 
    caractères vides n’est produite.

    Lors de la décomposition des éléments, si un contexte numérique apparait
    dans la variable (par ex. un Index), cela doit être précisé dans la commande 
    Split. Vous devez ajouter un attribut supplémentaire 'numéric'. l'exécution
    ressemblera à ceci~:

\begin{example}
\begin{verbatim}
        split (string, %_var, character, numeric)
\end{verbatim}
\end{example}

   Voici un exemple~:

\begin{example}
\begin{verbatim}
        set bar=''1.2.3.4''
        split (bar, tmp_%, '.', numeric)
        foreach i in tmp_%
        do
                warning "%i = $i"
        done
\end{verbatim}
\end{example}


\marklabel{subsec:addtoopt}{
\subsubsection{Ajouter de fichiers dans opt-Archive}
}

   Avec la fonction {\tt add\_to\_opt()} des fichiers supplémentaires peuvent 
   être ajoutés à l'opt-Archive. Il est possible de sélectionnés \emph{tous} 
   les fichiers du sous répertoire opt/ ou config/. Il n'y a pas de restriction 
   sur l’ajout de fichiers dans un opt-paquetage . Si des fichiers doivent est 
   copiés à la fois dans le répertoire l'opt/ et dans config/, placez d’abord 
   de préférence les fichiers du répertoire config/ avec la commande 
   add\_to\_opt. La fonction add\_to\_opt est complexe et en règle général 
   logique, la fonction décide quel fichier sera copié dans l'archive opt 
   en premier.

   La syntaxe est la suivante: {\tt add\_to\_opt $<$filename$>$[$<$flags$>$]}. 
   Ci-après un exemple à partir du paquetage SSHD.

\begin{example}
\begin{verbatim}
if (opt_sshd)
then
   foreach pkf in sshd_public_keyfile_%
   do
     stat("$config_dir/etc/ssh/$pkf", publickeyfile)
     if(publickeyfile_res == "OK")
     then
         add_to_opt "etc/ssh/$pkf" "mode=400 flags=utxt"
     else
         error "sshd: missing public keyfile ..."
     fi
   done
fi
\end{verbatim}
\end{example}

   Utiliser d'abord \jump{subsec:statdatei}{{\tt stat()}} pour vérifier si le 
   fichier existe bien dans le répertoire config. Si le fichier existe, il sera 
   ajouté à opt-Archive, sinon \var{mkfli4l} renvoie un message d'erreur.

   {\bf Remarque~:} \var{mkfli4l} \jump{subsec:konfigspezdatei}{vérifie} aussi 
   avec la fonction \var{add\_to\_opt} si le fichier à copier, se trouve bien 
   dans le répertoire config. 


\subsubsection{Contrôle de flux}

\begin{example}
\begin{verbatim}
        if (expr)
        then
                statement
        else
                statement
        fi
\end{verbatim}
\end{example}

    Un classique, la construction-if comme nous la connaissons. Si la condition 
    est vraie, alors, l’expression-then est exécutée, si la condition est 
    fausse, l’expression-else sera exécutée.

    Si vous voulez effectuer des tests de \%-variable, il faudra tester chaque 
    variable. Pour éviter cela, il y a l'instruction foreach-Statement, en deux 
    variantes~:

\begin{example}
\begin{verbatim}
        foreach loop_var in set_var
        do
                statement
        done

        foreach loop_var in set_var_1 set_var_2 ... set_var_n
        do
                statement
        done
\end{verbatim}
\end{example}

    Cette boucle parcourt toutes les \%-variables, en commençant par (rechercher 
    dans check/$<$PAQUETAGE$>$.txt) la variable\_n, et récupère l'Index 'n'. Ensuite
    loop\_var exécute la valeur respective pour chaque \%-variable.

    Il convient de noter, au sujet des variables optionnelles qui ne sont pas 
    spécifiées dans la configuration, une instance vide est quand même générée. 
    Elles doivent également être prises en compte dans le script, par exemple, 
    voici la procédure à suivre~:

\begin{example}
\begin{verbatim}
    foreach i in template_var_opt_%
    do
        if (i != "")
        then
            warning "%i is present (%i='$i')"
        else
            warning "%i is undefined (empty)"
        fi
    done
\end{verbatim}
\end{example}

    L'instruction dans la boucle décrites ci-dessus, peut être l'une des 
    fonctions suivante~: if, foreach, provides, depends, warning, error ou 
    fatal\_error

    Si l'on veut tester avec précision \%-variable, on peut sélectionner la 
    commande var\_\%[index]. Index peut être une variable normale, une chaîne 
    ou encore une table indexation.

\begin{example}
\begin{verbatim}
        foreach loop_var in var_n
        do
                statement
        done
\end{verbatim}
\end{example}

    La boucle ci-dessus va de 1 à var\_n. Vous pouvez afficher les variables 
    en utilisant la boucle loop\_var, pour indexer \_\% variable. Si vous voulez 
    parcourir pas une \_\% variable, mais plusieurs à la fois, vous devez 
    utiliser une indexation multiple de la boucle loop\_var pour \_\% variable.


    \subsubsection{Expressions}

    Les expressions vous permettent de fait à peu près tout ce que vous 
    attendez d'un langage de programmation. Les valeurs qui émergent de 
    l'expression 'val' peut-être, une variable, une chaîne ou une table 
    d'indexation. Les variables sont remplacées par des chaînes de caractères 
    comme indiqué ci-dessous. Un test pour l'égalité de deux variables pourrait 
    donc ressembler à ceci: 

\begin{example}
\begin{verbatim}
        var1 == var2
        "$var1" == "$var"
\end{verbatim}
\end{example}

    À noter, que la comparaison selon le type de variables se li dans le 
    fichier check/$<$paquetage$>$.txt où ils ont été créés. Les noms de type de 
    variables commençant par NUM reçoivent un type numérique. Si l'une des 
    deux variables est numérique, la comparaison se fait sur une base numérique, 
    c'est-à-dire que les chaînes sont converties en nombres, puis comparées. 
    Autrement, la comparaison est fondée sur une chaîne, le résultat de la 
    comparaison de '05' et '5' n'est pas une égalité, la comparaison de '18' 
    et '9' est '18' $<$ '9'.

    Pour la comparaison de versions, voici une aide pour la construction 
    de la (version) numérique, cette chaîne déterminera la valeur numérique, 
    dans le but de faire une comparaison les versions. 
    numeric(version) == sub\_version + 1000 * minor\_version + 10000 * major\_version

    Vous trouverez dans le tableau \ref{tab:expr} la liste complète 
    de toutes les expressions.

  \begin{table}[htb]
    \begin{center}
      \begin{tabular}{ll}
        \hline
        expr &                     true if\\
        \hline
        \hline
       id                    &   id == 'yes'\\
       val  == val           &  chaîne/numérique les valeurs sont indentiques\\
       val  != val           &  chaîne/numérique Les valeurs sont diffèrentes\\
       val  == number        &  numérique la valeur de val == nombre\\
       val  != number        &  numérique la valeur de val != nombre\\
       val  $<$  number      &  numérique la valeur de val val $<$  number\\
       val  $>$  number      &  numérique la valeur de val val $>$  number\\
       val  == version       &  numeric(val) == numeric(version)\\
       val  $<$  version     &  numeric(val) $<$  numeric(version)\\
       val  $>$  version     &  numeric(val) $>$  numeric(version)\\
       val  =\verb?~? string &  val correspond à une chaîne expression régulière\\
       ( expr )              &  l'expression entre les parenthèses est vraie\\
       expr \&\& expr        &  les deux expressions sont vraies\\
       expr || expr          &  au moins une des deux expressions est vraie\\
       copy\_pending(id)     &  voir la description ci-dessous\\
       samenet (string1, string2) & chaîne1 décrit le même réseau que la chaîne2\\
       subnet (string1, string2)  & chaîne1 décrit un sous-réseau de chaîne2\\
        \hline
      \end{tabular}
      \caption{Expressions logiques}
      \label{tab:expr}
    \end{center}
  \end{table}


\subsubsection{Opérateur-match}

Avec l'opérateur-match \verb?=~? vous pouvez vérifier, si une expression 
régulière correspond à la valeur de la variable "matches". En outre, 
l'opérateur peut également l’utiliser pour extraire une partie de l’expression 
de la variable. Après avoir appliqué avec succès une expression régulière à 
une variable, un tableau de match\_\%contiendra toutes les parties trouvées de 
la variable. Cela pourrait par exemple ressembler à ceci~:

\begin{example}
\begin{verbatim}
        set foo="foobar12"
        if ( foo =~ "(foo)(bar)([0-9]*)" )
        then
                foreach i in match_%
                do
                        warning "match %i: $i"
                done
        fi
\end{verbatim}
\end{example}

Après une exécution de mkfli4l, cela conduira vers la sortie suivante~:

\begin{example}
\begin{verbatim}
        Warning: match MATCH_1: foo
        Warning: match MATCH_2: bar
        Warning: match MATCH_3: 12
\end{verbatim}
\end{example}

  Lors de l'utilisation de \verb?=~? on peut faire référence à toutes 
  les expressions régulières existants. Si l'on veut par exemple vérifier, 
  si le pilote de la carte Ethernet-PCMCIA a été sélectionné, sans que 
  la variable opt\_pcmcia à été paramétrée sur yes, vous pouvez écrire~:

\begin{example}
\begin{verbatim}
        if (!opt_pcmcia)
        then
            foreach i in net_drv_%
            do
               if (i =~ "(RE:PCMCIA_NET_DRV)")
               then
                   error "If you want to use ..."
               fi
            done
        fi
\end{verbatim}
\end{example}


\subsubsection{Vérifier, en fonction de la valeur de la variable le fichier 
  a été copié~: copy\_pending}

        Avec le processus de vérification copy\_pending() vous pouvez vérifier 
        si le fichier a été copié ou non en fonction de la valeur de la variable. 
        On peut l’utiliser, par exemple pour tester un pilote spécifié par 
        l'utilisateur, pour savoir s’il existe bien et s’il a bien été copié. 
        copy\_pending accepte les noms à tester, sous forme d'une variable ou 
        d'une chaîne. Pour l’écriture des chaînes, opérer comme indiqué 
        ci-dessus, par exemple en utilisant la boucle foreach et "\%loop\_var", 
        avec cela vous pouvez examiner tout le contenu de \%-variable.

        copy\_pending() vérifie si, 
        \begin{itemize}
        \item la variable est active (si l'opt est chargé, la variable doit 
           être placé sur 'yes')

         \item la variable a été référencée dans le fichier opt/$<$paquetage$>$.txt

         \item le fichier a été copié en fonction de la valeur indiquée
        \end{itemize}

    Vous pouvez trouver un petit exemple de l'utilisation de toutes ces 
    fonctions dans le paquetage template.


\subsubsection{Comparer des adresses réseaux avec  -- {\em samenet} et 
  {\em subnet}}

Pour vérifier la communication entre les réseaux, nous avons besoin d'un test, 
pour savoir si les deux réseaux sont identiques ou si l'un des deux est un 
sous-réseau donc différent. Pour vérifier, vous avez deux fonctions 
{\em samenet} et {\em subnet} ; {\em samenet (netz1, netz2)} retourne true, 
si les deux réseaux sont identiques, {\em subnet (netz1, netz2)} retourne true, 
si net1 est le sous-réseau de net2.


\subsubsection{Créer des lignes de Commande-Kernel dans un script ext}

Obligatoire pour certain Opt, elle est utilisée pour rajouter d'autres paramètres 
dans le Kernel lors du Boot, on peut contrôler la variable KERNEL\_BOOT\_OPTION, 
pour savoir si les valeurs ont été bien incluses et d'envoyer au cas échéant un 
message d'avertissement ou d'erreur. Maintenant avec la variable interne 
KERNEL\_BOOT\_OPTION\_EXT on accède directement au script-ext, exemple~: 

\begin{example}
\begin{verbatim}
  set kernel_boot_option_ext="${kernel_boot_option_ext} nokbd"
\end{verbatim}
\end{example}

Ce mécanisme est utilisé dans le paquetage opt\_embedded, pour des problèmes 
connus des appareils WRAP et ALIX, telle que le reboot du mécanisme et de 
l'absence du contrôleur clavier 


\subsection{Prise en charge de Linux 2.4 et 2.6}

Les deux versions du Kernel se distinguent de petits détails, 
mais importants~:

\begin{itemize}
\item Il y a d'autres pilotes disponibles, certains ont disparu, 
   d'autres ont été ajoutés.
\item Les modules se terminent par '.o' ou '.ko'
\item Une partie les modules ont été appelés différemment
\item Certains modules ont un aspect différent
\item Les modules se trouvent à d’autres emplacement 
\end{itemize}

Ces différences sont en grande partie traitées automatiquement par {\em mkfli4l}. 
Pour définir ces modules disponibles, vous pouvez d’une part, contrôler 
les modules en fonction de la version utilisée 
(\jump{sec:regexp-dependencies}{les expressions régulières conditionnelles}) 
et d'autre part, permet à {\em mkfli4l} d’ajouter les différents 
fichiers dans les archives, en fonction de la version du kernel à savoir 
{\em opt/$<$paquetage$>$\_2\_4.txt} et {\em opt/$<$paquetage$>$\_2\_6.txt}.


\subsection{Documentation}

    les fichiers de la documentation sont placés dans 

    \begin{itemize}
    \item doc/deutsch/opt/$<$PAQUETAGE$>$.txt
    \item doc/deutsch/opt/$<$PAQUETAGE$>$.html
    \item doc/english/opt/$<$PAQUETAGE$>$.txt
    \item doc/english/opt/$<$PAQUETAGE$>$.html
    \item doc/french/opt/$<$PAQUETAGE$>$.txt
    \item doc/french/opt/$<$PAQUETAGE$>$.html
    \end{itemize}

    Les fichiers HTML peuvent également être divisés, c'est-à-dire être inclus 
    dans chaque OPT différent. Il faut tout de même qu'un $<$PAQUETAGE$>$.html, 
    soit le fichier référent pour tous les autres (voir Paquetage HD). Les 
    modifications d'un paquetage doivent être documentées dans l'un des fichiers 
    suivants~:

    \begin{itemize}
    \item doc/deutsch/opt/changes/$<$PAQUETAGE$>$-$<$VERSION$>$.txt
    \item doc/english/opt/changes/$<$PAQUETAGE$>$-$<$VERSION$>$.txt
    \end{itemize}

    L'ensemble de la documentation, ne doit pas contenir de tableau et doit 
    contenir après un maximum de 79 caractères un retour de ligne. Vous devez 
    vous assurer que la documentation pourra être lue correctement avec 
    un éditeur sans retour de ligne automatique.

    La documentation peut être produit dans le format Tex et ensuite être 
    transformé en format texte, html, PostScript et PDF. À titre d'exemple, 
    cette documentation peut servir à fli4l. Dans la documentation qui se 
    trouver dans le paquetage-Template traite du minimum requis pour les 
    Macros-\LaTeX. Vous pouvez voir une brève description générale dans 
    les paragraphes suivantes.


\subsubsection{Conditions pour créer une Documentation-\LaTeX}

  Pour créer des documents à partir des sources-\LaTeX, vous avez certaines 
  exigences à respecter relatives à l'environnement~: 

  \begin{itemize}
  \item Sous l’environnement Linux/Unix~: Pour faciliter la production de la 
    documentation, vous avez le programme Makefile, avec celui-ci toutes les 
    commandes sont automatisés (Cygwin devrait faire de même, mais je ne l’ai 
    pas encore testé)
  \item Installer latex2html pour les versions HTML
  \item Installer \LaTeX (fichier tetex testé sous Unix) et pdftex et 
    les paquetages suivants~:
    \begin{itemize}
    \item Script-KOMA à jour (version 2)
    \item Tous les paquetages nécessaires pour pdftex
    \item Dépaqueter le paquetage documentation pour fli4l, il est nécessaires 
      à makefile et fourni des styles de fichiers
  \end{itemize}
  \end{itemize}


\subsubsection{Nom de fichier }

Les fichiers de la documentation sont désignés selon le schéma suivant~:

\begin{description}
\item [$<$nom du paquetage$>$\_main.tex] Contiens la majeure partie de la 
  documentation. $<$nom du paquetage$>$ indique le nom du paquet, il doit être écrit 
  (en minuscules). Ce nom correspond au nom du dossier individuel installé 
  dans fli4l. 
\item[$<$nom du paquetage$>$\_appendix.tex] Si vous souhaitez ajouter des 
  commentaires supplémentaires au sujet du paquetage, ils seront placés 
  ici dans l’annexe. 
\end{description}

Ces fichiers sont placés dans le répertoire
\begin{tabbing}
  aaaaaaaa\=\kill
  \>fli4l/$<$nom du paquetage$>$/doc/deutsch/tex/$<$nom du paquetage$>$
\end{tabbing} 

Vous pouvez voir ci-dessous un exemple du paquetage sshd~:
\begin{verbatim}
> ls fli4l/doc/deutsch/tex/sshd/
Makefile sshd_appendix.tex  sshd_main.tex  sshd.tex
\end{verbatim}

Makefile est chargé de créer la documentation dans le fichier sshd.tex, nous 
indiquons pour le traitement les fichiers documentation et son annexe. 
Vous pouvez voir un exemple dans la documentation-Template.


\subsubsection{Principes de base du \LaTeX}

Mentions légales (Jörg)~: Cela ne fait pas très longtemps que je travail avec 
\LaTeX, ce que je vais vous écrire ici, sera très simplifié et limité, 
nous sommes loin de toutes les possibilités qu’offre \LaTeX

\LaTeX \ fonctionne un peu comme HTML "orienté- balise", seulement les balises 
sont appelées ici commandes, le format est le suivant~: \verb*?\commande? 
par ex. \verb*?\begin{environnement}? ... \verb*?\end{environnement}?.

\sloppypar{Dans la mesure du possible, utiliser les commandes, plutôt qu’abuser 
avec les balises physiques, par ex.~: utiliser \verb*?\warning{ne fait ... pas}? 
au lieu d’utiliser \verb*?\emph{ne fait ... pas}?.}

Chaque commande ou environnement peut absorber plusieurs paramètres 
supplémentaires, on peut écrire \verb*?\commande{paramètre1}{paramètre2}{paramètreN}?.

 Les paramètres optionnels sont indiqués comme ceci~: 
 \verb*?\commande[ParamèterOptionnel]{paramèter1}? ..., en général on indique 
 un seul paramètre optionnel, mais on peut en placer plusieurs dans certains cas. 

Dans le code source du document, certains paragraphes sont séparés par 
des lignes blanches. \LaTeX \ gardera ces sauts de ligne pour séparés 
les paragraphes dans le texte.

Les caractères suivants ont une signification spéciale avec \LaTeX \, ils 
doivent être précédé d'un \ dans le texte pour être écrit normalement~: 
\# \$ \& \_ \% \{ \}. Le caractère '\verb?~?' et '\verb?^?, comme 
ceci: \verb!\verb?~?! \verb!\verb?^?!.

Les principales commandes-\LaTeX sont expliquées dans la documentation-template.


\subsection{Formats de fichier}

    Dans le paquetage tous les fichiers texte (la documentation et les scripts 
    d’installation qui sont sur le routeur) doivent être placés au format DOS, 
    c'est à dire avec un CR-LF au lieu de juste un LF. Cela garantit que les 
    utilisateurs Windows pourront également lire la documentation avec Notepad 
    (ou bloc-notes), et pourront modifier les scripts sous Windows, ensuite 
    ils seront toujours susceptibles de fonctionner sur le routeur. 
    Les Scriptes sont convertis à la construction des archives dans le format 
    utilisé par le routeur (voir flags dans opt/$<$paquetage$>$.txt).


\subsection{Développer la documentation}

    Si vous devez définir programme pour une nouvelle interface, à partir d'un 
    paquetage et qui sera utilisé par d'autres programmes, la documentation de 
    cette interface, sera séparée du reste de la documentation et se trouvera 
    dans {\em doc/dev/$<$PAQUETAGE$>$.txt}.


\subsection{Programme-Client}

    Si vous ajoutez un programme-client pour un paquetage supplémentaire, 
    il sera placé dans le répertoire windows/ pour les clients-Windows et 
    dans le répertoire unix/ pour les clients-Unix et Linux.


\subsection{Code source}

    Les Programmes personnalisés et les codes sources peuvent être récupéré 
    dans le répertoire src/. Si vous avez plusieurs fichiers dans votre 
    programme, il serait bien de créer des sous-répertoires. Le programme peut 
    être construit comme le programme-fli4l, merci de jeter un œil à la 
    documentation du \jump{buildroot}{paquetage-source}.


\marklabel{sec:script_names}{
  \subsection{Les autres fichiers}
}

    Tous les fichiers stockés sur le routeur, sont dans les répertoires 
    opt/etc/ et dans opt/files/. Voici une description~: 

    \begin{itemize}
    \item Les Scriptes dans opt/etc/boot.d et opt/etc/ rc.d sont exécutés pour 
      l'amorçage du système
    \item Les Scriptes dans opt/etc/rc0.d sont exécutés lors de l'arrêt du système
    \item Les Scriptes dans opt/etc/ppp sont exécutés pour appeler et 
      raccrocher d’une connexion par modem 
    \item Vous avez dans opt/files les programmes exécutables et d'autres 
    fichiers, en fonction de leurs positions dans le fichier système *nix
    \end{itemize}

    Les scripts dans opt/etc/boot.d, opt/etc/rc.d et opt/etc/rc0.d sont nommés 
    de façon suivante~: 

    \begin{trivlist}
    \item rc$<$numéro$>$.$<$nom$>$
    \end{trivlist}
    
    Le numéro détermine l'ordre d'exécution de l’installation, le nom donne 
    une indication, pour quel programme/paquetage le script est traité.


\section{Conditions générales de création de script pour Fli4l}

Voici maintenant une introduction générale du Scripts-Shell, que vous pouvez 
lire aussi sur le Web, les informations sont spécifiques à Fli4l. 
Les informations à ce sujet, existent aussi dans les pages du manuel Unix-/Linux-. 
Les liens suivants peuvent servir de points dépard pour ce sujet~:

\begin{itemize}
\item Introduction au Scripts-Shell~:
  \begin{itemize}
  \item \altlink{http://cip.physik.uni-freiburg.de/main/howtos/sh.php}
  \end{itemize}
 \item Manuel en ligne~:
   \begin{itemize}
   \item \altlink{http://www.freebsd.org/cgi/man.cgi?manpath=Red+Hat+Linux/i386+9}
   \item \altlink{http://heapsort.de/man2web}
   \item \altlink{http://man.he.net/}
   \item \altlink{http://www.linuxcommand.org/superman_pages.php}
   \end{itemize}
\end{itemize}

Pour les utilisateurs Unix~: en raison de la place limitée, il n’était 
malheureusement pas possible, d’ajouter certains outils, par exemple awk, tail, 
uniq, etc. Cependant, beaucoup de ces outils peuvent être simulés dans certaine  
mesures. 


\subsection{Structure}

    Dans le monde Unix, il est essentiel de démarrer le script avec le nom de 
    l'interpréteur de commande, à la première ligne vous devez indiquer~: 

\begin{example}
\begin{verbatim}
      #!/bin/sh
\end{verbatim}
\end{example}

    Pour que l'on puisse identifier plus facilement le script, à savoir, à 
    quoi il sert, qui l'a écrit, il faut maintenant que celui-ci soit suivi 
    d'une en-tête à peu près comme ceci~:

\begin{example}
\begin{verbatim}
      #--------------------------------------------------------------------
      # /etc/rc.d/rc500.dummy - start my cool dummy server
      #
      # Creation:     19.07.2001  Tobias Gruetzmacher <fli4l@portfolio16.de>
      # Last Update:  11.11.2001  Tobias Gruetzmacher <fli4l@portfolio16.de>
      #--------------------------------------------------------------------
\end{verbatim}
\end{example}

    Vous pouvez maintenant poursuivre le script ... 


\subsection{Gestion des variables de configuration }

\subsubsection{Généralités}

    La composition de la configuration de fli4l est dans le fichier 
    $<$paquetage$>$/config/$<$paquetage$>$.txt. Lors de la création de la disquette de 
    démarrage, ses variables sont intégrées dans le fichier rc.cfg. Au 
    démarrage du routeur, ce fichier est lu avant tous les scripts rc 
    (scripts dans le dossier /etc/rc.d) de démarrage. Ce script peut 
    simplement accéder à toutes les variables de configuration 
    \$CONFIG\_VARIABLE.

    Si Nous avons besoin de paramètre supplémentaire pour des variables de 
    configuration, même après le démarrage, elles doivent être placées 
    dans un fichier séparé, car le fichier rc.cfg après le démarrage du 
    routeur disparaît. D'habitude, ces valeurs sont placées dans le fichier 
    /var/run/$<$nom$>$. De là, ils ont ensuite lu avec un autre fichier
    script. Il y a deux manières de procéder~:
    
    \begin{itemize}
    \item On écrit tout simplement les valeurs dans un fichier qui sera lu 
    par la suite, en conformité avec le format utilisé.
    \item On génère un fichier de configuration dans laquelle les variables 
    seront sous la forme FOO='foo'.
    \end{itemize}

    Pour ces deux manières, vous avez ci-dessous un exemple concret.


\subsubsection{Exemple pour stocker les valeurs dans un fichier}

    Voici l'exemple du paquetage-ISDN, pour l'évaluation des variables 
    de configuration que vous pouvez voir dans le fichier (/etc/rc.d/rc340.circuits)~:

\begin{example}
\begin{verbatim}
        # Variable pour % Variable
        idx=1
        # toujours activé isdn?
        if [ "$OPT_ISDN" = "yes" ]
        then
        # configuration 1-n circuits
            while [ "$idx" -le "$ISDN_CIRCUITS_N" ]
            do
                # comment composer le numéro n-ten circuits
                eval eaz='$ISDN_CIRC_'$idx'_EAZ'
                # Adresse IP locale pour interface
                eval local='$ISDN_CIRC_'$idx'_LOCAL'
                # ... à distance
                eval remote='$ISDN_CIRC_'$idx'_REMOTE'
                # ... masque du réseau
                eval netmask='$ISDN_CIRC_'$idx'_NETMASK'
\end{verbatim}
\end{example}

    Certaines valeurs sont nécessaires pour plus tard, ils seront donc 
    stockés dans un autre fichier~:

\begin{example}
\begin{verbatim}
                # enregistrer-fichier et générer les valeurs
                echo $local >/var/run/$dev.conf
                # Reste à ajouter
                echo $remote >>/var/run/$dev.conf
                echo $netmask >>/var/run/$dev.conf
\end{verbatim}
\end{example}

    Si vous avez besoin de ces valeurs un peu plus tard, vous 
    pourrai les lire de nouveau, comme vous pouvez le voir dans l’exemple 
    /usr/local/bin/delete-all-routes~:

\begin{example}
\begin{verbatim}
        # lecture des valeurs stockées
        conf=`cat /var/run/$dev.conf`
        # dans $conf les valeurs suivante sont jointes $1, $2, $3, ...
        set $conf
        # En utilisant les valeurs
        ip addr add $1 peer $2 dev $device
\end{verbatim}
\end{example}

    Dès le début de la lecture du fichier, le nombre de valeurs n'est pas 
    établi, on travaille avec la commande shift, jusqu'à ce qu'aucune 
    variable ne soit plus visible. comme indiqué ci-dessous~:

\begin{example}
\begin{verbatim}
        # lecture des valeurs stockées
        conf=`cat /var/run/$interface.conf`
        # dans $conf les valeurs suivante sont jointes $1, $2, $3, ...
        set $conf
        # En utilisant les valeurs
        while [ "$1" != "" ]
        do
            ip route add -net $1 netmask $2 dev $interface
            # les deux premier valeurs sont réglées et jetés, c'est au 
            # tour les prochaines à être gérées. comme les valeurs suivante 
            # $3 vers $1, $4 vers $2, ... , $n zu $(n-2)
            shift 2
        done
\end{verbatim}
\end{example}


\subsubsection{Exemple d'écriture de variable dans le format du fichier-config}

    Si vous souhaitez, écrire des variables dans le même format que le 
    fichier-config, vous pouvez suivre (l'exemple register)~:

    \begin{itemize}
    \item les variables de configuration sont écrites dans le fichier 
      /etc/rc.d/rc910.register~:

\begin{example}
\begin{verbatim}
           {
                echo "register_server='$REGISTER_SERVER'"
                echo "register_always='$REGISTER_ALWAYS'"
           } > var/run/register.conf
\end{verbatim}
\end{example}

    \item Les valeurs dans le fichier /usr/local/bin/register.sh deviennent 
      des commandes simple "source" du Shell (abréviation de "l'extention du 
      fichier"), ensuite la lecture sera disponible pour l'environnement du script~: 

\begin{example}
\begin{verbatim}
              . /var/run/register.conf
\end{verbatim}
\end{example}
    \end{itemize}

    Le nom conventionnelle est défini ici /var/run/$<$opt nom$>$.conf


\subsection{Recherche d'erreur}

    Au démarrage d'un script, il est souvent utile d’activer le mode débogage, 
    pour déterminer si "un ver est dans le script" et pour savoir s'il est inséré 
    au début ou à la fin du texte~:

\begin{example}
\begin{verbatim}
      begin_script <OPT-Name> "start message"
      <script code>
      end_script
\end{verbatim}
\end{example}

En fonctionnement normal, un texte apparait au démarrage du script et à la fin 
de se même texte le préfixe "finished" sera spécifié.

Si vous voulez déboguer un script, vous devez faire deux choses~:

\begin{enumerate}

\item Il faut mettre \jump{DEBUGSTARTUP}{\var{DEBUG\_\-STARTUP}} sur 'yes'.
\item Vous devez activer le débogage de l'opt choisi. On le fait en général 
   par la variable suivante~:
\begin{example}
\begin{verbatim}
      <OPT-Name>_DO_DEBUG='yes'
\end{verbatim}
\end{example}

Dans les fichiers de configurations, \footnote {parfois, plusieurs scripts 
de démarrage sont utilisés pour chaque variable de débogage, ils ont des 
noms différents pour chaque variable de débogage. Voici un rapide coup d'oeil 
sur ces scripts}. Maintenant vous pourrez voir sur la console, la représentation 
exact de l'exécution du programme.
\end{enumerate}

\subsubsection{D'autres variables pour le débogage}

\begin{description}

  \config{DEBUG\_ENABLE\_CORE}{DEBUG\_ENABLE\_CORE}{DEBUGENABLECORE}

  Si cette variable est placée sur {\em yes}, elle permet de créer un core-Dumps 
  (ou image mémoire). Si un programme se bloque en raison d'une erreur, un 
  fichier image enregistre l'état actuel du système, il pourra ensuite être 
  utilisée pour une analyser du problème. L'image core-Dumps sera enregistrée 
  dans le dossier /var/log/dumps/.

  \config{DEBUG\_IP}{DEBUG\_IP}{DEBUGIP}

  Si cette variable est placée sur {\em yes}, tous les appels du programme par 
  le protocol {\em ip} seront enregistrés.

  \config{DEBUG\_IPUP}{DEBUG\_IPUP}{DEBUGIPUP}  

  Si cette variable est placée sur {\em yes}, elle marquera les traces durant 
  l'exécution du Scripte ip-up/-down et seront enregistrées dans le System-Log 
  (ou journal système).

  \config{LOG\_BOOT\_SEQ}{LOG\_BOOT\_SEQ}{LOGBOOTSEQ}

  Si cette variable est placée sur {\em yes}, elle enregistre dans {\em bootlogd} 
  tous le processus de Boot visible sur la console. Cette variable est placée 
  par défaut sur {\em yes}.

  \config{DEBUG\_KEEP\_BOOTLOGD}{DEBUG\_KEEP\_BOOTLOGD}{DEBUGKEEPBOOTLOGD}

  Normalement bootlogd se termine à la fin du processus de boot. Si on active 
  cette variable, cela permet l'enregistrement au-delà de l'arrêt du processus 
  de boot visible sur la console.

  \config{DEBUG\_MDEV}{DEBUG\_MDEV}{DEBUGMDEV}

  Si on active cette variable cela génère le protocole Démons-mdev et produit 
  un fichier des périphériques dans le dossier /dev

%  \config{}{}{}
\end{description}

\subsection{Remarques}

\begin{itemize}
\item Il est {\bf toujours} préférable d'utiliser les accolades {} à la place 
   des parenthèses (). Il convient après l’ouverture de l’accolade de placer, 
   un espace ou un saut de ligne avant la prochaine commande et de placer 
   avant la fermeture de l’accolade un point-virgule ou un nouveau saut de 
   ligne. Par exemple~: 

\begin{example}
\begin{verbatim}
        { echo "cpu"; echo "quit"; } | ...
\end{verbatim}
\end{example}

        Équivaut à~:

\begin{example}
\begin{verbatim}
        {
                echo "cpu"
                echo "quit"
        } | ...
\end{verbatim}
\end{example}


      \item Un script peut être arrêté prématurément avec la commande "exit". 
        Mais pour les Scripts de démarrage (opt/etc/boot.d, opt/etc/rc.d/*), 
        les Scripts d’arrêt (opt/etc/rc0.d/*) et les Scripts ip-up/ip-down avec 
        (opt/etc/ppp/*) cela est carrément mortelle, il faut dire aussi 
        que ces Scripts ne seront plus exécuté. En cas de doute, ne toucher 
        à rien.


      \item KISS - Keep it small and simple - vous voulez utiliser Perl en tant 
        que langage script? Les possibilités d’écriture pour FLI4L ne te 
        suffisent pas? Penser à votre installation! Votre OPT en a vraiment 
        besoin? FLI4L est toujours "uniquement" un routeur, un routeur ne 
        doit pas offrir de services, comme un serveur. 


      \item Le message d'erreur~: "not found" signifie le plus souvent que le 
        script est encore au format-DOS. Autre problème: le script n'est pas 
        exécutable. Dans les deux cas, vous devez vérifier le fichier 
        opt/$<$paquetage$>$.txt afin de déterminer s’il est correct et de
        lui confirmer le bon mode /gid/uid/flags ou s'il contient la bonne 
        option. Si le script est exécuté au boot, un "chmod +x $<$Scriptname$>$" 
        doit être effectué. 


      \item Pour les fichiers temporaires, vous devez utiliser le chemin /tmp. 
        Mais il est essentiel de veiller à ne pas utiliser trop d’espace, 
        parce que le dossier est dans un Ramdisk-Rootfs! Si vous avez besoin de 
        plus d'espace, il faut créer un Ramdisk et le monter. L’ensemble 
        des détails à ce sujet se trouvent dans le paragraphe "RAM-Disks" 
        de Dev-Docu. 


     \item Afin que les fichiers temporaires obtiennent un nom unique, il 
       faut en principe joindre un processus-ID au fichier. Le nom de fichier 
       "correct" est /tmp/$<$nom-de-opts$>$-\$\$ au lieu de /tmp/$<$nom-de-opts$>$, 
       évidemment $<$nom-de-opts$>$ ne doit pas figurer, il sera probablement 
       remplacé par le votre ... et quoi?
\end{itemize}


\section{Travailler avec le filtrage de paquets}

\subsection{Ajouter vos propres chaînes et règles}

Au sujet de la manipulation du filtrage de paquets, vous avez à disposition 
une série de routines, qui permet d'ajouter et de supprimer des chaînes 
et des règles. 

\begin{description}
\item [add\_chain chain, add\_nat\_chain chain] Ajoute d’une chaîne de filtrage 
   ou une table-Nat.
\item [flush\_chain chain, flush\_nat\_chain chain] Supprime toutes les règles 
   d'une chaîne
\item [del\_chain chain, del\_nat\_chain chain] Supprime une chaîne de filtrage 
   ou une table-Nat; Les chaînes doivent être vides et n’avoir aucune référence 
   dans celle-ci, avant de les supprimées 
\item[add\_rule, ins\_rule, del\_rule] Permet d'ajouter une règle à la fin 
   d'une chaîne (add) ou d’insérer une règle dans la chaîne (ins) ou de supprimer 
   une règle à une chaîne (del). Les commandes sont les suivantes~: 
\begin{verbatim}
add_rule table chain rule comment
ins_rule table chain rule position comment
del_rule table chain rule comment
\end{verbatim}
  les paramètres ont les significations suivantes~:
  \begin{description}
  \item[table] La table, dans laquelle la chaîne et la règle doit être insérée 
  \item[chain] La chaîne, dans laquelle la règle doit être insérée 
  \item[rule] La règle, qui doit être inséré; vous devez utiliser le même 
    format que dans le fichier-config
  \item[position] La position, dans laquelle la règle doit être insérée 
  \item[comment] Le commentaire, qui sera affichée avec la règle, si vous voulez 
    voir le filtrage de paquets.
  \end{description}
\end{description}


\subsection{classer les règles dans une infrastructure}

Fli4l configure les règles du filtrage de paquets avec certaine norme. Si vous 
souhaitez insérer vos propres règles, vous pouvez ajouter les règles, selon 
le réglage standard. Pour cela, vous devez savoir quelle action l’utilisateur 
a effectué en rejetant un paquet. Ces informations sont normale pour les 
chaînes FORWARD et INPUT avec l’exécution des deux fonctions suivantes~: 

\begin{verbatim}
get_defaults FORWARD # get default actions for forward chain
get_count    FORWARD # get number of default rules for forward
\end{verbatim}

\begin{description}
\item[\$res] {\em res} contient l'emplacement des règles par défaut
\item[\$drop] {\em drop} contient la chaîne dans l‘arborescence, quand un paquet 
  est rejeté
\item[\$reject] contient la chaîne dans l‘arborescence, quand un paquet 
  est refusé
\end{description}


\subsection{Extension Matches pour le filtrage de paquets}

Fli4l utilise la syntaxe {\tt match:params} dans les règles de filtrage des 
paquets, cela permet d'avoir des conditions supplémentaires pour les paquets 
(voir mac:, limit:, length:, prot:, ...). Si vous voulez ajouter d'autres 
matchs, faite comme ci-dessous~: 

\begin{enumerate}
\item Créer d'un fichier opt/etc/rc.d/fwrules-{\em $<$name$>$}.ext et indiqué 
  ce fichier de la manière suivante~:
\begin{example}
\begin{verbatim}
# extension is available
foo_p=yes

# the actual extension, adding matches to match_opt
do_foo ()
{
        param=$1
        get_negation $param
        match_opt="$match_opt -m foo $neg_opt --fooval $param"
}
\end{verbatim}
\end{example}

\item Test de l'extension 
\begin{example}
\begin{verbatim}
> cd opt/etc/rc.d
> sh test-rules.sh 'foo:bar ACCEPT'
add_rule filter FORWARD 'foo:bar ACCEPT'
iptables -t filter -A FORWARD -m foo --fooval bar -s 0.0.0.0/0 \
    -d 0.0.0.0/0 -m comment --comment foo:bar ACCEPT -j ACCEPT
\end{verbatim}
\end{example}

\item L’expansion est incluse et tous les fichiers restants 
  (les composants-iptables, les modules netfilter) sont archivés avec 
  le mécanisme connus.
\item Pour permettre l'extension de la configuration, il faut ajouter 
  \var{PF\_GENERIC\_MATCH} dans le fichier *.exp, par exemple~:

\begin{example}
\begin{verbatim}
+FW_GENERIC_MATCH='foo:bar' : ''
\end{verbatim}
\end{example}
\end{enumerate}


\section{Création un CGI pour le paquetage-httpd}

\subsection{Information générale pour le serveur-Web}

Le serveur Web, qu’utilise Fli4l est {\tt mini\_httpd} de ACME Labs. Le code 
source et le manuel peuvent être téléchargés sur 
\altlink{http://www.acme.com/software/mini_httpd/}. Toutefois, fli4l a apportées 
quelques modifications sur la version (1.19), le patch se trouve dans 
le paquetage-SRC et dans le répertoire {\tt src/fli4l/httpd}.


\subsection{Nom de script}

Le nom du script doit être le plus efficace possible, de sorte à le distinguer 
facilement, par rapport à d'autres scripts et de vérifier s'il n'existe pas 
de doublon entre les différents noms OPTs.

Ensuite les scripts exécutables seront convertis dans le format-DOS et dans le 
format-UNIX pour transformer les sauts de ligne, puis ils seront enregistrés 
dans opt/votre\_opt.txt (voir ci-dessus).


\subsection{Une entrée dans le menu}

Pour que l’enregistrement d’un élément dans le menu soit possible, il faut 
créer cet élément dans le fichier {\tt /etc/httpd/menu}. Ce système permet de 
modifier le menu des OPTs, même en cours de fonctionnement. Cela doit être fait 
uniquement avec le script {\tt httpd-menu.sh}, vous devez respecter le format 
de fichier pour que ce fichier soit concluant. Pour insérer de nouveaux éléments 
dans le menu, vous devez utiliser la syntaxe suivante~:

\begin{verbatim}
    httpd-menu.sh add [-p <priority>] <link> <name> [section] [realm]
\end{verbatim}

Vous devez d’abord enregistrer le nom du fichier avec {\tt $<$name$>$} et 
indiquer le nom du lien dans {\tt [section]}. Si {\tt [section]} est omise, 
il sera enregistré par défaut dans la section "opt". On indique ensuite avec 
{\tt $<$link$>$} le lien pour la nouvelle page de destination. Puis on spécifie 
avec {\tt $<$priority$>$} la priorité de la section dans le menu. Si elle n'est 
pas spécifiée, la priorité par défaut est de 500. La priorité doit être un 
nombre à trois chiffres. Si la priorité de la section est basse, plus bas sera 
le lien dans cette section. Si un élément du menu est trop bas, vous pouvez 
choisir une priorité supérieure par ex. 900. En cas d'égalité de priorité, 
les entrées sont triées par rapport au rang des liens. Pour terminer on 
spécifiée avec {\tt [realm]}, les droit d’utilisation, ainsi l’utilisateur 
connecté dispose des autorisations pour pouvoir voir affiché les éléments 
du menu. Si {\tt [realm]} n'est pas spécifié, tous les éléments du menu, 
également toutes les sections seront vues par l’utilisateur, voir aussi 
\jump{sec:rights}{le paragraphe droit des utilisateurs}.

Exemple~:

\begin{verbatim}
    httpd-menu.sh add "neuedatei.cgi" "cliquez ici" "Tools" "tools"
\end{verbatim}

Cet exemple crée un lien avec le titre "cliquez ici", la cible du lien est le 
fichier "neuedatei.cgi", le titre est dans la section "Tools", vous pourrez 
utiliser cette section en cas de besoins. 

Le script peut également être utilisé pour supprimer des éléments 
dans le menu~:

\begin{verbatim}
    httpd-menu.sh rem <link>
\end{verbatim}

Avec cette commande et l'entrée du lien dans {\tt $<$link$>$}, cet élément 
du menu sera supprimé. Attention: Si plusieurs éléments du menu pointent vers 
le même fichier, tous les éléments du menu seront supprimés.

Puisque certaines sections ont des priorités, ils peuvent également 
être créés manuellement. La priorité de la section est créée automatiquement, 
lorsque vous créez une entrée, cette section reçoit la priorité 500. La syntaxe 
pour créer une priorité de section différente est la suivante~:

\begin{verbatim}
    httpd-menu.sh addsec <priority> <name>
\end{verbatim}

Vous devez placer dans ce paramètre {\tt $<$priority$>$} 3 chiffres cette 
valeur est numériques.

\wichtig{Pour déterminer judicieusement les priorités, cela vaut la peine 
de regarder le fichier {\tt /etc/httpd/menu} dans fli4l, les priorités sont 
dans la 2éme Colonnes.}

Par souci d'intégralité, voici une brève présentation du fichier menu. Pour 
ceux que la fonction {\tt httpd-menu.sh} suffit, vous pouvez sauter cette partie. 
Le fichier {\tt /etc/httpd/menu} a la structure suivante~: il est divisé en 
quatre colonnes. Dans la première colonne, vous avez une lettre d’identification, 
qui indique les différents éléments du menu. Dans la deuxième colonne, vous 
avez les classes de priorité. La troisième colonne contient les éléments pour 
les destinations des liens, un trait d'union pour le titre dans le menu, 
ce champ n'a pas trop d’importance. Dans la derrière colonne, le texte qui 
apparaît dans le menu.

Utiliser les lettres 't' pour un titre de section, vous pouvez commencer 
une nouvelle section dans le menu. Utiliser la lettre 'e' pour un nom d’élément 
normal dans le menu. Exemple~:

\begin{verbatim}
    t 300 - mon super OPT
    e 200 monnopt1.cgi fait parti du super
    e 500 monnopt1.cgi? plus=oui fait plus parti du super
\end{verbatim}

Lorsque vous modifiez ce fichier, il faut veiller, que le script 
{\tt httpd-menu.sh} soit toujours trié. Les différentes sections sont triées 
et les éléments par section sont classés. L'algorithme de tri exact peut être 
fait avec {\tt httpd-menu.sh} – le mieux serait d'étendre ce script pour rendre 
possible de nouvelles fonctionnalités, afin que toutes les modifications 
intervinnent dans un seul endroit du menu.


\subsection{Construire un script CGI}

\subsubsection{Les en-têtes}

Tous les scripts du serveur Web sont de simples scripts shell (les interpréteurs 
tels que Perl, PHP, etc, sont beaucoup trop gros pour FLI4L). Vous devez 
obligatoirement commencer le script par un en-tête qui doit comporter, 
(la référence de l'interpréteur, le nom, le sens du script, l'auteur, la licence)


\subsubsection{Le script auxiliaire cgi-helper}

Tout de suite après l'en-tête vous devez placer le script auxiliaire 
cgi-helper avec la commande suivante~: 

\begin{verbatim}
. /srv/www/include/cgi-helper
\end{verbatim}

L'espace  entre le point et Slash est important!

Ce script permet diverses fonctionnalités auxiliaires pour simplifier la création 
des CGIs, il est essentiel à fli4l. De plus, avec l'intégration de cgi-helper 
il effectue également des tâches standard, telles que l'analyse syntaxique 
des variables, qui ont été associées à des formulaires ou des transitions URL 
ou de l'affichage de la langue pour le texte ou des fichiers CSS. 

Voici une petite liste des fonctions~:

\begin{table}[htbp]
  \begin{scriptsize}
    \begin{tabular}{ll}
      Nom                  & Fonction \\
      \hline \\
      check\_rights        & Vérification des droits des utilisateurs \\
      http\_header         & Édition d’une HTTP-Headers standard ou d’une 
          en-tête spécifique, par ex., la manière de télécharger des fichiers \\
      show\_html\_header   & Édition complètes d'une en-tête de page (y compris 
          les HTTP-Header et les en-têtes du Menu) \\
      show\_html\_footer   & Édition de la fin d'une page HTML \\
      show\_tab\_header    & Édition d’un contenu de fenêtre pour tableau \\
      show\_tab\_footer    & Édition de la fin de contenu pour tableau \\
      show\_error          & Édition d'une fenêtre pour messages d'erreur 
          (couleur: rouge) \\
      show\_info           & Édition d'une fenêtre pour information/histoires 
          de réussite (couleur: vert) \\
    \end{tabular}
  \end{scriptsize}
  \caption{Fonctions du script cgi-helper.}
\end{table}


\subsubsection{Le contenu}

Afin d'assurer un aspect homogène et surtout pour la compatibilité avec les 
futures versions-fli4l, il est fortement recommandé d'utiliser les fonctions 
ci-dessus, même si nous pouvons théoriquement générer toutes les sorties 
dans un même CGI.

Un simple script-CGI peut ressembler à ceci~:

\begin{verbatim}
   #!/bin/sh
   # --------------------
   # Header (c) Autor Datum
   # --------------------
   # get main helper functions
   . /srv/www/include/cgi-helper

    show_html_header "Mon premier CGI"
    echo '   <h2>Bienvenue</h2>'
    echo '   <h3>Ceci est un exemple de script-CGI</h3>'
    show_html_footer
\end{verbatim}

La valeur qui est indiqué dans la fonction show\_html\_header, est utilisé 
en tant que titre. Il sera généré automatiquement dans le menu, il inclue aussi
automatiquement le script CSS et le fichier langue. Il faut pour cela que les 
fichiers scripts ont le même nom et qu’ils soient dans les répertoires 
/srv/www/css et /srv/www/lang (mais bien sûr, avec une extension différente). 
Exemple~:

\begin{verbatim}
    /srv/www/admin/OpenVPN.cgi
    /srv/www/css/OpenVPN.css
    /srv/www/lang/OpenVPN.de
\end{verbatim}

L'utilisation du fichier-langue ainsi que le fichier-CSS sont facultatif. 
Intégré toujours css/nom.css et lang/nom.xx les 'xx' correspond à la langue 
choisie. 

Vous pouvez placer à côté du titre de la fonction show\_html\_header d'autres 
paramètres. Une exécution de la fonction avec tous les paramètres possibles 
pourrait ressembler à ceci~:

\begin{verbatim}
    show_html_header "Titre de la page" "refresh=$time;url=$url;cssfile=$cssfile;showmenu=no"
\end{verbatim}

Tous les paramètres supplémentaires, comme le montre l'exemple ci-dessus, 
doivent avoir des guillemets et être séparés par un point-virgule. Autrement 
le contrôle de syntaxe ne sera PAS réussi! Il est nécessaire de respecter la 
syntaxe des paramètres.

Voici un bref aperçu des fonctions de ces paramètres~: 

\begin{itemize}
 \item refresh=\$time: Temps en secondes dans lequel la page sera rechargée par le navigateur.
 \item url=\$url: L'URL est rechargé après un rafraîchissement.
 \item cssfile=\$file: Nom du fichier CSS, si celui-ci est différent du CGI. 
 \item showmenu=no: Pour que l'en-tête et dans menu d'affichage le titre soit supprimé.
\end{itemize}

D'autres Conseils pour le contenu du CGI~:

\begin{itemize}
 \item Prenez votre temps~:-)
 \item Écrivez proprement le HTML (SELFHTML est un bon point de départ)
 \item Renoncer au bric-à-brac très moderne, (le JavaScript est OK, si cela ne 
dérange pas l’utilisateur, il doit avoir de l’aide, le script doit également 
fonctionner sans JavaScript)
\end{itemize}


\subsubsection{La fonction show\_tab\_header}

Dans le CGI, pour que le contenu de vos résultats soit bien rangé et affiché 
sur la page Web, avec l'aide du cgi-helper vous pouvez utiliser fonction 
show\_tab\_header. Il peut générer des titres dans des onglets cliquables dans 
un 'Tableau', ainsi celui-ci sera divisé en plusieurs domaines pour placer 
vos résultats, pour pouvez aussi simplement générer un titre (dans le tableau).

Les paramètres dans la fonction show\_tab\_header sont toujours écrits deux par 
deux. Le premier paramètre correspond au titre de l’onglet et le deuxième 
correspond au lien. Si vous indiquez 'no' comme deuxième paramètre, le titre 
sera seulement placé dans l'onglet (en couleur) et le lien ne sera pas cliquable. 

Dans l'exemple suivant, nous allons créer une 'fenêtre' dans laquelle nous 
allons mettre le titre 'Une grande fenêtre’. Dans la fenêtre sera écrit 'foo bar':

\begin{verbatim}
    show_tab_header "Une grande fenêtre" "no"
    echo "foo"
    echo "bar"
    show_tab_footer
\end{verbatim}


Dans l'exemple suivant, on génère deux onglets cliquables dans un tableau, dans 
les variables du script permettent différentes actions. 

\begin{verbatim}
    show_tab_header "1. onglet" "$myname?action=machdas" \
                    "2. onglet" "$myname?action=machdies"
    echo "foo"
    echo "bar"
    show_tab_footer
\end{verbatim}

Maintenant le contenu du script peut exploiter la variable FORM\_action (voir 
ci-dessous pour l’exploitation de la variable) en fonction des différents 
paramètres. l'onglet apparaît et l’on pourra le sélectionner en cliquant 
dessus, si vous ne voulez pas que cet onglet soit sélectionnable, vous devez 
placer dans la fonction 'no', pour ce passé du lien comme indiqué plus haut. 
Cela sera plus facile, si vous vous tenez à l'exemple suivant~:

\begin{verbatim}
    _opt_machdas="1. onglet"
    _opt_machdies="2. onglet"
    show_tab_header "$_opt_machdas" "$myname?action=opt_machdas" \
                    "$_opt_machdies" "$myname?action=opt_machdies"
    case $FORM_action in
        opt_machdas) echo "foo" ;;
        opt_machdies) echo "bar" ;;
    esac
    show_tab_footer
\end{verbatim}

Si vous utilisez une variable pour sélectionner un titre, ce nom correspond à 
l’action de la variable et commencera par un tiret '\_', ainsi l'onglet 
correspond à ce nom pourra être sélectionné.


\subsubsection{Faciliter le multilangage}

Le script contient une documentation afin de réaliser des scripts-CGI 
multilangage. Pour ce faire, vous devez 'juste' utiliser les variables 
commençant par un tiret '\_' pour traduire le texte et de définir ces variables 
dans la langue de votre choix. 

Exemple~:

lang/opt.de~:
\begin{verbatim}
    _opt_machdas="Eine Ausgabe"
\end{verbatim}

lang/opt.en~:
\begin{verbatim}
    _opt_machdas="An Output"
\end{verbatim}

admin/opt.cgi
\begin{verbatim}
    ...
    echo $_opt_machdas
    ...
\end{verbatim}


\subsubsection{Utilisation de formulaires}

Afin de traiter des formulaires, il faut savoir certaines choses. L’utilisation 
doit choisir la méthode de formulaire GET ou POST, les variables se trouvent 
après l’exécution du cgi-helpers (celle-ci exécute le programme proccgi) pour 
les utiliser comme des variables shell, avec le préfixe "FORM\_". Si vous avez 
entré un nom, une "adresse" dans le champ de formulaire et si vous indiquez 
dans le script-shell {\tt\$FORM\_adresse}, cette adresse sera accessible. 

Si vous voulez En savoir plus sur le programme proccgi~:
\altlink{http://www.fpx.de/fp/Software/ProcCGI.html}


\marklabel{sec:rights}{
    \subsection{Droits des utilisateurs}
}
Pour la gestion des droits des utilisateurs, vous devez insérée la ligne 
suivante au début du script~: 

\begin{verbatim}
    check_rights "misc" "test"
\end{verbatim}

Ce script doit est exécuté uniquement si l'utilisateur a tous les droits 
({\tt HTTPD\_RIGHTS\_x='all'}) ou avec tous les droits dans le domaine 
({\tt misc}) ({\tt HTTPD\_RIGHTS\_x='misc:all'}) ou alors avoir les droits pour 
exécuter une action spécifique ({\tt SEC\_ACTION}) ({\tt HTTPD\_RIGHTS\_x='misc:test'}).

% More examples?

\subsection{Divers}

info (Oui, c'est aussi important!)~:

\begin{itemize}
 \item Le {\tt mini\_httpd} ne protège pas les sous-répertoires par mot de passe. 
      Vous devez avoir un répertoire {\tt .htaccess} pour chaque utilisateur 
      ou créer un lien vert un autre fichier-htaccess.
 \item KISS - Keep it simple, stupid!
 \item Ces informations peuvent être changées à tout moment et sans préavis!
\end{itemize}


\subsection{Dépannage}

Pour dépanner vous devez activer Debug dans les CGIs et créer un fichier 
debug.log dans http://fli4l/admin/debug.log. Celui-ci inclura toutes les 
exécutions du CGI. Les Variables ne sont pas traitées en globalités et 
vous devez faire un reset à chaque problème-CGI.

\begin{verbatim}
   set_debug="yes"
   . /srv/www/include/cgi-helper
\end{verbatim}

Curl est idéal pour le dépannage, en particulier lorsque les têtes HTTP ne 
sont pas assemblé correctement ou que le navigateur affiche une page blanche. 
En outre, pour le dépannage le cache des navigateurs modernes est un véritable 
problème. 

Exemple: curl pour les  en-têtes-HTTP dumper (-D), pour voir le résultat CGI 
dans admin/mon.cgi et utiliser pour le nom d'utilisateur (-u) admin. 

\begin{verbatim}
   curl -D - http://fli4l/admin/mon.cgi -u admin
\end{verbatim}
En savoir plus sur curl (commande et information)~:
\altlink{http://de.wikipedia.org/wiki/CURL}


\section{Boot, reboot, se connexion et se déconnexion avec fli4l}

\subsection{Concept de Boot}

fli4l 2.0 peut être installé sur différent média, disque-dur ou 
carte-Compact-Flash(TM), il est aussi possible de l’installer sur un support 
Zip ou sur un CD-ROM amorçable. En outre, l’installation d’une version sur un 
disque-dur n'est pas fondamentalement différente que sur une disquette.

Ces exigences ont été réalisé grâce au fichier opt.img, jusqu'ici il était 
installé sur un disque-RAM maintenant il peut être placé sur d’autre média. 
Il peut s'agir d'une partition sur un disque dur ou une carte-CF. pour ce second 
volume, le répertoire /opt sera monté et de là il y aura uniquement les 
liens symboliques qui seront créés dans le rootfs. Aprè la mise en forme du 
Root-Filesystem correspond, la liste de la distribution-Fli4l est extrait, à 
une exception près -- le préfixe des fichiers est supprimé. Les fichiers 
opt/etc/rc sont directement trouvés dans /etc/rc et pour les fichiers 
opt/files/usr/local/bin/busybox ils sont trouvés dans /usr/local/bin/busybox. 
Ces fichiers sont seulement des liens vers le média monté en lecture seule, 
on peut les ignorer, tant que les fichiers ne sont pas modifiés. Si vous voulez 
les modifier, il faut d'abord rendre ces fichiers accessibles en écriture 
avec la commande mk\_writable.


\subsection{Scripts de démarrage}

Les Scripts exécutés lors du boot système, sont trouvés dans opt/etc/\{boot.d,rc.d\} 
et sont également exportés dans l'ordre, avec l’exécution du fichier boot.d, 
puis du fichier rc.d. Quand ces scripts sont exécutés, ils ne peuvent pas être 
arrêtés avec la commande "exit 0". Cette commande conduirait à une rupture du 
processus de Boot.


\subsubsection{Fonctions auxiliaires pour les scripts de démarrage}

Dans /etc/boot.d/base-helper différentes fonctions sont mises à disposition, 
elles peuvent être utilisées pour les scripts de démarrage. Cela concerne 
les catégories suivantes, le support de débogage, des modules de traitement, l
es messages d'erreur ou le remplacement des références symboliques. Pour charger 
les modules, vous devez utiliser la rotation automatique, avec la fonction de 
résolution do\_modprobe. mkfli4l et modprobe évaluent les modules à installer et 
rajoutent si nécessaire des modules à l'archive automatiquement. La fonction 
do\_insmod existe pour des raisons de compatibilité et pour des cas particuliers.

Les différentes fonctions sont les suivantes et brièvement décrites.

\begin{description}
\item[begin\_script $<$symbol$>$ $<$message$>$] Active le débogueur de script 
et envoie un message en utilisant {\em set -x}, si 
$<$symbol$>$\_DO\_DEBUG est sur yes.
\item[end\_script] Envoie un message final et fournit l'état de débogage 
initiale rétablie.
\item[do\_modrobe $<$module$>$ $<$params$>$] Charge le module avec {\em module} 
et les paramètres avec {\em params}, gére simultanément tout les modules.
\item[do\_modrobe\_if\_exists $<$module\_path$>$ $<$module$>$ $<$params$>$] 
Vérifie dabord si le module dans (/usr/lib/$<$kernel version$>$/$<$module path$>$/module) 
existe et ensuite exécute do\_modprobe.
\item[do\_insmod $<$module$>$ $<$params$>$] charge le module avec {\em module} 
et les paramètres avec {\em params}.
\item[do\_insmod\_once $<$module$>$ $<$params$>$] Avec do\_insmod, C'est la 
seule façon de s'assurer que le module est chargé qu'une seule fois
\item[do\_insmod\_if\_exists module\_path $<$module$>$ $<$params$>$] Vérifie si 
le module est bien dans (/usr/lib/$<$kernel version$>$/$<$module path$>$/module), 
si il existe, la fonction do\_insmod sera exécuté.
\item[do\_insmod\_if\_exists\_once $<$module\_path$>$ $<$module$>$ $<$params$>$] 
Vérifie si le module est bien dans (/usr/lib/$<$kernel version$>$/$<$module path$>$/module), 
si il existe et si il n'est pas déjà chargé, la fonction do\_insmod sera exécuté.
\item[mk\_writable $<$file$>$] Pour vous assurer que le fichier avec {\em file} 
sera accessible en écriture. Seulement si le fichier est en lecture seule dans 
le fichier-système et juste monté par un lien symbolique, une copie locale 
sera alors crée pour avoir le fichier en écrit.
\item[unique $<$elements$>$] Crée une liste des paramètres, pour que les éléments 
apparaissent qu'une seule fois. La liste est retournée dans la variable {\em list}.
\item[log\_error $<$error message$>$] Envoi un message d'erreur sur la console 
et dans /boot\_messages.txt. Si vous avez paramètre aucun message d'erreur, 
lire log\_error.
\item[set\_error $<$error\_message$>$] Envoi un message d'erreur et utilise 
flag-erreur, qui ensuite pourra être examiné via \_error.
\item[is\_error] Réinitialise l'indicateur du flag-erreur et renvoi TRUE si 
il a été fixé.
\item[translate\_ip\_net $<$value$>$] Remplace les références symboliques par 
des paramètres. Actuellement les traductions suivantes auront lieu~:
\begin{description}
  \item[adresse ip , réseau, none, default, pppoe, dynamic, nombre] pas de 
  traduction
  \item[any] est traduit par 0.0.0.0/0
  \item[IP\_NET\_*] est remplacé par le réseau se trouvant dans 
  la configuration.
  \item[IP\_NET\_*\_IPADDR] est remplacé par l'adresse-IP se trouvant dans 
  la configuration.
  \item[IP\_ROUTE\_*] est remplacé par la Route se trouvant dans 
  la configuration.
  \item[@$<$host name$>$] est remplacé par l'hôte ou par l'adresse-IP se 
  trouvant dans la configuration.
  \end{description}
\end{description}

Après l’exécution de translate\_ip\_net, vous pouvez vérifier avec is\_error 
si la traduction c’est faite correctement.


\subsubsection{opt/etc/boot.d/rc*.*}

    Les fichiers de ce répertoire sont exécutés les premiers. Ils ont pour 
    mission, de monter le boot-Device, de lire le fichier rc.cfg et de 
    décompresser les opt-Archive. Selon les scripts Bootyp, ils sont plus 
    ou moins complexes et font les choses suivantes~:

\begin{itemize}
\item load drivers (optional)
\item mount boot media (optional)
\item read rc.cfg
\item extract/mount opt files (optional)
\end{itemize}


\subsubsection{opt/etc/rc.d/rc*.*}

    Commandes, que vous pouvez installer lors du démarrage du routeur, 
    pour les modifications des scripts, il sont stockés dans le répertoire 
    opt/etc/rc.d. Les conventions au sujet des scripts sont les suivantes~:

    \begin{enumerate}
    \item De classer les noms comme ceci~: rc $<$nombre à trois 
    chiffres$>$.$<nom de Opt's>$ les scripts sont démarrés dans l'ordre 
    des numéros. Si plusieurs scripts ont le même numéro, c’est le caractère 
    alphabétique après le point qui détermine l'ordre. L’installation des 
    paquetages s’effectue les uns après les autres, ils sont définis par un numéro.

          Voici une estimation approximative, des numéros pouvant être utilisé 
          pour une installation~:

          \begin{tabular}{ll}
                  \hline
                  Numéro        &       fonction         \\
                  \hline
                  \hline
                  000-099       &       Système de base (mount, fuseau horaire) \\
                  100-199       &       Kernel-Module (Drivers) \\
                  200-299       &       Connexions externe (PPPoE, I4L, PPtP) \\
                  300-399       &       Réseau (Routing, Interfaces, Paketfilter) \\
                  400-499       &       Serveur (DHCP, HTTPD, Proxy, etc.) \\
                  500-900       &       Freeform, use as you wish \\
                  900-997       &       Tout ce qui peut générer un dial-up \\
                  998-999       &       reserved (don't use) \\
                  \hline
          \end{tabular}

    \item Vous devez {\em placer} dans ces scripts, toutes les fonctions 
    nécessaires pour changer le rootfs. (par ex. pour la création d'un 
    répertoire /var/log/lpd.

    \item Vous ne {\em devez} pas effectuer d'écriture dans les fichiers 
    scripts qui font partie d’une opt-Archives, car ces fichiers sont en 
    lecture seule sur le média. Pour modifier de tel fichier, il faut, au 
    préalable rendre accessible ce fichier en écriture via {\em mk\_writable}. 
    En appelant cette fonction, le fichier si nécessaire, sera copié et sera 
    accessible en écriture sur le rootfs. Si le fichier est déjà en écriture, 
    rien ne se passe à l’exécution de la fonction {\em mk\_writable}. 
    \wichtig{mk\_writable doit être utilisé sur les fichiers qui sont dans le 
    rootfs et non pas par le biais du dossier /opt. Si vous voulez modifier 
    /usr/local/bin/foo vous exécutez {\em mk\_writable /usr/local/bin/foo}.}

    \item Ces scripts ont besoin de vérifiés, avant d'exécuter les commandes 
    réelles, si l'OPT correspondant est actif. Cela se fait 
    habituellement par une simple déclaration-if~:

\begin{example}
\begin{verbatim}
    if [ "$OPT_<OPT-Name>" = "yes" ]
    then
        ...
        # ici OPT start!
        ...
    fi
\end{verbatim}
\end{example}

    \item Pour pouvoir déboguer plus facile, vous devez inséter dans le script 
      les fonctions {\em begin\_script name message} et {\em end\_script} 
      entre guillemets~:

\begin{example}
\begin{verbatim}
    if [ "$OPT_<OPT-Name>" = "yes" ]
    then
        begin_script FOO ``configuring foo ...''
        ...
        end_script
    fi
\end{verbatim}
\end{example}

    Pour juste déboguer de script au démarrage, vous devez simplement activer 
    la variable FOO\_DO\_DEBUG= 'yes'.

    \item Ce script ne peut pas accéder directement au fichier rc.cfg. Ce 
      n'est pas nécessaire, parce que toutes les variables de ce fichier sont 
      directement disponibles lorsque la procédure de démarrage sera terminée. 
      Dans le paragraphe "gestion des variables de configuration" explique 
      comment vous pouvez enregistrer des variables pour une utilisation 
      ultérieure. 

    \item . Le dossier /opt ne doit pas être utilisé comme dépôt pour 
    l’ensemble des données Opts. Si vous avez besoin espace supplémentaire, 
    vous devez créer un Ramdisk (ou disque virtuel) ensuite vous pourrez 
    indication ce chemin pour les variables.
    \end{enumerate}


\subsubsection{Stop-Scripts}

Chaque ordinateur a besoin d’un temps pour s’arrêter ou de redémarrer. 
Or, vous pouvez exécuter une fonction qui peut arrêter ou redémarrer 
l'ordinateur. Les commandes officielles sont halt et reboot. Ces commandes 
sont également placées dans IMONC, si vous l’avez installé, un clique sur le 
bouton suffira pour arrêter ou redémarrer.

Tous les scripts d'arrêt se trouvent dans le répertoire opt/etc/rc0.d /. 
Le nom du fichier est analogue à celui du script de démarrage.


\subsection{Périphériques ttyI}

Au sujet les périphériques ttyI, vous pouvez utiliser (/dev/ttyI0 ... /dev/ttyI15), 
pour la création d’un "émulateur de modem" avec des cartes ISDN (ou RNIS), 
il existe un compteur pour les conflits entre les différents paquetages et 
l’utilisation de ces périphériques, dispositif à éviter. Ces émulateur seront créés 
lors du démarrage du routeur, dans le fichier /var/run/next\_ttyI, avec 
l'utilisation un compteur. Dans l'exemple du script suivant, les valeurs sont 
interrogées, ils sont augmentés de un et seront à nouveau exportés comme Add-on 
pour un prochain démarrage.

\begin{example}
\begin{verbatim}
ttydev=`cat /var/run/next_ttyI`
if [ "$ttydev" -le 16 ]
then                                    # ttyI device available? yes
    ttydev=`/usr/bin/expr $ttydev + 1`  # ttyI device + 1
    echo $ttydev >/var/run/next_ttyI    # et enregistrer à nouveau
else                                    # ttyI device available? no
    /usr/local/bin/colecho "*** ERROR: no ttyI device for \
    <Name deines Addons> available ! ***" br x br
    sleep 10                            # wait, so user can read message
    ttydev_error=true                   # set error for later use
fi

if [ "$ttydev_error" != true ]          # start addon only if next tty device
                                        # was available to minimize error
then                                    # messages and minimize the
    ....                                # risk of uncomplete boot
fi
\end{verbatim}
\end{example}


\subsection{Scripts de connexion et de déconnexion par modem}

/etc/ppp transformés.ici les paquetages-opt sont exécuter comme des actions, après 
la création d'une connexion ou la déconnexion par modem si nécessaire. Les 
fichiers sont nommés comme ci-dessous~:

\begin{tabular}[h!]{ll}
    ip-up$<$numéro à trois chiffres$>$.$<$OPT-Name$>$    & est exécuté lors de la connexion \\
    ip-down$<$numéro à trois chiffres$>$.$<$OPT-Name$>$  & est exécutée {\em après} la déconnexion \\
\end{tabular}

Dans le script ip-down aucune intervention ne peut être réalisé, autrement cela 
conduirait à une nouvelle connexion Internet, avec uniquement un accès à l’état 
online permanent, pour les utilisateurs qui non pas de forfait illimité, 
cela peut couter très cher.

Car pour ce script, il n’y a aucun processus qui est généré, en plus, ce 
script ne peut {\em pas} être arrêté avec la commande "exit 0". 

Remarque~: Si vous voulez examiner les scripts ip-up, ils peuvent être 
exécuté à partir d'une variable et du rc321. Si la variable 
\emph{"ip\_up\_events"} est sur \var{"yes"} le script ip-up et vérifié. 
Si la variable est sur \var{"no"} le script ip-up ne sera pas vérifié.


\subsubsection{Les variables}

Exécution d'un concept spécifique, voici les différentes variables disponibles, 
qui fonctionne avec les scripts ip-up/ip-down. Les variables sont les suivantes~:

\begin{center}
\begin{tabular}[h!]{lp{10cm}}
    \$real\_interface    & L'interface actuelle, par ex. ppp0, ippp0, ...\\
    \$interface          & Interface-IMOND, avec pppoe, ippp0, ...\\
    \$tty                & Terminal de connexion... peut-être vide!\\
    \$speed              & Vitesse de connexion, par ex. avec ISDN 64000\\
    \$local              & Adresse-IP spécifique\\
    \$remote             & Adresse-IP du Point-to-Point-Partners\\
    \$is\_default\_route & Indique si ip-up/down actuelle est paramétré 
                        pour une interface via une route par défaut 
                        (peut est "oui" ou "no")\\
\end{tabular}
\end{center}


\subsubsection{Route par défaut}

Depuis la version 2.1.0, les Scripts-ip-up/down démarrent, non seulement avec 
une interface défaut-route, mais aussi avec tous les liaisons qu’utilisent 
les scripts ip-up/down. Pour simuler des comportements plus ancien, vous devez 
insérer dans les Scripts ip-up/down cette requête~:

\begin{example}
\begin{verbatim}
        # is a default-route-interface going up?
        if [ "$is_default_route" = "yes" ]
        then
        ...        # action particulière
        fi 
\end{verbatim}
\end{example}

Naturellement, les nouveaux comportements doivent être utilisés, 
pour des actions spéciales.


\section{Paquetage Template}

Pour illustrer quelques-uns des objectifs décrits ci-dessus, vous avez un 
paquetage avec des modèles pour la distribution fli4l. Dans ce paquetage vous avez 
une série de petits exemples, tels que~: 

\begin{itemize}
\item Voir un fichier config dans (config/template.txt)
\item Un fichier de contrôle qui est écrit dans (check/template.txt)
\item L’extension des fonctions de contrôle dans (check/template.ext)
\item Variables de configuration peuvent être stockés pour une utilisation 
  ultérieure dans\\ (opt/etc/rc.d/rc999.template)
\item stockage des variables de configuration pour être lu à nouveau dans\\ 
  (opt/files/usr/bin/template\_show\_config)
\end{itemize}


\section{Construire la disquette de Boot}

Depuis de la version 1.5 fli4l utilisé le programme syslinux pour booter 
sur la disquette. Cela a l'avantage d'avoir à disposition un système de 
fichiers DOS sur la disquette.

La disquette de boot contient les fichiers suivants~:

\begin{center}
\begin{tabular}[h!]{lp{10cm}}
ldlinux.sys           & Bootloader syslinux \\
syslinux.cfg          & Fichier de configuration pour syslinux \\
kernel                & Linux-Kernel\\
rootfs.img            & Root-Filesystem\\
opt.img               & Fichier Optionnel~: drivers et Opt-Paquetage\\
rc.cfg                & fichier de configuration des variables utilisées dans 
le fichier du répertoire config\\
\end{tabular}
\end{center} 

Au démarrage du script Mkfli4l.sh (ou mkfli4l.bat pour DOS) les fichiers 
opt.img, syslinux.cfg, rc.cfg, ainsi que rootfs.img sont d'abord exécutés. 
La liste des fichiers nécessaires pour le programme mkfli4l se trouve (
dans le sous-répertoire unix ou windows). L’archive Bz2 (compressé avec Bzip2 
archive-Tar) est requis pour la décompression du noyau et les modules-opt. 
Auparavant, le fichier rc.cfg, était également dans opt-archive, c’est depuis 
la version-fli4l 2.0, que celui-ci a été placé et mis directement sur la disquette.

Ensuite, l’ensemble des fichiers, fichier-Kernel, rootfs.img, opt.tar.bz2 
(opt.img) et rc.cfg, sont copiés sur la disquette avec syslinux.

Au boot de fli4l, le script /etc/rc du rc.cfg est analysé et extrait l'image-Tar 
compressée dans un disque virtuel ou sur une partition déjà existante, ensuite 
/opt est monté. Maintenant les fichiers opt/etc/* sont copier dans le rootfs, 
des liens symboliques pour les fichiers et les répertoires opt/* sont créés 
dans le rootfs. Pour terminer, les scripts dans le répertoire /etc/rc.d sont 
exécutés dans l'ordre alphanumérique, ensuite les pilotes sont chargés et 
les services démarrent.


% \section{Dateien im root-Filesystem}
%
% Das Shell-Script "mount-rootfs.sh" im src-Verzeichnis erstellt zunächst
% eine root-Filesystem-Image-Datei namens rootfs.img, falls diese noch
% nicht existiert. Anschließend wird diese Image-Datei über das loop-Device
% (nicht zu verwechseln mit dem loopback-Device) gemounted.
% Aufruf mit ``sh mount-rootfs.sh''
% Das Script legt im aktuellen Verzeichnis ein Directory "rootfs/" an
% und mountet darin das minix-Filesystem.
%
% Wichtig: Der Kernel muß das Loop-Device und das minix-Filesystem unterstützen,
% damit der Mount funktioniert!
%
% Die im rootfs sichtbaren Dateien und Verzeichnisse sind in Tabelle
% \ref{tab:rootfs} dargestellt. Die mit (BB) gekennzeichneten Dateien
% sind Hard-Links auf das Programm usr/local/bin/busybox.
%
% Das root-Filesystem kann mit dem Befehl ``sh umount-rootfs''
% wieder abgemeldet werden.
%
% Möchte man jedoch ein neues komprimiertes root-Filesystem-Image
% ../img/rootfs.bz2 erzeugen, sollte man stattdessen das Kommando
% ``sh compact-rootfs.sh'' verwenden. Dann werden die vorhandenen Dateien
% im minix-Image in ein neues Image umkopiert. Anschließend wird das neue
% Image wieder in "rootfs.img" umbenannt.
%
% Das hat folgenden Grund:
% Durch Änderungen in den Dateien bleiben Rest-Daten im Filesystem-Image
% liegen, die nicht gelöscht, aber nicht mehr verwendet werden. Diese
% erschweren die Komprimierung beim Erstellen der Boot-Diskette. Dabei
% kann es dann passieren, dass das komprimierte Filesystem-Image dann
% nicht mehr auf die Floppy passt!
%
% Nach dem Umkopieren wird das root-Filesystem-Image komprimiert als
% ../img/rootfs.bz2 abgespeichert.
%
%
% \begin{small}
%   \begin{center}
%
%     \begin{longtable}{||l|p{10cm}||}
%       \hline \hline
%       Datei/Verzeichnis & Verwendung \\
%       \hline .profile                    &profile-Datei für ash \\
%       bin/cat                     &Anzeigen von Dateien (BB) \\
%       bin/chgrp                   &Setzen von Gruppenzugehörigkeit von
%       Dateien (BB) \\
%       bin/chmod                   &Setzen von Berechtigungen von Dateien
%       (BB) \\
%       bin/chown                   &Setzen des Eigentümers von Dateien (BB) \\
%       bin/cp                      &Kopieren von Dateien (BB) \\
%       bin/date                    &Datum ausgeben/setzen (BB) \\
%       bin/dd                      &Dateien kopieren/konvertieren (BB) \\
%       bin/df                      &Freien Plattenplatz ausgeben (BB) \\
%       bin/dir                     &Verzeichnis in Kurzform ausgeben \\
%       bin/false                   &Liefert exit-Wert 1 \\
%       bin/hostname                &Setzen/Abfragen von hostname (BB) \\
%       bin/kill                    &Prozess beenden / Signal schicken (BB) \\
%       bin/ln                      &Datei linken (BB) \\
%       bin/ls                      &Dateiverzeichnis ausgeben (BB) \\
%       bin/mkdir                   &Dateiverzeichnis anlegen (BB) \\
%       bin/mount                   &Mount-Programm (BB) \\
%       bin/mv                      &Dateien umbenennen/verschieben (BB) \\
%       bin/ping                    &Ping pong (BB) \\
%       bin/ps                      &Prozesstabelle anzeigen (BB) \\
%       bin/rm                      &Dateien löschen (BB) \\
%       bin/sh                      &Shell, gelinkt auf /usr/bin/ash \\
%       bin/sleep                   &x Sekunden warten (BB) \\
%       bin/sync                    &Synchronisieren des
%       Linux-Filesystem-Caches (BB) \\
%       bin/tar                     &tar (BB) \\
%       bin/true                    &Liefert exit-Wert 0 \\
%       bin/umount                  &Umount-Programm (BB) \\
%       dev/...                     &Device-Nodes \\
%       etc/fstab                   &Filesysteme zum Mounten \\
%       etc/group                   &Group-Datei \\
%       etc/host.conf               &Bestimmt Verfahren für
%       Hostnamen-Auflösung \\
%       etc/inittab                 &für den init-Prozess \\
%       etc/mklinks.sh              &erstellt die Softlinks nach /opt \\
%       etc/mtab                    &Leere Datei für Mount-Tabelle \\
%       etc/passwd                  &Password-Datei \\
%       etc/protocols               &protocols-Datei \\
%       etc/rc                      &Boot-Script \\
%       etc/rc0                     &Shutdown-Script \\
%       etc/services                &Services-Tabelle \\
%       etc/shadow                  &Shadow-Datei \\
%       etc/shells                  &Mögliche Shells \\
%       sbin/halt                   &Halt Linux~:-) \\
%       sbin/modprobe               &Programm zum Laden von Kernel-Modulen \\
%       sbin/insmod                 &Programm zum Laden von Kernel-Modulen \\
%       sbin/lsmod                  &listet die geladenen Module auf \\
%       sbin/reboot                 &Reboot Linux (BB)  \\
%       sbin/rmmod                  &Löschen von Kernelmodulen (BB) \\
%       sbin/init                   &Busybox-init (BB) \\
%       sbin/poweroff               &??? (BB) \\
%       sbin/mkfs.minix             &zum formatieren der opt-Ramdisk (BB) \\
%       usr/bin/ash                 &Shell, bash ist viel zu groß für Floppy! \\
%       usr/bin/basename            &Basisnamen eines Dateinamens anzeigen
%       (BB) \\
%       usr/bin/cut                 &Link auf Busysbox-cut (BB) \\
%       usr/bin/dirname             &Verzeichnis eines Dateinamens anzeigen
%       (BB) \\
%       usr/bin/expr                &Mini-Rechenprogramm, zum Inkrementieren
%       (BB) \\
%       usr/bin/grep                &Link auf Busybox-grep (BB) \\
%       usr/bin/gunzip              &GNU unzip-Programm (BB) \\
%       usr/bin/killall             &Link auf Busybox-killall (BB) \\
%       usr/bin/nslookup            &Abfragen von DNS-Servern (BB) \\
%       usr/bin/sed                 &stream editor sed  \\
%       usr/bin/tr                  &Link auf Busybox-tr (BB) \\
%       usr/lib/terminfo/l/linux    &Linux-Konsole: terminfo-Datei \\
%       usr/i386-linux-uclibc/*     &Shared Libs, gegen die die Binaries
%       gelinkt wurden \\
%       usr/local/bin/busybox       &Busybox, s.a. http://busybox.lineo.org \\
%       usr/local/bin/clrhome       &Script: löscht Bildschirm, setzt Cursor
%       oben links \\
%       usr/local/bin/colecho       &echo mit Farbe~:-) \\
%       usr/local/bin/dtou          &DOS to Unix: CRs aus DOS Dateien
%       eliminieren \\
%       usr/bin/zcat                &zum Entpacken gzip-komrimierter Dateien
%       (BB) \\
%       boot/               &Mountpoint für die Bootdiskette \\
%       etc/ppp/ &   \\
%       etc/rc.d/  &   \\
%       etc/rc0.d/  &   \\
%       lib/modules/        &für die Kernel-Module \\
%       mnt/                &Verzeichnis für temporären Mount \\
%       proc/               &Verzeichnis für Prozesstabellen \\
%       opt/                &Mountpoint für das entpackte opt.img \\
%       tmp/                &Verzeichnis für temporäre Dateien \\
%       usr/lib/isdn/       &Verzeichnis für ISDN-Dateien, z.B. für AVM B1 \\
%       usr/local/ens/  &   \\
%       usr/sbin/ &   \\
%       var/adm/            &Verzeichnis für tmp-Dateien (Administration) \\
%       var/lock/           &Verzeichnis für Lockfiles zur Prozessverriegelung
%       \\
%       var/log/ &   \\
%       var/run/ &   \\
%       var/spool/          &Drucker-Spool-Verz. und Mount-Point f. Ramdisk \\
%       var/tmp/            &Verzeichnis für tmp-Dateien (Administration) \\
%       dev/inet &   \\
%       \hline \hline
%   \caption{Inhalt des rootfs}
%   \label{tab:rootfs}
% \end{longtable}
%   \end{center}
% \end{small}
%
%
%
\section{Fichiers de configurations}

Voici les dossiers présélectionnés par le routeur-fli4l on-the-fly, qui génére 
au moment du boot.

\begin{enumerate}
\item Configuration du fournisseur
  \begin{itemize}
  \item         etc/ppp/pap-secrets

  \item         etc/ppp/chap-secrets
  \end{itemize}

\item Configuration du DNS
  \begin{itemize}
  \item         etc/resolv.conf

  \item         etc/dnsmasq.conf

  \item         etc/dnsmasq\_dhcp.conf

  \item         etc/resolv.dnsmasq
  \end{itemize}

\item Fichier hôte
  \begin{itemize}
  \item         etc/hosts
  \end{itemize}

\item Configuration-imond
  \begin{itemize}
  \item         etc/imond.conf
  \end{itemize}
\end{enumerate}


\subsection{Configuration du fournisseur}

Pour sélectionné le fournisseur d'accés le réglage du User-ID et du Password 
se fait dans le fichier etc/ppp/pap-secrets avec User-ID et Password.

Exemple pour le fournisseur Planet-Interkom~:

\begin{verbatim}
# Secrets pour l'authentification en utilisant PAP
# client        server  secret                  IP addresses
"anonymer"      *       "surfer"                *
\end{verbatim}

Dans cette exemple, USER-ID est "anonymer". l'accés au serveur-distant sera 
permis à tous (avec "*"). "surfer" est le mot de passe pour le fournisseur 
Planet-Interkom.


\subsection{Configuration DNS}

Vous pouvez utiliser le routeur-fli4l comme un serveur-DNS. 
Pourquoi c'est utile - C'est nécessaire pour les ordinateurs-Windows 
dans un LAN, cela a déjà été expliqué dans .. /doc.

Le fichier-résolveur etc/resolv.conf contient les noms de domaine et 
les utilisateurs du serveur de nom. vous pouvez voir ci-dessous le contenu 
(du domain.de, il a seulement un endroit réservé pour indiquer la valeur de 
la variable de configuration \var{DOMAIN\_\-NAME})~:

\begin{verbatim}
        search domain.de
        nameserver 127.0.0.1
\end{verbatim}

Le serveur de noms dnsmasq est configuré en utilisant le fichier etc/dnsmasq.conf.
Il boot à partir du script rc001.base et du rc370.dnsmasq qui sont généré 
automatiquement cela pourrait ressembler à ceci~:

\begin{example}
\begin{verbatim}
user=dns
group=dns
resolv-file=/etc/resolv.dnsmasq
no-poll
no-negcache
bogus-priv
log-queries
domain-suffix=lan.fli4l
local=/lan.fli4l/
domain-needed
expand-hosts
filterwin2k
conf-file=/etc/dnsmasq_dhcp.conf
\end{verbatim}
\end{example}


\subsection{Fichier-Hôte}

    Il doit être familier à toutes personnes~:-)
    En outre, il est inutile si un serveur-DNS local est installé.


\subsection{Configuration-imond}

Les variables de configurations dans le fichier etc/imond.conf, doivent entre 
autre être activées \var{CIRC\_x\_NAME}, \var{CIRC\_x\_ROUTE}, \var{CIRC\_x\_CHARGEINT} 
et \var{CIRC\_x\_TIMES}. Il peut être constituée d'un maximum de 32 lignes 
(à l'exclusion des lignes de commentaires). Chaque ligne est composée de 8 colonnes~:

\begin{enumerate}
\item  Plage journalière
\item  Plage horraire
\item  Dispositif (ipppX ou isdnX)
\item  Circuit pour Default-Route: yes/no
\item  Numéro de Téléphone
\item  Nom du Circuit
\item  Prix de l'unité Téléphonique par Minute en EU
\item  Compteur (interval d'unité-Tél) en seconde
\end{enumerate}

    Voici un exemple~:

\begin{verbatim}
#day  hour  device  defroute  phone        name        charge  ch-int
Mo-Fr 18-09 ippp0   yes       010280192306 Addcom      0.0248  60
Sa-Su 00-24 ippp0   yes       010280192306 Addcom      0.0248  60
Mo-Fr 09-18 ippp1   yes       019160       Compuserve  0.019   180
Mo-Fr 09-18 isdn2   no        0221xxxxxxx  Firma       0.08    90
Mo-Fr 18-09 isdn2   no        0221xxxxxxx  Firma       0.03    90
Sa-Su 00-24 isdn2   no        0221xxxxxxx  Firma       0.03    90
\end{verbatim}

    Des explications complémentaires pour le routage au moindre coût peuvent 
    être trouvés dans .. /doc.
