Raise exception in python on headerGet() invalid data failure

Test for file data tag sanity in fnTag() extensions

- Basename and dirindex counts must be equal, dirnames count must be
  larger than zero and no larger than number of basenames. Check
  that directory indexes are within range. Additionally file states
  array size, if used, must equal to the genaral file count.

Fix crash on INSTFILENAMES extension on non-installed package

- Packages with no RPMTAG_FILESTATES cannot have installed files
  from our POV, just exit early in that case.
- Rerrange the exit path a bit and only call rpmtdFreeData() on
  file states if the corresponding headerGet() call was actually
  made. Wont make any difference yet, but once we have other jumps
  to exit it will.

Sanitize filename tag extension handling

- Rename rpmfiBuildFNames() to fnTag() and push all the td manipulation
  there, making all the various different fn-related tags differ by
  just the arguments to fnTag() and allowing central error etc
  handling. No functional changes (yet) though.

Flag error in tag container for non-extension tag retrieval

- This should mostly be a can't happen case, but at least in theory
  region retrieval could fail. So could unknown data type, but a header
  with unknown data types shouldn't even load... Anyway, there could
  be further error cases we might be able to flag here.

Add error indicator flag for tag data containers

- Tag retrieval can in some cases fail, especially so for tag
  extensions. The headerGet() interface doesn't directly allow
  distinguishing between non-existent tag and existent but invalid,
  but we can sneak in that information through in the tag data flags.

Add getter for rpmtd flags

- While these are mostly of rpmtd-internal interest only, there are
  cases when caller might want to know...

Remap inode numbers to fit into 32bit integer space on build (RhBug:714678)

- 64bit inode numbers lose their uniquity when brutally truncated
  to 32bit integers as we've done so far. This can and will cause rpm
  (and cpio) to mix up arbitrary file entries as hardlinks and vice versa.
- As the only interesting aspect of inode numbers is whether they're
  equal to something else or not, we dont have to carry the "physical"
  on-disk value to preserve semantics. So we can just remap the
  inode numbers to something that fits our 32bit integer tags
  without causing compatibility complexies with older rpms and
  cpio (and since we can't handle more than INT32_MAX files in a package
  anyway, breaking compatibility for this would be just braindead dumb).
  An extremely simple way to achieve this is to use our
  build-time file list index as the basis of stored inode number.
- In theory this breaks inode-device pairing, but as the buildroot
  cannot span across filesystems in any remotely normal conditions,
  just add a sanity check to catch the dirty tricksters...
- Based on a patch by Zdenek Pavlas, just further simplified and
  buildroot fs boundary sanity check added.

Also test that total size is calculated correctly wrt hardlinks

Add a rough-cut testcase for hardlink handling

- Check that we get expected number of links in package generation,
  that all the files got installed and that the linked files are
  actually hardlinks (for our purposes, plain inode suffices)

Add tag extension to calculate hardlink count for files

Switch back to former, much smaller BDB memory pool size (RhBug:752897)

- A larger cache is beneficial in various scenarios, but triggers
  horrible worst-case performance under memory pressure (or so my
  current theory goes, there might be other factors too). The
  worst-case degration is orders of magnitude bigger than the best-case
  improvements from the larger cache and for many use-cases doesn't
  make a whole lot difference.  We could/should tune the cache with
  priorizing indexes and all, and perhaps dynamically select the
  cache size but for now, the 1Mb cache size is known to "just work".

Add --test option to rpmkeys

- Allows, well, testing whether a key could be imported before actually
  doing it

Honor RPMTRANS_FLAG_TEST in rpmtsImportPubkey()

Remove the arbitrary limitation on transaction keyring change

- There are some situations where switching keyrings might be wanted,
  especially as long as we dont export a way to pass keyring as
  an argument to package reading/verification functions. Since thereäs
  no technical reason to disallow it, might as well allow it...

Disable signature checking during database rebuild by default

- While it would be perfectly reasonable to perform signature
  checking during db rebuild, this is problematic as long as our
  keys live in the same database we're rebuilding: the environment
  might be paniced, the indexes required for key lookups might be
  corrupt or non-existent etc - one would assume there's a reason for
  the db is getting rebuilt in the first place. When signature checking
  is enabled, we're forced to generate missing indexes on the potentially
  borked database we're just about to rebuild, which might not go very
  well, and since they keyring loading has no clue its getting called
  from middle of db rebuild it'll try to use a shared environment
  which might be broken ... etc.

Use private environment for database rebuilds too, document

- One of the more common reasons for users to do --rebuilddb is
  a paniced environment. Throwing DB_RUNRECOVER errors at the user
  who is trying to recover by rebuilding the db isn't terribly
  productive (RhBug:590710). Use a private environment while
  rebuilding for both the original and new database, and dont bother
  with CDB which only slows things down when there are no other
  players present.
- Verify wants the same flags but for different reasons...

Never load ts keyring if signature checking is disabled

- Loading the pubkeys from database numerous often unwanted side-effects,
  if signature checking is disabled then there's no point loading
  the keys either.
- Commit cad147070e5513312d851f44998012e8f0cdf1e3 did this for
  rpmReadPackageFile() specifically but we really want it honored
  for all operations including headerCheck() and friends, handle
  it centrally in loadKeys() for simplicity.

Don't free up file info sets on transaction test-runs

- We'd like to get rid of the potentially huge amounts of memory
  eaten by file info sets as early as possible, but when there's a
  chance that we'll get called again with either added transacation
  elements or on-disk changes, such as %pretrans changing something
  underneath us, we need to (be able to) recalculate everything
  from scratch. Only free up the memory when we know we dont need
  it anymore, ie on an actual transaction run.
- This doesn't change anything for rpm itself, for yum and others
  which do a separate test-transaction first, it means %pretrans
  directory<->symlink replacement hacks and the like have a chance
  of working again. I'm sure there's a bug filed on this somewhere but...

Use rpmReadHeader() on signature checking path too

- rpmReadHeader() performs far more initial sanity checks on the header
  than headerRead() does, and makes behavior consistent with eg query
  and install paths. As an added bonus we'll get more detailed
  error messages too.

Add a basic testcase for bogus filename triplet detection

Test for filename triplet sanity in rpmfiNew()

- Basename and dirindex counts must be equal, dirnames count must be
  larger than zero and no larger than number of basenames. Check
  that directory indexes are within range.
- There are mountains of further checks to be added here (and elsewhere)
  but we gotta start somewhere... and filename triplets are one of the more
  critical elements we got.

xcalloc() cannot return NULL, remove redundant check

Don't assume rpmfiNew() always succeeds

- Add NULL checks and add/adjust comments where appropriate.
- The remaining callers should handle NULL fi gracefully if not
  entirely correctly: rpmfiFC() returns 0 on NULL fi, so these
  callers just see the erronous file info set as "no files" case.
  Something to fine-tune later...

Add a basic testcase for bogus (incomplete) header detection

Add some basic sanity checks to rpmte creation, allow rpmteNew() to fail

- Verify that a header at least has the very basic elements like
  name, version, release, os and arch (except for gpg-pubkeys which
  dont have the latter two, sigh), fail if not.
- rpmfiNew() cannot currently fail but handling this error will allow
  sanity checking the file metadata which can be inconsistent even if
  a header is "physically" consistent.
- We'll eventually want to have sanity checks on dependency sets too, but
  unlike rpmfiNew(), rpmdsNew() currently returns NULL for non-existent
  dependencies (eg most packages do not have conflicts or obsoletes) to
  save memory. Either that needs to change or we'll need to check
  for tag existence for the meaning of a returned NULL here.

Don't assume rpmteNew() always succeeds, part III

- Return error from verifyscript if rpmteNew() fails. This can't
  currently happen but handling this error makes it possible to
  do sanity checks on the header contents, such as file list integrity etc.
  Unlikely to occur for installed packages, but verify can be run
  on non-installed packages as well, where failure is more of a possibility.

Move TR_ADDED file size init into addTE()

- No functional changes, just stuffing it there along with most
  other rpmte init work and remove the pointless switch-case while at it

Don't assume rpmteNew() always succeeds, part II

- Return error from rpmtsAddInstallElement() if rpmteNew() fails. This
  can't currently happen, but handling this error makes it possible
  to do sanity checks on the header contents, such as file list integrity.

Error out early if rpmdb open fails on upgrade element addition

- If we can't open the rpmdb then we cannot correctly process the
  upgrade, error out early. Mostly a "can't happen" case though.
  Also makes the logic a bit clearer, hopefully.

Don't assume rpmteNew() always succeeds, part I

- Return error from removePackage() if rpmteNew() fails. This can't
  currently happen and is unlikely anyway on already installed
  packages (this is more interesting for added packages) but
  just in case...
- Handling failure from upgrade- and obsoletes erasures is trickier
  both can add any number of erasure elements, and if one of them
  fails we'd need to undo all the erasures caused by this element.
  Just add a reminder comment for now.

Axe unused cruft

Kill off yet more repackage remnants from fsm

- CPIO_ALL_HARDLINKS flag and related code has been unused and dead
  since rpm >= 4.6.x

Lift hard-link payload writing to helper function, fsmStage is big enough

Eliminate FSM_WOPEN, FSM_WRITE and FSM_WCLOSE stages

- These are nothing but unnecessarily specialized Fopen(), Fwrite() and
  Fclose() for what is a purely local need in expandRegular(). Move
  the local stuff where it belongs.

Eliminate FSM_ROPEN, FSM_READ and FSM_RCLOSE stages

- These are nothing but unnecessarily specialized Fopen(), Fread() and
  Fclose() for what is a purely local need in writeFile(). Move
  the local stuff where it belongs.

Eliminate file digest related members from fsm struct

- Both digest algo and the current file digest from header are
  only needed inside expandRegular(), push the stuff down there.

Eliminate the now obviously unnecessary opath member from fsm struct

Avoid fsm->opath usage for symlink target

- Instead of behind-the-scenes pointer updating, use fsm->wrbuf
  explicitly for the link target. Doesn't make it less hackish
  but at least it now stands out.

Avoid fsm->opath usage in fsmMakeLinks()

- opath is the file that links will be made to, we grab it at the
  start and free at the end. No need to save and restore what we
  dont modify, one more fsm->opath usage down...

Remove unused FSM_MKLINKS stage

Avoid fsm->opath usage in final file rename

- Hopefully this makes the actual operation stand out more clearly
  with the unnecessary fsm->opath fiddling out of the picture,
  other than that there's not much to gain here.

Eliminate unnecessary fsm->path/opath shuffle on unlink

- No need to save and restore what we dont modify...
- Add comments to double-check later for couple of fishy looking bits

Eliminate unnecessary fsm->path/opath shuffle on backup renaming

- Makes the code much more obvious to follow since we're not swapping
  path/opath back and forwards just to be able to use a throwaway
  path for the rename. Dont bother null-checking on logging,
  if one of the paths was null we'd be dead already.
- Also fixes an ancient memleak: when osuffix is in use, fsm->path
  gets newly malloced before fsmVerify() but this part did another
  allocation on it, didn't save and restore fsm->path .. and nothing
  was freeing the original (local) allocation of fsm->path, only
  restoring the previous value.

Eliminate unnecessary st_mode save-modify-restore on dir creation

Eliminate unnecessary save-modify-restore around fsmUtime()

Eliminate unnecessary save-modify-restore on fifo creation

Move symlink() to separate helper function

- Similar to mkfifo(), mknod() & friends, doesn't do much but for
  consistency and fsmStage() size sanity...

Eliminate stupid fsm->path/opath in FSM_COMMIT now that we can

- Now that we can directly operate on temporarily variables instead
  of having to save-ping-restore-pong them, lets do so...
- Also eliminating NULL-checks on the path variables in logging - if
  either of the paths were NULL we would've already crashed in rename()

Blarg, stupid stupid mistake breaking symlink handling

- Introduced in commit d15bf56a70fdc2322a8d71f255241c20d895834f and
  uncaught prior to push as none of the test-suite cases involve
  symlinks. This is what happens when trying to quickly rewrite
  git history to put combine a forgotten change into earlier ones,
  guilty as charged :(

Only pass what little is actually needed in fsmMkdirs()

- Once all the other cruft has been carved out, turns out this needs
  nothing but a directory iterator which we can init and free
  in the caller easily enough, and selabel handle (duh). All the
  rest is independent of fsm internals in reality.

Eliminate stupid fsm->sb.st_mode abuse from fsmMkdirs()

- At the point where this runs there's probably nothing at all to
  save and restore in the stat buf anyway, but it's just stupid to
  abuse that when all we need is a local mode_t temp variable. Fix
  it now that we can.

Move mknod() to separate helper function

- Similar to mknod() and all, this doesn't do anything that special
  but fsmStage() is big enough as it is.

Move mkfifo() to separate helper function

- Similar to the other fsm syscall wrappers, this doesn't do anything
  that special, but fsmStage() is big enough without things like
  this inline.

Change fsmReadLink() to take "normal" arguments

- This doesn't need access to the entire fsm, it just needs a buffer
  to place the results in / return errors. Currently the "out" buffer
  is (ab)used for the results, this just forces that to stand out
  and should make it easier to sanitize later.

Change fsmUtime() to take "normal" arguments

- This doesn't need access to the entire fsm, just path and mtime
  from coming from a header originally. Will allow eliminating
  save -> abuse -> restore behavior in caller but leaving till later...

Change fsmChown(), fsmLChown() and fsmChmod() to take "normal" arguments

- None of these needs access to the entire fsm, they only
  exist to map and filter errors to rpm special needs and to
  create debug swew on top of the plain syscalls.

Change fsmMkdir() to take "normal" arguments

- This doesn't need access to the entire fsm, it only exists to
  map errors to CPIOERR_* and create debug foo. This will allow
  eliminating save -> abuse -> restore behavior in callers, but
  leaving that till later.

Change fsmStat() to take "normal" arguments

- This doesn't need access to the entire fsm, just regular stat()
  args and a flag whether to use lstat() or stat(). "followlinks"
  or such would be saner name for the flag but leaving that for now...

Change fsmRename() to take "normal" arguments

- This doesn't need access to the entire fsm, just regular rename()
  args and a flags to see whether "secure" delete should be done.
  In itself this only looks like more trouble, but all the callers
  are fiddling and saving and restoring with fsm->[o]path just
  to call this, which we can now avoid. Leaving sanitizing the
  callers till later though, this is a minefield...

Change fsmUnlink() and fsmRmdir() to take "normal" arguments

- Neither of these needs access to the entire fsm, they mostly
  exist to create debug cruft and to map errors to CPIOERR_*

Sanitize file capability setting in fsm

- Move parsing, setting and freeing of capabilities into simple
  helper function, there's no point whatsoever having the current
  capability stored in fsm when it only complicates freeing and all.
  WTH was I thinking when implementing this? (well, everything in
  fsm was done that way so...  but that's a lame excuse)

Sanitize selinux labeling in fsm

- Move all the label foobar into a simple helper function which
  finds, sets and frees the context if selinux is enabled, use
  for both regular operation and orphan directory labeling.
  Simplifies things a good deal...
- While the selabel handle can change during a transaction, it
  wont change while the fsm is running so its sufficient to grab
  it on entry instead of repeatedly calling rpmtsSELabelHandle() after
  figuring out where in the world our ts might be.

Eliminate unused subdir member from fsm struct

Eliminate silly sufbuf from fsm struct

- Allocate fsm->suffix directly when suffix is needed instead.
  Doesn't change anything, only makes life that little bit simpler.

Ensure installs always use a temp suffix on files

- This bogosity goes back to commit fcf6b50378eaeac4c1f7ca215b33586b4d41072f
  which was supposed to fix files getting erased if time() returns
  errors (RhBug:223931). Problem is, this "fix" didn't fix anything
  at all as the suffix still wouldn't be created in the error
  case, even if the FSM_UNDO part did the right thing. We always
  want a suffix on installs, it doesn't matter *what* the suffix is.

Remove unused "orphan" directory creation tracking variable from fsm

Move directory tracking variables out of fsm struct to local scope

- These are not used or needed outside fsmMkdirs() so its just
  plain dumb to have them in the big struct. No functional changes,
  just taming the fsm monster a little bit.

Add bunch of links to test-suite chroot to allow selinux to work

- With the new warning on failure to open selinux labels from
  commit 7a8b75d26605cf7a3fde9f624a80d6fb8390fcbd, the test-suite
  fails on large number of tests due to the extra output. This
  takes care of these false alarms on F16 at least.
- Recent selinux wants /etc/selinux and /sys (for /sys/fs/selinux),
  older ones would want /selinux. Add in /proc for good measure,
  selinux doesn't need it butit wont hurt either, other things will
  want it sooner or later.

remove the 'path' parameter of rpmtsSELabelInit()

- It is always selinux_file_context_path() anyway.

selinux: reopen label between transactions if necessary (RhBug: 746073)

Show arch in --last output too (RhBug:768516)

Eliminate now unnecessary runFsm() helper from psm

Eliminate no longer needed RPMFI_ISBUILD and RPMFI_ISSOURCE internal flags

Turn FSM into a blackbox, much like PSM is

- Similar in spirit to PSM blackbox treatment in
  commit df9cdb1321ada8e3b120771f91a2eefab4ac2ad5, except that
  technically fsm guts are still wide-open in fsm.h due to cpio
  "needing" them (yuck).
- Allows getting rid of dumb a**-backwards things like rpmfiFSM()
  which is just not needed, fsm is a relatively short-lived entity
  inside psm and build, nobody else needs to bother with it except
  for the returned results.
- Figure out the cpio map flags in fsmSetup() where it logically belongs,
  we have all the necessary info available there.
- Get rid of newFSM() and freeFSM(), we can just as well place the
  fsm on stack, merge the necessary cleanup bits from freeFSM()
  into fsmTeardown()
- Supposedly no functional changes, knock wood.

Eliminate archiveSize member from rpmfi

- rpmfi itself doesn't need it for anything, its only really used
  for progress reporting during install. Grab the size into psm
  total directly, this is already passed down to fsm.
- Removes one of the last remaining rpmfi opacity violations, just
  fi->apath to go...

Explicitly tell rpmfiNew() when its being used for build

- Eliminate feeble heuristic on archive size tag not being set during
  build for detecting this and have build code explicitly pass
  RPMFI_ISBUILD flag instead.
- Also eliminate the pointless isSource variable from rpmfiNew() while.

Issue package install/erase progress callbacks on justdb operation too

- Large --justdb operations can take considerable amount of time as well,
  getting progress bars for it is nice even if hardly necessary...

Eliminate fluff from PSM_INIT

- rpmpsmStage() runs with RPMRC_OK as assumed result, no need to
  set explicitly here.
- Dont bother testing for justdb flag here. The justdb case doesn't
  need fi->apath but it doesn't exactly hurt either, and we'll want
  to eliminate the apath kludge sooner or later anyway.

Update translations & sync with transifex

Oops, forgot to mark our new progress messages for translation

Adapt perl and python fileattrs to file 5.10 magics

- file 5.10 has changed magics at least for perl and python scripts, samples:

  5.09: a /usr/bin/perl -w script, ASCII text executable, with very long lines
  5.10: Perl script, ASCII text executable, with very long lines

  5.09: a /usr/bin/python script, ASCII text executable
  5.10: Python script, ASCII text executable

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

Transaction element parent is a transaction element, not an integer

- Ehm, this has been broken in the python bindings since the start,
  nobody noticed. Of course the parent value isn't particularly
  useful in normal usage but still...

Minor cleanup to rpmte_Key()

- Fix misleading indentation, initialize Key on declaration.
  No functional changes.

And finally, permit --hash and --percent cli-switches on erasures too

Add erasure callback support to rpmShowProgress() and enable on rpmErase()

- Just use the same bits as install does, they behave the same for
  our purposes. On upgrades the output would get confusing especially
  with --hash when package versions aren't output'ed, so we print
  out extra output when entering install and erase stages. Only
  do this when --hash is used (ie a human is probably watching us)
  to hopefully avoid breaking scripts (including our test-suite) that
  rely on the ages old behavior of non-hashed output.

Issue actual erasure progress callbacks too

- Whereas on install the progress is measured by bytes written to
  disk vs total archive size, on erase the best we can do is
  going by the number of files in the package. Fsm iterates backwards
  on erase so we can't just use fsm->ix but need to re-revert the value.

Clean up progress callbacks in fsm/psm machinery

- Move notifications from fsm to psm side for sanity and symmetry,
  psm already has members to hold the callback state.
- Replace PSM_NOTIFY "state" with a helper function that both
  fsm and psm itself use (except for error callbacks which are
  a bit different)
- Init psm->total early, this doesn't change and can now be
  used to refer to "all done" value whatever it happens to be,
  instead of magic "100" values etc.
- Packages with no files are now handled through the same path
  as everything else from progress reporting pov, we just skip calls
  to fsm if there are no files.
- Issue stop callbacks for install as well. While INST_CLOSE_FILE
  can be (and is currently) used to detect this condition, its
  conceptually an entirely different thing.
- Fix erasure callback parameters, they were reversed (starting from
  total and ending with 0, ehh...)

Add enum for RPMCALLBACK_INST_STOP callback event

- Unused atm but we'll be adding this shortly

Pass and remember the controlling psm (if any) in fsm

Eliminate repackage notification remnants from fsm

- This has been unused and dead code since rpm >= 4.6.0

Use rpmtsNotify() directly for psm error callbacks

- On error we're already on our way out of the psm, no point mucking
  with the psm state. No functional changes, just makes the code
  a little bit shorter.

document -D and -E in man.

rpmOption.required is not used.

rpmrc: do not use that nonexistent rpmOptionValue struct.

depends.c: save us one rpmdsNew in addObsoleteErasures.

- replaces rpmdsAnyMatchesDep with rpmdsNVRMatchesDep

depends.c: unused parameters in addUpgradeErasures, addObsoleteErasures.

- remove them.

Implement scriptlet start and stop callbacks (RhBug:606239)

- Adds two new transaction callbacks: RPMCALLBACK_SCRIPT_START and
  RPMCALLBACK_SCRIPT_STOP which get issued for every scriptlet we run.
- On script start, callback can optionally return an FD which will
  override transaction-wide script fd to make it easier to accurately
  collect per-scriptlet output (eg per-scriptlet temporary file).
  Callback is also responsible for closing the fd if it returns one.
- For both callbacks, "amount" holds the script tag number. On stop
  callback, "total" holds the scriptlet exit status mapped into
  OK/NOTFOUND/FAIL for success/non-fatal/fatal errors. Abusing "notfound"
  for warning result is ugly but differentiating it from the other
  cases allows callers to ignore SCRIPT_ERROR if they choose to
  implement stop and start.

Eliminate rpm cli callback internals from the API

- rpmcliHashes*, and rpmcliProgress* and rpmcliPackagesTotal are
  implementation details of rpmShowProgress() and are useless outside
  of it. Make them static, these shouldn't have been exported to
  begin with.

Eliminate pointless rpmcliPackagesTotal fiddling

- The total number of packages equals transaction order count, which
  is passed as total to transaction start callback. In particular
  messing with this from rpmtsAddInstallElement() is just stupid.
- This will break callers that are relying on rpmcliPackagesTotal value
  outside a running transaction, but that's just stupid anyway. The
  correct way to get number of elements in transaction set is calling
  rpmtsNElements(), which has been there for a good part of a decade.