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__().

Revert the ds, ts, fi and spec python object creation commits

- Hasty push-finger syndrom, while its not exactly plain wrong to
  do things this way, it doesn't really make sense for these types
  either. Python's own file object permits reinitialization though,
  so leaving rpm.fd() the way it is now.
- This reverts the following commits:
  d056df28c38e602d82b4f9b527c686037074e660
  3f77c3146da46a49f44b17fa66139fbe2dd9e45c
  7214b2e0a271b7a7b3df312c58593878cbf56504
  dc50fb2863c81159fb4cc8b25ce3862720c0cce5

Bring back c++ "protection" to rpmsq, oops

- The beginning of c++ extern block went with the dishwater in commit
  269df02ae1fc3955bee4e5f471b1172c04c714e2

Fix/sanitize rpm.ds python object creation a bit

- Move all actual initialization work into tp_init, permit
  reinitialization without leaking and use PyType_GenericNew for tp_new.

Fix/sanitize rpm.ts python object creation a bit

- Move all actual initialization work into tp_init, permit
  reinitialization without leaking and use PyType_GenericNew for tp_new.

Fix/sanitize rpm.fi python object creation a bit

- Move all actual initialization work into tp_init, permit
  reinitialization without leaking and use PyType_GenericNew for
  tp_new, eliminate internal rpmfi_Wrap() use.
  There's one user for rpmfi_Wrap() in rpmte-py.c which needs fixing
  later...
- Remove unused fiFromFi() helper function

Fix/sanitize rpm.spec python object creation

- Specs are not really immutable, move the initialization work into
  tp_init and use PyType_GenericNew for tp_new since we're not
  doing anything special there.
- Eliminate the stupid spec_Wrap() thing and hide specPkg_Wrap()
  out of side (TODO later...)

Add a simple and stupid test case for python spec parse

Fix/sanitize rpm.fd python object creation

- FD's are not really immutable, move the initialization work into
  tp_init and use PyType_GenericNew for tp_new since we're not
  doing anything special there.
- Remove half a dozen different unnecessary exit points

Fix the totally broken rpm.fd() read method

Add basic test for rpmio python bindings

Fix explicit directory %attr() when %defattr() is active (RhBug:481875)

- parseForAttr() doesn't know whether it's dealing with a directory or
  a file, so it can't know which defaults it should use.
  Move all the decision making on which of the explicit/default/implicit
  attributes into addFile() where we do know what kind of entry we're
  dealing with, and only parse in parseForAttr().
- Update the test-case status to expect success now.

Add a test-case for various %attr and %defattr combinations

- Currently this fails expectedly due to RhBug:681540 on the last
  directory of the test rpm.

Enable GLOB_ONLYDIR of the bundled glob() on platforms that support it

Pay attention to dir vs file when building (RhBug:505995)

- Preserve trailing slash if it exists, and also add one on explicit
  %dir entires. This lets rpmGlob() and friends to skip any matching
  files that might be present, fixing both test-cases in RhBug:505995.

Honor trailing slash in rpmGlob()

- Only return directories if a pattern contains a trailing slash.
  Use GLOB_ONLYDIR hint if available but as this is unreliable,
  we need to stat the paths to be sure.
- Hysterically enough, rpm bundles its own copy of glob() which does
  have GLOB_ONLYDIR but ATM it doesn't get build because HAVE_D_TYPE
  isn't defined outside glibc build environment which is where our glob
  originally came from...

Remove ugly isDir recurse prevention hack on build

- We know if we're already fts-walking by the way addFile() gets called,
  dont corrupt fl->isDir for no good reason.

Eliminate static BUFSIZ use in filelist parsing

- In the unlikely event of filelist line being longer than BUFSIZ
  we'd previously end up truncating the line, which is stupid
  since we can just as easily make the buffer large enough.

Use ARGV_t for filelist current locale storage

- Avoids having to manually do search, sort, join, free etc for
  no good reason. Could be further simplified with argvSplit() etc
  and sanitized overall but leaving that for another day...

Eliminate redundant noGlob member from filelist

- Since the only thing where globs are not permitted are %dev entires,
  check for device explicitcly in the glob part. Doh.

Eliminate redundant special docs tracking members in filelist

Eliminate unused fileCount member from FileList struct

Add DWARF-4 support to debugedit (RhBug:707677)

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

Avoid extra newlines in parsed spec output outside preamble

Add --parse option to rpmspec tool to dump parsed spec contents

- This is somewhat like 'gcc -E', useful for analyzing/troubleshooting
  what happens inside the preprocessing.

Support retrieving the spec contents in parsed format

- Collect the preprocessed (conditionals, macros etc evaluated)
  lines to a separate stringbuf, make rpmSpecGetSection() return
  that on RPMBUILD_NONE "section" (hack, but so is abusing RPMBUILD_FOO
  for the section here so shrug)

Error on unclosed macros & trailing line continuations in spec (RhBug:681567)

- Track the starting line in case copyNextLineFromOFI() indicates
  a multiline-construct. If we get an EOF from readLineFromOFI()
  while inside multiline read, its an illegal construct of some kind
  and we can even spit out a reasonably meaningful error pointing
  out the starting line number of the bad construct.

Try to generate fileclass in the tag ext at runtime if missing from header
- For non-regular files we can easily generate this information based
  on file mode + in case of symlinks, the link target is available
  in the header elsewhere. This also means --fileclass will return
  at least partial data for packages built with the external depgen.
- Clean up fileclassTag() a bit while at it, removing redundant fluff.
- Arguably this "magic" should be done inside rpmfiFClass() instead, but
  that'd require changing the API to return malloced data.

Export rpmteFailed() to python bindings

- Kinda related to RhBug:661962, yum relies on callbacks to catch
  install/erase errors but this is not accurate: on erase the
  element can be ambiguous as the callback only gives a name (sigh).
  In addition, elements can be skipped entirely if "parent" element
  fails, in which case no callbacks are issued so these cases would go
  completely unnoticed when relying on callbacks alone. te.Failed()
  gives users such as yum a chance to have a look at the real status
  of elements (after the transaction).

Don't remove buildroot docdir on %doc usage (ticket #836)
- Some software installs its own documentation and if you try to
  combine it with %doc, rpmbuild will abort with mysterious
  "cpio bad magic" or such errors because what was assumed to be
  there was not, as %doc would 'rm -rf' the docdir upon first
  invocation. I don't see any good reason to disallow sharing the
  same directory for %doc and documentation installed by software
  "make install" - the other alternative would be forcing %doc to
  go to some other location, only making docs harder to find.
- Also at least Mageia (and prior to that Mandriva) has been doing
  this for quite some time now.

Adjust script detection rules to work with file >= 5.07 too (RhBug:712251)
- Somewhere between file 5.05 and 5.07 it started adding encoding
  to script descriptions, eg "<mumble> script text executable" became
  "<mumble> script, <encoding> text executable" breaking what had
  been working for 10+ years in the case of old find-requires.
- Permit either comma or space after "script", this works for both
  old and new file.

Add bunch of further rpm-python tests for this and that

Eww, python ds.Instance() doesn't take any arguments
- ...means its been broken all along, sigh

Add a bunch of db match/key iterator test-cases in python
- This would've caught the breakage introduced in commit
  7e4415fcc5e11cfd4cd9d0dfe19568be73f15d74, but better late than never...

Rearrange test-suite python helper macros a bit
- Handle double [] "escaping" at RPM_PYRUN to avoid surprises when
  its used on its own
- Spin python-wrapped AT_CHECK into a macro of its own (RPMPY_CHECK)
- What formerly was RPMPY_CHECK is now RPMPY_TEST: this represents
  one entire testcase with all its setup and cleanup, whereas
  RPMPY_CHECK (the new one) might be used several times within a
  single test

Fix the non-keyed match iteration case wrt DB_NOTFOUND
- This broke in commit 7e4415fcc5e11cfd4cd9d0dfe19568be73f15d74,
  the cases are not identical afterall: With non-keyed cursor
  retrievals DB_NOTFOUND is returned when there's nothing more to
  get, this is not an error situation.

Use dbiCursorGetToSet() for the non-keyed match-iterator case too

Support set append in dbiCursorGetToSet()
- If called with an existing set, results are appended. Otherwise
  return a newly allocated set.

If key not specified, use DB_NEXT cursor mode (DB_SET wouldn't make sense)

Only honor keylen if keyp is also specified

Make it an error to call dbiGetToSet() with NULL keyp
- All current callers always supply non-NULL keyp, and requiring
  this gives useful possibilities elsewhere

Move the remaining DBT's in rpmdbInitIterator() to (more) local scope

Error/notfound case is handled the same for both these cases

Take advantage of dbiCursorGetToSet() in dbiFindByLabel() & friends
- Reduces the number of arguments to somewhat saner level and
  eliminates another reincarnation of the dbt2set() + error handling
  code littered all over the place.

Split actual cursor get + set-conversion to separate function
- Allows multiple retrieves on a single cursor instance, dbiGetToSet()
  is just a convenience wrapper around dbiCursorGetToSet() now.
- Creating and tearing down cursors isn't exactly terrifyingly
  expensive but still measurable when lots of lookups are done.

Add cursor method for retrieving the underlying db index handle

Add tests for the most common nvra query combinations

Use dbiGetToSet() in rpmdbFindByFile(), lose now unnecessary arguments

Use dbiGetToSet() for the common case in rpmdbInitIterator()

Simplify + cleanup rpmdbExtendIterator()
- Use the new dbiGetToSet() for doing the actual work, reducing
  fluff considerably
- Don't bother checking for NULLs where the lower levels do it
  already (mi and keyp NULL-checks are necessary here though)

Simplify + cleanup rpmdbCountPackages()
- Use the new dbiGetToSet() for doing the actual work, reducing
  fluff considerably
- Dont bother checking for NULL db, rpmdbOpenIndex() does this anyway
- Return an error, not 0 (ie "not found") for NULL db and name
- Remove redundant dbtag variable, this is always RPMDBI_NAME

Add a helper function to convert cursor retrievals to dbiIndexSets
- This stuff is repeated in rpmdb.c all over the place, to some
  this suggests making it into a function:
  - Hide the DBTs inside the function
  - Handle keylen fixups, set conversions and error logging centrally

Rename dbiFreeIndexSet() to dbiIndexSetFree() for naming style consistency

Minor cleanup to rpmdbFindByFile()
- Pass the dbi we already opened in rpmdbInitIterator() as argument
  instead of unnecessarily reopening in rpmdbFindByFile()
- Adjust the argument order to match that of dbiFindByLabel()
  for consistency
- Remove redundant error code assignment, we are already assuming error

Push cursor init+free down to dbiFindByLabel()
- The cursor is fully local to dbiFindByLabel() so there's no
  point passing it as an argument

Handle EINTR on the spot instead of restarting the entire loop
- The previous code was violating the "golden rules of select()" by
  possibly skipping processing of fd's that were included in the
  select() set. Also restarting the entire loop should not be
  necessary in case of EINTR select(), our conditions do not change
  in that situation.

Kick out self-pipe trick from depgen helper
- As we're not actually /doing/ anything with signals here, the self-pipe
  is not needed: select() will get interrupted and re-evaluated when the
  child exits so we can't get stuck there.
- Free "I spotted a classic dailywtf overcomplication" t-shirt goes to
  Michael Schroeder for pointing this out.

Abort depgen output reading on EOF, not child exiting
- There could, at least in theory, still be data to read after
  we receive SIGCHLD. Stop the loop on EOF on read instead.
  Thanks to Michael Schroeder for pointing this out.

Return explicit NULL from dbiFreeIndexSet()
- Explicit NULL is much more obvious here, also eliminate the (now)
  dead NULL-assignments and add a trash-n-burn memset() just in case

Cosmetics: function blocks start on a new line

Lift Dijkstra algorithm out of collectSCC() to separate function
- This splits outs nicely, moving queue allocation into separate
  scope and making collectSCC() less of an heavy-weight.
  No functional changes.

Eliminate struct copy in collectSCC(), use a pointer instead
- collectSCC() doesn't actually modify the SCC struct it looks at
  so operating on a copy is harmless, but using a (const) pointer
  to the original makes the idea more clear (we're not modifying
  the scc struct here, only its members)

Clean up + simplify pgpsigFormat()
- Don't do manually what the computer can do for you, let rasprintf()
  calculate the string sizes
- Handle possible date conversion errors: if we can't format the
  date correctly then at least show the integer value along with
  a complaint

Split the --replacepkgs hack to a helper function and document it
- Makes the huge rpmpsmStage() that little bit smaller, this
  special-case code does not belong inline there. Also gets rid
  of couple of dead assignments and unnecessary variable.
- Don't bother unless RPMPROB_FILTER_REPLACEPKG is set, it's not
  terribly expensive but its also wholly unnecessary in the normal case
- Document how the dang thing "works"

Make test-case for --replacepkgs stricter
- Actually verify we got the expected result, ie exactly one instance
  of the pkg installed after successful reinstall.

Reset cli configured flag on rpmcliFini() (RhBug:709421)

Cleanup rpmpsmNew() and rpmpsmFree()
- Remove redundant checks and other fluff, including dead
  NULL-assignments on free

Remove reamining dead assignments from rpmtsiFree() in transaction code
- Not all of these are at the end of local scope and in many cases
  the iterator pointer is reused, but the logic in all these is
  straightforward enough (no jumps etc) that there's no much
  chance of mistakenly using already freed iterator.

Remove dead NULL-assignment before reassign

Remove superfluous localtime() call
- The tm pointer is reset to localtime(&when) before accessed,
  this is nothing but a dead call and assignment

Remove dead keyp & keylen assignments in rpmdbNextIterator()
- Both get assigned to their values earlier in the loop and neither
  is used beyond this point in the loop .. so these are useless.

Clean up + clarify popMacro() a bit
- Actually protect against NULL mep (shouldn't happen but...)
- Remove bogus comment + add actually relevant comments
- Make the *mep reassignment more obvious by taking it out of
  the if where its easily missed
- Replace dead NULL-assignments with a trash-n-burn memset()
- Fixup indentation to match general rpm style

Use popMacro() when freeing the entire macro table
- We already have a function to free macro entries, use it to
  remove code duplication

Pass dbiClose() flags down to db->close()
- BDB of old might not have taken flags there but current ones
  do accept DB_NOSYNC to be specified (not that we use it but...)
- As a side-effect this eliminates another dead assignment

Return an explicit NULL from dbiFree(), remove dead assignment

Remove bogus condition on provide checking in query
- RPMQV_WHATPROVIDES only falls through to RPMQV_PATH on absolute
  paths, so the only place checking for provides_checked value would
  never be reached in the case it was set.
- Add a comment about the fallthrough case

Eliminate dead NULL-assignment by avoiding unnecessary allocation
- cpioHeaderRead() only needs to alloc after successfully reading
  the next filename from the cpio header, delay alloc until
  we know the read was successful.

Fix a logic error leading to unlink(NULL) call, oops.
- If writing the scriptlet to a file fails, its possible to
  end up with non-NULL script but with NULL fn and kaboom in unlink()

Eliminate bunch of dead assignments on ts vsflags
- The common pattern here is grabbing current flags to a local
  variable, modifying them for an operation and then restoring,
  which is fine... but we dont care about the previous flags
  when we're restoring them.

Eliminate dead assignment(s) on rpmfsFree(), memset() wipeout instead

rpmgiFree() cleanup to remove an exit point and dead assignment(s)

Remove trailing dead NULL-assignments from sepoltransFree()
- Replace assignments with a memset() to blast away the contents instead,
  taking care of other members too

Minor cleanups to sepolLoadPolicies() in sepolicy plugin
- Having an err label which we fall through on success too seems
  a bit funny, rename the label to exit
- Initialize the sepoltrans at declaration already
- Remove redundant RPMRC_FAIL assignment on sepoltransNew() fail
  case, this already assumes failure
- Remove redundant jump to exit from sepoltransCommit() error
- Eliminate trailing dead NULL assignment of the local pt variable

Return explicit NULL on sepoltransNew() failure

Remove possibility of abusing freed iterator by moving to local scope
- Eliminates another dead NULL-assignment + makes it "safer"

Eliminate obvious dead NULL-assignment at headerLoad() error exit

Eliminate dead NULL-assignment on lua scriptlet execution
- alloc the luavar on entry, free on exit to remove any abuse
  possibilities

Eliminate a few dead NULL-assignment eliminations in rpmgraph
- There are more but leaving the rest as a reminder to clean
  up rpmGraph() someday when bored enough...