Provided by: devscripts_2.17.12ubuntu1.1_amd64 bug

NOM

       debuild - Construire un paquet Debian

SYNOPSIS

       debuild [options_debuild] [options_dpkg-buildpackage] [--lintian-opts options_lintian]
       debuild [options_debuild] -- binary|binary-arch|binary-indep|clean ...

DESCRIPTION

       debuild  creates  all  the  files  necessary for uploading a Debian package. It first runs
       dpkg-buildpackage, then runs lintian on the .changes file created (assuming  that  lintian
       is  installed),  and  finally  signs  the  appropriate  files (using debsign(1) to do this
       instead of dpkg-buildpackage(1) itself; all relevant key-signing options are  passed  on).
       Signing  will  be  skipped  if  the distribution is UNRELEASED, unless dpkg-buildpackage's
       --force-sign option is used. Parameters can be passed to  dpkg-buildpackage  and  lintian,
       where  the  parameters  to  the  latter  are indicated with the --lintian-opts option. The
       allowable options in this case are --lintian and --no-lintian to force or skip the lintian
       step,  respectively.  The  default  is  to  run  lintian.  There  are also various options
       available for setting and preserving environment variables,  as  described  below  in  the
       Environment Variables section. In this method of running debuild, we also save a build log
       to the file ../<package>_<version>_<arch>.build.

       Une autre façon d'utiliser debuild est d'utiliser un  (ou  plus)  des  paramètres  binary,
       binary-arch, binary-indep et clean. Dans ce cas, debuild cherchera à obtenir les droits du
       superutilisateur  et  à  exécuter  debian/rules  avec  ce(s)  paramètre(s).  Les   options
       --rootcmd=commande_pour_devenir_superutilisateur                                        ou
       -rcommande_pour_devenir_superutilisateur      peuvent       être       utilisées.       La
       commande_pour_devenir_superutilisateur  est en règle générale une de celles-ci : fakeroot,
       sudo ou super. Lisez ci-dessous pour une discussion plus approfondie sur ce point.  Encore
       une fois, les options permettant de préserver l'environnement peuvent être utilisées. Dans
       ce cas, debuild cherchera également à exécuter dans un premier temps dpkg-checkbuilddeps ;
       cela peut être explicitement demandé ou empêché avec les options -D et -d, respectivement.
       Remarquez également que si une de ces options ou si  l'option  -r  est  indiquée  dans  la
       variable  DEBUILD_DPKG_BUILDPACKAGE_OPTS  du fichier de configuration, elle sera reconnue,
       même avec cette façon d'exécuter debuild.

       debuild lit aussi les fichiers de configuration de  devscripts  décrits  ci-dessous.  Cela
       permet de fournir des options à utiliser par défaut.

Vérification du nom du répertoire

       Comme  plusieurs autres scripts du paquet devscripts, debuild parcourt une arborescence de
       répertoires jusqu'à trouver un fichier debian/changelog avant  de  construire  le  paquet.
       Pour  éviter  les problèmes posés par les fichiers égarés, il examine le nom du répertoire
       parent une fois le fichier debian/changelog trouvé, et vérifie que le  nom  du  répertoire
       correspond  au  nom  du  paquet.  La  façon  précise  utilisée  est contrôlée par les deux
       variables    du    fichier    de    configuration    DEVSCRIPTS_CHECK_DIRNAME_LEVEL     et
       DEVSCRIPTS_CHECK_DIRNAME_REGEX,   et   les   options   en   ligne  de  commande  associées
       --check-dirname-level et --check-dirname-regex.

       DEVSCRIPTS_CHECK_DIRNAME_LEVEL peut prendre les valeurs suivantes :

       0      Ne jamais vérifier le nom du répertoire.

       1      Ne vérifier le nom du répertoire que  s'il  a  fallu  changer  de  répertoire  pour
              trouver le fichier debian/changelog. C'est le comportement par défaut.

       2      Toujours vérifier le nom du répertoire.

       Le  nom  du  répertoire  est  vérifié en testant si le nom du répertoire actuel (donné par
       pwd(1))   correspond   à    l'expression    rationnelle    donnée    par    la    variable
       DEVSCRIPTS_CHECK_DIRNAME_REGEX    du    fichier   de   configuration   ou   par   l'option
       --check-dirname-regex expression_rationnelle. Il s'agit d'une expression rationnelle  Perl
       (voir  perlre(1)),  qui  sera  ancrée  à son début et à sa fin. Si elle contient un « / »,
       alors elle doit correspondre au chemin complet, sinon elle doit  correspondre  au  nom  de
       répertoire  complet.  Si  elle contient la chaîne « PACKAGE », cette chaîne sera remplacée
       par le nom du paquet source déterminé par le fichier changelog. La valeur  par  défaut  de
       cette  expression  rationnelle  est  « PACKAGE(-.+)? »,  ce qui correspond aux répertoires
       nommés PACKAGE ou PACKAGE-version.

VARIABLES D'ENVIRONNEMENT

       Comme les variables d'environnement peuvent affecter la construction d'un paquet,  souvent
       de  façon  involontaire,  debuild nettoie l'environnement en enlevant toutes les variables
       d'environnement, à l'exception de TERM, HOME, LOGNAME, GNUPGHOME, PGPPATH, GPG_AGENT_INFO,
       GPG_TTY,  DBUS_SESSION_BUS_ADDRESS,  FAKEROOTKEY,  DEBEMAIL, DEB_*, des variables (C, CPP,
       CXX, LD et F)FLAGS et les variables _APPEND associées, ainsi que les  variables  pour  les
       paramètres  régionaux  LANG  et  LC_*.  La  variable  TERM vaut « dumb » si elle n'est pas
       définie, et PATH est définie à « /usr/sbin:/usr/bin:/sbin:/bin:/usr/bin/X11 ».

       Si une variable d'environnement ne doit  pas  être  modifiée  pour  la  construction  d'un
       paquet, il est possible d'utiliser --preserve-envvar var (ou -e var). L'environnement peut
       aussi être préservé en utilisant l'option --preserve-env. Cependant, même dans ce  cas  le
       PATH  est  remis  à  la valeur précisée ci-dessus. Le seul moyen d'empêcher le PATH d'être
       remis à zéro est d'utiliser  une  option  --preserve-envvar  PATH.  Mais  soyez  conscient
       qu'utiliser  des  programmes  d'un emplacement non standard peut facilement résulter en un
       paquet cassé, puisqu'il ne sera pas possible de le construire sur des systèmes standards.

       Remarquez que des répertoire peuvent être ajoutés au début de la variable  d'environnement
       PATH  en  utilisant l'option --prepend-path. C'est utile quand on veut utiliser des outils
       comme ccache ou distcc pour la construction d'un paquet.

       Il est également possible d'éviter d'avoir à écrire quelque chose comme TOTO=titi  debuild
       -e  TOTO  en  écrivant  debuild  -e  TOTO=titi  ou  la  forme  longue debuild --set-envvar
       TOTO=titi.

OBTENTION DES DROITS DU SUPERUTILISATEUR

       debuild doit être exécuté en tant que superutilisateur pour fonctionner correctement. Il y
       a  trois  façons fondamentalement différentes de faire cela. La première, et celle qui est
       conseillée, est  d'utiliser  une  commande  permettant  de  devenir  superutilisateur.  La
       meilleure  d'entre  elles  est  probablement  fakeroot(1),  puisqu'elle  ne  nécessite pas
       d'accorder véritablement de droits. super(1) et sudo(1)  sont  d'autres  possibilités.  Si
       aucune  option -r (ou --rootcmd) n'est donnée (rappelez-vous que dpkg-buildpackage accepte
       également une option -r)  et  qu'aucune  des  méthodes  suivantes  n'est  utilisée,  alors
       -rfakeroot sera implicitement considérée.

       La deuxième méthode est d'utiliser une commande comme su(1) pour devenir superutilisateur,
       et ensuite de réaliser toutes les  opérations  en  tant  que  superutilisateur.  Remarquez
       cependant  que  lintian s'arrêtera s'il est exécuté en tant que superutilisateur ou setuid
       root ; cela peut être contourné en utilisant l'option --allow-root de lintian si vous êtes
       sûr de vous.

       La troisième méthode consiste à installer debuild setuid root. Ce n'est pas la méthode par
       défaut, et nécessitera l'installation en tant que tel  par  l'administrateur  système.  Il
       faut  aussi  être  conscient  que  toute  personne  pouvant  exécuter  debuild en tant que
       superutilisateur ou setuid root a un accès complet au système.  Cette  méthode  n'est  pas
       recommandée,  mais  fonctionnera. debuild peut être installé avec les permissions 4754, de
       façon à ce que seuls les membres de son  groupe  puissent  l'exécuter.  L'inconvénient  de
       cette  méthode  est  que  les  autres  utilisateurs  ne  pourront  plus  alors utiliser ce
       programme. D'autres variantes consistent à avoir plusieurs copies de debuild ou d'utiliser
       des   programmes   comme   sudo  ou  super  pour  accorder  sélectivement  des  droits  du
       superutilisateur à certains utilisateurs. Si l'administrateur veut utiliser cette méthode,
       il  devra  utiliser  le  programme  dpkg-statoverride  pour  modifier  les  permissions de
       /usr/bin/debuild. Cela permettra de conserver les permissions après les mises à jour.

POINTS D'ACCROCHE

       debuild  gère  un  certain  nombre  de  points  d'ancrage  (« hook »)  quand  il   exécute
       dpkg-buildpackage. Remarquez que les points d'ancrage entre clean-hook et lintian (inclus)
       sont  passées  au  travers  de  dpkg-buildpackage  en  utilisant  leur  option  --hook-nom
       correspondante. Les points d'ancrage disponibles sont les suivants :

       dpkg-buildpackage-hook
              S'exécute avant le début de dpkg-buildpackage en appelant dpkg-checkbuilddeps.

              Le point d'ancrage est exécuté dans le source dépaqueté.

              Correspond au point d'ancrage init de dpkg.

       clean-hook
              S'exécute  avant  que  dpkg-buildpackage  lance debian/rules clean pour nettoyer le
              source. (S'exécute même si le source n'est pas nettoyé car -nc est utilisée.)

              Le point d'ancrage est exécuté dans le source dépaqueté.

              Correspond au point d'ancrage preclean de dpkg.

       dpkg-source-hook
              S'exécute après  le  nettoyage  du  source  et  avant  l'exécution  de  dpkg-source
              (s'exécute même si dpkg-source n'est pas appelé car -b, -B, ou -A est utilisée).

              Le point d'ancrage est exécuté dans le source dépaqueté.

              Correspond au point d'ancrage source de dpkg.

       dpkg-build-hook
              S'exécute  après dpkg-source et avant l'appel de debian/rules build (s'exécute même
              si ce n'est qu'une construction du paquet source, donc que debian/rules build n'est
              pas appelé).

              Le point d'ancrage est exécuté dans le source dépaqueté.

              Correspond au point d'ancrage build de dpkg.

       dpkg-binary-hook
              S'exécute  entre  les  appels  debian/rules build et debian/rules binary(-arch). Ne
              s'exécute que si un paquet binaire est construit.

              Le point d'ancrage est exécuté dans le source dépaqueté.

              Correspond au point d'ancrage binary de dpkg.

       dpkg-genchanges-hook
              S'exécute  seulement  après  la  construction  du  paquet  et   avant   l'appel   à
              dpkg-genchanges.

              Le point d'ancrage est exécuté dans le source dépaqueté.

              Correspond au point d'ancrage changes de dpkg.

       final-clean-hook
              S'exécute   après   dpkg-genchanges   et  avant  l'appel  final  debian/rules clean
              (s'exécute même si le source n'est pas nettoyé après la construction, ce qui est le
              comportement par défaut).

              Le point d'ancrage est exécuté dans le source dépaqueté.

              Correspond au point d'ancrage postclean de dpkg.

       lintian-hook
              S'exécute  (une  fois) avant l'appel à lintian (s'exécute même si lintian n'est pas
              appelé).

              Le point d'ancrage est exécuté à partir du répertoire parent du source dépaqueté.

              Correspond au point d'ancrage check de dpkg.

       signing-hook
              S'exécute seulement après l'appel à lintian et avant la signature  (s'exécute  même
              si rien n'est signé).

              Le point d'ancrage est exécuté à partir du répertoire parent du source dépaqueté.

              Correspond au point d'ancrage sign de dpkg, mais est exécuté par debuild.

       post-dpkg-buildpackage-hook
              S'exécute quand tout est fini.

              Le point d'ancrage est exécuté à partir du répertoire parent du source dépaqueté.

              Correspond au point d'ancrage done de dpkg, mais est exécuté par debuild.

       Une  commande  de point d'ancrage peut être définie soit dans le fichier de configuration,
       par exemple avec DEBUILD_SIGNING_HOOK='toto' (notez que les tirets  ont  été  modifiés  en
       caractères  de soulignement), ou avec l'option en ligne de commande --signing-hook-foo. La
       commande sera en partie modifiée : %% deviendra un signe % simple, %p sera remplacé par le
       nom  du  paquet,  %v  par  le  numéro de version du paquet, %s par le numéro de version du
       source et %u par le numéro de version amont. Ni %s ni %u ne  contiendra  de  temps  absolu
       (« epoch »). %a sera 1 si l'action suivante doit être effectuée et 0 dans le cas contraire
       (par exemple, dans le crochet dpkg-source, %a sera 1 si dpkg-source doit être lancé  et  0
       sinon).  Elle  sera  alors passée à l'interpréteur de commandes pour être traitée, et peut
       donc inclure des redirections ou des choses du genre. Par exemple, pour ne lancer  que  le
       crochet  dpkg-source si dpkg-source doit être exécutée, le crochet peut ressemble à ceci :
       « if [ %a -eq 1 ]; then ...; fi ».

       Soyez prudent avec les points d'accroche, puisqu'une mauvaise utilisation peut empêcher le
       paquet  de  se  compiler  depuis  le  source.  Ils  peuvent  être  utiles pour prendre des
       instantanés, etc.

OPTIONS

       Plus de précisions sont fournies ci-après.

       --no-conf, --noconf
              Ne lire aucun fichier de  configuration.  L'option  ne  peut  être  utilisée  qu'en
              première position de la ligne de commande.

       --rootcmd=commande-pour-devenir-superutilisateur, -rcommande-pour-devenir-superutilisateur
              Commande pour obtenir (ou simuler) les droits du superutilisateur.

       --preserve-env
              Ne pas nettoyer l'environnement, à l'exception du PATH.

       --preserve-envvar=var, -evar
              Ne pas nettoyer la variable d'environnement var.

              Si  var se termine par un astérisque (« * ») alors toutes les variables qui ont une
              correspondance avec la portion de var avant l'astérisque seront préservées.

       --set-envvar=var=valeur, -evar=valeur
              Définir  la  variable  d'environnement  var  à  valeur  et  ne  l'enlève   pas   de
              l'environnement.

       --prepend-path=valeur
              Une fois que PATH a été normalisé, ajouter valeur au début.

       --lintian
              Exécuter  lintian  après dpkg-buildpackage. C'est le comportement par défaut. Cette
              option permet de remplacer une  directive  contraire  placée  dans  un  fichier  de
              configuration.

       --no-lintian
              Ne pas exécuter lintian après dpkg-buildpackage.

       --no-tgz-check
              Même  si  dpkg-buildpackage  est  exécuté  et  que le numéro de version possède une
              révision pour Debian, ne pas vérifier si le fichier .orig.tar.gz ou  le  répertoire
              .orig existe avant de démarrer la construction.

       --tgz-check
              Si  dpkg-buildpackage  est exécuté et que le numéro de version possède une révision
              pour Debian, vérifier si le fichier .orig.tar.gz  ou  le  répertoire  .orig  existe
              avant de démarrer la construction. C'est le comportement par défaut.

       --username nom_utilisateur
              Pour  les signatures, utiliser debrsign plutôt que debsign. nom_utilisateur indique
              l'identifiant à utiliser.

       --toto-hook=accroche
              Définir un point d'accroche comme décrit ci-dessus. Si accroche est  laissé  blanc,
              le point d'accroche est annulé.

       --clear-hooks
              Supprimer  tous les points d'accroche. Ils peuvent être réinstaurés par des options
              ultérieures en ligne de commande.

       --check-dirname-level N
              Veuillez consulter la section Vérification du nom du répertoire ci-dessus pour  une
              explication de cette option.

       --check-dirname-regex regex
              Veuillez  consulter la section Vérification du nom du répertoire ci-dessus pour une
              explication de cette option.

       -d     Ne pas exécuter dpkg-checkbuilddeps pour vérifier les dépendances  de  construction
              du paquet (« build dependencies »).

       -D     Exécuter dpkg-checkbuilddeps pour vérifier les dépendances de construction.

VARIABLES DE CONFIGURATION

       Les deux fichiers de configuration /etc/devscripts.conf et ~/.devscripts sont évalués dans
       cet ordre par un interpréteur de  commandes  (« shell »)  pour  placer  les  variables  de
       configuration.  Des  options  de ligne de commande peuvent être utilisées pour neutraliser
       les paramètres des fichiers de configuration. Les paramètres des variables d'environnement
       sont  ignorés à cette fin. Si la première option donnée en ligne de commande est --noconf,
       alors ces fichiers ne sont pas évalués. Les variables actuellement identifiées sont :

       DEBUILD_PRESERVE_ENV
              Lui attribuer la valeur yes équivaut à utiliser l'option --preserve-env.

       DEBUILD_PRESERVE_ENVVARS
              Définit les variables d'environnement à conserver. Elle est constituée d'une  liste
              de  variables d'environnement séparées par des virgules. Cela correspond à utiliser
              plusieurs fois les options --preserve-envvar ou -e.

       DEBUILD_SET_ENVVAR_var=valeur
              Équivaut à utiliser --set-envvar=var=value.

       DEBUILD_PREPEND_PATH
              Équivaut à utiliser --prepend-path.

       DEBUILD_ROOTCMD
              Lui attribuer la valeur prog équivaut à utiliser -rprog.

       DEBUILD_TGZ_CHECK
              Lui attribuer la valeur no équivaut à utiliser l'option --no-tgz-check en ligne  de
              commande.

       DEBUILD_SIGNING_USERNAME
              Définir  cette  variable  équivaut  à  utiliser  l'option  --username  en  ligne de
              commande.

       DEBUILD_DPKG_BUILDPACKAGE_OPTS
              Voici les options qui devraient être passées à l'invocation  de  dpkg-buildpackage.
              Elles  sont  données avant toute option en ligne de commande. À cause des problèmes
              de guillemets avec les interpréteurs de commandes, pour les paramètres contenant un
              espace,  il  sera nécessaire d'ajouter des guillemets supplémentaires. Par exemple,
              pour forcer à toujours utiliser votre clef GPG,  même  pour  les  envois  parrainés
              (« sponsored upload »), le fichier de configuration pourra contenir :

              DEBUILD_DPKG_BUILDPACKAGE_OPTS="-k'Julian Gilbey <jdg@debian.org>' -sa"

              ce  qui  fournit  exactement  deux  options.  Sans  les guillemets supplémentaires,
              dpkg-buildpackage se serait plaint (à juste titre) que Gilbey n'est pas une  option
              reconnue (elle ne commence pas par un signe -).

              Également,  si  ce  paramètre contient une (ou plusieurs) des options -r, -d ou -D,
              elle sera toujours prise en compte par debuild. Remarquez que  l'option  -r  placée
              ici écrasera le paramètre DEBUILD_ROOTCMD.

       DEBUILD_TOTO_HOOK
              La variable de point d'accroche pour le point d'accroche toto. Voyez la section sur
              les points d'accroche pour plus de détails. Par défaut, elle est non définie.

       DEBUILD_LINTIAN
              Lui attribuer la valeur no empêchera l'exécution de lintian.

       DEBUILD_LINTIAN_OPTS
              Ce sont les options qui doivent être passées lors de l'invocation de lintian. Elles
              sont  données  avant  toute  option en ligne de commande, et l'utilisation de cette
              option    est    la    même    que    celle    décrite     pour     la     variable
              DEBUILD_DPKG_BUILDPACKAGE_OPTS.

       DEVSCRIPTS_CHECK_DIRNAME_LEVEL, DEVSCRIPTS_CHECK_DIRNAME_REGEX
              Veuillez  consulter la section Vérification du nom du répertoire ci-dessus pour une
              explication de ces variables. Remarquez que ce sont des variables de  configuration
              pour  tous les outils du paquet devscripts ; elles impacteront tous les scripts qui
              les utilisent, comme indiqué  dans  leurs  pages  de  manuel  respectives  et  dans
              devscripts.conf(5).

EXEMPLES

       Pour construire votre propre paquet, lancez simplement debuild depuis l'arbre des sources.
       Des options de dpkg-buildpackage(1) peuvent être passées en ligne de commande.

       La ligne de commande typiquement utilisée pour construire le(s) paquet(s) binaire(s)  sans
       signer le fichier .changes (ou le fichier .dsc inexistant) est :

              debuild -i -us -uc -b

       Changez -b en -S pour ne construire qu'un paquet source.

       Voici  un  exemple  appelant  lintian  (et  lui fournissant des options) pour vérifier les
       paquets créés :

              debuild --lintian-opts -i

       Remarquez bien l'ordre des options : d'abord  les  options  de  debuild,  puis  celles  de
       dpkg-buildpackage  et  enfin  celles  de  lintian (lintian est appelé par défaut). Si vous
       utilisez toujours les mêmes options de dpkg-buildpackage, vous  pouvez  utiliser  l'option
       DEBUILD_DPKG_BUILDPACKAGE_OPTS du fichier de configuration, comme décrit plus haut.

       Pour  construire  un  paquet  pour  un  envoi  parrainé  (« sponsored upload »), donné par
       toto_1.0-1.dsc et les fichiers source respectifs, lancez quelque chose  qui  ressemblerait
       aux commandes suivantes :

              dpkg-source -x toto_1.0-1.dsc
              cd toto-1.0
              debuild -k0x12345678

       où  0x12345678 est remplacé par l'identifiant de votre clef GPG ou un autre identifiant de
       clef tel que votre adresse de messagerie.  De  nouveau,  vous  pouvez  également  utiliser
       l'option  du  fichier de configuration DEBUILD_DPKG_BUILDPACKAGE_OPTS tel que c'est décrit
       plus haut pour éviter d'avoir à taper l'option -k à chaque  fois  que  vous  effectuez  un
       envoi parrainé.

VOIR AUSSI

       chmod(1),    debsign(1),    dpkg-buildpackage(1),   dpkg-checkbuilddeps(1),   fakeroot(1),
       lintian(1), su(1), sudo(1), super(1), devscripts.conf(5), dpkg-statoverride(8)

AUTEUR

       Le programme debuild a été initialement écrit par Christoph Lameter <clameter@debian.org>.
       La version actuelle a été écrite par Julian Gilbey <jdg@debian.org>.

TRADUCTION

       Ce    document    est    une    traduction,   maintenue   à   l'aide   de   l'outil   po4a
       <https://po4a.alioth.debian.org/> par l'équipe de traduction francophone du projet Debian.

       Nicolas François, Guillaume Delacour, Cyril Brulebois, Thomas Huriaux et David Prévot  ont
       réalisé cette traduction.

       L'équipe  de  traduction  a  fait  le  maximum  pour  réaliser une adaptation française de
       qualité.   Veuillez   signaler   toute   erreur    de    traduction    en    écrivant    à
       <debian-l10n-french@lists.debian.org> ou par un rapport de bogue sur le paquet devscripts.

       La  version  anglaise  la  plus à jour de ce document est toujours consultable en ajoutant
       l'option « -L C » à la commande man.