|
|
- #include "test_utils.hh"
-
- #include <pEp/pEpEngine.h>
- #include <pEp/message_api.h>
- #include <pEp/keymanagement.h>
- #include <pEp/identity_list.h>
- #include <pEp/Adapter.hh>
- #include <pEp/status_to_string.hh>
- #include <pEp/mime.h>
- #include <tuple>
-
- namespace pEp {
- namespace Test {
- namespace Utils {
-
- //Ident
- pEpIdent wrap(::pEp_identity *const ident)
- {
- assert(ident);
- auto ret = pEpIdent(ident, [](::pEp_identity *) {});
- return ret;
- }
-
- pEpIdent appropriate(::pEp_identity *const ident)
- {
- assert(ident);
- auto ret = pEpIdent(ident, ::free_identity);
- return ret;
- }
-
- pEpIdent dup(const ::pEp_identity *const ident)
- {
- assert(ident);
- auto ret = pEpIdent(::identity_dup(ident), ::free_identity);
- return ret;
- }
-
- pEpIdent kill(::pEp_identity *const ident)
- {
- assert(ident);
- auto ret = pEpIdent(::identity_dup(ident), ::free_identity);
- ::free_identity(ident);
- return ret;
- }
-
- //IdentityList
- pEpIdentList wrap(::identity_list *const ident)
- {
- assert(ident);
- auto ret = pEpIdentList(ident, [](::identity_list *) {});
- return ret;
- }
-
- pEpIdentList appropriate(::identity_list *const ident)
- {
- assert(ident);
- auto ret = pEpIdentList(ident, ::free_identity_list);
- return ret;
- }
-
- pEpIdentList dup(const ::identity_list *const ident)
- {
- assert(ident);
- auto ret = pEpIdentList(::identity_list_dup(ident), ::free_identity_list);
- return ret;
- }
-
- pEpIdentList kill(::identity_list *const ident)
- {
- assert(ident);
- auto ret = pEpIdentList(::identity_list_dup(ident), ::free_identity_list);
- ::free_identity_list(ident);
- return ret;
- }
-
- //Message
- pEpMessage wrap(::message *const msg)
- {
- assert(msg);
- auto ret = pEpMessage(msg, [](::message *) {});
- return ret;
- }
-
- pEpMessage appropriate(::message *const msg)
- {
- assert(msg);
- auto ret = pEpMessage(msg, ::free_message);
- return ret;
- }
-
- pEpMessage dup(const ::message *const msg)
- {
- assert(msg);
- auto ret = pEpMessage(::message_dup(msg), ::free_message);
- return ret;
- }
-
- pEpMessage kill(::message *const msg)
- {
- assert(msg);
- auto ret = pEpMessage(::message_dup(msg), ::free_message);
- ::free_message(msg);
- return ret;
- }
-
- // helpers
- pEpIdent createOwnIdent(const std::string &address)
- {
- std::string name;
- ::pEp_identity *ident = nullptr;
- ident = ::new_identity(
- strdup(address.c_str()),
- "",
- PEP_OWN_USERID,
- ("myself " + address).c_str());
- ident->me = true;
-
- return appropriate(ident);
- }
-
- pEpIdent createCptIdent(const std::string &address)
- {
- std::string name;
- ::pEp_identity *ident = nullptr;
- ident = ::new_identity(
- strdup(address.c_str()),
- "",
- "",
- ("partner " + address).c_str());
- ident->me = false;
-
- return appropriate(ident);
- }
-
- pEpIdent createRawIdent(const std::string &address)
- {
- std::string name;
- ::pEp_identity *ident = nullptr;
- ident = ::new_identity(strdup(address.c_str()), "", "", "");
- ident->me = false;
-
- return appropriate(ident);
- }
-
- pEpIdentList createIdentityList(const std::vector<std::string> &addresses)
- {
- ::identity_list *list;
- list = ::new_identity_list(nullptr);
- for (std::string addr : addresses) {
- ::identity_list_add(list, ::identity_dup(createCptIdent(addr).get()));
- }
- return appropriate(list);
- }
-
- pEpMessage createMessage(pEpIdent from, pEpIdent to, const std::string &longmsg)
- {
- // create and fill in msg
- ::message *msg = ::new_message(PEP_dir_outgoing);
- msg->from = ::identity_dup(from.get());
- msg->to = ::new_identity_list(::identity_dup(to.get()));
- msg->longmsg = strdup(longmsg.c_str());
-
- pEpMessage ret = appropriate(msg);
- return ret;
- }
-
- pEpMessage createMessage(pEpIdent from, const std::string &to_addr, const std::string &longmsg)
- {
- pEpIdent to_ident = createCptIdent(to_addr);
- return createMessage(from, to_ident, longmsg);
- }
-
- std::string mimeEncode(const pEpMessage msg)
- {
- char *mimetext;
- PEP_STATUS status = ::mime_encode_message(msg.get(), false, &mimetext, false);
- throw_status(status);
- std::string text{ mimetext };
- free(mimetext);
- return text;
- }
-
- pEpMessage mimeDecode(const std::string &mime_text)
- {
- ::message *msg;
- bool has_possible_pEp_msg;
- ::PEP_STATUS status = ::mime_decode_message(
- mime_text.c_str(),
- mime_text.length(),
- &msg,
- &has_possible_pEp_msg);
- throw_status(status);
- return pEpMessage(msg, ::free_message);
- }
-
- EncryptResult encryptMessage(const pEpMessage msg)
- {
- pEpMessage msg_out;
- bool could_encrypt = false;
- ::message *msgenc = nullptr;
- PEP_STATUS status = ::encrypt_message(
- Adapter::session(),
- msg.get(),
- nullptr,
- &msgenc,
- PEP_enc_PEP,
- 0);
- throw_status(status);
- ::message *msg_out_p = nullptr;
- if (msgenc != nullptr) {
- could_encrypt = true;
- msg_out = appropriate(msgenc);
- } else {
- could_encrypt = false;
- msg_out = msg;
- }
- return EncryptResult(msg_out, "", could_encrypt);
- }
-
-
- DecryptResult decryptMessage(const pEpMessage msg, ::PEP_decrypt_flags_t *flags)
- {
- pEpMessage msg_out;
- bool was_encrypted = false;
-
- ::message *dec{ nullptr };
- ::stringlist_t *kl = ::new_stringlist("");
- ::PEP_rating rating;
- PEP_STATUS status = ::decrypt_message(
- Adapter::session(),
- msg.get(),
- &dec,
- &kl,
- &rating,
- flags);
- throw_status(status);
- if (dec != nullptr) {
- was_encrypted = true;
- msg_out = appropriate(dec);
- } else {
- was_encrypted = false;
- msg_out = msg;
- }
- return DecryptResult(msg_out, rating, kl, flags, was_encrypted);
- }
-
- DecryptResult decryptMessage(const pEpMessage msg)
- {
- ::PEP_decrypt_flags_t dummy{ 0 };
- return decryptMessage(msg, &dummy);
- }
-
- EncryptResult encryptAndEncode(const pEpMessage msg)
- {
- EncryptResult ret = encryptMessage(msg);
- std::string mime_text = mimeEncode(std::get<0>(ret));
- std::get<1>(ret) = mime_text;
- return ret;
- }
-
- DecryptResult decryptAndDecode(const std::string &mime_data)
- {
- DecryptResult ret;
- pEpMessage rx_msg = mimeDecode(mime_data);
- ret = decryptMessage(rx_msg);
- return ret;
- }
- } // namespace Utils
- } // namespace Test
- } // namespace pEp
|