00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033 #ifdef HAVE_CONFIG_H
00034 #include <config.h>
00035 #endif
00036
00037 #include "kconfigbasedkeyfilter.h"
00038
00039 #include <kconfigbase.h>
00040 #include <klocale.h>
00041
00042 static const struct {
00043 const char * name;
00044 GpgME::Key::OwnerTrust trust;
00045 GpgME::UserID::Validity validity;
00046 } ownerTrustAndValidityMap[] = {
00047 { "unknown", GpgME::Key::Unknown, GpgME::UserID::Unknown },
00048 { "undefined", GpgME::Key::Undefined, GpgME::UserID::Undefined },
00049 { "never", GpgME::Key::Never, GpgME::UserID::Never },
00050 { "marginal", GpgME::Key::Marginal, GpgME::UserID::Marginal },
00051 { "full", GpgME::Key::Full, GpgME::UserID::Full },
00052 { "ultimate", GpgME::Key::Ultimate, GpgME::UserID::Ultimate },
00053 };
00054
00055 static GpgME::Key::OwnerTrust map2OwnerTrust( const QString & s ) {
00056 for ( unsigned int i = 0 ; i < sizeof ownerTrustAndValidityMap / sizeof *ownerTrustAndValidityMap ; ++i )
00057 if ( s.lower() == ownerTrustAndValidityMap[i].name )
00058 return ownerTrustAndValidityMap[i].trust;
00059 return ownerTrustAndValidityMap[0].trust;
00060 }
00061
00062 static GpgME::UserID::Validity map2Validity( const QString & s ) {
00063 for ( unsigned int i = 0 ; i < sizeof ownerTrustAndValidityMap / sizeof *ownerTrustAndValidityMap ; ++i )
00064 if ( s.lower() == ownerTrustAndValidityMap[i].name )
00065 return ownerTrustAndValidityMap[i].validity;
00066 return ownerTrustAndValidityMap[0].validity;
00067 }
00068
00069
00070 Kleo::KConfigBasedKeyFilter::KConfigBasedKeyFilter( const KConfigBase & config )
00071 : KeyFilter(),
00072 mSpecificity( 0 ),
00073 mItalic( false ),
00074 mBold( false ),
00075 mStrikeOut( false ),
00076 mUseFullFont( false ),
00077 mRevoked( DoesNotMatter ),
00078 mExpired( DoesNotMatter ),
00079 mDisabled( DoesNotMatter ),
00080 mRoot( DoesNotMatter ),
00081 mCanEncrypt( DoesNotMatter ),
00082 mCanSign( DoesNotMatter ),
00083 mCanCertify( DoesNotMatter ),
00084 mCanAuthenticate( DoesNotMatter ),
00085 mHasSecret( DoesNotMatter ),
00086 mIsOpenPGP( DoesNotMatter ),
00087 mWasValidated( DoesNotMatter ),
00088 mOwnerTrust( LevelDoesNotMatter ),
00089 mOwnerTrustReferenceLevel( GpgME::Key::Unknown ),
00090 mValidity( LevelDoesNotMatter ),
00091 mValidityReferenceLevel( GpgME::UserID::Unknown )
00092 {
00093 mFgColor = config.readColorEntry( "foreground-color" );
00094 mBgColor = config.readColorEntry( "background-color" );
00095 mName = config.readEntry( "name", i18n("<unnamed>") );
00096 mIcon = config.readEntry( "icon" );
00097 if ( config.hasKey( "font" ) ) {
00098 mUseFullFont = true;
00099 mFont = config.readFontEntry( "font" );
00100 } else {
00101 mItalic = config.readBoolEntry( "font-italic", false );
00102 mBold = config.readBoolEntry( "font-bold", false );
00103 }
00104 mStrikeOut = config.readBoolEntry( "font-strikeout", false );
00105 #ifdef SET
00106 #undef SET
00107 #endif
00108 #define SET(member,key) \
00109 if ( config.hasKey( key ) ) { \
00110 member = config.readBoolEntry( key ) ? Set : NotSet ; \
00111 ++mSpecificity; \
00112 }
00113 SET( mRevoked, "is-revoked" );
00114 SET( mExpired, "is-expired" );
00115 SET( mDisabled, "is-disabled" );
00116 SET( mRoot, "is-root-certificate" );
00117 SET( mCanEncrypt, "can-encrypt" );
00118 SET( mCanSign, "can-sign" );
00119 SET( mCanCertify, "can-certify" );
00120 SET( mCanAuthenticate, "can-authenticate" );
00121 SET( mHasSecret, "has-secret-key" );
00122 SET( mIsOpenPGP, "is-openpgp-key" );
00123 SET( mWasValidated, "was-validated" );
00124 #undef SET
00125 static const struct {
00126 const char * prefix;
00127 LevelState state;
00128 } prefixMap[] = {
00129 { "is-", Is },
00130 { "is-not-", IsNot },
00131 { "is-at-least-", IsAtLeast },
00132 { "is-at-most-", IsAtMost },
00133 };
00134 for ( unsigned int i = 0 ; i < sizeof prefixMap / sizeof *prefixMap ; ++i ) {
00135 const QString key = QString( prefixMap[i].prefix ) + "ownertrust";
00136 if ( config.hasKey( key ) ) {
00137 mOwnerTrust = prefixMap[i].state;
00138 mOwnerTrustReferenceLevel = map2OwnerTrust( config.readEntry( key ) );
00139 ++mSpecificity;
00140 break;
00141 }
00142 }
00143 for ( unsigned int i = 0 ; i < sizeof prefixMap / sizeof *prefixMap ; ++i ) {
00144 const QString key = QString( prefixMap[i].prefix ) + "validity";
00145 if ( config.hasKey( key ) ) {
00146 mValidity = prefixMap[i].state;
00147 mValidityReferenceLevel = map2Validity( config.readEntry( key ) );
00148 ++mSpecificity;
00149 break;
00150 }
00151 }
00152 }
00153
00154 Kleo::KConfigBasedKeyFilter::~KConfigBasedKeyFilter() {
00155
00156 }
00157
00158 bool Kleo::KConfigBasedKeyFilter::matches( const GpgME::Key & key ) const {
00159 #ifdef MATCH
00160 #undef MATCH
00161 #endif
00162 #define MATCH(member,method) \
00163 if ( member != DoesNotMatter && key.method() != bool( member == Set ) ) \
00164 return false
00165 #define IS_MATCH(what) MATCH( m##what, is##what )
00166 #define CAN_MATCH(what) MATCH( mCan##what, can##what )
00167 IS_MATCH( Revoked );
00168 IS_MATCH( Expired );
00169 IS_MATCH( Disabled );
00170 IS_MATCH( Root );
00171 CAN_MATCH( Encrypt );
00172 CAN_MATCH( Sign );
00173 CAN_MATCH( Certify );
00174 CAN_MATCH( Authenticate );
00175 MATCH( mHasSecret, isSecret );
00176 #undef MATCH
00177 if ( mIsOpenPGP != DoesNotMatter &&
00178 bool( key.protocol() == GpgME::Context::OpenPGP ) != bool( mIsOpenPGP == Set ) )
00179 return false;
00180 if ( mWasValidated != DoesNotMatter &&
00181 bool( key.keyListMode() & GpgME::Context::Validate ) != bool( mWasValidated == Set ) )
00182 return false;
00183 switch ( mOwnerTrust ) {
00184 default:
00185 case LevelDoesNotMatter:
00186 break;
00187 case Is:
00188 if ( key.ownerTrust() != mOwnerTrustReferenceLevel )
00189 return false;
00190 break;
00191 case IsNot:
00192 if ( key.ownerTrust() == mOwnerTrustReferenceLevel )
00193 return false;
00194 break;
00195 case IsAtLeast:
00196 if ( (int)key.ownerTrust() < (int)mOwnerTrustReferenceLevel )
00197 return false;
00198 break;
00199 case IsAtMost:
00200 if ( (int)key.ownerTrust() > (int)mOwnerTrustReferenceLevel )
00201 return false;
00202 break;
00203 }
00204 const GpgME::UserID uid = key.userID(0);
00205 switch ( mValidity ) {
00206 default:
00207 case LevelDoesNotMatter:
00208 break;
00209 case Is:
00210 if ( uid.validity() != mValidityReferenceLevel )
00211 return false;
00212 break;
00213 case IsNot:
00214 if ( uid.validity() == mValidityReferenceLevel )
00215 return false;
00216 break;
00217 case IsAtLeast:
00218 if ( (int)uid.validity() < (int)mValidityReferenceLevel )
00219 return false;
00220 break;
00221 case IsAtMost:
00222 if ( (int)uid.validity() > (int)mValidityReferenceLevel )
00223 return false;
00224 break;
00225 }
00226 return true;
00227 }
00228
00229 static inline QFont resizedFont( QFont font, int pointSize, bool strike ) {
00230 font.setPointSize( pointSize );
00231 if ( strike )
00232 font.setStrikeOut( true );
00233 return font;
00234 }
00235
00236 static inline QFont adapt( QFont font, bool it, bool b, bool strike ) {
00237 if ( it )
00238 font.setItalic( true );
00239 if ( b )
00240 font.setBold( true );
00241 if ( strike )
00242 font.setStrikeOut( true );
00243 return font;
00244 }
00245
00246 QFont Kleo::KConfigBasedKeyFilter::font( const QFont & f ) const {
00247 if ( mUseFullFont )
00248 return resizedFont( mFont, f.pointSize(), mStrikeOut );
00249 else
00250 return adapt( f, mItalic, mBold, mStrikeOut );
00251 }