Provided by: sbuild_0.67.0-2ubuntu7_all bug

NAME

       sbuild - build debian packages from source

SYNOPSIS

       sbuild [-h|--help | -V|--version] [-v|--verbose | -q|--quiet] [-D|--debug] [-A|--arch-all]
       [--archive=archive]  [-d|--dist=distribution]  [-c|--chroot=chroot]  [--arch=architecture]
       [--arch-any       |      --no-arch-any]      [--arch-all-only]      [--build=architecture]
       [--host=architecture]  [--profiles=profile[,...]]    [-s|--source]   [--force-orig-source]
       [--make-binNMU=changelog-entry]     [--binNMU=NMU-version]    [--append-to-version=string]
       [--add-depends=dependency]  [--add-conflicts=dependency]   [--add-depends-arch=dependency]
       [--add-conflicts-arch=dependency]         [--add-depends-indep=dependency]         [--add-
       conflicts-indep=dependency]     [-m|--maintainer=maintainer]      [-e|--uploader=uploader]
       [-k|--keyid=key-id] [-j|--jobs=n] [--debbuildopt=option] [--debbuildopts=options] [--dpkg-
       source-opt=options]          [--dpkg-source-opts=options]          [-p|--purge=purge-mode]
       [--purge-build=purge-mode]      [--purge-deps=purge-mode]     [--purge-session=purge-mode]
       [-b|--batch]    [-n|--nolog]    [--clean-source]    [--no-clean-source]    [--run-lintian]
       [--no-run-lintian]   [--lintian-opt=options]   [--lintian-opts=options]   [--run-piuparts]
       [--no-run-piuparts]           [--piuparts-opt=options]           [--piuparts-opts=options]
       [--piuparts-root-arg=options] [--piuparts-root-args=options] [--pre-build-commands=string]
       [--chroot-setup-commands=string]                     [--build-deps-failed-commands=string]
       [--starting-build-commands=string]                      [--finished-build-commands=string]
       [--build-failed-commands=string]                        [--chroot-cleanup-commands=string]
       [--post-build-commands=string]                         [--anything-failed-commands=string]
       [--log-external-command-output] [--log-external-command-error]  [--setup-hook=hook-script]
       [--build-dep-resolver=resolver]         [--resolve-alternatives|--no-resolve-alternatives]
       [--extra-package=package.deb] [--extra-repository=spec]  [--extra-repository-key=file.asc]
       [--build-path=string] [PACKAGE[.dsc]]

DESCRIPTION

       sbuild  rebuilds  Debian  binary packages from the corresponding Debian source, installing
       any missing source dependencies.  The  build  takes  place  in  a  dedicated  clean  build
       environment (chroot), rather than on the host system.

       sbuild  can  fetch  the  Debian  source  over  a  network, or it can use locally available
       sources.

       sbuild is given a packages to process as the argument PACKAGE[.dsc].  This argument is  in
       the form of either a debianized package source directory, a source package name along with
       a version in the form package_version, or a .dsc file. If  no  arguments  are  given,  the
       current working directory is passed as an argument.

       For  arguments  given  as source directories, dpkg-source is first run to produce a source
       .dsc file. Then, the package is built using the .dsc produced. For arguments in  the  form
       package_version, apt is used to download the source package. For arguments given as a .dsc
       file, sbuild builds the source packages directly. For .dsc files in remote locations,  the
       source packages are downloaded first, then built.

       It  is  also  possible  to  run  external  commands  with sbuild. See the section EXTERNAL
       COMMANDS for more on this.

       sbuild mails the build logs to a user.   It  is  configured  by  the  configuration  files
       /etc/sbuild/sbuild.conf   and   ~/.sbuildrc.    An   example   sbuildrc  is  available  in
       /usr/share/doc/sbuild/examples/example.sbuildrc.  A custom path to  a  configuration  file
       can  also  be specified through setting the SBUILD_CONFIG environment variable to the path
       of an additional configuration file.

       You can build either using a local  package  with  its  .dsc  file  or  a  remote  one  by
       specifying an explicit dpkg version.

       Note:  When  using  schroot  (recommended),  the  chroot having the name (or alias) of the
       specified distribution will be used; schroot  uses  a  chroot  named  $distribution-$arch-
       sbuild,  $distribution-sbuild,  $distribution-$arch  or  $distribution,  in  that order of
       preference.  The -c or --chroot option may be used to override the chroot to be used. When
       configured  to  use sudo (deprecated), sbuild will look for a symlink to a chroot with the
       same name as the distribution specified.  sbuild will use a symlink to the chroot  located
       in   /etc/sbuild/chroot/$distribution,  or  must  be  run  in  a  directory  containing  a
       chroot-$distribution symlink to  the  chroot  (not  recommended,  but  done  for  backward
       compatibility).

OPTIONS

       -h, --help
              Display this manual.

       -V, --version
              Print version information.

       --add-depends=dependency

       --add-conflicts=dependency

       --add-depends-arch=dependency

       --add-conflicts-arch=dependency

       --add-depends-indep=dependency

       --add-conflicts-indep=dependency
              These  options  add  a  build  dependencies  to  the source package being built, in
              addition to the build dependency information specified  in  debian/control.   These
              dependencies  will  be concatenated directly to the Build-Depends, Build-Conflicts,
              Build-Depends-Arch, Build-Conflicts-Arch, Build-Depends-Indep and  Build-Conflicts-
              Indep  dependencies,  respectively.  The options may be used any number of times to
              add multiple  dependencies.   The  format  is  identical  to  the  format  used  in
              debian/control.

       --arch=architecture
              Build  using the architecture specified.  A chroot named $distribution-$arch-sbuild
              or $distribution-arch is searched for, in that order  of  preference.   The  chroot
              must  be installed and configured appropriately to build as that architecture, e.g.
              using personality=linux32 to build i386 packages on an  amd64  system.   Note  that
              this option is equivalent to "--host=architecture --build=architecture".

       --host=architecture
              Build  using  the  host architecture specified.  If $host and $build don't match, a
              chroot named  $distribution-$build-$host-sbuild  or  $distribution-$build-$host  is
              searched  for, falling back to $distribution-$build-sbuild or $distribution-$build,
              in that order of preference.  This option is only useful  for  cross-building  when
              used together with --build.

       --build=architecture
              Build  using  the  build  architecture  specified.   This option is only useful for
              cross-building when used together with --host.  If --build is  not  specified,  the
              default system architecture is assumed.

       -A, --arch-all
              Also build Architecture: all packages, i.e. use dpkg-buildpackage -b instead of -B.

       --no-arch-all
              Do  not  build Architecture: all packages, i.e. use dpkg-buildpackage -B instead of
              -b. This option is the opposite of --arch-all.

       --arch-any
              Build Architecture: any packages. This is the default behavior.

       --no-arch-any
              Do not build Architecture: any packages. This option is the opposite of  --arch-any
              and only useful when used together with --arch-all or --source.

       --arch-all-only
              Only  build Architecture:all packages, i.e. use dpkg-buildpackage -A instead of -B.
              The --arch=architecture option can still be used to specify the  architecture  used
              to build the package.

       -b, --batch
              Operate  in  batchmode, i.e. write a build-progress file during execution and files
              on shutdown to facilitate a clean restart.

       -c, --chroot=chroot
              Use  the  specified  chroot.  If  not  specified,  the  default  is  the  first  of
              $distribution-$arch-sbuild,     $distribution-sbuild,     $distribution-$arch    or
              $distribution that exists.

       -d, --dist=distribution
              Explicitly set the distribution for the package build. This will be  selecting  the
              correct  chroot  to  use  and  also sets the value of the Distribution field in the
              created .changes file. Setting this option is necessary when giving sbuild  a  .dsc
              file  or  a plain source package name to build. In the latter case it specifies the
              distribution the source package is fetched from.

       --archive=archive
              Communicate with specified archive.

       -D, --debug
              Enable debug output.

       --apt-clean
       --no-apt-clean
              Run (or do not run) apt-get  clean  in  the  chroot  before  executing  the  build,
              overriding the default setting.

       --apt-update
       --no-apt-update
              Run  (or  do  not  run)  apt-get  update  in the chroot before executing the build,
              overriding the default setting.

       --apt-upgrade
       --no-apt-upgrade
              Run (or do not run) apt-get upgrade in  the  chroot  before  executing  the  build,
              overriding the default setting.

       --apt-distupgrade
       --no-apt-distupgrade
              Run  (or  do not run) apt-get distupgrade in the chroot before executing the build,
              overriding the default setting.

       -m, --maintainer=maintainer
              Specify the identity to use  for  GPG  signing  packages,  and  also  used  as  the
              maintainer for binary NMUs.  This does not normally require setting (it defaults to
              the uploader).

       -e, --uploader=uploader
              Passed to dpkg-genchanges and is used to set the Changed-by: field in the  .changes
              file(s).

       -k, --keyid=key-id
              Passed  to dpkg-genchanges and is used to set the key to sign the .changes file(s).
              Default is not using any key.

       -j, --jobs=n
              Number of jobs to run simultaneously.  Passed through to dpkg-buildpackage.

       --debbuildopt=option
              Pass the specified option directly to dpkg-buildpackage.

       --debbuildopts=options
              Pass the specified options directly to dpkg-buildpackage.  The  options  should  be
              separated by spaces.  If any options contain spaces, use --debbuildopt instead.

       --dpkg-source-opt=options
              Pass the specified options directly to dpkg-source. This is only used when creating
              a source package from a Debianized source directory.
              NOTE: The '-b' option will always be passed to dpkg-source.

       --dpkg-source-opts=options
              Extra options to be appended to existing options passed to dpkg-source.

       --mail-log-to=email-address
              Send the build log to the specified email  address.   This  overrides  the  $mailto
              configuration option.

       --mailfrom=email-address
              Email  address  used  as  the  sender  address  for build logs.  This overrides the
              $mailfrom configuration option.

       -n, --nolog
              Do not create a package log file in the $log_dir directory and no build  log  file,
              but print everything to stdout. Also do not send any log mails.

       -p, --purge=purge-mode
              Convenience  option  to  set purge-mode for build directory, build dependencies and
              session.

       --profiles=profile[,...]"
              Specify the profile(s) we build, as a comma-separated list. Defaults to  the  space
              separated list of profiles in the DEB_BUILD_PROFILES environment variable.

       --purge-build=purge-mode
              purge-mode  determines  if  the  build  directory  will  be  deleted after a build.
              Possible values are always (default), never, and successful.

       --purge-deps=purge-mode
              purge-mode determines if the build dependencies will  be  removed  after  a  build.
              Possible values are always (default), never, and successful.

       --purge-session=purge-mode
              Purge  the  schroot  session following a build.  This is useful in conjunction with
              the --purge-build and --purge-deps options when using snapshot  chroots,  since  by
              default the snapshot will be deleted.  Possible values are always (default), never,
              and successful.

       -s, --source
              Also build source package, i.e. use dpkg-buildpackage without -B.

       --no-source
              Don't build source package, i.e. use dpkg-buildpackage with -B.  This option is the
              opposite of --source.

       --force-orig-source
              When  used  with  in  conjunction  with -s, this option forces the inclusion of the
              orig.tar.gz file in the generated .changes file, even in cases where it  would  not
              normally be included, i.e. use dpkg-buildpackage -sa.

       --use-snapshot
              Installs the latest snapshot gcc compiler from the gcc-snapshot package, and alters
              the build environment to use the snapshot compiler for the build.

       -v, --verbose
              Be verbose, i.e. all information goes to stdout as well as to the log files.

       -q, --quiet
              Be quiet.  This is the opposite of --verbose.

       --make-binNMU=changelog-entry
              With this option, sbuild will create a new changelog entry in  debian/changelog  of
              every  package built. The version number will be in the format for binary-only NMUs
              (see --binNMU); the maintainer is set to the maintainer name configured for sbuild.
              changelog-entry  will  be  used  as the changelog entry following “Binary-only non-
              maintainer upload for ARCH -- no source changes”. Please note that the versions  in
              the  PACKAGE_VERSION[.dsc] arguments still have to be the unmodified (non-NMU ones)
              so that the sources can be found. The version number in log files and mails will be
              modified by sbuild automatically.

       --binNMU=NMU-version
              The  version  number  of  the  binary NMU.  This should be used in conjunction with
              --make-binNMU.  version is a single number for the (+bn)  format  used  for  binary
              NMUs.

       --append-to-version=string
              This  option  is similar to --make-binNMU except that it allows the user to specify
              an arbitrary string to be appended to the version number  (immediately  before  the
              '+' in the Debian revision if --make-binNMU is also provided).

       --clean-source
              When executing sbuild from within an unpacked source tree, execute the debian/rules
              clean target. This is the default and might require some of the build  dependencies
              installed on the host.

       --no-clean-source
              When  executing  sbuild  from  within  an  unpacked  source  tree,  do  not run the
              debian/rules clean target before building the source package. Only set this if  you
              start from a clean checkout and you know what you are doing.

       --run-lintian
              Run lintian after a successful build.

       --no-run-lintian
              Don't run lintian after a successful build.  If sbuild is configured to run lintian
              by default, this option will prevent lintian being run.

       --lintian-opt=options
              Run lintian with the specified options.

       --lintian-opts=options
              Append extra options to existing options passed to lintian.

       --run-piuparts
              Run piuparts after a successful build.

       --no-run-piuparts
              Don't run piuparts after a successful  build.   If  sbuild  is  configured  to  run
              piuparts by default, this option will prevent piuparts being run.

       --piuparts-opt=options
              Run piuparts with the specified options.

       --piuparts-opts=options
              Append extra options to existing options passed to piuparts.

       --piuparts-root-arg=options
              Add  an  argument  that  is  used  to  launch piuparts as root. If no arguments are
              specified, piuparts will be launched via sudo.

       --piuparts-root-args=options
              Add arguments that are used to  launch  piuparts  as  root.  If  no  arguments  are
              specified, piuparts will be launched via sudo.

       --pre-build-commands=string
              This  is  the earliest external command which is run right after the chroot session
              has been initialized and before anything else is done (like  installing  the  build
              dependencies). The command is run as root outside of the chroot. This option can be
              used multiple times to add multiple commands. See the section EXTERNAL COMMANDS for
              more information.

       --chroot-setup-commands=string
              Run  these  commands  after  the  chroot  and  variables have been setup but before
              dependencies are installed. The command is run as root inside of the chroot.   This
              option  can  be  used  multiple  times  to  add  multiple commands. See the section
              EXTERNAL COMMANDS for more information.

       --build-deps-failed-commands=string
              These commands are run if installing the build  dependencies  has  failed  directly
              after  the  failed  attempt.  The  environment  is  intact,  and the failure can be
              investigated.  Especially %SBUILD_SHELL is useful here. The command is run as  root
              inside the chroot. This option can be used multiple times to add multiple commands.
              See the section EXTERNAL COMMANDS for more information.

       --starting-build-commands=string
              Run these commands after dependencies are installed, just before the package  build
              with  dpkg-buildpackage  starts.  The command is run as the (non-root) user running
              sbuild inside the chroot. This option can be used multiple times  to  add  multiple
              commands. See the section EXTERNAL COMMANDS for more information.

       --finished-build-commands=string
              Run these commands immediately after the timed package build finishes.  The command
              is run as the (non-root) user running sbuild inside the chroot.  This option can be
              used multiple times to add multiple commands. See the section EXTERNAL COMMANDS for
              more information.

       --build-failed-commands=string
              These commands are run if dpkg-buildpackage has failed directly  after  the  failed
              attempt.   The  environment  is  intact,  and  the  failure  can  be  investigated.
              Especially %SBUILD_SHELL is useful here. The command is run as the (non-root)  user
              running  %sbuild  inside  the chroot. This option can be used multiple times to add
              multiple commands. See the section EXTERNAL COMMANDS for more information.

       --chroot-cleanup-commands=string
              Run these commands when a chroot is cleaned up, before build directory  is  purged.
              The  command  is  run  as  root inside the chroot. This option can be used multiple
              times to add  multiple  commands.  See  the  section  EXTERNAL  COMMANDS  for  more
              information.

       --post-build-commands=string
              Run  this  command  after a successful build. The command is run as root outside of
              the chroot. This option can be used multiple times to add multiple  commands.   See
              the section EXTERNAL COMMANDS for more information.

       --anything-failed-commands=string
              Run   these   commands  for  all  the  --xxx-failed-commands  options.   Especially
              %SBUILD_SHELL is useful here. This  option  can  be  used  multiple  times  to  add
              multiple commands. See the section EXTERNAL COMMANDS for more information.

       --log-external-command-output
              Write output from external commands to the build log.

       --log-external-command-error
              Write error output from external commands to the build log.

       --setup-hook=hook-script DEPRECATED
              This  option is deprecated. Use of this option will add hook-script to the external
              commands to run via chroot-setup-commands.

       --build-dep-resolver=resolver
              Use the specified resolver to handle selecting the build  dependencies.   Supported
              resolvers  are  apt  (the default), aptitude, aspcud and xapt.  The apt resolver is
              the most appropriate resolver for most users, for building for unstable, stable and
              other  distributions.   If  alternative  build  dependencies  are  used  (excluding
              architecture restrictions), only the first alternative will  be  used;  the  others
              will  be  ignored.   The aptitude resolver is very similar, but smarter and slower,
              and it will consider all alternatives by default; it  is  suited  to  more  complex
              situations,  such  as  building  packages  for the experimental distribution, where
              packages need installing from multiple suites (unstable and experimental).  Due  to
              performance  and other issues (bug #139615), aptitude is not recommended for use by
              default.  If the dependency situation is so complex that neither apt  nor  aptitude
              are  able  to  find a solution, then you can use the aspcud resolver. This resolver
              uses apt-cudf to ask aspcud, a real SAT solver, for a solution to the  installation
              problem.  Since  aspcud  is a real SAT solver it will always find a solution if one
              exists.  The xapt resolver is intended only for cross-building, and is a  temporary
              transitional  feature  which will be removed following the complete introduction of
              multi-arch support.

       --resolve-alternatives
              Allow the use of  alternatives  in  Build-Depends,  Build-Depends-Arch  and  Build-
              Depends-Indep.  This is the default for the aptitude dependency resolver.

       --no-resolve-alternatives
              Do  not  allow  the  use  of  alternatives in Build-Depends, Build-Depends-Arch and
              Build-Depends-Indep.  Note that alternatives for the same package  (e.g.  different
              versions)  are  still allowed.  This is the default for the apt and xapt dependency
              resolvers.

       --extra-package=package.deb
              Make package.deb available for build-dependency  resolution,  by  adding  it  to  a
              temporary  archive  created  by  sbuild.   This  makes  it easier to build packages
              against locally-built build depenencies, without  waiting  for  those  packages  to
              enter  the main archive, or going through the hassle of maintaining a local archive
              and making it accessible inside the chroot.  package.deb is copied into the chroot,
              so it can refer to any path on the host system.

       --extra-repository=spec
              Add  a  repository  to  the  list  of  apt  sources  during the package build.  The
              repository specification is a line suitable for an apt  sources.list(5)  file.  For
              instance,  you might use --extra-repository="deb http://httpredir.debian.org/debian
              experimental main" to allow packages in the experimental  distribution  to  fulfill
              build-dependencies.  Note  that the build chroot must already trust the key of this
              repository or a key must be given with the --extra-repository-key flag.  (see  apt-
              secure(8))

       --extra-repository-key=file.asc
              Add  file.asc  to  the list of trusted keys inside the chroot. The key is read from
              the filename given, and added to the trusted keys. For more information,  see  apt-
              secure(8).  This flag is particularly useful if the target in --extra-repository is
              not signed with a key that's trusted by the base chroot.

       --build-path=string
              By  default  the  package  is  built  in   a   path   of   the   following   format
              /build/packagename-XXXXXX/packagename-version/  where  XXXXXX  is  a  random  ascii
              string. This option allows one to specify a custom path where the package is  built
              inside  the chroot. Notice that the sbuild user in the chroot must have permissions
              to create the path. Common writable locations are subdirectories of /tmp or /build.
              The  buildpath  must  be  an empty directory because the last component of the path
              will be removed after the build is finished. If you  are  running  multiple  sbuild
              instances with the same build path in parallel for the same package, make sure that
              your build path is not in a directory commonly  mounted  by  all  sbuild  instances
              (like /tmp or /home). In that case, use for example /build instead. Otherwise, your
              builds will probably fail or contain wrong content.

       --sbuild-mode=mode
              Behaviour changes for use in a buildd environment.  This overrides the $sbuild_mode
              configuration option.

EXTERNAL COMMANDS

       Support  to  run  external  commands  during  an sbuild run is provided. A set of external
       commands can be run at various stages of a  build.  Providing  commands  to  run  is  done
       through  the  appropriate  options  given  on  the command line and through the use of the
       configuration files. In the configuration file, the list of commands to run are placed  in
       a hash of arrays of arrays of strings corresponding to the commands to run.

       There  are  several sets of commands. The pre/post-build- commands are run external to the
       chroot. The chroot-setup/cleanup- commands and Starting/Finished-Build- commands  are  run
       inside the chroot. They are all run as root except the Starting/Finishing-build- commands,
       which  are  run  as  the  current  sbuild  user.  build-deps-failed  runs   similarly   to
       chroot-setup: in the chroot as root. build-failed runs similarly to finished-build: in the
       chroot as the user.

       Here is a summary of the ordering, user, internal/external to chroot for each command hook

       The following table shows each command hook in the context of the tasks  sbuild  performs.
       The  column  root  shows whether the command is run as root (yes) or not (no).  The column
       chroot shows whether the command is run inside  our  outside  the  chroot.  The  remaining
       columns  show  the  percent escapes that are defined in each command. Percent escapes that
       are available in all commands (%%, %d, %a, %b, %p, %s) are omitted.

       command/action                         root   chroot    %c    %r
       ──────────────────────────────────────────────────────────────────
       Initialise chroot session
       --pre-build-commands                   yes    outside   no    yes
       Setup the chroot and variables
       --chroot-setup-commands                yes    inside    no    no
       Update and upgrade packages
       Install Dependencies
       --build-deps-failed-commands           yes    inside    no    no
       --starting-build-commands              no     inside    no    no
       Run dpkg-buildpackage
       --build-failed-commands                no     inside    no    no
       --finished-build-commands              no     inside    no    no
       Run lintian (if configured)
       Cleanup build files and dependencies
       --chroot-cleanup-commands              yes    inside    yes   no
       Close schroot session
       Run piuparts (if configured)
       --post-build-commands                  yes    outside   yes   yes

       The commands can be given in the configuration files. They can be given as strings or as a
       list  of  arguments.  For  example,  to  run "foo" and "bar" with arguments before a build
       starts, specifying the "foo" command as a list and "bar" as a string, one could do this:

       $external_commands = {
           "pre-build-commands" => [
               ['foo', 'arg1', 'arg2'],
               'bar arg1 arg2 arg3',
           ],
       };

       Hash keys for commands to run at other stages have the same name  as  their  corresponding
       command-line option name without the preceding '--'.

       Here's  an  example  of  how  to  do  the same with the previous example, except using the
       --pre-build-commands option.

       $ sbuild \
             --pre-build-commands='foo arg1 arg2' \
             --pre-build-commands='bar arg1 arg2 arg3'

       Note that all these commands are executed through the shell in  "/bin/sh".  If  specifying
       the  command  as  a  list  in the config file, very few shell facilities are supported: no
       redirection, no command concatenation with ; and so on. When  passing  a  string  (in  the
       config  file or on the commandline), the string is passed as-is to the shell. So all shell
       facilities are available, given that you escape everything properly, as you  would  in  an
       interactive shell.

       Besides  running  external  commands,  sbuild  can  also detect the use of certain percent
       escapes given as arguments. These are used to allow for a command to be  supplied  with  a
       certain argument depending on the escape given.  For example, it could be possible to have
       an external command be given the path to a .changes file.

       Here is a listing of keywords and a description of what it's converted to.

       %%     Used to escape a '%'.

       %d, %SBUILD_DSC
              These escapes are converted to the absolute path to a package's .dsc file.

       %c, %SBUILD_CHANGES
              These escapes are converted to the absolute path to  a  package's  source  .changes
              file.   This   variable   is   only  set  after  the  build  is  finished,  i.e  in
              --chroot-cleanup-commands and --post-build-commands.

       %a, %SBUILD_HOST_ARCH
              These escapes are converted to the debian name of the  architecture  the  build  is
              being built for (e.g amd64, armhf).

       %r, %SBUILD_CHROOT_DIR
              These  escapes are converted to the absolute path on the host to the root directory
              of the chroot. This variable is not set if the external command is run  inside  the
              chroot.   Thus   this   escape  is  only  available  for  --pre-build-commands  and
              --post-build-commands.

       %b, %SBUILD_BUILD_DIR
              These escapes are converted to the absolute path to the build directory inside  the
              chroot.

       %p, %SBUILD_PKGBUILD_DIR
              These  escapes  are  converted  to the absolute path to the package build directory
              inside the chroot.

       %s, %SBUILD_SHELL
              This is converted to a command to spawn an interactive "bash" shell

       Percent escapes are only substituted when an appropriate value is  defined  for  them.  At
       other  times, it is left unchanged. In practice this means that there are only two escapes
       that are not available in all external commands: %c and %r. For example, a  .changes  file
       is  only  defined  at  the  end of a build, so using %c will only be substituted for post-
       build-commands.

       Here's an example of using an escape to run a program foo on a .changes file after a build
       is done.

       $ sbuild --post-build-commands \
             'foo %SBUILD_CHANGES'

       And  here's  an  example  that  will spawn an interactive shell to investigate the problem
       whenever the build failed:

       $ sbuild --build-failed-commands '%s'

       One final note, external commands are processed in the order they are  given.   Also,  the
       commands  given  in  a  configuration  file  are  processed first, then the commands given
       through the command line options.

LOCAL ARCHIVE

       The apt and aptitude resolvers create a local archive for installing  build  dependencies.
       This  is  an internal implementation detail of the build dependency resolver, which is not
       user configurable, and is intended to be entirely transparent  to  the  user.   The  local
       archive  exists  only  transiently  during  the package build.  It does not persist across
       builds, and it is only used to store the dummy dependency packages created  for  a  single
       build.

       The dependency resolvers do the following:

       ·      Create a dummy dependency package.  This contains the Build-Depends (and optionally
              Build-Depends-Arch and Build-Depends-Indep) as Depends,  and  Build-Conflicts  (and
              optionally Build-Conflicts-Arch and Build-Conflicts-Indep) as Conflicts.

       ·      Install the dummy dependency package into the local archive,

       ·      Generate the Packages, Sources and Release files.

       ·      Write a sources.list file for the local archive into /etc/apt/sources.list.d.

       ·      Inject  the  lists  directly into /var/lib/apt/lists.  This step is to save running
              updating all apt sources which is undesirable during a build; apt and  aptitude  do
              not support updating a single source at present.

       ·      Regenerate the apt caches to ensure everything is in sync.

       ·      Install  the  dummy  dependency  package with apt or aptitude; the dummy package is
              pulled from the local apt archive, while all its dependencies are pulled  from  the
              regular configured apt sources.

       At  the  end  of the build, the local archive is removed, along with the rest of the build
       tree.

ENVIRONMENT VARIABLES

       The following environment variables are used by sbuild:

       HOME   The home directory of the user.

       LOGNAME
              Used in lockfiles.

       SBUILD_CONFIG
              Path to an additional configuration file  on  top  of  the  system  wide  and  user
              specific ones.

FILES

       /etc/sbuild/sbuild.conf
              Configuration,  maintained  by  the  system  administrator.   This  may  be used to
              override the defaults.

       /etc/sbuild/chroot
              Directory containing symbolic links to chroots.  This is only used for sudo  chroot
              access; schroot access uses the schroot chroot configuration.

       ~/.sbuildrc
              User-specific configuration.

       /var/lib/sbuild
              Build trees, archive signing keys, build statistics and lock files.

AUTHORS

       Roman Hodek <Roman.Hodek@informatik.uni-erlangen.de>.

       sbuild  is  based  on  debbuild,  written  by  James Troup <james@nocrew.org> and has been
       modified by
       Ben Collins <bcollins@debian.org>,
       Ryan Murray <rmurray@debian.org>,
       Francesco Paolo Lovergine <frankie@debian.org>,
       Michael Banck <mbanck@debian.org>, and
       Roger Leigh <rleigh@debian.org>

COPYRIGHT

       Copyright © 1998-2000 Roman Hodek <roman@hodek.net>
       Copyright © 1998-1999 James Troup <troup@debian.org>
       Copyright © 2003-2006 Ryan Murray <rmurray@debian.org>
       Copyright © 2001-2003 Rick Younie <younie@debian.org>
       Copyright © 2003-2004 Francesco Paolo Lovergine <frankie@debian.org>
       Copyright © 2005      Michael Banck <mbanck@debian.org>
       Copyright © 2005-2009 Roger Leigh <rleigh@debian.org>

SEE ALSO

       sbuild.conf(5),         sbuild-abort(1),         sbuild-adduser(8),         sbuild-apt(1),
       sbuild-checkpackages(1),  sbuild-createchroot(8),  sbuild-distupgrade(1),  sbuild-hold(1),
       sbuild-setup(7).  sbuild-shell(1), sbuild-unhold(1), sbuild-update(1),  sbuild-upgrade(1),
       schroot(1),