1 files changed, 378 insertions, 0 deletions

diff --git a/framework/src/domain/mime/mimetreeparser/interface.h b/framework/src/domain/mime/mimetreeparser/interface.h
new file mode 100644
index 00000000..7c3ea28b
--- /dev/null
+++ b/framework/src/domain/mime/mimetreeparser/interface.h
@@ -0,0 +1,378 @@
+/*
+    Copyright (c) 2016 Sandro Knauß <knauss@kolabsystems.com>
+
+    This library is free software; you can redistribute it and/or modify it
+    under the terms of the GNU Library General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    This library 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 Library General Public
+    License for more details.
+
+    You should have received a copy of the GNU Library General Public License
+    along with this library; see the file COPYING.LIB.  If not, write to the
+    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+    02110-1301, USA.
+*/
+
+#pragma once
+
+#include <functional>
+#include <memory>
+#include <vector>
+
+#include <QDateTime>
+#include <QUrl>
+#include <QMimeType>
+
+class Part;
+class PartPrivate;
+
+class MailMime;
+class MailMimePrivate;
+
+class AlternativePart;
+class AlternativePartPrivate;
+
+class SinglePart;
+class SinglePartPrivate;
+
+class EncryptionPart;
+class EncryptionPartPrivate;
+
+class EncapsulatedPart;
+class EncapsulatedPartPrivate;
+
+class Content;
+class ContentPrivate;
+
+class CertContent;
+class CertContentPrivate;
+
+class EncryptionError;
+
+class Key;
+class KeyPrivate;
+class Signature;
+class SignaturePrivate;
+class Encryption;
+class EncryptionPrivate;
+
+typedef std::shared_ptr<Signature> SignaturePtr;
+typedef std::shared_ptr<Encryption> EncryptionPtr;
+
+class Parser;
+class ParserPrivate;
+
+/* 
+ * A MessagePart that is based on a KMime::Content
+ */
+class MailMime
+{
+public:
+    typedef std::shared_ptr<MailMime> Ptr;
+    /**
+     *  Various possible values for the "Content-Disposition" header.
+     */
+    enum Disposition {
+        Invalid,           ///< Default, invalid value
+        Inline,            ///< inline
+        Attachment        ///< attachment
+    };
+
+    MailMime();
+
+    // interessting header parts of a KMime::Content
+    QMimeType mimetype() const;
+    Disposition disposition() const;
+    QUrl label() const;
+    QByteArray cid() const;
+    QByteArray charset() const;
+    QString filename() const;
+
+    // Unique identifier to ecactly this KMime::Content
+    QByteArray link() const;
+
+    QByteArray content() const;
+    //Use default charset
+    QString encodedContent() const;
+
+    // overwrite default charset with given charset
+    QString encodedContent(QByteArray charset) const;
+
+    QByteArray decodedContent() const;
+
+    bool isFirstTextPart() const;
+    bool isFirstPart() const;
+    bool isTopLevelPart() const;
+
+    MailMime::Ptr parent() const;
+
+private:
+    std::unique_ptr<MailMimePrivate> d;
+
+    friend class PartPrivate;
+};
+
+class Content
+{
+public:
+    typedef std::shared_ptr<Content> Ptr;
+    Content(const QByteArray &content, Part *parent);
+    Content(ContentPrivate *d_ptr);
+    virtual ~Content();
+
+    QByteArray content() const;
+
+    QByteArray charset() const;
+
+    //Use default charset
+    QString encodedContent() const;
+
+    // overwrite default charset with given charset
+    QString encodedContent(const QByteArray &charset) const;
+
+    QVector<SignaturePtr> signatures() const;
+    QVector<EncryptionPtr> encryptions() const;
+    MailMime::Ptr mailMime() const;
+    virtual QByteArray type() const;
+    Part* parent() const;
+private:
+    std::unique_ptr<ContentPrivate> d;
+};
+
+class PlainTextContent : public Content
+{
+public:
+    PlainTextContent(const QByteArray &content, Part *parent);
+    PlainTextContent(ContentPrivate *d_ptr);
+    QByteArray type() const Q_DECL_OVERRIDE;
+};
+
+class HtmlContent : public Content
+{
+public:
+    HtmlContent(const QByteArray &content, Part *parent);
+    HtmlContent(ContentPrivate* d_ptr);
+    QByteArray type() const Q_DECL_OVERRIDE;
+};
+
+/*
+ * importing a cert GpgMe::ImportResult
+ * checking a cert (if it is a valid cert)
+ */
+
+class CertContent : public Content
+{
+public:
+    typedef std::shared_ptr<CertContent> Ptr;
+    CertContent(const QByteArray &content, Part *parent);
+
+    QByteArray type() const Q_DECL_OVERRIDE;
+    enum CertType {
+        Pgp,
+        SMime
+    };
+
+    enum CertSubType {
+        Public,
+        Private
+    };
+
+    CertType certType() const;
+    CertSubType certSubType() const;
+    int keyLength() const;
+
+private:
+    std::unique_ptr<CertContentPrivate> d;
+};
+
+class Part
+{
+public:
+    typedef std::shared_ptr<Part> Ptr;
+    Part();
+    virtual QByteArray type() const;
+
+    virtual QVector<QByteArray> availableContents() const;
+    virtual QVector<Content::Ptr> content(const QByteArray& ct) const;
+    QVector<Content::Ptr> content() const;
+
+    bool hasSubParts() const;
+    QVector<Part::Ptr> subParts() const;
+    Part *parent() const;
+
+    QVector<SignaturePtr> signatures() const;
+    QVector<EncryptionPtr> encryptions() const;
+    virtual MailMime::Ptr mailMime() const;
+protected:
+    std::unique_ptr<PartPrivate> d;
+private:
+    friend class ParserPrivate;
+    friend class PartPrivate;
+};
+
+class AlternativePart : public Part
+{
+public:
+    typedef std::shared_ptr<AlternativePart> Ptr;
+
+    AlternativePart();
+    virtual ~AlternativePart();
+
+    QVector<QByteArray> availableContents() const Q_DECL_OVERRIDE;
+    QVector<Content::Ptr> content(const QByteArray& ct) const Q_DECL_OVERRIDE;
+
+    QByteArray type() const Q_DECL_OVERRIDE;
+
+private:
+    PartPrivate *reachParentD() const;
+    std::unique_ptr<AlternativePartPrivate> d;
+
+    friend class ParserPrivate;
+    friend class AlternativePartPrivate;
+};
+
+class SinglePart : public Part
+{
+ public:
+    typedef std::shared_ptr<SinglePart> Ptr;
+
+    SinglePart();
+    virtual ~SinglePart();
+
+    QVector<Content::Ptr> content(const QByteArray& ct) const Q_DECL_OVERRIDE;
+    QVector<QByteArray> availableContents() const Q_DECL_OVERRIDE;
+
+    QByteArray type() const Q_DECL_OVERRIDE;
+private:
+    PartPrivate *reachParentD() const;
+    std::unique_ptr<SinglePartPrivate> d;
+
+    friend class ParserPrivate;
+    friend class SinglePartPrivate;
+};
+
+/*
+ * we want to request complete headers like:
+ * from/to...
+ */
+
+class EncapsulatedPart : public SinglePart
+{
+public:
+    typedef std::shared_ptr<EncapsulatedPart> Ptr;
+    QByteArray type() const Q_DECL_OVERRIDE;
+
+    //template <class T> QByteArray header<T>();
+private:
+    std::unique_ptr<EncapsulatedPartPrivate> d;
+};
+
+class EncryptionError
+{
+public:
+    int errorId() const;
+    QString errorString() const;
+};
+
+class Key
+{
+public:
+    typedef std::shared_ptr<Key> Ptr;
+    Key();
+    Key(KeyPrivate *);
+    ~Key();
+
+    QString keyid() const;
+    QString name() const;
+    QString email() const;
+    QString comment() const;
+    QVector<QString> emails() const;
+    enum KeyTrust {
+        Unknown, Undefined, Never, Marginal, Full, Ultimate
+    };
+    KeyTrust keyTrust() const;
+
+    bool isRevokation() const;
+    bool isInvalid() const;
+    bool isExpired() const;
+
+    std::vector<Key::Ptr> subkeys();
+    Key parentkey() const;
+private:
+    std::unique_ptr<KeyPrivate> d;
+};
+
+class Signature
+{
+public:
+    typedef std::shared_ptr<Signature> Ptr;
+    Signature();
+    Signature(SignaturePrivate *);
+    ~Signature();
+
+    Key::Ptr key() const;
+    QDateTime creationDateTime() const;
+    QDateTime expirationDateTime() const;
+    bool neverExpires() const;
+
+    //template <> StatusObject<SignatureVerificationResult> verify() const;
+    private:
+        std::unique_ptr<SignaturePrivate> d;
+};
+
+/*
+ * Normally the Keys for encryption are subkeys
+ * for clients the parentkeys are "more interessting", because they store the name, email etc.
+ * but a client may also wants show to what subkey the mail is really encrypted, an if this subkey isRevoked or something else
+ */
+class Encryption
+{
+public:
+    enum ErrorType {
+        NoError,
+        PassphraseError,
+        KeyMissing,
+        UnknownError
+    };
+    typedef std::shared_ptr<Encryption> Ptr;
+    Encryption();
+    Encryption(EncryptionPrivate *);
+    ~Encryption();
+    std::vector<Key::Ptr> recipients() const;
+    QString errorString();
+    ErrorType errorType();
+private:
+    std::unique_ptr<EncryptionPrivate> d;
+};
+
+class Parser
+{
+public:
+    typedef std::shared_ptr<Parser> Ptr;
+    Parser(const QByteArray &mimeMessage);
+    ~Parser();
+
+    Part::Ptr getPart(const QUrl &url);
+
+    QVector<Part::Ptr> collect(const Part::Ptr &start, std::function<bool(const Part::Ptr &)> select, std::function<bool(const Content::Ptr &)> filter) const;
+    Part::Ptr find(const Part::Ptr &start, std::function<bool(const Part::Ptr &)> select) const;
+    QVector<Part::Ptr> collectContentParts() const;
+    QVector<Part::Ptr> collectAttachmentParts() const;
+    //template <> QVector<ContentPart::Ptr> collect<ContentPart>() const;
+
+    //template <> static StatusObject<SignatureVerificationResult> verifySignature(const Signature signature) const;
+    //template <> static StatusObject<Part> decrypt(const EncryptedPart part) const;
+
+signals:
+    void partsChanged();
+
+private:
+    std::unique_ptr<ParserPrivate> d;
+
+    friend class InterfaceTest;
+};
+