void
ReplicationOptimizer::notifySendFailure(DataObjectRef dObj, NodeRef node)
{
if (utilFunction) {
utilFunction->notifySendFailure(dObj, node);
}
string dobj_id = DataObject::idString(dObj);
string node_id = Node::idString(node);
string key = getKey(dobj_id, node_id);
meta_map_t::iterator it = meta.find(key);
if (it == meta.end()) {
errorCount++;
HAGGLE_ERR("Missing entry.\n");
return;
}
ReplicationDataObjectUtilityMetadataRef do_info = (*it).second;
if (!do_info) {
errorCount++;
HAGGLE_ERR("Missing metadata.\n");
return;
}
Timeval now = Timeval::now();
double delta = now.getTimeAsMilliSecondsDouble() - do_info->getComputedTime().getTimeAsMilliSecondsDouble();
if (delta > computePeriodMs && utilFunction) {
double new_utility = utilFunction->compute(do_info->getId(), do_info->getNodeId());
do_info->setUtility(new_utility, now);
}
}
ProtocolEvent ProtocolUDPGeneric::waitForEvent(
DataObjectRef &dObj,
Timeval *timeout,
bool writeevent)
{
QueueElement *qe = NULL;
Queue *q = getQueue();
if (!q) {
return PROT_EVENT_ERROR;
}
SocketWrapper *sock = getReadEndOfReceiveSocket();
if (NULL == sock) {
HAGGLE_ERR("%s Null receive socket\n", getName());
return PROT_EVENT_ERROR_FATAL;
}
HAGGLE_DBG("%s Waiting for queue element or timeout... %s\n",
getName(), timeout->getAsString().c_str());
QueueEvent_t qev = q->retrieve(&qe,
sock->getSOCKET(),
timeout,
writeevent);
if (QUEUE_ELEMENT == qev) {
dObj = qe->getDataObject();
delete qe;
return PROT_EVENT_TXQ_NEW_DATAOBJECT;
}
if (QUEUE_EMPTY == qev) {
return PROT_EVENT_TXQ_EMPTY;
}
if (QUEUE_WATCH_WRITE == qev) {
return PROT_EVENT_WRITEABLE;
}
if (QUEUE_WATCH_ABANDONED == qev) {
// SW: this occurs when the protocol has been shutdown via some other
// mechanism, such as interface down
HAGGLE_DBG("%s Waiting for event abandoned\n", getName());
return PROT_EVENT_SHOULD_EXIT;
}
if (QUEUE_TIMEOUT == qev) {
HAGGLE_DBG("%s Waiting for event timeout\n", getName());
return PROT_EVENT_TIMEOUT;
}
if (QUEUE_WATCH_READ == qev) {
return PROT_EVENT_INCOMING_DATA;
}
HAGGLE_ERR("%s Waiting for event unknown error\n", getName());
return PROT_EVENT_ERROR;
}
ssize_t
SocketWrapper::sendTo(
const void *buf,
size_t len,
int flags,
const struct sockaddr *to,
socklen_t tolen)
{
if ((NULL == to) || (NULL == buf)) {
HAGGLE_ERR("Invalid argument\n");
return -1;
}
if (INVALID_SOCKET == sock) {
HAGGLE_ERR("Cannot sendto on closed socket\n");
return -1;
}
ssize_t ret = sendto(sock, (const char *)buf, len, flags, to, tolen);
if (-1 == ret) {
HAGGLE_ERR("Sendto failed : %s\n", STRERROR(ERRNO));
}
return ret;
}
ssize_t
SocketWrapper::recvFrom(
void *buf,
size_t len,
int flags,
struct sockaddr *from,
socklen_t *fromlen)
{
if ((NULL == from) || (NULL == buf)) {
HAGGLE_ERR("Invalid argument\n");
return -1;
}
if (INVALID_SOCKET == sock) {
HAGGLE_ERR("Cannot recvfrom on closed socket\n");
return -1;
}
ssize_t ret = recvfrom(sock, (char *)buf, len, flags, from, fromlen);
if (-1 == ret) {
HAGGLE_ERR("Recvfrom failed : %s\n", STRERROR(ERRNO));
}
return ret;
}
bool ResourceMonitorAndroid::run()
{
Watch w;
HAGGLE_DBG("Running resource monitor\n");
if (uevent_init() == -1) {
HAGGLE_ERR("Could not open uevent socket\n");
return false;
}
while (!shouldExit()) {
int ret;
w.reset();
int ueventIndex = w.add(uevent_fd);
ret = w.wait();
if (ret == Watch::ABANDONED) {
break;
} else if (ret == Watch::FAILED) {
HAGGLE_ERR("Wait on objects failed\n");
break;
}
if (w.isSet(ueventIndex)) {
uevent_read();
}
}
return false;
}
bool
ReplicationManagerObjectState::getMatchStrength(string dobj_id, string node_name, int *o_ratio, int *o_threshold)
{
string key = getKey(dobj_id, node_name);
if (!o_ratio) {
HAGGLE_ERR("NULL ratio ptr.\n");
errorCount++;
return false;
}
if (!o_threshold) {
HAGGLE_ERR("NULL threshold ptr.\n");
errorCount++;
return false;
}
// NOTE: data objects with 0 overlap in attributes will not
// show up in the dataObjectIdMatch data structure
int ratio = 0;
int threshold = 0;
Map<string, match>::iterator it = dataObjectIdMatch.find(key);
if (it != dataObjectIdMatch.end()) {
match m = (*it).second;
ratio = m.ratio;
threshold = m.threshold;
}
*o_ratio = ratio;
*o_threshold = threshold;
return true;
}
SOCKET
SocketWrapper::accept(
struct sockaddr *saddr,
socklen_t *addrlen)
{
if (INVALID_SOCKET == sock) {
HAGGLE_ERR("Invalid server socket\n");
return INVALID_SOCKET;
}
if (!saddr || !addrlen) {
HAGGLE_ERR("Invalid address\n");
return INVALID_SOCKET;
}
SOCKET clientsock = ::accept(sock, saddr, addrlen);
if (clientsock == INVALID_SOCKET) {
HAGGLE_ERR("Accept failed : %s\n",
STRERROR(ERRNO));
return INVALID_SOCKET;
}
return clientsock;
}
static bool sendBuffer(SOCKET sock, const void *data, size_t toSend)
{
size_t i = 0;
do {
ssize_t ret = send(sock, (char *)data + i, toSend, 0);
if (ret == -1) {
#if defined(OS_WINDOWS)
if (WSAGetLastError() != WSAEWOULDBLOCK) {
HAGGLE_ERR("Could not write HTTP to socket err=%d\n", ERRNO);
goto out;
}
#else
if (errno != EAGAIN) {
HAGGLE_ERR("Could not write HTTP to socket err=%d\n", errno);
goto out;
}
#endif
} else {
toSend -= ret;
i += ret;
}
} while (toSend > 0);
out:
return toSend == 0;
}
void
ReplicationManagerObjectState::unCacheNode(string node_name)
{
{
Map<string, NodeRef>::iterator it = cachedNodes.find(node_name);
if (it == cachedNodes.end()) {
HAGGLE_ERR("Node is not cached.\n");
errorCount++;
return;
}
NodeRef node = (*it).second;
cachedNodes.erase(it);
string node_id = Node::idString(node);
Map<string, string>::iterator itt = proxy_id_to_node_name.find(node_id);
if (itt == proxy_id_to_node_name.end()) {
HAGGLE_ERR("Proxy id is missing for node: %s\n", node_id.c_str());
errorCount++;
return;
}
proxy_id_to_node_name.erase(itt);
}
{ // synch up the indexes
bool found1 = false;
Map<string, string>::iterator it = nodeIdMatchIndex.find(node_name);
for (; it != nodeIdMatchIndex.end(); it++) {
string matchKey = (*it).second;
nodeIdMatchIndex.erase(it);
found1 = true;
// remove from match
Map<string, match>::iterator ittt = dataObjectIdMatch.find(matchKey);
if (ittt == dataObjectIdMatch.end()) {
HAGGLE_ERR("Key: %s missing from match map\n", matchKey.c_str());
break;
}
dataObjectIdMatch.erase(ittt);
// remove any left over node entries in node index if it's empty now
string dobj_id = dataObjectIdFromKey(matchKey);
bool found2 = false;
//Map<string, string>::iterator itt = dataObjectIdMatchIndex.find(dobj_id);
Map<string, string>::iterator itt = dataObjectIdMatchIndex.begin();
for (; itt != dataObjectIdMatchIndex.end(); itt++) {
if ((*itt).second == matchKey) {
found2 = true;
dataObjectIdMatchIndex.erase(itt);
break;
}
}
if (!found2) {
HAGGLE_ERR("Did not find data object: %s in object index\n", dobj_id.c_str());
errorCount++;
}
}
if (!found1) {
HAGGLE_DBG2("Did not find node: %s in node index\n", node_name.c_str());
}
}
nodesDeleted++;
}
bool
SocketWrapper::openSocket(
int domain,
int type,
int protocol,
bool registersock,
bool nonblock)
{
if (INVALID_SOCKET != sock) {
HAGGLE_ERR("socket already open\n");
return false;
}
sock = ::socket(domain, type, protocol);
if (INVALID_SOCKET == sock) {
HAGGLE_ERR("could not open socket\n");
return false;
}
if (!setNonblock(nonblock)) {
closeSocket();
return false;
}
if (registersock && !registerSocket()) {
closeSocket();
return false;
}
return true;
}
// CBMEN, HL, Begin
int
ReplicationOptimizer::getCost(DataObjectRef dObj, string node_id)
{
int dataLen = 0;
{
dataLen = (int) dObj->getDataLen();
// include metadata size
Metadata *m = dObj->getMetadata();
if (!m) {
errorCount++;
HAGGLE_ERR("Missing metadata.\n");
return 0;
}
dataLen += m->getContent().size();
}
{
node_map_t::iterator it = node_map.find(node_id);
if (it == node_map.end()) {
errorCount++;
HAGGLE_ERR("Missing node: %s\n", node_id.c_str());
return 0;
}
}
return dataLen;
}
int
ReplicationKnapsackOptimizerTiebreakerCreateTime::compare(
ReplicationDataObjectUtilityMetadataRef m1,
ReplicationDataObjectUtilityMetadataRef m2)
{
if (!m1 && !m2) {
HAGGLE_ERR("NULL arguments\n");
return 0;
}
if (!m1) {
HAGGLE_ERR("NULL m1 argument.\n");
return 1;
}
if (!m2) {
HAGGLE_ERR("NULL m2 argument.\n");
return -1;
}
if (m1->getCreateTime() == m2->getCreateTime()) {
return 0;
}
if (m1->getCreateTime() < m2->getCreateTime()) {
return -1;
}
return 1;
}
static RSA *stringToRSAKey(const char *keyStr, KeyType_t type = KEY_TYPE_PUBLIC)
{
RSA *key = NULL;
//HAGGLE_DBG("trying to convert:\n%s\n", keyStr);
BIO *bp = BIO_new_mem_buf(const_cast<char *>(keyStr), -1);
if (!bp) {
HAGGLE_ERR("Could not allocate BIO\n");
return NULL;
}
if (type == KEY_TYPE_PUBLIC) {
if (!PEM_read_bio_RSA_PUBKEY(bp, &key, NULL, NULL)) {
HAGGLE_ERR("Could not read public key from PEM string\n");
}
} else if (type == KEY_TYPE_PRIVATE) {
if (!PEM_read_bio_RSAPrivateKey(bp, &key, NULL, NULL)) {
HAGGLE_ERR("Could not read private key from PEM string\n");
}
}
BIO_free(bp);
return key;
}
Certificate::Certificate(const string& _subject, const string& _issuer, const string& _validity, const Node::Id_t _owner, RSA *_rsaPubKey) :
#ifdef DEBUG_LEAKS
LeakMonitor(LEAK_TYPE_CERTIFICATE),
#endif
stored(false), verified(false), hasSignature(false), x(NULL), subject(_subject), issuer(_issuer), validity(_validity), pubKey(NULL), rsaPubKey(NULL), x509_PEM_str(NULL)
{
memcpy(owner, _owner, sizeof(Node::Id_t));
x = X509_new();
if (!x) {
HAGGLE_ERR("Could not allocate X509 certificate struct\n");
return;
}
X509_set_version(x, 2);
pubKey = EVP_PKEY_new();
if (!pubKey) {
X509_free(x);
HAGGLE_ERR("Could not allocate X509 EVP_PKEY\n");
return;
}
EVP_PKEY_assign_RSA(pubKey, RSAPublicKey_dup(_rsaPubKey));
X509_set_pubkey(x, pubKey);
rsaPubKey = EVP_PKEY_get1_RSA(pubKey);
/* Set validity.
FIXME: currently hardcoded
*/
int days = 30;
X509_gmtime_adj(X509_get_notBefore(x),0);
X509_gmtime_adj(X509_get_notAfter(x),(long)60*60*24*days);
X509_NAME *subject_name = X509_get_subject_name(x);
/* Set subject */
//X509_NAME_add_entry_by_txt(subname,"C", MBSTRING_ASC, "SE", -1, -1, 0);
X509_NAME_add_entry_by_txt(subject_name, "CN", MBSTRING_ASC, (const unsigned char *)subject.c_str(), -1, -1, 0);
X509_NAME_add_entry_by_txt(subject_name, "O", MBSTRING_ASC, (const unsigned char *)"Haggle", -1, -1, 0);
X509_set_subject_name(x, subject_name);
/* Set issuer */
X509_NAME *issuer_name = X509_get_issuer_name(x);
X509_NAME_add_entry_by_txt(issuer_name, "CN", MBSTRING_ASC, (const unsigned char *)issuer.c_str(), -1, -1, 0);
X509_NAME_add_entry_by_txt(issuer_name, "O", MBSTRING_ASC, (const unsigned char *)"Haggle", -1, -1, 0);
X509_set_issuer_name(x, issuer_name);
//HAGGLE_DBG("Subject=\'%s\' issuer=\'%s\'\n", subject.c_str(), issuer.c_str());
certificate_set_serial(x);
}
ProtocolEvent
SocketWrapper::openConnection(
const struct sockaddr *saddr,
socklen_t addrlen)
{
bool wasNonBlock = isNonblock();
if (INVALID_SOCKET == sock) {
HAGGLE_ERR("Socket is invalid\n");
return PROT_EVENT_ERROR;
}
if (!saddr) {
HAGGLE_ERR("Address is invalid\n");
return PROT_EVENT_ERROR;
}
// block while connecting
if (nonblock) {
setNonblock(false);
}
bool hasError = false;
int ret = ::connect(sock, saddr, addrlen);
if (SOCKET_ERROR == ret) {
hasError = true;
HAGGLE_ERR("Problems connecting: %s\n",
SocketWrapper::getProtocolErrorStr());
}
if (wasNonBlock) {
setNonblock(true);
}
if (!hasError) {
HAGGLE_DBG("Succesfully connected to socket.\n");
setConnected(true);
return PROT_EVENT_SUCCESS;
} else {
HAGGLE_DBG("An error occurred connecting: %s\n",
getProtocolErrorStr());
}
switch (getProtocolError()) {
case PROT_ERROR_BAD_HANDLE:
case PROT_ERROR_INVALID_ARGUMENT:
case PROT_ERROR_NO_MEMORY:
case PROT_ERROR_NOT_A_SOCKET:
case PROT_ERROR_NO_STORAGE_SPACE:
return PROT_EVENT_ERROR_FATAL;
default:
return PROT_EVENT_ERROR;
}
}
// each file buffer stores an array of coded blocks
// +-------+------------+-------+------------+-----
// | coeff | coded data | coeff | coded data | ...
// +-------+------------+-------+------------+-----
CodedBlockPtr CodeTorrent::ReadGenBuf(int gen, int k) {
// NOTE: error checking must be done prior to invoking this method!
// (i.e. are there strictly less than k blocks in this file buffer?)
// NOTE: k begins at 0
CodedBlockPtr tempBlock;
tempBlock = AllocCodedBlock(num_blocks_gen[gen], block_size);
tempBlock->gen = gen;
const char *ext = ".temp";
char *ext2 = new char[3]; // what if more than 100 gens?
#ifdef WIN32
itoa(gen, ext2, 10); // base : 10
#else
sprintf(ext2, "%d", gen);
#endif
int fname_len = strlen(filename);
int ext_len = strlen(ext);
int ext2_len = strlen(ext2);
// this is dumb but works
char *filename_read = new char[fname_len + ext_len + ext2_len + 1];
memcpy(filename_read, filename, fname_len);
memcpy(filename_read + fname_len, ext, ext_len);
memcpy(filename_read + fname_len + ext_len, ext2, ext2_len);
filename_read[fname_len + ext_len + ext2_len] = '\0';
fp = fopen(filename_read, "rb");
if(fp) HAGGLE_DBG2("Opening file %s for writing with file descriptor %d\n", filename_read, fileno(fp));
if (!fp) {
HAGGLE_ERR("CODETORRENT ERROR: cache access error!\n");
}
if (fseek(fp, (num_blocks_gen[gen] + block_size) * k, SEEK_SET)) {
HAGGLE_ERR("CODETORRENT ERROR: cache access error!\n");
}
int cf = fread(tempBlock->coeffs, 1, num_blocks_gen[gen], fp);
int sm = fread(tempBlock->sums, 1, block_size, fp);
if (cf != num_blocks_gen[gen] || sm != block_size) {
HAGGLE_ERR("CODETORRENT ERROR: cache reading error!\n");
}
fclose(fp);
delete[] filename_read;
delete[] ext2;
return tempBlock;
}
void
CachePurgerRelTTL::onConfig(
const Metadata& m)
{
if (m.getName() != getName()) {
HAGGLE_ERR("Wrong config.\n");
return;
}
const char *param;
param = m.getParameter(CACHE_PURGER_REL_TTL_METRIC);
if (!param) {
HAGGLE_ERR("No metric specified\n");
return;
}
metricField = string(param);
param = m.getParameter(CACHE_PURGER_REL_TTL_TAG);
if (!param) {
HAGGLE_ERR("No tag specified\n");
return;
}
tagField = string(param);
param = m.getParameter(CACHE_PURGER_REL_TTL_TAG_VALUE);
if (!param) {
HAGGLE_ERR("No tag value specified\n");
return;
}
tagFieldValue = string(param);
param = m.getParameter(CACHE_PURGER_REL_TTL_KEEP_IN_BF_NAME);
if (param) {
if (0 == strcmp("true", param)) {
keepInBF = true;
}
else if (0 == strcmp("false", param)) {
keepInBF = false;
}
else {
HAGGLE_ERR("Field must be true or false\n");
}
}
param = m.getParameter(CACHE_PURGER_REL_TTL_MIN_DB_TIME_S);
if (param) {
minDBtimeS = atof(param);
}
HAGGLE_DBG("Loaded relative TTL purger with metric: %s, tag=%s:%s, keep in bf: %s, min db time: %f\n",
metricField.c_str(), tagField.c_str(), tagFieldValue.c_str(), keepInBF ? "true" : "false", minDBtimeS);
}
/*
* Helper to return the top K data objects in the cache, according to
* a specified sort function. Mainly used for statistics repoorting.
*/
void
PrintHelperHeapItem::getTopKHelper(
int K,
PrinterHelperType_t type,
do_util_metadata_t utilMetadata,
do_util_metadata_list_t *o_top10)
{
if (!o_top10) {
HAGGLE_ERR("NULL output list\n");
return;
}
Heap Kheap;
int k_count = 0;
for (do_util_metadata_t::iterator it = utilMetadata.begin();
it != utilMetadata.end(); it++) {
DataObjectUtilityMetadata *do_info = (*it).second;
if (!do_info) {
HAGGLE_ERR("NULL do metadata in map\n");
continue;
}
PrintHelperHeapItem *ele = new PrintHelperHeapItem(type, do_info);
PrintHelperHeapItem *top = static_cast<PrintHelperHeapItem *>(Kheap.front());
if (k_count++ < K) {
Kheap.insert(ele);
}
else if (!top) {
HAGGLE_ERR("Somehow popped NULL heap element\n");
}
else if (top->getMetric() < ele->getMetric()) {
Kheap.extractFirst();
Kheap.insert(ele);
delete top;
}
else {
delete ele;
}
}
while (!Kheap.empty()) {
PrintHelperHeapItem *heap_item =
static_cast<PrintHelperHeapItem *>(Kheap.extractFirst());
if (!heap_item) {
HAGGLE_ERR("NULL heap item\n");
continue;
}
DataObjectUtilityMetadata *do_meta = heap_item->getMetadata();
if (!do_meta) {
HAGGLE_ERR("NULL data object metadata\n");
continue;
}
o_top10->push_front(do_meta);
delete heap_item;
}
}
bool ProtocolRFCOMM::initbase()
{
struct sockaddr_bt localAddr;
if (isConnected()) {
// Nothing to do
return true;
}
if (!openSocket(AF_BLUETOOTH, SOCK_STREAM, BTPROTO_RFCOMM, isServer())) {
HAGGLE_ERR("Could not create RFCOMM socket\n");
return false;
}
memset(&localAddr, 0, sizeof(struct sockaddr_bt));
localAddr.bt_family = AF_BLUETOOTH;
localAddr.bt_channel = channel & 0xff;
#ifndef OS_WINDOWS
if (localIface) {
BluetoothAddress *addr = localIface->getAddress<BluetoothAddress>();
if (addr) {
// Binding RFCOMM sockets to a hardware address does not
// seem to work in Windows
BDADDR_swap(&localAddr.bt_bdaddr, addr->getRaw());
}
}
#endif
if (isServer()) {
localAddr.bt_channel = channel & 0xff;
/* If this is a server we bing to a specific channel to listen on */
if (!bind((struct sockaddr *)&localAddr, sizeof(localAddr))) {
closeSocket();
#ifdef OS_WINDOWS
HAGGLE_ERR("Bind failed for local address WSA error=%s\n", StrError(WSAGetLastError()));
#endif
HAGGLE_ERR("Could not bind local address for RFCOMM socket\n");
return false;
}
HAGGLE_DBG("Bound RFCOMM server to channel=%d\n", channel);
} else {
HAGGLE_DBG("Created RFCOMM client on channel=%d\n", channel);
}
return true;
}
void deleteCallback(Event *e)
{
if (!e || !purger) {
HAGGLE_ERR("No event to delete callback\n");
return;
}
DataObjectRef dObj = e->getDataObject();
if (!dObj) {
HAGGLE_ERR("No data object\n");
return;
}
kernel->getDataStore()->deleteDataObject(dObj, purger->getKeepInBloomfilter());
}
// SW: START: remove from local bloomfilter.
void
CacheStrategyUtility::onBloomfilterRemoveDelay(Event *e)
{
if (!e || !e->hasData()) {
HAGGLE_ERR("No data.\n");
return;
}
DataObjectId_t *heapId = (DataObjectId_t *)e->getData();
if (!heapId) {
HAGGLE_ERR("NULL dObj heap id.\n");
return;
}
getManager()->removeFromLocalBF(*heapId);
free(heapId);
}
ProtocolEvent ProtocolUDPGeneric::sendData(
const void *buf,
size_t len,
const int flags,
size_t *bytes)
{
*bytes = 0;
int signed_size = static_cast<int>(len);
if (signed_size <= 0) {
HAGGLE_ERR("%s Cannot send file of invalid length %d\n", getName(), signed_size);
return PROT_EVENT_ERROR_FATAL;
}
size_t newLength = len + sizeof(udpmsg_t);
void *newBuff = malloc(newLength);
bzero(newBuff, newLength);
udpmsg_t *header = (udpmsg_t *)newBuff;
memcpy(header->session_no, nextSendSessionNo, sizeof(DataObjectId_t));
header->seq_no = nextSendSeqNo;
header->src_ip = srcIP;
header->dest_ip = destIP;
if (NULL == memcpy((void *)&(((char *)newBuff)[sizeof(udpmsg_t)]), buf, len)) {
HAGGLE_ERR("%s Could not create new buffer\n", getName());
return PROT_EVENT_ERROR_FATAL;
}
HAGGLE_DBG2("%s Sending packet with session no %s, sequence no %d, and size %d\n",
getName(),
DataObject::idString(nextSendSessionNo).c_str(),
nextSendSeqNo,
len);
ProtocolEvent pEvent;
ssize_t sbytes;
pEvent = sendHook(newBuff, newLength, flags, &sbytes);
if (sbytes < 0) {
free(newBuff);
return PROT_EVENT_ERROR;
}
*bytes = static_cast<size_t>(sbytes) - sizeof(udpmsg_t);
free(newBuff);
return pEvent;
}
ReplicationOptimizer::~ReplicationOptimizer()
{
if (knapsack) {
delete knapsack;
}
if (utilFunction) {
delete utilFunction;
}
if (globalOptimizer) {
delete globalOptimizer;
}
// remove the utility cache entries
for (meta_map_t::iterator it = meta.begin(); it != meta.end(); it++) {
ReplicationDataObjectUtilityMetadataRef do_info = (*it).second;
meta.erase(it);
if (!do_info) {
errorCount++;
HAGGLE_ERR("NULL meta.\n");
continue;
}
}
for (dobj_id_map_t::iterator it = dobjs.begin(); it != dobjs.end(); it++) {
dobjs.erase(it);
}
for (neighbor_node_id_map_t::iterator it = utils.begin(); it != utils.end(); it++) {
utils.erase(it);
}
}
bool Certificate::verifySignature(RSA *key)
{
bool res = false;
if (!key)
return false;
if (verified)
return true;
EVP_PKEY *pkey = EVP_PKEY_new();
if (!pkey) {
HAGGLE_ERR("Could not allocate EVP_PKEY\n");
writeErrors("");
return false;
}
EVP_PKEY_set1_RSA(pkey, key);
res = verifySignature(pkey);
EVP_PKEY_free(pkey);
return res;
}
bool ProtocolManager::registerProtocol(Protocol *p)
{
protocol_registry_t::iterator it;
if (!p)
return false;
// We are in shutdown, so do not accept this protocol to keep running.
if (getState() > MANAGER_STATE_RUNNING) {
p->shutdown();
if (!p->isDetached()) {
p->join();
HAGGLE_DBG("Joined with protocol %s\n", p->getName());
}
return false;
}
if (protocol_registry.insert(make_pair(p->getId(), p)).second == false) {
HAGGLE_ERR("Protocol %s already registered!\n", p->getName());
return false;
}
p->setRegistered();
HAGGLE_DBG("Protocol %s registered\n", p->getName());
return true;
}
bool SecurityHelper::verifyDataObject(DataObjectRef& dObj, CertificateRef& cert) const
{
RSA *key;
// Cannot verify without signature
if (!dObj->getSignature()) {
HAGGLE_ERR("No signature in data object, cannot verify\n");
return false;
}
writeErrors("(not this): ");
key = cert->getPubKey();
if (RSA_verify(NID_sha1, dObj->getId(), sizeof(DataObjectId_t),
const_cast<unsigned char *>(dObj->getSignature()), dObj->getSignatureLength(), key) != 1) {
char *raw;
size_t len;
writeErrors("");
dObj->getRawMetadataAlloc((unsigned char **)&raw, &len);
if (raw) {
HAGGLE_DBG("Signature is invalid:\n%s\n", raw);
free(raw);
}
dObj->setSignatureStatus(DataObject::SIGNATURE_INVALID);
return false;
}
HAGGLE_DBG("Signature is valid\n");
dObj->setSignatureStatus(DataObject::SIGNATURE_VALID);
return true;
}
bool SecurityHelper::run()
{
HAGGLE_DBG("SecurityHelper running...\n");
while (!shouldExit()) {
QueueEvent_t qe;
SecurityTask *task = NULL;
qe = taskQ.retrieve(&task);
switch (qe) {
case QUEUE_ELEMENT:
doTask(task);
// Delete task here or return it with result in private event?
//delete task;
break;
case QUEUE_WATCH_ABANDONED:
HAGGLE_DBG("SecurityHelper instructed to exit...\n");
return false;
default:
HAGGLE_ERR("Unknown security task queue return value\n");
}
}
return false;
}
bool
SocketWrapper::multiplySndBufferSize(int factor)
{
bool res = false;
#if defined(OS_LINUX)
int ret = 0;
long optval = 0;
socklen_t optlen = sizeof(optval);
ret = ::getsockopt(sock, SOL_SOCKET, SO_SNDBUF, &optval, &optlen);
if (-1 == ret) {
return res;
}
HAGGLE_DBG("Original send buffer set to %ld bytes\n", optval);
optval = optval * factor;
ret = ::setsockopt(sock, SOL_SOCKET, SO_SNDBUF, &optval, optlen);
if (-1 == ret) {
HAGGLE_ERR("Could not set send buffer to %ld bytes\n", optval);
} else {
HAGGLE_DBG("Send buffer set to %ld bytes\n", optval);
res = true;
}
#endif
return res;
}
ProtocolEvent
SocketWrapper::sendData(
const void *buf,
size_t len,
const int flags,
ssize_t *bytes)
{
*bytes = 0;
if (!isConnected()) {
HAGGLE_ERR("Not connected\n");
return PROT_EVENT_ERROR;
}
ssize_t ret;
ret = send(sock, (const char *)buf, len, flags);
if (0 > ret) {
return PROT_EVENT_ERROR;
}
if (0 == ret) {
return PROT_EVENT_PEER_CLOSED;
}
*bytes = ret;
return PROT_EVENT_SUCCESS;
}
void SecurityManager::onConfig(Metadata *m)
{
const char *param = m->getParameter("security_level");
if (param) {
char *level = new char[strlen(param) + 1];
size_t i;
// Convert string to uppercase
for (i = 0; i < strlen(param); i++) {
level[i] = toupper(param[i]);
}
level[i] = '\0';
if (strcmp(level, security_level_names[SECURITY_LEVEL_HIGH]) == 0) {
securityLevel = SECURITY_LEVEL_HIGH;
HAGGLE_DBG("Security level set to %s\n", security_level_names[SECURITY_LEVEL_HIGH]);
} else if (strcmp(level, security_level_names[SECURITY_LEVEL_MEDIUM]) == 0) {
securityLevel = SECURITY_LEVEL_MEDIUM;
HAGGLE_DBG("Security level set to %s\n", security_level_names[SECURITY_LEVEL_MEDIUM]);
} else if (strcmp(level, security_level_names[SECURITY_LEVEL_LOW]) == 0) {
securityLevel = SECURITY_LEVEL_LOW;
HAGGLE_DBG("Security level set to %s\n", security_level_names[SECURITY_LEVEL_LOW]);
} else {
HAGGLE_ERR("Unrecognized security level '%s'\n", level);
}
delete [] level;
}
}
