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