.\" -*- coding: UTF-8 -*-
'\" t
.\" Copyright 1995 Yggdrasil Computing, Incorporated.
.\" written by Adam J. Richter (adam@yggdrasil.com),
.\" with typesetting help from Daniel Quinlan (quinlan@yggdrasil.com).
.\" and Copyright 2003, 2015 Michael Kerrisk <mtk.manpages@gmail.com>
.\"
.\" SPDX-License-Identifier: GPL-2.0-or-later
.\"
.\" Modified by David A. Wheeler <dwheeler@dwheeler.com> 2000-11-28.
.\" Applied patch by Terran Melconian, aeb, 2001-12-14.
.\" Modified by Hacksaw <hacksaw@hacksaw.org> 2003-03-13.
.\" Modified by Matt Domsch, 2003-04-09: _init and _fini obsolete
.\" Modified by Michael Kerrisk <mtk.manpages@gmail.com> 2003-05-16.
.\" Modified by Walter Harms: dladdr, dlvsym
.\" Modified by Petr Baudis <pasky@suse.cz>, 2008-12-04: dladdr caveat
.\"
.\"*******************************************************************
.\"
.\" This file was generated with po4a. Translate the source file.
.\"
.\"*******************************************************************
.TH dlopen 3 "5 février 2023" "Pages du manuel de Linux 6.03" 
.SH NOM
dlclose, dlopen, dlmopen \- Ouvrir et fermer un objet partagé
.SH BIBLIOTHÈQUE
Bibliothèque de liens dynamiques (\fIlibdl\fP, \fI\-ldl\fP)
.SH SYNOPSIS
.nf
\fB#include <dlfcn.h>\fP
.PP
\fBvoid *dlopen(const char *\fP\fIfilename\fP\fB, int \fP\fIflags\fP\fB);\fP
\fBint dlclose(void *\fP\fIhandle\fP\fB);\fP
.PP
\fB#define _GNU_SOURCE\fP
.br
\fB#include <dlfcn.h>\fP
.PP
\fBvoid *dlmopen(Lmid_t \fP\fIlmid\fP\fB, const char *\fP\fIfilename\fP\fB, int \fP\fIflags\fP\fB);\fP
.fi
.SH DESCRIPTION
.SS dlopen()
La fonction \fBdlopen\fP() charge la bibliothèque dynamique dont le nom est
fourni dans la chaîne \fIfilename\fP (terminée par l'octet NULL) et renvoie un
descripteur opaque («\ handle\ ») représentant la bibliothèque dynamique. Ce
descripteur est utilisé avec d'autres fonctions dans l'API dlopen, telles
que \fBdlsym\fP(3), \fBdladdr\fP(3), \fBdlinfo\fP(3) et \fBdlclose\fP().
.PP
.\" FIXME On Solaris, when handle is NULL, we seem to get back
.\" a handle for (something like) the root of the namespace.
.\" The point here is that if we do a dlmopen(LM_ID_NEWLM), then
.\" the filename==NULL case returns a different handle than
.\" in the initial namespace. But, on glibc, the same handle is
.\" returned. This is probably a bug in glibc.
.\"
Si l'argument \fIfilename\fP est un pointeur NULL, le descripteur renvoyé
correspond au programme principal. Si \fIfilename\fP contient une barre oblique
(«\ /\ »), il est interprété comme un chemin (relatif ou absolu). Autrement,
l'éditeur dynamique de liens cherche la bibliothèque de la façon suivante
(consultez \fBld.so\fP(8) pour plus de détails)\ :
.IP \[bu] 3
(ELF seulement) Si l'objet appelant (c'est\-à\-dire la bibliothèque partagée
ou l'exécutable depuis lequel \fBdlopen\fP() est appelée) contient la balise
DT_RPATH mais pas la balise DT_RUNPATH, les répertoires listés dans la
balise DT_RPATH seront parcourus.
.IP \[bu]
Si à l'instant où le programme est démarré, la variable d'environnement
\fBLD_LIBRARY_PATH\fP est définie et contient une liste de répertoires séparés
par des deux\-points «\ :\ », ces répertoires seront parcourus. Par mesure de
sécurité, cette variable est ignorée dans le cas de programmes set\-user\-ID
et set\-group\-ID.
.IP \[bu]
(ELF seulement) Si l'objet appelant contient la balise DT_RUNPATH, les
répertoires listés dans cette balise seront parcourus.
.IP \[bu]
Le fichier de cache \fI/etc/ld.so.cache\fP (entretenu par \fBldconfig\fP(8)) est
vérifié pour voir s'il contient une entrée correspondant à \fIfilename\fP.
.IP \[bu]
Les répertoires \fI/lib\fP et \fI/usr/lib\fP sont parcourus (dans cet ordre).
.PP
Si l'objet indiqué dans \fIfilename\fP a des dépendances sur d'autres objets
partagés, ceux\-ci seront automatiquement chargés par l'éditeur dynamique de
liens, en utilisant les mêmes règles. Le processus peut être récursif si ces
objets ont, à leur tour, des dépendances, et ainsi de suite.
.PP
L'une des deux valeurs suivantes doit être incluse dans \fIflag\fP\ :
.TP 
\fBRTLD_LAZY\fP
.\" commit 12b5b6b7f78ea111e89bbf638294a5413c791072
Effectuer des liaisons paresseuses. Ne résoudre les symboles que lorsque le
code qui les référence est exécuté. Si le symbole n'est jamais référencé,
alors il n'est jamais résolu. Les liaisons paresseuses ne sont effectuées
que pour les références de fonctions\ ; les références de variables sont
toujours immédiatement liées quand l'objet partagé est chargé. Depuis la
version\ 2.1.1 de la glibc, ce drapeau est supplanté par l'effet de la
variable d'environnment \fBLD_BIND_NOW\fP.
.TP 
\fBRTLD_NOW\fP
Si cette valeur est spécifiée ou si la variable d'environnement
\fBLD_BIND_NOW\fP est définie avec une chaîne non vide, tous les symboles non
définis de l'objet partagé sont résolus avant le retour de \fBdlopen\fP(). Si
cela ne peut pas être fait, une erreur est renvoyée.
.PP
Zéro ou plusieurs des valeurs suivantes peuvent être spécifiées avec un OU
binaire dans \fIflag\fP\ :
.TP 
\fBRTLD_GLOBAL\fP
Les symboles définis par cet objet partagé seront rendus disponibles pour la
résolution des symboles des objets partagés chargés ultérieurement.
.TP 
\fBRTLD_LOCAL\fP
C'est la réciproque de \fBRTLD_GLOBAL\fP et le comportement par défaut si aucun
des drapeaux n'est spécifié. Les symboles définis dans cet objet partagé ne
sont pas rendus disponibles pour résoudre les références des objets partagés
chargés ultérieurement.
.TP 
\fBRTLD_NODELETE\fP (depuis la glibc\ 2.2)
Ne pas décharger l'objet partagé lors de \fBdlclose\fP(). En conséquence, les
variables statiques de l'objet ne sont pas réinitialisées si l'objet est
chargé ultérieurement avec \fBdlopen\fP().
.TP 
\fBRTLD_NOLOAD\fP (depuis la glibc\ 2.2)
.\"
Ne pas charger l'objet partagé. Cela peut être utilisé pour tester si
l'objet partagé n'est pas déjà chargé (\fBdlopen\fP() renvoie NULL s'il n'est
pas chargé, ou le descripteur de l'objet partagé s'il est déjà chargé). Ce
drapeau peut aussi être utilisé pour promouvoir les drapeaux d'un objet
partagé déjà chargé. Par exemple, un objet partagé qui a été chargé avec
\fBRTLD_LOCAL\fP peut être de nouveau ouvert avec \fBRTLD_NOLOAD\ |\ RTLD_GLOBAL\fP.
.TP 
\fBRTLD_DEEPBIND\fP (depuis la glibc\ 2.3.4)
.\" Inimitably described by UD in
.\" http://sources.redhat.com/ml/libc-hacker/2004-09/msg00083.html.
Placer l'espace de recherche des symboles de cet objet partagé avant
l'espace global. Cela signifie qu'un objet autonome utilisera de préférence
ses propres symboles aux symboles globaux de même noms contenus dans les
objets déjà chargés.
.PP
Si l'argument \fIfilename\fP est un pointeur NULL, le descripteur renvoyé
correspond au programme principal. Lorsqu'il est passé à \fBdlsym\fP(), ce
descripteur provoque la recherche d'un symbole dans le programme principal,
puis dans tous les objets partagés chargés au démarrage du programme, puis
dans toutes les objets partagés chargés par \fBdlopen\fP() avec l'attribut
\fBRTLD_GLOBAL\fP.
.PP
Les références aux symboles de l'objet partagé sont résolues en utilisant
(dans l'ordre)\ : les symboles dans la table de liens des objets chargés pour
le programme principal et ses dépendances, les symboles dans les objets
partagés (et leurs dépendances) qui ont été ouverts par un appel antérieur à
\fBdlopen\fP() avec le drapeau \fBRTLD_GLOBAL\fP et les définitions dans l'objet
partagé lui\-même (ainsi que toute dépendance ayant été chargée pour cet
objet).
.PP
Tout symbole global dans l'exécutable qui a été placé dans sa table de
symboles dynamiques par \fBld\fP(1) peut aussi être utilisé pour résoudre les
références dans un objet partagé dynamiquement chargé. Les symboles peuvent
être placés dans la table de symbole soit parce que les liens de
l'exécutable ont été édités avec le drapeau «\ \-rdynamic\ » (ou de façon
synonyme «\ \-\-export\-dynamic\ »), qui fait que tous les symboles globaux de
l'exécutable sont placés dans la table de symboles dynamiques, soit parce
que \fBld\fP(1) a identifié une dépendance sur un symbole dans un autre objet
durant l'édition de liens statiques.
.PP
Si le même objet partagé est chargé une nouvelle fois avec \fBdlopen\fP(), le
même descripteur sera renvoyé. Un décompte du nombre de chargements est
toutefois conservé par l'éditeur dynamique de liens afin d'éviter de le
décharger avant que la fonction \fBdlclose\fP() n'ait été appelée autant de
fois que \fBdlopen\fP() a réussi. Les constructeurs (voir ci\-dessous) sont
seulement appelés lorsque l'objet est réellement chargé en mémoire
(c'est\-à\-dire lorsque le compteur de références est augmenté et passe à\ 1).
.PP
Un appel ultérieur à \fBdlopen\fP() qui charge le même objet partagé avec
\fBRTLD_NOW\fP peut forcer la résolution de symboles pour un objet partagé
chargé antérieurement avec \fBRTLD_LAZY\fP. De façon similaire, un objet
préalablement ouvert avec \fBRTLD_LOCAL\fP peut être promu à \fBRTLD_GLOBAL\fP
lors d'un appel ultérieur à \fBdlopen\fP().
.PP
.\"
Si \fBdlopen\fP() échoue pour une raison quelconque, elle renvoie NULL.
.SS dlmopen()
Cette fonction effectue la même tâche que \fBdlopen\fP()\ ; les arguments
\fIfilename\fP et \fIflags\fP, de même que la valeur de renvoi, sont les mêmes à
l'exception des différences décrites plus bas.
.PP
La fonction \fBdlmopen\fP() diffère de la fonction \fBdlopen\fP() principalement
parce qu'elle accepte un argument supplémentaire, \fIlmid\fP, qui indique la
liste de tables de liens (aussi appelée \fIespace de noms\fP) dans laquelle
l'objet partagé doit être chargé. En comparaison, \fBdlopen\fP() ajoute l'objet
partagé dynamiquement chargé au même espace de noms que l'objet partagé pour
lequel l'appel \fBdlopen\fP() est fait. Le type \fILmid_t\fP est un gestionnaire
opaque qui fait référence à un espace de noms.
.PP
.\" FIXME: Is using dlinfo() RTLD_DI_LMID the right technique?
L'argument \fIlmid\fP est soit l'ID d'un espace de noms existant (pouvant être
obtenu en utilisant la requête \fBdlinfo\fP(3) \fBRTLD_DI_LMID\fP) ou l'une des
valeurs spéciales suivantes\ :
.TP 
\fBLM_ID_BASE\fP
Charger l'objet partagé dans l'espace de noms initial (c'est\-à\-dire l'espace
de noms de l'application).
.TP 
\fBLM_ID_NEWLM\fP
Créer un nouvel espace de noms et y charger l'objet partagé. Les liens de
l'objet doivent avoir été liés pour référencer tous les autres objets
partagés dont il a besoin puisque l'espace de noms est initialement vide.
.PP
Si \fIfilename\fP est vide, alors l'unique valeur autorisée pour \fIlmid\fP est
\fBLM_ID_BASE\fP.
.SS dlclose()
La fonction \fBdlclose\fP() décrémente le compteur de références de l'objet
partagé chargé dynamiquement et indiqué par \fIhandle\fP.
.PP
Si le compteur de références de cet objet tombe en dessous de zéro et
qu'aucun symbole dans cet objet n'est requis par un autre objet, alors
l'objet est déchargé après avoir appelé tous les destructeurs définis pour
l'objet. Des symboles dans cet objet peuvent être requis par un autre objet
parce qu'il a été ouvert avec le drapeau \fBRTLD_GLOBAL\fP et que l'un de ses
symboles a permis une relocalisation dans un autre objet.
.PP
Tous les objets partagés qui ont été chargés automatiquement lorsque
\fBdlopen\fP() a été invoquée sur l'objet référencé par \fIhandle\fP sont fermés
récursivement de la même façon.
.PP
Un renvoi réussi de \fBdlclose\fP() ne garantit que les symboles associés avec
\fIhandle\fP sont supprimés de l'espace d'adressage de l'appelant. En plus de
références résultant d'appels explicites à \fBdlopen\fP(), un objet partagé a
peut\-être été chargé de façon implicite (et les références prises en compte)
à cause de références dans d'autres objets partagés. Ce n'est que lorsque
toutes les références sont relachées que l'objet partagé peut être supprimé
de l'espace d'adressage.
.SH "VALEUR RENVOYÉE"
En cas de succès, \fBdlopen\fP() et \fBdlmopen\fP() renvoient un gestionnaire non
nul pour l'objet chargé. En cas d'erreur (le fichier ne peut pas être
trouvé, il n'est pas lisible, a le mauvais format ou bien a provoqué des
erreurs lors de son chargement), ces fonctions renvoient NULL.
.PP
En cas de succès, \fBdlclose\fP() renvoie \fB0\fP, en cas d'erreur une valeur non
nulle est renvoyée.
.PP
Les erreurs de ces fonctions peuvent être diagnostiquées en utilisant
\fBdlerror\fP(3).
.SH VERSIONS
\fBdlopen\fP() et \fBdlclose\fP() sont présentes dans la version\ 2.0 et suivantes
de la glibc. \fBdlmopen\fP() est apparue pour la première fois dans la
version\ 2.3.4 de la glibc.
.SH ATTRIBUTS
Pour une explication des termes utilisés dans cette section, consulter
\fBattributes\fP(7).
.ad l
.nh
.TS
allbox;
lbx lb lb
l l l.
Interface	Attribut	Valeur
T{
\fBdlopen\fP(),
\fBdlmopen\fP(),
\fBdlclose\fP()
T}	Sécurité des threads	MT\-Safe
.TE
.hy
.ad
.sp 1
.SH STANDARDS
POSIX.1\-2001 décrit \fBdlclose\fP() et \fBdlopen\fP(). La fonction \fBdlmopen\fP()
est une extension GNU.
.PP
Les drapeaux \fBRTLD_NOLOAD\fP, \fBRTLD_NODELETE\fP et \fBRTLD_DEEPBIND\fP sont des
extensions GNU\ ; les deux premiers sont également présents sur Solaris.
.SH NOTES
.SS "dlmopen() et espace de noms"
Une liste de table de liens définit un espace de noms isolé pour la
résolution de symboles par l'éditeur dynamique de liens. À l'intérieur d'un
espace de noms, les objets partagés dépendants sont implicitement chargés
selon les règles usuelles, et les références aux symboles sont résolues
selon les règles usuelles, mais un telle résolution est limitée aux
définitions fournies aux objets qui ont été chargés (explicitement et
implicitement) dans l'espace de noms.
.PP
La fonction \fBdlmopen\fP() permet une isolation de chargement d'objet,
c'est\-à\-dire la capacité à charger un objet partagé dans un nouvel espace de
noms sans exposer le reste de l'application aux symboles rendus disponibles
par le nouvel objet. Notez que l'utilisation du drapeau \fBRTLD_LOCAL\fP n'est
pas suffisante pour réaliser cela puisque qu'il empêche les symboles des
objets partagés d'être disponibles à \fItout\fP autre objet partagé. Dans
certains cas, il peut être souhaitable de rendre les symboles fournis par un
objet partagé chargé dynamiquement disponibles à d'autres objets (ou à un
sous\-ensemble) partagés sans exposer ces symboles à l'application
entière. Cela peut être réalisé par l'utilisation d'un espace de noms séparé
et du drapeau \fBRTLD_GLOBAL\fP.
.PP
La fonction \fBdlmopen\fP() peut également être utilisée pour fournir une
meilleure isolation que le drapeau \fBRTLD_LOCAL\fP. En particulier, les objets
partagés chargés avec \fBRTLD_LOCAL\fP peuvent être promus à \fBRTLD_GLOBAL\fP
s'ils sont des dépendances d'un autre objet partagé chargé avec
\fBRTLD_GLOBAL\fP mis à part dans le cas (peu commun) où l'on a un contrôle
explicite sur les dépendances de tous les objets partagés.
.PP
Les cas possibles d'utilisation de \fBdlmopen\fP() sont des greffons où
l'auteur du cadriciel de chargement de greffon ne peut pas faire confiance
aux auteurs du greffon et ne souhaite pas que des symboles non définis du
cadriciel greffon soient résolus en symboles du greffon. Une autre
utilisation est de charger le même objet plus d'une fois. Sans l'utilisation
de \fBdlmopen\fP(), cela exigerait la création de copies distinctes du fichier
de l'objet partagé. Grâce à l'utilisation de \fBdlmopen\fP(), cela peut être
réalisé par le chargement du même fichier d'objet partagé dans différents
espaces de noms.
.PP
.\" DL_NNS
.\"
L'implémentation de la glibc prend en charge un nombre maximal de 16\ espaces
de noms.
.SS "Fonctions d'initialisation et de finalisation"
.\" info gcc "C Extensions" "Function attributes"
Les objets partagés peuvent exporter des fonctions en utilisant les
attributs de fonction \fB__attribute__((constructor))\fP et
\fB__attribute__((destructor))\fP. Les fonctions de construction sont exécutées
avant que \fBdlopen\fP() ne renvoie, et les fonctions de destruction sont
exécutées avant que \fBdlclose\fP() ne renvoie. Un objet partagé peut exporter
plusieurs constructeurs et destructeurs et des priorités peuvent être
associées à chaque fonction pour déterminer l'ordre dans lequel elles
s'exécutent. Consultez les pages d'information de \fBgcc\fP (sous «\ Attributs
de fonction\ ») pour plus d'informations.
.PP
Une méthode plus ancienne d'obtenir (partiellement) le même résultat passe
par l'utilisation de deux symboles spéciaux reconnus par l'éditeur de
liens\ : \fB_init\fP et \fB_fini\fP. Si un objet partagé chargé dynamiquement
exporte une routine nommée \fB_init\fP(), alors son code est exécuté après le
chargement d'un objet partagé, avant le retour de \fBdlopen\fP(). Si l'objet
partagé exporte une routine nommée \fB_fini\fP, elle est appelée juste avant le
déchargement de l'objet. Dans ce cas, vous voudrez éviter de lier
l'exécutable avec les fichiers de démarrage du système, qui contiennent des
versions par défaut de ces fichiers\ ; pour cela, vous pouvez spécifier
l'option \fI\-nostartfiles\fP à la ligne de commande de \fBgcc\fP(1).
.PP
.\"
.\" Using these routines, or the gcc
.\" .B \-nostartfiles
.\" or
.\" .B \-nostdlib
.\" options, is not recommended.
.\" Their use may result in undesired behavior,
.\" since the constructor/destructor routines will not be executed
.\" (unless special measures are taken).
.\" .\" void _init(void) __attribute__((constructor));
.\" .\" void _fini(void) __attribute__((destructor));
.\"
L'utilisation de \fB_init\fP et \fB_fini\fP est rendue obsolète en faveur des
constructeurs et destructeurs susmentionnés, ce qui entre autres avantages,
permet la définition de plusieurs fonctions d'initialisation et de
finalisation.
.PP
Depuis la glibc\ 2.2.3, \fBatexit\fP(3) peut être utilisée pour enregistrer un
gestionnaire de sortie qui sera automatiquement appelé quand un objet
partagé est déchargé.
.SS Historique
Ces fonctions font partie de l'API dlopen, dérivée de SunOS.
.SH BOGUES
.\" dlerror(): "invalid mode"
.\" https://sourceware.org/bugzilla/show_bug.cgi?id=18684
Pour la version\ 2.24 de la glibc, spécifier le drapeau \fBRTLD_GLOBAL\fP lors
de l'appel à \fBdlmopen\fP() génère une erreur. De plus, spécifier
\fBRTLD_GLOBAL\fP lors d'un appel à \fBdlopen\fP() résulte en un plantage du
programme (\fBSIGSEGV\fP) si l'appel est effectué depuis n'importe quel objet
chargé dans un autre espace de noms que celui initial.
.SH EXEMPLES
Le programme suivant charge la bibliothèque de maths (de la glibc),
recherche l'adresse de la fonction \fBcos\fP(3) et affiche le cosinus
de\ 2.0. Ci\-dessous, un exemple de construction et d'exécution du programme\ :
.PP
.in +4n
.EX
$ \fBcc dlopen_demo.c \-ldl\fP
$ \fB./a.out\fP
\-0.416147
.EE
.in
.SS "Source du programme"
.\" SRC BEGIN (dlopen.c)
\&
.EX
#include <dlfcn.h>
#include <stdio.h>
#include <stdlib.h>

#include <gnu/lib\-names.h>  /* Defines LIBM_SO (which will be a
                               string such as "libm.so.6") */
int
main(void)
{
    void *handle;
    double (*cosine)(double);
    char *error;

    handle = dlopen(LIBM_SO, RTLD_LAZY);
    if (!handle) {
        fprintf(stderr, "%s\en", dlerror());
        exit(EXIT_FAILURE);
    }

    dlerror();    /* Supprime une erreur existante */

    cosine = (double (*)(double)) dlsym(handle, "cos");

    /* D'après le standard ISO\ C, la conversion de type entre un pointeur
       de fonction et « void * », comme effectuée ci\-dessus, produit des
       résultats indéfinis.
       POSIX.1\-2003 et POSIX.1\-2008 ont admis cet état de fait et proposé
       le contournement ci\-dessous :

           *(void **) (&cosine) = dlsym(handle, "cos");

       Cette conversion (lourde) de type est conforme au standard
       ISO\ C and évitera tout avertissement du compilateur.

.\" http://pubs.opengroup.org/onlinepubs/009695399/functions/dlsym.html#tag_03_112_08
.\" http://pubs.opengroup.org/onlinepubs/9699919799/functions/dlsym.html#tag_16_96_07
.\" http://austingroupbugs.net/view.php?id=74
       La révision technique 2013 de POSIX.1\-2008 a amélioré la
       situation en exigeant que les implémentations prennent en charge
       la conversion du type « void * » vers un pointeur de fonction.
       Cependant, certains compilateurs (par exemple gcc avec
       l'option « \-pedantic ») peuvent se plaindre de la conversion
       effectuée dans ce programme. */

    error = dlerror();
    if (error != NULL) {
        fprintf(stderr, "%s\en", error);
        exit(EXIT_FAILURE);
    }

    printf("%f\en", (*cosine)(2.0));
    dlclose(handle);
    exit(EXIT_SUCCESS);
}
.EE
.\" SRC END
.SH "VOIR AUSSI"
\fBld\fP(1), \fBldd\fP(1), \fBpldd\fP(1), \fBdl_iterate_phdr\fP(3), \fBdladdr\fP(3),
\fBdlerror\fP(3), \fBdlinfo\fP(3), \fBdlsym\fP(3), \fBrtld\-audit\fP(7), \fBld.so\fP(8),
\fBldconfig\fP(8)
.PP
pages Info de ld, pages Info de gcc
.PP
.SH TRADUCTION
La traduction française de cette page de manuel a été créée par
Christophe Blaess <https://www.blaess.fr/christophe/>,
Stéphan Rafin <stephan.rafin@laposte.net>,
Thierry Vignaud <tvignaud@mandriva.com>,
François Micaux,
Alain Portal <aportal@univ-montp2.fr>,
Jean-Philippe Guérard <fevrier@tigreraye.org>,
Jean-Luc Coulon (f5ibh) <jean-luc.coulon@wanadoo.fr>,
Julien Cristau <jcristau@debian.org>,
Thomas Huriaux <thomas.huriaux@gmail.com>,
Nicolas François <nicolas.francois@centraliens.net>,
Florentin Duneau <fduneau@gmail.com>,
Simon Paillard <simon.paillard@resel.enst-bretagne.fr>,
Denis Barbier <barbier@debian.org>,
David Prévot <david@tilapin.org>
et
Grégoire Scano <gregoire.scano@malloc.fr>
.
.PP
Cette traduction est une documentation libre ; veuillez vous reporter à la
.UR https://www.gnu.org/licenses/gpl-3.0.html
GNU General Public License version 3
.UE
concernant les conditions de copie et 
de distribution. Il n'y a aucune RESPONSABILITÉ LÉGALE.
.PP
Si vous découvrez un bogue dans la traduction de cette page de manuel, 
veuillez envoyer un message à
.MT debian-l10n-french@lists.debian.org
.ME .