Remove hysterically useless RPMSIGN_NONE + --sign popt leftovers

Eliminate unused rootdir member from rpmInstallArguments

Eliminate unused qva_prefix and qva_verbose from rpmQVKArguments

Use the common rpmcliQueryFlags for signature verify options in rpm cli too
- Technically this changes the rpmcliQuery() and rpmcliVerify() API
  in the sense that we no longer honor the qva->qva_flags for the
  --nosignature and others, but we assume anybody using these (as if
  anybody was using the "cli" API) uses rpmcliInit() which takes
  care of these common bits... shrug.
- Ditch ancient and hidden --nopgp --nogpg switches along with the
  dishwater which are simply alias to --nosignature.
- Eliminate now unused qva_flags from rpmInstallArguments (along with
  a double vsflags goo from rpmgraph)

Use the common rpmcliQueryFlags for signature verify options in rpmbuild
- The various --nosignature etc verification switches are common to
  everything, and have been available through rpmcliQueryFlags via
  the common popt table since 2002. Might as well finally use it
  to limit the amount of duplicate popt goo.

Permit passing spec parse flags in python too
- The preferred flags default would be RPMSPEC_NONE, but it would break
  compatibility with older rpm versions where rpm.spec() doesn't accept
  flags.

Add an experimental low-level build method to python spec
- This is mostly just a toy for now, but serves as a kind of yardstick
  for what is missing in librpmbuild to be generally useful for
  building stuff.

Add the various spec + build flags to python

Cosmetics: use an enum instead of #defines for source type bits

Clarify RPMBUILD_STRINGBUF comment

Swap rpmSpecBuild() arguments for consistency with other APIs
- What we're building comes first, /how/ we're building comes second
- Update the sole caller, doesn't matter as this is a new interface...

Update translations again to pick up strings moving around etc

Oops, forgot to update POTFILES.in on poptBT.c removal

Add a new public function for retrieving build dependencies from spec
- Not needed by rpmbuild itself currently, but permits retrieving the
  build dependency information in a format that's better suited for
  further processing than an rpm problem set.

Move build dependency checking from cli tool to librpmbuild
- Add new public rpmSpecCheckDeps() function which can be used for
  checking build dependencies of a spec against a transaction set.
- Change checkSpec() in rpmbuild cli to use the new interface
- rpmbuild.c is now free of direct spec structure accesses

Return NULL from rpmtsProblems() if no problems exist
- Avoids callers having to separately test for number of problems
  and freeing when no problems exist

Cosmetics: update comments + use a specific type for buildAmount

Eliminate specFlags from rpmBuildArguments
- Spec parse flags are specific to parsing a spec, not building it.
  This could be relevant again if a higher level build API is added
  to the library but not ATM.

Eliminate targets from rpmBuildArguments
- Targets are obviously relevant for building but not in the
  context of rpmSpecBuild which expects the environment to be set up
  already. If/when we add a higher level build interface to librpmbuild
  this comes relevant again, until then bury inside the cli-tool.
- Simplify the target parsery by using argvSplit() and friends.

Eliminate buildMode and buildChar from rpmBuildArguments
- The mode letters are only relevant for the rpmbuild cli tool. If/when
  some of the related build logic is moved from the cli tool to the
  library, we'll need a better way of expressing these combinations
  than letters.

Eliminate verify flags from rpmBuildArguments
- Transaction set verification bits are not relevant to building,
  bury inside the rpmbuild cli utility.
- Also the type was wrong, its rpmVerifyFlags, not rpmQueryFlags, duh

Eliminate noDeps and shortCircuit from rpmBuildArguments struct
- Both of these are only relevant to the rpmbuild cli utility,
  eg checking for build-requires is up to caller, not librpmbuild.

Eliminate popt goo from librpmbuild
- Move the cli-switch manouvering into rpmbuild.c cli utility where
  it belongs.

Eliminate _noDirTokens from librpmbuild API+ABI
- Add another flag set to control package generation, passing around
  as necessary. Use this to implement --nodirtokens functionality
  in a cleaner manner.

Eliminate freeNames() from librpmbuild ABI
- Call freeNames() at end of buildSpec() instead of requiring API
  users to clean up after us. This does mean losing some of the
  supposed caching advantage when building on more than one spec,
  but hardly matters, one spec at a time is the typical build usage
  anyway.

Detect short-circuited build based on executed build steps from buildSpec()
- Avoids having to access rpmBTArgs from deep packageBinaries(),
  API changing is not an issue anymore...

Handle --nobuild as another buildAmount flag

l10n: Updated Polish (pl) translation to 100%

New status: 754 messages complete with 0 fuzzies and 0 untranslated.

Transmitted-via: Transifex (www.transifex.net).

Handle spec flags parse option figuring in popt callback already

Handle --nolang as another spec parse flag

Combine spec parsing options into a common flag bitfield

Rename freeSpec() -> rpmSpecFree() for namespacing
- librpmbuild actually now has what remotely resembles an API, after
  we broke every single thing there was ;)

...and finally eliminate the spec crapola from transaction set for good

Eliminate transaction set from spec parsing internals

Pass flags directly to the lower level parseSpec() helper

Eliminate parseSpec() from librpmbuild, trim unused arguments
- We can't keep compatibility while eliminating goo like transaction set
  from the arguments so dont bother trying.

Update callers to use the new rpmSpecParse() interface

A new saner interface for parsing spec files
- For now just a wrapper around parseSpec() that returns *gasp*
  a pointer to a parsed spec structure.
- Limit the amount of goo that needs passing - optimally we'd only need
  the spec + parsing flags, but due to %{buildroot} macro abuse in specs
  we'll need that for now too.

Eliminate silly and unused timecheck feature from (lib)rpmbuild
- This was broken for years without anybody complaining, should
  be safe to conclude nobody will miss it later either. And if
  somebody misses it, this is a job for rpmlint really.

Spec rootDir is only relevant for building, eliminate from parseSpec()
- The whole rootDir seems dubious for build purposes, but in any case its
  only relevant during the actual build process, not for spec parsing.
  Set spec->rootDir from buildSpec() for the duration of the
  build to avoid having to refactor doScript() and all right now.

Eliminate cookie from spec structure
- Cookies are not a property of spec but a given build, handle this
  internally to buildSpec() except for --rebuild which passes the
  srpm identifier cookie through buildArgs

Sanitize buildSpec() arguments a bit

Replace buildSpec() with a new interface in the API
- Accept the entire build arguments structure along with a spec, these
  contain everything that we'll need
- Just a convenience wrapper for buildSpec() for now, more things
  to follow...
- Update the sole existing caller accordingly

Lift remaining build-related stuff out of librpm over to build-side
- none of this belongs to librpm headers and ABI

Eliminate useless hardwired build debug foo

Passed-in values are const for every headerPutType() variant
- Silly oversight back then, oh well... this shouldn't affect any callers,
  just avoids dumb warnings where none should be seen

Update translations to pick up new messages

Add newly added files to POTFILES.in too

debugedit: fix incorrect error messages regarding -b and -d

Add files for testing SELinux collection/plugin

This adds two basic tarballs, one containing two minimal executables
(foo & bar), and one contain a simple policy for the two executables.
This also adds a new spec file with a policy subpackage, the new
%sepolicy section, and the sepolicy collection.

Add SELinux policy plugin

This adds a new plugin specifically for a collection to load SELinux
policy. This implements the post_add and pre_remove plugin hooks. The
only time anything happens during the pre_remove hook is if post_add was
not called (i.e.  if the transaction only removes policies).

This plugin extracts all the policy information from packages in the
sepolicy collection during the open te hook. It then determines which
policies should be installed/removed based on if the package is being
installed/removed and the type of the policy and the system policy. It
then executes semodule (or uses libsemanage if semodule cannot be
executed or installing in a chroot) to remove and install the necessary
policies. It then reloads the selinux state, reloads the file contexts,
and if necessary, relabels the file system.

Use selabel interfaces instead of matchpathcon

This replaces the old matchpathcon interfaces with the new selabel
interfaces for relabeling files, storing an selabel handle in the
transaction set.

With this change, also comes an added distinction between --nocontexts
being specified and a failure to read the load file contexts.
Previously, there was no distinction, and both cases used the
RPMTRANS_FLAG_NOCONTEXTS flag.

However, with the new policy plugin, it is necessary to make such a
distinction. This is because matchpathcon_init (now selabel interfaces)
can fail at the beginning of the transaction, but succeed later after
new policy is installed. Because of this, we may need to enable/disable
RPMTRANS_FLAG_NOCONTEXTS multiple times. However, because this flag
could also mean --nocontexts, we cannot do that. By storing the selabel
handle in the rpmts, we can easily keep track if the handle has been
successfully created, rather than overloading RPMTRANS_FLAG_NOCONTEXTS
with two meanings.

Add new %sepolicy section to the spec file format

The %sepolicy section is used to describe SELinux policy to be included
in a package. It's syntax is similar to other sections (%files, %pre,
%post, etc.) in that you can provide a string and -n after the
declaration to specify policy should be added to a subpackage.

For example:

%sepolicy
 # policy in this section will be added to the main package

%sepolicy foo
 # policy in this section will be added to the '<mainpackage>-foo' subpackage

%sepolicy -n bar
 # policy in this section will be added to the 'bar' subpackage

The %sepolicy section contains zero or more %semodule directives, with the
following format:

%semodule [OPTIONS] path/to/module.pp

The available options are:

-b, --base
The module is a base module

-n, --name=NAME
The name of the module. If not given, assumes the name is the basename of
the module file with file extensions removed.

-t, --types=TYPES
One or more comma-separated strings specifying which policy types the
module can work with. To explicitly state that a module can work with any
policy type, "default" can be specified as the value. If not specified,
assumes the module can work with any policy type, and assigns the types as
"default".

Below is an example of this new format:

  %sepolicy
  %semodule -n foo -t mls policy/foo.pp
  %semodule -n bar -t strict,targeted,mls -b policy/bar.pp

This also adds new header tags to store the new information:
 RPMTAG_POLICYNAMES        (string array)
 RPMTAG_POLICYTYPES        (string array)
 RPMTAG_POLICYTYPESINDEXES (uint32 array)
 RPMTAG_POLICYFLAGS        (uint32 array)

The index of NAMES and FLAGS maps directly to the index of RPMTAG_POLICIES.
However, because a single policy can have multiple types, the mapping for
TYPES is not direct. For this, the index maps to TYPESINDEXES, which
contains the index of the policy that the type maps to. This is similar to
how DIRINDEXES is used to map DIRNAMES and BASENAMES. As an example, the
previous %sepolicy section would have the following header tags:

RPMTAG_POLICIES:
 0: <foo.pp data, base64 encoded>
 1: <bar.pp data, base64 encoded>

RPMTAG_POLICYNAMES:
 0: foo
 1: bar

RPMTAG_POLICYFLAGS:
 0: 0
 1: 1 # assumes flag 1 == BASE

RPMTAG_POILCYTYPES:        RPMTAG_POLICYTYPESINDEXES:
 0: mls                     0: 0
 1: strict                  1: 1
 2: targeted                2: 1
 3: mls                     3: 1

Remove the existing %policy directive

Remove the existing %policy directive, to be replaced with a new
%sepolicy section with more configurable options.

Update the plugin architecture to allow for remembering state

This moves most of the plugin logic to a new rpmplugins file with a
struct and functions for managing plugins, allowing for plugins to carry
state. This also adds init and cleanup hooks for plugins to initialize
and cleanup their state, and a new 'open te' hook allowing plugins to
read and save information from transaction elements.

This also generalizes the plugin architecture a bit so it isn't so
specific to collections.

Permit packages with no files to omit %files entirely
- Fixes the long standing obscure behavior of missing %files
  section causes build to complete without errors but without producing
  any packages either. Packages without files in them are perfectly
  valid (eg metapackages), requiring empty %files section for those
  is just unnecessary spec noise.
- Remove %files section on one of the test-suite specs to create
  a test-case for this as a side-effect.
- This of course introduces a slight incompatibility with older rpm's,
  if compatibility is required then just add those empty %files in the
  spec, they dont hurt anything but the readers eyes.

Clean up newPackage() a bit
- No much point explicitly NULL'ing calloc()'ed memory, only initialize
  the values that are something else + other cosmetics.

Split arch/os/platform adding out of parseSpec()
- Combining description /checking/ and arch/os/platform /adding/
  into same for-loop (to save cycles or lines, dunno) makes no sense
  whatsoever. No functional changes.

Stuff the remaining truly internal structure defs out of sight
- All these are internal implementation details that no callers
  should mess with. Bury inside rpmbuild_internal.h.
- spec, package and source structures are tougher nuts as python
  bindings expect to expose some of the information, we'll need
  at least some api to cover walking over package headers etc before
  shutting the door completely.

Mass eviction of remaining internal helpers in librpmbuild API
- Yank everything qualifying as "internal helper function" into
  internal-only headers, loosely grouped as follows:
  1) Everything involving spec-manipulation goes into rpmbuild_internal.h
  2) All other miscellaneous helpers go into rpmbuild_misc.h
- This leaves us a rather minimal, and nearly useful API into librpmbuild:
  Users need to be able to parse a spec, query or build (parts of) it
  and free up the spec structure when done. This is what we have now,
  various still exposed structures not counting.

Eliminate unused spec argument from addReqProv()
- addReqProv() only operates on the header, not spec

Bury OpenFileInfo inside parseSpec.c
- Nothing outside spec parsing machinery needs this nor should mess
  with it, enforce with opaque pointer.

Eliminate freePackage() from librpmbuild API
- The only thing that should ever call this is freePackages() which
  was already made static. As newPackage() links the package structure
  with the spec, its not safe for others to call it.

Eliminate initSourceHeader() from librpmbuild API
- This is a funky little implementation detail which no caller should
  have to bother with. Move it to parseSpec.c which is the only place
  needing it now and make static.

Eliminate ancient leftover initSourceHeader() call
- processSourceFiles() is only ever called through buildSpec(),
  and if you throw unparsed spec into that you're pretty much screwed
  anyway. rpmbuild always called initSourceHeader() anyway, and now
  its ensured for all successfully parsed specs.

Initialize source header from parseSpec() instead of caller(s)
- This is where it logically seems to belong to, after all parseSpec()
  similarly populates all other metadata of the binaries etc too.
  No point requiring callers to do this obscure extra call.

Move source+patch tag insertion into initSourceHeader()
- processSourceFiles() is more about processing the physical files
  ending up in the srpm payload, source + patch tags are mostly just
  informational and can be added early

Eliminate an exit point from parseSpec()

Eliminate doRmSource() from librpmbuild API again
- buildSpec() is sufficient interface for accomplishing the same,
  avoid exposing internal helpers

Fix RhBug:452477 differently to avoid doRmSource()

Eliminate addChangelogEntry() from librpmbuild API
- This is just an internal helper for parseChangelog(), no point
  exporting it

Eliminate buildHost() and getBuildTime() from librpmbuild API
- Neither is needed anywhere outside pack.c, bury there and make static

Eliminate checkPackages() from librpmbuild API
- No needs outside pack.c, make it static

Eliminate parseExpressionString() from librpmbuild
- This has been unused since its introduction in 1998...

Eliminate freePackages() from librpmbuild API
- This is a spec-internal cleanup task, no need outside spec.c

Eliminate now unnecessary buildio.h
- readRPM() is not used or needed by anything, shred it
- make writeRPM() static inside the only place needing it: pack.c
- move struct cpioSourceArchive_s inside pack.c

Send the mostly broken rpminject and rpmsort "test programs" to shredder

Eliminate newOpenFileInfo() from librpmbuild API
- Nothing outside parseSpec.c needs, bury it there and make static

Eliminate addSource() from librpmbuild API
- Nothing outside parsePreamble.c needs, bury it there and make static

Eliminate parseNoSource() from librpmbuild API
- Nothing outside parsePreamble.c needs, bury it there and make static

Remove ancient autohelp-handling related leftovers

Lose leftover variable, use const for s to clarify usage

l10n: Updated Polish (pl) translation to 100%

New status: 729 messages complete with 0 fuzzies and 0 untranslated.

Transmitted-via: Transifex (www.transifex.net).

Remove signing support from (lib)rpmbuild
- Signing is better done in an environment completely separated from
  the process of actually building packages. This is how its generally
  done anyway by distros, this change just forces the issue.
- While signing on build seems handy and saves some io-churn, this
  is very insecure as your precious secret passphrase remains unencrypted
  in memory for the entire duration of the build where it's accessible
  to whatever happens to be building. This change doesn't
  affect fix the issue of unencrypted passphrase residing in memory
  and potentially getting swapped out, it only limits the exposure
  to the actual signing process which isn't subject to unknown scripts
  poking around.
- Minimally preserve rpmbuild's --sign functionality via popt --pipe hack
  to call rpm --addsign when build completes

Yet another unused copy of identifyDepend() hiding inline

Hack to get popt working when running from build tree
- Dynamic linking with libtool causes binaries to appear as lt-foo,
  which confuses the heck out of popt aliasing. Add a dumb hack to
  rpmcliInit() to fixup the lt- out of popt context names.

Argh. Realize we already have equivalents of initCli() and finishCli()
- rpmcliInit() and rpmcliFini() do almost exactly the same as our
  newborn cli-helpers, but they've been almost unused until now.
  Use them and lose the new ones.. doh.
- The downside is that popt aliases are now broken when running commands
  from the build tree due to lt-foo in argv[0], whereas initCli() took
  and explicit popt context name argument. Oh well...
- rpmcliFini() was missing several necessary memory cleanup calls,
  add them there while at it.

Remove unused code, hidden away from compiler warnings via inlining

Kludge to get rid of ugly lone --quiet on usage message

Update translations to pick up stuff moving around

Move --pipe handling to cliutils helpers

Oops, fallout from commit 5fe63cd8e0b552a9687666e8b5f9454cf274d69d

Lump much of the common cli-init + finish tasks into cliutils helpers

Add a convenience library for stuff common cli-bits into

If MiNT can't cope, frankly my dear, I dont give a damn

Merge build.[ch] into rpmbuild.c, doesn't make sense to separate anymore

Clean up rpmbuild's --quiet handling + honor it on --rebuild too

Cosmetics cleanup

Eliminate unnecessary sanity checks wrt --sign and fix indentation

Test argument count early, avoiding the need to re-check over and over
- Instead of bothering with different error messages for tar/spec/pkg
  messages, just dump usage when no arguments present.
- Testing argument file existence for signing is meaningless on build
  as we're not signing the specs or tarballs present there but the
  build result.