kpgpkey.h

/*
    kpgpkey.h
 
    Copyright (C) 2001,2002 the KPGP authors
    See file AUTHORS.kpgp for details
 
    This file is part of KPGP, the KDE PGP/GnuPG support library.
 
    KPGP is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.
 
    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software Foundation,
    Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
 */
 
#ifndef KPGPKEY_H
#define KPGPKEY_H
 
#include <time.h>
 
#include <tqcstring.h>
#include <tqstring.h>
#include <tqstringlist.h>
#include <tqvaluelist.h>
 
namespace Kpgp {
 
typedef enum
{ // this is copied from gpgme.h which is a part of GPGME
  KPGP_VALIDITY_UNKNOWN = 0,   // the trust hasn't been determined
  KPGP_VALIDITY_UNDEFINED = 1, // trust is undefined
  KPGP_VALIDITY_NEVER = 2,
  KPGP_VALIDITY_MARGINAL = 3,
  KPGP_VALIDITY_FULL = 4,
  KPGP_VALIDITY_ULTIMATE = 5
} Validity;
 
typedef enum
{
  NeverEncrypt = -1,
  UnknownEncryptPref = 0,
  AlwaysEncrypt = 1,
  AlwaysEncryptIfPossible = 2,
  AlwaysAskForEncryption = 3,
  AskWheneverPossible = 4
} EncryptPref;
 
 
typedef TQCString KeyID;
 
class KeyIDList : public TQValueList<KeyID>
{
 public:
  KeyIDList() { }
  KeyIDList( const KeyIDList& l ) : TQValueList<KeyID>(l) { }
  KeyIDList( const TQValueList<KeyID>& l ) : TQValueList<KeyID>(l) { }
  KeyIDList( const KeyID& i ) { append(i); }
 
  TQStringList toStringList() const;
 
  static KeyIDList fromStringList( const TQStringList& );
};
 
class UserID
{
 public:
  UserID(const TQString& str,
             const Validity validity = KPGP_VALIDITY_UNKNOWN,
             const bool revoked = false,
             const bool invalid = false);
  ~UserID() {};
  
  TQString text() const;
 
  bool revoked() const;
 
  bool invalid() const;
 
  Validity validity() const;
 
  void setText(const TQString& str);
 
  void setRevoked(const bool revoked);
 
  void setInvalid(const bool invalid);
 
  void setValidity(const Validity validity);
 
 protected:
  bool mRevoked : 1;
  bool mInvalid : 1;
  Validity mValidity;
  TQString mText;
};
 
typedef TQPtrList<UserID> UserIDList;
typedef TQPtrListIterator<UserID> UserIDListIterator;
 
inline TQString UserID::text() const
{
  return mText;
}
 
inline bool UserID::revoked() const
{
  return mRevoked;
}
 
inline bool UserID::invalid() const
{
  return mInvalid;
}
 
inline Validity UserID::validity() const
{
  return mValidity;
}
 
inline void UserID::setText(const TQString& str)
{
  mText = str;
}
 
inline void UserID::setRevoked(const bool revoked)
{
  mRevoked = revoked;
}
 
inline void UserID::setInvalid(const bool invalid)
{
  mInvalid = invalid;
}
 
inline void UserID::setValidity(const Validity validity)
{
  mValidity = validity;
}
 
 
class Subkey
{
 public:
  Subkey(const KeyID& keyID, const bool secret = false);
  ~Subkey() {};
 
  bool secret() const;
 
  bool revoked() const;
 
  bool expired() const;
 
  bool disabled() const;
 
  bool invalid() const;
 
  bool canEncrypt() const;
 
  bool canSign() const;
 
  bool canCertify() const;
 
  unsigned int keyAlgorithm() const;
 
  unsigned int keyLength() const;
 
  KeyID longKeyID() const;
 
  KeyID keyID() const;
  
  TQCString fingerprint() const;
 
  time_t creationDate() const;
 
  time_t expirationDate() const;
 
  void setSecret(const bool secret);
 
  void setRevoked(const bool revoked);
 
  void setExpired(const bool expired);
 
  void setDisabled(const bool disabled);
 
  void setInvalid(const bool invalid);
 
  void setCanEncrypt(const bool canEncrypt);
 
  void setCanSign(const bool canSign);
 
  void setCanCertify(const bool canCertify);
 
  void setKeyAlgorithm(const unsigned int keyAlgo);
 
  void setKeyLength(const unsigned int keyLen);
 
  void setKeyID(const KeyID& keyID);
 
  void setFingerprint(const TQCString& fingerprint);
 
  void setCreationDate(const time_t creationDate);
 
  void setExpirationDate(const time_t expirationDate);
 
 protected:
  bool mSecret : 1;
  /* various flags */
  bool mRevoked : 1;
  bool mExpired : 1;
  bool mDisabled : 1;
  bool mInvalid : 1;
  bool mCanEncrypt : 1;
  bool mCanSign : 1;
  bool mCanCertify : 1;
 
  unsigned int mKeyAlgo;
  unsigned int mKeyLen;
  KeyID mKeyID;
  TQCString mFingerprint;
  time_t mTimestamp; /* -1 for invalid, 0 for not available */
  time_t mExpiration; /* -1 for never, 0 for not available */
};
 
inline bool Subkey::secret() const
{
  return mSecret;
}
 
inline bool Subkey::revoked() const
{
  return mRevoked;
}
 
inline bool Subkey::expired() const
{
  return mExpired;
}
 
inline bool Subkey::disabled() const
{
  return mDisabled;
}
 
inline bool Subkey::invalid() const
{
  return mInvalid;
}
 
inline bool Subkey::canEncrypt() const
{
  return mCanEncrypt;
}
 
inline bool Subkey::canSign() const
{
  return mCanSign;
}
 
inline bool Subkey::canCertify() const
{
  return mCanCertify;
}
 
inline unsigned int Subkey::keyAlgorithm() const
{
  return mKeyAlgo;
}
 
inline unsigned int Subkey::keyLength() const
{
  return mKeyLen;
}
 
inline KeyID Subkey::longKeyID() const
{
  return mKeyID;
}
 
inline KeyID Subkey::keyID() const
{
  return mKeyID.right(8);
}
 
inline TQCString Subkey::fingerprint() const
{
  return mFingerprint;
}
 
inline time_t Subkey::creationDate() const
{
  return mTimestamp;
}
 
inline time_t Subkey::expirationDate() const
{
  return mExpiration;
}
 
inline void Subkey::setSecret(const bool secret)
{
  mSecret = secret;
}
 
inline void Subkey::setRevoked(const bool revoked)
{
  mRevoked = revoked;
}
 
inline void Subkey::setExpired(const bool expired)
{
  mExpired = expired;
}
 
inline void Subkey::setDisabled(const bool disabled)
{
  mDisabled = disabled;
}
 
inline void Subkey::setInvalid(const bool invalid)
{
  mInvalid = invalid;
}
 
inline void Subkey::setCanEncrypt(const bool canEncrypt)
{
  mCanEncrypt = canEncrypt;
}
 
inline void Subkey::setCanSign(const bool canSign)
{
  mCanSign = canSign;
}
 
inline void Subkey::setCanCertify(const bool canCertify)
{
  mCanCertify = canCertify;
}
 
inline void Subkey::setKeyAlgorithm(const unsigned int keyAlgo)
{
  mKeyAlgo = keyAlgo;
}
 
inline void Subkey::setKeyLength(const unsigned int keyLen)
{
  mKeyLen = keyLen;
}
 
inline void Subkey::setKeyID(const KeyID& keyID)
{
  mKeyID = keyID;
}
 
inline void Subkey::setFingerprint(const TQCString& fingerprint)
{
  mFingerprint = fingerprint;
}
 
inline void Subkey::setCreationDate(const time_t creationDate)
{
  mTimestamp = creationDate;
}
 
inline void Subkey::setExpirationDate(const time_t expirationDate)
{
  mExpiration = expirationDate;
}
 
typedef TQPtrList<Subkey> SubkeyList;
typedef TQPtrListIterator<Subkey> SubkeyListIterator;
 
 
class Key
{
 public:
  Key( const KeyID& keyid = KeyID(),
       const TQString& uid = TQString(),
       const bool secret = false);
  ~Key();
 
  void clear();
 
  bool secret() const;
 
  bool revoked() const;
 
  bool expired() const;
 
  bool disabled() const;
 
  bool invalid() const;
 
  bool canEncrypt() const;
 
  bool canSign() const;
 
  bool canCertify() const;
 
  void setSecret(const bool secret);
 
  void setRevoked(const bool revoked);
 
  void setExpired(const bool expired);
 
  void setDisabled(const bool disabled);
 
  void setInvalid(const bool invalid);
 
  void setCanEncrypt(const bool canEncrypt);
 
  void setCanSign(const bool canSign);
 
  void setCanCertify(const bool canCertify);
 
 
  EncryptPref encryptionPreference();
 
  void setEncryptionPreference( const EncryptPref encrPref );
 
 
  TQString primaryUserID() const;
 
  KeyID primaryKeyID() const;
 
  TQCString primaryFingerprint() const;
 
  bool isNull() const;
 
  time_t creationDate() const;
 
  Validity keyTrust() const;
 
  Validity keyTrust( const TQString& uid ) const;
 
  void cloneKeyTrust( const Key* key );
 
  bool isValid() const;
 
  bool isValidEncryptionKey() const;
 
  bool isValidSigningKey() const;
 
  const UserIDList userIDs() const;
 
  const SubkeyList subkeys() const;
 
  void addUserID(const TQString& uid,
                 const Validity validity = KPGP_VALIDITY_UNKNOWN,
                 const bool revoked = false,
                 const bool invalid = false);
 
  void addUserID(const UserID *userID);
 
  bool matchesUserID(const TQString& str, bool cs = true);
 
  void addSubkey(const KeyID& keyID, const bool secret = false);
 
  void addSubkey(const Subkey *subkey);
 
  Subkey *getSubkey(const KeyID& keyID);
 
  void setFingerprint(const KeyID& keyID, const TQCString& fpr);
 
 protected:
  bool mSecret : 1;
  /* global flags */
  bool mRevoked : 1;
  bool mExpired : 1;
  bool mDisabled : 1;
  bool mInvalid : 1;
  bool mCanEncrypt : 1;
  bool mCanSign : 1;
  bool mCanCertify : 1;
  
  EncryptPref mEncryptPref;
 
  SubkeyList mSubkeys;
  UserIDList mUserIDs;
};
 
inline bool Key::secret() const
{
  return mSecret;
}
 
inline bool Key::revoked() const
{
  return mRevoked;
}
 
inline bool Key::expired() const
{
  return mExpired;
}
 
inline bool Key::disabled() const
{
  return mDisabled;
}
 
inline bool Key::invalid() const
{
  return mInvalid;
}
 
inline bool Key::canEncrypt() const
{
  return mCanEncrypt;
}
 
inline bool Key::canSign() const
{
  return mCanSign;
}
 
inline bool Key::canCertify() const
{
  return mCanCertify;
}
 
inline void Key::setSecret(const bool secret)
{
  mSecret = secret;
}
 
inline void Key::setRevoked(const bool revoked)
{
  mRevoked = revoked;
}
 
inline void Key::setExpired(const bool expired)
{
  mExpired = expired;
}
 
inline void Key::setDisabled(const bool disabled)
{
  mDisabled = disabled;
}
 
inline void Key::setInvalid(const bool invalid)
{
  mInvalid = invalid;
}
 
inline void Key::setCanEncrypt(const bool canEncrypt)
{
  mCanEncrypt = canEncrypt;
}
 
inline void Key::setCanSign(const bool canSign)
{
  mCanSign = canSign;
}
 
inline void Key::setCanCertify(const bool canCertify)
{
  mCanCertify = canCertify;
}
 
inline EncryptPref Key::encryptionPreference()
{
  return mEncryptPref;
}
 
inline void Key::setEncryptionPreference( const EncryptPref encrPref )
{
  mEncryptPref = encrPref;
}
 
inline TQString Key::primaryUserID() const
{
  UserID *uid = mUserIDs.getFirst();
 
  if (uid)
    return uid->text();
  else
    return TQString();
}
 
inline KeyID Key::primaryKeyID() const 
{
  Subkey *key = mSubkeys.getFirst();
 
  if (key)
    return key->keyID();
  else
    return KeyID();
}
 
inline TQCString Key::primaryFingerprint() const
{
  Subkey *key = mSubkeys.getFirst();
 
  if (key)
    return key->fingerprint();
  else
    return TQCString();
}
 
inline const UserIDList Key::userIDs() const
{ 
  return mUserIDs;
}
 
inline const SubkeyList Key::subkeys() const
{ 
  return mSubkeys;
}
 
inline bool Key::isNull() const
{
  return (mUserIDs.isEmpty() || mSubkeys.isEmpty());
}
 
inline time_t Key::creationDate() const
{
  if( !mSubkeys.isEmpty() )
    return mSubkeys.getFirst()->creationDate();
  else
    return -1;
}
 
inline void Key::addUserID(const UserID *userID)
{
  if (userID)
    mUserIDs.append(userID);
}
 
inline void Key::addSubkey(const Subkey *subkey)
{
  if (subkey)
    mSubkeys.append(subkey);
}
 
 
 
typedef TQPtrList<Key> KeyListBase;
typedef TQPtrListIterator<Key> KeyListIterator;
 
class KeyList : public KeyListBase
{
 public:
  ~KeyList()
    { clear(); }
 
 private:
  int compareItems( TQPtrCollection::Item s1, TQPtrCollection::Item s2 )
    { 
      // sort case insensitively by the primary User IDs
      return TQString::compare((static_cast<Key*>(s1))->primaryUserID().lower(),
                              (static_cast<Key*>(s2))->primaryUserID().lower());
    }
};
 
} // namespace Kpgp
 
#endif