summaryrefslogtreecommitdiffstats
path: root/kmail/messagecomposer.h
diff options
context:
space:
mode:
Diffstat (limited to 'kmail/messagecomposer.h')
-rw-r--r--kmail/messagecomposer.h279
1 files changed, 279 insertions, 0 deletions
diff --git a/kmail/messagecomposer.h b/kmail/messagecomposer.h
new file mode 100644
index 000000000..7d908bfac
--- /dev/null
+++ b/kmail/messagecomposer.h
@@ -0,0 +1,279 @@
+/*
+ * messagecomposer.cpp
+ *
+ * Copyright (c) 2004 Bo Thorsen <bo@sonofthor.dk>
+ *
+ * This program 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; version 2 of the License
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * 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.
+ *
+ * In addition, as a special exception, the copyright holders give
+ * permission to link the code of this program with any edition of
+ * the Qt library by Trolltech AS, Norway (or with modified versions
+ * of Qt that use the same license as Qt), and distribute linked
+ * combinations including the two. You must obey the GNU General
+ * Public License in all respects for all of the code used other than
+ * Qt. If you modify this file, you may extend this exception to
+ * your version of the file, but you are not obligated to do so. If
+ * you do not wish to do so, delete this exception statement from
+ * your version.
+ */
+
+#ifndef MESSAGECOMPOSER_H
+#define MESSAGECOMPOSER_H
+
+#include "kmmsgpart.h"
+#include "keyresolver.h"
+
+#include <qobject.h>
+#include <qvaluevector.h>
+
+#include <mimelib/mediatyp.h>
+#include <kleo/cryptobackend.h>
+#include <kpgp.h>
+
+#include <vector>
+
+class KMMessage;
+class KMComposeWin;
+
+class MessageComposerJob;
+class EncryptMessageJob;
+class SetLastMessageAsUnencryptedVersionOfLastButOne;
+
+namespace Kleo {
+ class KeyResolver;
+}
+
+namespace GpgME {
+ class Key;
+}
+
+namespace KPIM {
+ class Identity;
+}
+
+class MessageComposer : public QObject {
+ Q_OBJECT
+ friend class ::MessageComposerJob;
+ friend class ::EncryptMessageJob;
+ friend class ::SetLastMessageAsUnencryptedVersionOfLastButOne;
+
+public:
+ class KeyResolver;
+
+ MessageComposer( KMComposeWin* win, const char* name=0 );
+ ~MessageComposer();
+
+ /**
+ * Applies the user changes to the message object of the composer
+ * and signs/encrypts the message if activated. Returns FALSE in
+ * case of an error (e.g. if PGP encryption fails).
+ * If backgroundMode is true then no functions which might require
+ * user interaction (like signing/encrypting) are performed
+ */
+ void applyChanges( bool disableCrypto );
+
+ QString originalBCC() const { return mBcc; }
+
+ void setDisableBreaking( bool b ) { mDisableBreaking = b; }
+
+ const QValueVector<KMMessage*> & composedMessageList() const {
+ return mMessageList;
+ }
+
+ bool isPerformingSignOperation() const { return mPerformingSignOperation; }
+signals:
+ void done( bool );
+
+private:
+ void readFromComposeWin();
+
+ void adjustCryptFlags();
+
+ bool encryptWithChiasmus( const Kleo::CryptoBackend::Protocol * chiasmus,
+ const QByteArray& body,
+ QByteArray& resultData );
+ void chiasmusEncryptAllAttachments();
+ void composeChiasmusMessage( KMMessage& theMessage, Kleo::CryptoMessageFormat format );
+
+ // This is the composeMessage method
+ void composeMessage();
+ // And these two are the parts that should be run after job completions
+ void createUnencryptedMessageVersion();
+
+ /**
+ * Internal helper function called from applyChanges(void) to allow
+ * processing several messages (encrypted or unencrypted) based on
+ * the same composer content.
+ * That's useful for storing decrypted versions of messages which
+ * were sent in encrypted form. (khz, 2002/06/24)
+ */
+ void composeMessage( KMMessage& theMessage,
+ bool doSign, bool doEncrypt,
+ Kleo::CryptoMessageFormat format );
+ void continueComposeMessage( KMMessage& theMessage, bool doSign,
+ bool doEncrypt,
+ Kleo::CryptoMessageFormat format );
+
+ /**
+ * Called by composeMessage for inline-openpgp messages
+ */
+ void composeInlineOpenPGPMessage( KMMessage& theMessage,
+ bool doSign, bool doEncrypt );
+
+ /**
+ * Get message ready for sending or saving.
+ * This must be done _before_ signing and/or encrypting it.
+ */
+ QByteArray breakLinesAndApplyCodec();
+
+ /**
+ * Create a plain text version of a marked up mail for use as the plain
+ * part in a multipart/alternative mail.
+ */
+ QCString plainTextFromMarkup( const QString& markupText );
+
+ /**
+ * Get signature for a message (into mMessage).
+ * To build nice S/MIME objects signing and encoding must be separated.
+ */
+ void pgpSignedMsg( const QByteArray& cText, Kleo::CryptoMessageFormat f );
+ /**
+ * Get encrypted message.
+ * To build nice S/MIME objects signing and encrypting must be separate.
+ */
+ Kpgp::Result pgpEncryptedMsg( QByteArray& rEncryptedBody,
+ const QByteArray& cText,
+ const std::vector<GpgME::Key> & encryptionKeys,
+ Kleo::CryptoMessageFormat f );
+
+ /**
+ * Get signed & encrypted message.
+ * To build nice S/MIME objects signing and encrypting must be separate.
+ */
+ Kpgp::Result pgpSignedAndEncryptedMsg( QByteArray& rEncryptedBody,
+ const QByteArray& cText,
+ const std::vector<GpgME::Key> & signingKeys,
+ const std::vector<GpgME::Key> & encryptionKeys,
+ Kleo::CryptoMessageFormat f );
+
+ /**
+ * Check for expiry of various certificates.
+ */
+ bool checkForEncryptCertificateExpiry( const QString& recipient,
+ const QCString& certFingerprint );
+
+ /**
+ * Build a MIME object (or a flat text resp.) based upon
+ * structuring information returned by a crypto plugin that was
+ * called via pgpSignedMsg() (or pgpEncryptedMsg(), resp.).
+ *
+ * NOTE: The c string representation of the MIME object (or the
+ * flat text, resp.) is returned in resultingPart, so just
+ * use this string as body text of the surrounding MIME object.
+ * This string *is* encoded according to contentTEncClear
+ * and thus should be ready for being sent via SMTP.
+ */
+ bool processStructuringInfo( const QString bugURL,
+ const QString contentDescriptionClear,
+ const QCString contentTypeClear,
+ const QCString contentSubtypeClear,
+ const QCString contentDispClear,
+ const QCString contentTEncClear,
+ const QByteArray& bodytext,
+ const QString contentDescriptionCiph,
+ const QByteArray& ciphertext,
+ KMMessagePart& resultingPart,
+ bool signing, Kleo::CryptoMessageFormat format );
+
+ void encryptMessage( KMMessage* msg, const Kleo::KeyResolver::SplitInfo & si,
+ bool doSign, bool doEncrypt,
+ KMMessagePart newBodyPart,
+ Kleo::CryptoMessageFormat format );
+
+ void addBodyAndAttachments( KMMessage* msg, const Kleo::KeyResolver::SplitInfo & si,
+ bool doSign, bool doEncrypt,
+ const KMMessagePart& ourFineBodyPart,
+ Kleo::CryptoMessageFormat format );
+
+private slots:
+ void slotDoNextJob();
+
+private:
+ void doNextJob();
+ void emitDone( bool ok );
+
+ int encryptionPossible( const QStringList & recipients, bool openPGP );
+ bool determineWhetherToSign( bool doSignCompletely );
+ bool determineWhetherToEncrypt( bool doEncryptCompletely );
+ void markAllAttachmentsForSigning( bool sign );
+ void markAllAttachmentsForEncryption( bool enc );
+
+ KMComposeWin* mComposeWin;
+ MessageComposerJob * mCurrentJob;
+ KMMessage* mReferenceMessage;
+ QValueVector<KMMessage*> mMessageList;
+
+ Kleo::KeyResolver * mKeyResolver;
+
+ QCString mSignCertFingerprint;
+
+ struct Attachment {
+ Attachment( KMMessagePart * p=0, bool s=false, bool e=false )
+ : part( p ), sign( s ), encrypt( e ) {}
+ KMMessagePart * part;
+ bool sign;
+ bool encrypt;
+ };
+ QValueVector<Attachment> mAttachments;
+
+ QString mPGPSigningKey, mSMIMESigningKey;
+ bool mUseOpportunisticEncryption;
+ bool mSignBody, mEncryptBody;
+ bool mSigningRequested, mEncryptionRequested;
+ bool mDoSign, mDoEncrypt;
+ unsigned int mAllowedCryptoMessageFormats;
+ bool mDisableCrypto;
+ bool mDisableBreaking;
+ QString mBcc;
+ QStringList mTo, mCc, mBccList;
+ bool mDebugComposerCrypto;
+ bool mAutoCharset;
+ QCString mCharset;
+ bool mIsRichText;
+ uint mIdentityUid;
+ bool mRc; // Set this to false, if something fails during the processes
+ bool mHoldJobs; // Don't run the next job yet
+
+ QByteArray mText; // textual representation of the message text, encoded
+ unsigned int mLineBreakColumn; // used for line breaking
+
+ // These are the variables of the big composeMessage(X,Y,Z) message
+ KMMessagePart* mNewBodyPart;
+ QByteArray mSignature;
+
+ QByteArray mEncodedBody; // Only needed if signing and/or encrypting
+ bool mEarlyAddAttachments, mAllAttachmentsAreInBody;
+ KMMessagePart mOldBodyPart;
+ int mPreviousBoundaryLevel;
+
+ // The boundary is saved for later addition into mp/a body
+ DwString mSaveBoundary;
+ QCString mMultipartMixedBoundary;
+
+ QValueList<MessageComposerJob*> mJobs;
+ bool mEncryptWithChiasmus;
+ bool mPerformingSignOperation;
+};
+
+#endif /* MESSAGECOMPOSER_H */