debconf - en to fr translation catalogue (519 entries)

note: type: SH
en: NAME
fr: NOM

note: type: textblock
en: debconf - run a debconf-using program
fr: debconf - Exécuter un programme utilisant debconf

note: type: verbatim
en:  debconf [options] command [args]
fr:  debconf [options] commande [args]

note: type: textblock
en: Debconf is a configuration system for Debian packages. For a debconf overview and documentation for sysadmins, see L<debconf(7)> (in the debconf-doc package).
fr: Debconf est un système de configuration pour les paquets Debian. Pour faire un tour d'horizon de debconf et pour obtenir de la documentation pour les administrateurs système, veuillez consulter L<debconf(7)>.

note: type: textblock
en: The B<debconf> program runs a program under debconf's control, setting it up to talk with debconf on stdio. The program's output is expected to be debconf protocol commands, and it is expected to read result codes on stdin. See L<debconf-devel(7)> for details about the debconf protocol.
fr: Le programme B<debconf> exécute un programme sous contrôle de debconf, en le configurant pour communiquer avec debconf sur l'entrée et la sortie standard. La sortie du programme sera l'une des commandes du protocole debconf, et les codes résultants seront lus sur l'entrée standard. Pour plus de détails sur le protocole de debconf, veuillez consulter L<debconf-devel(7)>.

note: type: textblock
en: The command to be run under debconf must be specified in a way that will let your PATH find it.
fr: La commande à exécuter depuis debconf doit être spécifiée de manière à ce qu'elle soit trouvée dans votre PATH.

note: type: textblock
en: This command is not the usual way that debconf is used. It's more typical for debconf to be used via L<dpkg-preconfigure(8)> or L<dpkg-reconfigure(8)>.
fr: Cette commande ne reflète pas l'utilisation habituelle de debconf. Il est courant pour debconf d'être appelé via L<dpkg-preconfigure(8)> ou L<dpkg-reconfigure(8)>.

note: type: =item
en: B<-o>I<package>, B<--owner=>I<package>
fr: B<-o>I<paquet>, B<--owner=>I<paquet>

note: type: textblock
en: Tell debconf what package the command it is running is a part of. This is necessary to get ownership of registered questions right, and to support unregister and purge commands properly.
fr: Indique à debconf à quel paquet appartient la commande exécutée. C'est nécessaire pour que les droits de propriété des questions enregistrées soient bons et pour que les commandes « purge » et « unregister » soient gérées correctement.

note: type: textblock
en: Select the frontend to use.
fr: Sélectionner l'interface à utiliser.

note: type: =item
en: B<-p>I<value>, B<--priority=>I<value>
fr: B<-p>I<valeur>, B<--priority=>I<valeur>

note: type: textblock
en: Specify the minimum priority of question that will be displayed.
fr: Spécifier la priorité minimale des questions qui vont être posées.

note: type: textblock
en: Enables terse output mode. This affects only some frontends.
fr: Activer le mode d'affichage concis. Cela n'affecte que certaines interfaces.

note: type: =head1
en: EXAMPLES
fr: EXEMPLES

note: type: textblock
en: To debug a shell script that uses debconf, you might use:
fr: Pour déboguer un script shell qui utilise debconf, vous devriez utiliser :

note: type: verbatim
en:  DEBCONF_DEBUG=developer debconf my-shell-prog
fr:  DEBCONF_DEBUG=developer debconf mon-script-shell

note: type: textblock
en: Or, you might use this:
fr: Ou ceci :

note: type: verbatim
en:  debconf --frontend=readline sh -x my-shell-prog
fr:  debconf --frontend=readline sh -x mon-script-shell

note: type: SH
en: SEE ALSO
fr: VOIR AUSSI

note: type: SH
en: AUTHOR
fr: AUTEUR

note: type: textblock
en: Debconf::Client::ConfModule - client module for ConfModules
fr: Debconf::Client::ConfModule - module client pour ConfModules

note: type: verbatim
en:  use Debconf::Client::ConfModule ':all';
     version('2.0');
     my $capb=capb('backup');
     input("medium", "foo/bar");
     my @ret=go();
     if ($ret[0] == 30) {
     	# Back button pressed.
     	...
     }
     ...
fr:  use Debconf::Client::ConfModule ':all';
     version('2.0');
     my $capb=capb('backup');
     input("medium", "toto/titi");
     my @ret=go();
     if ($ret[0] == 30) {
     	# Bouton retour arrière pressé.
     	...
     }
     ...

note: type: textblock
en: This is a module to ease writing ConfModules for Debian's configuration management system. It can communicate with a FrontEnd via the debconf protocol (which is documented in full in the debconf_specification in Debian policy).
fr: C'est un module pour faciliter l'écriture de ConfModules pour le gestionnaire de configuration système Debian. Il peut communiquer avec une interface via le protocole debconf (qui est entièrement documenté dans le fichier «E<nbsp>debconf_specificationE<nbsp>» du paquet «E<nbsp>debian-policyE<nbsp>»).

note: type: textblock
en: The design is that each command in the protocol is represented by one function in this module (with the name lower-cased).  Call the function and pass in any parameters you want to follow the command. If the function is called in scalar context, it will return any textual return code. If it is called in list context, an array consisting of the numeric return code and the textual return code will be returned.
fr: L'idée est que chaque commande du protocole est représentée par une fonction dans ce module (le nom étant en minuscule). Appelez la fonction avec les paramètres que vous voulez passer à la commande. Si la fonction est appelée dans un contexte scalaire, elle retournera un code textuel. Si elle est appelée dans un contexte de liste, un tableau composé des codes de retour numérique et textuel sera retourné.

note: type: textblock
en: This module uses Exporter to export all functions it defines. To import everything, simply import ":all".
fr: Ce module utilise Exporter pour exporter toutes les fonctions qu'il définit. Pour tout importer, importer simplement «E<nbsp>:allE<nbsp>».

note: type: textblock
en: Ensure that a FrontEnd is running.  It's a little hackish. If DEBIAN_HAS_FRONTEND is set, a FrontEnd is assumed to be running.  If not, one is started up automatically and stdin and out are connected to it. Note that this function is always run when the module is loaded in the usual way.
fr: S'assure qu'une interface est lancée. C'est un peu une méthode de hackers. Si DEBIAN_HAS_FRONTEND est positionnée, une interface est supposée être lancée. Sinon, une interface est automatiquement lancée et les entrée et sortie standard sont connectées à celle-ci. Remarquez que cette fonction est toujours lancée quand le module est chargé de manière habituelle.

note: type: textblock
en: The frontend doesn't send a return code here, so we cannot try to read it or we'll block.
fr: L'interface n'envoie pas ici de code de retour, nous n'essaierons donc pas de le lire, car nous serions bloqués.

note: type: =item
en: AUTOLOAD
fr: CHARGEMENT AUTOMATIQUE

note: type: textblock
en: Creates handler functions for commands on the fly.
fr: Créer des fonctions de gestion pour des commandes à la volée.

note: type: textblock
en: The debconf specification (/usr/share/doc/debian-policy/debconf_specification.txt.gz).
fr: Le fichier de spécification de debconf (/usr/share/doc/debian-policy/debconf_specification.html.gz).

note: type: textblock
en: debconf-apt-progress - install packages using debconf to display a progress bar
fr: debconf-apt-progress - installer des paquets utilisant debconf en affichant une barre d'avancement

note: type: verbatim
en:  debconf-apt-progress [--] command [args ...]
     debconf-apt-progress --config
     debconf-apt-progress --start
     debconf-apt-progress --from waypoint --to waypoint [--] command [args ...]
     debconf-apt-progress --stop
fr:  debconf-apt-progress [--] commande [paramètres ...]
     debconf-apt-progress --config
     debconf-apt-progress --start
     debconf-apt-progress --from graduation --to graduation [--] commande [paramètres ...]
     debconf-apt-progress --stop

note: type: textblock
en: B<debconf-apt-progress> installs packages using debconf to display a progress bar. The given I<command> should be any command-line apt frontend; specifically, it must send progress information to the file descriptor selected by the C<APT::Status-Fd> configuration option, and must keep the file descriptors nominated by the C<APT::Keep-Fds> configuration option open when invoking debconf (directly or indirectly), as those file descriptors will be used for the debconf passthrough protocol.
fr: B<debconf-apt-progress> installer des paquets utilisant debconf en affichant une barre d'avancement. La I<commande> passée en paramètre devrait être une ligne de commande quelconque d'un frontal APT ; plus précisément, ce frontal doit envoyer des informations d'avancement au descripteur de fichier choisi par l'option de configuration C<APT::Status-Fd> et il doit conserver ouverts les descripteurs de fichier renseignés via l'option de configuration C<APT::Keep-Fds> lorsqu'il invoque debconf (directement ou non), puisque ces descripteurs de fichier vont être utilisés par le protocole de communication debconf.

note: type: textblock
en: The arguments to the command you supply should generally include B<-y> (for B<apt-get> or B<aptitude>) or similar to avoid the apt frontend prompting for input. B<debconf-apt-progress> cannot do this itself because the appropriate argument may differ between apt frontends.
fr: Les paramètres de la commande que vous passez doivent en général inclure B<-y> (pour B<apt-get> et B<aptitude>) ou quelque chose de similaire afin d'éviter que le frontal pour APT ne pose des questions à l'utilisateur. B<debconf-apt-progress> ne peut pas le faire lui-même puisque le paramètre adéquat peut varier en fonction des frontaux APT.

note: type: textblock
en: The B<--start>, B<--stop>, B<--from>, and B<--to> options may be used to create a progress bar with multiple segments for different stages of installation, provided that the caller is a debconf confmodule. The caller may also interact with the progress bar itself using the debconf protocol if it so desires.
fr: Les options B<--start>, B<--stop>, B<--from> et B <--to> peuvent être utilisées pour créer une barre d'avancement comportant de multiples segments correspondant à différentes étapes de l'installation, pourvu que l'appelant soit un module de configuration debconf. L'appelant peut aussi interagir avec la barre d'avancement en utilisant le protocole debconf.

note: type: textblock
en: debconf locks its config database when it starts up, which makes it unfortunately inconvenient to have one instance of debconf displaying the progress bar and another passing through questions from packages being installed. If you're using a multiple-segment progress bar, you'll need to eval the output of the B<--config> option before starting the debconf frontend to work around this. See L<the EXAMPLES section/EXAMPLES> below.
fr: debconf verrouille sa base de données de configuration lorsqu'il démarre, ce qui empêche malheureusement d'avoir une instance de debconf affichant la barre d'avancement et une autre traitant les questions des paquets en cours d'installation. Si vous utilisez une barre d'avancement comportant plusieurs segments, vous allez avoir besoin d'évaluer la sortie de l'option B<--config> avant de lancer le frontal debconf, afin de contourner cette limitation. Veuillez consulter L<la section EXEMPLES/EXEMPLES> ci-dessous.

note: type: textblock
en: Print environment variables necessary to start up a progress bar frontend.
fr: Affiche les variables d'environnement nécessaires pour lancer un frontal de suivi de l'avancement.

note: type: textblock
en: Start up a progress bar, running from 0 to 100 by default. Use B<--from> and B<--to> to use other endpoints.
fr: Démarre une barre d'avancement, allant de 0 à 100 par défaut. Utilisez les options <--from> et <--to> pour indiquer des limites différentes.

note: type: =item
en: B<--from> I<waypoint>
fr: B<--from> I<graduation>

note: type: textblock
en: If used with B<--start>, make the progress bar begin at I<waypoint> rather than 0.
fr: Si utilisée avec B<--start>, commence la barre d'avancement à I<graduation> plutôt qu'à 0.

note: type: textblock
en: Otherwise, install packages with their progress bar beginning at this "waypoint". Must be used with B<--to>.
fr: Sinon, installe les paquets avec une barre d'avancement commençant à cette graduation. Doit être utilisée avec B<--to>.

note: type: =item
en: B<--to> I<waypoint>
fr: B<--to> I<graduation>

note: type: textblock
en: If used with B<--start>, make the progress bar end at I<waypoint> rather than 100.
fr: Si utilisée avec B<--start>, termine une barre de progression à I<graduation> plutôt qu'à 100.

note: type: textblock
en: Otherwise, install packages with their progress bar ending at this "waypoint". Must be used with B<--from>.
fr: Sinon, installe les paquets avec une barre de progression se terminant à cette graduation. Doit être utilisée avec B<--from>.

note: type: textblock
en: Stop a running progress bar.
fr: Arrêter une barre d'avancement en cours.

note: type: textblock
en: Avoid starting, stopping, or stepping the progress bar. Progress messages from apt, media change events, and debconf questions will still be passed through to debconf.
fr: Ne pas démarrer, arrêter, ou passer en pas à pas la barre de progression. Les messages de progression d'apt, les événements des média amovibles et les questionnaires debconf seront transférés à debconf.

note: type: =item
en: B<--dlwaypoint> I<percentage>
fr: B<--dlwaypoint> I<pourcentage>

note: type: textblock
en: Specify what percent of the progress bar to use for downloading packages.  The remainder will be used for installing packages. The default is to use 15% for downloading and the remaining 85% for installing.
fr: Spécifier le pourcentage de la barre de progression à utiliser pour le téléchargement des paquets. Le reste sera utilisé pour la phase d'installation des paquets. Par défaut, 15 % de la barre de progression est utilisé pour le téléchargement, les 85 % restant pour l'installation.

note: type: =item
en: B<--logfile> I<file>
fr: B<--logfile> I<fichier>

note: type: textblock
en: Send the normal output from apt to the given file.
fr: Envoyer la sortie normale d'APT dans le I<fichier>.

note: type: textblock
en: Send the normal output from apt to stderr. If you supply neither B<--logfile> nor B<--logstderr>, the normal output from apt will be discarded.
fr: Envoyer la sortie normale d'APT vers la sortie standard d'erreur (« stderr »). Si vous ne passez ni l'option B<--logfile> ni l'option B<--logstderr>, la sortie normale d'APT sera désactivée.

note: type: textblock
en: Terminate options. Since you will normally need to give at least the B<-y> argument to the command being run, you will usually need to use B<--> to prevent that being interpreted as an option to B<debconf-apt-progress> itself.
fr: Terminer les options. Comme vous allez normalement avoir besoin de passer l'option B<-y> à la commande à lancer, vous devrez certainement utiliser B<--> pour l'empêcher d'être interprétée comme une option de B<debconf-apt-progress> lui-même.

note: type: textblock
en: Install the GNOME desktop and an X window system development environment within a progress bar:
fr: Installer l'environnement GNOME et l'environnement de développement X-Window avec une barre d'avancement.

note: type: textblock
en: Install the GNOME, KDE, and XFCE desktops within a single progress bar, allocating 45% of the progress bar for each of GNOME and KDE and the remaining 10% for XFCE:
fr: Installer les environnements GNOME, KDE et XFCE avec une seule barre d'avancement, en allouant 45 % de celle-ci à GNOME, autant à KDE, et les 10 % restants à XFCE :

note: type: =head1
en: RETURN CODE
fr: CODE RENVOYÉ

note: type: textblock
en: The exit code of the specified command is returned, unless the user hit the cancel button on the progress bar. If the cancel button was hit, a value of 30 is returned. To avoid ambiguity, if the command returned 30, a value of 3 will be returned.
fr: Le code de retour de la commande spécifiée est renvoyé à moins que l'utilisateur presse le bouton Annuler de la barre de progression. Si le bouton Annuler est pressé, la valeur 30 est renvoyée. Pour éviter toute ambiguïté, si la commande renvoie 30, la valeur 3 sera renvoyée.

note: type: =head1
en: AUTHORS
fr: AUTEURS

note: type: textblock
en: debconf-escape - helper when working with debconf's escape capability
fr: debconf-escape - assistant pour la fonctionnalité d'échappement de debconf

note: type: verbatim
en:  debconf-escape -e < unescaped-text
     debconf-escape -u < escaped-text
fr:  debconf-escape -e < texte-non-échappé
     debconf-escape -u < texte-échappé

note: type: textblock
en: When debconf has the 'escape' capability set, it will expect commands you send it to have backslashes and newlines escaped (as C<\\> and C<\n> respectively) and will in turn escape backslashes and newlines in its replies. This can be used, for example, to substitute multi-line strings into templates, or to get multi-line extended descriptions reliably using C<METAGET>.
fr: Si « escape » n'est pas trouvé dans vos fonctionnalités, debconf va attendre que les commandes que vous lui passez comportent des antislashes et des caractères de retour à la ligne échappés (comme C<\\> et C<\n> respectivement) et va faire de même pour ses réponses. Ceci peut être utilisé par exemple pour changer des chaînes multilignes en modèles, ou pour récupérer des descriptions étendues multilignes de manière fiable en utilisant C<METAGET>.

note: type: textblock
en: L<debconf-devel(7)> (available in the debconf-doc package)
fr: L<debconf-devel(7)> (disponible dans le paquet debconf-doc)

note: type: textblock
en: debconf-communicate - communicate with debconf
fr: debconf-communicate - communiquer avec debconf

note: type: verbatim
en:  echo commands | debconf-communicate [options] [package]
fr:  echo commandes | debconf-communicate [options] [paquet]

note: type: textblock
en: B<debconf-communicate> allows you to communicate with debconf on the fly, from the command line. The package argument is the name of the package which you are pretending to be as you communicate with debconf, and it may be omitted if you are lazy. It reads commands in the form used by the debconf protocol from stdin. For documentation on the available commands and their usage, see the debconf specification.
fr: B<debconf-communicate> permet de communiquer à la volée avec debconf depuis la ligne de commande. Le paramètre paquet est le nom du paquet que vous voulez faire communiquer avec debconf, il peut être omis si vous êtes paresseux. Ce programme lit depuis l'entrée standard des commandes utilisées par le protocole de debconf. Pour la documentation sur les commandes disponibles ainsi que leur usage, veuillez consulter les spécifications de debconf.

note: type: textblock
en: The commands are executed in sequence. The textual return code of each is printed out to standard output.
fr: Les commandes sont exécutées dans l'ordre. Le code de retour de chaque commande est affiché sur la sortie standard.

note: type: textblock
en: The return value of this program is the numeric return code of the last executed command.
fr: La valeur de retour de ce programme est le code de retour de la dernière commande exécutée.

note: type: SH
en: EXAMPLE
fr: EXEMPLE

note: type: textblock
en: Print out the value of the debconf/frontend question.
fr: Afficher l'importance de la question de l'interface/debconf.

note: type: =head1
en: WARNING
fr: ATTENTION

note: type: textblock
en: This program should never be used from a maintainer script of a package that uses debconf! It may however, be useful in debugging.
fr: Ce programme ne devrait pas être utilisé par les scripts de maintenance d'un paquet qui utilise debconf ! Il peut, cependant, être utile pour le débogage.

note: type: textblock
en: debconf-copydb - copy a debconf database
fr: debconf-copydb - copier une base de données debconf

note: type: verbatim
en:  debconf-copydb sourcedb destdb [--pattern=pattern] [--owner-pattern=pattern] [--config=Foo:bar]
fr:  debconf-copydb sourcedb destdb [--pattern=pattern] [--owner-pattern=patern] [--config=Toto:titi]

note: type: textblock
en: B<debconf-copydb> copies items from an existing debconf database into another, possibly new database. The two databases may have different formats; if so a conversion will automatically be done.
fr: B<debconf-copydb> copie des éléments d'une base de données debconf existante dans une autre base, ou dans une nouvelle. Les deux bases de données peuvent être de différents formats ; si c'est le cas, une conversion sera automatiquement effectuée.

note: type: textblock
en: The name of the source database. Typically it will be defined in your debconf.conf (or .debconfrc) file.
fr: Nom de la base de données source. Elle sera définie dans votre fichier debconf.conf (ou .debconfrc).

note: type: textblock
en: The name of the destination database. It may be defined in debconf.conf or .debconfrc, or you might define it on the command line (see below).
fr: Nom de la base de données de destination. Elle peut être définie dans debconf.conf ou .debconfrc, ou vous pouvez la définir sur la ligne de commande (voir ci-dessous).

note: type: textblock
en: If this is specified, only items in I<sourcedb> whose names match the pattern will be copied.
fr: Si ceci est spécifié, seuls les éléments dont les noms correspondent au motif dans I<sourcedb> seront copiés.

note: type: textblock
en: If this is specified, only items in I<sourcedb> whose owners match the pattern will be copied.
fr: Si ceci est spécifié, seuls les éléments dont les propriétaires correspondent au motif dans I<sourcedb> seront copiés.

note: type: =item
en: B<-c> I<foo:bar>, B<--config> I<Foo:bar>
fr: B<-c> I<toto:titi>, B<--config> I<Toto:titi>

note: type: textblock
en: Set option Foo to bar. This is similar to writing:
fr: Définir l'option Toto à la valeur titi. Cela équivaut à écrire :

note: type: verbatim
en:   Foo: bar
fr:   Toto: titi

note: type: textblock
en: In debconf.conf, except you probably want to leave off the space on the command line (or quote it: "Foo: bar"). Generally must be used multiple times, to build up a full configuration stanza. While blank lines are used to separate stanzas in debconf.conf, this program will assume that "Name:dbname" denotes the beginning of a new stanza.
fr: dans debconf.conf, excepté que vous voulez probablement omettre l'espace sur la ligne de commande (ou mettre une double apostrophe : "Toto: titi"). Cela doit être généralement utilisé plusieurs fois, pour développer un paragraphe entier de configuration. Puisque les lignes blanches sont utilisées pour séparer les paragraphes dans debconf.conf, ce programme supposera que « Name:dbname >» dénote le début d'un nouveau paragraphe.

note: type: textblock
en: Copy all of configdb to backup, assuming you already have the backup database defined in debconf.conf.
fr: Copier tout le contenu de configdb vers backup, en supposant que vous avez déjà défini la base de données de secours dans votre fichier debconf.conf.

note: type: textblock
en: Copy slrn's data out of configdb, and into newdb. newdb is not defined in the rc file, so the --config switches set up the database on the fly.
fr: Copier les données de slrn en dehors de configdb vers newdb. newdb n'est pas défini dans le fichier rc, donc le commutateur --config crée la base de données à la volée.

note: type: verbatim
en:   debconf-copydb configdb stdout -c Name:stdout -c Driver:Pipe \
      	-c InFd:none --pattern='^foo/'
fr:   debconf-copydb configdb stdout -c Name:stdout -c Driver:Pipe \
      	-c InFd:none --pattern='^toto/'

note: type: textblock
en: Spit out all the items in the debconf database related to package foo.
fr: Envoyer tous les éléments dans la base de données debconf relatifs au paquet toto.

note: type: textblock
en: This uses the special purpose pipe driver to copy a database to a remote system.
fr: Utiliser un tube spécial pour copier une base de données vers un système distant.

note: type: textblock
en: debconf-getlang - extract a language from a templates file
fr: debconf-getlang - extraire une langue depuis un questionnaire

note: type: verbatim
en:  debconf-getlang lang master [translation]
     debconf-getlang --stats master translation [...]
fr:  debconf-getlang lang master [traduction]
     debconf-getlang --stats master traduction [...]

note: type: textblock
en: Note: This utility is deprecated; you should switch to using the po-debconf package.
fr: Note : cet utilitaire est mis de côté, vous devriez vous tourner vers l'utilisation du paquet po-debconf.

note: type: textblock
en: This program helps make and manage translations of debconf templates.  There are basically three situations in which this program might be called:
fr: Ce programme aide à effectuer et à gérer les traductions des questions-modèles de debconf. À la base, il y a trois situations où ce programme peut être appelé :

note: type: =item
en: A translation is just being started.
fr: Une traduction a juste commencé.

note: type: textblock
en: You want to provide the translator with a file they can work on that has the English fields from your templates file, plus blank Field-ll fields for the target language that they can fill in.
fr: Vous voulez fournir au traducteur un fichier sur lequel il peut travailler et qui contienne les champs en anglais de votre questionnaire et des champs vierges « Field-ll » pour la langue cible qu'il pourra remplir.

note: type: textblock
en: To do this, run the program with first parameter being the code for the language that is being translated to, and the second parameter being the filename of the English templates file.
fr: Pour faire ceci, exécutez le programme avec comme premier paramètre le code de la langue de la traduction et comme second paramètre le nom du questionnaire en anglais.

note: type: =item
en: A translation is well under way.
fr: Une traduction est déjà bien avancée.

note: type: textblock
en: You have changed some English text, or added more items to your templates file, and you want to send the translators a file with the English text plus their current translations (or you are the translator, and you want to generate such a file for your own use).
fr: Vous avez changé quelques textes en anglais, ou ajouté des éléments à votre questionnaire et vous voulez envoyer aux traducteurs un fichier avec le texte en anglais plus les traductions actuelles (ou vous êtes le traducteur et vous voulez générer un tel fichier pour votre propre utilisation).

note: type: textblock
en: To accomplish this, run the program with the first parameter being the the code for the language that is being translated to, the second parameter being the filename of the master English templates file, and the third parameter being the filename of the current translated file.
fr: Pour accomplir ceci, exécutez le programme avec comme premier paramètre le code de la langue de la traduction, comme deuxième paramètre le nom du principal questionnaire en anglais et comme troisième paramètre le nom du fichier traduit actuel.

note: type: textblock
en: When run this way, the program is smart enough to notice fuzzy translations. For example a fuzzy Description will be output as Description-<lang>-fuzzy, and a new, blank Description-<lang> will be added.  Translators should remove the -fuzzy fields as they correct the fuzzy translations.
fr: Quand vous le lancez de cette manière, le programme est assez malin pour remarquer les traductions approximatives. Par exemple, une traduction approximative sera sortie comme Description-<lang>-fuzzy et une nouvelle Description-<lang> vierge sera ajoutée. Les traducteurs doivent supprimer les champs -fuzzy lorsqu'ils corrigent les traductions approximatives.

note: type: =item
en: Checking the status of a translation
fr: Vérification de l'état d'une traduction.

note: type: textblock
en: To check the status of a translation, use the --status flag, and pass the english template file as the first parameter, and all the other translated templates after that. It will output statistics for each of them. For example:
fr: Pour vérifier l'état d'une traduction, utilisez le drapeau --status, et passez-lui le questionnaire en anglais comme premier paramètre et toutes les autres questions-modèles traduites après. Il affichera les statistiques pour chacun d'eux. Par exemple :

note: type: verbatim
en:   debconf-getlang --stats debian/templates debian/templates.*
fr:   debconf-getlang --stats debian/questions-modèles debian/questions-modèles.*

note: type: textblock
en: Note that the text in the generated templates may be word-wrapped by debconf.
fr: Remarquez que le texte généré dans la question-modèle peut être coupé par debconf.

note: type: textblock
en: debconf-get-selections - output contents of debconf database
fr: debconf-get-selections - afficher le contenu de la base de données de debconf

note: type: textblock
en: Output the current debconf database in a format understandable by debconf-set-selections.
fr: Afficher la base de données actuelle de debconf dans un format compréhensible par debconf-set-selections.

note: type: textblock
en: To dump the debconf database of the debian-installer, from /var/log/installer/cdebconf, use the --installer parameter.
fr: Pour sauvegarder la base de données de l'installateur Debian, depuis /var/log/installer/cdebconf, utilisez le paramètre --installer.

note: type: textblock
en: debconf-loadtemplate - load template file into debconf database
fr: debconf-loadtemplate - charger un questionnaire dans la base de données de debconf

note: type: verbatim
en:  debconf-loadtemplate owner file [file ..]
fr:  debconf-loadtemplate propriétaire fichier [fichier ..]

note: type: textblock
en: Loads one or more template files into the debconf database. The first parameter specifies the owner of the templates (typically, the owner is the name of a debian package). The remaining parameters are template files to load.
fr: Ce programme charge un ou plusieurs questionnaires dans la base de données de debconf. Le premier paramètre spécifie le propriétaire du questionnaire (généralement, le propriétaire est le nom du paquet). Les paramètres restants sont les questionnaires à charger.

note: type: textblock
en: This program should never be used from a maintainer script of a package that uses debconf! It may however, be useful in debugging, or to seed the debconf database.
fr: Ce programme ne devrait jamais être utilisé par les scripts de maintenance d'un paquet qui utilise debconf ! Il devrait, cependant, être utile pour le débogage ou pour remplir la base de données de debconf.

note: type: textblock
en: debconf-mergetemplate - merge together multiple debconf template files
fr: debconf-mergetemplate - fusionner plusieurs questionnaires debconf

note: type: textblock
en: Note: This utility is deprecated. You should switch to using po-debconf's po2debconf program.
fr: Note : Cet utilitaire est mis de côté ; vous devriez vous tourner vers l'utilisation du programme po2debconf du paquet po-debconf.

note: type: textblock
en: This program is useful if you have multiple debconf templates files which you want to merge together into one big file. All the specified files will be read in, merged, and output to standard output.
fr: Ce programme est utile si vous avez de nombreux questionnaires debconf que vous voulez fusionner dans un seul gros fichier. Tous les fichiers spécifiés seront lus, fusionnés et affichés sur la sortie standard.

note: type: textblock
en: This can be especially useful if you are dealing with translated template files. In this case, you might have your main template file, plus several other files provided by the translators. These files will have translated fields in them, and maybe the translators left in the english versions of the fields they translated, for their reference.
fr: Cela peut être très utile si vous avez affaire à des questionnaires traduits. Dans ce cas, vous devriez avoir un questionnaire principal et plusieurs fichiers fournis par les traducteurs. Ces fichiers auront des champs traduits et peut-être que les traducteurs auront laissé la version anglaise des champs qu'ils ont traduit, pour référence.

note: type: textblock
en: So, you want to merge together all the translated templates files with your main templates file. Any fields that are unique to the translated files need to be added in to the correct templates, but any fields they have in common should be superseded by the fields in the main file (which might be more up-to-date).
fr: Vous voulez donc fusionner tous les questionnaires traduits avec votre fichier principal. Chaque champ particulier à un fichier traduit doit être ajouté dans le bon questionnaire, mais les champs communs doivent être remplacés par les champs du fichier principal (qui devraient être plus à jour).

note: type: textblock
en: This program handles that case properly, just list each of the translated templates files, and then your main templates file last.
fr: Ce programme traite ce cas correctement, listez seulement chacun des questionnaires traduits et en dernier vos questionnaires principaux.

note: type: textblock
en: Merge in even outdated translations. The default is to drop them with a warning message.
fr: Fusionner même les traductions obsolètes. L'action par défaut est de les laisser tomber en le signalant par un message d'avertissement.

note: type: textblock
en: If a translation has an entire template that is not in the master file (and thus is probably an old template), drop that entire template.
fr: Si un questionnaire traduit possède une question-modèle qui n'est pas dans le fichier principal (c'est probablement une ancienne question), rejeter toute la question.

note: type: textblock
en: debconf-set-selections - insert new values into the debconf database
fr: debconf-set-selections - insérer de nouvelles valeurs dans la base de données de debconf

note: type: verbatim
en:  debconf-set-selections file
     debconf-get-selections | ssh newhost debconf-set-selections
fr:  debconf-set-selections fichier
     debconf-get-selections | ssh nouvelhôte debconf-set-selections

note: type: textblock
en: B<debconf-set-selections> can be used to pre-seed the debconf database with answers, or to change answers in the database. Each question will be marked as seen to prevent debconf from asking the question interactively.
fr: B<debconf-set-selections> peut être utilisé pour prévisualiser la base de données de debconf et les réponses, ou pour modifier les réponses dans la base de données. Chaque question sera marquée comme vue afin d'éviter à debconf de poser la question de manière interactive.

note: type: textblock
en: Reads from a file if a filename is given, otherwise from stdin.
fr: Si un nom de fichier est donné, celui-ci est lu, sinon l'entrée standard est utilisée.

note: type: textblock
en: Only use this command to seed debconf values for packages that will be or are installed. Otherwise you can end up with values in the database for uninstalled packages that will not go away, or with worse problems involving shared values. It is recommended that this only be used to seed the database if the originating machine has an identical install.
fr: Utilisez cette commande uniquement pour positionner les valeurs debconf par défaut pour des paquets qui seront installés ou qui le sont déjà. Autrement vous pouvez finir par avoir des valeurs restant dans la base de données pour des paquets non installés, ou des problèmes plus importants concernant des valeurs partagées. Il est recommandé d'utiliser cela uniquement pour renseigner les bases de données de machines ayant exactement la même installation.

note: type: =head1
en: DATA FORMAT
fr: FORMAT DES DONNÉES

note: type: textblock
en: The data is a series of lines. Lines beginning with a # character are comments. Blank lines are ignored. All other lines set the value of one question, and should contain four values, each separated by one character of whitespace. The first value is the name of the package that owns the question. The second is the name of the question, the third value is the type of this question, and the fourth value (through the end of the line)  is the value to use for the answer of the question.
fr: Les données sont sous forme d'une série de lignes. Les lignes commençant par le caractère dièse (« # ») sont des commentaires. Les lignes vides sont ignorées. Toutes les autres lignes définissent la valeur d'une question et devraient contenir quatre champs, chacun d'eux séparé par un caractère d'espacement. Le premier champ est le nom du paquet propriétaire de la question. Le second est le nom de la question, le troisième champ est le type de la question et le quatrième (jusqu'à la fin de la ligne) est la valeur de la réponse à utiliser pour cette question.

note: type: textblock
en: Alternatively, the third value can be "seen"; then the preseed line only controls whether the question is marked as seen in debconf's database. Note that preseeding a question's value defaults to marking that question as seen, so to override the default value without marking a question seen, you need two lines.
fr: Une alternative est de spécifier "seen" comme troisième valeur ; la ligne spécifiant la valeur par défaut ne fait alors que contrôler si la question est marquée comme déjà vue dans la base de données de debconf. Notez que donner une valeur par défaut à une question implique le marquage de celle-ci comme étant vue, ainsi pour remplacer la valeur par défaut d'une question, sans la marquer comme vue, vous avez besoin de deux lignes.

note: type: textblock
en: Lines can be continued to the next line by ending them with a "\" character.
fr: Une ligne peut être continuée sur la ligne suivant en la terminant par un caractère « \ ».

note: type: verbatim
en:  # Force debconf priority to critical.
     debconf debconf/priority select critical
fr:  # Forcer la priorité de debconf à critique (« critical »).
     debconf debconf/priority select critical

note: type: verbatim
en:  # Override default frontend to readline, but allow user to select.
     debconf debconf/frontend select readline
     debconf debconf/frontend seen false
fr:  # Remplacer l'interface par défaut par readline, 
     # mais autoriser l'utilisateur à choisir.
     debconf debconf/frontend select readline
     debconf debconf/frontend seen false

note: type: textblock
en: verbose output
fr: Affichage bavard

note: type: textblock
en: only check the input file format, do not save changes to database
fr: ne vérifier que le format du fichier d'entrée, ne pas sauvegarder les modifications effectués dans la base de données.

note: type: textblock
en: L<debconf-get-selections(1)> (available in the debconf-utils package)
fr: L<debconf-get-selections(1)> (disponible dans le paquet debconf-utils)

note: type: textblock
en: debconf-show - query the debconf database
fr: debconf-show - interroger la base de données de debconf

note: type: verbatim
en:  debconf-show packagename [...] [--db=dbname]
     debconf-show --listowners [--db=dbname]
     debconf-show --listdbs
fr:  debconf-show nomdupaquet [...] [--db=nomdb]
     debconf-show --listowners [--db=nomdb]
     debconf-show --listdbs

note: type: textblock
en: B<debconf-show> lets you query the debconf database in different ways.
fr: B<debconf-show> vous permet d'interroger la base de données de debconf de différentes manières.

note: type: textblock
en: The most common use is "debconf-show packagename", which displays all items in the debconf database owned by a given package, and their current values.  Questions that have been asked already are prefixed with an '*'.
fr: L'utilisation la plus courante est « debconf-show nomdupaquet », qui affiche tous les éléments de la base de données de debconf possédés par un paquet, ainsi que leurs valeurs. Les questions ayant déjà été posées sont précédées d'une « * ».

note: type: textblock
en: This can be useful as a debugging aid, and especially handy in bug reports involving a package's use of debconf.
fr: Cela peut être utile pour aider au débogage et particulièrement pratique dans les rapports de bogue impliquant un paquet qui utilise debconf.

note: type: textblock
en: Specify the database to query. By default, debconf-show queries the main database.
fr: Indiquer la base de données à interroger. Par défaut, debconf-show interroge la base de données principale.

note: type: textblock
en: Lists all owners of questions in the database. Generally an owner is equivalent to a debian package name.
fr: Lister tous les propriétaires des questions de la base de données. En général, un propriétaire équivaut à un nom de paquet debian.

note: type: textblock
en: Lists all available databases.
fr: Lister toutes les bases de données disponibles.

note: type: textblock
en: Joey Hess <joeyh@debian.org> and Sylvain Ferriol
fr: Joey Hess <joeyh@debian.org> et Sylvain Ferriol

note: type: textblock
en: dpkg-preconfigure - let packages ask questions prior to their installation
fr: dpkg-preconfigure - permet aux paquets de poser des questions avant leur installation

note: type: verbatim
en:  dpkg-preconfigure [options] package.deb
fr:  dpkg-preconfigure [options] paquet.deb

note: type: textblock
en: B<dpkg-preconfigure> lets packages ask questions before they are installed.  It operates on a set of debian packages, and all packages that use debconf will have their config script run so they can examine the system and ask questions.
fr: B<dpkg-preconfigure> permet aux paquets de poser des questions avant qu'ils ne soient installés. Il opère sur un jeu de paquets debian, et tous ceux qui utilisent debconf lanceront leur script de configuration, pouvant ainsi examiner le système et poser des questions.

note: type: textblock
en: Set the lowest priority of questions you are interested in. Any questions with a priority below the selected priority will be ignored and their default answers will be used.
fr: Positionner la priorité la plus basse des questions auxquelles vous vous intéressez. Toutes les questions en dessous de la priorité sélectionnée seront ignorées et les réponses par défaut seront utilisées.

note: type: textblock
en: Run in apt mode. It will expect to read a set of package filenames from stdin, rather than getting them as parameters. Typically this is used to make apt run dpkg-preconfigure on all packages before they are installed.  To do this, add something like this to /etc/apt/apt.conf:
fr: Exécuter en mode apt. Il s'attendra à lire un jeu de noms de paquets depuis l'entrée standard, plutôt que de les obtenir en paramètre. C'est généralement utilisé pour faire exécuter dpkg-preconfigure par apt avant que tous les paquets ne soient installés. Pour ce faire, ajoutez quelque chose comme ceci dans /etc/apt/apt.conf :

note: type: verbatim
en:  // Pre-configure all packages before
     // they are installed.
     DPkg::Pre-Install-Pkgs {
     	"dpkg-preconfigure --apt --priority=low";
     };
fr:  // Pré-configure tous les paquets
     // avant qu'ils ne soient installés.
     DPkg::Pre-Install-Pkgs {
     	"dpkg-preconfigure --apt --priority=low";
     };

note: type: textblock
en: Display usage help.
fr: Afficher un message d'aide.

note: type: textblock
en: dpkg-reconfigure - reconfigure an already installed package
fr: dpkg-reconfigure - reconfigurer un paquet déjà installé

note: type: verbatim
en:  dpkg-reconfigure [options] packages
fr:  dpkg-reconfigure [options] paquets

note: type: textblock
en: B<dpkg-reconfigure> reconfigures packages after they have already been installed. Pass it the names of a package or packages to reconfigure. It will ask configuration questions, much like when the package was first installed.
fr: B<dpkg-reconfigure> reconfigure les paquets après qu'ils ont déjà été installés. Donnez-lui le nom d'un ou plusieurs paquets à reconfigurer.

note: type: textblock
en: If you just want to see the current configuration of a package, see L<debconf-show(1)> instead.
fr: Si vous voulez juste consulter la configuration debconf actuelle d'un paquet, utilisez L<debconf-show(1)>.

note: type: textblock
en: Select the frontend to use. The default frontend can be permanently changed by:
fr: Sélectionner l'interface à utiliser. L'interface par défaut peut être fixée de façon permanente par :

note: type: textblock
en: Note that if you normally have debconf set to use the noninteractive frontend, dpkg-reconfigure will use the dialog frontend instead, so you actually get to reconfigure the package.
fr: Remarquez que si vous avez paramétré debconf pour utiliser par défaut l'interface non interactive, dpkg-reconfigure utilisera l'interface dialog à la place et vous devrez réellement reconfigurer le paquet.

note: type: textblock
en: Specify the minimum priority of question that will be displayed.  dpkg-reconfigure normally shows low priority questions no matter what your default priority is. See L<debconf(7)> for a list.
fr: Spécifier la priorité minimale des questions qui seront affichées.  Normalement, dpkg-reconfigure affiche les questions à priorité basse sans tenir compte de votre priorité par défaut. Voyez la page L<debconf(7)> pour en obtenir une liste.

note: type: textblock
en: Use whatever the default priority of question is, instead of forcing the priority to low.
fr: Utiliser la priorité par défaut, au lieu de forcer la priorité à low.

note: type: textblock
en: By default, all questions are shown, even if they have already been answered. If this parameter is set though, only questions that have not yet been seen will be asked.
fr: Par défaut, toutes les questions sont affichées, même si vous y avez déjà répondu. Cependant, si ce paramètre est défini, seules les questions qui n'ont pas été affichées seront posées.

note: type: textblock
en: Force dpkg-reconfigure to reconfigure a package even if the package is in an inconsistent or broken state. Use with caution.
fr: Forcer dpkg-reconfigure à reconfigurer un paquet même si celui-ci est dans un état incohérent ou cassé. Utilisez ce paramètre avec précaution.

note: type: textblock
en: Prevent dpkg-reconfigure from reloading templates. Use with caution; this will prevent dpkg-reconfigure from repairing broken templates databases.  However, it may be useful in constrained environments where rewriting the templates database is expensive.
fr: Empêcher dpkg-reconfigure de recharger les modèles. Utilisez cette option avec prudence ; elle empêche dpkg-reconfigure de réparer les bases de données des modèles cassés. Cependant cette option est utile pour des systèmes où la mise à jour des bases de données des modèles est coûteuse en ressources.

note: type: Plain text
en: debconf.conf - debconf configuration file
fr: debconf.conf - fichier de configuration de debconf

note: type: Plain text
en: Debconf is a configuration system for Debian packages. /etc/debconf.conf and ~/.debconfrc are configuration files debconf uses to determine which databases it should use. These databases are used for storing two types of information; dynamic config data the user enters into it, and static template data. Debconf offers a flexible, extensible database backend. New drivers can be created with a minimum of effort, and sets of drivers can be combined in various ways.
fr: Debconf est un système de configuration pour les paquets Debian. /etc/debconf.conf et ~/.debconfrc sont les fichiers de configuration utilisés pour déterminer la base de données qui doit être utilisée. Ces bases de données sont utilisées pour garder deux types d'informations ; les données dynamiques de configuration que l'utilisateur a définies et les données statiques des questions. Debconf offre une interface souple et extensible pour la gestion des bases de données. De nouveaux pilotes peuvent être créés sans effort et les pilotes peuvent être combinés de différentes façons.

note: type: Plain text
en:   # This is a sample config file that is
      # sufficient to use debconf.
      Config: configdb
      Templates: templatedb
fr:   # Ceci est un exemple de fichier de configuration
      # suffisant pour utiliser debconf.
      Config: configdb
      Templates: templatedb

note: type: SH
en: FILE FORMAT
fr: FORMAT DE FICHIER

note: type: Plain text
en: The format of this file is a series of stanzas, each separated by at least one wholly blank line. Comment lines beginning with a "#" character are ignored.
fr: Le format de ce fichier est une suite de paragraphes, chacun d'eux séparé par au moins une ligne blanche. Les lignes de commentaires, commençant par un caractère dièse (« # »), sont ignorées.

note: type: Plain text
en: The first stanza of the file is special, is used to configure debconf as a whole. Two fields are required to be in this first stanza:
fr: Le premier paragraphe du fichier est spécial et est utilisé pour configurer l'ensemble de debconf. Ce premier paragraphe requiert deux champs :

note: type: Plain text
en: Specifies the name of the database from which to load config data.
fr: Indique le nom de la base de données où prendre les données de configuration.

note: type: Plain text
en: Specifies the name of the database to use for the template cache.
fr: Indiquer le nom de la base de données à utiliser pour le cache des questions.

note: type: Plain text
en: Additional fields that can be used include:
fr: Champs additionnels pouvant être ajoutés :

note: type: Plain text
en: The frontend Debconf should use, overriding any frontend set in the debconf database.
fr: L'interface utilisée par debconf, remplace toute interface indiquée dans la base de données de debconf.

note: type: Plain text
en: The priority Debconf should use, overriding any priority set in the debconf database.
fr: La priorité utilisée par debconf, remplace toute priorité indiquée dans la base de données de debconf.

note: type: Plain text
en: The email address Debconf should send mail to if it needs to make sure that the admin has seen an important message. Defaults to "root", but can be set to any valid email address to send the mail there. If you prefer to never have debconf send you mail, specify a blank address. This can be overridden on the fly with the DEBCONF_ADMIN_EMAIL environment variable.
fr: L'adresse électronique à laquelle Debconf envoie un courriel pour s'assurer que l'administrateur a bien vu une remarque importante. Par défaut « root », mais ce peut être une adresse électronique valable où envoyer le courriel. Si vous préférez que debconf ne vous envoie pas de courriel, spécifiez une adresse vide. Cela peut être annulé à la volée par la variable d'environnement DEBCONF_ADMIN_EMAIL.

note: type: Plain text
en: If set, this will cause debconf to output debugging information to standard error. The value it is set to can be something like "user", "developer", "db", or a regular expression. Typically, rather than setting it permanently in a config file, you will only want to temporarily turn on debugging, and the DEBCONF_DEBUG environment variable can be set instead to accomplish that.
fr: Si ce champ existe, debconf affichera alors les informations de débogage sur la sortie d'erreur standard. La valeur fixée peut être quelque chose comme « user », « developer », « db » ou encore une expression rationnelle. Généralement, plutôt que de le configurer de manière figée dans un fichier de configuration, vous voudrez activer le débogage temporairement, la variable d'environnement DEBCONF_DEBUG peut alors être utilisée à la place pour accomplir ce débogage.

note: type: Plain text
en: If set, this will make debconf not display warnings about various things.  This can be overridden on the fly with the DEBCONF_NOWARNINGS environment variable.
fr: S'il existe, debconf n'affichera aucun avertissement. Il peut être annulé à la volée par la variable d'environnement DEBCONF_NOWARNINGS.

note: type: Plain text
en: Makes debconf log debugging information as it runs, to the syslog. The value it is set to controls that is logged. See Debug, above for an explanation of the values that can be set to control what is logged.
fr: Debconf enregistre des informations de débogage lors de son fonctionnement, dans le fichier syslog. La valeur donnée sert à contrôler ce qui est enregistré dans le journal. Voir plus haut Debug pour une explication des valeurs qui peuvent être choisies pour contrôler ce qui est enregistré dans le journal.

note: type: Plain text
en: If set to "true", makes some debconf frontends use a special terse display mode that outputs as little as possible. Defaults to false. Terse mode may be temporarily set via the DEBCONF_TERSE environment variable.
fr: S'il est fixé à « true », certaines interfaces debconf utiliseront un mode d'affichage concis et spécial qui affiche le moins d'informations possible. Par défaut à « false ». Le mode concis peut être choisi temporairement grâce à la variable d'environnement DEBCONF_TERSE.

note: type: Plain text
en: For example, the first stanza of a file might look like this:
      Config: configdb
      Templates: templatedb
fr: Par exemple, le premier paragraphe d'un fichier devrait ressembler à ça :
      Config: configdb
      Templates: templatedb

note: type: Plain text
en: Each remaining stanza in the file sets up a database. A database stanza
    begins by naming the database:
      Name: configdb
fr: Chaque paragraphe restant dans le fichier configure une base de données. Un
    paragraphe de base de données commence par nommer la base de données :
      Name: configdb

note: type: Plain text
en: Then it indicates what database driver should be used for this database.
    See DRIVERS, below, for information about what drivers are available.
      Driver: File
fr: Ensuite, on indique le pilote à utiliser pour
    cette base de données. Pour avoir des informations sur les pilotes disponibles,
    voir la section DRIVER plus bas.
      Driver: File

note: type: Plain text
en: You can indicate that the database is not essential to the proper
    functioning of debconf by saying it is not required. This will make debconf
    muddle on if the database fails for some reason.
      Required: false
fr: Vous pouvez indiquer que la base de données n'est pas essentielle au
    fonctionnement correct de debconf en spécifiant qu'elle n'est pas requise. Cela
    mettra le désordre dans debconf en cas de défaillance quelconque de la base de données.
      Required: false

note: type: Plain text
en: You can mark any database as readonly and debconf will not write anything
    to it.
      Readonly: true
fr: Vous pouvez marquer une base de données comme étant en lecture seule, debconf
    n'y écrira alors rien.
      Readonly: true

note: type: Plain text
en: You can also limit what types of data can go into the database with Accept- and Reject- lines; see ACCESS CONTROLS, below.
fr: Vous pouvez aussi limiter le type de données pouvant aller dans la base de données avec les lignes Accept- et Reject- ; voir la section CONTRÔLES D'ACCÈS plus bas.

note: type: Plain text
en: The remainder of each database stanza is used to provide configuration
    specific to that driver. For example, the Text driver needs to know
    a directory to put the database in, so you might say:
      Filename: /var/cache/debconf/config.dat
fr: Le reste de chaque paragraphe d'une base de données est utilisé pour fournir
    une configuration spécifique à ce pilote. Par exemple, le pilote Text a besoin
    de savoir dans quel répertoire mettre la base de données, vous devriez donc
    entrer :
      Filename: /var/cache/debconf/config.dat

note: type: SH
en: DRIVERS
fr: PILOTES

note: type: Plain text
en: A number of drivers are available, and more can be written with little difficulty. Drivers come in two general types. First there are real drivers -- drivers that actually access and store data in some kind of database, which might be on the local filesystem, or on a remote system. Then there are meta-drivers that combine other drivers together to form more interesting systems. Let's start with the former.
fr: Il y a de nombreux pilotes disponibles et on peut en écrire d'autres sans grande difficulté. Les pilotes sont répartis en deux types. Il y a d'abord les pilotes réels -- pilotes qui lisent et stockent réellement les données dans quelque sorte de base de données, qui peut se trouver sur le système de fichiers local ou sur un système distant. Il y a ensuite les méta-pilotes qui associent différents pilotes pour former des systèmes plus intéressants. Commençons par les premiers.

note: type: Plain text
en: This database driver allows debconf to store a whole database in a single flat text file. This makes it easy to archive, transfer between machines, and edit. It is one of the more compact database formats in terms of disk space used. It is also one of the slowest.
fr: Ce pilote permet à debconf de stocker une base de données complète dans un simple fichier texte. Cela facilite l'archivage, le transfert entre les machines et l'édition. C'est l'un des formats de base de données les plus compacts en terme d'espace disque utilisé. C'est aussi l'un des formats les plus lents.

note: type: Plain text
en: On the downside, the entire file has to be read in each time debconf starts up, and saving it is also slow.
fr: Parmi les inconvénients, le fichier doit être lu en entier à chaque fois que debconf démarre ; de même, le sauvegarder est lent.

note: type: Plain text
en: The following things are configurable for this driver.
fr: Pour ce pilote, les points suivants sont configurables.

note: type: Plain text
en: The file to use as the database. This is a required field.
fr: Fichier à utiliser comme base de données. Ce champ est obligatoire.

note: type: Plain text
en: The permissions to create the file with if it does not exist. Defaults to 600, since the file could contain passwords in some circumstances.
fr: Les permissions du fichier à créer s'il n'existe pas. Elles sont par défaut mises à 600 parce que, dans certains circonstances, le fichier peut contenir des mots de passe.

note: type: Plain text
en: The format of the file. See FORMATS below. Defaults to using a rfc-822 like format.
fr: Format du fichier. Voir plus bas la section FORMATS. Le format par défaut est du type défini par la RFC-822.

note: type: Plain text
en: Whether a backup should be made of the old file before changing it.  Defaults to true.
fr: Indique si une sauvegarde de l'ancien fichier doit être effectuée avant de le modifier. Par défaut à « true » (vrai).

note: type: Plain text
en: As example stanza setting up a database using this driver:
fr: Voici un exemple de paragraphe configurant une base de données qui utilise ce pilote :

note: type: Plain text
en: This database driver allows debconf to store data in a hierarchical directory structure. The names of the various debconf templates and questions are used as-is to form directories with files in them. This format for the database is the easiest to browse and fiddle with by hand.  It has very good load and save speeds. It also typically occupies the most space, since a lot of small files and subdirectories do take up some additional room.
fr: Ce pilote permet à debconf de stocker les données dans une structure hiérarchisée de type répertoire. Les noms des différents questionnaires et questions debconf sont utilisés pour former des répertoires contenant les fichiers. Ce format de base de données est le plus facile à consulter et à modifier à la main. Il a une très bonne vitesse de chargement et de sauvegarde. C'est lui qui utilise le plus d'espace, car tous les petits fichiers et sous-répertoires occupent beaucoup de place.

note: type: Plain text
en: The directory to put the files in. Required.
fr: Répertoire où sont déposés les fichiers. Obligatoire.

note: type: Plain text
en: An extension to add to the names of files. Must be set to a non-empty string; defaults to ".dat"
fr: Extension à ajouter aux noms de fichiers. Ce doit être une chaîne de caractères non vide ; par défaut, sa valeur est « .dat »

note: type: Plain text
en: This database driver is a compromise between the File and DirTree databases. It uses a directory, in which there is (approximately) one file per package that uses debconf. This is fairly fast, while using little more room than the File database driver.
fr: Ce pilote est un compromis entre les bases de données File et DirTree. Il utilise un répertoire dans lequel il y a (approximativement) un fichier par paquet qui utilise debconf. C'est assez rapide, bien qu'utilisant un peu plus d'espace que le pilote de base de données File.

note: type: Plain text
en: This driver is configurable in the same ways as is the DirTree driver, plus:
fr: Ce pilote est configurable de la même manière que le pilote DirTree, plus :

note: type: Plain text
en: The permissions to create files with. Defaults to 600, since the files could contain passwords in some circumstances.
fr: Les permissions des fichiers créés. Par défaut à 600 parce que les fichiers peuvent, dans certaines circonstances, contenir des mots de passe.

note: type: Plain text
en: WARNING: This database driver is currently experimental. Use with caution.
fr: ATTENTION : Ce pilote est actuellement expérimental. Utilisez-le avec précaution.

note: type: Plain text
en: This database driver accesses a LDAP directory for debconf configuration data. Due to the nature of the beast, LDAP directories should typically be accessed in read-only mode. This is because multiple accesses can take place, and it's generally better for data consistency if nobody tries to modify the data while this is happening. Of course, write access is supported for those cases where you do want to update the config data in the directory.
fr: Ce pilote accède à un répertoire LDAP pour les données de configuration de debconf. Les répertoires LDAP doivent être en lecture seule, à cause de la nature de la bête. C'est parce que plusieurs accès peuvent avoir lieu et il vaut mieux, pour la cohérence des données, que personne n'essaie de les modifier lorsque cela arrive. Bien sûr, on peut donner la possibilité de modifier ces répertoires lorsque vous voulez mettre à jour les données de configuration.

note: type: Plain text
en: For information about setting up a LDAP server for debconf, read /usr/share/doc/debconf-doc/README.LDAP (from the debconf-doc package).
fr: Pour plus d'informations à propos de la configuration d'un serveur LDAP pour debconf, veuillez lire /usr/share/doc/debconf-doc/README.LDAP (du paquet debconf-doc).

note: type: Plain text
en: To use this database driver, you must have the libnet-ldap-perl package installed. Debconf suggests that package, but does not depend on it.
fr: Pour utiliser ce pilote, vous devez avoir installé le paquet libnet-ldap-perl. Debconf suggère ce paquet mais ne dépend pas de lui.

note: type: Plain text
en: Please carefully consider the security implications of using a remote debconf database. Unless you trust the source, and you trust the intervening network, it is not a very safe thing to do.
fr: Veuillez être attentif à ce qu'implique une base de données debconf distante en ce qui concerne la sécurité. Ce n'est pas une chose très sûre à faire à moins que vous fassiez confiance à la source et au réseau intervenant.

note: type: Plain text
en: The host name or IP address of an LDAP server to connect to.
fr: Nom d'hôte ou adresse IP d'un serveur LDAP auquel se connecter.

note: type: Plain text
en: The port on which to connect to the LDAP server. If none is given, the default port is used.
fr: Port de connexion au serveur LDAP. Si aucun n'est donné, le port par défaut est utilisé.

note: type: Plain text
en: The DN under which all config items will be stored. Each config item will be assumed to live in a DN of cn=E<lt>item nameE<gt>,E<lt>Base DNE<gt>. If this structure is not followed, all bets are off.
fr: Le DN sous lequel tous les points de la configuration seront stockés. Chaque point de configuration est supposé exister dans un DN de cn=E<lt>item nameE<gt>,E<lt>Base DNE<gt>. Si cette structure n'est pas respectée, rien ne fonctionne.

note: type: Plain text
en: The DN to bind to the directory as. Anonymous bind will be used if none is specified.
fr: DN à attacher au répertoire. Un lien anonyme sera utilisé s'il n'y en a aucun de spécifié.

note: type: Plain text
en: The password to use in an authenticated bind (used with binddn, above). If not specified, anonymous bind will be used.
fr: Mot de passe à utiliser dans un attachement authentifié (utilisé avec binddn, ci-dessus). Si ce n'est pas spécifié, un lien anonyme sera utilisé.

note: type: Plain text
en: This option should not be used in the general case. Anonymous binding should be sufficient most of the time for read-only access. Specifying a bind DN and password should be reserved for the occasional case where you wish to update the debconf configuration data.
fr: Cette option ne doit pas être utilisée dans le cas général. La liaison anonyme devrait être suffisante dans la plupart des cas pour un accès en lecture seule. Spécifier un DN lié à un mot de passe devrait être réservé pour les cas où vous souhaitez mettre à jour vos données de configuration de debconf.

note: type: Plain text
en: Enable access to individual LDAP entries, instead of fetching them all at once in the beginning. This is very useful if you want to monitor your LDAP logs for specific debconf keys requested. In this way, you could also write custom handling code on the LDAP server part.
fr: Activer l'accès aux entrées individuelles de l'annuaire LDAP au lieu de toutes les télécharger au début. Cela est très utile si vous voulez analyser des requêtes debconf depuis les journaux de LDAP. Cette option permet aussi d'écrire du code de gestion sur le serveur LDAP.

note: type: Plain text
en: Note that when this option is enabled, the connection to the LDAP server is kept active during the whole Debconf run. This is a little different from the all-in-one behavior where two brief connections are made to LDAP; in the beginning to retrieve all the entries, and in the end to save eventual changes.
fr: Notez que lorsque cette option est activée, la connexion au serveur LDAP reste active durant toute l'exécution de debconf. Ce comportement est différent lorsque vous télécharger toutes les données d'un seul bloc car deux connexions au serveur LDAP sont réalisées ; une au début pour récupérer toutes les données et une à la fin pour sauvegarder les éventuelles modifications.

note: type: Plain text
en: An example stanza setting up a database using this driver, assuming the remote database is on example.com and can be accessed anonymously:
fr: Voici un exemple de paragraphe configurant une base de données qui utilise ce pilote, en supposant que la base de données distante est sur exemple.com et qu'on peut y accéder anonymement :

note: type: Plain text
en: Another example, this time the LDAP database is on localhost, and can be written to:
fr: Autre exemple, cette fois la base de données LDAP est sur l'hôte local et peut être modifiée :

note: type: Plain text
en: This special-purpose database driver reads and writes the database from standard input/output. It may be useful for people with special needs.
fr: Ce pilote spécial lit et écrit la base de données depuis l'entrée/sortie standard. Ça peut être utile pour les personnes qui ont des besoins spécifiques.

note: type: Plain text
en: The format to read and write. See FORMATS below. Defaults to using a rfc-822 like format.
fr: Format à lire et écrire. Voir la section FORMATS plus bas. Par défaut, il utilise un format du type défini par la RFC-822.

note: type: Plain text
en: File descriptor number to read from. Defaults to reading from stdin. If set to "none", the database will not read any data on startup.
fr: Numéro du descripteur de fichier à lire. La lecture se fait par défaut depuis l'entrée standard. S'il est fixé à « none », la base de données ne lira aucune donnée au démarrage.

note: type: Plain text
en: File descriptor number to write to. Defaults to writing to stdout. If set to "none", the database will be thrown away on shutdown.
fr: Numéro du descripteur de fichier à écrire. L'écriture se fait par défaut sur la sortie standard. S'il est fixé à « none », la base de données va être détruite lors de l'arrêt.

note: type: Plain text
en: That's all of the real drivers, now moving on to meta-drivers..
fr: C'est tout pour les pilotes réels, nous allons à présent voir les méta-pilotes.

note: type: Plain text
en: This driver stacks up a number of other databases (of any type), and allows them to be accessed as one. When debconf asks for a value, the first database on the stack that contains the value returns it. If debconf writes something to the database, the write normally goes to the first driver on the stack that has the item debconf is modifying, and if none do, the new item is added to the first writable database on the stack.
fr: Ce pilote superpose plusieurs autres bases de données (de tout type) et permet l'accès à celles-ci comme si elles n'en formaient qu'une seule. Lorsque debconf demande une valeur, la première base dans la pile qui contient cette valeur la retourne. Si debconf écrit quelque chose dans la base de données, l'écriture se fait normalement dans le premier pilote de la pile qui contient l'élément modifié par debconf ; s'il n'y en a pas, le nouvel élément est ajouté à la première base de données de la pile sur laquelle on peut écrire.

note: type: Plain text
en: Things become more interesting if one of the databases on the stack is readonly. Consider a stack of the databases foo, bar, and baz, where foo and baz are both readonly. Debconf wants to change an item, and this item is only present in baz, which is readonly. The stack driver is smart enough to realize that won't work, and it will copy the item from baz to bar, and the write will take place in bar. Now the item in baz is shadowed by the item in bar, and it will not longer be visible to debconf.
fr: Les choses deviennent plus intéressantes si l'une des bases de données de la pile est en lecture seule. Considérez une pile des bases de données toto, titi et tata, où toto et tata sont toutes les deux en lecture seule. Debconf veut changer un élément et cet élément n'est présent que dans tata, qui est en lecture seule. Le pilote de pile est assez malin pour réaliser que ça ne fonctionne pas, il copiera l'élément de tata vers titi et l'écriture aura lieu dans titi. Maintenant l'élément de tata est caché par celui de titi et il ne sera plus visible de debconf.

note: type: Plain text
en: This kind of thing is particularly useful if you want to point many systems at a central, readonly database, while still allowing things to be overridden on each system. When access controls are added to the picture, stacks allow you to do many other interesting things, like redirect all passwords to one database while a database underneath it handles everything else.
fr: Ce genre de choses est particulièrement utile si vous voulez faire pointer beaucoup de systèmes vers une base de données centrale en lecture seule, tout en permettant la réécriture des éléments sur chaque système. Si l'on ajoute des contrôles d'accès, les piles permettent de faire beaucoup d'autres choses intéressantes, comme rediriger tous les mots de passe vers une base de données pendant qu'une autre base de données en dessous s'occupe de tout le reste.

note: type: Plain text
en: Only one piece of configuration is needed to set up a stack:
fr: Un seul élément de configuration est nécessaire pour configurer une pile :

note: type: Plain text
en: This is where you specify a list of other databases, by name, to tell it what makes up the stack.
fr: C'est là que vous spécifiez une liste d'autres bases de données, par nom, pour dire de quoi est composée la pile.

note: type: Plain text
en: For example:
fr: Par exemple :

note: type: Plain text
en: WARNING: The stack driver is not very well tested yet. Use at your own risk.
fr: ATTENTION : le pilote de piles n'a pas encore été vraiment testé. Utilisez-le à vos risques et périls.

note: type: Plain text
en: This driver passes all requests on to another database driver. But it also copies all write requests to a backup database driver.
fr: Ce pilote transmet toutes les requêtes vers un autre pilote. Mais il copie aussi toutes les requêtes d'écriture vers un pilote de sauvegarde.

note: type: Plain text
en: You must specify the following fields to set up this driver:
fr: Pour configurer ce pilote, vous devez spécifier les champs suivants :

note: type: Plain text
en: The database to read from and write to.
fr: Base de données à lire et dans laquelle écrire.

note: type: Plain text
en: The name of the database to send copies of writes to.
fr: Nom de la base de données où envoyer les copies à écrire.

note: type: Plain text
en: This driver passes all requests on to another database driver, outputting verbose debugging output about the request and the result.
fr: Ce pilote transmet toutes les requêtes vers un autre pilote, affichant toutes les informations de débogage à propos des requêtes et de leurs résultats.

note: type: SH
en: ACCESS CONTROLS
fr: CONTRÔLES D'ACCÈS

note: type: Plain text
en: When you set up a database, you can also use some fields to specify access controls. You can specify that a database only accepts passwords, for example, or make a database only accept things with "foo" in their name.
fr: Quand vous configurez une base de données, vous pouvez aussi utiliser des champs pour indiquer les contrôles d'accès. Vous pouvez spécifier, par exemple, qu'une base de données n'accepte que les mots de passe ou faire qu'une base de données n'accepte que les choses ayant dans leur nom « toto ».

note: type: Plain text
en: As was mentioned earlier, this access control, if set to "true", makes a database readonly. Debconf will read values from it, but will never write anything to it.
fr: Comme on l'a mentionné, ce contrôle d'accès, s'il est fixé à « true », rend une base de données accessible uniquement en lecture seule. Debconf en lira les valeurs mais n'y écrira jamais rien.

note: type: Plain text
en: The text in this field is a perl-compatible regular expression that is matched against the names of items as they are requested from the database. Only if an items name matches the regular expression, will the database allow debconf to access or modify it.
fr: Le texte de ce champ est une expression rationnelle compatible Perl (« PCRE ») qui correspond aux noms des éléments requis de la base de données. La base de données ne permettra à debconf d'y accéder ou de la modifier que si le nom d'un élément concorde avec l'expression rationnelle.

note: type: Plain text
en: Like Accept-Name, except any item name matching this regular expression will be rejected.
fr: Comme Accept-Name, excepté que tout élément correspondant à cette expression rationnelle sera rejeté.

note: type: Plain text
en: Another regular expression, this matches against the type of the item that is being accessed. Only if the type matches the regex will access be granted.
fr: Autre expression rationnelle, correspondant au type de l'élément auquel on accédera. L'accès ne sera accordé que si le type correspond à l'expression rationnelle.

note: type: Plain text
en: Like Accept-Type, except any type matching this regular expression will be rejected.
fr: Comme Accept-Type, excepté que tout type correspondant à cette expression rationnelle sera rejeté.

note: type: Plain text
en: Some of the database drivers use format modules to control the actual format in which the database is stored on disk. These formats are currently supported:
fr: Quelques pilotes utilisent des modules de format pour contrôler le format réel d'enregistrement des bases de données sur le disque. Ces formats sont actuellement gérés :

note: type: Plain text
en: This is a file format loosely based upon the rfc-822 format for email message headers. Similar formats are used throughout Debian; in the dpkg status file, and so on.
fr: C'est un format de fichier vaguement basé sur le format de la RFC-822 pour les entêtes de courriel. Des formats similaires sont utilisés partout dans Debian ; dans le fichier d'état de dpkg, et autres.

note: type: Plain text
en: Here is a more complicated example of a debconf.conf file.
fr: Voici un exemple de fichier debconf.conf parmi les plus compliqués.

note: type: Plain text
en:   # This stanza is used for general debconf setup.
      Config: stack
      Templates: templates
      Log: developer
      Debug: developer
fr:   # Ce paragraphe est utilisé pour la
      # configuration générale de debconf.
      Config: stack
      Templates: templates
      Log: developer
      Debug: developer

note: type: Plain text
en:   # This is my own local database.
      Name: mydb
      Driver: DirTree
      Directory: /var/cache/debconf/config
fr:   # Ma base de données locale.
      Name: mydb
      Driver: DirTree
      Directory: /var/cache/debconf/config

note: type: Plain text
en:   # This is another database that I use to hold
      # only X server configuration.
      Name: X
      Driver: File
      Filename: /etc/X11/debconf.dat
      Mode: 644
      # It's sorta hard to work out what questions
      # belong to X; it should be using a deeper
      # tree structure so I could just match on ^X/
      # Oh well.
      Accept-Name: xserver|xfree86|xbase
fr:   # C'est une autre base de données que
      # j'utilise pour ne garder que la
      # configuration de mon serveur X.
      Name: X
      Driver: File
      Filename: /etc/X11/debconf.dat
      Mode: 644
      # Il est difficile de savoir quelles
      # sont le questions concernent X ; il faudrait
      # utiliser une arborescence plus profonde
      # pour que je puisse n'accepter que les
      # correspondances avec ^X/
      # Passons.
      Accept-Name: xserver|xfree86|xbase

note: type: Plain text
en:   # This is our company's global, read-only
      # (for me!) debconf database.
      Name: company
      Driver: LDAP
      Server: debconf.foo.com
      BaseDN: cn=debconf,dc=foo,dc=com
      BindDN: uid=admin,dc=foo,dc=com
      BindPasswd: secret
      Readonly: true
      # I don't want any passwords that might be
      # floating around in there.
      Reject-Type: password
      # If this db is not accessible for whatever
      # reason, carry on anyway.
      Required: false
fr:   # C'est la base de données générale de notre
      # société, en lecture seule (pour moi !).
      Name: company
      Driver: LDAP
      Server: debconf.toto.com
      BaseDN: cn=debconf,dc=toto,dc=com
      BindDN: uid=admin,dc=toto,dc=com
      BindPasswd: secret
      Readonly: true
      # Je ne veux pas que les mots de passe traînent par là.
      Reject-Type: password
      # Si cette base de données n'est pas disponible
      # pour quelque raison que ce soit, on continue.
      Required: false

note: type: Plain text
en:   # I use this database to hold
      # passwords safe and secure.
      Name: passwords
      Driver: File
      Filename: /etc/debconf/passwords
      Mode: 600
      Accept-Type: password
fr:   # J'utilise cette base de données pour
      # conserver les mots de passe en sûreté.
      Name: passwords
      Driver: File
      Filename: /etc/debconf/passwords
      Mode: 600
      Accept-Type: password

note: type: Plain text
en:   # Let's put them all together
      # in a database stack.
      Name: stack
      Driver: Stack
      Stack: passwords, X, mydb, company
      # So, all passwords go to the password database.
      # Most X configuration stuff goes to the X
      # database, and anything else goes to my main
      # database. Values are looked up in each of those
      # in turn, and if none has a particular value, it
      # is looked up in the company-wide LDAP database
      # (unless it's a password).
fr:   # Rassemblons toutes ces bases
      # de données dans une pile.
      Name: stack
      Driver: Stack
      Stack: passwords, X, mydb, company
      # Donc, tous les mots de passe vont dans la
      # base de données passwords. La plupart des objets
      # concernant la configuration de X vont dans la
      # base de données X, et tout le reste va dans ma
      # base de données principale. Les valeurs sont
      # recherchées tour à tour dans chacune de ces bases
      # de données et si une valeur particulière n'est trouvée
      # nulle part, elle est recherchée dans la base de
      # données LDAP au niveau de la société (à moins que ce ne
      # soit un mot de passe).

note: type: Plain text
en:   # A database is also used to hold templates. We
      # don't need to make this as fancy.
      Name: templates
      Driver: File
      Mode: 644
      Format: 822
      Filename: /var/cache/debconf/templates
fr:   # Une base de données est aussi utilisée
      # pour conserver les questionnaires. Nous
      # n'avons pas besoin d'y mettre autant de fantaisie.
      Name: templates
      Driver: File
      Mode: 644
      Format: 822
      Filename: /var/cache/debconf/templates

note: type: Plain text
en: If you use something like ${HOME} in this file, it will be replaced with the value of the named environment variable.
fr: Si vous utilisez dans ce fichier quelque chose comme ${HOME}, cette variable sera remplacée par la valeur de la variable d'environnement nommée ainsi.

note: type: Plain text
en: Environment variables can also be used to override the databases on the fly, see B<debconf>(7)
fr: Les variables d'environnement peuvent aussi être utilisées pour remplacer à la volée les bases de données utilisées, voir B<debconf>(7).

note: type: Plain text
en: The field names (the part of the line before the colon) is case-insensitive. The values, though, are case sensitive.
fr: Il n'est pas tenu compte de la casse des noms des champs (la partie de la ligne avant le deux-points). Cependant, les valeurs sont sensibles à la casse.

note: type: SH
en: PLANNED ENHANCEMENTS
fr: AMÉLIORATIONS PRÉVUES

note: type: Plain text
en: More drivers and formats. Some ideas include: A SQL driver, with the capability to access a remote database.  A DHCP driver, that makes available some special things like hostname, IP address, and DNS servers.  A driver that pulls values out of public DNS records TXT fields.  A format that is compatible with the output of cdebconf.  An override driver, which can override the value field or flags of all requests that pass through it.
fr: Autres pilotes et formats. Voici quelques idées : un pilote SQL, avec la possibilité d'accéder à une base de données distante ; un pilote DHCP, qui rend disponible certaines choses spécifiques comme le nom d'hôte, l'adresse IP et les serveurs DNS ; un pilote qui prend ses valeurs dans les champs TXT des enregistrements DNS publics ; un format compatible avec la sortie de cdebconf ; un pilote d'annulation, qui peut annuler la valeur d'un champ ou les drapeaux de toutes les requêtes qui lui sont adressées.

note: type: SH
en: FILES
fr: FICHIERS

note: type: Plain text
en: confmodule - communicate with Debian configuration system FrontEnd.
fr: confmodule - Communiquer avec l'interface de configuration système Debian

note: type: Plain text
en:   #!/bin/sh -e
      . /usr/share/debconf/confmodule
      db_version 2.0
      db_capb 'backup'
      CAPB=$RET
      db_input 'foo/bar' || true
      db_go || true
fr:   #!/bin/sh -e
      . /usr/share/debconf/confmodule
      db_version 2.0
      db_capb 'backup'
      CAPB=$RET
      db_input 'toto/titi' || true
      db_go || true

note: type: Plain text
en: This is a library of shell functions that eases communication with Debian's configuration management system. It can communicate with a FrontEnd via the debconf protocol. The design is that each command in the protocol is represented by one function in this module. The functionname is the same as the command, except it is prefixed with "db_" and is lower-case. Call the function and pass in any parameters you want to follow the command. Any textual return code from the FrontEnd will be returned to you in the $RET variable, while the numeric return code from the FrontEnd will be returned as a return code (and so those return codes must be captured or ignored).
fr: C'est une bibliothèque de fonctions shell qui facilite la communication avec le gestionnaire de configuration système Debian. Elle peut communiquer avec une interface via le protocole debconf. Chaque commande du protocole est représentée par une fonction de cette bibliothèque. Le nom de la fonction est le même que celui de la commande, excepté qu'il est préfixé avec « db_ » et est en minuscules. Appelez la fonction et transmettez-lui les paramètres que vous voulez pour la commande. Un code de retour textuel de l'interface vous sera renvoyé dans la variable $RET, et le code de retour numérique de l'interface sera renvoyé comme code de retour (ces codes de retour doivent être pris en compte ou ignorés).

note: type: Plain text
en: Once this library is loaded, any text you later output will go to standard
    error, rather than standard output. This is a good thing in general, because
    text sent to standard output is interpreted by the FrontEnd as commands. If
    you do want to send a command directly to the FrontEnd, you must output it
    to file descriptor 3, like this:
      echo GET foo/bar E<gt>&3
fr: Une fois cette bibliothèque chargée, tout texte émis par la suite le sera sur
    la sortie d'erreur standard, plutôt que sur la sortie standard. C'est une bonne chose en
    général, car le texte envoyé à la sortie standard est interprété par l'interface
    comme une commande. Si vous voulez envoyer une commande directement à
    l'interface, vous devez l'envoyer vers le descripteur de fichier 3, comme
    ceci :
      echo GET toto/titi E<gt>&3

note: type: Plain text
en: The library checks to make sure it is actually speaking to a FrontEnd by examining the DEBIAN_HAS_FRONTEND variable. If it is set, a FrontEnd is assumed to be running. If not, the library turns into one, and runs a copy of the script that loaded the library connected to it. This means that if you source this library, you should do so very near to the top of your script, because everything before the sourcing of the library may well be run again.
fr: La bibliothèque s'assure qu'elle communique réellement avec une interface en examinant la variable DEBIAN_HAS_FRONTEND. Si elle est définie, une interface est supposée être lancée. Sinon, la bibliothèque en devient une et lance une copie du script qui chargea la bibliothèque et se connecta à elle. Cela signifie que si vous chargez cette bibliothèque, vous devez le faire presque au début de votre script, parce que tout ce qui a été fait avant le chargement de la bibliothèque sera peut-être exécuté une fois de plus.

note: type: Plain text
en: B<debconf-devel>(7), B<dpkg-preconfigure>(8), B<dpkg-reconfigure>(8), debconf_specification in the debian-policy package
fr: B<debconf-devel>(7), B<dpkg-preconfigure>(8), B<dpkg-reconfigure>(8), les spécifications debconf dans le paquet debian-policy

note: type: Plain text
en: debconf - Debian package configuration system
fr: debconf - système de configuration des paquets Debian

note: type: Plain text
en: Debconf is a configuration system for Debian packages. There is a rarely-used command named debconf, documented in B<debconf>(1)
fr: Debconf est un système de configuration pour les paquets Debian. Il existe une commande rarement utilisée nommée debconf, documentée dans B<debconf>(1)

note: type: Plain text
en: Debconf provides a consistent interface for configuring packages, allowing you to choose from several user interface frontends. It supports preconfiguring packages before they are installed, which allows large installs and upgrades to ask you for all the necessary information up front, and then go do the work while you do something else. It lets you, if you're in a hurry, skip over less important questions and information while installing a package (and revisit it later).
fr: Debconf fournit une interface cohérente pour la configuration des paquets et donne à l'utilisateur le choix entre plusieurs interfaces. Il peut configurer des paquets avant qu'ils ne soient installés, ce qui permet à des installations et des mises à niveau importantes de demander toutes les informations nécessaires au préalable, et de vous laisser faire ce que vous voulez pendant que les paquets s'installent. Debconf vous permet, si vous êtes pressé, de sauter les questions les moins importantes au moment de l'installation d'un paquet (en y revenant plus tard).

note: type: SH
en: Preconfiguring packages
fr: Préconfiguration des paquets

note: type: Plain text
en: Debconf can configure packages before they are even installed onto your system. This is useful because it lets all the questions the packages are going to ask be asked at the beginning of an install, so the rest of the install can proceed while you are away getting a cup of coffee.
fr: Debconf peut configurer les paquets avant même qu'ils ne soient installés sur votre système. Ainsi, toutes les questions des paquets vous seront posées au début de l'installation ce qui permettra à l'installation de continuer pendant que vous êtes en train de prendre un café.

note: type: Plain text
en: If you use apt (version 0.5 or above), and you have apt-utils installed, each package apt installs will be automatically preconfigured. This is controlled via I</etc/apt/apt.conf.d/70debconf>
fr: Si vous utilisez apt (version 0.5 ou supérieure) et que vous avez installé apt-utils, chaque paquet installé par apt sera automatiquement préconfiguré. Ceci est contrôlé via I</etc/apt/apt.conf.d/70debconf>

note: type: Plain text
en: Sometimes you might want to preconfigure a package by hand, when you're not installing it with apt. You can use B<dpkg-preconfigure>(8)  to do that, just pass it the filenames of the packages you want to preconfigure. You will need apt-utils installed for that to work.
fr: Quelquefois vous voudrez préconfigurer un paquet vous-même, quand vous l'installez sans apt. Vous pouvez utiliser B<dpkg-preconfigure>(8) pour ce faire. Donnez-lui seulement le nom du paquet que vous voulez préconfigurer. Vous aurez besoin d'installer apt-utils pour que cela fonctionne.

note: type: SH
en: Reconfiguring packages
fr: Reconfiguration des paquets

note: type: Plain text
en: Suppose you installed the package, and answered debconf's questions, but now that you've used it awhile, you realize you want to go back and change some of your answers. In the past, reinstalling a package was often the thing to do when you got in this situation, but when you reinstall the package, debconf seems to remember you have answered the questions, and doesn't ask them again (this is a feature).
fr: Supposons que vous ayez installé un paquet et que vous ayez répondu aux questions de debconf, mais maintenant que vous l'utilisez de temps en temps, vous réalisiez que vous voulez revenir sur quelques-unes de vos réponses et les changer. Autrefois, il fallait faire une réinstallation quand vous étiez dans cette situation ; mais quand vous réinstallez le paquet, debconf semble se souvenir que vous avez déjà répondu aux questions et ne vous les pose pas à nouveau (c'est voulu).

note: type: Plain text
en: Luckily, debconf makes it easy to reconfigure any package that uses it.
    Suppose you want to reconfigure debconf itself. Just run, as root:
      dpkg-reconfigure debconf
fr: Heureusement, debconf facilite la reconfiguration des paquets qui l'utilisent.
    Supposez que vous voulez reconfigurer debconf lui-même. Exécutez simplement, en
    tant que superutilisateur :
      dpkg-reconfigure debconf

note: type: Plain text
en: This will ask all the questions you saw when debconf was first installed.  It may ask you other questions as well, since it asks even low priority questions that may have been skipped when the package was installed.  You can use it on any other package that uses debconf, as well.
fr: Il vous posera toutes les questions que vous avez vues lors de la première installation de debconf. Il peut aussi vous poser d'autres questions, puisqu'il vous pose même les questions de priorité basse qui ont pu être sautées quand le paquet a été installé. Vous pouvez aussi bien l'utiliser avec n'importe quel autre paquet utilisant debconf.

note: type: SH
en: Frontends
fr: Interfaces

note: type: Plain text
en: One of debconf's unique features is that the interface it presents to you is only one of many, that can be swapped in at will. There are many debconf frontends available:
fr: Une fonctionnalité remarquable de debconf est qu'il possède plusieurs interfaces et l'on peut en changer à loisir. Voici les interfaces disponibles :

note: type: Plain text
en: The default frontend, this uses the B<whiptail>(1)  or B<dialog>(1)  programs to display questions to you. It works in text mode.
fr: Interface par défaut : elle utilise les programmes B<whiptail>(1) ou B<dialog>(1) pour afficher les questions. Elle fonctionne en mode texte.

note: type: Plain text
en: The most traditional frontend, this looks quite similar to how Debian configuration always has been: a series of questions, printed out at the console using plain text, and prompts done using the readline library. It even supports tab completion. The libterm-readline-gnu-perl package is strongly recommended if you chose to use this frontend; the default readline module does not support prompting with default values.  At the minimum, you'll need the perl-modules package installed to use this frontend.
fr: C'est l'interface la plus traditionnelle. Elle ressemble à la configuration Debian classique : une série de questions, imprimées sur la console en mode texte et des invites affichées avec la bibliothèque readline. Elle reconnaît même le complètement avec « tab ». Le paquet libterm-readline-gnu-perl est fortement recommandé si vous choisissez d'utiliser cette interface ; le module readline par défaut ne gère pas les invites de saisie avec des valeurs par défaut. Pour utiliser cette interface, vous aurez besoin d'installer le paquet perl-modules.

note: type: Plain text
en: This frontend has some special hotkeys. Pageup (or ctrl-u)  will go back to the previous question (if that is supported by the package that is using debconf), and pagedown (or ctrl-v) will skip forward to the next question.
fr: Cette interface a quelques commandes spéciales. « Page préc. » (ou ctrl-u) reviendra à la question précédente (si cela est géré par le paquet utilisant debconf) et « Page suiv. » (ou ctrl-v) passera à la question suivante.

note: type: Plain text
en: This is the best frontend for remote admin work over a slow connection, or for those who are comfortable with unix.
fr: C'est la meilleure interface pour les administrateurs à distance travaillant par une connexion lente, ou pour ceux qui sont à l'aise avec Unix.

note: type: Plain text
en: This is the anti-frontend. It never interacts with you at all, and makes the default answers be used for all questions. It might mail error messages to root, but that's it; otherwise it is completely silent and unobtrusive, a perfect frontend for automatic installs. If you are using this front-end, and require non-default answers to questions, you will need to preseed the debconf database; see the section below on Unattended Package Installation for more details.
fr: C'est l'anti-interface. Elle n'interagit jamais avec vous et utilise les réponses par défaut pour toutes les questions. Elle enverra parfois un courriel à root avec les messages que le paquet voulait afficher, mais c'est tout ! À part ça, elle est silencieuse et discrète, c'est une interface parfaite pour des installations automatiques. Si vous utilisez cette interface et si vous voulez que les réponses aux questions ne soient pas celles par défaut, vous aurez besoin de renseigner d'abord la base de données de debconf ; pour plus de détails, consultez la section ci-dessous sur l'installation de paquets sans surveillance.

note: type: Plain text
en: This is a modern X GUI using the gtk and gnome libraries. Of course, it requires a valid DISPLAY to work; debconf will fall back to other frontends if it can't work. Note that this frontend requires you have the libgtk3-perl package installed.
fr: C'est une interface graphique moderne utilisant les bibliothèques de gtk et de GNOME. Bien sûr, elle nécessite une variable DISPLAY valable pour fonctionner ; si elle ne peut pas fonctionner, debconf se rabattra sur d'autres interfaces. Remarquez que cette interface nécessite que vous ayez installé le paquet libgtk3-perl.

note: type: Plain text
en: This frontend provides a modern X GUI based on the KDE Platform. You of course need a DISPLAY to use this frontend and you must install debconf-kde-helper package. The frontend will fall back to dialog if some of the prerequisites are not met.
fr: Cette interface fournit un outil graphique moderne basé sur la plateforme KDE. Vous aurez bien sûr besoin d'une variable DISPLAY pour utiliser cette interface et vous devez installer le paquet debconf-kde-helper. L'interface se rabattra sur l'interface dialog si un des prérequis est absent.

note: type: Plain text
en: This is for those fanatics who have to do everything in a text editor. It runs your editor on a file that looks something like a typical unix config file, and you edit the file to communicate with debconf. Debconf's author prefers to not comment regarding the circumstances that led to this frontend being written.
fr: C'est pour ces fanatiques qui veulent tout faire à l'aide d'un éditeur de texte. Elle lance votre éditeur sur un fichier qui ressemble à un fichier de configuration Unix, et vous modifiez le fichier qui sert à communiquer avec debconf. L'auteur de debconf préfère ne pas commenter les circonstances qui ont conduit à l'écriture de cette interface.

note: type: Plain text
en: This frontend acts as a web server, that you connect to with your web browser, to browse the questions and answer them.  It has a lot of promise, but is a little rough so far.  When this frontend starts up, it will print out the location you should point your web browser to. You have to run the web browser on the same machine you are configuring, for security reasons.
fr: Cette interface agit comme un serveur web auquel vous vous connectez avec votre navigateur web, pour parcourir les questions et y répondre. Elle est très prometteuse, mais un peu rugueuse pour l'instant. Quand cette interface se met en route, elle indiquera le lieu où vous devrez pointer votre navigateur web. Pour des raisons de sécurité, vous devez exécuter votre navigateur web sur la machine que vous configurez.

note: type: Plain text
en: Do keep in mind that this is not a very secure frontend.  Anyone who has access to the computer being configured can currently access the web server and configure things while this frontend is running. So this is more of a proof of concept than anything.
fr: Gardez à l'esprit que ce n'est pas une interface sécurisée. Tous ceux qui ont accès à l'ordinateur en cours de configuration peuvent aussi accéder au serveur web et configurer certaines choses alors que cette interface tourne. C'est plus une preuve de concept qu'autre chose.

note: type: Plain text
en: You can change the default frontend debconf uses by reconfiguring
    debconf. On the other hand, if you just want to change the frontend
    for a minute, you can set the DEBIAN_FRONTEND environment variable to
    the name of the frontend to use. For example:
      DEBIAN_FRONTEND=readline apt-get install slrn
fr: Vous pouvez changer l'interface par défaut qu'utilise debconf en le
    reconfigurant. D'un autre côté, si vous voulez juste changer l'interface pour 
    un instant, vous pouvez positionner la variable d'environnement DEBIAN_FRONTEND
    avec le nom de l'interface à utiliser. Par exemple :
      DEBIAN_FRONTEND=readline apt-get install slrn

note: type: Plain text
en: The B<dpkg-reconfigure>(8)  and B<dpkg-preconfigure>(8)  commands also let you pass I<--frontend=> to them, followed by the frontend you want them to use.
fr: Les commandes B<dpkg-reconfigure>(8) et B<dpkg-preconfigure>(8) permettent aussi de leur passer I<--frontend=> en paramètre, suivi de l'interface que vous voulez qu'elles utilisent.

note: type: Plain text
en: Note that not all frontends will work in all circumstances. If a frontend fails to start up for some reason, debconf will print out a message explaining why, and fall back to the next-most similar frontend.
fr: Notez que toutes les interfaces ne fonctionneront pas en toute circonstance. Si le démarrage d'une interface échoue pour quelque raison que ce soit, debconf affichera un message expliquant pourquoi et se rabattra sur l'interface la plus proche.

note: type: SH
en: Priorities
fr: Priorités

note: type: Plain text
en: Another nice feature of debconf is that the questions it asks you are prioritized. If you don't want to be bothered about every little thing, you can set up debconf to only ask you the most important questions.  On the other hand, if you are a control freak, you can make it show you all questions. Each question has a priority. In increasing order of importance:
fr: Pouvoir donner des priorités aux questions que vous pose debconf est une fonctionnalité agréable. Si vous ne voulez pas être ennuyé par les questions sans importance, vous pouvez configurer debconf pour qu'il ne vous pose que les questions les plus importantes. D'un autre côté, si vous aimez tout contrôler, vous pouvez lui faire afficher toutes les questions. Chaque question a une priorité. Par ordre croissant d'importance :

note: type: Plain text
en: Very trivial questions that have defaults that will work in the vast majority of cases.
fr: Questions peu importantes dont les valeurs par défaut suffisent dans la majorité des cas.

note: type: Plain text
en: Normal questions that have reasonable defaults.
fr: Questions normales avec des valeurs par défaut raisonnables.

note: type: Plain text
en: Questions that don't have a reasonable default.
fr: Questions qui n'ont pas de valeurs par défaut convenables.

note: type: Plain text
en: Questions that you really, really need to see (or else).
fr: Questions que vous avez vraiment besoin de voir (ou autre).

note: type: Plain text
en: Only questions with a priority equal to or greater than the priority you choose will be shown to you. You can set the priority value by reconfiguring debconf, or temporarily by passing I<--priority=> followed by the value to the B<dpkg-reconfigure>(8)  and B<dpkg-preconfigure>(8)  commands, or by setting the DEBIAN_PRIORITY environment variable.
fr: Seules les questions avec une priorité supérieure ou égale à la priorité que vous avez choisie seront affichées. Vous pouvez fixer la valeur de la priorité en reconfigurant debconf, ou temporairement en passant l'option I<--priority=> suivie de la valeur voulue aux commandes B<dpkg-reconfigure>(8) et B<dpkg-preconfigure>(8), ou en positionnant la variable d'environnement DEBIAN_PRIORITY.

note: type: SH
en: Backend Database
fr: Base de données principale

note: type: Plain text
en: Debconf uses a rather flexible and potentially complicated backend database for storing data such as the answers to questions. The file B</etc/debconf.conf> is used to configure this database. If you need to set up something complicated, like make debconf read a remote database to get defaults, with local overrides, read the B<debconf.conf>(5)  man page for all the gory details. Generally, the backend database is located in B</var/cache/debconf/> .
fr: Debconf utilise une base de données sous-jacente plutôt flexible et potentiellement compliquée pour sauvegarder les réponses déjà données aux questions. Le fichier B</etc/debconf.conf> est utilisé pour configurer cette base de données. Si vous avez besoin de configurer quelque chose de compliqué, comme utiliser une base de données distante pour obtenir les valeurs par défaut, annulées par des variables locales, lisez la page de manuel B<debconf.conf>(5) pour tous les détails croustillants. La base de données principale se trouve généralement dans B</var/cache/debconf/>.

note: type: SH
en: Unattended Package Installation
fr: Installation des paquets sans surveillance

note: type: Plain text
en: If you have many machines to manage you will sometimes find yourself in the position of needing to perform an unattended installation or upgrade of packages on many systems, when the default answers to some configuration questions are not acceptable. There are many ways to approach this; all involve setting up a database and making debconf use it to get the answers you want.
fr: Si vous avez beaucoup de machines à gérer, vous aurez sûrement besoin de faire une installation ou une mise à niveau sans surveillance, alors que les réponses par défaut à certaines questions de configuration ne sont pas acceptables. Il y a beaucoup de manières pour faire cela ; toutes impliquent la configuration d'une base de données que debconf utilisera pour obtenir les réponses par défaut que vous voulez.

note: type: Plain text
en: You should really read B<debconf.conf>(5)  before this section, as you need to understand how debconf's databases work.
fr: Avant de lire cette section, vous devriez vraiment lire B<debconf.conf>(5) car vous avez besoin de comprendre le fonctionnement de la base de données de debconf.

note: type: Plain text
en: The easiest way to set up the database is to install the packages on one machine and answer their questions as usual. Or you might just use B<dpkg-preconfigure>(8)  to configure a set of packages without actually installing them. Or you might even decide to write a plain text debconf database by hand or something.
fr: Le plus simple pour configurer la base de données est d'installer les paquets sur une machine et de répondre aux questions. Vous pouvez aussi utiliser B<dpkg-preconfigure>(8) pour configurer un ensemble de paquets sans réellement les installer. Vous pouvez même décider d'écrire une base de données debconf à la main, comme un simple texte...

note: type: Plain text
en: Once you have the database, you need to figure out how to make the remote systems use it. This depends of course on the configuration of those systems and what database types they are set up to use.
fr: Une fois que vous avez la base de données, vous devez trouver comment faire pour que les systèmes distants l'utilisent. Cela dépend bien sûr de la configuration de ces systèmes et de la base de données qu'ils doivent utiliser.

note: type: Plain text
en: If you are using the LDAP debconf database, an entire network of debian machines can also have any or all package installation questions answered automatically by a single LDAP server.
fr: Si vous utilisez la base de données LDAP de debconf, un seul serveur LDAP peut répondre à toutes les questions d'installation des paquets d'un réseau complet de machines Debian.

note: type: Plain text
en: But perhaps you're using something a little bit easier to set up like, say, the default debconf database configuration, or you just don't want your remote systems to use LDAP all the time. In this case the best approach is to temporarily configure the remote systems to stack your database underneath their own existing databases, so they pull default values out of it. Debconf offers two environment variables, DEBCONF_DB_FALLBACK and DEBCONF_DB_OVERRIDE, to make it easy to do this on the fly. Here is a sample use:
fr: Mais peut-être utilisez-vous quelque chose d'un peu plus facile à configurer, comme par exemple, la base de données de configuration de debconf par défaut, ou ne voulez-vous tout simplement pas que vos systèmes distants utilisent LDAP continuellement. Dans ce cas, la meilleure approche est de configurer temporairement les systèmes distants pour qu'ils ajoutent votre base de données sous leurs propres bases, de manière à ce qu'ils obtiennent les valeurs par défaut de celle-ci. Debconf offre deux variables d'environnement, DEBCONF_DB_FALLBACK et DEBCONF_DB_OVERRIDE, pour le faire à la volée et simplement. Ici, un exemple d'utilisation :

note: type: Plain text
en:    cat /var/cache/debconf/config.dat | \e
       ssh root@target "DEBIAN_FRONTEND=noninteractive \e
                      DEBCONF_DB_FALLBACK=Pipe apt-get upgrade"
fr:    cat /var/cache/debconf/config.dat | \e
       ssh root@cible "DEBIAN_FRONTEND=noninteractive \e
                      DEBCONF_DB_FALLBACK=Pipe apt-get upgrade"

note: type: Plain text
en: This makes the debconf on the remote host read in the data that is piped across the ssh connection and interpret it as a plain text format debconf database. It then uses that database as a fallback database -- a read-only database that is queried for answers to questions if the system's main debconf database lacks answers.
fr: Cela fait que debconf sur l'hôte distant lit les données passées dans le tube à travers la connexion SSH et les interprète comme une base de données debconf en mode texte. Il n'utilise cette base de données qu'en dernier lieu -- c'est une base de données en lecture seule, où l'on cherche les réponses que la base principale du système ne peut fournir.

note: type: Plain text
en: Here's another way to use the DEBCONF_DB_FALLBACK environment variable:
fr: Une autre manière d'utiliser la variable d'environnement DEBCONF_DB_FALLBACK :

note: type: Plain text
en:   ssh -R 389:ldap:389 root@target \e
      	"DEBCONF_DB_FALLBACK='LDAP{host:localhost}' apt-get upgrade"
fr:   ssh -R 389:ldap:389 root@cible \e
      	"DEBCONF_DB_FALLBACK='LDAP{host:localhost}' apt-get upgrade"

note: type: Plain text
en: Here ssh is used to set up a tunneled LDAP connection and run debconf.  Debconf is told to use the LDAP server as the fallback database. Note the use of "{host:localhost}" to configure how debconf accesses the LDAP database by providing the "host" field with a value of "localhost".
fr: ssh est utilisé ici pour configurer une connexion LDAP dans un tunnel et lancer debconf. On indique à debconf d'utiliser le serveur LDAP comme base de données de secours. Remarquez l'utilisation de « {host:localhost} » pour configurer l'accès de debconf à la base de données LDAP fournissant le champ « host » avec la valeur « localhost ».

note: type: Plain text
en: Here's another method:
fr: Encore une autre méthode :

note: type: Plain text
en:   scp config.dat root@target:
      ssh root@target "DEBCONF_DB_FALLBACK='File{/root/config.dat}' apt-get upgrade
fr:   scp config.dat root@cible:
      ssh root@cible "DEBCONF_DB_FALLBACK='File{/root/config.dat}' apt-get upgrade

note: type: Plain text
en: Here you copy the database over with scp, and then ssh over and make debconf use the file you copied over. This illustrates a shorthand you can use in the DEBCONF_DB_FALLBACK parameters -- if a field name is left off, it defaults to "filename".
fr: Ici, vous copiez la base de données avec scp, puis ssh, et vous faites utiliser à debconf la base de données que vous avez copiée. Cela illustre un raccourci que vous pouvez utiliser dans les paramètres de DEBCONF_DB_FALLBACK -- si le nom n'est pas indiqué, celui par défaut est « filename ».

note: type: Plain text
en: There is only one problem with these uses of the DEBCONF_DB_FALLBACK parameter: While the fallback database can provide answers to questions the other debconf databases have never seen, it is only queried as a fallback; after the other databases. If you need to instead temporarily override an existing value on the remote host, you should instead use the DEBCONF_DB_OVERRIDE variable. Like DEBCONF_DB_FALLBACK, it sets up a temporary database, but this database is consulted before any others, and can be used to override existing values.
fr: Il y a un problème avec l'utilisation des paramètres de DEBCONF_DB_FALLBACK : alors que la base de données de secours peut fournir des réponses à des questions que les autres bases de données debconf n'ont jamais vues, on ne l'interroge qu'en dernier lieu : après les autres bases de données. Si vous avez besoin d'annuler temporairement une valeur existante sur l'hôte distant, vous devriez plutôt utiliser la variable DEBCONF_DB_OVERRIDE. Comme DEBCONF_DB_FALLBACK, elle configure une base de données temporaire, mais cette base de données est consultée avant les autres et peut être utilisée pour remplacer les valeurs existantes.

note: type: SH
en: Developing for Debconf
fr: Développer pour debconf

note: type: Plain text
en: Package developers and others who want to develop packages that use debconf should read B<debconf-devel>(7)  .
fr: Les développeurs de paquet et ceux qui veulent développer des paquets qui utilisent debconf devraient lire B<debconf-devel>(7).

note: type: Plain text
en: Briefly, debconf communicates with maintainer scripts or other programs via standard input and output, using a simple line-oriented command language similar to that used by common internet protocols such as SMTP. Programs use this protocol to ask debconf to display questions to the user, and retrieve the user's answers. The questions themselves are defined in a separate file, called the "templates file", which has a format not unlike a debian control file.
fr: Brièvement, debconf communique avec des scripts de maintenance ou d'autres programmes via les entrée et sortie standard, en utilisant un langage orienté ligne de commandes semblable à ce qui est utilisé par les protocoles usuels de l'internet comme SMTP. Les programmes utilisent ce protocole pour demander à debconf d'afficher les questions et de récupérer les réponses de l'utilisateur. Les questions elles-mêmes sont définies dans des fichiers séparés, appelés « questionnaires », dont le format n'est pas très différent de celui d'un fichier de contrôle de Debian.

note: type: Plain text
en: Debian packages which use debconf typically provide both a templates file and a "config" script (run to preconfigure the package) in the control metadata section of the package.
fr: Les paquets Debian qui utilisent debconf fournissent généralement un questionnaire et un script de « configuration » (exécuté pour préconfigurer le paquet) dans la partie métadonnées du paquet.

note: type: SH
en: ENVIRONMENT
fr: ENVIRONNEMENT

note: type: Plain text
en: Used to temporarily change the frontend debconf uses. See above.
fr: Utilisée pour changer temporairement l'interface debconf utilisée. Voir plus haut.

note: type: Plain text
en: Used to temporarily change the minimum priority of question debconf will display. See above.
fr: Utilisée pour changer temporairement la priorité que les questions doivent avoir (au minimum) pour être affichées par debconf. Voir plus haut.

note: type: Plain text
en: Turns on debugging output on standard error. May be set to a facility name or a regular expression which matches a facility name (such as '.*' to output all debug info). The facility names include:
fr: Active l'affichage du débogage sur la sortie standard d'erreur. Elle peut être fixée par le nom d'un mécanisme ou par une expression rationnelle qui correspond au nom d'un mécanisme (comme « .* » pour afficher toutes les informations de débogage). Les noms de mécanisme incluent :

note: type: Plain text
en: Debugging info of interest to a debconf user.
fr: Informations de débogage intéressantes pour un utilisateur de debconf.

note: type: Plain text
en: Debugging info of interest to a package developer.
fr: Informations de débogage intéressantes pour un développeur de paquet.

note: type: Plain text
en: Debugging info about the backend database.
fr: Informations de débogage concernant la base de données sous-jacente.

note: type: Plain text
en: Set to "yes" to disable some warnings that debconf may display. Does not suppress display of fatal errors.
fr: Positionnez-la à « yes » pour désactiver certains avertissements que debconf pourrait afficher. Elle ne supprime pas l'affichage des erreurs fatales.

note: type: Plain text
en: Set to "yes" to enable terse mode, in which debconf frontends cut down on the verbiage as much as possible.
fr: Positionnez-la à « yes » pour activer le mode concis dans lequel les interfaces debconf suppriment autant que possible le bavardage.

note: type: Plain text
en: Stack a database after the normally used databases, so that it is used as a fallback to get configuration information from. See "Unattended Package Installation" above. If the value of the variable is the name of an existing database in debconf.conf, then that database will be used.  Otherwise, the environment variable can be used to configure a database on the fly, by telling the type of database, and optionally passing field:value settings, inside curly braces after the type. Spaces are used to separate fields, so you cannot specify a field value containing whitespace.
fr: Ajouter une base de données en plus de celles utilisées habituellement, elle est donc utilisée en secours pour obtenir les informations de configuration. Voir la section « Installation des paquets sans surveillance » plus haut. Si la valeur de la variable est le nom d'une base de données existante dans debconf.conf, la base de données sera alors utilisée. Néanmoins, la variable d'environnement peut être utilisée pour configurer une base de données à la volée, en donnant le type de la base de données et des paramètres optionnels (champ:valeur) après le type et entre accolades. Les espaces sont utilisées pour séparer les champs, vous ne pourrez donc pas spécifier de valeur de champ contenant des espaces.

note: type: Plain text
en: Thus, this uses the fallbackdb in debconf.conf:
      DEBCONF_DB_FALLBACK=fallbackdb
fr: La ligne suivante demande l'utilisation de fallbackdb dans debconf.conf :
      DEBCONF_DB_FALLBACK=fallbackdb

note: type: Plain text
en: While this sets up a new database of type File, and tells it a filename to
    use and turns off backups:
      DEBCONF_DB_FALLBACK=File{Filename:/root/config.dat Backup:no}
fr: Alors que cette ligne configure une nouvelle base de données de type fichier, 
    donne un nom de fichier à utiliser et désactive toute sauvegarde :
      DEBCONF_DB_FALLBACK=File{Filename:/root/config.dat Backup:no}

note: type: Plain text
en: And as a shorthand, this sets up a database of type File with a filename:
      DEBCONF_DB_FALLBACK=File{/root/config.dat}
fr: En résumé, cette ligne configure une base de données de type Fichier avec un nom de
    fichier :
      DEBCONF_DB_FALLBACK=File{/root/config.dat}

note: type: Plain text
en: Note that if a fallback database is set up on the fly, it will be read-only by default.
fr: Remarquez que si la base de données de secours est configurée à la volée, elle sera utilisable en lecture seule par défaut.

note: type: Plain text
en: Stack a database before the normally used databases, so that it can override values from them. The value of the variable works the same as does the value of DEBCONF_DB_FALLBACK.
fr: Ajouter une base de données avant celles utilisées normalement, elle peut donc remplacer les valeurs des autres. La valeur de la variable fonctionne de la même manière que pour DEBCONF_DB_FALLBACK.

note: type: Plain text
en: Use a given database instead of the normally used databases.  This may be useful for testing with a separate database without having to create a separate debconf.conf, or to avoid locking the normal databases.
fr: Utiliser une base de données particulière au lieu des bases de données utilisées normalement. Cela peut être utile pour des tests avec une base de données séparée sans avoir à créer de fichier debconf.conf séparé, ou pour éviter de verrouiller les bases de données normales.

note: type: Plain text
en: If this environment variable is set, debconf will ignore a user's ~/.debconfrc file, and use the system one instead.  If it is set to the name of a regular file, debconf will use that file in preference to the system configuration files.
fr: Si cette variable d'environnement est définie, debconf ignorera le fichier ~/.debconfrc de l'utilisateur et utilisera à la place le fichier de configuration du système.

note: type: Plain text
en: If this environment variable is set, debconf will use dialog in preference to whiptail for the dialog frontend.
fr: Si cette variable d'environnement est définie, debconf utilisera de préférence dialog à whiptail pour l'interface dialog.

note: type: Plain text
en: If this environment variable is set, debconf will use Xdialog in preference to whiptail for the dialog frontend.
fr: Si cette variable d'environnement est définie, debconf utilisera de préférence Xdialog à whiptail pour l'interface dialog.

note: type: Plain text
en: Set to "true" to cause the seen flag to be set for questions asked in the noninteractive frontend.
fr: Positionné à "true", cela positionne le drapeau « seen » pour les questions posées dans l'interface non interactive.

note: type: SH
en: BUGS
fr: BOGUES

note: type: Plain text
en: Probably quite a few, there's a lot of code here.
fr: Probablement beaucoup, il y a beaucoup de code ici.

note: type: Plain text
en: If you do file a bug report, be sure to include the following information:
fr: Si vous présentez un rapport de bogue, assurez-vous d'inclure les informations suivantes :

note: type: Plain text
en: The debconf frontend you were using when the problem occurred
fr: l'interface debconf que vous utilisiez lorsque le problème est survenu ;

note: type: Plain text
en: What you did to trigger the problem.
fr: ce que vous avez fait pour déclencher le problème ;

note: type: Plain text
en: The full text of any error messages. If you can reproduce the bug, do so with DEBCONF_DEBUG='.*' set and exported. This speeds up debugging a lot.
fr: le texte complet des messages d'erreur. Si vous pouvez reproduire le bogue, faites-le avec DEBCONF_DEBUG='.*' définie et exportée. Cela accélère beaucoup le débogage.

note: type: Plain text
en: debconf - developers guide
fr: debconf - guide du développeur

note: type: Plain text
en: This is a guide for developing packages that use debconf.
fr: C'est un guide pour créer des paquets qui utilisent debconf.

note: type: Plain text
en: This manual assumes that you are familiar with debconf as a user, and are familiar with the basics of debian package construction.
fr: Ce manuel suppose que vous connaissez bien debconf en tant qu'utilisateur et que vous êtes familier avec les bases de la construction des paquets Debian.

note: type: Plain text
en: This manual begins by explaining two new files that are added to debian packages that use debconf. Then it explains how the debconf protocol works, and points you at some libraries that will let your programs speak the protocol. It discusses other maintainer scripts that debconf is typically used in: the postinst and postrm scripts. Then moves on to more advanced topics like shared debconf templates, debugging, and some common techniques and pitfalls of programming with debconf. It closes with a discussion of debconf's current shortcomings.
fr: Ce manuel commence par expliquer les deux nouveaux fichiers ajoutés aux paquets Debian qui utilisent debconf. Puis il explique comment le protocole debconf fonctionne et vous indique les bibliothèques qui permettent de communiquer avec le protocole. Il traite les autres scripts d'administration où debconf est typiquement utilisé : les scripts postinst et postrm. Ensuite, il passe à des sujets plus pointus comme le partage des questionnaires debconf, le débogage, d'autres techniques courantes et les pièges de la programmation avec debconf. Il se termine par une discussion sur les défauts actuels de debconf.

note: type: SH
en: THE CONFIG SCRIPT
fr: LE SCRIPT DE CONFIGURATION

note: type: Plain text
en: Debconf adds an additional maintainer script, the config script, to the set of maintainer scripts that can be in debian packages (the postinst, preinst, postrm, and prerm). The config script is responsible for asking any questions necessary to configure the package.
fr: Debconf ajoute un script d'administration, le script config, au jeu de scripts pouvant être présents dans un paquet Debian (les scripts postinst, preinst, postrm, prerm). Le script config doit poser toutes les questions nécessaires à la configuration du paquet.

note: type: Plain text
en: Note: It is a little confusing that dpkg refers to running a package's postinst script as "configuring" the package, since a package that uses debconf is often fully pre-configured, by its config script, before the postinst ever runs. Oh well.
fr: Remarque : il est un peu ennuyeux que dpkg considère le script postinst du paquet comme un script de « configuration » du paquet ; en effet, un paquet utilisant debconf est souvent pré-configuré, par son script config, avant que le script postinst soit lancé. Mais, bon !

note: type: Plain text
en: Like the postinst, the config script is passed two parameters when it is run. The first tells what action is being performed, and the second is the version of the package that is currently installed. So, like in a postinst, you can use dpkg --compare-versions on $2 to make some behavior happen only on upgrade from a particular version of a package, and things like that.
fr: Lorsque le script config est lancé, deux paramètres lui sont passés ; il en va de même pour le script postinst. Le premier est l'action à effectuer et le second est la version du paquet actuellement installé. Donc, comme pour un script postinst, vous pouvez utiliser dpkg --compare-versions sur $2 pour effectuer une action seulement en cas de mise à niveau d'une version particulière du paquet ou d'autres actions de ce type.

note: type: Plain text
en: The config script can be run in one of three ways:
fr: Le script config peut être lancé de l'une de ces trois façons :

note: type: Plain text
en: If a package is pre-configured, with dpkg-preconfigure, its config script is run, and is passed the parameters "configure", and installed-version.
fr: Si un paquet est pré-configuré, avec dpkg-preconfigure, son script config est lancé avec les paramètres « configure » et « installed-version ».

note: type: Plain text
en: When a package's postinst is run, debconf will try to run the config script then too, and it will be passed the same parameters it was passed when it is pre-configured. This is necessary because the package might not have been pre-configured, and the config script still needs to get a chance to run. See HACKS for details.
fr: Lorsque le script postinst d'un paquet est lancé, debconf essaiera aussi de lancer le script config, avec les mêmes paramètres que ceux qui sont passés lorsqu'il est pré-configuré. C'est nécessaire car le paquet n'a peut-être pas été pré-configuré, et donc le script config doit alors être lancé. Veuillez consulter la section BIDOUILLES pour plus de précisions.

note: type: Plain text
en: If a package is reconfigured, with dpkg-reconfigure, its config script it run, and is passed the parameters "reconfigure" and installed-version.
fr: Si un paquet est reconfiguré, avec dpkg-reconfigure, son script config est lancé et les paramètres « reconfigure » et le numéro de la version installée lui sont passés.

note: type: Plain text
en: Note that since a typical package install or upgrade using apt runs steps 1 and 2, the config script will typically be run twice. It should do nothing the second time (to ask questions twice in a row is annoying), and it should definitely be idempotent. Luckily, debconf avoids repeating questions by default, so this is generally easy to accomplish.
fr: Notez que puisqu'une installation ou une mise à niveau typique utilisant apt exécute les étapes 1 et 2, le script config sera lancé deux fois. La seconde fois, il ne devrait rien faire (poser les questions deux fois de suite est ennuyeux) et il devrait être nettement idempotent. Par chance, debconf évite par défaut de répéter les questions, donc c'est relativement facile à effectuer.

note: type: Plain text
en: Note that the config script is run before the package is unpacked. It should only use commands that are in essential packages. The only dependency of your package that is guaranteed to be met when its config script is run is a dependency (possibly versioned) on debconf itself.
fr: Notez que le script config est lancé avant que le paquet ne soit dépaqueté. Il ne devrait utiliser que des commandes disponibles dans les paquets essentiels. La seule dépendance qui est sûre d'être satisfaite lorsque son script config est lancé est une dépendance (éventuellement sur une version spécifique) sur debconf lui-même.

note: type: Plain text
en: The config script should not need to modify the filesystem at all. It just examines the state of the system, and asks questions, and debconf stores the answers to be acted on later by the postinst script. Conversely, the postinst script should almost never use debconf to ask questions, but should instead act on the answers to questions asked by the config script.
fr: Le script config ne devrait pas avoir besoin de modifier le système de fichiers. Il vérifie seulement l'état du système et pose des questions. Debconf conserve alors les réponses, qui pourront être utilisées par le script postinst. Et inversement, le script postinst ne devrait presque jamais utiliser debconf pour poser des questions, mais devrait à la place utiliser les réponses aux questions posées par le script config.

note: type: SH
en: THE TEMPLATES FILE
fr: LE FICHIER TEMPLATES

note: type: Plain text
en: A package that uses debconf probably wants to ask some questions. These questions are stored, in template form, in the templates file.
fr: Un paquet qui utilise debconf voudra probablement poser quelques questions. Ces questions sont conservées sous une forme standard dans le fichier templates.

note: type: Plain text
en: Like the config script, the templates file is put in the control.tar.gz section of a deb. Its format is similar to a debian control file; a set of stanzas separated by blank lines, with each stanza having a RFC822-like form:
fr: Comme le script config, le fichier templates est inclus dans la section control.tar.gz d'un paquet. Son format est semblable à celui du fichier control Debian ; un ensemble de paragraphes séparés par des lignes vides, où chaque paragraphe possède une forme du type RFC 822 :

note: type: Plain text
en:   Template: foo/bar
      Type: string
      Default: foo
      Description: This is a sample string question.
       This is its extended description.
       .
       Notice that:
        - Like in a debian package description, a dot
          on its own line sets off a new paragraph.
        - Most text is word-wrapped, but doubly-indented
          text is left alone, so you can use it for lists
          of items, like this list. Be careful, since
          it is not word-wrapped, if it's too wide
          it will look bad. Using it for short items
          is best (so this is a bad example).
fr:   Template: toto/tata
      Type: string
      Default: toto
      Description: Il s'agit d'un exemple de question
       Ceci est la description longue  
       .
       Veuillez noter que :
        - comme dans une description de paquet Debian, un point seul définit un
          nouveau paragraphe ;
        - la plupart du texte est reformaté, mais le texte avec une indentation
          double est gardé tel quel, ainsi vous pouvez l'utiliser pour des listes,
          comme celle-ci. Soyez prudent, comme il n'est pas reformaté, s'il est
          trop large, il s'affichera mal. Il vaut mieux l'utiliser pour des
          éléments courts (donc ceci est un mauvais exemple).

note: type: Plain text
en:   Template: foo/baz
      Type: boolean
      Description: Clear enough, no?
       This is another question, of boolean type.
fr:   Template: toto/titi
      Type: boolean
      Description: C'est clair n'est-ce pas ?
       Ceci est une autre question, de type booléenne.

note: type: Plain text
en: For some real-life examples of templates files, see /var/lib/dpkg/info/debconf.templates, and other .templates files in that directory.
fr: Pour des exemples concrets de fichiers templates, regardez /var/lib/dpkg/info/debconf.templates, ainsi que les autres fichiers .templates de ce répertoire.

note: type: Plain text
en: Let's look at each of the fields in turn..
fr: Examinons chaque champ successivement :

note: type: Plain text
en: The name of the template, in the 'Template' field, is generally prefixed with the name of the package. After that the namespace is wide open; you can use a simple flat layout like the one above, or set up "subdirectories" containing related questions.
fr: Le nom du message, dans le champ « Template », est généralement préfixé avec le nom du paquet. Ensuite, l'espace de nommage est très libre ; vous pouvez utiliser une simple disposition plane, ou définir des « sous-répertoires » contenant ces questions.

note: type: Plain text
en: The type of the template determines what kind of widget is displayed to the user. The currently supported types are:
fr: Le type du message détermine le type d'objet devant être présenté à l'utilisateur. Les types actuellement reconnus sont :

note: type: Plain text
en: Results in a free-form input field that the user can type any string into.
fr: C'est un champ libre où l'utilisateur peut taper n'importe quelle chaîne de caractères.

note: type: Plain text
en: Prompts the user for a password. Use this with caution; be aware that the password the user enters will be written to debconf's database. You should probably clean that value out of the database as soon as is possible.
fr: Demande à l'utilisateur un mot de passe. Utilisez-le avec précaution ; soyez conscient que le mot de passe que l'utilisateur indique sera écrit dans la base de données de debconf. Vous devriez probablement effacer cette valeur de la base de données dès que possible.

note: type: Plain text
en: A true/false choice.
fr: Un choix du type « vrai ou faux ».

note: type: Plain text
en: A choice between one of a number of values. The choices must be specified in a field named 'Choices'. Separate the possible values with commas and spaces, like this:
fr: Un choix entre des valeurs. Les choix doivent être spécifiés dans un champ nommé « Choices ». Les valeurs sont séparées par des virgules et des espaces, comme ceci :

note: type: Plain text
en:   Choices: yes, no, maybe
fr:   Choices: oui, non, peut-être

note: type: Plain text
en: Like the select data type, except the user can choose any number of items from the choices list (or choose none of them).
fr: Comme le type de données select, excepté que l'utilisateur peut choisir plusieurs éléments de la liste (ou n'en choisir aucun).

note: type: Plain text
en: Rather than being a question per se, this datatype indicates a note that can be displayed to the user. It should be used only for important notes that the user really should see, since debconf will go to great pains to make sure the user sees it; halting the install for them to press a key.  It's best to use these only for warning about very serious problems, and the error datatype is often more suitable.
fr: À la place d'une question, ce type de données indique une note qui peut être affichée à l'utilisateur. Elle ne devrait être utilisée que pour des notes importantes que l'utilisateur doit absolument lire, car debconf va déployer les grands moyens pour s'assurer que l'utilisateur la lira ; en arrêtant l'installation et en attendant qu'il presse une touche. Il est préférable de n'utiliser ceci que pour signaler des problèmes très sérieux et le type de données «\ error\ » est souvent plus approprié.

note: type: Plain text
en: This datatype is used for error messages, such as input validation errors.  Debconf will show a question of this type even if the priority is too high or the user has already seen it.
fr: Ce type de données est utilisé pour les messages d'erreur, comme des erreurs d'entrée invalide. Debconf posera une question de ce genre même si la priorité est trop haute, ou si l'utilisateur l'a déjà vue.

note: type: Plain text
en: This datatype is used for titles, to be set with the SETTITLE command.
fr: Ce type de données est utilisé pour les titres, afin qu'ils soient positionnés avec la commande SETTITLE.

note: type: Plain text
en: This datatype can be used for fragments of text, such as labels, that can be used for cosmetic reasons in the displays of some frontends. Other frontends will not use it at all. There is no point in using this datatype yet, since no frontends support it well. It may even be removed in the future.
fr: Ce type de données peut être utilisé pour des portions de texte, comme des étiquettes, qui peuvent être utilisées pour des raisons cosmétiques dans l'affichage de certaines interfaces. D'autres interfaces ne l'utiliseront pas. Il n'y a pas de raison de l'utiliser pour l'instant, puisqu'aucune interface ne le gère correctement. Il risque même d'être supprimé dans le futur.

note: type: Plain text
en: The 'Default' field tells debconf what the default value should be. For multiselect, it can be a list of choices, separated by commas and spaces, similar to the 'Choices' field. For select, it should be one of the choices. For boolean, it is "true" or "false", while it can be anything for a string, and it is ignored for passwords.
fr: Le champ « Default » indique à debconf la valeur par défaut. Pour multiselect, elle peut être une liste de choix séparés par des virgules semblable au champ « Choices ». Pour select, elle devrait être l'un des choix possibles. Pour Boolean, c'est « true » ou « false », alors que cela peut être n'importe quoi pour une chaîne de caractères et est ignoré pour les mots de passe.

note: type: Plain text
en: Don't make the mistake of thinking that the default field contains the "value" of the question, or that it can be used to change the value of the question. It does not, and cannot, it just provides a default value for the first time the question is displayed. To provide a default that changes on the fly, you'd have to use the SET command to change the value of a question.
fr: Ne faites pas l'erreur de penser que le champ default contient la « valeur » de la question, ou qu'il puisse être utilisé pour changer la valeur de la question. Il ne le fait pas, et ne le peut pas, il fournit seulement une valeur par défaut lorsqu'une question est affichée pour la première fois. Pour fournir une valeur par défaut qui change à la volée, vous devriez utiliser la commande SET pour changer la valeur de la question.

note: type: Plain text
en: The 'Description' field, like the description of a Debian package, has two parts: A short description and an extended description. Note that some debconf frontends don't display the long description, or might only display it if the user asks for help. So the short description should be able to stand on its own.
fr: Le champ « Description », comme la description d'un paquet Debian, est constitué de deux parties : une description courte et une description longue. Notez que certaines interfaces debconf n'affichent pas la description longue, ou ne l'affichent que si l'utilisateur demande de l'aide. La description courte doit donc suffire à la compréhension du message.

note: type: Plain text
en: If you can't think up a long description, then first, think some more. Post to debian-devel. Ask for help. Take a writing class! That extended description is important. If after all that you still can't come up with anything, leave it blank. There is no point in duplicating the short description.
fr: Si vous n'arrivez pas à trouver une description longue, premièrement, réfléchissez-y plus longuement. Postez sur debian-devel. Demandez de l'aide. Prenez votre plus belle plume ! Car la description longue est importante. Si après tout ça vous n'arrivez toujours pas à proposer quelque chose, laissez-la vide. Cela n'apporte rien de recopier la description courte.

note: type: Plain text
en: Text in the extended description will be word-wrapped, unless it is prefixed by additional whitespace (beyond the one required space). You can break it up into separate paragraphs by putting " ." on a line by itself between them.
fr: Le texte dans la description longue sera reformaté, à moins qu'il ne soit préfixé avec une espace supplémentaire (après l'espace requise). Vous pouvez le découper en plusieurs paragraphes en les séparant par " ." sur une ligne.

note: type: Plain text
en: A question is an instantiated template. By asking debconf to display a question, your config script can interact with the user. When debconf loads a templates file (this happens whenever a config or postinst script is run), it automatically instantiates a question from each template. It is actually possible to instantiate several independent questions from the same template (using the REGISTER command), but that is rarely necessary. Templates are static data that comes from the templates file, while questions are used to store dynamic data, like the current value of the question, whether a user has seen a question, and so on. Keep the distinction between a template and a question in mind, but don't worry too much about it.
fr: Une question est une instance d'un message. En demandant à debconf d'afficher une question, votre script config peut interagir avec l'utilisateur. Quand debconf charge un questionnaire (cela arrive à chaque fois qu'un script postinst ou config est lancé), il crée automatiquement la question à partir du message. Il est possible de créer plusieurs questions indépendantes à partir d'un même message (en utilisant la commande REGISTER), mais c'est rarement nécessaire. Les messages sont des données statiques qui proviennent du fichier templates, alors que les questions sont utilisées pour conserver des données dynamiques, comme la valeur actuelle d'une question, ou si un utilisateur a déjà vu une question, etc. Gardez bien à l'esprit la différence entre un message et une question, mais ne vous inquiétez pas trop.

note: type: SH
en: SHARED TEMPLATES
fr: MESSAGES PARTAGÉS

note: type: Plain text
en: It's actually possible to have a template and a question that are shared among a set of packages. All the packages have to provide an identical copy of the template in their templates files. This can be useful if a bunch of packages need to ask the same question, and you only want to bother the user with it once. Shared templates are generally put in the shared/ pseudo-directory in the debconf template namespace.
fr: Il est tout à fait possible que des paquets partagent un message et une question. Tous les paquets doivent fournir une copie identique du message dans leur fichier templates. Cela peut être utile si un groupe de paquets a besoin de poser les mêmes questions et que vous avez envie de ne déranger les utilisateurs qu'une seule fois. Les messages partagés sont généralement placés dans le pseudo-répertoire shared/ dans l'espace de nommage des questionnaires debconf.

note: type: SH
en: THE DEBCONF PROTOCOL
fr: LE PROTOCOLE DEBCONF

note: type: Plain text
en: Config scripts communicate with debconf using the debconf protocol. This is a simple line-oriented protocol, similar to common internet protocols such as SMTP. The config script sends debconf a command by writing the command to standard output. Then it can read debconf's reply from standard input.
fr: Les scripts config communiquent avec debconf en utilisant le protocole debconf. C'est un protocole simple orienté ligne, semblable aux protocoles internet courants comme SMTP. Le script config envoie à debconf une commande en l'écrivant sur la sortie standard. Il peut alors lire la réponse de debconf depuis l'entrée standard.

note: type: Plain text
en: Debconf's reply can be broken down into two parts: A numeric result code (the first word of the reply), and an optional extended result code (the remainder of the reply). The numeric code uses 0 to indicate success, and other numbers to indicate various kinds of failure. For full details, see the table in Debian policy's debconf specification document.
fr: Les réponses de debconf peuvent être scindées en deux parties : un code de retour numérique (le premier mot de la réponse) et un code de retour étendu facultatif (le reste de la réponse). Le code numérique utilise 0 pour indiquer un succès et d'autres nombres pour indiquer divers types d'erreur. Pour plus de précisions, veuillez consulter le tableau dans les spécifications debconf de la charte Debian.

note: type: Plain text
en: The extended return code is generally free form and unspecified, so you should generally ignore it, and should certainly not try to parse it in a program to work out what debconf is doing. The exception is commands like GET, that cause a value to be returned in the extended return code.
fr: Le code de retour étendu n'a généralement aucune forme particulière, vous pourrez donc, dans la plupart des cas, l'ignorer et vous ne devriez pas essayer de l'analyser dans un programme pour savoir ce que debconf est en train de faire. Les commandes comme GET sont des exceptions car elles retournent une valeur dans le code de retour étendu.

note: type: Plain text
en: Generally you'll want to use a language-specific library that handles the nuts and bolts of setting up these connections to debconf and communicating with it.
fr: Vous voudrez généralement utiliser une bibliothèque spécifique à un langage qui gère l'aspect pratique des connexions et des communications avec debconf.

note: type: Plain text
en: For now, here are the commands in the protocol. This is not the definitive definition, see Debian policy's debconf specification document for that.
fr: Maintenant, voici les commandes de ce protocole. Ce n'est pas une définition complète, veuillez consulter les spécifications debconf de la charte Debian pour plus d'informations.

note: type: TP
en: B<VERSION number>
fr: B<VERSION nombre>

note: type: Plain text
en: You generally don't need to use this command. It exchanges with debconf the protocol version number that is being used. The current protocol version is 2.0, and versions in the 2.x series will be backwards-compatible. You may specify the protocol version number you are speaking and debconf will return the version of the protocol it speaks in the extended result code. If the version you specify is too low, debconf will reply with numeric code 30.
fr: Vous n'aurez, en général, pas besoin d'utiliser cette commande. Elle échange avec le protocole debconf le numéro de la version utilisée. La version actuelle du protocole est 2.0 et les versions de la série 2.x assureront la compatibilité ascendante. Vous pouvez spécifier le numéro de version du protocole que vous parlez et debconf retournera la version du protocole qu'il parle dans le code de retour étendu. Si la version que vous spécifiez est trop faible, debconf renverra un code de retour numérique égal à 30.

note: type: TP
en: B<CAPB capabilities>
fr: B<CAPB fonctionnalités>

note: type: Plain text
en: You generally don't need to use this command. It exchanges with debconf a list of supported capabilities (separated by spaces). Capabilities that both you and debconf support will be used, and debconf will reply with all the capabilities it supports.
fr: Vous n'aurez, en général, pas besoin d'utiliser cette commande. Elle échange avec debconf une liste des fonctionnalités reconnues (séparées par des espaces). Des fonctionnalités supportées par vous et debconf seront utilisées et debconf répondra avec toutes les fonctionnalités qu'il accepte.

note: type: Plain text
en: If 'escape' is found among your capabilities, debconf will expect commands you send it to have backslashes and newlines escaped (as \e\e and \en respectively) and will in turn escape backslashes and newlines in its replies. This can be used, for example, to substitute multi-line strings into templates, or to get multi-line extended descriptions reliably using METAGET. In this mode, you must escape input text yourself (you can use B<debconf-escape>(1)  to help with this if you want), but the confmodule libraries will unescape replies for you.
fr: Si « escape » ne fait pas partie de vos fonctionnalités, debconf va attendre que les commandes que vous lui passez comportent des antislashes et des caractères de retour à la ligne échappés (comme \e\e et \en respectivement) et va faire de même pour ses réponses. Ceci peut être utilisé par exemple pour changer des chaînes de caractères multilignes en modèles, ou pour récupérer des descriptions étendues multilignes de manière fiable en utilisant METAGET.

note: type: Plain text
en: This sets the title debconf displays to the user, using the short description of the template for the specified question. The template should be of type title. You rarely need to use this command since debconf can automatically generate a title based on your package's name.
fr: Utilisez la description courte du message comme titre de l'écran debconf pour la question indiquée. Le message devrait être de type titre. Vous n'aurez que rarement besoin de cette commande puisque debconf peut automatiquement générer un titre basé sur le nom de votre paquet.

note: type: Plain text
en: Setting the title from a template means they are stored in the same place as the rest of the debconf questions, and allows them to be translated.
fr: Définir le titre depuis un message signifie que les titres seront stockés à la même place que les autres questions posées par debconf. Elle permet aussi de traduire ces titres.

note: type: TP
en: B<TITLE string>
fr: B<TITLE chaîne de caractères>

note: type: Plain text
en: This sets the title debconf displays to the user to the specified string.  Use of the SETTITLE command is normally to be preferred as it allows for translation of the title.
fr: Utiliser la chaîne de caractères comme titre de l'écran debconf. L'utilisation de la commande SETTITLE est préférable car elle permet de traduire les titres affichés par debconf.

note: type: TP
en: B<INPUT priority question>
fr: B<INPUT priorité question>

note: type: Plain text
en: Ask debconf to prepare to display a question to the user. The question is not actually displayed until a GO command is issued; this lets several INPUT commands be given in series, to build up a set of questions, which might all be asked on a single screen.
fr: Demande à debconf de préparer l'affichage d'une question à l'utilisateur. La question n'est pas affichée jusqu'à ce que la commande GO soit lancée ; cela permet de lancer plusieurs commandes INPUT en série, pour construire un jeu de questions qui pourraient toutes être posées sur un seul écran.

note: type: Plain text
en: The priority field tells debconf how important it is that this question be shown to the user. The priority values are:
fr: Le champ priorité indique à debconf s'il est important que la question soit posée à l'utilisateur ou non. Les priorités sont :

note: type: Plain text
en: Very trivial items that have defaults that will work in the vast majority of cases; only control freaks see these.
fr: Éléments peu importants dont la valeur par défaut convient dans la majorité des cas ; seuls ceux qui veulent tout contrôler les voient ;

note: type: Plain text
en: Normal items that have reasonable defaults.
fr: Éléments normaux qui ont une valeur par défaut raisonnable ;

note: type: Plain text
en: Items that don't have a reasonable default.
fr: Éléments qui n'ont pas de valeur par défaut raisonnable ;

note: type: Plain text
en: Items that will probably break the system without user intervention.
fr: Éléments qui peuvent probablement casser le système sans l'intervention de l'utilisateur.

note: type: Plain text
en: Debconf decides if the question is actually displayed, based on its priority, and whether the user has seen it before, and which frontend is being used. If the question will not be displayed, debconf replies with code 30.
fr: Pour décider si la question doit être affichée ou non, debconf se base sur sa priorité, si l'utilisateur l'a déjà vue et l'interface qui va être utilisée. Si la question n'est pas à afficher, debconf retournera un code de retour égal à 30.

note: type: Plain text
en: Tells debconf to display the accumulated set of questions (from INPUT commands) to the user.
fr: Cette commande demande à debconf d'afficher les questions accumulées (depuis les commandes INPUT).

note: type: Plain text
en: If the backup capability is supported and the user indicates they want to back up a step, debconf replies with code 30.
fr: Si la fonctionnalité de sauvegarde est supportée et si l'utilisateur indique qu'il veut revenir à une étape précédente, debconf répondra avec un code de retour égal à 30.

note: type: Plain text
en: Clears the accumulated set of questions (from INPUT commands) without displaying them.
fr: Élimine les questions accumulées (avec les commandes INPUT) sans les afficher.

note: type: Plain text
en: Some debconf frontends can display a number of questions to the user at once.  Maybe in the future a frontend will even be able to group these questions into blocks on screen. BEGINBLOCK and ENDBLOCK can be placed around a set of INPUT commands to indicate blocks of questions (and blocks can even be nested). Since no debconf frontend is so sophisticated yet, these commands are ignored for now.
fr: Certaines interfaces peuvent afficher plusieurs questions à l'utilisateur en même temps. Peut-être qu'à l'avenir une interface pourra regrouper ces questions en blocs sur l'écran. BEGINBLOCK et ENDBLOCK peuvent être placées autour de plusieurs commandes INPUT pour indiquer des blocs de questions (les blocs peuvent même être emboîtés). Étant donné qu'aucune interface n'est encore aussi sophistiquée, ces commandes sont pour l'instant ignorées.

note: type: Plain text
en: This command tells debconf that you're done talking to it. Often debconf can detect termination of your program and this command is not necessary.
fr: Cette commande dit à debconf que vous avez fini de communiquer avec lui. En général, debconf peut détecter la fin de votre programme, cette commande n'est donc pas nécessaire.

note: type: Plain text
en: After using INPUT and GO to display a question, you can use this command to get the value the user entered. The value is returned in the extended result code.
fr: Après avoir utilisé INPUT et GO pour afficher une question, vous pouvez utiliser cette commande pour récupérer la valeur indiquée par l'utilisateur. Cette valeur est renvoyée dans le code de retour étendu.

note: type: TP
en: B<SET question value>
fr: B<SET question valeur>

note: type: Plain text
en: This sets the value of a question, and it can be used to override the default value with something your program calculates on the fly.
fr: Cette commande positionne la valeur d'une question et peut être utilisée pour remplacer la valeur par défaut avec une valeur que votre programme calcule à la volée.

note: type: Plain text
en: This resets the question to its default value (as is specified in the 'Default' field of its template).
fr: Cela remet la question à sa valeur par défaut (comme il est spécifié dans le champ « Default » de son message).

note: type: TP
en: B<SUBST question key value>
fr: B<SUBST question clé valeur>

note: type: Plain text
en: Questions can have substitutions embedded in their 'Description' and 'Choices' fields (use of substitutions in 'Choices' fields is a bit of a hack though; a better mechanism will eventually be developed). These substitutions look like "${key}". When the question is displayed, the substitutions are replaced with their values. This command can be used to set the value of a substitution. This is useful if you need to display some message to the user that you can't hard-code in the templates file.
fr: Des questions peuvent avoir des substitutions incluses dans leurs champs « Description » et « Choices » (l'utilisation de substitutions dans les champs « Choices » fait un peu bidouillage, un meilleur mécanisme sera développé). Ces substitutions ressemblent à « ${key} ». Quand les questions sont affichées, les substitutions sont remplacées par leurs valeurs. Cette commande peut être utilisée pour fixer la valeur d'une substitution. Cela peut être utile si vous avez besoin d'afficher à l'utilisateur des messages que vous ne pouvez pas mettre dans le fichier templates.

note: type: Plain text
en: Do not try to use SUBST to change the default value of a question; it won't work since there is a SET command explicitly for that purpose.
fr: N'essayez pas d'utiliser SUBST pour changer la valeur par défaut d'une question ; cela ne fonctionnera pas puisqu'il y a la commande SET prévue à cet effet.

note: type: TP
en: B<FGET question flag>
fr: B<FGET question marque>

note: type: Plain text
en: Questions can have flags associated with them. The flags can have a value of "true" or "false". This command returns the value of a flag.
fr: Une marque peut être associée à une question. Les marques peuvent avoir une valeur « true » ou « false ». Cette commande renvoie la valeur de la marque.

note: type: TP
en: B<FSET question flag value>
fr: B<FSET question marque valeur>

note: type: Plain text
en: This sets the value of a question's flag. The value must be either "true" or "false".
fr: Cela fixe la valeur de la marque d'une question. La valeur est soit « true » soit « false ».

note: type: Plain text
en: One common flag is the "seen" flag. It is normally only set if a user has already seen a question. Debconf usually only displays questions to users if they have the seen flag set to "false" (or if it is reconfiguring a package).  Sometimes you want the user to see a question again -- in these cases you can set the seen flag to false to force debconf to redisplay it.
fr: La marque « seen » est courante. Elle n'est normalement positionnée que si un utilisateur a déjà vu la question. Habituellement, debconf affiche à l'utilisateur seulement les questions dont la marque « seen » est positionnée à « false » (ou si vous reconfigurez un paquet). Quelquefois vous voulez que l'utilisateur revoie une question -- dans ce cas vous pouvez positionner la marque « seen » à false pour forcer debconf à l'afficher à nouveau.

note: type: TP
en: B<METAGET question field>
fr: B<METAGET question champ>

note: type: Plain text
en: This returns the value of any field of a question's associated template (the Description, for example).
fr: Cela renvoie la valeur d'un champ d'une question associée à un message (le champ Description, par exemple).

note: type: TP
en: B<REGISTER template question>
fr: B<REGISTER message question>

note: type: Plain text
en: This creates a new question that is bound to a template. By default each template has an associated question with the same name. However, any number of questions can really be associated with a template, and this lets you create more such questions.
fr: Cela crée une nouvelle question qui est liée à un message. Par défaut, chaque message possède une question du même nom qui lui est associée.  Toutefois, on peut associer autant de questions que l'on veut à un message et cela permet de créer beaucoup de questions.

note: type: Plain text
en: This removes a question from the database.
fr: Cela retire une question de la base de données.

note: type: Plain text
en: Call this in your postrm when your package is purged. It removes all of your package's questions from debconf's database.
fr: Appelez cette commande dans votre script postrm lorsque votre paquet est purgé. Il retire toutes les questions concernant votre paquet de la base de données de debconf.

note: type: Plain text
en: This extension loads the specified template file into debconf's database.  The owner defaults to the package that is being configured with debconf.
fr: Cette extensions charge le fichier de modèle spécifié dans la base de données de debconf. Le propriétaire assume que le paquet est en cours de configuration avec debconf.

note: type: Plain text
en: Here is a simple example of the debconf protocol in action.
fr: Voici un exemple simple du protocole debconf en action.

note: type: Plain text
en:   INPUT medium debconf/frontend
      30 question skipped
      FSET debconf/frontend seen false
      0 false
      INPUT high debconf/frontend
      0 question will be asked
      GO
      [ Here debconf displays a question to the user. ]
      0 ok
      GET no/such/question
      10 no/such/question doesn't exist
      GET debconf/frontend
      0 Dialog
fr:   INPUT medium debconf/frontend
      30 question skipped
      FSET debconf/frontend seen false
      0 false
      INPUT high debconf/frontend
      0 question will be asked
      GO
      [ debconf affiche ici une question à l'utilisateur. ]
      0 ok
      GET no/such/question
      10 no/such/question doesn't exist
      GET debconf/frontend
      0 Dialog

note: type: SH
en: LIBRARIES
fr: BIBLIOTHÈQUES

note: type: Plain text
en: Setting things up so you can talk to debconf, and speaking the debconf protocol by hand is a little too much work, so some thin libraries exist to relieve this minor drudgery.
fr: Comme parler directement à debconf via son protocole représente trop de travail, il existe quelques bibliothèques pour vous épargner cette tâche ingrate.

note: type: Plain text
en: For shell programming, there is the /usr/share/debconf/confmodule library, which you can source at the top of a shell script, and talk to debconf in a fairly natural way, using lower-case versions of the debconf protocol commands, that are prefixed with "db_" (ie, "db_input" and "db_go"). For details, see B<confmodule>(3)  .
fr: Pour la programmation shell, il y a la bibliothèque /usr/share/debconf/confmodule que vous pouvez inclure en début d'un script shell ; vous pourrez communiquer avec debconf de façon presque naturelle en utilisant la version en minuscules des commandes du protocole debconf qui sont préfixées de « db_ » (par ex. « db_input » et « db_go »). Pour plus de précisions veuillez consulter B<confmodule>(3).

note: type: Plain text
en: Perl programmers can use the B<Debconf::Client::ConfModule>(3pm)  perl module, and python programmers can use the debconf python module.
fr: Les programmeurs Perl peuvent utiliser le module perl B<Debconf::Client::ConfModule>(3pm) et les programmeurs Python peuvent utiliser le module python debconf.

note: type: Plain text
en: The rest of this manual will use the /usr/share/debconf/confmodule library in example shell scripts. Here is an example config script using that library, that just asks a question:
fr: Le reste de ce manuel utilisera la bibliothèque /usr/share/debconf/confmodule dans des scripts shell à titre d'exemple. Voici un exemple de script config utilisant cette bibliothèque, il pose seulement une question :

note: type: Plain text
en: Notice the uses of "|| true" to prevent the script from dying if debconf decides it can't display a question, or the user tries to back up. In those situations, debconf returns a non-zero exit code, and since this shell script is set -e, an untrapped exit code would make it abort.
fr: Remarquez l'utilisation de « || true » pour éviter que le script ne meurt si debconf décide qu'il ne peut pas afficher une question, ou si l'utilisateur essaie de revenir en arrière. Dans ces situations, debconf renvoie un code de retour non nul et puisque set -e est positionné dans ce script shell, un code de retour non intercepté le fera abandonner.

note: type: Plain text
en: And here is a corresponding postinst script, that uses the user's answer to the question to see if the system should be rebooted (a rather absurd example..):
fr: Et voici le script postinst correspondant, qui utilise la réponse à la question de l'utilisateur pour voir si le système doit être redémarré (un exemple plutôt stupide) :

note: type: Plain text
en: Notice the use of the $RET variable to get at the extended return code from the GET command, which holds the user's answer to the question.
fr: Remarquez l'utilisation de la variable $RET pour récupérer le code de retour étendu de la commande GET, qui contient la réponse de l'utilisateur à la question.

note: type: SH
en: THE POSTINST SCRIPT
fr: LE SCRIPT POSTINST

note: type: Plain text
en: The last section had an example of a postinst script that uses debconf to get the value of a question, and act on it. Here are some things to keep in mind when writing postinst scripts that use debconf:
fr: La dernière section avait un exemple de script postinst qui utilise debconf pour récupérer la valeur d'une question et agir selon elle. Voici quelques remarques à garder à l'esprit lors de l'écriture des scripts postinst qui utilisent debconf :

note: type: Plain text
en: Avoid asking questions in the postinst. Instead, the config script should ask questions using debconf, so that pre-configuration will work.
fr: évitez de poser des questions dans le script postinst. Le script config devrait poser ces questions à sa place en utilisant debconf, pour que la pré-configuration fonctionne par la suite ;

note: type: Plain text
en: Always source /usr/share/debconf/confmodule at the top of your postinst, even if you won't be running any db_* commands in it.  This is required to make sure the config script gets a chance to run (see HACKS for details).
fr: incluez toujours /usr/share/debconf/confmodule au début de votre script postinst, même si vous ne lancez aucune des commandes db_*. C'est nécessaire pour s'assurer que le script config sera bien lancé (veuillez consulter la section BIDOUILLES pour plus de détails) ;

note: type: Plain text
en: Avoid outputting anything to stdout in your postinst, since that can confuse debconf, and postinst should not be verbose anyway. Output to stderr is ok, if you must.
fr: évitez d'afficher quelque chose sur la sortie standard dans votre script postinst, puisque cela peut perturber debconf ; le script postinst ne devrait de toute façon pas être bavard. L'affichage sur la sortie d'erreur est autorisé, si vous le devez ;

note: type: Plain text
en: If your postinst launches a daemon, make sure you tell debconf to STOP at the end, since debconf can become a little confused about when your postinst is done otherwise.
fr: si votre script postinst lance un démon, soyez sûr de dire à debconf de STOPper à la fin, car debconf peut avoir du mal à détecter la fin du script postinst ;

note: type: Plain text
en: Make your postinst script accept a first parameter of "reconfigure". It can treat it just like "configure". This will be used in a later version of debconf to let postinsts know when they are reconfigured.
fr: faites accepter à votre script postinst un premier paramètre « reconfigure ». Il peut le traiter comme « configure ». Cela sera utilisé dans une version ultérieure de debconf pour permettre aux scripts postinst de savoir quand ils sont reconfigurés.

note: type: SH
en: OTHER SCRIPTS
fr: AUTRES SCRIPTS

note: type: Plain text
en: Besides the config script and postinst, you can use debconf in any of the other maintainer scripts. Most commonly, you'll be using debconf in your postrm, to call the PURGE command when your package is purged, to clean out its entries in the debconf database. (This is automatically set up for you by B<dh_installdebconf>(1)B<,> by the way.)
fr: En plus des scripts config et postinst, vous pouvez utiliser debconf dans tout autre script d'administration. En général, vous utiliserez debconf dans votre script postrm, pour appeler la commande PURGE quand votre paquet est purgé, pour vider ses entrées dans la base de données de debconf. En fait, cela est automatiquement configuré pour vous par B<dh_installdebconf>(1)B<.>

note: type: Plain text
en: A more involved use of debconf would be if you want to use it in the postrm when your package is purged, to ask a question about deleting something. Or maybe you find you need to use it in the preinst or prerm for some reason. All of these uses will work, though they'll probably involve asking questions and acting on the answers in the same program, rather than separating the two activities as is done in the config and postinst scripts.
fr: Un emploi plus sophistiqué de debconf serait de l'utiliser dans le script postrm lors de la purge de votre paquet, pour poser une question concernant la suppression de quelque chose. Ou peut-être avez-vous besoin de l'utiliser dans les scripts preinst ou prerm pour quelque raison que ce soit. Toutes ces utilisations fonctionneront, bien qu'elles impliqueront probablement de poser une question et d'agir en fonction de la réponse dans le même programme, plutôt que de séparer les deux actions comme dans les scripts config et postinst.

note: type: Plain text
en: Note that if your package's sole use of debconf is in the postrm, you should make your package's postinst source /usr/share/debconf/confmodule, to give debconf a chance to load up your templates file into its database. Then the templates will be available when your package is being purged.
fr: Notez que si votre paquet n'utilise debconf que dans le script postrm, vous devriez faire en sorte que le script postinst de votre paquet inclue /usr/share/debconf/confmodule, pour que debconf puisse charger votre fichier templates dans sa base de données. Le questionnaire sera alors disponible lorsque votre paquet sera purgé.

note: type: Plain text
en: You can also use debconf in other, standalone programs. The issue to watch out for here is that debconf is not intended to be, and must not be used as a registry. This is unix after all, and programs are configured by files in /etc, not by some nebulous debconf database (that is only a cache anyway and might get blown away). So think long and hard before using debconf in a standalone program.
fr: Vous pouvez aussi utiliser debconf dans d'autres programmes indépendants. Le seul problème est que debconf n'est pas conçu pour être un système d'enregistrement et ne peut pas être utilisé comme tel. La philosophie d'Unix est préservée, les programmes sont configurés à l'aide de fichiers dans /etc, et non pas par une sombre base de données debconf (ce n'est qu'un cache et il peut se volatiliser). Réfléchissez donc longuement avant d'utiliser debconf dans un programme indépendant.

note: type: Plain text
en: There are times when it can make sense, as in the apt-setup program which uses debconf to prompt the user in a manner consistent with the rest of the debian install process, and immediately acts on their answers to set up apt's sources.list.
fr: Cela peut prendre un sens dans certains cas, comme dans le programme apt-setup qui utilise debconf pour interroger l'utilisateur de manière cohérente avec le reste de la procédure d'installation de Debian et qui agit immédiatement avec les réponses pour configurer le fichier sources.list.

note: type: SH
en: LOCALIZATION
fr: LOCALISATION

note: type: Plain text
en: Debconf supports localization of templates files. This is accomplished by adding more fields, with translated text in them. Any of the fields can be translated. For example, you might want to translate the description into Spanish. Just make a field named 'Description-es' that holds the translation. If a translated field is not available, debconf falls back to the normal English field.
fr: Debconf accepte la localisation des fichiers templates. Cela est accompli en ajoutant d'autres champs contenant les traductions. Tous les champs peuvent être traduits. Par exemple, vous pourriez avoir envie de traduire la description en espagnol. Créez simplement un champ nommé « Description-es » contenant la traduction. Si un champ traduit n'est pas disponible, debconf utilise le champ anglais.

note: type: Plain text
en: Besides the 'Description' field, you should translate the 'Choices' field of a select or multiselect template. Be sure to list the translated choices in the same order as they appear in the main 'Choices' field. You do not need to translate the 'Default' field of a select or multiselect question, and the value of the question will be automatically returned in English.
fr: En plus du champ « Description », vous devriez traduire le champ « Choices » d'un message de type select ou multiselect. Il faut lister les choix traduits dans l'ordre dans lequel ils apparaissent dans le champ « Choices » principal. Vous ne devriez pas avoir besoin de traduire le champ « Default » d'une question de type select ou multiselect et la valeur de la question sera automatiquement retournée en anglais.

note: type: Plain text
en: You will find it easier to manage translations if you keep them in separate files; one file per translation. In the past, the B<debconf-getlang>(1)  and B<debconf-mergetemplate>(1)  programs were used to manage debian/template.ll files. This has been superseded by the B<po-debconf>(7)  package, which lets you deal with debconf translations in .po files, just like any other translations. Your translators will thank you for using this new improved mechanism.
fr: Vous trouverez sûrement plus facile de gérer les traductions si vous les conservez dans des fichiers séparés ; un fichier par traduction. Par le passé, les programmes B<debconf-getlang>(1) et B<debconf-mergetemplate>(1) étaient utilisés pour gérer les fichiers debian/templates.ll. Cela a été rendu obsolète par le paquet B<po-debconf>(7), qui permet de traiter les traductions des questionnaires debconf avec des fichiers .po comme les autres traductions. Vos traducteurs vous remercieront pour l'utilisation de ce nouveau mécanisme performant.

note: type: Plain text
en: For the details on po-debconf, see its man page. If you're using debhelper, converting to po-debconf is as simple as running the B<debconf-gettextize>(1)  command once, and adding a Build-Dependency on po-debconf and on debhelper (E<gt>= 4.1.13).
fr: Pour plus de précisions sur po-debconf, consultez sa page de manuel. Si vous utilisez debhelper, la conversion vers po-debconf est aussi simple que de lancer la commande B<debconf-gettextize>(1) une fois et d'ajouter une dépendance de construction (« Build-Depends »)  sur po-debconf et sur debhelper (E<gt>= 4.1.13).

note: type: SH
en: PUTTING IT ALL TOGETHER
fr: RÉCAPITULATION

note: type: Plain text
en: So you have a config script, a templates file, a postinst script that uses debconf, and so on. Putting these pieces together into a debian package isn't hard. You can do it by hand, or can use B<dh_installdebconf>(1)  which will merge your translated templates, copy the files into the right places for you, and can even generate the call to PURGE that should go in your postrm script. Make sure that your package depends on debconf (E<gt>= 0.5), since earlier versions were not compatible with everything described in this manual. And you're done.
fr: Donc vous avez un script config, un fichier templates, un script postinst qui utilisent debconf, etc. Réunir tous ces scripts dans un paquet Debian n'est pas difficile. Vous pouvez le faire à la main ou utiliser B<dh_installdebconf>(1) qui fusionne vos questions-modèles traduites, copie les fichiers à la bonne place pour vous et peut même générer l'appel à PURGE qui devrait être placé dans votre script postrm. Assurez-vous que votre paquet dépende de debconf (E<gt>= 0.5), puisque les anciennes versions n'étaient pas compatibles avec tout ce qui est décrit dans ce manuel. Et c'est terminé !

note: type: Plain text
en: Well, except for testing, debugging, and actually using debconf for more interesting things than asking a few basic questions. For that, read on..
fr: Mais vous ne pouvez pas encore tester, déboguer et utiliser debconf pour des choses plus intéressantes que de poser de simples questions. Pour cela, veuillez continuer à lire.

note: type: SH
en: DEBUGGING
fr: DÉBOGAGE

note: type: Plain text
en: So you have a package that's supposed to use debconf, but it doesn't quite work. Maybe debconf is just not asking that question you set up. Or maybe something weirder is happening; it spins forever in some kind of loop, or worse. Luckily, debconf has plenty of debugging facilities.
fr: Vous avez donc un paquet qui est supposé utiliser debconf, mais il ne fonctionne pas très bien. Peut-être que debconf ne pose pas la question que vous avez configurée. Ou peut-être que quelque chose d'étrange arrive ; il entre dans une boucle infinie, ou pire encore. Heureusement, debconf possède beaucoup de possibilités de débogage.

note: type: Plain text
en: The first thing to reach for is the DEBCONF_DEBUG environment variable.  If you set and export DEBCONF_DEBUG=developer, debconf will output to stderr a dump of the debconf protocol as your program runs. It'll look something like this -- the typo is made clear:
fr: La première chose à portée de main est la variable d'environnement DEBCONF_DEBUG. Si vous positionnez et exportez DEBCONF_DEBUG=developer, debconf affichera sur la sortie d'erreur standard (« stderr ») une copie du protocole debconf lorsque votre programme s'exécute. Elle ressemblera à quelque chose comme ceci -- la faute est flagrante :

note: type: Plain text
en: It's rather useful to use debconf's readline frontend when you're debugging (in the author's opinion), as the questions don't get in the way, and all the debugging output is easily preserved and logged.
fr: Lors d'un débogage, l'interface readline de debconf est très utile (d'après l'auteur), car les questions ne masquent pas cet affichage, toute la sortie du débogage est facilement préservée et enregistrée.

note: type: Plain text
en: If this environment variable is set to 'true', the frontend will display the values in Choices-C fields (if present) of select and multiselect templates rather than the descriptive values.
fr: Si cette variable d'environnement est définie à « true », l'interface graphique affichera les valeurs dans les champs « Choices-C » (s'ils sont présents) des modèles select et multi-select au lieu des valeurs compréhensibles.

note: type: Plain text
en: Another useful tool is the B<debconf-communicate>(1)  program. Fire it up and you can speak the raw debconf protocol to debconf, interactively. This is a great way to try stuff out on the fly.
fr: B<debconf-communicate>(1) est un autre programme utile. Lancez-le et vous pourrez parler le protocole debconf brut à debconf. C'est une bonne manière d'essayer des choses à la volée.

note: type: Plain text
en: If a user is reporting a problem, B<debconf-show>(1)  can be used to dump out all the questions owned by your package, displaying their values and whether the user has seen them.
fr: Si un utilisateur rapporte un problème, B<debconf-show>(1) peut être utilisé pour lister les questions de votre paquet, en affichant leurs valeurs et en indiquant si l'utilisateur les a déjà vues.

note: type: Plain text
en: To avoid the often tedious build/install/debug cycle, it can be useful to load up your templates with B<debconf-loadtemplate>(1)  and run your config script by hand with the B<debconf>(1)  command. However, you still have to do that as root, right? Not so good.  And ideally you'd like to be able to see what a fresh installation of your package looks like, with a clean debconf database.
fr: Pour éviter le cycle ennuyeux construction/installation/débogage, il peut être utile de charger vos questionnaires avec B<debconf-loadtemplate>(1) et de lancer votre script config à la main avec la commande B<debconf>(1).  Néanmoins, vous devez toujours le faire en tant que superutilisateur, d'accord ? Pas terrible ! Et idéalement vous souhaiteriez être en mesure de voir à quoi ressemble une installation toute fraîche de votre paquet avec une base de données debconf propre.

note: type: Plain text
en: It turns out that if you set up a ~/.debconfrc file for a normal user, pointing at a personal config.dat and template.dat for the user, you can load up templates and run config scripts all you like, without any root access. If you want to start over with a clean database, just blow away the *.dat files.
fr: Il s'avère que si vous configurez un fichier ~/.debconfrc pour un utilisateur normal, pointant vers un config.dat et un template.dat propres à l'utilisateur, vous pouvez charger les questionnaires et lancer tous les scripts config que vous voulez, sans avoir besoin d'un accès super-utilisateur. Si vous voulez commencer avec une base de données propre, supprimez simplement les fichiers *.dat.

note: type: Plain text
en: For details about setting this up, see B<debconf.conf>(5)B<,> and note that /etc/debconf.conf makes a good template for a personal ~/.debconfrc file.
fr: Pour plus de détails pour mettre cela en place, voyez B<debconf.conf>(5)B<,> et remarquez que /etc/debconf.conf fait un bon modèle pour un fichier ~/.debconfrc personnel.

note: type: SH
en: ADVANCED PROGRAMMING WITH DEBCONF
fr: PROGRAMMATION AVANCÉE AVEC DEBCONF

note: type: SS
en: Config file handling
fr: Manipulation du fichier de configuration

note: type: Plain text
en: Many of you seem to want to use debconf to help manage config files that are part of your package. Perhaps there is no good default to ship in a conffile, and so you want to use debconf to prompt the user, and write out a config file based on their answers. That seems easy enough to do, but then you consider upgrades, and what to do when someone modifies the config file you generate, and dpkg-reconfigure, and ...
fr: Beaucoup d'entre vous ont l'air de vouloir utiliser debconf pour aider à la gestion des fichiers de configuration contenus dans vos paquets. Peut-être qu'il n'y a pas de bonne valeur par défaut à inclure dans votre paquet, vous voulez donc utiliser debconf pour interroger l'utilisateur et écrire un fichier de configuration basé sur ses réponses. Cela semble assez facile à faire, mais lorsque vous considérez les mises à niveau, que faire lorsque quelqu'un modifie le fichier de configuration que vous générez, et dpkg-reconfigure, et...

note: type: Plain text
en: There are a lot of ways to do this, and most of them are wrong, and will often earn you annoyed bug reports. Here is one right way to do it. It assumes that your config file is really just a series of shell variables being set, with comments in between, and so you can just source the file to "load" it.  If you have a more complicated format, reading (and writing) it becomes a bit trickier.
fr: Il y a beaucoup de manières de le faire, la plupart d'entre-elles ne sont pas correctes et vous serez souvent ennuyé par des rapports de bogue. Voici une manière correcte de le faire. Cela suppose que votre fichier config n'est composé que d'une série de variables de shell positionnées, avec des commentaires entre elles, vous pouvez simplement inclure le fichier pour le « charger ». Si vous avez un format plus compliqué, sa lecture (et son écriture) devient un peu plus délicate.

note: type: Plain text
en: Your config script will look something like this:
fr: Votre script config ressemblera à quelque chose comme ça :

note: type: Plain text
en:  # Load config file, if it exists.
     if [ -e $CONFIGFILE ]; then
     	. $CONFIGFILE || true
fr:  # charge le fichier de configuration, s'il existe.
     if [ -e $CONFIGFILE ]; then
     	. $CONFIGFILE || true

note: type: Plain text
en:  	# Store values from config file into
     	# debconf db.
     	db_set mypackage/foo "$FOO"
     	db_set mypackage/bar "$BAR"
     fi
fr: 	# Enregistrer les valeurs du fichier de configuration
     	# dans la base de données de debconf
     	db_set mypackage/toto "$FOO"
     	db_set mypackage/titi "$BAR"
     fi

note: type: Plain text
en:  # Ask questions.
     db_input medium mypackage/foo || true
     db_input medium mypackage/bar || true
     db_go || true
fr:  # Poser les questions.
     db_input medium mypackage/toto || true
     db_input medium mypackage/titi || true
     db_go || true

note: type: Plain text
en: And the postinst will look something like this:
fr: Et le script postinst ressemblera à quelque chose comme ceci :

note: type: Plain text
en:  # Generate config file, if it doesn't exist.
     # An alternative is to copy in a template
     # file from elsewhere.
     if [ ! -e $CONFIGFILE ]; then
     	echo "# Config file for my package" E<gt> $CONFIGFILE
     	echo "FOO=" E<gt>E<gt> $CONFIGFILE
     	echo "BAR=" E<gt>E<gt> $CONFIGFILE
     fi
fr:  # Générer un fichier de configuration, s'il n'en existe pas.
     # Une alternative est d'effectuer une copie dans un fichier
     # modèle depuis un autre endroit.
     if [ ! -e $CONFIGFILE ]; then
     	echo "# Fichier de configuration pour mon paquet" E<gt> $CONFIGFILE
     	echo "TOTO=" E<gt>E<gt> $CONFIGFILE
     	echo "TITI=" E<gt>E<gt> $CONFIGFILE
     fi

note: type: Plain text
en:  # Substitute in the values from the debconf db.
     # There are obvious optimizations possible here.
     # The cp before the sed ensures we do not mess up
     # the config file's ownership and permissions.
     db_get mypackage/foo
     FOO="$RET"
     db_get mypackage/bar
     BAR="$RET"
     cp -a -f $CONFIGFILE $CONFIGFILE.tmp
fr:  # Substituer les valeurs par celles de la base
     # de données de debconf. Des optimisations
     # évidentes sont possibles ici. Le cp avant
     # le sed permet de s'assurer que l'on ne détruit
     # pas le système des droits du fichier config.
     db_get mypackage/foo
     TOTO="$RET"
     db_get mypackage/bar
     TITI="$RET"
     cp -a -f $CONFIGFILE $CONFIGFILE.tmp

note: type: Plain text
en:  # If the admin deleted or commented some variables but then set
     # them via debconf, (re-)add them to the conffile.
     test -z "$FOO" || grep -Eq '^ *FOO=' $CONFIGFILE || \e
     	echo "FOO=" E<gt>E<gt> $CONFIGFILE
     test -z "$BAR" || grep -Eq '^ *BAR=' $CONFIGFILE || \e
     	echo "BAR=" E<gt>E<gt> $CONFIGFILE
fr:  # Si l'administrateur a supprimé ou commenté des variables mais
     # les a ensuite définies via debconf, ajouter (à nouveau) au
     # fichier de configuration (conffile).
     test -z "$TOTO" || grep -Eq '^ *TOTO=' $CONFIGFILE || \e
     	echo "TOTO=" E<gt>E<gt> $CONFIGFILE
     test -z "$TITI" || grep -Eq '^ *TITI=' $CONFIGFILE || \e
     	echo "TITI=" E<gt>E<gt> $CONFIGFILE

note: type: Plain text
en:  sed -e "s/^ *FOO=.*/FOO=\e"$FOO\e"/" \e
         -e "s/^ *BAR=.*/BAR=\e"$BAR\e"/" \e
         E<lt> $CONFIGFILE E<gt> $CONFIGFILE.tmp
     mv -f $CONFIGFILE.tmp $CONFIGFILE
fr:  sed -e "s/^ *TOTO=.*/TOTO=\e"$TOTO\e"/" \e
         -e "s/^ *TITI=.*/TITI=\e"$TITI\e"/" \e
         E<lt> $CONFIGFILE E<gt> $CONFIGFILE.tmp
     mv -f $CONFIGFILE.tmp $CONFIGFILE

note: type: Plain text
en: Consider how these two scripts handle all the cases. On fresh installs the questions are asked by the config script, and a new config file generated by the postinst. On upgrades and reconfigures, the config file is read in, and the values in it are used to change the values in the debconf database, so the admin's manual changes are not lost. The questions are asked again (and may or may not be displayed). Then the postinst substitutes the values back into the config file, leaving the rest of it unchanged.
fr: Examinez comment ces deux scripts gèrent tous les cas. Sur une nouvelle installation, les questions sont posées par le script config et un nouveau fichier de configuration est généré par le script postinst. Pendant les mises à niveau et les reconfigurations, le fichier config est lu, et ses valeurs sont utilisées pour modifier les valeurs dans la base de données de debconf : les modifications manuelles de l'administrateur ne sont donc pas perdues. Les questions sont posées à nouveau (et peuvent être affichées ou non). Puis le script postinst remplace les valeurs dans le fichier config, en laissant le reste du fichier inchangé.

note: type: SS
en: Letting the user back up
fr: Permettre à l'utilisateur de revenir en arrière

note: type: Plain text
en: Few things are more frustrating when using a system like debconf than being asked a question, and answering it, then moving on to another screen with a new question on it, and realizing that hey, you made a mistake, with that last question, and you want to go back to it, and discovering that you can't.
fr: Peu de choses sont plus frustrantes, quand vous utilisez un système comme debconf, que de répondre à une question posée, puis de passer à un autre écran avec une nouvelle question, de réaliser alors que vous avez fait une erreur dans la dernière question et que vous voulez y retourner mais vous découvrez que vous ne le pouvez pas.

note: type: Plain text
en: Since debconf is driven by your config script, it can't jump back to a previous question on its own but with a little help from you, it can accomplish this feat. The first step is to make your config script let debconf know it is capable of handling the user pressing a back button.  You use the CAPB command to do this, passing backup as a parameter.
fr: Puisque debconf est conduit par votre script config, il ne peut revenir seul à une question précédente, mais avec un petit coup de pouce de votre part, il peut le faire. La première étape est que votre script config fasse savoir à debconf qu'il est capable de gérer le fait que l'utilisateur presse un bouton de retour en arrière. Vous utiliserez la commande CAPB pour le faire en passant backup en paramètre.

note: type: Plain text
en: Then after each GO command, you must test to see if the user asked to back up (debconf returns a code of 30), and if so jump back to the previous question.
fr: Puis, après chaque commande GO, vous devez essayer de voir si l'utilisateur a demandé à revenir en arrière (debconf renvoie un code de retour 30) et si c'est le cas, revenir à la question précédente.

note: type: Plain text
en: There are several ways to write the control structures of your program so it can jump back to previous questions when necessary. You can write goto-laden spaghetti code. Or you can create several functions and use recursion. But perhaps the cleanest and easiest way is to construct a state machine. Here is a skeleton of a state machine that you can fill out and expand.
fr: Il existe plusieurs manières d'écrire des structures de contrôle pour que votre programme puisse revenir aux questions antérieures lorsque c'est nécessaire. Vous pouvez écrire du code spaghetti plein de goto. Ou vous pouvez créer plusieurs fonctions et les utiliser de manière récursive. Mais peut-être que la façon la plus correcte et la plus simple est de construire une machine à états. Voici le squelette d'une machine à états que vous pouvez remplir et améliorer.

note: type: Plain text
en:  STATE=1
     while true; do
     	case "$STATE" in
      	1)
      		# Two unrelated questions.
     		db_input medium my/question || true
     		db_input medium my/other_question || true
     	;;
     	2)
     		# Only ask this question if the
     		# first question was answered in
     		# the affirmative.
            	db_get my/question
     		if [ "$RET" = "true" ]; then
     			db_input medium my/dep_question || true
     		fi
      	;;
     	*)
     		# The default case catches when $STATE is greater than the
     		# last implemented state, and breaks out of the loop. This
     		# requires that states be numbered consecutively from 1
     		# with no gaps, as the default case will also be entered
     		# if there is a break in the numbering
     		break # exits the enclosing "while" loop
      	;;
      	esac
fr:  STATE=1
     while true; do
     	case "$STATE" in
     	1)
     		# Deux questions sans rapport.
     		db_input medium ma/question || true
     		db_input medium mon/autre_question || true
     	;;
     	2)
     		# Ne poser cette question que si la
     		# réponse à la première question était oui.
            	db_get ma/question
     		if [ "$RET" = "true" ]; then
     			db_input medium ma/question_dependante || true
     		fi
     	;;
     	*)
     		# Le cas par défaut est atteint quand $STATE est plus
     		# grand que le dernier état implémenté, et provoque la
     		# sortie de la boucle. Ceci requiert que les état soient
     		# numérotés à partir de 1, successivement, et sans trou, 
     		# puisque l'on entrera dans le cas par défaut s'il y a un
     		# trou dans la numérotation
     		break # quitte la boucle "while"
     	;;
     	esac

note: type: Plain text
en:  if [ $STATE -eq 0 ]; then
     	# The user has asked to back up from the first
     	# question. This case is problematical. Regular
     	# dpkg and apt package installation isn't capable
     	# of backing up questions between packages as this
     	# is written, so this will exit leaving the package
     	# unconfigured - probably the best way to handle
     	# the situation.
     	exit 10
     fi
fr:  if [ $STATE -eq 0 ]; then
     	# L'utilisateur a demandé à revenir à la première
     	# question. Ce cas est problématique. L'installation
     	# normale des paquets avec dpkg et apt n'est pas
     	# capable de revenir en arrière vers les questions
     	# d'autres paquets, à l'heure où ceci est écrit, donc
     	# cela va provoquer la sortie, laissant les paquets non
     	# configurés - ce qui est probablement la meilleure
     	# façon de gérer la situation.
     	exit 10
     fi

note: type: Plain text
en: Note that if all your config script does is ask a few unrelated questions, then there is no need for the state machine. Just ask them all, and GO; debconf will do its best to present them all in one screen, and the user won't need to back up.
fr: Notez que si tout ce que fait votre script config est de poser quelques questions sans rapport les unes avec les autres, il n'y a pas besoin d'une machine à états. Posez simplement toutes les questions et GO ; debconf fera de son mieux pour les présenter toutes sur un écran et l'utilisateur n'aura pas besoin de revenir en arrière.

note: type: SS
en: Preventing infinite loops
fr: Éviter les boucles infinies

note: type: Plain text
en: One gotcha with debconf comes up if you have a loop in your config script. Suppose you're asking for input and validating it, and looping if it's not valid:
fr: Une chose très agaçante peut arriver avec debconf si vous avez une boucle dans votre script. Supposez que vous demandiez une entrée et que vous la validiez, ou que vous effectuiez une boucle si elle n'est pas valable :

note: type: Plain text
en:  ok=''
     do while [ ! "$ok" ];
     	db_input low foo/bar || true
     	db_go || true
     	db_get foo/bar
     	if [ "$RET" ]; then
     		ok=1
     	fi
     done
fr:  ok=\(aq\(aq
     do while [ ! "$ok" ];
     	db_input low toto/titi || true
     	db_go || true
     	db_get toto/titi
     	if [ "$RET" ]; then
     		ok=1
     	fi
     done

note: type: Plain text
en: This looks ok at first glance. But consider what happens if the value of foo/bar is "" when this loop is entered, and the user has their priority set high, or is using a non-interactive frontend, and so they are not really asked for input. The value of foo/bar is not changed by the db_input, and so it fails the test and loops. And loops ...
fr: Cela parait correct au premier coup d'œil. Mais pensez à ce qui va arriver si la valeur de toto/titi est "" lorsque l'on entre dans cette boucle et que l'utilisateur a fixé la priorité à high, ou s'il utilise une interface non interactive et qu'on ne lui demande donc aucune entrée. La valeur de toto/titi n'est pas changée par db_input et donc le test échoue et boucle. Et boucle...

note: type: Plain text
en: One fix for this is to make sure that before the loop is entered, the value of foo/bar is set to something that will pass the test in the loop. So for example if the default value of foo/bar is "1", then you could RESET foo/bar just before entering the loop.
fr: Une solution à ce problème est de s'assurer qu'avant l'entrée dans la boucle, la valeur de toto/titi est positionnée à quelque chose qui permettra de passer le test de la boucle. Donc par exemple si la valeur par défaut de toto/titi est « 1 », vous pourrez passer la commande RESET toto/titi juste avant d'entrer dans la boucle.

note: type: Plain text
en: Another fix is to check the return code of the INPUT command. If it is 30 then the user is not being shown the question you asked them, and you should break out of the loop.
fr: Une autre solution serait de vérifier la valeur du code de retour de la commande INPUT. Si c'est 30, l'utilisateur ne verra alors pas la question qui lui est posée et vous devriez sortir de la boucle.

note: type: SS
en: Choosing among related packages
fr: Choisir parmi plusieurs paquets liés

note: type: Plain text
en: Sometimes a set of related packages can be installed, and you want to prompt the user which of the set should be used by default. Examples of such sets are window managers, or ispell dictionary files.
fr: Parfois, un ensemble de paquets liés peuvent être installés et vous voulez demander à l'utilisateur lequel doit être utilisé par défaut. Les dictionnaires, ispell ou les gestionnaires de fenêtres sont des exemples de tels jeux de paquets.

note: type: Plain text
en: While it would be possible for each package in the set to simply prompt, "Should this package be default?", this leads to a lot of repetitive questions if several of the packages are installed. It's possible with debconf to present a list of all the packages in the set and allow the user to choose between them. Here's how.
fr: Bien qu'il pourrait être possible de simplement demander « Ce paquet doit-il être celui par défaut ? » pour chaque paquet de l'ensemble, cela aboutit à un grand nombre de questions répétitives si plusieurs de ces paquets sont installés. Avec debconf, il est possible d'afficher une liste de tous les paquets de l'ensemble et d'autoriser l'utilisateur à choisir l'un d'entre eux. Et voici comment.

note: type: Plain text
en: Make all the packages in the set use a shared template. Something like this:
fr: Utilisez un message partagé par tous les paquets de cet ensemble. Quelque chose comme ceci :

note: type: Plain text
en:  Template: shared/window-manager
     Type: select
     Choices: ${choices}
     Description: Select the default window manager.
      Select the window manager that will be started by
      default when X starts.
fr:  Template: shared/window-manager
     Type: select
     Choices: ${choices}
     Description: Choisissez une gestionnaire de fenêtres par défaut
      Veuillez choisir le gestionnaire de fenêtres qui sera démarré par défaut
      lors du lancement de X.
     Description: Select the default window manager.
      Select the window manager that will be started by
      default when X starts.

note: type: Plain text
en: Each package should include a copy of the template. Then it should include some code like this in its config script:
fr: Chaque paquet devrait inclure une copie de ce message. Puis il devrait inclure du code comme ceci dans son script config :

note: type: Plain text
en: A bit of an explanation is called for. By the time your config script runs, debconf has already read in all the templates for the packages that are being installed. Since the set of packages share a question, debconf records that fact in the owners field. By a strange coincidence, the format of the owners field is the same as that of the choices field (a comma and space delimited list of values).
fr: Une petite explication est nécessaire. Pour l'instant votre script est lancé, debconf a déjà lu tous les questionnaires des paquets qui vont être installés. Puisque tous ces paquets ont une question en commun, debconf enregistre ce fait dans le champ owners. Par une étrange coïncidence, le format du champ owners est le même que celui du champ choices (une liste de valeurs séparées par virgule et espace).

note: type: Plain text
en: The METAGET command can be used to get the list of owners and the list of choices. If they are different, then a new package has been installed. So use the SUBST command to change the list of choices to be the same as the list of owners, and ask the question.
fr: La commande METAGET peut être utilisée pour récupérer la liste des propriétaires (« owners ») et la liste des choix. S'ils sont différents, un nouveau paquet est alors installé. Utilisez alors la commande SUBST pour modifier la liste des choix afin qu'elle soit identique à celle des propriétaires et posez la question.

note: type: Plain text
en: When a package is removed, you probably want to see if that package is the currently selected choice, and if so, prompt the user to select a different package to replace it.
fr: Lorsqu'un paquet est supprimé, vous voudrez probablement voir si ce paquet est le choix actuellement sélectionné et s'il l'est, demander à l'utilisateur de sélectionner un autre paquet pour le remplacer.

note: type: Plain text
en: This can be accomplished by adding something like this to the prerm scripts of all related packages (replacing E<lt>packageE<gt> with the package name):
fr: Cela peut être accompli en ajoutant quelque chose comme ceci dans le script prerm de tous les paquets liés (en remplaçant E<lt>paquetE<gt> par le nom du paquet) :

note: type: Plain text
en:  if [ -e /usr/share/debconf/confmodule ]; then
     	. /usr/share/debconf/confmodule
     	# I no longer claim this question.
     	db_unregister shared/window-manager
fr:  if [ -e /usr/share/debconf/confmodule ]; then
     	. /usr/share/debconf/confmodule
     	# Je ne veux plus de cette question.
     	db_unregister shared/window-manager

note: type: Plain text
en:  	# See if the shared question still exists.
     	if db_get shared/window-manager; then
     		db_metaget shared/window-manager owners
     		db_subst shared/window-manager choices $RET
     		db_metaget shared/window-manager value
     		if [ "E<lt>packageE<gt>" = "$RET" ] ; then
     			db_fset shared/window-manager seen false
     			db_input high shared/window-manager || true
     			db_go || true
     		fi
fr: 	# Regarde si la question partagée existe toujours.
     	if db_get shared/window-manager; then
     		db_metaget shared/window-manager owners
     		db_subst shared/window-manager choices $RET
     		db_metaget shared/window-manager value
     		if [ "E<lt>paquetE<gt>" = "$RET" ] ; then
     			db_fset shared/window-manager seen false
     			db_input high shared/window-manager || true
     			db_go || true
     		fi

note: type: Plain text
en:  		# Now do whatever the postinst script did
     		# to update the window manager symlink.
     	fi
     fi
fr:  		# Maintenant faites ce que le script postinst faisait
     		# pour mettre à jour le lien symbolique du gestionnaire de
     		# fenêtre.
     	fi
     fi

note: type: SH
en: HACKS
fr: BIDOUILLES

note: type: Plain text
en: Debconf is currently not fully integrated into dpkg (but I want to change this in the future), and so some messy hacks are currently called for.
fr: Debconf n'est pas encore entièrement intégré à dpkg (mais je veux changer ça), cela demande donc actuellement quelques bidouilles peu propres.

note: type: Plain text
en: The worst of these involves getting the config script to run. The way that works now is the config script will be run when the package is pre-configured. Then, when the postinst script runs, it starts up debconf again. Debconf notices it is being used by the postinst script, and so it goes off and runs the config script. This can only work if your postinst loads up one of the debconf libraries though, so postinsts always have to take care to do that. We hope to address this later by adding explicit support to dpkg for debconf. The B<debconf>(1)  program is a step in this direction.
fr: Le pire de ces bidouillages est le lancement du script config. Le fonctionnement actuel est de lancer le script config lorsque le paquet est pré-configuré. Puis, lorsque le script postinst s'exécute, il lance debconf. Debconf remarque qu'il va être utilisé par le script postinst, il s'arrête et lance le script config. Cela ne fonctionne que si votre script postinst charge l'une des bibliothèques debconf, les scripts postinst doivent toujours prendre soin de les charger. Nous espérons nous attaquer à cela plus tard en ajoutant un support explicite de debconf dans dpkg. Le programme B<debconf>(1) est une étape dans ce sens.

note: type: Plain text
en: A related hack is getting debconf running when a config script, postinst, or other program that uses it starts up. After all, they expect to be able to talk to debconf right away. The way this is accomplished for now is that when such a script loads a debconf library (like /usr/share/debconf/confmodule), and debconf is not already running, it is started up, and a new copy of the script is re-execed. The only noticeable result is that you need to put the line that loads a debconf library at the very top of the script, or weird things will happen. We hope to address this later by changing how debconf is invoked, and turning it into something more like a transient daemon.
fr: Une bidouille similaire est de lancer debconf lorsqu'un script config, postinst, ou d'autres programmes qui l'utilisent commence. Après tout, ils espèrent avoir la possibilité de communiquer avec debconf d'une façon correcte. Pour l'instant, la manière dont cela est accompli est que lorsqu'un tel script charge une bibliothèque debconf (comme /usr/share/debconf/confmodule) et que debconf n'est pas déjà lancé, il est démarré et une nouvelle copie du script est ré-exécutée. Le seul résultat perceptible est que vous avez besoin de mettre la ligne qui charge une bibliothèque debconf au tout début du script, ou des choses étranges arriveront. Nous espérons examiner ça plus tard en changeant l'invocation de debconf et le changer en un démon provisoire.

note: type: Plain text
en: It's rather hackish how debconf figures out what templates files to load, and when it loads them. When the config, preinst, and postinst scripts invoke debconf, it will automatically figure out where the templates file is, and load it. Standalone programs that use debconf will cause debconf to look for templates files in /usr/share/debconf/templates/progname.templates.  And if a postrm wants to use debconf at purge time, the templates won't be available unless debconf had a chance to load them in its postinst. This is messy, but rather unavoidable. In the future some of these programs may be able to use debconf-loadtemplate by hand though.
fr: La façon dont debconf trouve quels fichiers templates charger et quand les charger ressemble vraiment à une bidouille. Lorsque les scripts config, preinst et postinst invoquent debconf, il trouvera automatiquement l'emplacement du fichier templates et le chargera. Les programmes indépendants qui utilisent debconf forceront debconf à rechercher les fichiers templates dans /usr/share/debconf/templates/nomduprog.templates. Et si un le script postrm veut utiliser debconf au moment de la purge, les questionnaires ne seront pas disponibles à moins que debconf ait une opportunité de les charger dans son script postinst. Cela n'est pas très propre mais presque inévitable. Dans le futur, certains de ces programmes pourraient malgré tout avoir la possibilité d'utiliser debconf-loadtemplate à la main.

note: type: Plain text
en: /usr/share/debconf/confmodule's historic behavior of playing with file descriptors and setting up a fd #3 that talks to debconf, can cause all sorts of trouble when a postinst runs a daemon, since the daemon ends up talking to debconf, and debconf can't figure out when the script terminates. The STOP command can work around this. In the future, we are considering making debconf communication happen over a socket or some other mechanism than stdio.
fr: Le comportement historique de /usr/share/debconf/confmodule de jouer avec les descripteurs de fichier et de configurer un descripteur de fichier spécial (« fd #3 ») qui communique avec debconf, peut causer toutes sortes de trouble lorsqu'un démon est lancé par un script postinst, puisque le démon cesse de communiquer avec debconf et que debconf ne peut pas savoir quand le script se termine. La commande STOP peut être utilisée pour ceci. Nous envisagerons plus tard de faire passer la communication avec debconf à travers une socket ou un autre mécanisme que les entrées et sorties standard.

note: type: Plain text
en: Debconf sets DEBCONF_RECONFIGURE=1 before running postinst scripts, so a postinst script that needs to avoid some expensive operation when reconfigured can look at that variable. This is a hack because the right thing would be to pass $1 = "reconfigure", but doing so without breaking all the postinsts that use debconf is difficult. The migration plan away from this hack is to encourage people to write postinsts that accept "reconfigure", and once they all do, begin passing that parameter.
fr: Debconf positionne DEBCONF_RECONFIGURE=1 avant de lancer les scripts postinst, donc un script postinst voulant éviter des opérations coûteuses lorsqu'il est reconfiguré peut regarder cette variable. C'est une bidouille car la meilleure chose à faire serait de lui passer $1 = "reconfigure", mais le faire sans casser tous les scripts postinsts qui utilisent debconf est difficile. Le projet de migration pour cette bidouille est d'encourager les gens à écrire des scripts postinst qui acceptent "reconfigure" et, une fois qu'ils le feront tous, commencer à passer ce paramètre.

note: type: Plain text
en: B<debconf>(7)  is the debconf user's guide.
fr: B<debconf>(7) est le guide de l'utilisateur de debconf.

note: type: Plain text
en: The debconf specification in debian policy is the canonical definition of the debconf protocol. /usr/share/doc/debian-policy/debconf_specification.txt.gz
fr: La spécification debconf dans la charte Debian est une définition canonique du protocole debconf. /usr/share/doc/debian-policy/debconf_specification.txt.gz

note: type: Plain text
en: B<debconf.conf>(5)  has much useful information, including some info about the backend database.
fr: B<debconf.conf>(5) contient beaucoup d'informations, y compris des informations sur les pilotes de la base de données.
