libkpgp/kpgpkey.h

   1 /*
   2     kpgpkey.h
   3
   4     Copyright (C) 2001,2002 the KPGP authors
   5     See file AUTHORS.kpgp for details
   6
   7     This file is part of KPGP, the KDE PGP/GnuPG support library.
   8
   9     KPGP is free software; you can redistribute it and/or modify
  10     it under the terms of the GNU General Public License as published by
  11     the Free Software Foundation; either version 2 of the License, or
  12     (at your option) any later version.
  13
  14     You should have received a copy of the GNU General Public License
  15     along with this program; if not, write to the Free Software Foundation,
  16     Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #ifndef KPGPKEY_H
  20 #define KPGPKEY_H
  21
  22 #include <QtCore/QString>
  23 #include <QtCore/QStringList>
  24
  25 #include <time.h>
  26
  27 namespace Kpgp {
  28
  29 /** These are the possible validity values for a PGP user id and for the owner
  30     trust.
  31  */
  32 typedef enum
  33 { // this is copied from gpgme.h which is a part of GPGME
  34   KPGP_VALIDITY_UNKNOWN = 0,   // the trust hasn't been determined
  35   KPGP_VALIDITY_UNDEFINED = 1, // trust is undefined
  36   KPGP_VALIDITY_NEVER = 2,
  37   KPGP_VALIDITY_MARGINAL = 3,
  38   KPGP_VALIDITY_FULL = 4,
  39   KPGP_VALIDITY_ULTIMATE = 5
  40 } Validity;
  41
  42 /** These are the possible preferences for encryption.
  43  */
  44 typedef enum
  45 {
  46   NeverEncrypt = -1,
  47   UnknownEncryptPref = 0,
  48   AlwaysEncrypt = 1,
  49   AlwaysEncryptIfPossible = 2,
  50   AlwaysAskForEncryption = 3,
  51   AskWheneverPossible = 4
  52 } EncryptPref;
  53
  54
  55 typedef QByteArray KeyID;
  56
  57 class KeyIDList : public QList<KeyID>
  58 {
  59  public:
  60   KeyIDList() { }
  61   KeyIDList( const KeyIDList& l ) : QList<KeyID>(l) { }
  62   KeyIDList( const QList<KeyID>& l ) : QList<KeyID>(l) { }
  63   KeyIDList( const KeyID& i ) { append(i); }
  64
  65   QStringList toStringList() const;
  66
  67   static KeyIDList fromStringList( const QStringList& );
  68 };
  69
  70 /** This class is used to store information about a user id of a PGP key.
  71  */
  72 class UserID
  73 {
  74  public:
  75   /** Constructs a new user id with the given values.
  76    *  @param str User Id (descriptive text)
  77    *  @param validity Validity of key, relevant mostly if @p invalid is @c false
  78    *  @param revoked Is the key revoked?
  79    *  @param invalid Is the key invalid?
  80    *
  81    *  @todo How exactly do invalid and validity affect each other?
  82    */
  83   explicit UserID(const QString& str,
  84                   const Validity validity = KPGP_VALIDITY_UNKNOWN,
  85                   const bool revoked = false,
  86                   const bool invalid = false);
  87   ~UserID() {}
  88
  89   /** Returns the text of the user id. */
  90   QString text() const;
  91
  92   /** Returns true if the user id has been revoked. */
  93   bool revoked() const;
  94
  95   /** Returns true if the user id is invalid. */
  96   bool invalid() const;
  97
  98   /** Returns the validity of resp. the trust in the user id. */
  99   Validity validity() const;
 100
 101   /** Sets the text of the user id to @p str.
 102    *  @param str The new user id text.
 103    */
 104   void setText(const QString& str);
 105
 106   /** Sets the flag if the user id has been revoked to @p revoked.
 107    *  @param revoked Whether the user id has been revoked or not.
 108    *  @todo Does one revoke a user id or a key? See also comments
 109    *        for setInvalid() and setText().
 110    */
 111   void setRevoked(const bool revoked);
 112
 113   /** Sets the flag if the user id is invalid to @p invalid.
 114    *  @param invalid Whether the user id is invalid or not.
 115    *  @todo Is it the <em>user id</em> that is invalid or the
 116    *        key itself? This should then also be documented in
 117    *        setText().
 118    */
 119   void setInvalid(const bool invalid);
 120
 121   /** Sets the validity of resp. the trust in the user id to @p validity .
 122    *  @param validity New validity value.
 123    *  @todo Are there any restrictions on how you can change validities?
 124    */
 125   void setValidity(const Validity validity);
 126
 127  protected:
 128   /** Revoked flag. @see setRevoked() @see revoked() */
 129   bool mRevoked : 1;
 130   /** Invalid flag. @see setInvalid() @see invalid() */
 131   bool mInvalid : 1;
 132   /** Validity (assuming invalid flag is @c false). @see setValidity() @see validity() */
 133   Validity mValidity;
 134   /** User id (descriptive text). @see setText() @see text() */
 135   QString mText;
 136 };
 137
 138 typedef QList<UserID*> UserIDList;
 139
 140 inline QString UserID::text() const
 141 {
 142   return mText;
 143 }
 144
 145 inline bool UserID::revoked() const
 146 {
 147   return mRevoked;
 148 }
 149
 150 inline bool UserID::invalid() const
 151 {
 152   return mInvalid;
 153 }
 154
 155 inline Validity UserID::validity() const
 156 {
 157   return mValidity;
 158 }
 159
 160 inline void UserID::setText(const QString& str)
 161 {
 162   mText = str;
 163 }
 164
 165 inline void UserID::setRevoked(const bool revoked)
 166 {
 167   mRevoked = revoked;
 168 }
 169
 170 inline void UserID::setInvalid(const bool invalid)
 171 {
 172   mInvalid = invalid;
 173 }
 174
 175 inline void UserID::setValidity(const Validity validity)
 176 {
 177   mValidity = validity;
 178 }
 179
 180
 181 /** This class is used to store information about a subkey of a PGP key.
 182  */
 183 class Subkey
 184 {
 185  public:
 186   /** Constructs a new subkey with the given key ID. */
 187   explicit Subkey(const KeyID& keyID, const bool secret = false);
 188   ~Subkey() {}
 189
 190   /** Returns true if the subkey is a secret subkey. */
 191   bool secret() const;
 192
 193   /** Returns true if the subkey has been revoked. */
 194   bool revoked() const;
 195
 196   /** Returns true if the subkey has expired. */
 197   bool expired() const;
 198
 199   /** Returns true if the subkey has been disabled. */
 200   bool disabled() const;
 201
 202   /** Returns true if the subkey is invalid. */
 203   bool invalid() const;
 204
 205   /** Returns true if the subkey can be used to encrypt data. */
 206   bool canEncrypt() const;
 207
 208   /** Returns true if the subkey can be used to sign data. */
 209   bool canSign() const;
 210
 211   /** Returns true if the subkey can be used to certify keys. */
 212   bool canCertify() const;
 213
 214   /** Returns the key algorithm of the subkey. */
 215   unsigned int keyAlgorithm() const;
 216
 217   /** Returns the length of the subkey in bits. */
 218   unsigned int keyLength() const;
 219
 220   /** Returns the long 64 bit key ID of the subkey if it's available.
 221       Otherwise the short 32 bit key ID is returned. */
 222   KeyID longKeyID() const;
 223
 224   /** Returns the (short) 32 bit key ID of the subkey. */
 225   KeyID keyID() const;
 226
 227   /** Returns the fingerprint of the subkey. */
 228   QByteArray fingerprint() const;
 229
 230   /** Returns the creation date of the subkey. */
 231   time_t creationDate() const;
 232
 233   /** Returns the expiration date of the subkey. */
 234   time_t expirationDate() const;
 235
 236   /** Sets the flag if the subkey is a secret subkey to @p secret .
 237    *  @param secret Whether this subkey is secret or not.
 238    *  @see secret()
 239    */
 240   void setSecret(const bool secret);
 241
 242   /** Sets the flag if the subkey has been revoked to @p revoked .
 243    *  @param revoked Whether this subkey is revoked or not.
 244    *  @see revoked()
 245    */
 246   void setRevoked(const bool revoked);
 247
 248   /** Sets the flag if the subkey has expired to @p expired .
 249    *  @param expired Whether this subkey has expired or not.
 250    *  @see expired()
 251    */
 252   void setExpired(const bool expired);
 253
 254   /** Sets the flag if the subkey has been disabled to @p disabled .
 255    *  @param disabled Whether this subkey is disabled or not.
 256    *  @see disabled()
 257    */
 258   void setDisabled(const bool disabled);
 259
 260   /** Sets the flag if the subkey is invalid to @p invalid .
 261    *  @param invalid Whether this subkey is invalid or not.
 262    *  @see invalid()
 263    */
 264   void setInvalid(const bool invalid);
 265
 266   /** Sets the flag if the subkey can be used to encrypt data to @p canEncrypt .
 267       @param canEncrypt Whether this subkey can encrypt or not.
 268       @see canEncrypt()
 269   */
 270   void setCanEncrypt(const bool canEncrypt);
 271
 272   /** Sets the flag if the subkey can be used to sign data to @p canSign .
 273       @param canSign Whether this subkey can sign or not.
 274       @see canSign()
 275   */
 276   void setCanSign(const bool canSign);
 277
 278   /** Sets the flag if the subkey can be used to certify keys to @p canCertify .
 279       @param canCertify Whether this subkey can certify or not.
 280       @see canCertify()
 281   */
 282   void setCanCertify(const bool canCertify);
 283
 284   /** Sets the key algorithm of the subkey to @p keyAlgo .
 285       @param keyAlgo The key algorithm to use.
 286       @see keyAlgorithm
 287       @todo What are legal values? What do they mean?
 288             Where are they documented?
 289   */
 290   void setKeyAlgorithm(const unsigned int keyAlgo);
 291
 292   /** Sets the key length of the subkey to @p keyLen  bits.
 293       @param keyLength Length of the subkey.
 294       @see keyLength()
 295       @todo What are the valid lengths? Is 0 ok?
 296   */
 297   void setKeyLength(const unsigned int keyLen);
 298
 299   /** Sets the key ID of the subkey to @p keyID .
 300       @param keyID the key ID for this subkey (just a string)
 301       @see keyID()
 302       @todo What are legal key IDs? How about NULL IDs?
 303   */
 304   void setKeyID(const KeyID& keyID);
 305
 306   /** Sets the fingerprint of the subkey to @p fingerprint .
 307       @param fingerprint to use for this subkey
 308       @see fingerprint()
 309       @todo What are legal fingerprints?
 310   */
 311   void setFingerprint(const QByteArray& fingerprint);
 312
 313   /** Sets the creation date of the subkey to @p creationDate  seconds
 314       since Epoch.
 315       @param creationDate Creation time of this subkey, in seconds
 316              since the epoch (still midnight, january 1, 1970 in most
 317              places).
 318   */
 319   void setCreationDate(const time_t creationDate);
 320
 321   /** Sets the expiration date of the subkey to @p expirationDate  seconds
 322       since Epoch.
 323       @param expirationDate Expiry time of this subkey, in seconds
 324              since the epoch (still midnight, january 1, 1970 in most
 325              places).
 326       @todo Does this expiry influence any of the other flags?
 327   */
 328   void setExpirationDate(const time_t expirationDate);
 329
 330  protected:
 331   /** Is this subkey secret? @see secret() @see setSecret() */
 332   bool mSecret : 1;
 333   /** Is this subkey revoked? @see revoked() @see setRevoked() */
 334   bool mRevoked : 1;
 335   /** Is this subkey expired? @see expired() @see setExpired() */
 336   bool mExpired : 1;
 337   /** Is this subkey disabled? @see disabled() @see setDisabled() */
 338   bool mDisabled : 1;
 339   /** Is this subkey invalid? @see invalid() @see setInvalid() */
 340   bool mInvalid : 1;
 341   /** Can this subkey encrypt? @see canEncrypt() @see setCanEncrypt() */
 342   bool mCanEncrypt : 1;
 343   /** Can this subkey sign? @see canSign() @see setCanSign() */
 344   bool mCanSign : 1;
 345   /** Can this subkey certify? @see canCertify() @see setCanCertify() */
 346   bool mCanCertify : 1;
 347
 348   unsigned int mKeyAlgo;
 349   unsigned int mKeyLen;
 350   KeyID mKeyID;
 351   QByteArray mFingerprint;
 352   time_t mTimestamp; /**< -1 for invalid, 0 for not available */
 353   time_t mExpiration; /**< -1 for never, 0 for not available */
 354 };
 355
 356 inline bool Subkey::secret() const
 357 {
 358   return mSecret;
 359 }
 360
 361 inline bool Subkey::revoked() const
 362 {
 363   return mRevoked;
 364 }
 365
 366 inline bool Subkey::expired() const
 367 {
 368   return mExpired;
 369 }
 370
 371 inline bool Subkey::disabled() const
 372 {
 373   return mDisabled;
 374 }
 375
 376 inline bool Subkey::invalid() const
 377 {
 378   return mInvalid;
 379 }
 380
 381 inline bool Subkey::canEncrypt() const
 382 {
 383   return mCanEncrypt;
 384 }
 385
 386 inline bool Subkey::canSign() const
 387 {
 388   return mCanSign;
 389 }
 390
 391 inline bool Subkey::canCertify() const
 392 {
 393   return mCanCertify;
 394 }
 395
 396 inline unsigned int Subkey::keyAlgorithm() const
 397 {
 398   return mKeyAlgo;
 399 }
 400
 401 inline unsigned int Subkey::keyLength() const
 402 {
 403   return mKeyLen;
 404 }
 405
 406 inline KeyID Subkey::longKeyID() const
 407 {
 408   return mKeyID;
 409 }
 410
 411 inline KeyID Subkey::keyID() const
 412 {
 413   return mKeyID.right(8);
 414 }
 415
 416 inline QByteArray Subkey::fingerprint() const
 417 {
 418   return mFingerprint;
 419 }
 420
 421 inline time_t Subkey::creationDate() const
 422 {
 423   return mTimestamp;
 424 }
 425
 426 inline time_t Subkey::expirationDate() const
 427 {
 428   return mExpiration;
 429 }
 430
 431 inline void Subkey::setSecret(const bool secret)
 432 {
 433   mSecret = secret;
 434 }
 435
 436 inline void Subkey::setRevoked(const bool revoked)
 437 {
 438   mRevoked = revoked;
 439 }
 440
 441 inline void Subkey::setExpired(const bool expired)
 442 {
 443   mExpired = expired;
 444 }
 445
 446 inline void Subkey::setDisabled(const bool disabled)
 447 {
 448   mDisabled = disabled;
 449 }
 450
 451 inline void Subkey::setInvalid(const bool invalid)
 452 {
 453   mInvalid = invalid;
 454 }
 455
 456 inline void Subkey::setCanEncrypt(const bool canEncrypt)
 457 {
 458   mCanEncrypt = canEncrypt;
 459 }
 460
 461 inline void Subkey::setCanSign(const bool canSign)
 462 {
 463   mCanSign = canSign;
 464 }
 465
 466 inline void Subkey::setCanCertify(const bool canCertify)
 467 {
 468   mCanCertify = canCertify;
 469 }
 470
 471 inline void Subkey::setKeyAlgorithm(const unsigned int keyAlgo)
 472 {
 473   mKeyAlgo = keyAlgo;
 474 }
 475
 476 inline void Subkey::setKeyLength(const unsigned int keyLen)
 477 {
 478   mKeyLen = keyLen;
 479 }
 480
 481 inline void Subkey::setKeyID(const KeyID& keyID)
 482 {
 483   mKeyID = keyID;
 484 }
 485
 486 inline void Subkey::setFingerprint(const QByteArray& fingerprint)
 487 {
 488   mFingerprint = fingerprint;
 489 }
 490
 491 inline void Subkey::setCreationDate(const time_t creationDate)
 492 {
 493   mTimestamp = creationDate;
 494 }
 495
 496 inline void Subkey::setExpirationDate(const time_t expirationDate)
 497 {
 498   mExpiration = expirationDate;
 499 }
 500
 501 typedef QList<Subkey*> SubkeyList;
 502
 503
 504 /** This class is used to store information about a PGP key.
 505  */
 506 class Key
 507 {
 508  public:
 509   /** Constructs a new PGP key with @p keyid  as key ID of the
 510       primary key and @p uid  as primary user ID.
 511       @param keyid Key ID for this Key
 512       @param uid   UID for this key (user ID)
 513       @param secret Is this key secret?
 514   */
 515   explicit Key( const KeyID& keyid = KeyID(),
 516                 const QString& uid = QString(),
 517                 const bool secret = false);
 518   ~Key();
 519
 520   /** Clears/resets all key data. */
 521   void clear();
 522
 523   /** Returns true if the key is a secret key. */
 524   bool secret() const;
 525
 526   /** Returns true if the key has been revoked. */
 527   bool revoked() const;
 528
 529   /** Returns true if the key has expired. */
 530   bool expired() const;
 531
 532   /** Returns true if the key has been disabled. */
 533   bool disabled() const;
 534
 535   /** Returns true if the key is invalid. */
 536   bool invalid() const;
 537
 538   /** Returns true if the key can be used to encrypt data. */
 539   bool canEncrypt() const;
 540
 541   /** Returns true if the key can be used to sign data. */
 542   bool canSign() const;
 543
 544   /** Returns true if the key can be used to certify keys. */
 545   bool canCertify() const;
 546
 547   /** Sets the flag if the key is a secret key to @p secret .
 548       @param secret Whether this key is secret or not
 549       @see secret()
 550   */
 551   void setSecret(const bool secret);
 552
 553   /** Sets the flag if the key has been revoked to @p revoked .
 554       @param revoked Whether the key is revoked or not
 555       @see revoked()
 556   */
 557   void setRevoked(const bool revoked);
 558
 559   /** Sets the flag if the key has expired to <em>expired . */
 560   void setExpired(const bool expired);
 561
 562   /** Sets the flag if the key has been disabled to <em>disabled . */
 563   void setDisabled(const bool disabled);
 564
 565   /** Sets the flag if the key is invalid to <em>invalid . */
 566   void setInvalid(const bool invalid);
 567
 568   /** Sets the flag if the key can be used to encrypt data to
 569       <em>canEncrypt . */
 570   void setCanEncrypt(const bool canEncrypt);
 571
 572   /** Sets the flag if the key can be used to sign data to
 573       <em>canSign . */
 574   void setCanSign(const bool canSign);
 575
 576   /** Sets the flag if the key can be used to certify keys to
 577       <em>canCertify . */
 578   void setCanCertify(const bool canCertify);
 579
 580
 581   /** Returns the encryption preference for this key. */
 582   EncryptPref encryptionPreference();
 583
 584   /** Sets the encryption preference for this key to <em>encrPref . */
 585   void setEncryptionPreference( const EncryptPref encrPref );
 586
 587
 588   /** Returns the primary user ID or a null string if there are no
 589       user IDs. */
 590   QString primaryUserID() const;
 591
 592   /** Returns the key ID of the primary key or a null string if there
 593       are no subkeys. */
 594   KeyID primaryKeyID() const;
 595
 596   /** Returns the fingerprint of the primary key or a null string if there
 597       are no subkeys. */
 598   QByteArray primaryFingerprint() const;
 599
 600   /** Returns true if there are no user IDs or no subkeys.*/
 601   bool isNull() const;
 602
 603   /** Returns the creation date of the primary subkey.
 604    */
 605   time_t creationDate() const;
 606
 607   /** Returns the trust value of this key. This is the maximal trust value
 608       of any of the user ids of this key.
 609    */
 610   Validity keyTrust() const;
 611
 612   /** Returns the trust value for the given user id of this key.
 613    */
 614   Validity keyTrust( const QString& uid ) const;
 615
 616   /** Set the validity values for the user ids to the validity values of
 617       the given key. This is useful after rereading a key without expensive
 618       trust checking.
 619    */
 620   void cloneKeyTrust( const Key* key );
 621
 622   /** Returns true if the key is valid, i.e. not revoked, expired, disabled
 623       or invalid.
 624    */
 625   bool isValid() const;
 626
 627   /** Returns true if the key is a valid encryption key. The trust is not
 628       checked.
 629    */
 630   bool isValidEncryptionKey() const;
 631
 632   /** Returns true if the key is a valid signing key. The trust is not checked.
 633    */
 634   bool isValidSigningKey() const;
 635
 636   /** Returns the list of userIDs. */
 637   const UserIDList userIDs() const;
 638
 639   /** Returns the list of subkeys. */
 640   const SubkeyList subkeys() const;
 641
 642   /** Adds a user ID with the given values to the key if <em>uid  isn't
 643       an empty string. */
 644   void addUserID(const QString& uid,
 645                  const Validity validity = KPGP_VALIDITY_UNKNOWN,
 646                  const bool revoked = false,
 647                  const bool invalid = false);
 648
 649   /** Adds the given user ID to the key. */
 650   void addUserID(const UserID *userID);
 651
 652   /** Returns true if the given string matches one of the user IDs.
 653       The match is case sensitive if <em>cs  is true or case insensitive
 654       if <em>cs  is false. */
 655   bool matchesUserID(const QString& str, bool cs = true);
 656
 657   /** Adds a subkey with the given values to the key if <em>keyID  isn't
 658       an empty string. */
 659   void addSubkey(const KeyID& keyID, const bool secret = false);
 660
 661   /** Adds the given subkey to the key. */
 662   void addSubkey(const Subkey *subkey);
 663
 664   /** Returns a pointer to the subkey with the given key ID. */
 665   Subkey *getSubkey(const KeyID& keyID);
 666
 667   /** Sets the fingerprint of the given subkey to <em>fpr . */
 668   void setFingerprint(const KeyID& keyID, const QByteArray& fpr);
 669
 670  protected:
 671   bool mSecret : 1;
 672   /* global flags */
 673   bool mRevoked : 1;
 674   bool mExpired : 1;
 675   bool mDisabled : 1;
 676   bool mInvalid : 1;
 677   bool mCanEncrypt : 1;
 678   bool mCanSign : 1;
 679   bool mCanCertify : 1;
 680
 681   EncryptPref mEncryptPref;
 682
 683   SubkeyList mSubkeys;
 684   UserIDList mUserIDs;
 685 };
 686
 687 inline bool Key::secret() const
 688 {
 689   return mSecret;
 690 }
 691
 692 inline bool Key::revoked() const
 693 {
 694   return mRevoked;
 695 }
 696
 697 inline bool Key::expired() const
 698 {
 699   return mExpired;
 700 }
 701
 702 inline bool Key::disabled() const
 703 {
 704   return mDisabled;
 705 }
 706
 707 inline bool Key::invalid() const
 708 {
 709   return mInvalid;
 710 }
 711
 712 inline bool Key::canEncrypt() const
 713 {
 714   return mCanEncrypt;
 715 }
 716
 717 inline bool Key::canSign() const
 718 {
 719   return mCanSign;
 720 }
 721
 722 inline bool Key::canCertify() const
 723 {
 724   return mCanCertify;
 725 }
 726
 727 inline void Key::setSecret(const bool secret)
 728 {
 729   mSecret = secret;
 730 }
 731
 732 inline void Key::setRevoked(const bool revoked)
 733 {
 734   mRevoked = revoked;
 735 }
 736
 737 inline void Key::setExpired(const bool expired)
 738 {
 739   mExpired = expired;
 740 }
 741
 742 inline void Key::setDisabled(const bool disabled)
 743 {
 744   mDisabled = disabled;
 745 }
 746
 747 inline void Key::setInvalid(const bool invalid)
 748 {
 749   mInvalid = invalid;
 750 }
 751
 752 inline void Key::setCanEncrypt(const bool canEncrypt)
 753 {
 754   mCanEncrypt = canEncrypt;
 755 }
 756
 757 inline void Key::setCanSign(const bool canSign)
 758 {
 759   mCanSign = canSign;
 760 }
 761
 762 inline void Key::setCanCertify(const bool canCertify)
 763 {
 764   mCanCertify = canCertify;
 765 }
 766
 767 inline EncryptPref Key::encryptionPreference()
 768 {
 769   return mEncryptPref;
 770 }
 771
 772 inline void Key::setEncryptionPreference( const EncryptPref encrPref )
 773 {
 774   mEncryptPref = encrPref;
 775 }
 776
 777 inline QString Key::primaryUserID() const
 778 {
 779   UserID *uid = mUserIDs.isEmpty() ? 0 : mUserIDs.first();
 780
 781   if (uid)
 782     return uid->text();
 783   else
 784     return QString();
 785 }
 786
 787 inline KeyID Key::primaryKeyID() const
 788 {
 789   Subkey *key = mSubkeys.isEmpty() ? 0 : mSubkeys.first();
 790
 791   if (key)
 792     return key->keyID();
 793   else
 794     return KeyID();
 795 }
 796
 797 inline QByteArray Key::primaryFingerprint() const
 798 {
 799   Subkey *key = mSubkeys.isEmpty() ? 0 : mSubkeys.first();
 800
 801   if (key)
 802     return key->fingerprint();
 803   else
 804     return QByteArray();
 805 }
 806
 807 inline const UserIDList Key::userIDs() const
 808 {
 809   return mUserIDs;
 810 }
 811
 812 inline const SubkeyList Key::subkeys() const
 813 {
 814   return mSubkeys;
 815 }
 816
 817 inline bool Key::isNull() const
 818 {
 819   return (mUserIDs.isEmpty() || mSubkeys.isEmpty());
 820 }
 821
 822 inline time_t Key::creationDate() const
 823 {
 824   if( !mSubkeys.isEmpty() )
 825     return mSubkeys.first()->creationDate();
 826   else
 827     return -1;
 828 }
 829
 830 inline void Key::addUserID(const UserID *userID)
 831 {
 832   if (userID)
 833     mUserIDs.append(const_cast<UserID*>(userID));
 834 }
 835
 836 inline void Key::addSubkey(const Subkey *subkey)
 837 {
 838   if (subkey)
 839     mSubkeys.append(const_cast<Subkey*>(subkey));
 840 }
 841
 842
 843 typedef QList<Key*> KeyList;
 844
 845 inline bool KeyCompare( Key* left, Key* right )
 846 {
 847   const int result = QString::compare( left->primaryUserID().toLower(), right->primaryUserID().toLower() );
 848   return result == -1;
 849 }
 850
 851 } // namespace Kpgp
 852
 853 #endif