Provided by: devscripts_2.11.1ubuntu3_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 cree tous les fichiers necessaires pour  envoyer  un  paquet  a
       l'archive  Debian.  Il execute dans un premier temps dpkg-buildpackage,
       puis lintian avec le fichier .changes cree (en  supposant  que  lintian
       est  installe),  enfin  il  signe  les  fichiers  .changes  et/ou  .dsc
       appropries (en utilisant debsign(1) plutot  que  dpkg-buildpackage(1) ;
       toutes  les  options  relatives  a  la signature lui sont passees). Des
       parametres peuvent etre fournis  a  dpkg-buildpackage  et  lintian,  en
       utilisant  les  parametres  de l'option --lintian-opts pour ce dernier.
       Les  options  --lintian  et  --no-lintian  permettent  de   forcer   ou
       d'empecher  l'execution de lintian. Par defaut, lintian est execute. Il
       y a egalement d'autres options permettant de definir ou  conserver  des
       variables  d'environnement,  comme  decrit  dans  la  section VARIABLES
       D'ENVIRONNEMENT  ci-dessous.  Cette  facon  d'executer  debuild  permet
       egalement  d'obtenir  un  journal  de  la  construction  du paquet dans
       ../<paquet>_<version>_<arch>.build.

       Une autre facon d'utiliser debuild est  d'utiliser  un  (ou  plus)  des
       parametres  binary,  binary-arch,  binary-indep  et clean. Dans ce cas,
       debuild cherchera  a  obtenir  les  droits  du  superutilisateur  et  a
       executer    debian/rules   avec   ce(s)   parametre(s).   Les   options
       --rootcmd=commande_pour_devenir_superutilisateur                     ou
       -rcommande_pour_devenir_superutilisateur  peuvent  etre  utilisees.  La
       commande_pour_devenir_superutilisateur est en  regle  generale  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 preserver l'environnement peuvent etre utilisees. Dans ce
       cas, debuild cherchera egalement  a  executer  dans  un  premier  temps
       dpkg-checkbuilddeps ;  cela  peut etre explicitement demande ou empeche
       avec les options -D et -d, respectivement. Notez egalement que  si  une
       de  ces  options  ou  si  l'option  -r  est  indiquee  dans la variable
       DEBUILD_DPKG_BUILDPACKAGE_OPTS du fichier de configuration,  elle  sera
       reconnue, meme avec cette facon d'executer debuild.

       debuild  lit  aussi les fichiers de configuration de devscripts decrits
       ci-dessous. Cela permet de fournir des options a utiliser par defaut.

V'erification du nom du r'epertoire

       Comme plusieurs autres scripts du paquet devscripts,  debuild  parcourt
       une   arborescence   de   repertoires   jusqu'a   trouver   un  fichier
       debian/changelog  avant  de  construire  le  paquet.  Pour  eviter  les
       problemes  poses  par  les  fichiers  egares,  il  examine  le  nom  du
       repertoire parent une  fois  le  fichier  debian/changelog  trouve,  et
       verifie  que le nom du repertoire correspond au nom du paquet. La facon
       precise utilisee est controlee par les deux  variables  du  fichier  de
       configuration             DEVSCRIPTS_CHECK_DIRNAME_LEVEL             et
       DEVSCRIPTS_CHECK_DIRNAME_REGEX, et les options  en  ligne  de  commande
       associees --check-dirname-level et --check-dirname-regex.

       DEVSCRIPTS_CHECK_DIRNAME_LEVEL peut prendre les valeurs suivantes :

       0      Ne jamais verifier le nom du repertoire.

       1      Ne  verifier  le  nom  du repertoire que s'il a fallu changer de
              repertoire pour trouver le fichier  debian/changelog.  C'est  le
              comportement par defaut.

       2      Toujours verifier le nom du repertoire.

       Le  nom  du  repertoire  est verifie en testant si le nom du repertoire
       courant (donne par pwd(1)) correspond a l'expression rationnelle donnee
       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 ancree a
       son debut et a sa fin. Si elle contient un  << / >>,  alors  elle  doit
       correspondre   au   chemin   complet.   Si   elle  contient  la  chaine
       << PACKAGE >>, cette chaine sera remplacee par le nom du paquet  source
       determine  par  le  fichier  changelog.  La  valeur par defaut de cette
       expression rationnelle est << PACKAGE(-.+)? >>, ce qui  correspond  aux
       repertoires nommes PACKAGE ou PACKAGE-version.

VARIABLES D'ENVIRONNEMENT

       Comme  les  variables  d'environnement peuvent affecter la construction
       d'un  paquet,  souvent   de   facon   involontaire,   debuild   nettoie
       l'environnement  en  enlevant  toutes  les variables d'environnement, a
       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  associees,  ainsi  que  les  variables   pour   les
       parametres  regionaux LANG et LC_*. La variable TERM vaut << dumb >> si
       elle    n'est    pas    definie,    et    PATH    est     definie     a
       << /usr/sbin:/usr/bin:/sbin:/bin:/usr/bin/X11 >>.

       Si  une  variable  d'environnement  ne  doit  pas etre modifiee pour la
       construction d'un paquet, il est possible d'utiliser  --preserve-envvar
       var  (ou -e var). L'environnement peut aussi etre preserve en utilisant
       l'option --preserve-env. Cependant, meme dans ce cas le PATH est  remis
       a la valeur precisee ci-dessus. Le seul moyen d'empecher le PATH d'etre
       remis a zero est d'utiliser une  option  --preserve-envvar  PATH.  Mais
       soyez   conscient  qu'utiliser  des  programmes  d'un  emplacement  non
       standard peut facilement resulter en un paquet casse, puisqu'il ne sera
       pas possible de le construire sur des systemes standards.

       Notez  que  des repertoire peuvent etre ajoutes au debut 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 egalement possible d'eviter d'avoir a ecrire quelque chose comme
       TOTO=titi  debuild -e TOTO en ecrivant debuild -e TOTO=titi ou la forme
       longue debuild --set-envvar TOTO=titi.

OBTENTION DES DROITS DU SUPERUTILISATEUR

       debuild doit etre execute en tant que superutilisateur pour fonctionner
       correctement. Il y a trois facons fondamentalement differentes de faire
       cela. La premiere, et celle qui  est  conseillee,  est  d'utiliser  une
       commande  permettant  de devenir superutilisateur. La meilleure d'entre
       elles  est  probablement  fakeroot(1),  puisqu'elle  ne  necessite  pas
       d'accorder  veritablement  de droits. super(1) et sudo(1) sont d'autres
       possibilites.  Si  aucune  option  -r  (ou  --rootcmd)   n'est   donnee
       (rappelez-vous  que  dpkg-buildpackage accepte egalement une option -r)
       et qu'aucune des methodes suivantes n'est  utilisee,  alors  -rfakeroot
       sera implicitement consideree.

       La  deuxieme  methode  est  d'utiliser  une  commande  comme su(1) pour
       devenir superutilisateur, et ensuite de realiser toutes les  operations
       en  tant  que  superutilisateur. Notez cependant que lintian s'arretera
       s'il est execute en tant que superutilisateur  ou  setuid  root ;  cela
       peut  etre  contourne  en utilisant l'option --allow-root de lintian si
       vous etes sur de vous.

       La troisieme methode consiste a installer debuild setuid root. Ce n'est
       pas  la  methode  par defaut, et necessitera l'installation en tant que
       tel par l'administrateur systeme. Il  faut  aussi  etre  conscient  que
       toute personne pouvant executer debuild en tant que superutilisateur ou
       setuid root a un acc`es complet au  syst`eme.  Cette  methode  n'est  pas
       recommandee,  mais  fonctionnera.  debuild  peut etre installe avec les
       permissions 4754, de facon a ce que seuls les  membres  de  son  groupe
       puissent l'executer. L'inconvenient de cette methode est que les autres
       utilisateurs ne pourront plus alors  utiliser  ce  programme.  D'autres
       variantes  consistent a avoir plusieurs copies de debuild ou d'utiliser
       des programmes comme sudo ou  super  pour  accorder  selectivement  des
       droits du superutilisateur a certains utilisateurs. Si l'administrateur
       veut  utiliser  cette  methode,  il   devra   utiliser   le   programme
       dpkg-statoverride  pour  modifier  les permissions de /usr/bin/debuild.
       Cela permettra de conserver les permissions apres les mises a jour.

POINTS D'ACCROCHE

       debuild gere un certain nombre de points d'accroche (<< hook >>)  quand
       il  execute  dpkg-buildpackage.  Notez  que si un des points d'accroche
       entre clean-hook et final-hook (inclus) est  utilise,  debuild  emulera
       certaines  sections  du  processus  dpkg-buildpackage plutot que de les
       executer  directement,  puisque  dpkg-buildpackage  n'a  pas  de  point
       d'accroche. Les points d'accroche disponibles sont les suivants :

       dpkg-buildpackage-hook
              S'execute  avant  le  debut  de  dpkg-buildpackage  en  appelant
              dpkg-checkbuilddeps.

       clean-hook
              S'execute avant que dpkg-buildpackage lance la  regle  clean  du
              fichier debian/rules pour nettoyer le source. (S'execute meme si
              le source n'est pas nettoye car -nc est utilisee.)

       dpkg-source-hook
              S'execute apres le nettoyage du source et avant  l'execution  de
              dpkg-source  (s'execute meme si dpkg-source n'est pas appele car
              -b, -B, ou -A est utilisee).

       dpkg-build-hook
              S'execute apres dpkg-source et avant l'appel de la  regle  build
              du  fichier  debian/rules  (s'execute  meme  si  ce n'est qu'une
              construction du paquet  source,  donc  que  la  regle  build  du
              fichier debian/rules n'est pas appelee).

       dpkg-binary-hook
              S'execute  entre les appels aux regles build et binary(-arch) du
              fichier debian/rules. Ne s'execute que si un paquet binaire  est
              construit.

       dpkg-genchanges-hook
              S'execute  seulement  apres  la  construction du paquet et avant
              l'appel a dpkg-genchanges.

       final-clean-hook
              S'execute apres dpkg-genchanges et  avant  l'appel  final  a  la
              regle clean du fichier debian/rules (s'execute meme si le source
              n'est  pas  nettoye  apres  la  construction,  ce  qui  est   le
              comportement par defaut).

       lintian-hook
              S'execute  (une fois) avant l'appel a lintian (s'execute meme si
              aucun de ces programmes n'est appele).

       signing-hook
              S'execute  seulement  apres  l'appel  a  lintian  et  avant   la
              signature (s'execute meme si rien n'est signe).

       post-dpkg-buildpackage-hook
              S'execute quand tout est fini.

       Une commande de point d'accroche peut etre definie soit dans le fichier
       de configuration, par exemple avec  DEBUILD_SIGNING_HOOK='toto'  (notez
       que les tirets ont ete modifies en caracteres de soulignement), ou avec
       l'option en ligne de commande --signing-hook-foo. La commande  sera  en
       partie  modifiee : %% deviendra un signe % simple, %p sera remplace par
       le nom du paquet, %v par le numero de version  du  paquet,  %s  par  le
       numero de version du source et %u par le numero de version amont. Ni %s
       ni %u ne contiendra  de  temps  absolu  (<< epoch >>).  %a  sera  1  si
       l'action  suivante  doit etre effectuee et 0 dans le cas contraire (par
       exemple, dans le crochet dpkg-source, %a sera  1  si  dpkg-source  doit
       etre  lance  et  0  sinon).  Elle sera alors passee a l'interpreteur de
       commandes pour etre traitee, 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  etre  executee,  le  crochet   peut
       ressemble a ceci : << if [ %a -eq 1 ]; then ...; fi >>.

       Soyez   prudent   avec   les  points  d'accroche,  puisqu'une  mauvaise
       utilisation peut empecher le paquet de se compiler  depuis  le  source.
       Ils peuvent etre utiles pour prendre des instantanes, etc.

       Enfin,  seuls  dpkg-buildpackage-hook  et  les  points d'accroche avant
       lintian-hook peuvent etre utilises si dpkg-cross est installe (cela est
       du  au fait que debuild reimplemente en interne dpkg-buildpackage, mais
       n'essaie pas de reimplementer le remplacement  de  dpkg-cross  pour  ce
       script).

OPTIONS

       Plus de precisions sont fournies ci-apres.

       --no-conf, --noconf
              Ne  lire  aucun  fichier de configuration. L'option ne peut etre
              utilisee qu'en premiere 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, a l'exception du PATH.

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

              Si var se termine par un asterisque (<< * >>) alors  toutes  les
              variables  qui  ont  une  correspondance  avec la portion de var
              avant l'asterisque seront preservees.

       --set-envvar=var=valeur, -evar=valeur
              Definir la variable d'environnement var a valeur et ne  l'enleve
              pas de l'environnement.

       --prepend-path=valeur
              Une fois que PATH a ete normalise, ajouter valeur au debut.

       --lintian
              Executer  lintian apres dpkg-buildpackage. C'est le comportement
              par defaut. Cette  option  permet  de  remplacer  une  directive
              contraire placee dans un fichier de configuration.

       --no-lintian
              Ne pas executer lintian apres dpkg-buildpackage.

       --no-tgz-check
              Meme  si  dpkg-buildpackage  est  execute  et  que  le numero de
              version possede une revision pour Debian, ne pas verifier si  le
              fichier  .orig.tar.gz  ou  le  repertoire  .orig existe avant de
              demarrer la construction.

       --tgz-check
              Si dpkg-buildpackage est execute et que  le  numero  de  version
              possede  une  revision  pour  Debian,  verifier  si  le  fichier
              .orig.tar.gz ou le repertoire .orig existe avant de demarrer  la
              construction. C'est le comportement par defaut.

       --username nom_utilisateur
              Pour  les  signatures,  utiliser  debrsign  plutot  que debsign.
              nom_utilisateur indique l'identifiant a utiliser.

       --toto-hook=accroche
              Definir un point d'accroche comme decrit ci-dessus. Si  accroche
              est laisse blanc, le point d'accroche est annule.

       --clear-hooks
              Supprimer   tous   les   points  d'accroche.  Ils  peuvent  etre
              reinstaures par des options ulterieures en ligne de commande.

       --check-dirname-level N
              Veuillez consulter la section V'erification du nom du  r'epertoire
              ci-dessus pour une explication de cette option.

       --check-dirname-regex regex
              Veuillez  consulter la section V'erification du nom du r'epertoire
              ci-dessus pour une explication de cette option.

       -d     Ne  pas   executer   dpkg-checkbuilddeps   pour   verifier   les
              dependances     de     construction    du    paquet    (<< build
              dependencies >>).

       -D     Executer dpkg-checkbuilddeps pour verifier  les  dependances  de
              construction.

VARIABLES DE CONFIGURATION

       Les    deux   fichiers   de   configuration   /etc/devscripts.conf   et
       ~/.devscripts sont evalues  dans  cet  ordre  par  un  interpreteur  de
       commandes (<< shell >>) pour placer les variables de configuration. Des
       options de ligne de commande peuvent etre  utilisees  pour  neutraliser
       les  parametres  des  fichiers  de  configuration.  Les  parametres des
       variables d'environnement sont ignores a  cette  fin.  Si  la  premiere
       option  donnee en ligne de commande est --noconf, alors ces fichiers ne
       sont pas evalues. Les variables actuellement identifiees sont :

       DEBUILD_PRESERVE_ENV
              Lui  attribuer  la  valeur  yes  equivaut  a  utiliser  l'option
              --preserve-env.

       DEBUILD_PRESERVE_ENVVARS
              Definit  les  variables  d'environnement  a  conserver. Elle est
              constituee d'une liste de variables d'environnement separees par
              des  virgules.  Cela  correspond  a  utiliser plusieurs fois les
              options --preserve-envvar ou -e.

       DEBUILD_SET_ENVVAR_var=valeur
              Equivaut a utiliser --set-envvar=var=value.

       DEBUILD_PREPEND_PATH
              Equivaut a utiliser --prepend-path.

       DEBUILD_ROOTCMD
              Lui attribuer la valeur prog equivaut a utiliser -rprog.

       DEBUILD_TGZ_CHECK
              Lui  attribuer  la  valeur  no  equivaut  a  utiliser   l'option
              --no-tgz-check en ligne de commande.

       DEBUILD_SIGNING_USERNAME
              Definir  cette  variable equivaut a utiliser l'option --username
              en ligne de commande.

       DEBUILD_DPKG_BUILDPACKAGE_OPTS
              Voici les options qui devraient etre passees a  l'invocation  de
              dpkg-buildpackage.  Elles  sont  donnees  avant  toute option en
              ligne de commande. A cause des problemes de guillemets avec  les
              interpreteurs  de  commandes,  pour  les parametres contenant un
              espace,   il   sera   necessaire   d'ajouter   des    guillemets
              supplementaires.  Par  exemple,  pour forcer a toujours utiliser
              votre clef GPG, meme pour  les  envois  parraines  (<< 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
              supplementaires, dpkg-buildpackage se  serait  plaint  (a  juste
              titre)  que  Gilbey  n'est  pas  une  option  reconnue  (elle ne
              commence pas par un signe -).

              Egalement, si ce  parametre  contient  une  (ou  plusieurs)  des
              options  -r,  -d  ou  -D, elle sera toujours prise en compte par
              debuild. Notez que l'option -r placee ici ecrasera le  parametre
              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 details.
              Par defaut, elle est non definie.

       DEBUILD_LINTIAN
              Lui attribuer la valeur no empechera l'execution de lintian.

       DEBUILD_LINTIAN_OPTS
              Ce   sont   les   options  qui  doivent  etre  passees  lors  de
              l'invocation de lintian. Elles sont donnees avant  toute  option
              en  ligne  de  commande, et l'utilisation de cette option est la
              meme     que     celle     decrite     pour     la      variable
              DEBUILD_DPKG_BUILDPACKAGE_OPTS.

       DEVSCRIPTS_CHECK_DIRNAME_LEVEL, DEVSCRIPTS_CHECK_DIRNAME_REGEX
              Veuillez  consulter la section V'erification du nom du r'epertoire
              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 indique 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 etre
       passees via la ligne de commande.

       La  ligne  de  commande  typiquement  utilisee  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
       verifier les paquets crees :

              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
       appele  par  defaut).  Si  vous  utilisez toujours les memes options de
       dpkg-buildpackage,      vous       pouvez       utiliser       l'option
       DEBUILD_DPKG_BUILDPACKAGE_OPTS   du  fichier  de  configuration,  comme
       decrit plus haut.

       Pour  construire  un  paquet  pour  un  envoi  parraine   (<< sponsored
       upload >>), donne 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

       ou 0x12345678 est remplace par l'identifiant de votre clef  GPG  ou  un
       autre  identifiant  de  clef  tel  que  votre adresse de messagerie. De
       nouveau,  vous  pouvez  egalement  utiliser  l'option  du  fichier   de
       configuration  DEBUILD_DPKG_BUILDPACKAGE_OPTS  tel  que cela est decrit
       plus haut pour eviter d'avoir a taper l'option -k  a  chaque  fois  que
       vous effectuez un envoi parraine.

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  ete initialement ecrit par Christoph Lameter
       <clameter@debian.org>. La version actuelle  a  ete  ecrite  par  Julian
       Gilbey <jdg@debian.org>.

TRADUCTION

       Ce  document  est  une  traduction,  maintenue a l'aide de l'outil po4a
       <URL:http://po4a.alioth.debian.org/>   par   l'equipe   de   traduction
       francophone du projet Debian.

       Nicolas  Francois,  Guillaume Delacour, Cyril Brulebois, Thomas Huriaux
       et David Prevot ont realise cette traduction.

       L'equipe de traduction a fait le maximum pour realiser  une  adaptation
       francaise  de qualite.  Veuillez signaler toute erreur de traduction en
       ecrivant a <debian-l10n-french@lists.debian.org> ou par un  rapport  de
       bogue sur le paquet devscripts.

       La  version  anglaise  la  plus  a  jour  de  ce  document est toujours
       consultable en ajoutant l'option << -L C >> a la commande man.