pEp.foundation
/
libpEpAdapter
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

Tests: test_tofu - WORKING again \o/

LIB-11
heck 4 years ago
parent
4fc519bd3f
commit
c018c95c57
1 changed files with 83 additions and 44 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 127
      test/test_tofu.cc

127
test/test_tofu.cc
View File

@ -21,25 +21,29 @@ using pEpIdent = std::shared_ptr<::pEp_identity>;
using pEpMessage = std::shared_ptr<::message>;
//Ident
pEpIdent wrap(::pEp_identity *const ident) {
pEpIdent wrap(::pEp_identity *const ident)
{
assert(ident);
auto ret = pEpIdent(ident, [](::pEp_identity *) {});
return ret;
}
pEpIdent appropriate(::pEp_identity *const ident) {
pEpIdent appropriate(::pEp_identity *const ident)
{
assert(ident);
auto ret = pEpIdent(ident, ::free_identity);
return ret;
}
pEpIdent dup(const ::pEp_identity *const ident) {
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) {
pEpIdent kill(::pEp_identity *const ident)
{
assert(ident);
auto ret = pEpIdent(::identity_dup(ident), ::free_identity);
::free_identity(ident);
@ -47,25 +51,29 @@ pEpIdent kill(::pEp_identity *const ident) {
}
//Message
pEpMessage wrap(::message *const msg) {
pEpMessage wrap(::message *const msg)
{
assert(msg);
auto ret = pEpMessage(msg, [](::message *) {});
return ret;
}
pEpMessage appropriate(::message *const msg) {
pEpMessage appropriate(::message *const msg)
{
assert(msg);
auto ret = pEpMessage(msg, ::free_message);
return ret;
}
pEpMessage dup(const ::message *const msg) {
pEpMessage dup(const ::message *const msg)
{
assert(msg);
auto ret = pEpMessage(::message_dup(msg), ::free_message);
return ret;
}
pEpMessage kill(::message *const msg) {
pEpMessage kill(::message *const msg)
{
assert(msg);
auto ret = pEpMessage(::message_dup(msg), ::free_message);
::free_message(msg);
@ -73,78 +81,103 @@ pEpMessage kill(::message *const msg) {
}
pEpIdent createIdentity(const std::string &address, bool myself) {
pEpIdent createIdentity(const std::string &address, bool myself)
{
std::string name;
std::string id;
::pEp_identity *partner = nullptr;
if (myself) {
name = "myself " + address;
partner = ::new_identity(
strdup(address.c_str()),
"",
PEP_OWN_USERID,
("myself " + address).c_str());
partner->me = true;
} else {
name = "partner " + address;
partner = ::new_identity(strdup(address.c_str()), "", "23", ("partner " + address).c_str());
partner->me = false;
}
::pEp_identity *partner = ::new_identity(strdup(address.c_str()), NULL, PEP_OWN_USERID,
strdup(name.c_str()));
return appropriate(partner);
}
pEpMessage createMessage(pEpIdent from, pEpIdent to, const std::string &longmsg) {
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->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) {
auto to_ident = createIdentity(to_addr, false);
pEpMessage createMessage(pEpIdent from, const std::string &to_addr, const std::string &longmsg)
{
pEpIdent to_ident = createIdentity(to_addr, false);
return createMessage(from, to_ident, longmsg);
}
pEpMessage mimeDecode(const std::string &mime_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);
mime_text.c_str(),
mime_text.length(),
&msg,
&has_possible_pEp_msg);
throw_status(status);
return pEpMessage(msg, ::free_message);
}
std::string mimeEncode(pEpMessage msg) {
std::string mimeEncode(pEpMessage msg)
{
char *mimetext;
PEP_STATUS status = ::mime_encode_message(msg.get(), false, &mimetext, false);
throw_status(status);
std::string text{mimetext};
std::string text{ mimetext };
free(mimetext);
return text;
}
void encryptAndSend(pEpIdent from, std::string to_addr, std::string longmsg, PityUnit<PityPerspective> &unit) {
pEpMessage msg = createMessage(from, to_addr, "INIT_TOFU");
void encryptAndSend(pEpIdent from, std::string to_addr, std::string longmsg, PityUnit<PityPerspective> &unit)
{
pEpMessage msg = createMessage(from, to_addr, longmsg);
::message *msgenc = nullptr;
// ::pEp_identity *receiver_ident = msg.get()->to->ident;
// {
// PEP_STATUS status = ::update_identity(Adapter::session(), receiver_ident);
// unit.log("encryptAndSend: UPDATE IDENT - " + status_to_string(status));
// }
// msg.get()->to = ::new_identity_list(receiver_ident);
PEP_STATUS status = ::encrypt_message(Adapter::session(), msg.get(), nullptr, &msgenc, PEP_enc_PEP, 0);
throw_status(status);
unit.log("encryptAndSend: " + status_to_string(status));
unit.log("encryptAndSend" + Utils::to_string(msgenc, false));
std::string mime_text = mimeEncode(wrap(msgenc));
::message *msg_out = nullptr;
if(msgenc != nullptr ){
msg_out = msgenc;
} else {
msg_out = msg.get();
}
unit.log("encryptAndSend: ENCRYPT - " + status_to_string(status));
unit.log("encryptAndSend" + Utils::to_string(msg_out, false));
std::string mime_text = mimeEncode(wrap(msg_out));
unit.transport()->sendMsg(to_addr, mime_text);
}
pEpMessage receiveAndDecrypt(PityUnit<PityPerspective> &unit) {
pEpMessage receiveAndDecrypt(PityUnit<PityPerspective> &unit)
{
pEpMessage ret;
std::string rx_data = unit.transport()->receiveMsg();
pEpMessage rx_msg = mimeDecode(rx_data);
::message *dec{nullptr};
::message *dec{ nullptr };
::stringlist_t *kl = ::new_stringlist("");
PEP_rating rating;
unsigned int flags{0};
PEP_STATUS status = ::decrypt_message(Adapter::session(), rx_msg.get(), &dec, &kl, &rating,
&flags);
unsigned int flags{ 0 };
PEP_STATUS status = ::decrypt_message(Adapter::session(), rx_msg.get(), &dec, &kl, &rating, &flags);
throw_status(status);
if (dec != nullptr) {
ret = appropriate(dec);
@ -157,7 +190,8 @@ pEpMessage receiveAndDecrypt(PityUnit<PityPerspective> &unit) {
return ret;
}
void tofu(PityUnit<PityPerspective> &unit, PityPerspective *ctx, bool init) {
void tofu(PityUnit<PityPerspective> &unit, PityPerspective *ctx, bool init)
{
unit.log("Model : " + ctx->model.getName());
unit.log("myself : " + ctx->name);
unit.log("partner: " + ctx->partner);
@ -169,15 +203,16 @@ void tofu(PityUnit<PityPerspective> &unit, PityPerspective *ctx, bool init) {
pEpIdent my_ident = createIdentity(ctx->name, true);
::PEP_STATUS status = ::myself(Adapter::session(), my_ident.get());
pEp::throw_status(status);
// unit.log(status_to_string(status));
// unit.log(Utils::to_string(my_ident.get()));
// unit.log(status_to_string(status));
// unit.log(Utils::to_string(my_ident.get()));
// ACT
// Utils::readKey();
if (init) {
unit.log("Initiating TOFU...");
encryptAndSend(my_ident, ctx->partner, "INIT TOFU", unit);
}
// Utils::readKey();
while (true) {
pEpMessage msg_rx = receiveAndDecrypt(unit);
unit.log(">");
@ -185,20 +220,24 @@ void tofu(PityUnit<PityPerspective> &unit, PityPerspective *ctx, bool init) {
pEpIdent rx_from = wrap(msg_rx->from);
std::string rx_longmessage = msg_rx->longmsg;
//
encryptAndSend(my_ident, rx_from->address,
"REPLY[ " + std::string(rx_from->address) + " ] " + rx_longmessage, unit);
encryptAndSend(
my_ident,
rx_from->address,
"REPLY[ " + std::string(rx_from->address) + " ] " + rx_longmessage,
unit);
unit.log("<");
Utils::sleep_millis(10000);
Utils::sleep_millis(1000);
}
}
int main(int argc, char *argv[]) {
int main(int argc, char *argv[])
{
PityUnit<PityPerspective>::debug_log_enabled = false;
int nodesCount = 2;
PityModel model{"test_tofu", nodesCount};
PitySwarm swarm{model};
PityModel model{ "test_tofu", nodesCount };
PitySwarm swarm{ model };
swarm.addTestUnit(0, "tofu1", [](PityUnit<PityPerspective> &unit, PityPerspective *ctx) {
tofu(unit, ctx, true);

Write Preview
Loading…
Cancel
Save