KeyRing.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
\---------------------------------------------------------------------*/
#ifndef ZYPP_KEYRING_H
#define ZYPP_KEYRING_H

#include <iosfwd>
#include <map>
#include <list>
#include <set>
#include <string>

#include "zypp/base/ReferenceCounted.h"
#include "zypp/Callback.h"
#include "zypp/base/PtrTypes.h"
#include "zypp/Locale.h"
#include "zypp/PublicKey.h"

namespace zypp
{ 

  DEFINE_PTR_TYPE(KeyRing);

  struct KeyRingReport : public callback::ReportBase
  {

    virtual bool askUserToAcceptUnsignedFile( const std::string &file );

    virtual bool askUserToAcceptUnknownKey( const std::string &file, const std::string &id );

    virtual bool askUserToTrustKey( const PublicKey &key);


    virtual bool askUserToImportKey( const PublicKey &key);
    virtual bool askUserToAcceptVerificationFailed( const std::string &file, const PublicKey &key );
  };

  struct KeyRingSignals : public callback::ReportBase
  {
    virtual void trustedKeyAdded( const PublicKey &/*key*/ )
    {}
    virtual void trustedKeyRemoved( const PublicKey &/*key*/ )
    {}
  };

  class KeyRingException : public Exception
   {
     public:
       KeyRingException()
       : Exception( "Bad Key Exception" )
       {}
       KeyRingException( const std::string & msg_r )
       : Exception( msg_r )
       {}
       virtual ~KeyRingException() throw() {};
   };

  //
  //    CLASS NAME : KeyRing
  //
  class KeyRing  : public base::ReferenceCounted, private base::NonCopyable
  {
    friend std::ostream & operator<<( std::ostream & str, const KeyRing & obj );

  public:
    class Impl;

  public:
    KeyRing(const Pathname &baseTmpDir);
    //explicit
    //KeyRing(const Pathname &general_kr, const Pathname &trusted_kr);

    void importKey( const PublicKey &key, bool trusted = false);

    void dumpTrustedPublicKey( const std::string &id, std::ostream &stream )
    { dumpPublicKey(id, true, stream); }

    void dumpUntrustedPublicKey( const std::string &id, std::ostream &stream )
    { dumpPublicKey(id, false, stream); }

    void dumpPublicKey( const std::string &id, bool trusted, std::ostream &stream );

    std::string readSignatureKeyId( const Pathname &signature );

    bool isKeyTrusted( const std::string &id);

    bool isKeyKnown( const std::string &id );

    void deleteKey( const std::string &id, bool trusted =  false);

    std::list<PublicKey> publicKeys();

    std::list<PublicKey> trustedPublicKeys();

    std::list<std::string> publicKeyIds();

    std::list<std::string> trustedPublicKeyIds();

    bool verifyFileSignatureWorkflow( const Pathname &file, const std::string filedesc, const Pathname &signature);
    bool verifyFileSignature( const Pathname &file, const Pathname &signature);
    bool verifyFileTrustedSignature( const Pathname &file, const Pathname &signature);

    ~KeyRing();

  public:

    //std::string asString() const
    //{}

  private:
    RWCOW_pointer<Impl> _pimpl;
  };

  inline std::ostream & operator<<( std::ostream & str, const KeyRing & /*obj*/ )
  {
    //return str << obj.asString();
    return str;
  }


  namespace target
  {
    namespace rpm
    {
      struct KeyRingSignals : public ::zypp::KeyRingSignals
      {};
    }
  }

} // namespace zypp
#endif // ZYPP_KEYRING_H

---