RpmDb.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
\---------------------------------------------------------------------*/
// -*- C++ -*-
 
#ifndef ZYPP_TARGET_RPM_RPMDB_H
#define ZYPP_TARGET_RPM_RPMDB_H
 
#include <iosfwd>
#include <list>
#include <vector>
#include <string>
 
#include "zypp/Pathname.h"
#include "zypp/ExternalProgram.h"
 
#include "zypp/Package.h"
#include "zypp/KeyRing.h"
 
#include "zypp/target/rpm/RpmFlags.h"
#include "zypp/target/rpm/RpmHeader.h"
#include "zypp/target/rpm/RpmCallbacks.h"
#include "zypp/ZYppCallbacks.h"
 
namespace zypp
{
namespace target
{
namespace rpm
{
 
//
//      CLASS NAME : RpmDb
class RpmDb : public base::ReferenceCounted, private base::NonCopyable
{
public:
 
  typedef class InstTargetError Error;
 
  //
  // INITALISATION
  //
private:
 
  enum DbStateInfoBits {
    DbSI_NO_INIT        = 0x0000,
    DbSI_HAVE_V4        = 0x0001,
    DbSI_MADE_V4        = 0x0002,
    DbSI_MODIFIED_V4    = 0x0004,
    DbSI_HAVE_V3        = 0x0008,
    DbSI_HAVE_V3TOV4    = 0x0010,
    DbSI_MADE_V3TOV4    = 0x0020
  };
 
  friend std::ostream & operator<<( std::ostream & str, const DbStateInfoBits & obj );
 
  void dbsi_set( DbStateInfoBits & val_r, const unsigned & bits_r ) const
  {
    val_r = (DbStateInfoBits)(val_r | bits_r);
  }
  void dbsi_clr( DbStateInfoBits & val_r, const unsigned & bits_r ) const
  {
    val_r = (DbStateInfoBits)(val_r & ~bits_r);
  }
  bool dbsi_has( const DbStateInfoBits & val_r, const unsigned & bits_r ) const
  {
    return( (val_r & bits_r) == bits_r );
  }
 
  DbStateInfoBits _dbStateInfo;
 
  Pathname _root;
 
  Pathname _dbPath;
 
  void internal_initDatabase( const Pathname & root_r, const Pathname & dbPath_r,
                              DbStateInfoBits & info_r );
 
  static void removeV4( const Pathname & dbdir_r, bool v3backup_r );
 
  static void removeV3( const Pathname & dbdir_r, bool v3backup_r );
 
  void modifyDatabase();
 
public:
 
  RpmDb();
 
  ~RpmDb();
 
  Date timestamp() const;
 
  const Pathname & root() const
  {
    return _root;
  }
 
  const Pathname & dbPath() const
  {
    return _dbPath;
  }
 
  bool initialized() const
  {
    return( ! _root.empty() );
  }
 
  void initDatabase( Pathname root_r = Pathname(),
                     Pathname dbPath_r = Pathname(),
                     bool doRebuild_r = false );
 
  void closeDatabase();
 
  void rebuildDatabase();
 
  void importPubkey( const PublicKey & pubkey_r );
 
  void removePubkey( const PublicKey & pubkey_r );
 
  std::list<PublicKey> pubkeys() const;
 
  std::set<Edition> pubkeyEditions() const;
 
  //
  // Direct RPM database retrieval via librpm.
  //
public:
 
  std::list<FileInfo> fileList( const std::string & name_r, const Edition & edition_r ) const;
 
  bool hasFile( const std::string & file_r, const std::string & name_r = "" ) const;
 
  std::string whoOwnsFile( const std::string & file_r ) const;
 
  bool hasProvides( const std::string & tag_r ) const;
 
  bool hasRequiredBy( const std::string & tag_r ) const;
 
  bool hasConflicts( const std::string & tag_r ) const;
 
  bool hasPackage( const std::string & name_r ) const;
 
  bool hasPackage( const std::string & name_r, const Edition & ed_r ) const;
 
  void getData( const std::string & name_r,
                RpmHeader::constPtr & result_r ) const;
 
  void getData( const std::string & name_r, const Edition & ed_r,
                RpmHeader::constPtr & result_r ) const;
 
  //
public:
  enum SyncTrustedKeyBits
  {
    SYNC_TO_KEYRING     = 1<<0, 
    SYNC_FROM_KEYRING   = 1<<1, 
    SYNC_BOTH           = SYNC_TO_KEYRING | SYNC_FROM_KEYRING
  };
  void syncTrustedKeys( SyncTrustedKeyBits mode_r = SYNC_BOTH );
  void importZyppKeyRingTrustedKeys();
  void exportTrustedKeysInZyppKeyRing();
 
private:
  ExternalProgram *process;
 
  typedef std::vector<const char*> RpmArgVec;
 
  void run_rpm( const RpmArgVec& options,
                ExternalProgram::Stderr_Disposition stderr_disp =
                  ExternalProgram::Stderr_To_Stdout);
 
 
  bool systemReadLine(std::string &line);
 
  int systemStatus();
 
  void systemKill();
 
  int exit_code;
 
  std::string error_message;
 
  Pathname _backuppath;
 
  bool _packagebackups;
 
  bool _warndirexists;
 
  void processConfigFiles(const std::string& line,
                          const std::string& name,
                          const char* typemsg,
                          const char* difffailmsg,
                          const char* diffgenmsg);
 
 
public:
 
  typedef std::set<std::string> FileList;
 
  enum CheckPackageResult
  {
    CHK_OK            = 0, 
    CHK_NOTFOUND      = 1, 
    CHK_FAIL          = 2, 
    CHK_NOTTRUSTED    = 3, 
    CHK_NOKEY         = 4, 
    CHK_ERROR         = 5, 
    CHK_NOSIG         = 6, 
  };
 
  struct CheckPackageDetail : std::vector<std::pair<CheckPackageResult,std::string>>
  {};
 
  CheckPackageResult checkPackage( const Pathname & path_r, CheckPackageDetail & detail_r );
  CheckPackageResult checkPackage( const Pathname & path_r );
 
  CheckPackageResult checkPackageSignature( const Pathname & path_r, CheckPackageDetail & detail_r );
 
  void installPackage ( const Pathname & filename, RpmInstFlags flags = RPMINST_NONE );
 
  void removePackage( const std::string & name_r, RpmInstFlags flags = RPMINST_NONE );
  void removePackage( Package::constPtr package, RpmInstFlags flags = RPMINST_NONE );
 
  Pathname getBackupPath (void)
  {
    return _backuppath;
  }
 
  bool backupPackage(const std::string& packageName);
 
  bool backupPackage(const Pathname& filename);
 
  void setBackupPath(const Pathname& path);
 
  void createPackageBackups(bool yes)
  {
    _packagebackups = yes;
  }
 
  bool queryChangedFiles(FileList & fileList, const std::string& packageName);
 
public:
 
  virtual std::ostream & dumpOn( std::ostream & str ) const;
 
protected:
  void doRemovePackage( const std::string & name_r, RpmInstFlags flags, callback::SendReport<RpmRemoveReport> & report );
  void doInstallPackage( const Pathname & filename, RpmInstFlags flags, callback::SendReport<RpmInstallReport> & report );
  void doRebuildDatabase(callback::SendReport<RebuildDBReport> & report);
};
 
std::ostream & operator<<( std::ostream & str, RpmDb::CheckPackageResult obj );
 
std::ostream & operator<<( std::ostream & str, const RpmDb::CheckPackageDetail & obj );
 
} // namespace rpm
} // namespace target
} // namespace zypp
 
#endif // ZYPP_TARGET_RPM_RPMDB_H