自学教程：C++ HAGGLE_ERR函数代码示例

voidReplicationOptimizer::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;}

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;}

boolReplicationManagerObjectState::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;}

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;}

voidReplicationManagerObjectState::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++;}

// CBMEN, HL, BeginintReplicationOptimizer::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_LEAKSLeakMonitor(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);}

ProtocolEventSocketWrapper::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());    }

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;}

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;}

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;	}}