Eliminate redundant local variable in headerLoad()

Sanity check region length on header load

- Region size can't obviously be larger than the containing header,
  sanity check to avoid crashes from malformed packages.
- We should really test for length equality here, but with dribbles
  the size is sometimes off by three, whatever the reason (bug likely),
  leaving that investigation for some sunnier day...

Sanity check OpenPGP packet lengths in pgpPrtSubType()

- Sub-packet prefix length + packet length can't very well be larger
  than the remaining packet length. In addition to sanity checking,
  return an error code and have callers actually check for it.
- Fixes (yet another) segfault on malformed package (RhBug:742499)

Sanity check region offset range on headerLoad()

- Fixes the  first case crash of RhBug:741606 / CVE-2011-3378 where
  immutable region offset is way out of bounds.

Sanity check region offset in regionSwab()

- Region offsets are supposed to be negative when when an entry
  is involved, otherwise zero. Fixes some cases of crash'n'burn on
  malformed headers having bogus offsets (CVE-2011-3378)

Whoops, ftell() and rpmio equivalents should return long not off_t

Fix up a few strict-prototype warnings on x86

Kick out ppc arch detection leftovers

- This should've been in commit 6e2f56fe25a9ee62af51e0408861a8a43c97a709
  all the way back then, unused ever since...

Eliminate hysterical copy-paste comments from rpmrc

Bit of rpmrc spring-cleaning: nuke detection for some extinct creatures

Add Transifex config + adjust .gitignore to track it

Nuke ancient ChangeLog in po/

Use POPT_BIT_SET for setting the scriptlet flags

- No functional changes, just avoid doing extra work for what popt
  can already do for us.

Actually remember scriptlet flags in the rpmScript struct

- Currently doesn't make any difference but since we actually
  have a flags member in the struct, might as well use it. Also
  we'll shortly be needing these during the actual execution too.

Rename scriptlet flags from RPMSCRIPT_FOO to RPMSCRIPT_FLAG_FOO

- No functional changes (and this is still internal-only API),
  just making more obvious what they are and clearing the
  RPMSCRIPT_FOO namespace for possible future use for the scriptlet
  types themselves.

Show all interpreter arguments on --scripts query (ticket #847)

- Previously any arguments to interpreter were invisible unless
  you happened to know that RPMTAG_FOOPROG are actually string
  arrays despite their type showing plain string, and queried
  as arrays. This makes all the arguments for all scriptlets
  supporting interpreter arguments visible on --scripts query
  and also serves as an example on how to properly query them.i
- Perhaps worth noting is the exact formatting of the query:
  "(using[ %{PRETRANSPROG}]" instead of the more typical style of
  "(using [%{PRETRANSPROG} ]" to avoid extra trailing blanks.

Show possible %verifyscript interpreter similarly to other scriptlets

Scriptlet argument tags are really arrays

- While the vast majority of scriptlet interpreters only consist
  of the interpreter name itself, they all can consist of arbitrary
  number of extra arguments. Rpm itself doesn't really care whether
  the tags are strings or string arrays but the scalar definition
  causes the rest of arguments to be invisible from eg python.
  Also having the type shown as string array hints at the proper
  query format when accessing these (and rpm itself is doing it
  wrong too in --scripts alias). Related to ticket #847.

Sanity check trigger scriptlet arguments on build

- Trigger scriptlets differ from other types in that additional
  arguments to scriptlet interpreter are not supported due to the
  way trigger data is stored in the header. Until now any extra
  arguments have just been quietly discarded, make it an hard
  error to avoid surprises.

Fix brp-python-bytecompile breakage from the recent whitespace patch

Use the new FOO_NEVRS extensions for --requires etc popt aliases

- Makes the popt foobar somewhat saner and fixes RhBug:717534 and
  RhBug:735801 while at it.

Add four new extension tags for pretty-formatting dependencies

- The current method that --requires and friends use is kinda
  cumbersome and outputs extra whitespace for dependencies which
  dont have flags+version attached. Adding extensions for this
  is likely to be easier than teaching query formatting to
  permit conditionalizing on current value instead of just tag existence.

$RPM_BUILD_ROOT breaks brp-* scripts if it contains spaces (ticket #843)

- This patch adds quotes around $RPM_BUILD_ROOT in places that I noticed
  they were missing, and attempts to handle some of the problems that can
  occur when looping over the output of find.

Signed-off-by: Panu Matilainen <pmatilai@redhat.com>

Manual typo fix.

Signed-off-by: Panu Matilainen <pmatilai@redhat.com>

Sync autoconf macro defaults in manual with the macros file.

Signed-off-by: Panu Matilainen <pmatilai@redhat.com>

Make --pipe command failures reflect our exit codes (RhBug:735481)

Make rpmScript opaque

- Add accessor for fetching the script tag, the final piece that
  psm needs (and will continue to do so) from script internals.
  This allows the script type to become opaque for real.

Add an API for creating real rpmScript items out of triggers, use it

- Bury rpmScriptNew() into being internal helper in rpmscript -
  triggers and other scripts differ quite a bit in how their data
  is laid out in the header, especially args need "special attention".
- Besides cleaning up things in the psm side, this technically makes
  trigger scripts runnable without having a header at hand. Of course
  currently trigger scripts are currently created and destroyed
  on the spot from headers so this is of academic interest...

First step towards unifying triggers into rpmScript API

- Add a lower level script creation function to deal with the
  body expansions and such, use it for triggers as well.
- This is still fairly ugly but its something that can be reasonably
  backported to 4.9.x which needs this too, as currently triggers
  are forgetting to set script->descr, causing "(null) failure" messages
  on glibc and on others, in would just crash on trigger failure
  and/or in debug verbosity level.

Fix up one strict-prototype warning that has crept in meantime

GCC warning option tweaks

- WTH are we compiling with -Wno-char-subscripts? This appears to have
  been there since the dawn of times, and at least nowadays removing
  it causes no new warnings.
- Re-enable -Wstrict-prototypes, either NSS headers have gotten fixed
  or GCC has gotten smarter and no longer whines about broken
  system headers.

Oops, RPMSENSE_PRETRANS and _POSTTRANS missing from python bindings

Don't add config() provides if config install is disabled

- Similarly to commit 40ee8e7427ace319687dd36bd5f745d1ef2f2236,
  take --noconfigs into account for the virtual config() provides too

Don't add file provides for doc/config files if they wont be installed

- Files which dont get installed cannot very well satisfy dependencies,
  take this into account for docs and configs when --nodocs & --noconfigs
  flags are used.

Pass tsflags to rpmal and remember them

- No functional changes here, but we'll need to know some of these
  bits for accurately calculating various dependency bits later on.

Source formatting cosmetics: function blocks start on the next line

Only consider installed files when looking at removed dependencies

- Non-installed files cannot very well have dependencies, this
  eliminates some bogosities from those cases.

Add RPMTAG_INSTFILENAMES tag extension for state-aware file lists

- For a more consistent experience wrt all the state-awareness stuff,
  this needs to be easily querifiable too.
- Also makes the tagnames kludgery from commit
  cac8c389607d7a5735b2905035fdfe4404670d06 unnecessary

Add + use helper macro for testing for installed file state

Oops, missing include for rpmFreeMacros() in python module

- This should've been in commit f07ab5c1afa9b0b7105082a8617ec6a7657fc27e

Avoid SystemError on inserting an empty list insert to header from python

Add method to reset + reload rpm configuration to python bindings

Remember ds color (if set) through rpmdsCurrent()

- Currently only dependency sets coming from transaction elements
  get colored, only bother allocating memory for non-zero color.

Oops, forgot to add the instfilenames pseudo index to tag lookup code

- DBI tags dont really belong there to begin with but changing this
  would be more painful than its worth...

Use RPMDBI_INSTFILENAMES on file queries as well

- This changes query behavior quite a bit as files with non-installed
  status are no longer returned as matches. The rationale is that
  it makes figuring out dependency issues with the "new" behavior
  more obvious (but perhaps we should have a switch to enable
  former behavior). Besides not satisfying dependencies, files with
  non-installed status are not really owned by the package, as they
  would not be removed on package removal.

Take advantage on RPMDBI_INSTFILENAMES in rpmdbProvides()

- No functional changes, we did the same thing "manually" here already.
  Only now the data is more conveniently available through API to
  other callers who might care (yum & friends)

Add a new pseudo index for actually installed files

- RPMDBI_BASENAMES (ugh) returns all headers with matching filenames,
  whether the files are actually installed or not, which can be
  rather misleading when dealing with file dependencies. The new
  RPMDBI_INSTFILENAMES only returns headers with matching filenames
  whose state indicates they are actually present on the system.

Generalize pseudo tag handling in rpmdbInitIterator()

- No functional changes, just makes the case where a pseudo index
  uses a differently numbered underlying physical db index more generic.

Use correct file state for colored file replacements

- On colored file conflict resolution, the non-preferred colored
  file state would depend on installation order: if non-preferred
  arch is installed first, and the preferred arch in another
  transaction, the non-preferred color would get marked "replaced"
  indicating a forced install when none was used. This fixes
  the file state in such cases to "wrong color" to be consistent
  of the other installation scenarios.

Add test for ts.clear() as a side-effect of add to ts test

Export rpmtsEmpty() to python as ts.clear()

- Why the heck hasn't this been exported before, duh?
- Method name clear() chosen as this appears to be emerging as a
  standard of sorts for this kind of operation: dictionaries and
  sets have it and list will get it in some python 3.x version.
  Additionally foo.empty() could easily be mistaken for "test whether
  container foo is empty or not" (especially those with c++ background...)

Remove support for ancient bzip2 library versions

- bzip2 1.0 is over ten years old by now, anybody still using versions
  older than that get what they deserve...

Remove unused FDFOO macros

Handle query format field width centrally in formatValue()

- Eliminate the quirky formatPrefix buffer argument to formatter functions,
  deal with the width at formatValue() if specified.
- This not only simplifies things a great deal, removes a nasty
  unbounded buffer writing from formatter functions and speeds things
  up somewhat by removing extra rasprintf()'s in many cases, it also
  gives us width formatting of everything including "error messages"
  like "(none)" and "(not a number)" which previously got dumped without
  any formatting.
- The cost of this is the loss of zero padding support for numeric
  data but that's hardly a big deal.

Take length of format width specifier into account for format string buffer

- Prevents buffer overflow in case of ridiculous field width specifiers
  like --qf "%100000000000000000000000000{name}". There's another similar
  static-sized buffer in rpmtdFormat() but there we're not dealing
  with user-speficied format strings so its okay even if ugly.
- The format string handling wants a bigger overhaul but this makes
  for a nice little backportable patch for starters.

Validate query format field width specifier is sane

- Only allow [[-]<number>] in the format field, users have no business
  telling which format conversion sprintf() should use for tag data.
  Fixes embarrassing segfaults from things like %s{size} which rpm
  has merrily passed on to sprintf() as-is.

Strip trailing slash from paths at addFile()

- Fixes regression from commit 23167c3ea459405c98d8e759993efb6d9b1ea7f3
  which causes all %dir entries to have a trailing slash, breaking
  at least dependencies on such directories and probably something
  else as well.

pgpVerifySig() check of NULL hash is the wrong way around

- NULL hash is pretty much a can't happen-case here but lets be
  sane if it happens afterall - NULL hash would be an error and
  we dont want to process the rest if that happened.

Restore %defattr() behavior on special %doc

- With the change in the defattr handling (commit 09efbe96), you also
  need to save the current defattr setting when processing %doc.
  Otherwise doc files will just get the value from the latest defattr line.

Fix misleading error message when gpg key is expired (RhBug:672727)

Sanity check signatures even if we dont have a key

- Fixes a regression originating all the way back from commit
  c7fc09d585ff3831924f72f61d990aa791f2c3f2 (ie rpm >= 4.8.0)
  where a package with a bogus signature can slip through undetected
  if we dont have a key for it.
- This additional sanity check on the signature prevents is enough
  to prevent the fuzzed package in RhBug:721225 from crashing us
  by stopping the bad package at the front door. That we don't have
  proper tag data validation is another, much wider issue...

Fix memleak on keys with more than one user id

- This is not "correct", we should permit more than one user id.
  Leaking memory is still worse than not leaking, corrent behavior
  or not.

Fix crash on PGP packets/armors with more than one key (RhBug:667582)

- While OpenPGP permits arbitrary number of keys per packet/armor,
  we can't handle more than one, error out early.  The poor user
  wont get much of a clue as to what went wrong, but thats still
  better than crashing and burning.
- Return NULL from pgpPrtPubkeyParams() on errors and pass it onwards
  from pgpPrtKey() which propagates it up to callers. Besides
  the crash, this also fixes the error path from pgpNewPublicKey()
  failures.

Oops, rpmPubkeyDig() should return NULL if pgpPrtPkts() fails

Only increment number of query/verify sources when we encounter new types

- This makes it legal to specify the same query/verify source more
  than once. Not that it makes a whole lot of sense to do so, but
  complaining "only one type of query/verify permitted at a time" seems
  silly as well if you're just (accidentally) specifying the same
  source twice. Besides, this makes the code a bit cleaner.
- Kinda related to RhBug:691930.

Fix the sanity check on number of query/verify sources (RhBug:691930)

- Prior to commit 2e672f3fae9d8ff7ee64ae13cfa2fe65272c2ede, the
  callback would get called twice for every option so the expected
  number of query/verify sources was doubled. Now the numbers
  match with reality, adjust the check.

Whoops, wrong variable passed to io debugging

Cleanup fdRead(), fdWrite() and fdSeek() a bit

- Remove unnecessary fluff, these are very simple operations
  and dont need any temporary variables, re-re-redundant NULL checking
  etc, its already done at the caller level.

Cosmetics: remove empty comments and such

Dont bother checking for NULL fd on stats collection

- All the places calling these are already checking for NULL fd,
  no point re-re-re-re-re-checking it

Centralize most of the debug goo as well

Just pass fd pointers around instead of "cookies" cast to fd

- There's not a whole lot of point passing our own data structure
  around in void pointers and re-re-re-re-re-recasting them to fd's
  again all over the place. Just pass the damn fd to begin with.

Centralize fd digests collection

- Instead of requiring every io type to remember to update digests
  on their own, do it centrally on Fread() and Fwrite().
- This changes the digest calculation on writes slightly: previously
  we calculated the digests regardless whether the actual write
  succeeded or not, now we do this similarly to reads and only
  update the digests on success.

Centralize fd stats collection

- Instead of requiring every io type to call stats on their own,
  simply call the stat updates from the main functions Fread() etc

Eliminate unused leftover bytesRemain member from FD_t

- This used to be relevant for remote io but now its just unused.
- Also remove the "simulate EOF" on NULL fd returns while at it,
  these seem simply wrong (considering Fread() and Fwrite() behave
  more like read() and write rather than fread() and fwrite())

Minor cosmetics cleanup to Fseek()

Return an error on Fread() / Fwrite() on NULL fd

- Merrily returning success on read/write on NULL fd just is not
  sane. If something breaks because of this then that something
  needs fixing instead...
- Also return code type was mismatching in both, these return
  ssize_t not int.

Implement Ftell() for zlib versions that support it

Add basic test for Ftell() in python

Use a vector for Ftell() functionality too

Remove pointless fdSeekNot() "not implemented" function

- Fseek() and friends already return -2 for not implemented functions,
  this is not needed at all

Add a simple test for Fflush() functionality in python

- Prior to previous patch this segfaulted and tracebacked...

Fix totally broken Fflush() operation

- This only ever worked for fpio, for all other types it returns
  bogons or crashes and burns.
- Use the file op vectors to find our fflush function instead
  of #ifdef/#endif if/else/ifelse jungle.
- Notably fdio and ufdio do not have a fflush() equivalent because
  they dont need one. Use a dummy function to always return success to
  differentiate from -2 aka "not supported by this io type"

Axe the broken fpio support for good

- The whole thing is extremely hacky and failing to properly take
  fundamental differences in eg fread() and read() semantics into
  account (the whole rpmio fd is confused over this: Fread() claims
  to be fread() clone but reads behave with read() semantics
  and we dont provide feof() equivalent etc), special cased all over
  the io code when vectors exist for this purpose etc (not that fpio
  is the only offender in that regard)... RIP. Nothing should miss
  this but if we'd ever want to add it back, it'd better be done
  right at least.
- This COULD silently break somebody's code if they rely on the broken
  special case semantics of fpio mode, but most likely rpm itself
  was the only thing using fpio (and relying on the behavior) and
  even then, mostly only to get a FILE stream pointer out of it.
  Now we'll just silently return a fdio descriptor, as we do for any
  unrecognized io mode... (another sigh)

zlib is mandatory, fail at configure if missing + remove conditionals

- Unlike bz2 and xz/lz, zlib compression is not tracked by any rpmlib
  feature and is part of the original package format really, zlib
  simply must be always present.

Eliminate the last two fpio uses in rpm codebase

- Both relate to reading manifests and it doesn't make the damnest
  difference what io mode these use as rpmReadPackageManifest()
  opens its own stream on the fd with fdopen() which works on
  any io type, not just fpio..

Eliminate the uuugly and stupid fdGetFILE() from the API

If we need a FILE stream then get one...

- Replace the hysterical "lets see if the temp creation gave an fpio
  fd (it didn't), if not open another fd and then get its private
  FILE pointer" fiddling: since we need a FILE stream then open one
  with fdopen(), duh. Grabbing a rpmio fd to begin with is stupid enough
  when all we want is a stream, but wanting to use rpmMkTempFile()
  functionality...
- Also fixes an fd+mem leak in the unlikely but possible case that
  rpmMkTempFile() succeeds but fdopen() fails.

Take advantage of Fdescr() in rpmReadPackageFile()

- If fn to rpmReadPackageFile() is NULL, use Fdescr() value to give
  more meaningful errors
- Change a couple of places where we haven't got a clue of the file
  name to take advantage of the above

Teach python rpmio bindings about Fdescr()

- Similarly to python file object having o.name, export Fdescr()
  as fd.name. Python uses <foo> for non-paths but [foo] seems like
  a safer choice wrt accidental redirections.
- Also add a basic testcase for fd.name

Remember path (or other description) in fd's, add getter

- If opened by path, we obviously want to use that. Otherwise
  generate a description lazily on first Fdescr() call: on Linux
  we can grab something relatively meaningful by looking up from /proc
  (this is why we want to be lazy here...). If that's not available
  or fails, just generate a string on the current fdno. Actual
  paths are returned as is, other descriptions are bracketed,
  (eg "[mumble 123]").
- This makes it possible to give more meaningful error messages in
  places where we only get an fd from somebody (related to RhBug:522160)

Eliminate fdNew() from the API

- Nobody should be able to create file descriptors which are not
  attached to a file/descriptor of some kind, the only sane
  fd constructors are Fopen(), Fdopen() and fdDup().
- The same applies to fdFree() but its a bit more complicated,
  punting that till later...

Further streamline & sanitize lead handling

- Never log anything from rpmLeadRead(), instead return an error message
  the callers can log if they see fit
- Add a return value for the lead type (which is the only bit of
  info from the lead we sometimes resort to using)
- Permit NULL pointers on all return values
- Eliminate rpmLeadCheck() and rpmLeadType() from the internal API,
  these are now combined into rpmLeadRead().
- Fix up the callers: only (re)signing needs the actual lead,
  signature verification only cares if its valid or not and
  package reading only wants the type from the lead (annoying but...)

Only bother mallocing lead for return if read actually succeeded

- Doesn't make much of a difference now, just paving way for next steps

Eliminate remaining assert()'s in rpmlead.c

- Blowing up with assert() on freeing NULL is just dumb...
- rpmLeadWrite() can easily be made to handle NULL lead gracefully

Make rpmLeadRead() return an allocated lead, fixup callers

- Requiring callers to allocate a lead "buffer" for reading into
  is just DUMB (greetings to self back in 2008, sigh). This avoids
  having to deal with freeing the lead in case the read failed, and
  allows getting rid of rpmLeadNew() completely.

Start beating a little bit of sense into the braindamaged rpmlead API

- rpmLeadNew() should not populate the struct, only allocate it
- The only case where we're creating new lead data is
  rpmLeadFromHeader(), move all initialization there, and add a comment
  for RhBug:717898. Also eliminate the stupid assert, we can
  easily handle NULL header here.

Add tests for header getattr() behavior sanity

Fix the broken python header  __getattr__() behavior, take 13 (or so)

- Tags as header attributes seemed like a nice idea at the time... but
  has been a PITA due to side-effects it causes, such as breaking
  getattr() use for "capability testing", eg:
      >>> h2 = copy.deepcopy(h)
      Traceback (most recent call last):
        File "<stdin>", line 1, in <module>
        File "/usr/lib64/python2.7/copy.py", line 172, in deepcopy
          copier = getattr(x, "__deepcopy__", None)
      ValueError: unknown header tag
- Since we can't really go removing the brainded feature (somebody might
  actually be using it) try harder to fix it: if its not an actual
  attribute, save the exception we got from PyObject_GenericGetAttr()
  and if its not a valid tag either, restore the original exception.
  This allows cases like the above __deepcopy__ to work properly.

Add __reduce__() method to python header object

- This allows header objects to be pickled and also copied correctly
  with python's copy.copy()
- Split the header to string-conversion into a separate helper function,
  used by the now largely unnecessary unload() method and __reduce__().