Fix rpmProblem reference counting in python bindings

Declare a few python functions only taking one argument as such

Rip python checkSignals() wtf'ery
- since the function takes no arguments, declare it as such...

Python archscore() only ever takes one argument, simplify

Make python ts.problems() return a python list, not rpm.ps object
- rpm.ps object only supports iteration and subscript (with wonderfully
  wacko semantics), returning a regular list serves us better
- rip the now useless rpm.ps object type

Remove unused psFromPs()

Eliminate broken rpmps append() method from python bindings (RhBug:538218)
- The code to insert new problems has been using invalid conversion code
  causing crashes since 2004 and nobody noticed, safe to say this is an
  unused interface. Additionally the method argument flags were wrong, it
  was declared as METH_VARARGS but actually expected METH_O semantics. RIP.

Add in-memory hash for caching rpmdb dependency lookups
- worst case behavior for uncached dependency lookups can be disastrous,
  eg > 35s vs < 1s on my laptop for trying to remove /bin/sh provider
- we only bother caching rpmdb lookups, the other cases plenty fast already
- using in-memory cache avoids nasty in vs out of chroot issues with
  temporary db files, which otherwise were about as fast

Document our new format extensions

Add file verifyflags format extension

Add file state format extension

Update rpmtd formats comments to match reality
- we dont require exact int32 etc types, any numeric type works

Convert relative imports within rpm package to absolute imports

Permit any file-like object in rpm.setLogFile()
- using PyObject_AsFileDescriptor() does away with another Python 3
  incompatibility and makes it more flexible.. but also more murky
  as rpmlogSetFile() only accepts FILE * streams...

Update module initialization to work with both Python 2.x and 3.x
- split common initialization tasks to separate functions, so that only the
  details of initializing a python module object differ
- patch from David Malcolm

Remove unnecessary (cmpfunc) casts from our type objects
- cmpfunc is no more in Python 3 and casting NULL to anything makes
  little sense anyhow

Eliminate ambiguous tp_compare and tp_richcompare from rpm.ds
- both comparison types are highly ambiguous, eg what on earth does
  "foo provides bar = 1" < "bar requires foo > 2" mean?
- if straight ds1.evr vs ds2.evr comparison is needed, we'll be better
  off supporting that through rpm.versionCompare() which has clear semantics
- avoids another Python 3 incompatibility too

Add ds.Compare() as a thin wrapper over rpmdsCompare()

Type-check rpm.ds() comparison/search arguments everywhere
- also make them only accept one argument, simplifying arg parsing

Rip out stillborn code

Eliminate the ambigious tp_compare from rpm.hdr
- Avoids another Python 3 incompatibility as it doesn't have tp_compare
  anymore
- We could add a compatible tp_richcompare, but comparisons like
  'if h1 < h2: do foo' are highly ambiguous, callers are better of
  using explicit rpm.versinCompare(h1, h2) instead

Use PyObject_AsFileDescriptor() instead of object type comparison
- this permits any file-like object implementing .fileno() method
  (including rpm.fd) to be dup'ed, not just PyFile subtypes
- this also avoids yet another incompatibility with Python 3 which doesn't
  have PyFile_Check() and PyFile_AsFile() at all

Dont bother calculating hardlink counts when the value is not used
- speeds up non-verbose --list queries by some ~50%

Support multiple python versions in brp-python-bytecompile (RhBug:53117)
- For *.py files in python library path, use matching python interpreter
  version for compiling, this is especially needed for Python 3 which
  is very different from Python 2 code. And even if the code compiled
  with a wrong version, it would be recompiled at run-time when invoked
  with the intended python version, causing verification errors etc.
- For *.py files outside the library path, use "system python" which
  might not be always correct but we dont really know any better.
- Patch from David Malcolm

Argh, typo in previous commit

Remove explicit Py_TPFLAGS_HAVE_RICHCOMPARE from ds type flags
- HAVE_RICHCOMPARE is included in Py_TPFLAGS_DEFAULT since at least
  Python 2.3 which is as far back as we care, no need to explicitly
  set it. Eliminating the unnecessary flag removes another Python 3
  compatibility issue as the flag is gone there.

Make disk space problem reporting slightly saner (RhBug:517418)
- Only report disk space/inode issues for packages that are affected
  instead of piling up all the problems in all filesystems on all remaining
  packages
- The messages are still ambiguous at best, need to figure out something
  better one of these days...

Let Python decide the "native" string type for tag names
- Py_BuildValue("s", ...) returns unicode objects in Python 3, string
  objects in Python 2, this is what we want here

Permit unicode as ts.dbMatch() key argument

Allow unicode objects as tag name everywhere

Add conversion function for handling python unicode -> string issues
- In Python 3 everything is unicode, forcing each and every caller to
  convert manually is a bit much.

Make --httpproxy and friends work again (RhBug:529214)
- macro fiddling to pass the macros set by --httpproxy etc popt aliases
  to the url helper
- ftp proxy and http proxy control the same thing (http proxy) now to
  keep things simple
- while at it, add %__urlhelper_localopts for local customization needs
  without having to override the entire __urlhelperopts macro

On Python 3, use macros to alias all usage of PyInt_ to PyLong_ equivalents
- Python 3 unified PyInt with PyLong, the former no longer exists
- Based on a patch by David Malcolm

Replace PyString usage with PyBytes everywhere
- In Python 2.6 PyBytes is just an alias for PyString, Python 3.0
  removed PyString entirely
- Add compatibility defines for Python < 2.6
- Based on David Malcolm's Python 3.x efforts

Ensure RPMSENSE_RPMLIB bit is always set on rpmlib() requires in rpmds flags
- some packages in the wild have rpmlib() requires without the flag set
  due to older rpm not always setting it (for one, rpmdeps as external
  dependency  generator could cause such deps), causing bogus dependency
  failures on install
- only fix up dependencies coming from a header, rpmdsSingle() correctness
  is up to the caller

Ensure rpmlib() dependency sanity on build
- only requires on rpmlib(foo) are allowed
- make sure any rpmlib() foo dependencies have RPMSENSE_RPMLIB bit set,
  rpmdeps as external dependency generator can create rpmlib() dependencies
  without the bit set, and also any manual rpmlib() deps wont have it

Fix memory leaks on error exit from parseRCPOT()

Remove leftovers from python header files
- rpmSingleHeaderFromFD() and hdrLoad() are now implemented in python,
  declarations accidentally left here
- make rpmMergeHeaders() static, nothing outside header-py.c needs

Convert all usage of two-expression exception raising to modern syntax

Replace all usage of the two-expression
    raise foo, 'bar'
syntax with the long-equivalent
    raise foo('bar')
as the old syntax was removed in Python 3 (PEP 3109), and the new syntax
is supported in Python 2

PyVarObject_HEAD_INIT() compatibility macro for Python < 2.6

Generalize type object initialization to work with both Python 2.* and Python 3.*

The layout of PyVarObject changed between python 2 and python 3, and this leads
to the existing code for all of the various PyTypeObject initializers failing to
compile with python 3

Change the way we initialize these structs to use PyVarObject_HEAD_INIT directly,
rather than merely PyObject_HEAD_INIT, so that it compiles cleanly with both major
versions of Python

Py_TYPE() compatibility macro for Python < 2.6

Generalize access to ob_type so that they work with both Python 2.* and Python 3.*

Python 2's various object structs use macros to implement common fields at the top of each
struct.

Python 3's objects instead embed a PyObject struct as the first member within the more refined
object structs.

Use the Py_TYPE() macro when accessing ob_type in order to encapsulate this difference.

Avoid using python's print for Python 3.x compatibility
- print chanced from statement to a function in python 3, for our
  purposes sys.stdout.write() is sufficient and avoids dealing with
  the incompatibilities between Python 2.x and 3.x
- suggested by David Malcolm / Ville Skyttä

Unbreak lzdio/xzdio
- revert part of b0d1038190be5cb4b45e2c2c7c84ee7022164ba2 which broke
  the split-personality lzdio/xzdio

Skip posttrans scripts of failed transaction elements

Since we really want a FILE* then get one in the first place
- this is visible in the librpmbuild exported goo, rename the member
  to force build-breakage on the poor souls trying to use librpmbuild API

Use a helper function for finding fileno of specific io type
- also differentiate between lzdio and xzdio here

Lose unnecessary url type checking from fdSize()
- we're only dealing with local files once fd is opened

Lose unused leftover definitions

Eliminate ufdio-specific read, write, seek and close
- we dont do network IO anymore so ufdio only differs from fdio by
  downloading the file on open if necessary, after that it's just fdio

Use fd.tell() instead of going around through os.lseek() with fdno

Add tell() method to rpm.fd class

Add ftell() clone to FD_t

Avoid unnecessary dup'ing of file descriptors on header list operations
- convert to rpm.fd on python side already add use internal helper
  which only accepts rpm.fd type to avoid having to dup around on
  every item

Accept rpm.fd() types file objects everywhere in python bindings
- turn rpmfdFromPyObject() into a python-level object converter, add
  a separate C-level getter for the fd pointer itself
- take advantage of python refcounting to handle differences between
  native vs converted rpm.fd in callers so we can simply decref the
  rpmfdFromPyObject() result without having to worry whether it was
  converted or not (ie should we close it or not)

Make fdUpdateDigests() static now that its possible

Make FD_t struct opaque, finally

Eliminate last remaining FD_t struct privacy violation
- add getter for fd digest bundle, uninline the setter

Remove cpio stuff from FD_t
- only the FSM cares about cpio position, move it there - there's only
  ever one fd active inside FSM, no need to track it per-fd

Move debug goo defs to rpmio.c

Move pile of helpers from rpmio_internal.h to rpmio.c, remove unused stuff
- nothing outside rpmio.c needs these, make 'em static there
- uninlining reveals quite a few completely unused helpers...

Move fd statistics foo inside rpmio.c now that it can

Move fdDigest*() to rpmio.c where they better belong

Remove pointless inlining of stuff in rpmio

Use common "not implemented" implementation of Fseek()

Add first rough-cut python bindings for rpmio fd
- attempt to mimic python file object where possible, but nowhere near
  all methods are supported, either just not yet done or due to
  underlying limitations

Raise exception in the converter, not caller

Permit changing rpm.td tag from python

Add limited support for modifying headers to python
- for now we only support tag deletion and assigning rpmtd objects, limiting
  this to copying data from other headers

Fix format extension memleak on empty strings

Output dependency type on --requires etc queries if verbose (RhBug:528342)

Add RPMTAG_VERBOSE extension
- hack to permit different query formatting based on rpm's verbosity level

Permit conditional query formats on not yet cached data too

Oops, configuring wrong ts in rpm.ts() initialization

Move further initialization from python ts tp_new to tp_init
- lose the unnecessary rpmts_Wrap(), it's not needed and just gets
  in the way of things

Revert explicit PyErr_NoMemory() returns to just returning NULL
- tp_alloc failing is likely to be OOM but we dont know that for a fact,
  and the failing method is responsible for setting the exception

Handle NULL in ts get/setKeyring as python None

Kill off _rpmb.error exception type
- import of _rpmb messes up rpm.error to point to _rpmb.error which we
  do not want
- use ValueError for unparsable spec for now, need to figure something
  saner there still

Permit setting and getting ts keyring from python

Add bindings for rpm keyring and pubkey types

Add an interface to parse armored OpenPGP from memory
- refactor the decoding part out of pgpReadPkts() to separate helper,
  and add pgpParsePkts() around that

Support passing extra options to dep generator scripts

Lose unused python/perl/java stringbuffers from rpmfc

Bah, get the new ocaml-scripts into tarballs too
- should've been in commit 82e7dd702013d3679fda438333de30afdec17a4f

Python namespace import fiddling
- import rpm instead of _rpm for exception name compatibility
- import the lowlevel transaction class as _rpmts, makes it slightly
  easier to see which is which

Teach the internal dep generator about OCaml
- OCaml seems to have fairly well detectable magic in its files, nice
- Dont call the regular find-requires from the scripts now that internal
  is working

Add OCaml dependency generator scripts (Richard W.M. Jones)

Deprecate %__lzma, use %__xz in it.

Decompress lzma files with xz.

Improve perl.req here-doc skipping.

This version is stricter in finding the end identifier by using equality test
instead of a regex (as a side effect, fixes rhbz#524929) as well as parsing
quoted identifiers, and adds support for identifiers in backticks.

Delete ancient and defunc python test programs

Dont leak memory from rpm.fi() methods
- Py_BuildValue() always copies the data mallocing here is just wrong

Handle all rpmds variants in its constructor
- either it takes a header + tag, or (name, flags, version) tuple + tag
  to generate a single dep
- push rpm.dsSingle() compatibility out to python side
- hdr.dsFromHeader() and hdr.dsOfHeader() no longer need to be in rpmds-py.c

rpmdb open failing is certainly an rpm error, not TypeError

Dead code removal

Permit threads during rpmReadPackageFile()

Type mismatch is TypeError, not rpm.error

Push hdrFromFdno() error code handling over to python side
- return (rpmrc, header) tuple from C to let python do whatever it
  wishes with the information
- let python side worry about generating backwards compatible returns

Push hdrCheck() error code handling over to python side
- return (rpmrc, message) tuple from C to let python do whatever it
  wishes with the information
- let python side worry about generating backwards compatible returns