Provided by: devscripts_2.10.39ubuntu7_i386 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 crée tous les fichiers nécessaires pour  envoyer  un  paquet  à
       l’archive  Debian.  Il exécute dans un premier temps dpkg-buildpackage,
       puis lintian avec le fichier .changes créé (en  supposant  que  lintian
       est  installé),  enfin  il  signe  les  fichiers  .changes  et/ou  .dsc
       appropriés (en utilisant debsign(1) plutôt  que  dpkg-buildpackage(1) ;
       toutes  les  options  relatives  à  la signature lui sont passées). Des
       paramètres peuvent être fournis  à  dpkg-buildpackage  et  lintian,  en
       utilisant  les  paramètres  de l’option --lintian-opts pour ce dernier.
       Les  options  --lintian  et  --no-lintian  permettent  de   forcer   ou
       d’empêcher  l’exécution de lintian. Par défaut, lintian est exécuté. Il
       y a également d’autres options permettant de positionner  ou  conserver
       des variables d’environnement, comme décrit dans la section « VARIABLES
       D’ENVIRONNEMENT » ci-dessous. Cette  façon  d’exécuter  debuild  permet
       également  d’obtenir  un  journal  de  la  construction  du paquet dans
       ../<paquet>_<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 privilèges  du  superutilisateur  et  à
       exécuter    debian/rules   avec   ce(s)   paramètre(s).   Les   options
       --rootcmd=commande_pour_devenir_root  ou   -rcommande_pour_devenir_root
       peuvent  être  utilisées.  La  commande_pour_devenir_root  est en règle
       générale une de celles-ci : fakeroot, sudo ou super.  Voyez  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 ; ceci peut  être  explicitement  demandé  ou
       empêché  avec les options -D et -d, respectivement. Notez é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. Ceci permet de fournir des options à utiliser par défaut.

Vérification du nom du répertoire

       Comme  certains  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 vérifie jamais le nom du répertoire.

       1      Ne vérifie 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      Vérifie toujours le nom du répertoire.

       Le nom du répertoire est vérifié en testant si  le  nom  du  répertoire
       courant (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 regex. 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. 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 DENVIRONNEMENT
       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,
       FAKEROOTKEY, 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   positionnée,   et   PATH   est   positionnée   à
       « /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.

       Notez 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 PRIVILÈGES 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  privilèges.  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 supposé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. Notez cependant  que  lintian  s’arrêtera
       s’il  est  exécuté  en  tant que superutilisateur ou setuid root ; ceci
       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
       privilèges    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. Ceci permettra de conserver les permissions après les
       mises à jour.

CROCHETS

       debuild gère un certain nombre de points d’accroche (« hook ») quand il
       exécute  dpkg-buildpackage. Notez que si un des points d’accroche entre
       clean-hook  et  final-hook  (inclus)  est  utilisé,   debuild   émulera
       certaines  sections  du  processus  dpkg-buildpackage plutôt que de les
       exécuter  directement,  puisque  dpkg-buildpackage  n’a  pas  de  point
       d’accroche. Les points d’accroche suivants sont disponibles :

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

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

       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 ou -B est utilisée.)

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

       dpkg-binary-hook
              S’exécute  entre les appels aux règles build et binary(-arch) du
              fichier debian/rules. Ne s’exécute QUE si un paquet binaire  est
              construit.

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

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

       lintian-hook
              S’exécute (une fois) avant l’appel à lintian. (S’exécute même si
              aucun de ces programmes n’est appelé.)

       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é.)

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

       Une  commande  crochet  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, %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 crochets, 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.

       Enfin,  seuls dpkg-buildpackage-hook et les crochets avant lintian-hook
       peuvent être utilisés si dpkg-cross est installé. (Ceci est dû au  fait
       que  debuild  réimplémente  en interne dpkg-buildpackage, mais n’essaie
       pas de réimplémenter le remplacement de dpkg-cross pour ce script.)

OPTIONS

       Pour plus de détails, voir ci-dessus.

       --no-conf, --noconf
              Ne lit 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-root, -rcommande-pour-devenir-root
              Commande    pour    obtenir    (ou   simuler)   les   privilèges
              superutilisateur.

       --preserve-env
              Ne nettoie pas l’environnement, à l’exception du PATH.

       --preserve-envvar=var, -evar
              Ne nettoie pas 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
              Positionne 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écute  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
              N’exécute pas 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 vérifie pas que  le
              fichier .orig.tar.gz 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érifie  que  le  fichier
              .orig.tar.gz  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.
              username indique l’identifiant à utiliser.

       --toto-hook=crochet
              Définit  un  crochet comme décrit ci-dessous. Si hook est blanc,
              le crochet est annulé.

       --clear-hooks
              Supprime tous les crochets. Ils peuvent être réinstallés par des
              options ultérieures en ligne de commande.

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

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

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

       -D     Exécute 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
              Si elle est positionnée à  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.  Ceci  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
              Positionner cette variable à prog équivaut à utiliser -rprog.

       DEBUILD_TGZ_CHECK
              Si elle est positionnée  à  no,  équivaut  à  utiliser  l’option
              --no-tgz-check en ligne de commande.

       DEBUILD_SIGNING_USERNAME
              Positionner   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 clé GPG, même pour  les  envois  sponsorisé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. Notez que l’option -r placée ici écrasera le  paramètre
              DEBUILD_ROOTCMD.

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

       DEBUILD_LINTIAN
              Si elle est positionnée à no, alors lintian ne sera pas exécuté.

       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.
              Notez 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 via la 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

       Prenez note de 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  sponsorisé  (« sponsored
       upload »), donné par toto_1.0-1.dsc et les fichiers sources 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 clé GPG ou un
       autre identifiant de clé  tel  que  votre  adresse  de  messagerie.  De
       nouveau,   Vous  pouvez  également  utiliser  l’option  du  fichier  de
       configuration DEBUILD_DPKG_BUILDPACKAGE_OPTS tel que  cela  est  décrit
       plus  haut  pour  éviter  d’avoir à taper l’option -k à chaque fois que
       vous effectuez un envoi sponsorisé.

VOIR AUSSI

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

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,  réalisée  par  Nicolas   François,
       Guillaume Delacour, Cyril Brulebois et Thomas Huriaux.

       L’équipe  de  traduction a fait le maximum pour réaliser une adaptation
       française de qualité.

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

       N’hésitez  pas  à  signaler  à  l’auteur  ou  à  la liste de traduction
       <debian-l10-french@lists.debian.org>, selon le cas, toute  erreur  dans
       cette page de manuel.