2016-08-27 00:51:00 -04:00
|
|
|
#include "STDInclude.hpp"
|
|
|
|
|
|
|
|
#ifndef DISABLE_BITMESSAGE
|
|
|
|
|
|
|
|
#include <Shlwapi.h>
|
|
|
|
|
|
|
|
using namespace Utils;
|
|
|
|
|
|
|
|
namespace Components
|
|
|
|
{
|
2016-08-28 13:38:16 -04:00
|
|
|
BitMessage* BitMessage::Singleton = NULL;
|
2016-08-27 00:51:00 -04:00
|
|
|
|
|
|
|
BitMessage::BitMessage()
|
|
|
|
{
|
2016-08-28 13:38:16 -04:00
|
|
|
if (Singleton != NULL)
|
|
|
|
throw new std::runtime_error("Only one instance of BitMessage allowed at the same time.");
|
|
|
|
|
2016-08-27 00:51:00 -04:00
|
|
|
Singleton = this;
|
|
|
|
|
|
|
|
Logger::Print("Initializing BitMessage...\n");
|
2016-08-27 15:20:08 -04:00
|
|
|
this->BMClient = new BitMRC(BITMESSAGE_OBJECT_STORAGE_FILENAME, BITMESSAGE_KEYS_FILENAME);
|
|
|
|
this->BMClient->init();
|
|
|
|
this->BMClient->defaultTTL = 1 * 60 * 60; // 1 hour
|
2016-08-27 00:51:00 -04:00
|
|
|
|
|
|
|
if (this->BMClient->PrivAddresses.empty())
|
|
|
|
{
|
|
|
|
if (!this->InitAddr())
|
|
|
|
{
|
|
|
|
// Generate a random address ready to use
|
|
|
|
throw std::runtime_error("Failed to prepare source address for exception handling");
|
|
|
|
}
|
2016-08-27 15:20:08 -04:00
|
|
|
this->BMClient->save();
|
2016-08-27 00:51:00 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
this->BMClient->start();
|
|
|
|
|
2016-08-27 05:24:26 -04:00
|
|
|
Command::Add("bm_send", [](Command::Params params) {
|
|
|
|
if (params.Length() < 3) return;
|
|
|
|
|
|
|
|
ustring pubAddrString;
|
|
|
|
pubAddrString.fromString(params[1]);
|
|
|
|
PubAddr pubAddr;
|
|
|
|
if (pubAddr.loadAddr(pubAddrString))
|
|
|
|
{
|
|
|
|
ustring msg;
|
|
|
|
msg.fromString(params.Join(2));
|
|
|
|
|
|
|
|
Logger::Print("Sending message (this may take a while)...\n");
|
|
|
|
Singleton->BMClient->sendMessage(msg, pubAddr, Singleton->BMClient->PrivAddresses[0]);
|
|
|
|
Logger::Print("Message sent.\n");
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
Logger::Print("Address not correct!\n");
|
|
|
|
}
|
|
|
|
});
|
2016-08-27 04:16:12 -04:00
|
|
|
Command::Add("bm_sendb", [](Command::Params params) {
|
|
|
|
if (params.Length() < 2) return;
|
|
|
|
|
2016-08-27 00:51:00 -04:00
|
|
|
ustring msg;
|
2016-08-27 04:16:12 -04:00
|
|
|
msg.appendVarString(params.Join(1));
|
|
|
|
Logger::Print("Sending broadcast...\n");
|
2016-08-27 00:51:00 -04:00
|
|
|
Singleton->BMClient->sendBroadcast(msg, Singleton->BMClient->PrivAddresses[0]);
|
2016-08-27 04:16:12 -04:00
|
|
|
Logger::Print("Broadcast done.\n");
|
2016-08-27 00:51:00 -04:00
|
|
|
});
|
|
|
|
Command::Add("bm_check_messages", [](Command::Params) {
|
|
|
|
while (Singleton->BMClient->new_messages.size() > 0)
|
|
|
|
{
|
|
|
|
auto msg = Singleton->BMClient->new_messages.pop();
|
|
|
|
Logger::Print("New message:\nFrom: %s\nTo: %s\nMessage:\n%s\n", msg.from.c_str(), msg.to.c_str(), msg.info.c_str());
|
|
|
|
}
|
|
|
|
});
|
|
|
|
Command::Add("bm_check_connections", [](Command::Params) {
|
|
|
|
std::shared_lock<std::shared_timed_mutex> mlock(Singleton->BMClient->mutex_nodes);
|
|
|
|
|
|
|
|
for (auto& node : Singleton->BMClient->Nodes)
|
|
|
|
{
|
|
|
|
switch (node->state) {
|
|
|
|
case 0: // Not connected
|
|
|
|
Logger::Print("%s: Disconnected\n", node->Ip.c_str());
|
|
|
|
break;
|
|
|
|
case 1: // Connecting
|
|
|
|
Logger::Print("%s: Connecting\n", node->Ip.c_str());
|
|
|
|
break;
|
|
|
|
case 2: // Connected
|
|
|
|
Logger::Print("%s: Connected\n", node->Ip.c_str());
|
|
|
|
break;
|
|
|
|
case 3: // Reconnecting
|
|
|
|
Logger::Print("%s: Reconnecting\n", node->Ip.c_str());
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
mlock.unlock();
|
|
|
|
});
|
|
|
|
Command::Add("bm_check_privatekey", [](Command::Params) {
|
|
|
|
std::shared_lock<std::shared_timed_mutex> mlock(Singleton->BMClient->mutex_priv);
|
|
|
|
|
|
|
|
if (Singleton->BMClient->PrivAddresses.empty()) {
|
|
|
|
Logger::Print("No private key\n");
|
|
|
|
}
|
|
|
|
else
|
|
|
|
for (auto& addr : Singleton->BMClient->PrivAddresses)
|
|
|
|
{
|
|
|
|
Logger::Print("%s\n", addr.getAddress().c_str());
|
|
|
|
}
|
|
|
|
|
|
|
|
mlock.unlock();
|
|
|
|
});
|
|
|
|
Command::Add("bm_check_publickey", [](Command::Params) {
|
|
|
|
std::shared_lock<std::shared_timed_mutex> mlock(Singleton->BMClient->mutex_pub);
|
|
|
|
|
|
|
|
if (Singleton->BMClient->PubAddresses.empty()) {
|
|
|
|
Logger::Print("No public key\n");
|
|
|
|
}
|
|
|
|
else
|
|
|
|
for (auto& addr : Singleton->BMClient->PubAddresses)
|
|
|
|
{
|
2016-08-29 02:58:04 -04:00
|
|
|
Logger::Print("%s (waiting for public key: %s)\n", addr.getAddress().c_str(), addr.waitingPubKey() ? "yes" : "no");
|
2016-08-27 00:51:00 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
mlock.unlock();
|
|
|
|
});
|
|
|
|
Command::Add("bm_save", [](Command::Params) {
|
2016-08-29 02:58:04 -04:00
|
|
|
Singleton->Save();
|
2016-08-27 00:51:00 -04:00
|
|
|
});
|
|
|
|
Command::Add("bm_address_public", [](Command::Params params) {
|
2016-08-27 04:16:12 -04:00
|
|
|
if (params.Length() < 2) return;
|
2016-08-27 00:51:00 -04:00
|
|
|
|
|
|
|
ustring addre;
|
2016-08-27 04:16:12 -04:00
|
|
|
addre.fromString(params.Join(1));
|
2016-08-27 00:51:00 -04:00
|
|
|
PubAddr address;
|
|
|
|
if (address.loadAddr(addre))
|
|
|
|
{
|
|
|
|
Logger::Print("Asking public key!\n");
|
|
|
|
Singleton->BMClient->getPubKey(address);
|
|
|
|
Logger::Print("Asked! check publickey for news on that address!\n");
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
Logger::Print("Address not correct!\n");
|
|
|
|
}
|
|
|
|
});
|
|
|
|
Command::Add("bm_address_broadcast", [](Command::Params params) {
|
2016-08-27 04:16:12 -04:00
|
|
|
if (params.Length() < 2) return;
|
2016-08-27 00:51:00 -04:00
|
|
|
|
|
|
|
ustring addre;
|
2016-08-27 04:16:12 -04:00
|
|
|
addre.fromString(params.Join(1));
|
2016-08-27 00:51:00 -04:00
|
|
|
PubAddr address;
|
|
|
|
if (address.loadAddr(addre))
|
|
|
|
{
|
|
|
|
Logger::Print("Adding subscription!\n");
|
|
|
|
Singleton->BMClient->addSubscription(address);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
Logger::Print("Address not correct!\n");
|
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
2016-08-28 13:38:16 -04:00
|
|
|
BitMessage::~BitMessage()
|
|
|
|
{
|
|
|
|
Singleton = NULL;
|
2016-08-29 03:03:10 -04:00
|
|
|
delete this->BMClient;
|
2016-08-28 13:38:16 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
void BitMessage::SetDefaultTTL(time_t ttl)
|
|
|
|
{
|
|
|
|
this->BMClient->defaultTTL = ttl;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool BitMessage::RequestPublicKey(std::string targetAddress)
|
|
|
|
{
|
|
|
|
// Convert to ustring
|
|
|
|
ustring targetAddressU;
|
|
|
|
targetAddressU.fromString(targetAddress);
|
|
|
|
|
|
|
|
// Convert to PubAddr
|
|
|
|
PubAddr pubAddr;
|
|
|
|
if (!pubAddr.loadAddr(targetAddressU))
|
|
|
|
{
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Request public key!
|
|
|
|
this->BMClient->getPubKey(pubAddr);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2016-08-29 02:58:04 -04:00
|
|
|
bool BitMessage::RequestAndWaitForPublicKey(std::string targetAddress)
|
|
|
|
{
|
|
|
|
// Convert to ustring
|
|
|
|
ustring targetAddressU;
|
|
|
|
targetAddressU.fromString(targetAddress);
|
|
|
|
|
|
|
|
// Convert to PubAddr
|
|
|
|
PubAddr pubAddr;
|
|
|
|
if (!pubAddr.loadAddr(targetAddressU))
|
|
|
|
{
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Request public key!
|
|
|
|
this->BMClient->getPubKey(pubAddr);
|
|
|
|
|
|
|
|
// TODO: Wait for public key by using signalling in BitMRC, needs to be done directly in the fork.
|
|
|
|
do
|
|
|
|
{
|
|
|
|
sleep(1000);
|
|
|
|
} while (pubAddr.waitingPubKey());
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2016-08-28 13:38:16 -04:00
|
|
|
bool BitMessage::Subscribe(std::string targetAddress)
|
|
|
|
{
|
|
|
|
// Convert to ustring
|
|
|
|
ustring targetAddressU;
|
|
|
|
targetAddressU.fromString(targetAddress);
|
|
|
|
|
|
|
|
// Convert to PubAddr
|
|
|
|
PubAddr pubAddr;
|
|
|
|
if (!pubAddr.loadAddr(targetAddressU))
|
|
|
|
{
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Subscribe!
|
|
|
|
this->BMClient->addSubscription(pubAddr);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool BitMessage::SendMsg(std::string targetAddress, std::string message, time_t ttl)
|
|
|
|
{
|
|
|
|
// Convert target address to ustring
|
|
|
|
ustring targetAddressU;
|
|
|
|
targetAddressU.fromString(targetAddress);
|
|
|
|
|
|
|
|
// Convert target address to PubAddr
|
|
|
|
PubAddr pubAddr;
|
|
|
|
if (!pubAddr.loadAddr(targetAddressU))
|
|
|
|
{
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Convert message to ustring
|
|
|
|
ustring messageU;
|
|
|
|
messageU.fromString(message);
|
|
|
|
|
|
|
|
// Send the message
|
|
|
|
// TODO - Set mutex on priv when accessing first private address
|
|
|
|
if (ttl > 0)
|
|
|
|
this->BMClient->sendMessage(messageU, pubAddr, this->BMClient->PrivAddresses[0], ttl);
|
|
|
|
else
|
|
|
|
this->BMClient->sendMessage(messageU, pubAddr, this->BMClient->PrivAddresses[0]);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool BitMessage::SendBroadcast(std::string message, time_t ttl)
|
|
|
|
{
|
|
|
|
// Convert message to ustring
|
|
|
|
ustring messageU;
|
|
|
|
messageU.fromString(message);
|
|
|
|
|
|
|
|
// TODO - Set mutex on priv when accessing first private address
|
|
|
|
if (ttl > 0)
|
|
|
|
this->BMClient->sendBroadcast(messageU, this->BMClient->PrivAddresses[0], ttl);
|
|
|
|
else
|
|
|
|
this->BMClient->sendBroadcast(messageU, this->BMClient->PrivAddresses[0]);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2016-08-27 00:51:00 -04:00
|
|
|
bool BitMessage::InitAddr()
|
|
|
|
{
|
|
|
|
Logger::Print("Generating BM address...\n");
|
|
|
|
Addr myAddress;
|
|
|
|
if (!myAddress.generateRandom())
|
|
|
|
{
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
BMClient->addAddr(myAddress);
|
|
|
|
return true;
|
|
|
|
}
|
2016-08-29 02:58:04 -04:00
|
|
|
|
|
|
|
void BitMessage::Save()
|
|
|
|
{
|
|
|
|
BMClient->save();
|
|
|
|
}
|
2016-08-27 00:51:00 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|