Provided by: devscripts_2.11.6ubuntu1_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  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  définir  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 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.
       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.  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 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 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,
       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   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.

       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 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. Notez 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'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 disponibles sont les suivants :

       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, -B, ou -A 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 de point d'accroche 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.

       Enfin,  seuls  dpkg-buildpackage-hook  et les points d'accroche avant lintian-hook peuvent
       être utilisés si dpkg-cross est installé (cela 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

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

       Notez 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 cela est
       décrit plus haut pour éviter d'avoir à taper l'option -k à chaque fois que vous  effectuez
       un envoi parrainé.

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,   maintenue   à   l'aide   de   l'outil   po4a
       <URL:http://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.