Provided by: sbuild_0.75.0-1ubuntu1_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]           [--chroot-
       mode=schroot|sudo|autopkgtest]  [--arch=architecture] [--arch-any | --no-arch-any] [--build=architecture]
       [--host=architecture]       [--profiles=profile[,...]]         [-s|--source]        [--force-orig-source]
       [--make-binNMU=changelog-entry]            [--binNMU=NMU-version]            [--append-to-version=string]
       [--binNMU-timestamp=timestamp]    [--binNMU-changelog=changelog]    [--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] [--source-only-changes] [-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]   [--run-autopkgtest]  [--no-run-autopkgtest]  [--autopkgtest-opt=options]
       [--autopkgtest-opts=options]      [--autopkgtest-root-arg=options]      [--autopkgtest-root-args=options]
       [--pre-build-commands=string]  [--chroot-setup-commands=string]  [--chroot-update-failed-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]  [--autopkgtest-virt-
       server=schroot|lxc|chroot|qemu|ssh]                                [--autopkgtest-virt-server-opt=string]
       [--autopkgtest-virt-server-opts=options]                                         [--purge-extra-packages]
       [--bd-uninstallable-explainer=dose3|apt] [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, a source package name, 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 or  package,  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

       Options set on the command line overwrite settings made in the configuration file.

       -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.  These command  line  options  append  to  the  MANUAL_DEPENDS,  MANUAL_CONFLICTS,
              MANUAL_DEPENDS_ARCH,   MANUAL_CONFLICTS_ARCH,   MANUAL_DEPENDS_INDEP   and  MANUAL_CONFLICTS_INDEP
              configuration variables, respectively. See sbuild.conf(5) for more information.

       --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".  This command line option sets the HOST_ARCH and  BUILD_ARCH  configuration
              variables. See sbuild.conf(5) for more information.

       --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.  This command line option sets the
              HOST_ARCH configuration variable. See sbuild.conf(5) for more information.

       --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.   This command line option sets the BUILD_ARCH configuration variable. See sbuild.conf(5)
              for more information.

       -A, --arch-all
              Also build Architecture: all packages. This option is the  opposite  of  --no-arch-all.   See  the
              section  BUILD  ARTIFACTS  for more information.  This command line option sets the BUILD_ARCH_ALL
              configuration variable. See sbuild.conf(5) for more information.

       --no-arch-all
              Do not build Architecture: all packages. This  is  the  default  behaviour.  This  option  is  the
              opposite  of --arch-all.  See the section BUILD ARTIFACTS for more information.  This command line
              option sets the BUILD_ARCH_ALL configuration variable. See sbuild.conf(5) for more information.

       --arch-any
              Build Architecture: any packages. This is the default behavior. This option  is  the  opposite  of
              --no-arch-any.   See  the  section BUILD ARTIFACTS for more information.  This command line option
              sets the BUILD_ARCH_ANY configuration variable. See sbuild.conf(5) for more information.

       --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.   See  the  section BUILD ARTIFACTS for more
              information.  This command  line  option  sets  the  BUILD_ARCH_ANY  configuration  variable.  See
              sbuild.conf(5) for more information.

       -b, --batch
              Operate  in  batchmode, i.e. write a build-progress file during execution and files on shutdown to
              facilitate a clean restart.  This command line option sets the BATCH_MODE configuration  variable.
              See sbuild.conf(5) for more information.

       -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.   This  command line option sets the CHROOT configuration variable. See sbuild.conf(5) for
              more information.

       --chroot-mode=schroot|sudo|autopkgtest
              Select the desired chroot mode. Four values are possible: schroot (the default), sudo (which  uses
              sudo  to  execute chroot in a directory from /etc/sbuild/chroot or ./chroot) and autopkgtest which
              uses the autopkgtest-virt-* binaries (selectable via the --autopkgtest-virt-server option).   This
              command  line  option  sets  the  CHROOT_MODE  configuration variable. See sbuild.conf(5) for more
              information.

       -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.  This command
              line option sets the DISTRIBUTION configuration variable. See sbuild.conf(5) for more information.

       --archive=archive
              Communicate with specified archive.  This command  line  option  sets  the  ARCHIVE  configuration
              variable. See sbuild.conf(5) for more information.

       -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.  This command line option sets the APT_CLEAN configuration variable.  See  sbuild.conf(5)
              for more information.

       --apt-update
       --no-apt-update
              Run  (or  do  not  run)  apt-get  update  in the chroot before executing the build, overriding the
              default setting.  This option has no effect on updating the internal sbuild  apt  repository,  the
              repository  for  extra  packages  (see  --extra-package)  and  the repositories given via --extra-
              repository. These are always updated. Thus, this option only influences  updates  of  the  default
              repositories  of the chroot.  This command line option sets the APT_UPDATE configuration variable.
              See sbuild.conf(5) for more information.

       --apt-upgrade
       --no-apt-upgrade
              Run (or do not run) apt-get upgrade in the chroot  before  executing  the  build,  overriding  the
              default  setting.   This  command  line  option  sets  the APT_UPGRADE configuration variable. See
              sbuild.conf(5) for more information.

       --apt-distupgrade
       --no-apt-distupgrade
              Run (or do not run) apt-get distupgrade in the chroot before executing the build,  overriding  the
              default  setting.   This  command line option sets the APT_DISTUPGRADE configuration variable. See
              sbuild.conf(5) for more information.

       -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).  This command line
              option sets the MAINTAINER_NAME configuration variable. See sbuild.conf(5) for more information.

       -e, --uploader=uploader
              Passed to dpkg-genchanges and is used to set the Changed-by: field in the .changes file(s).   This
              command  line  option  sets  the UPLOADER_NAME configuration variable. See sbuild.conf(5) for more
              information.

       -k, --keyid=key-id
              Passed to debsign and is used to set the key to sign the .changes file(s).  Default is  not  using
              any  key  and  not  signing  the  .changes  file(s).   This  command  line  option sets the KEY_ID
              configuration variable. See sbuild.conf(5) for more information.

       --source-only-changes
              In addition to the .changes file generated by dpkg-buildpackage,  also  produce  a  .changes  file
              suitable for a source-only upload. If requested by --keyid, this .changes file will also be signed
              by debsign.  This command line option sets the  SOURCE_ONLY_CHANGES  configuration  variable.  See
              sbuild.conf(5) for more information.

       -j, --jobs=n
              Number  of  jobs  to  run simultaneously.  Passed through to dpkg-buildpackage.  This command line
              option appends the appropriate  -j  option  to  the  DPKG_BUILDPACKAGE_USER_OPTIONS  configuration
              variable. See sbuild.conf(5) for more information.

       --debbuildopt=option
              Pass  the specified option directly to dpkg-buildpackage in addition to the options already passed
              by sbuild. This option can be passed multiple times (once per dpkg-buildpackage option) and can be
              freely  mixed  with  the --debbuildopts option. Options will be passed to dpkg-buildpackage in the
              order that the --debbuildopt and --debbuildopts options are  given  on  the  command  line.   This
              command  line  option  appends  to  the DPKG_BUILDPACKAGE_USER_OPTIONS configuration variable. See
              sbuild.conf(5) for more information.

       --debbuildopts=options
              Pass the specified options directly to dpkg-buildpackage in addition to the options already passed
              by  sbuild.  The  argument  will  be  split  by  whitespaces and the resulting array passed to the
              dpkg-buildpackage invocation. If any options contain spaces, use  --debbuildopt  for  them.   This
              option can be passed multiple times and can be freely mixed with the --debbuildopt option. Options
              will be passed to dpkg-buildpackage in the order that the --debbuildopt and --debbuildopts options
              are    given    on    the   command   line.    This   command   line   option   appends   to   the
              DPKG_BUILDPACKAGE_USER_OPTIONS configuration variable. See sbuild.conf(5) for more information.

       --dpkg-source-opt=options
              Pass the specified option directly to dpkg-source in addition to the  options  already  passed  by
              sbuild.  This is only used when creating a source package from a Debianized source directory. This
              option can be passed multiple times (once per dpkg-source option) and can be freely mixed with the
              --dpkg-source-opts  option.  Options  will  be  passed  to  dpkg-source  in  the  order  that  the
              --dpkg-source-opt and --dpkg-source-opts options are given on the command line.  This command line
              option  appends  to  the  DPKG_SOURCE_OPTIONS  configuration variable. See sbuild.conf(5) for more
              information.
              NOTE: The '-b' option will always be passed to dpkg-source.

       --dpkg-source-opts=options
              Pass the specified options directly to dpkg-source in addition to the options  already  passed  by
              sbuild.  The  argument  will  be  split  by  whitespaces  and  the  resulting  array passed to the
              dpkg-source invocation. This is only used when creating a source package from a Debianized  source
              directory.  If  any  options  contain  spaces, use --dpkg-source-opt for them.  This option can be
              passed multiple times and can be freely mixed with the --dpkg-source-opt option.  Options will  be
              passed  to  dpkg-source in the order that the --dpkg-source-opt and --dpkg-source-opts options are
              given on  the  command  line.   This  command  line  option  appends  to  the  DPKG_SOURCE_OPTIONS
              configuration variable. See sbuild.conf(5) for more information.

       --mail-log-to=email-address
              Send  the  build  log  to  the  specified email address.  This command line option sets the MAILTO
              configuration variable. See sbuild.conf(5) for more information.

       --mailfrom=email-address
              Email address used as the sender address for build  logs.   This  command  line  option  sets  the
              MAILFROM configuration variable. See sbuild.conf(5) for more information.

       -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.  This command line  option  sets  the  NOLOG
              configuration variable. See sbuild.conf(5) for more information.

       --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.  This command  line  option  sets  the
              BUILD_PROFILES configuration variable. See sbuild.conf(5) for more information.

       -p, --purge=purge-mode
              Convenience  option  to  set purge-mode for build directory, build dependencies and session.  This
              command  line  option  sets  the   PURGE_BUILD_DEPS,   PURGE_BUILD_DIRECTORY   and   PURGE_SESSION
              configuration variables. See sbuild.conf(5) for more information.

       --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.  This command line option sets the  PURGE_BUILD_DIRECTORY
              configuration variable. See sbuild.conf(5) for more information.

       --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.  This  command  line  option  sets  the  PURGE_BUILD_DEPS
              configuration variable. See sbuild.conf(5) for more information.

       --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.  This command line option
              sets the PURGE_SESSION configuration variable. See sbuild.conf(5) for more information.

       -s, --source
              Build the source package in addition to the other requested build artifacts. By default,  the  dsc
              will not be rewritten because the source package is the input to sbuild, not its output. Even when
              running from an unpacked source tree sbuild will first build the source package using  dpkg-source
              and  then  pass  that  on to the sbuild machinery. Use this option only when you know what you are
              doing. This will rewrite the original dsc passed to sbuild.  See the section BUILD  ARTIFACTS  for
              more  information.   This  command  line  option sets the BUILD_SOURCE configuration variable. See
              sbuild.conf(5) for more information.

       --no-source
              Don't rebuild the source package. This is the default. It is the opposite of  --source.   See  the
              section  BUILD  ARTIFACTS  for  more  information.  This command line option sets the BUILD_SOURCE
              configuration variable. See sbuild.conf(5) for more information.

       --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.   This  command  line  option  sets  the  FORCE_ORIG_SOURCE  configuration
              variable. See sbuild.conf(5) for more information.

       --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.   Specifically,  this  option  appends
              /usr/lib/gcc-snapshot/lib   to  the  value  of  the  LD_LIBRARY_PATH  configuration  variable  and
              /usr/lib/gcc-snapshot/bin to the value of the PATH  configuration  variable.   It  also  sets  the
              GCC_SNAPSHOT configuration variable. See sbuild.conf(5) for more information.

       -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.  The --append-to-version option has a similar
              effect but allows one to specify an arbitrary version suffix instead of a custom changelog  entry.
              To   have   a  custom  version  suffix  and  a  custom  changelog  entry,  use  --make-binNMU  and
              --append-to-version  at  the  same  time  with  --binNMU=0.   This  option  is  incompatible  with
              --binNMU-changelog.  This command line option sets the BIN_NMU configuration variable and sets the
              BIN_NMU_VERSION configuration variable to 1 if it was not set yet, for  example  by  the  --binNMU
              option. See sbuild.conf(5) for more information.

       --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.   If  the  argument  is  the
              empty  string  or zero, then the +bn suffix will not be appended.  The +bn suffix will be appended
              after  the  string  given   via   --append-to-version.    This   option   is   incompatible   with
              --binNMU-changelog.  This command line option sets the BIN_NMU_VERSION configuration variable. See
              sbuild.conf(5) for more information.

       --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).  To pass an arbitrary changelog text as well, combine this option
              with  --make-binNMU  but  be  aware  that  this  will also add the +bn suffix unless you also pass
              --binNMU=0 to disable it.  This option is incompatible with --binNMU-changelog.  This command line
              option sets the APPEND_TO_VERSION configuration variable. See sbuild.conf(5) for more information.

       --binNMU-timestamp=timestamp
              Set  the  timestamp  of  the new binNMU changelog entry. By default, the time of the build will be
              used to generate the binNMU changelog timestamp. This option allows one to use a custom  timestamp
              instead.  The  timestamp  is  either given as an integer in Unix time or as a string in the format
              compatible with Debian changelog entries (i.e. as it is generated by date  -R).   This  option  is
              incompatible  with  --binNMU-changelog.   This  command  line  option  sets  the BIN_NMU_TIMESTAMP
              configuration variable. See sbuild.conf(5) for more information.

       --binNMU-changelog=changelog
              Set the complete content of a binary-only changelog entry. This option allows  full  customization
              of  the  new  changelog entry. It is up to the user to make sure that the changelog entry is well-
              formed. The argument has to include all necessary newlines. Leading and trailing newlines will  be
              stripped.   Sbuild  will  not  interpret  any backslash escapes.  This option is incompatible with
              --make-binNMU, --binNMU, --append-to-version and --binNMU-timestamp.   This  command  line  option
              sets the BIN_NMU_CHANGELOG configuration variable. See sbuild.conf(5) for more information.

       --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.   This
              command  line  option  sets  the  CLEAN_SOURCE configuration variable. See sbuild.conf(5) for more
              information.

       --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.   This  command  line  option  sets  the  CLEAN_SOURCE  configuration
              variable. See sbuild.conf(5) for more information.

       --run-lintian
              Run lintian after a successful build.  This command line option sets the RUN_LINTIAN configuration
              variable. See sbuild.conf(5) for more information.

       --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.   This  command line option sets the RUN_LINTIAN
              configuration variable. See sbuild.conf(5) for more information.

       --lintian-opt=options
              Pass the specified option directly to lintian in addition to the options already passed by sbuild.
              This  option  can  be passed multiple times (once per lintian option) and can be freely mixed with
              the --lintian-opts option.  Options will be passed to lintian in the order that the  --lintian-opt
              and --lintian-opts options are given on the command line.  This command line option appends to the
              LINTIAN_OPTIONS configuration variable. See sbuild.conf(5) for more information.

       --lintian-opts=options
              Pass the specified options directly to lintian in  addition  to  the  options  already  passed  by
              sbuild.  The  argument  will be split by whitespaces and the resulting array passed to the lintian
              invocation. If any options contain spaces, use --lintian-opt for them.  This option can be  passed
              multiple  times  and can be freely mixed with the --lintian-opts option. Options will be passed to
              lintian in the order that the --lintian-opt and --lintian-opts options are given  on  the  command
              line.   This  command  line  option  appends  to  the  LINTIAN_OPTIONS configuration variable. See
              sbuild.conf(5) for more information.

       --run-piuparts
              Run  piuparts  after  a  successful  build.   This  command  line  option  sets  the  RUN_PIUPARTS
              configuration variable. See sbuild.conf(5) for more information.

       --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.  This  command  line  option  sets  the  RUN_PIUPARTS
              configuration variable. See sbuild.conf(5) for more information.

       --piuparts-opt=options
              Pass  the  specified  option  directly  to  piuparts  in addition to the options already passed by
              sbuild. This option can be passed multiple times (once per piuparts  option)  and  can  be  freely
              mixed  with  the --piuparts-opts option.  Options will be passed to piuparts in the order that the
              --piuparts-opt and --piuparts-opts options are given on the command line.  Certain percent escapes
              are  supported.  To  write  a  literal  percent sign, escape it with another percent sign. See the
              section OPTION STRING PERCENT ESCAPES for more information.  This command line option  appends  to
              the PIUPARTS_OPTIONS configuration variable. See sbuild.conf(5) for more information.

       --piuparts-opts=options
              Pass  the  specified  options  directly  to  piuparts in addition to the options already passed by
              sbuild. The argument will be split by whitespaces and the resulting array passed to  the  piuparts
              invocation. If any options contain spaces, use --piuparts-opt for them.  This option can be passed
              multiple times and can be freely mixed with the --piuparts-opts option. Options will be passed  to
              piuparts in the order that the --piuparts-opt and --piuparts-opts options are given on the command
              line.  Certain percent escapes are supported. To write a literal  percent  sign,  escape  it  with
              another  percent  sign.  See the section OPTION STRING PERCENT ESCAPES for more information.  This
              command line option appends to the PIUPARTS_OPTIONS configuration variable. See sbuild.conf(5) for
              more information.

       --piuparts-root-arg=options
              Add  an  argument  that is used to launch piuparts as root. Without this option, the default is to
              use "sudo --" to launch piuparts. If an empty  string  is  supplied,  then  piuparts  is  launched
              without  any  prefixed  command.   This option can be specified multiple times.  This command line
              option appends to the PIUPARTS_ROOT_ARGS  configuration  variable.  See  sbuild.conf(5)  for  more
              information.

       --piuparts-root-args=options
              Add  arguments  that  are used to launch piuparts as root.  Without this option, the default is to
              use "sudo --" to launch piuparts. If an empty  string  is  supplied,  then  piuparts  is  launched
              without  any  prefixed  command.   The  argument  will  be  split  by whitespaces. To pass options
              containing whitespaces use the option --piuparts-root-arg.  This command line  option  appends  to
              the PIUPARTS_ROOT_ARGS configuration variable. See sbuild.conf(5) for more information.

       --run-autopkgtest
              Run  autopkgtest  after  a  successful  build.   This command line option sets the RUN_AUTOPKGTEST
              configuration variable. See sbuild.conf(5) for more information.

       --no-run-autopkgtest
              Don't run autopkgtest after a successful build.  If sbuild is configured  to  run  autopkgtest  by
              default,  this  option  will  prevent  autopkgtest  being  run.  This command line option sets the
              RUN_AUTOPKGTEST configuration variable. See sbuild.conf(5) for more information.

       --autopkgtest-opt=options
              Pass the specified option directly to autopkgtest in addition to the  options  already  passed  by
              sbuild.  This  option can be passed multiple times (once per autopkgtest option) and can be freely
              mixed with the --autopkgtest-opts option.  Options will be passed to autopkgtest in the order that
              the  --autopkgtest-opt  and  --autopkgtest-opts  options  are  given on the command line.  Certain
              percent escapes are supported. To write a literal percent sign, escape  it  with  another  percent
              sign.  See  the  section  OPTION  STRING  PERCENT ESCAPES for more information.  This command line
              option appends to the AUTOPKGTEST_OPTIONS configuration  variable.  See  sbuild.conf(5)  for  more
              information.

       --autopkgtest-opts=options
              Pass  the  specified  options directly to autopkgtest in addition to the options already passed by
              sbuild. The argument will  be  split  by  whitespaces  and  the  resulting  array  passed  to  the
              autopkgtest  invocation.  If  any  options  contain  spaces, use --autopkgtest-opt for them.  This
              option can be passed multiple times and can be freely mixed with  the  --autopkgtest-opts  option.
              Options   will   be   passed   to   autopkgtest  in  the  order  that  the  --autopkgtest-opt  and
              --autopkgtest-opts options are given on the command line.  Certain percent escapes are  supported.
              To  write  a  literal  percent  sign,  escape it with another percent sign. See the section OPTION
              STRING  PERCENT  ESCAPES  for  more  information.   This  command  line  option  appends  to   the
              AUTOPKGTEST_OPTIONS configuration variable. See sbuild.conf(5) for more information.

       --autopkgtest-root-arg=options
              Add an argument that is used to launch autopkgtest as root. Without this option, the default is to
              use "sudo --" to launch autopkgtest. If an empty string is supplied, then autopkgtest is  launched
              without  any  prefixed  command.   This option can be specified multiple times.  This command line
              option appends to the AUTOPKGTEST_ROOT_ARGS configuration variable. See  sbuild.conf(5)  for  more
              information.

       --autopkgtest-root-args=options
              Add arguments that are used to launch autopkgtest as root.  Without this option, the default is to
              use "sudo --" to launch autopkgtest. If an empty string is supplied, then autopkgtest is  launched
              without  any  prefixed  command.   The  argument  will  be  split  by whitespaces. To pass options
              containing whitespaces use the option --autopkgtest-root-arg.  This command line option appends to
              the AUTOPKGTEST_ROOT_ARGS configuration variable. See sbuild.conf(5) for more information.

       --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. Certain percent escapes are supported. To write a literal percent sign, escape  it  with
              another  percent  sign. See the section EXTERNAL COMMANDS for more information.  This command line
              option appends to the  EXTERNAL_COMMANDS  configuration  variable.  See  sbuild.conf(5)  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. Certain percent escapes are supported. To write a literal percent
              sign, escape it with another percent sign. See the section EXTERNAL COMMANDS for more information.
              This   command   line   option  appends  to  the  EXTERNAL_COMMANDS  configuration  variable.  See
              sbuild.conf(5) for more information.

       --chroot-update-failed-commands=string
              Run these commands after any of 'apt-get update',  'apt-get  upgrade'  or  'apt-get  dist-upgrade'
              failed.   This  hook  is not run for updates of the internal sbuild apt repository, the repository
              for extra packages (see --extra-package) and the repositories given via  --extra-repository.   The
              environment  is  intact,  and  the failure can be investigated. Especially %SBUILD_SHELL is useful
              here. This option can be used multiple times to add multiple commands. Certain percent escapes are
              supported.   To  write a literal percent sign, escape it with another percent sign.See the section
              EXTERNAL COMMANDS for more information.  This command line option appends to the EXTERNAL_COMMANDS
              configuration variable. See sbuild.conf(5) 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. Certain percent escapes are supported. To write a literal  percent
              sign, escape it with another percent sign. See the section EXTERNAL COMMANDS for more information.
              This  command  line  option  appends  to  the  EXTERNAL_COMMANDS   configuration   variable.   See
              sbuild.conf(5) 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. Certain percent escapes are
              supported. To write a literal percent sign, escape it with another percent sign. See  the  section
              EXTERNAL COMMANDS for more information.  This command line option appends to the EXTERNAL_COMMANDS
              configuration variable. See sbuild.conf(5) 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. Certain percent escapes are supported. To write a literal percent sign,  escape
              it  with  another  percent  sign.  See  the  section EXTERNAL COMMANDS for more information.  This
              command line option appends to the EXTERNAL_COMMANDS configuration  variable.  See  sbuild.conf(5)
              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. Certain percent escapes are supported. To write a
              literal  percent  sign, escape it with another percent sign. See the section EXTERNAL COMMANDS for
              more information.  This  command  line  option  appends  to  the  EXTERNAL_COMMANDS  configuration
              variable. See sbuild.conf(5) 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.
              Certain  percent  escapes  are supported.  To write a literal percent sign, escape it with another
              percent sign. See the section EXTERNAL COMMANDS for more information.  This  command  line  option
              appends to the EXTERNAL_COMMANDS configuration variable. See sbuild.conf(5) 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.   Certain  percent  escapes  are
              supported.  To  write a literal percent sign, escape it with another percent sign. See the section
              EXTERNAL COMMANDS for more information.  This command line option appends to the EXTERNAL_COMMANDS
              configuration variable. See sbuild.conf(5) 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. Certain percent escapes are
              supported.  To  write a literal percent sign, escape it with another percent sign. See the section
              EXTERNAL COMMANDS for more information.  This command line option appends to the EXTERNAL_COMMANDS
              configuration variable. See sbuild.conf(5) for more information.

       --log-external-command-output
              Write  output  from  external  commands  to  the  build  log.   This  command line option sets the
              LOG_EXTERNAL_COMMAND_OUTPUT configuration variable. See sbuild.conf(5) for more information.

       --log-external-command-error
              Write error output from external commands to the build log.  This command  line  option  sets  the
              LOG_EXTERNAL_COMMAND_ERROR configuration variable. See sbuild.conf(5) for more information.

       --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.  This command line option sets  the  CHROOT_SETUP_SCRIPT  configuration
              variable  and appends to the EXTERNAL_COMMANDS configuration variable. See sbuild.conf(5) for more
              information.

       --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 solver (in  the  math  sense),  to  find  a  solution  to  the
              installation  problem.  Since  aspcud  uses  a  real  solver (an ASP solver) it will always find a
              solution if one exists. The solution found by the aspcud resolver can be refined by  changing  the
              default optimization criteria through the --aspcud-criteria option.  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.   This  command  line  option  sets  the
              BUILD_DEP_RESOLVER configuration variable. See sbuild.conf(5) for more information.

       --aspcud-criteria=criteria
              Optimization  criteria  in  extended  MISC  2012  syntax  passed  to  aspcud   through   apt-cudf.
              Optimization  criteria  are  separated  by  commas, sorted by decreasing order of priority and are
              prefixed  with  a  polarity  (+  to  maximize  and  -  to  minimize).   The  default  criteria  is
              -removed,-changed,-new  which  first  minimizes the number of removed packages, then the number of
              changed packages (up or downgrades) and then the number of new  packages.  A  common  task  is  to
              minimize  the  number  of  packages  from  experimental.   To  do this you can add a criteria like
              -count(solution,APT-Release:=/a=experimental/) to the default criteria.  This will  then  minimize
              the  number of packages in the solution which contain the string a=experimental in the APT-Release
              field of the EDSP output created by apt. For more help on how to write optimization criteria,  see
              the  apt-cudf(1)  man  page.  Specifically  the  help on the --criteria option.  This command line
              option sets the ASPCUD_CRITERIA configuration variable. See sbuild.conf(5) for more information.

       --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.   This  command  line  option sets the
              RESOLVE_ALTERNATIVES configuration variable. See sbuild.conf(5) for more information.

       --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.   This  command  line  option  sets  the
              RESOLVE_ALTERNATIVES configuration variable. See sbuild.conf(5) for more information.

       --extra-package=package.deb|directory
              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
              dependencies,  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.  If a directory is passed
              instead of a regular file, then all regular files inside that directory with a filename that  ends
              in  .deb  will  be  added in the same fashion as it is done for individual packages.  This command
              line option appends to the EXTRA_PACKAGES configuration  variable.  See  sbuild.conf(5)  for  more
              information.

       --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)).   This  command  line  option  appends   to   the   EXTRA_REPOSITORIES
              configuration variable. See sbuild.conf(5) for more information.

       --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.  This command line option  appends  to  the  EXTRA_REPOSITORY_KEYS  configuration
              variable. See sbuild.conf(5) for more information.

       --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. The sbuild user in the chroot
              must have permissions to create the path. Common writable locations are subdirectories of /tmp  or
              /build.  Using  /tmp might be dangerous, because (depending on the chroot backend) the /tmp inside
              the chroot might be a world writable location that  can  be  accessed  by  processes  outside  the
              chroot.  The  directory  /build  can only be accessed by the sbuild user and group and should be a
              safe location.  The buildpath must be an empty directory because the last component  of  the  path
              will  be  removed  after  the build is finished.  Notice that depending on the chroot backend (see
              --chroot-mode), some locations inside the chroot might be bind mounts that are shared  with  other
              sbuild  instances.  You  must  avoid  using  these shared locations as the build path or otherwise
              concurrent runs of sbuild will likely fail. With the default schroot chroot backend, the directory
              /build   is   shared  between  multiple  schroot  sessions.  You  can  change  this  behaviour  in
              /etc/schroot/sbuild/fstab. The behaviour of other chroot backends will vary.   This  command  line
              option sets the BUILD_PATH configuration variable. See sbuild.conf(5) for more information.

       --autopkgtest-virt-server=schroot|lxc|chroot|qemu|ssh
              The  autopkgtest  virtualization  server.  Can  be specified with or without the autopkgtest-virt-
              prefix.  For instance, the following set of command line options will  use  the  autopkgtest-virt-
              schroot  backend  for a package build: --chroot-mode=autopkgtest --autopkgtest-virt-server=schroot
              --chroot unstable-amd64-sbuild The value of the  --chroot  option  will  be  passed  as  the  last
              positional  argument  to the autopkgtest-virt-* invocation. Thus, the value of the --chroot option
              becomes the image name of the virtual machine in case of autopkgtest-virt-qemu, the  lxc-container
              name  in  case of autopkgtest-virt-lxc, the path to the chroot in case of autopkgtest-virt-chroot,
              the name of the schroot in case of autopkgtest-virt-schroot and so on.  This command  line  option
              sets the AUTOPKGTEST_VIRT_SERVER configuration variable. See sbuild.conf(5) for more information.

       --autopkgtest-virt-server-opt=string
              Pass  the  specified option directly to the respective autopkgtest-virt-* virtualization server in
              addition to the options already passed by sbuild. This option can be passed multiple  times  (once
              per  autopkgtest-virt-*  option)  and  can be freely mixed with the --autopkgtest-virt-server-opts
              option.  Options will be passed to the respective autopkgtest-virt-* virtualization server in  the
              order  that the --autopkgtest-virt-server-opt and --autopkgtest-virt-server-opts options are given
              on the command line.  See the manual pages of the respective autopkgtest-virt-* commands for  more
              information.   Certain  percent  escapes are supported. To write a literal percent sign, escape it
              with another percent sign. See the section OPTION STRING PERCENT  ESCAPES  for  more  information.
              This  command  line  option appends to the AUTOPKGTEST_VIRT_SERVER_OPTIONS configuration variable.
              See sbuild.conf(5) for more information.

       --autopkgtest-virt-server-opts=options
              Pass the specified options directly to the respective autopkgtest-virt-* virtualization server  in
              addition  to  the  options already passed by sbuild. The argument will be split by whitespaces and
              the resulting array passed to the autopkgtest-virt-* invocation. If any  options  contain  spaces,
              use  --autopkgtest-virt-server-opt  for them.  This option can be passed multiple times and can be
              freely mixed with the  --autopkgtest-virt-server-opts  option.  Options  will  be  passed  to  the
              respective     autopkgtest-virt-*    virtualization    server    in    the    order    that    the
              --autopkgtest-virt-server-opt and --autopkgtest-virt-server-opts options are given on the  command
              line.  See  the  manual  pages of the respective autopkgtest-virt-* commands for more information.
              Certain percent escapes are supported. To write a literal percent sign,  escape  it  with  another
              percent  sign.  See  the section OPTION STRING PERCENT ESCAPES for more information.  This command
              line  option  appends  to  the   AUTOPKGTEST_VIRT_SERVER_OPTIONS   configuration   variable.   See
              sbuild.conf(5) for more information.

       --sbuild-mode=mode
              Behaviour  changes for use in a buildd environment.  This command line option sets the SBUILD_MODE
              configuration variable. See sbuild.conf(5) for more information.

       -    stats-dir=directory
              Directory for  writing  build  statistics  to.   This  command  line  option  sets  the  STATS_DIR
              configuration variable. See sbuild.conf(5) for more information.

       --purge-extra-packages
              This  is  an experimental option. Only use when you know what you are doing.  Source packages must
              be buildable with only their build dependencies, all packages marked as Essential:yes, the  build-
              essential  package  and their transitive dependencies installed. But by default, most chroots will
              also include Priority:required packages and apt as well as  their  transitive  dependencies.  This
              option  will  try  to  remove all additional packages that are not strictly required for the build
              right after build dependencies were installed. This currently works best with the aspcud resolver.
              The  apt  resolver  will not make as much effort to remove all unneeded packages and will keep all
              providers of a virtual package and all packages from any dependency alternative that happen to  be
              installed.  The aptitude and xapt resolver do not implement this feature yet. The removed packages
              are not (yet) added again after the build finished. This can have undesirable  side  effects  like
              lintian not working (because there is no apt to install its dependencies) or bare chroots becoming
              totally unusable after apt was removed from them. Thus, this  option  should  only  be  used  with
              throw-away  chroots  like schroot provides them where the original state is automatically restored
              after each build. This command line option sets the PURGE_EXTRA_PACKAGES  configuration  variable.
              See sbuild.conf(5) for more information.

       --bd-uninstallable-explainer=dose3|apt
              If the build dependencies cannot be satisfied by the chosen resolver, sbuild will run the selected
              method to give a better explanation why the  build  dependencies  cannot  be  installed.  Possible
              arguments for this option are dose3 (the default) and apt. To disable this feature, pass the empty
              string.  Depending on the resolver, the dose3 explainer might report  a  dependency  situation  as
              satisfiable even if the chosen resolver found it to be unsatisfiable. This is especially likely to
              happen if the apt resolver (the default) is used. Such disparities can have  two  reasons:  either
              the  understanding  of the involved dependency situation of the apt and dose3 solver differs (this
              is a bug) or the apt solver was unable to find a solution  if  the  dependency  situation  is  not
              trivial  (for  example  if  it  involves packages from multiple repositories). In the former case,
              please report the disparity as a bug against the resolvers. In the latter  case,  use  a  resolver
              that  is  more  likely  to  find  a solution like the aptitude or aspcud resolvers. Especially the
              aspcud resolver should find a solution if and only if  the  dose3  solver  also  finds  one.  This
              command line option sets the BD_UNINSTALLABLE_EXPLAINER configuration variable. See sbuild.conf(5)
              for more information.

BUILD ARTIFACTS

       Sbuild is meant to be used to build architecture specific binary packages from a given source package. In
       addition,  sbuild is also able to generate architecture independent binary packages as well as to rebuild
       the original source package that was used as input. In summary, sbuild  is  able  to  build  architecture
       specific  binary  packages,  architecture  independent  binary packages and source packages. What ends up
       being built is determined by the configuration variables BUILD_ARCH_ANY, BUILD_ARCH_ALL and BUILD_SOURCE,
       respectively. See sbuild.conf(5) for a detailed explanation of these configuration variables.

       By  default,  BUILD_ARCH_ANY  and BUILD_ARCH_ALL are set to true while BUILD_SOURCE is set to false. This
       behaviour can be changed either by using command line options or by modifying the configuration variables
       in  your  ~/.sbuildrc.  The  relevant  command  line  options  to  change  the  values of BUILD_ARCH_ANY,
       BUILD_ARCH_ALL and BUILD_SOURCE are --arch-any/--no-arch-any, --arch-all/--no-arch-all and --source/--no-
       source, respectively.

       The values of BUILD_ARCH_ANY, BUILD_ARCH_ALL and BUILD_SOURCE change the parameter that dpkg-buildpackage
       is called with. The following table displays the argument passed to dpkg-buildpackage in the last  column
       depending on the configuration options in the first three columns.

       BUILD_ARCH_ANY   BUILD_ARCH_ALL   BUILD_SOURCE   dpkg-buildpackage flag
       ────────────────────────────────────────────────────────────────────────
       false            false            false          invalid
       false            false            true           -S
       false            true             false          -A
       false            true             true           -g
       true             false            false          -B
       true             false            true           -G
       true             true             false          -b
       true             true             true           no 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. All command are  run  inside  the  chroot  as  root  except  for  the
       pre/post-build-  commands  which  are  run  as  the  user running sbuild outside of the chroot. To run an
       external command as another user than the root user, prefix your command with runuser -u sbuild --.

       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 working directory inside the chroot  is  the  one  marked  with
       <<BUILDDIR>>  inside  the  log.  By default, this is a directory of the format /build/packagename-XXXXXX/
       where XXXXXX is a random ascii string.  Otherwise, it is the directory set  by  --build-path  or  by  the
       BUILD_PATH  configuration  option.   The  working directory outside of the chroot is $HOME. The remaining
       columns show the percent escapes that are defined in each command.  Percent escapes that are available in
       all commands (%%, %a, %b, %s) are omitted.  The value maybe in the column for the %d and %p escapes means
       that the value can not relied upon to be defined in these stages.  More specifically, these escapes  will
       not  be  defined  at  these  points  if the user specified a source package name without a version on the
       command line. In that case, the version will  only  become  known  after  the  source  package  has  been
       retrieved in the "Fetch and unpack source package" stage.

       command/action                         root   chroot    %c    %e    %d,%p
       ──────────────────────────────────────────────────────────────────────────
       Initialise chroot session
       --pre-build-commands                   no     outside   no    yes   maybe
       Setup the chroot and variables
       --chroot-setup-commands                yes    inside    no    no    maybe
       Update and upgrade packages
       --chroot-update-failed-commands        yes    inside    no    no    maybe
       Fetch and unpack source package
       Install Dependencies
       --build-deps-failed-commands           yes    inside    no    no    yes
       --starting-build-commands              yes    inside    no    no    yes
       Run dpkg-buildpackage
       --build-failed-commands                yes    inside    no    no    yes
       --finished-build-commands              yes    inside    no    no    yes
       Run lintian (if configured)
       Cleanup build files and dependencies
       --chroot-cleanup-commands              yes    inside    yes   no    yes
       Close schroot session
       Run piuparts (if configured)
       Run autopkgtest (if configured)
       --post-build-commands                  no     outside   yes   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 is  the
              .changes  file generated by the dpkg-buildpackage invocation and not the source-only .changes file
              that might've been produced additionally via --source-only-changes.  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).

       %e, %SBUILD_CHROOT_EXEC
              These escapes are converted to a command which can  be  executed  on  a  host  and  can  be  given
              arguments  which will then be executed inside the chroot. Standard input and output of the process
              started inside the chroot are connected to the program executed on the host.  Thus,  this  command
              can  also be used to copy data into the chroot and out of the chroot. The working directory of the
              process started inside the chroot is the root directory of the chroot. The process is  started  as
              the  root  user.  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

       %SBUILD_BUILD_ARCH
              This escape is converted to the Debian name of the architecture that the build  is  being  run  on
              (e.g amd64, armhf).

       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  %e.  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 '%SBUILD_SHELL'

       The following example would copy a file from the host into the chroot:

       $ sbuild --pre-build-commands \
             'cat blub.txt | %SBUILD_CHROOT_EXEC sh -c "cat > blub.txt"'

       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.

OPTION STRING PERCENT ESCAPES

       Besides for external command strings, percent escapes can also  be  used  in  custom  options  passed  to
       piuparts,  autopkgtest  and  the  chosen  autopkgtest-virt  server.   This  is  for  example  useful  for
       communicating the right chroot backend to piuparts  or  autopkgtest  depending  on  the  distribution  or
       architecture the source package was built for.

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

       %%     Used to escape a '%'.

       %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_DISTRIBUTION
              The distribution  that  the  source  package  was  built  for.  This  is  the  value  recorded  in
              debian/changelog  or  the value passed via the --dist option.  Mnemonic: the r is the first letter
              in "release".

       Here is an example that will run piuparts with the right schroot chroot:

       $ sbuild --run-piuparts \
             --piuparts-opts="--schroot=%r-%a-sbuild"

       Or an example of running autopkgtest with the right schroot chroot:

       $ sbuild --run-autopkgtest --autopkgtest-root-args= \
             --autopkgtest-opts="-- schroot %r-%a-sbuild"

       To achieve the same effect via the configuration file, add the following:

       $autopkgtest_root_args = '';
       $piuparts_opts = [ '--schroot=%r-%a-sbuild' ];
       $autopkgtest_opts = [ '--', 'schroot', '%r-%a-sbuild' ];

       The --autopkgtest-root-args option and the $autopkgtest_root_args configuration variable are set  to  the
       empty  string because the default is to run autopkgtest with "sudo --" in front of it which is not needed
       with the schroot autopkgtest backend.

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.

EXAMPLES

       Before  you  use sbuild for the first time, you have to do some setup depending on the chroot backend you
       are using. The default backend is schroot. To use sbuild with the schroot backend, you need to  add  your
       user  to  the  sbuild  group and create a schroot chroot. The latter can be accomplished by using sbuild-
       createchroot(8). If the chroot contains a Debian derivative  with  apt  (<<  0.8.16~exp3),  or  a  Debian
       release  before  Wheezy,  then  it is also required to create gpg key pairs using sbuild-update --keygen.
       After this one time setup, you can now use sbuild to build packages like this:

       % sbuild -d unstable bash

       Or on a .dsc:

       % sbuild -d unstable bash.dsc

       Or from within an  unpacked  source  package  (the  -d  parameter  is  not  necessary  here  because  the
       distribution is inferred from debian/copyright):

       % sbuild

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

       /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),