kmail

messagecomposer.h

00001 /*
00002  *  messagecomposer.cpp
00003  *
00004  *  Copyright (c) 2004 Bo Thorsen <bo@sonofthor.dk>
00005  *
00006  *  This program is free software; you can redistribute it and/or modify
00007  *  it under the terms of the GNU General Public License as published by
00008  *  the Free Software Foundation; version 2 of the License
00009  *
00010  *  This program is distributed in the hope that it will be useful,
00011  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
00012  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00013  *  GNU General Public License for more details.
00014  *
00015  *  You should have received a copy of the GNU General Public License
00016  *  along with this program; if not, write to the Free Software
00017  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
00018  *
00019  *  In addition, as a special exception, the copyright holders give
00020  *  permission to link the code of this program with any edition of
00021  *  the Qt library by Trolltech AS, Norway (or with modified versions
00022  *  of Qt that use the same license as Qt), and distribute linked
00023  *  combinations including the two.  You must obey the GNU General
00024  *  Public License in all respects for all of the code used other than
00025  *  Qt.  If you modify this file, you may extend this exception to
00026  *  your version of the file, but you are not obligated to do so.  If
00027  *  you do not wish to do so, delete this exception statement from
00028  *  your version.
00029  */
00030 
00031 #ifndef MESSAGECOMPOSER_H
00032 #define MESSAGECOMPOSER_H
00033 
00034 #include "kmmsgpart.h"
00035 #include "keyresolver.h"
00036 
00037 #include <qobject.h>
00038 #include <qvaluevector.h>
00039 
00040 #include <mimelib/mediatyp.h>
00041 #include <kleo/cryptobackend.h>
00042 #include <kpgp.h>
00043 
00044 #include <vector>
00045 
00046 class KMMessage;
00047 class KMComposeWin;
00048 class CryptPlugWrapper;
00049 
00050 class MessageComposerJob;
00051 class EncryptMessageJob;
00052 class SetLastMessageAsUnencryptedVersionOfLastButOne;
00053 
00054 namespace Kleo {
00055   class KeyResolver;
00056 }
00057 
00058 namespace GpgME {
00059   class Key;
00060 }
00061 
00062 namespace KPIM {
00063   class Identity;
00064 }
00065 
00066 class MessageComposer : public QObject {
00067   Q_OBJECT
00068   friend class ::MessageComposerJob;
00069   friend class ::EncryptMessageJob;
00070   friend class ::SetLastMessageAsUnencryptedVersionOfLastButOne;
00071 
00072 public:
00073   class KeyResolver;
00074 
00075   MessageComposer( KMComposeWin* win, const char* name=0 );
00076   ~MessageComposer();
00077 
00085   void applyChanges( bool disableCrypto );
00086 
00087   QString originalBCC() const { return mBcc; }
00088 
00089   void setDisableBreaking( bool b ) { mDisableBreaking = b; }
00090 
00091   const QValueVector<KMMessage*> & composedMessageList() const {
00092     return mMessageList;
00093   }
00094 
00095   bool isPerformingSignOperation() const { return mPerformingSignOperation; }
00096 signals:
00097   void done( bool );
00098 
00099 private:
00100   void readFromComposeWin();
00101 
00102   void adjustCryptFlags();
00103 
00104   bool encryptWithChiasmus( const Kleo::CryptoBackend::Protocol * chiasmus,
00105                             const QByteArray& body,
00106                             QByteArray& resultData );
00107   void chiasmusEncryptAllAttachments();
00108   void composeChiasmusMessage( KMMessage& theMessage, Kleo::CryptoMessageFormat format );
00109 
00110   // This is the composeMessage method
00111   void composeMessage();
00112   // And these two are the parts that should be run after job completions
00113   void createUnencryptedMessageVersion();
00114 
00122   void composeMessage( KMMessage& theMessage,
00123                        bool doSign, bool doEncrypt,
00124                Kleo::CryptoMessageFormat format );
00125   void continueComposeMessage( KMMessage& theMessage, bool doSign,
00126                                bool doEncrypt,
00127                    Kleo::CryptoMessageFormat format );
00128 
00132   void composeInlineOpenPGPMessage( KMMessage& theMessage,
00133                                     bool doSign, bool doEncrypt );
00134 
00139   QByteArray breakLinesAndApplyCodec();
00140 
00145   QCString plainTextFromMarkup( const QString& markupText );
00146 
00151   void pgpSignedMsg( const QByteArray& cText, Kleo::CryptoMessageFormat f );
00156   Kpgp::Result pgpEncryptedMsg( QByteArray& rEncryptedBody,
00157                                 const QByteArray& cText,
00158                                 const std::vector<GpgME::Key> & encryptionKeys,
00159                 Kleo::CryptoMessageFormat f );
00160 
00165   Kpgp::Result pgpSignedAndEncryptedMsg( QByteArray& rEncryptedBody,
00166                      const QByteArray& cText,
00167                      const std::vector<GpgME::Key> & signingKeys,
00168                      const std::vector<GpgME::Key> & encryptionKeys,
00169                      Kleo::CryptoMessageFormat f );
00170 
00174   bool checkForEncryptCertificateExpiry( const QString& recipient,
00175                                          const QCString& certFingerprint );
00176 
00188   bool processStructuringInfo( const QString bugURL,
00189                                const QString contentDescriptionClear,
00190                                const QCString contentTypeClear,
00191                                const QCString contentSubtypeClear,
00192                                const QCString contentDispClear,
00193                                const QCString contentTEncClear,
00194                                const QByteArray& bodytext,
00195                                const QString contentDescriptionCiph,
00196                                const QByteArray& ciphertext,
00197                                KMMessagePart& resultingPart,
00198                    bool signing, Kleo::CryptoMessageFormat format );
00199 
00200   void encryptMessage( KMMessage* msg, const Kleo::KeyResolver::SplitInfo & si,
00201                        bool doSign, bool doEncrypt,
00202                        KMMessagePart newBodyPart,
00203                Kleo::CryptoMessageFormat format );
00204 
00205   void addBodyAndAttachments( KMMessage* msg, const Kleo::KeyResolver::SplitInfo & si,
00206                               bool doSign, bool doEncrypt,
00207                               const KMMessagePart& ourFineBodyPart,
00208                               Kleo::CryptoMessageFormat format );
00209 
00210 private slots:
00211   void slotDoNextJob();
00212 
00213 private:
00214   void doNextJob();
00215   void emitDone( bool ok );
00216 
00217   int encryptionPossible( const QStringList & recipients, bool openPGP );
00218   bool determineWhetherToSign( bool doSignCompletely );
00219   bool determineWhetherToEncrypt( bool doEncryptCompletely );
00220   void markAllAttachmentsForSigning( bool sign );
00221   void markAllAttachmentsForEncryption( bool enc );
00222 
00223   KMComposeWin* mComposeWin;
00224   MessageComposerJob * mCurrentJob;
00225   KMMessage* mReferenceMessage;
00226   QValueVector<KMMessage*> mMessageList;
00227 
00228   Kleo::KeyResolver * mKeyResolver;
00229 
00230   QCString mSignCertFingerprint;
00231 
00232   struct Attachment {
00233     Attachment( KMMessagePart * p=0, bool s=false, bool e=false )
00234       : part( p ), sign( s ), encrypt( e ) {}
00235     KMMessagePart * part;
00236     bool sign;
00237     bool encrypt;
00238   };
00239   QValueVector<Attachment> mAttachments;
00240 
00241   QString mPGPSigningKey, mSMIMESigningKey;
00242   bool mUseOpportunisticEncryption;
00243   bool mSignBody, mEncryptBody;
00244   bool mSigningRequested, mEncryptionRequested;
00245   bool mDoSign, mDoEncrypt;
00246   unsigned int mAllowedCryptoMessageFormats;
00247   bool mDisableCrypto;
00248   bool mDisableBreaking;
00249   QString mBcc;
00250   QStringList mTo, mCc, mBccList;
00251   bool mDebugComposerCrypto;
00252   bool mAutoCharset;
00253   QCString mCharset;
00254   bool mIsRichText;
00255   uint mIdentityUid;
00256   bool mRc; // Set this to false, if something fails during the processes
00257   bool mHoldJobs; // Don't run the next job yet
00258 
00259   QByteArray mText; // textual representation of the message text, encoded
00260   unsigned int mLineBreakColumn; // used for line breaking
00261 
00262   // These are the variables of the big composeMessage(X,Y,Z) message
00263   KMMessagePart* mNewBodyPart;
00264   QByteArray mSignature;
00265 
00266   QByteArray mEncodedBody; // Only needed if signing and/or encrypting
00267   bool mEarlyAddAttachments, mAllAttachmentsAreInBody;
00268   KMMessagePart mOldBodyPart;
00269   int mPreviousBoundaryLevel;
00270 
00271   // The boundary is saved for later addition into mp/a body
00272   DwString  mSaveBoundary;
00273   QCString mMultipartMixedBoundary;
00274 
00275   QValueList<MessageComposerJob*> mJobs;
00276   bool mEncryptWithChiasmus;
00277   bool mPerformingSignOperation;
00278 };
00279 
00280 #endif /* MESSAGECOMPOSER_H */
KDE Home | KDE Accessibility Home | Description of Access Keys