complete roundtrip

message_cache.cc

@@ -17,23 +17,49 @@ namespace pEp {
     }
 
     PEP_STATUS MessageCache::cache_mime_encode_message(
-            which one,
+            int one,
             const message * msg,
             bool omit_fields,
             char **mimetext,
             bool has_pEp_msg_attachment     
         )
     {
-        return message_cache.mime_encode_message(one, msg, omit_fields,
+        which _one = (which) one;
+        return message_cache.mime_encode_message(_one, msg, omit_fields,
                 mimetext, has_pEp_msg_attachment);
     }
 
-    void MessageCache::cache_release(std::string id)
+    PEP_STATUS MessageCache::cache_mime_decode_message(
+            const char *mimetext,
+            size_t size,
+            message **msg,
+            bool* has_possible_pEp_msg
+        )
+    {
+        return message_cache.mime_decode_message(mimetext, size, msg,
+                has_possible_pEp_msg);
+    }
+
+    PEP_STATUS MessageCache::cache_encrypt_message(
+            PEP_SESSION session,
+            message *src,
+            stringlist_t *extra,
+            message **dst,
+            PEP_enc_format enc_format,
+            PEP_encrypt_flags_t flags
+        )
+    {
+        return message_cache.encrypt_message(session, src, extra, dst,
+                enc_format, flags);
+    }
+
+    PEP_STATUS MessageCache::cache_release(const char *id)
     {
         try {
-            message_cache._cache.erase(id);
+            message_cache._cache.erase(std::string(id));
         }
         catch (...) { }
+        return PEP_STATUS_OK;
     }
 
     static char *dup(const char *src)
@@ -153,12 +179,11 @@ namespace pEp {
 
         dst->id = dup(src->id);
 
+        if (!emptystr(src->shortmsg))
             dst->shortmsg = dup(src->shortmsg);
-
-        if (!emptystr(src->longmsg))
+        else if (!emptystr(src->longmsg))
             dst->longmsg = dup("pEp");
-
-        if (!emptystr(src->longmsg_formatted))
+        else if (!emptystr(src->longmsg_formatted))
             dst->longmsg_formatted = dup("<pEp/>");
         
         // attachments are never copied
@@ -214,8 +239,6 @@ namespace pEp {
         ::message *_dst = *dst;
         *dst = empty_message_copy(_dst);
 
-        message_cache._cache.emplace(std::make_pair(std::string(_src->id),
-                    cache_entry(_src, _dst)));
         return status;
     }
 
@@ -279,5 +302,69 @@ namespace pEp {
 
         return status;
     }
+
+    PEP_STATUS MessageCache::mime_decode_message(
+            const char *mimetext,
+            size_t size,
+            message **msg,
+            bool* has_possible_pEp_msg
+        )
+    {
+        ::message *_msg = nullptr;
+        PEP_STATUS status = ::mime_decode_message(mimetext, size, &_msg,
+                has_possible_pEp_msg);
+        if (status)
+            return status;
+
+        *msg = empty_message_copy(_msg);
+
+        message_cache._cache.emplace(std::make_pair(std::string(_msg->id),
+                    cache_entry(_msg, nullptr)));
+
+        return status;
+    }
+
+    PEP_STATUS MessageCache::encrypt_message(
+            PEP_SESSION session,
+            message *src,
+            stringlist_t *extra,
+            message **dst,
+            PEP_enc_format enc_format,
+            PEP_encrypt_flags_t flags
+        )
+    {
+        ::message *_msg = message_cache._cache.at(src->id).src;
+        
+        free(src->longmsg);
+        src->longmsg = _msg->longmsg;
+        _msg->longmsg = nullptr;
+
+        free(src->longmsg_formatted);
+        src->longmsg_formatted = _msg->longmsg_formatted;
+        _msg->longmsg_formatted = nullptr;
+
+        free_bloblist(src->attachments);
+        src->attachments = _msg->attachments;
+        _msg->attachments = nullptr;
+
+        ::message *_dst = nullptr;
+        PEP_STATUS status = ::encrypt_message(session, src, extra, &_dst,
+                enc_format, flags);
+
+        _msg->longmsg = src->longmsg;
+        src->longmsg = nullptr;
+
+        _msg->longmsg_formatted = src->longmsg_formatted;
+        src->longmsg_formatted = nullptr;
+
+        _msg->attachments = src->attachments;
+        src->attachments = nullptr;
+ 
+        *dst = empty_message_copy(_dst);
+        ::free_message(message_cache._cache.at(src->id).dst);
+        message_cache._cache.at(src->id).dst = _dst;
+
+        return status;
+    }
 };
 

message_cache.hh

@@ -22,6 +22,23 @@ namespace pEp {
         std::mutex _mtx;
 
     public:
+        enum which { msg_src, msg_dst };
+
+		static PEP_STATUS cache_mime_decode_message(
+				const char *mimetext,
+				size_t size,
+				message **msg,
+				bool* has_possible_pEp_msg
+			);
+
+        static PEP_STATUS cache_mime_encode_message(
+                int one,
+                const message * msg,
+                bool omit_fields,
+                char **mimetext,
+                bool has_pEp_msg_attachment     
+            );
+
         static PEP_STATUS cache_decrypt_message(
                 PEP_SESSION session,
                 message *src,
@@ -31,20 +48,34 @@ namespace pEp {
                 PEP_decrypt_flags_t *flags
         );
 
-        enum which { msg_src, msg_dst };;
+		static PEP_STATUS cache_encrypt_message(
+				PEP_SESSION session,
+				message *src,
+				stringlist_t *extra,
+				message **dst,
+				PEP_enc_format enc_format,
+				PEP_encrypt_flags_t flags
+			);
+
+        static PEP_STATUS cache_release(const char *id);
 
-        static PEP_STATUS cache_mime_encode_message(
+    protected:
+		PEP_STATUS mime_decode_message(
+				const char *mimetext,
+				size_t size,
+				message **msg,
+				bool* has_possible_pEp_msg
+			);
+
+        PEP_STATUS mime_encode_message(
                 which one,
-                const message * msg,
+                const message * src,
                 bool omit_fields,
                 char **mimetext,
                 bool has_pEp_msg_attachment
             );
 
-        static void cache_release(std::string id);
-
-    protected:
-        DYNAMIC_API PEP_STATUS decrypt_message(
+        PEP_STATUS decrypt_message(
                 PEP_SESSION session,
                 message *src,
                 message **dst,
@@ -53,12 +84,13 @@ namespace pEp {
                 PEP_decrypt_flags_t *flags
         );
 
-        DYNAMIC_API PEP_STATUS mime_encode_message(
-                which one,
-                const message * src,
-                bool omit_fields,
-                char **mimetext,
-                bool has_pEp_msg_attachment
+		PEP_STATUS encrypt_message(
+				PEP_SESSION session,
+				message *src,
+				stringlist_t *extra,
+				message **dst,
+				PEP_enc_format enc_format,
+				PEP_encrypt_flags_t flags
 			);
 
         static ::message *empty_message_copy(::message *src);

test/test_message_cache.cc

@@ -14,48 +14,76 @@ int main()
     pEp_identity *alice = ::new_identity("alice@mail.com", nullptr, PEP_OWN_USERID, "Alice");
     ::myself(session, alice);
 
-    pEp_identity *bob = ::new_identity("bob@mail.com", nullptr, PEP_OWN_USERID, "Bob");
-    ::update_identity(session, bob);
+    char *mime = strdup("From: Alice <alice@mail.com>\n"
+                        "To: Bob <bob@mail.com>\n"
+                        "Subject: short message\n"
+                        "Message-ID: <42>\n"
+                        "\n"
+                        "long message\n");
 
-    ::message *src = new_message(PEP_dir_incoming);
-    src->from = identity_dup(alice);
-    src->to = ::new_identity_list(::identity_dup(bob));
+    // add to cache
+
+    ::message *src = nullptr;
+    bool has_possible_pEp_msg;
+    status = MessageCache::cache_mime_decode_message(mime, strlen(mime), &src, &has_possible_pEp_msg);
+    assert(status == PEP_STATUS_OK);
 
-    src->shortmsg = strdup("short message");
-    assert(src->shortmsg);
+    status = ::myself(session, src->from);
+    assert(status == PEP_STATUS_OK);
 
-    src->longmsg = strdup("long message");
-    assert(src->longmsg);
+    ::update_identity(session, src->to->ident);
+    assert(status == PEP_STATUS_OK);
 
-    src->longmsg_formatted = strdup("<long msg='formatted'/>");
-    assert(src->longmsg_formatted);
+    pEp_identity *bob = identity_dup(src->to->ident);
 
-    src->attachments = new_bloblist(strdup("blobdata"), 8, "application/octet-stream", "blob.data");
-    assert(src->attachments && src->attachments->value);
+    src->dir = PEP_dir_outgoing;
+    ::message *dst = nullptr;
+    status = MessageCache::cache_encrypt_message(session, src, nullptr, &dst, PEP_enc_PEP, 0);
+    assert(status != PEP_ILLEGAL_VALUE);
+
+    assert(src->longmsg == nullptr);
+    assert(src->attachments == nullptr);
+
+    assert(dst == nullptr);
+
+    // remove from cache
+
+    free(mime);
+    mime = nullptr;
+    status = MessageCache::cache_mime_encode_message(MessageCache::msg_src, src, false, &mime, false);
+    assert(status == PEP_STATUS_OK);
+
+    cout << mime << endl;
 
     // add to cache
 
-    ::message *dst = nullptr;
+    ::free_message(src);
+    src = nullptr;
+    status = MessageCache::cache_mime_decode_message(mime, strlen(mime), &src, &has_possible_pEp_msg);
+    assert(status == PEP_STATUS_OK);
+
+    assert(src->longmsg == nullptr);
+    assert(src->attachments == nullptr);
+
     PEP_rating rating;
     PEP_decrypt_flags_t flags = 0;
     stringlist_t *keylist = nullptr;
 
-    status = MessageCache::cache_decrypt_message(session, src, &dst, &keylist, &rating, &flags);
-    assert(status == PEP_ILLEGAL_VALUE);
-
-    src->id = strdup("42");
-    assert(src->id);
     status = MessageCache::cache_decrypt_message(session, src, &dst, &keylist, &rating, &flags);
     assert(status != PEP_ILLEGAL_VALUE);
 
-    assert(string(src->longmsg) == "pEp");
+    assert(src->longmsg == nullptr);
     assert(src->attachments == nullptr);
 
     // remove from cache
 
-    char *mime = nullptr;
+    free(mime);
+    mime = nullptr;
     status = MessageCache::cache_mime_encode_message(MessageCache::msg_src, src, false, &mime, false);
 
+    assert(src->longmsg == nullptr);
+    assert(src->attachments == nullptr);
+
     cout << mime << endl;
 
     free(mime);