make signs & encrytiopn work

3 files changed, 224 insertions, 26 deletions

diff --git a/framework/domain/mimetreeparser/interface.cpp b/framework/domain/mimetreeparser/interface.cpp
index 04f0fdf2..d6354c9e 100644
--- a/framework/domain/mimetreeparser/interface.cpp
+++ b/framework/domain/mimetreeparser/interface.cpp
@@ -122,10 +122,21 @@ public:
     void createMailMime(const MimeTreeParser::TextMessagePart::Ptr &part);
     void createMailMime(const MimeTreeParser::AlternativeMessagePart::Ptr &part);
     void createMailMime(const MimeTreeParser::HtmlMessagePart::Ptr &part);
+
+    void appendEncryption(const MimeTreeParser::EncryptedMessagePart::Ptr &part);
+    void appendSignature(const MimeTreeParser::SignedMessagePart::Ptr &part);
+
+    void setSignatures(const QVector<Signature::Ptr> &sigs);
+    void setEncryptions(const QVector<Encryption::Ptr> &encs);
+
+    const QVector<Encryption::Ptr> &encryptions() const;
+    const QVector<Signature::Ptr> &signatures() const;
 private:
     Part *q;
     Part *mParent;
     QVector<Part::Ptr> mSubParts;
+    QVector<Encryption::Ptr> mEncryptions;
+    QVector<Signature::Ptr> mSignatures;
     MailMime::Ptr mMailMime;
 };
 
@@ -166,6 +177,27 @@ void PartPrivate::appendSubPart(Part::Ptr subpart)
     mSubParts.append(subpart);
 }
 
+void PartPrivate::appendEncryption(const MimeTreeParser::EncryptedMessagePart::Ptr& part)
+{
+    mEncryptions.append(Encryption::Ptr(new Encryption));
+}
+
+void PartPrivate::setEncryptions(const QVector< Encryption::Ptr >& encs)
+{
+    mEncryptions = encs;
+}
+
+void PartPrivate::appendSignature(const MimeTreeParser::SignedMessagePart::Ptr& part)
+{
+    mSignatures.append(Signature::Ptr(new Signature));
+}
+
+
+void PartPrivate::setSignatures(const QVector< Signature::Ptr >& sigs)
+{
+    mSignatures = sigs;
+}
+
 Part *PartPrivate::parent() const
 {
     return mParent;
@@ -181,6 +213,16 @@ const MailMime::Ptr& PartPrivate::mailMime() const
     return mMailMime;
 }
 
+const QVector< Encryption::Ptr >& PartPrivate::encryptions() const
+{
+    return mEncryptions;
+}
+
+const QVector< Signature::Ptr >& PartPrivate::signatures() const
+{
+    return mSignatures;
+}
+
 Part::Part()
     : d(std::unique_ptr<PartPrivate>(new PartPrivate(this)))
 {
@@ -217,24 +259,24 @@ QVector<Content::Ptr> Part::content(const QByteArray& ct) const
     return QVector<Content::Ptr>();
 }
 
-QVector<Encryption> Part::encryptions() const
+QVector<Encryption::Ptr> Part::encryptions() const
 {
+    auto ret = d->encryptions();
     auto parent = d->parent();
     if (parent) {
-        return parent->encryptions();
-    } else {
-        return QVector<Encryption>();
+        ret.append(parent->encryptions());
     }
+    return ret;
 }
 
-QVector<Signature> Part::signatures() const
+QVector<Signature::Ptr> Part::signatures() const
 {
+    auto ret = d->signatures();
     auto parent = d->parent();
     if (parent) {
-        return parent->signatures();
-    } else {
-        return QVector<Signature>();
+        ret.append(parent->signatures());
     }
+    return ret;
 }
 
 MailMime::Ptr Part::mailMime() const
@@ -250,8 +292,23 @@ public:
     Part *mParent;
     Content *q;
     MailMime::Ptr mMailMime;
+    QVector<Encryption::Ptr> mEncryptions;
+    QVector<Signature::Ptr> mSignatures;
+    void appendSignature(const MimeTreeParser::SignedMessagePart::Ptr &sig);
+    void appendEncryption(const MimeTreeParser::EncryptedMessagePart::Ptr &enc);
 };
 
+void ContentPrivate::appendEncryption(const MimeTreeParser::EncryptedMessagePart::Ptr& enc)
+{
+    mEncryptions.append(Encryption::Ptr(new Encryption));
+}
+
+void ContentPrivate::appendSignature(const MimeTreeParser::SignedMessagePart::Ptr& sig)
+{
+    mSignatures.append(Signature::Ptr(new Signature));
+}
+
+
 Content::Content(const QByteArray& content, Part *parent)
     : d(std::unique_ptr<ContentPrivate>(new ContentPrivate))
 {
@@ -261,24 +318,32 @@ Content::Content(const QByteArray& content, Part *parent)
     d->mParent = parent;
 }
 
+Content::Content(ContentPrivate* d_ptr)
+    : d(std::unique_ptr<ContentPrivate>(d_ptr))
+{
+    d->q = this;
+}
+
 Content::~Content()
 {
 }
 
-QVector<Encryption> Content::encryptions() const
+QVector<Encryption::Ptr> Content::encryptions() const
 {
+    auto ret = d->mEncryptions;
     if (d->mParent) {
-        return d->mParent->encryptions();
+        ret.append(d->mParent->encryptions());
     }
-    return QVector<Encryption>();
+    return ret;
 }
 
-QVector<Signature> Content::signatures() const
+QVector<Signature::Ptr> Content::signatures() const
 {
+    auto ret = d->mSignatures;
     if (d->mParent) {
-        return d->mParent->signatures();
+        ret.append(d->mParent->signatures());
     }
-    return QVector<Signature>();
+    return ret;
 }
 
 QByteArray Content::content() const
@@ -327,6 +392,19 @@ PlainTextContent::PlainTextContent(const QByteArray& content, Part* parent)
 
 }
 
+PlainTextContent::PlainTextContent(ContentPrivate* d_ptr)
+    : Content(d_ptr)
+{
+
+}
+
+HtmlContent::HtmlContent(ContentPrivate* d_ptr)
+    : Content(d_ptr)
+{
+
+}
+
+
 QByteArray PlainTextContent::type() const
 {
     return "PlainTextContent";
@@ -417,7 +495,23 @@ void SinglePartPrivate::fillFrom(MimeTreeParser::TextMessagePart::Ptr part)
     mType = "plaintext";
     mContent.clear();
     foreach (const auto &mp, part->subParts()) {
-        mContent.append(std::make_shared<PlainTextContent>(mp->text().toLocal8Bit(), q));
+        auto d_ptr = new ContentPrivate;
+        d_ptr->mContent = part->text().toLocal8Bit();
+        d_ptr->mParent = q;
+        d_ptr->mCodec = "utf-8";
+        const auto enc = mp.dynamicCast<MimeTreeParser::EncryptedMessagePart>();
+        auto sig = mp.dynamicCast<MimeTreeParser::SignedMessagePart>();
+        if (enc) {
+           d_ptr->appendEncryption(enc);
+           const auto s = enc->subParts();
+           if (s.size() == 1) {
+               sig = s[0].dynamicCast<MimeTreeParser::SignedMessagePart>();
+           }
+        }
+        if (sig) {
+           d_ptr->appendSignature(sig);
+        }
+        mContent.append(std::make_shared<PlainTextContent>(d_ptr));
         q->reachParentD()->createMailMime(part);
     }
 }
@@ -472,6 +566,54 @@ PartPrivate* SinglePart::reachParentD() const
     return Part::d.get();
 }
 
+class SignaturePrivate
+{
+public:
+    Signature *q;
+};
+
+Signature::Signature()
+    :d(std::unique_ptr<SignaturePrivate>(new SignaturePrivate))
+{
+    d->q = this;
+}
+
+
+Signature::Signature(SignaturePrivate *d_ptr)
+    :d(std::unique_ptr<SignaturePrivate>(d_ptr))
+{
+    d->q = this;
+}
+
+Signature::~Signature()
+{
+
+}
+
+
+class EncryptionPrivate
+{
+public:
+    Encryption *q;
+};
+
+Encryption::Encryption(EncryptionPrivate *d_ptr)
+    :d(std::unique_ptr<EncryptionPrivate>(d_ptr))
+{
+    d->q = this;
+}
+
+Encryption::Encryption()
+    :d(std::unique_ptr<EncryptionPrivate>(new EncryptionPrivate))
+{
+    d->q = this;
+}
+
+Encryption::~Encryption()
+{
+
+}
+
 ParserPrivate::ParserPrivate(Parser* parser)
     : q(parser)
     , mNodeHelper(std::make_shared<MimeTreeParser::NodeHelper>())
@@ -513,21 +655,43 @@ void ParserPrivate::createTree(const MimeTreeParser::MessagePart::Ptr &start, co
          if (attachment) {
             auto part = std::make_shared<SinglePart>();
             part->d->fillFrom(attachment);
-            mTree->d->appendSubPart(part);
+            tree->d->appendSubPart(part);
          } else if (text) {
             auto part = std::make_shared<SinglePart>();
             part->d->fillFrom(text);
-            mTree->d->appendSubPart(part);
+            tree->d->appendSubPart(part);
         } else if (alternative) {
             auto part = std::make_shared<AlternativePart>();
             part->d->fillFrom(alternative);
-            mTree->d->appendSubPart(part);
+            tree->d->appendSubPart(part);
         } else if (html) {
             auto part = std::make_shared<SinglePart>();
             part->d->fillFrom(html);
-            mTree->d->appendSubPart(part);
+            tree->d->appendSubPart(part);
         } else {
-            createTree(m, tree);
+            const auto enc = mp.dynamicCast<MimeTreeParser::EncryptedMessagePart>();
+            const auto sig = mp.dynamicCast<MimeTreeParser::SignedMessagePart>();
+            if (enc || sig) {
+                auto subTree =  std::make_shared<Part>();
+                if (enc) {
+                    subTree->d->appendEncryption(enc);
+                }
+                if (sig) {
+                    subTree->d->appendSignature(sig);
+                }
+                createTree(m, subTree);
+                foreach(const auto &p, subTree->subParts()) {
+                    tree->d->appendSubPart(p);
+                    if (enc) {
+                        p->d->setEncryptions(subTree->d->encryptions());
+                    }
+                    if (sig) {
+                        p->d->setSignatures(subTree->d->signatures());
+                    }
+                }
+            } else {
+                createTree(m, tree);
+            }
         }
     }
 }
diff --git a/framework/domain/mimetreeparser/interface.h b/framework/domain/mimetreeparser/interface.h
index a6a7f39d..a482a824 100644
--- a/framework/domain/mimetreeparser/interface.h
+++ b/framework/domain/mimetreeparser/interface.h
@@ -54,7 +54,12 @@ class EncryptionError;
 
 class Key;
 class Signature;
+class SignaturePrivate;
 class Encryption;
+class EncryptionPrivate;
+
+typedef std::shared_ptr<Signature> SignaturePtr;
+typedef std::shared_ptr<Encryption> EncryptionPtr;
 
 class Parser;
 class ParserPrivate;
@@ -109,6 +114,7 @@ class Content
 public:
     typedef std::shared_ptr<Content> Ptr;
     Content(const QByteArray &content, Part *parent);
+    Content(ContentPrivate *d_ptr);
     virtual ~Content();
 
     QByteArray content() const;
@@ -121,8 +127,8 @@ public:
     // overwrite default charset with given charset
     QString encodedContent(QByteArray charset) const;
 
-    virtual QVector<Signature> signatures() const;
-    virtual QVector<Encryption> encryptions() const;
+    QVector<SignaturePtr> signatures() const;
+    QVector<EncryptionPtr> encryptions() const;
     MailMime::Ptr mailMime() const;
     virtual QByteArray type() const;
     Part* parent() const;
@@ -134,6 +140,7 @@ class PlainTextContent : public Content
 {
 public:
     PlainTextContent(const QByteArray &content, Part *parent);
+    PlainTextContent(ContentPrivate *d_ptr);
     QByteArray type() const Q_DECL_OVERRIDE;
 };
 
@@ -141,6 +148,7 @@ class HtmlContent : public Content
 {
 public:
     HtmlContent(const QByteArray &content, Part *parent);
+    HtmlContent(ContentPrivate* d_ptr);
     QByteArray type() const Q_DECL_OVERRIDE;
 };
 
@@ -171,9 +179,8 @@ public:
     int keyLength() const;
 
 private:
-    std::unique_ptr<CertContentPrivate> d;    
+    std::unique_ptr<CertContentPrivate> d;
 };
-
 class Part
 {
 public:
@@ -189,8 +196,8 @@ public:
     QVector<Part::Ptr> subParts() const;
     Part *parent() const;
 
-    virtual QVector<Signature> signatures() const;
-    virtual QVector<Encryption> encryptions() const;
+    QVector<SignaturePtr> signatures() const;
+    QVector<EncryptionPtr> encryptions() const;
     virtual MailMime::Ptr mailMime() const;
 protected:
     std::unique_ptr<PartPrivate> d;
@@ -298,12 +305,20 @@ class Key
 
 class Signature
 {
+public:
+    typedef std::shared_ptr<Signature> Ptr;
+    Signature();
+    Signature(SignaturePrivate *);
+    ~Signature();
+
     Key key() const;
     QDateTime creationDateTime() const;
     QDateTime expirationTime() const;
     bool neverExpires() const;
 
     //template <> StatusObject<SignatureVerificationResult> verify() const;
+    private:
+        std::unique_ptr<SignaturePrivate> d;
 };
 
 /*
@@ -313,7 +328,14 @@ class Signature
  */
 class Encryption
 {
+public:
+    typedef std::shared_ptr<Encryption> Ptr;
+    Encryption();
+    Encryption(EncryptionPrivate *);
+    ~Encryption();
     std::vector<Key> recipients() const;
+private:
+    std::unique_ptr<EncryptionPrivate> d;
 };
 
 class Parser
diff --git a/framework/domain/mimetreeparser/tests/interfacetest.cpp b/framework/domain/mimetreeparser/tests/interfacetest.cpp
index fb073fc1..ac77b025 100644
--- a/framework/domain/mimetreeparser/tests/interfacetest.cpp
+++ b/framework/domain/mimetreeparser/tests/interfacetest.cpp
@@ -145,6 +145,8 @@ private slots:
         QCOMPARE(contentList.size(), 1);
         QCOMPARE(contentList[0]->content(), QStringLiteral("The quick brown fox jumped over the lazy dog.").toLocal8Bit());
         QCOMPARE(contentList[0]->charset(), QStringLiteral("utf-8").toLocal8Bit());
+        QCOMPARE(contentList[0]->encryptions().size(), 1);
+        QCOMPARE(contentList[0]->signatures().size(), 0);
         auto contentAttachmentList = parser.collectAttachmentParts();
         QCOMPARE(contentAttachmentList.size(), 0);
     }
@@ -162,12 +164,18 @@ private slots:
         QCOMPARE(contentList.size(), 1);
         QCOMPARE(contentList[0]->content(), QStringLiteral("test text").toLocal8Bit());
         QCOMPARE(contentList[0]->charset(), QStringLiteral("utf-8").toLocal8Bit());
+        QCOMPARE(contentList[0]->encryptions().size(), 1);
+        QCOMPARE(contentList[0]->signatures().size(), 1);
         auto contentAttachmentList = parser.collectAttachmentParts();
         QCOMPARE(contentAttachmentList.size(), 2);
         QCOMPARE(contentAttachmentList[0]->availableContents(), QVector<QByteArray>() << "text/plain");
         QCOMPARE(contentAttachmentList[0]->content().size(), 1);
+        QCOMPARE(contentAttachmentList[0]->encryptions().size(), 1);
+        QCOMPARE(contentAttachmentList[0]->signatures().size(), 1);
         QCOMPARE(contentAttachmentList[1]->availableContents(), QVector<QByteArray>() << "image/png");
         QCOMPARE(contentAttachmentList[1]->content().size(), 1);
+        QCOMPARE(contentAttachmentList[1]->encryptions().size(), 0);
+        QCOMPARE(contentAttachmentList[1]->signatures().size(), 0);
     }
 
     void testOpenPPGInline()
@@ -179,10 +187,14 @@ private slots:
         auto contentPart = contentPartList[0];
         QVERIFY((bool)contentPart);
         QCOMPARE(contentPart->availableContents(),  QVector<QByteArray>() << "plaintext");
+        QCOMPARE(contentPart->encryptions().size(), 0);
+        QCOMPARE(contentPart->signatures().size(), 0);
         auto contentList = contentPart->content("plaintext");
         QCOMPARE(contentList.size(), 1);
         QCOMPARE(contentList[0]->content(), QStringLiteral("asdasd asd asd asdf sadf sdaf sadf äöü").toLocal8Bit());
         QCOMPARE(contentList[0]->charset(), QStringLiteral("utf-8").toLocal8Bit());
+        QCOMPARE(contentList[0]->encryptions().size(), 1);
+        QCOMPARE(contentList[0]->signatures().size(), 1);
         auto contentAttachmentList = parser.collectAttachmentParts();
         QCOMPARE(contentAttachmentList.size(), 0);
     }