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/Source.h"
#include "zypp/KeyRing.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();

          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() );

          void closeDatabase();

          void rebuildDatabase();

          void importPubkey( const Pathname & pubkey_r );

          std::list<PublicKey> pubkeys() const;

          std::set<Edition> pubkeyEditions() const;

          //
          // Cached RPM database retrieval via librpm.
          //
        private:

          class Packages;

          Packages & _packages;

          std::set<std::string> _filerequires;

        public:

          bool packagesValid() const;

          const std::list<Package::Ptr> & getPackages();

     #warning uncomment
#if 0

          void traceFileRel( const PkgRelation & rel_r );
#endif

          //
          // 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;


          static Package::Ptr makePackageFromHeader( const RpmHeader::constPtr header, std::set<std::string> * filerequires, const Pathname & location, Source_Ref source );

          //
        public:
          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;

          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 RpmInstFlag
            {
              RPMINST_NONE       = 0x0000,
              RPMINST_NODOCS     = 0x0001,
              RPMINST_NOSCRIPTS  = 0x0002,
              RPMINST_FORCE      = 0x0004,
              RPMINST_NODEPS     = 0x0008,
              RPMINST_IGNORESIZE = 0x0010,
              RPMINST_JUSTDB     = 0x0020,
              RPMINST_NODIGEST   = 0x0040,
              RPMINST_NOSIGNATURE= 0x0080,
              RPMINST_NOUPGRADE  = 0x0100,
              RPMINST_TEST       = 0x0200
            };

          enum checkPackageResult
            {
            CHK_OK                = 0x00,
            CHK_INCORRECT_VERSION = 0x01, // package does not contain expected version
            CHK_INCORRECT_FILEMD5 = 0x02, // md5sum of file is wrong (outside)
            CHK_GPGSIG_MISSING    = 0x04, // package is not signeed
            CHK_MD5SUM_MISSING    = 0x08, // package is not signeed
            CHK_INCORRECT_GPGSIG  = 0x10, // signature incorrect
            CHK_INCORRECT_PKGMD5  = 0x20, // md5sum incorrect (inside)
            CHK_OTHER_FAILURE     = 0x40  // rpm failed for some reason
            };


          unsigned checkPackage (const Pathname& filename, std::string version = "", std::string md5 = "" );

          void installPackage (const Pathname& filename, unsigned flags = 0 );

          void removePackage(const std::string & name_r, unsigned flags = 0);
          void removePackage(Package::constPtr package, unsigned flags = 0);

          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: // static members

          static std::string checkPackageResult2string(unsigned code);

        public:

          virtual std::ostream & dumpOn( std::ostream & str ) const;

          //
          // Installation log
          //
        private:

          class Logfile;

        public:

          static bool setInstallationLogfile( const Pathname & filename );

        protected:
          void doRemovePackage( const std::string & name_r, unsigned flags, callback::SendReport<RpmRemoveReport> & report );
          void doInstallPackage( const Pathname & filename, unsigned flags, callback::SendReport<RpmInstallReport> & report );
          const std::list<Package::Ptr> & doGetPackages(callback::SendReport<ScanDBReport> & report);
          void doRebuildDatabase(callback::SendReport<RebuildDBReport> & report);


      };

    } // namespace rpm
  } // namespace target
} // namespace zypp

#endif // ZYPP_TARGET_RPM_RPMDB_H

---