CPointer CObjects::Get(char* szObjectName)
{
CBaseObject* pvObject;
CPointer pObject;
pvObject = GetFromMemory(szObjectName);
if (pvObject)
{
pObject.AssignObject(pvObject);
return pObject;
}
pvObject = GetFromDatabase(szObjectName);
if (pvObject)
{
pObject.AssignObject(pvObject);
return pObject;
}
pvObject = GetFromSources(szObjectName);
if (pvObject)
{
pObject.AssignObject(pvObject);
return pObject;
}
return Null();
}
void CKadHandler::HandleNodeRes(const CVariant& NodeRes, CKadNode* pNode, CComChannel* pChannel)
{
if(GetParent<CKademlia>()->Cfg()->GetBool("DebugRT"))
LogLine(LOG_DEBUG, L"Recived 'Node Response' from %s", pNode->GetID().ToHex().c_str());
CVariant List = NodeRes["LIST"];
if(List.Count() > (uint32)GetParent<CKademlia>()->Cfg()->GetInt("NodeReqCount"))
throw CException(LOG_ERROR, L"Node returned more nodes than requested (spam)");
SKadData* pData = pChannel->GetData<SKadData>();
// Note: if pData->pLookup is NULL this was just a bootstrap request
NodeMap Nodes;
for(uint32 i = 0; i<List.Count(); i++)
{
CPointer<CKadNode> pNewNode = new CKadNode(GetParent<CKademlia>()->Root());
pNewNode->Load(List.At(i));
if(GetParent<CKademlia>()->Root()->AddNode(pNewNode) && pData->pLookup)
{
CUInt128 uDistance = pData->pLookup->GetID() ^ pNewNode->GetID();
Nodes.insert(NodeMap::value_type(uDistance, pNewNode));
}
}
if(pData->pLookup)
GetParent<CKademlia>()->Manager()->AddNodes(pData->pLookup, pNode, pChannel, Nodes);
}
void TestObjectsFlushClearGetByName(void)
{
CFileUtil cFileUtil;
CPointer pObject;
Ptr<CTestDoubleNamedString> pDouble;
Ptr<CRoot> pRoot;
cFileUtil.RemoveDir("Output");
cFileUtil.MakeDir("Output/Dehollowfication");
ObjectsInit("Output/Dehollowfication");
SetupObjectsConstructors();
pRoot = ORoot();
pDouble = ONMalloc(CTestDoubleNamedString, "Double")->Init();
pRoot->Add(pDouble);
AssertLongLongInt(0, gcObjects.NumDatabaseObjects());
AssertLongLongInt(0, gcObjects.NumDatabaseNames());
pObject = gcObjects.Get(3);
AssertNotNull(pObject.Object());
AssertString("CTestDoubleNamedString", pObject.ClassName());
gcObjects.Flush(TRUE, TRUE);
AssertLongLongInt(3, gcObjects.NumDatabaseObjects());
AssertLongLongInt(2, gcObjects.NumDatabaseNames());
pObject = gcObjects.Get("Double");
AssertNotNull(pObject.Object());
AssertString("CTestDoubleNamedString", pObject.ClassName());
ObjectsKill();
}
CPointer CObjects::TestGetFromMemory(OIndex oi)
{
CPointer pObject;
pObject.AssignObject(GetFromMemory(oi));
return pObject;
}
CPointer CObjects::TestGetFromMemory(char* szName)
{
CPointer pObject;
pObject.AssignObject(GetFromMemory(szName));
return pObject;
}
uint32 CKademlia::LoadNodes()
{
wstring ConfigPath = Cfg()->GetString("ConfigPath");
if(ConfigPath.empty())
return 0;
uint32 Count = 0;
try
{
CVariant NeoNodes;
ReadFile(ConfigPath + L"NeoNodes.dat", NeoNodes);
const CVariant& NodeList = NeoNodes["Nodes"];
for(uint32 i=0; i < NodeList.Count(); i++)
{
CPointer<CKadNode> pNode = new CKadNode(m_pRootZone);
pNode->Load(NodeList.At(i), true);
if(pNode->GetAddresses().empty())
continue;
Count++;
m_pRootZone->AddNode(pNode);
}
m_pKadHandler->SetLastContact(NeoNodes["LastContact"]);
}
catch(const CException&)
{
ASSERT(0);
}
return Count;
}
void TestObjectDehollowfication(void)
{
CFileUtil cFileUtil;
CPointer pPointer;
CTestDoubleNamedString* pcInternal;
Ptr<CTestDoubleNamedString> pDouble;
Ptr<CTestNamedString> pSingle;
int iClassSize;
OIndex oiOld;
OIndex oiNew;
cFileUtil.RemoveDir("Output");
cFileUtil.MakeDir("Output/Dehollowfication");
ObjectsInit("Output/Dehollowfication");
SetupObjectsForDehollowfication();
gcObjects.Flush(TRUE, TRUE);
AssertLongLongInt(9, gcObjects.NumDatabaseObjects());
ObjectsKill();
ObjectsInit("Output/Dehollowfication");
SetupObjectsConstructors();
AssertLongLongInt(9, gcObjects.NumDatabaseObjects());
AssertTrue(gcObjects.Contains("Double"));
pPointer = gcObjects.Get("Double");
AssertNotNull(pPointer.Object());
AssertString("CTestDoubleNamedString", pPointer.ClassName());
pcInternal = (CTestDoubleNamedString*)pPointer.Object();
AssertTrue(pcInternal->mpSplit1.IsNotNull());
AssertTrue(pcInternal->mpSplit1.IsHollow());
AssertTrue(pcInternal->mpSplit2.IsNotNull());
AssertTrue(pcInternal->mpSplit2.IsHollow());
pDouble = pPointer;
oiOld = pDouble->mpSplit1.GetIndex();
AssertTrue(pcInternal->mpSplit1.IsHollow()); //Making sure we haven't de-hollowed the object by calling GetIndex.
//Problem - An oi of 1 is briefly assigned to the de-hollowed object and then it is reassigned back to its original value.
iClassSize = pDouble->mpSplit1->ClassSize(); //The method call - ClassSize() - is irrelevant as long as the -> operator on mpSplit1 is invoked.
AssertTrue(pcInternal->mpSplit1.IsNotNull());
AssertFalse(pcInternal->mpSplit1.IsHollow());
AssertInt(sizeof(CTestNamedString), iClassSize);
AssertString("CTestNamedString", pcInternal->mpSplit1.ClassName());
oiNew = pDouble->mpSplit1.GetIndex();
AssertLongLongInt(oiOld, oiNew);
pSingle = pDouble->mpSplit2;
AssertTrue(pcInternal->mpSplit2.IsNotNull());
AssertTrue(pcInternal->mpSplit2.IsHollow());
ObjectsKill();
}
void TestObjectReaderSimpleDeserialised(void)
{
WriteObjectReaderSimpleFile();
CObjectReaderSimpleDisk cReader;
CObjectGraphDeserialiser cGraphDeserialiser;
CPointer cBase;
Ptr<CTestNamedString> cNS1;
Ptr<CTestNamedString> cNS2;
CPointer cTemp;
CObjectAllocator cAllocator;
CDependentReadObjects cDependentReadObjects;
MemoryInit();
ObjectsInit();
gcObjects.AddConstructor<CTestNamedString>();
AssertLongLongInt(0, gcObjects.NumDatabaseObjects());
AssertLongLongInt(0, gcObjects.NumMemoryIndexes());
cAllocator.Init(&gcObjects);
cDependentReadObjects.Init();
cReader.Init("Output\\ObjectReaderSimple\\Test\\");
cGraphDeserialiser.Init(&cReader, FALSE, &cAllocator, &cDependentReadObjects, gcObjects.GetMemory());
cBase = cGraphDeserialiser.Read("Waggy");
AssertLongLongInt(0, gcObjects.NumDatabaseObjects());
AssertLongLongInt(2, gcObjects.NumMemoryIndexes());
cNS1 = gcObjects.Get("Waggy");
AssertTrue(cNS1.IsNotNull());
AssertString("NS1", cNS1->mszEmbedded.Text());
cNS2 = gcObjects.Get("Dog");
AssertTrue(cNS2.IsNotNull());
AssertString("NS2", cNS2->mszEmbedded.Text());
AssertTrue(cBase.IsNotNull());
AssertString("CTestNamedString", cBase->ClassName());
AssertPointer(&cNS1, &cBase);
AssertPointer(&cNS2, &cNS1->mpAnother);
AssertPointer(NULL, &cNS2->mpAnother);
cGraphDeserialiser.Kill();
cDependentReadObjects.Kill();
cAllocator.Kill();
cReader.Kill();
ObjectsKill();
}
CPointer* CBinaryFile::FindPointer(object oIdentifier, int iOffset, unsigned int iLevel)
{
CPointer* ptr = FindAddress(oIdentifier);
if (ptr->IsValid())
{
ptr->m_ulAddr += iOffset;
while (iLevel > 0)
{
ptr = ptr->GetPtr();
iLevel = iLevel - 1;
}
}
return ptr;
}
void CKadHandler::HandleRouteReq(const CVariant& RouteReq, CKadNode* pNode, CComChannel* pChannel)
{
if(GetParent<CKademlia>()->Cfg()->GetBool("DebugRU"))
LogLine(LOG_DEBUG, L"Recived 'Route Resuest' from %s", pNode->GetID().ToHex().c_str());
CVariant RouteRes(CVariant::EMap);
SKadData* pData = pChannel->GetData<SKadData>();
CPointer<CKadRelay> pRelay = pData->pLookup->Cast<CKadRelay>();
if(!pRelay)
{
if(!RouteReq.Has("TID")) // this is optional it is not send on a refresn
throw CException(LOG_ERROR, L"Invalid Lookup Request");
if(pData->pLookup)
throw CException(LOG_ERROR, L"Recived Route Resuest for a lookup that is not a CKadRelay");
CLookupManager* pLookupManager = GetParent<CKademlia>()->Manager();
pRelay = pLookupManager->GetRelayEx(RouteReq["EID"], RouteReq["TID"]); // find already existing relay for this Entity and target combination
//ASSERT(pRelay == pLookupManager->GetLookup(RouteReq["LID"])->Cast<CKadRelay>()); // lookup ID should be consistent
if(!pRelay)
{
pRelay = new CKadRelay(RouteReq["TID"], pLookupManager);
if(pRelay->InitRelay(RouteReq)) // if false it means the lookup is invalid
{
pRelay->SetHopLimit(RouteReq.Get("JMPS"));
pRelay->SetJumpCount(RouteReq.Get("HOPS"));
pRelay->SetBrancheCount(RouteReq.Get("BRCH"));
pRelay->SetLookupID(RouteReq["LID"]);
pLookupManager->StartLookup(pRelay.Obj());
if(RouteReq.Has("TRACE"))
pRelay->EnableTrace();
}
}
// For this cahnnel the relay was new, setup BC
pData->pLookup = CPointer<CKadLookup>(pRelay, true); // weak pointer
pChannel->AddUpLimit(pData->pLookup->GetUpLimit());
pChannel->AddDownLimit(pData->pLookup->GetDownLimit());
}
string Error = pRelay->AddDownLink(pNode, pChannel); // add or update
if(!Error.empty())
RouteRes["ERR"] = Error;
if(GetParent<CKademlia>()->Cfg()->GetBool("DebugRU"))
LogLine(LOG_DEBUG, L"Sending 'Route Response' to %s", pNode->GetID().ToHex().c_str());
pChannel->QueuePacket(KAD_ROUTE_RESPONSE, RouteRes);
}
int WriteObjectReaderChunkedFile(void)
{
CPointer cBase;
CObjectWriterChunked cWriter;
CObjectGraphSerialiser cGraphSerialiser;
cBase = SetupObjectReaderChunkedChunkFile();
cWriter.Init("Output\\ObjectReaderChunked\\Test\\", "", "Reader");
cGraphSerialiser.Init(&cWriter);
AssertTrue(cGraphSerialiser.Write(cBase.BaseObject()));
cGraphSerialiser.Kill();
cWriter.Kill();
return (int)gcObjects.NumMemoryIndexes();
}
CPointer<CJSScript> CKadScript::MakeScript(const string& Source, const wstring& Name, uint32 Version)
{
CPointer<CJSScript> pScript = new CJSScript(this);
CDebugScope Debug(this); // this may origined with a operation but is a global event
wstring FileName = ToHex(m_CodeID.GetData(), m_CodeID.GetSize()) + L"/" + Name;
map<string, CObject*> Objects;
Objects["debug"] = new CDebugObj(FileName + L"-v" + GetVersion(Version), LineLogger, this);
Objects["kademlia"] = GetParent<CKademlia>();
Objects["script"] = this;
if(CBinaryCache* pCache = GetParent<CKademlia>()->Engine()->GetCache())
Objects["cache"] = pCache;
wstring wSource;
Utf8ToWStr(wSource, Source);
pScript->Initialize(wSource, FileName, Objects); // this can fron a CException
return pScript;
}
CPointer CObjects::Get(OIndex oi)
{
CBaseObject* pvObject;
CPointer pObject;
pvObject = mcMemory.Get(oi);
if (pvObject)
{
pObject.AssignObject(pvObject);
return pObject;
}
pvObject = GetFromDatabase(oi);
if (pvObject)
{
pObject.AssignObject(pvObject);
return pObject;
}
return Null();
}
void WriteObjectReaderSimpleFile(void)
{
MemoryInit();
ObjectsInit();
gcObjects.AddConstructor<CTestNamedString>();
CPointer cBase;
CObjectWriterSimple cWriter;
CObjectGraphSerialiser cGraphSerialiser;
cBase = SetupObjectReaderSimpleFile();
cWriter.Init("Output\\ObjectReaderSimple\\Test\\", "");
cGraphSerialiser.Init(&cWriter);
AssertTrue(cGraphSerialiser.Write(cBase.BaseObject()));
cGraphSerialiser.Kill();
cWriter.Kill();
ObjectsKill();
MemoryKill();
}
void CKadHandler::ResumeExchange(CPointer<CKadNode> pNode)
{
TExchangeMap::iterator X = m_KeyExchanges.find(SKadNode(pNode));
if(CTrustedKey* pTrustedKey = pNode->GetTrustedKey())
{
TExchangeMap::iterator I = X;
X = m_KeyExchanges.end();
for(; I != m_KeyExchanges.end() && I->first.pNode == pNode; I++) // for each exchange for this node
{
if(I->second.pExchange)
continue;
if(pTrustedKey->IsAuthenticated() || !I->second.bAuthenticate) // the key we know is eider authenticated or we dont need authentication
SendCryptoRequest(I->first.pNode, I->first.pChannel, &I->second, pTrustedKey); // try to activate this key
else if(X == m_KeyExchanges.end())
X = I;
}
}
if(X != m_KeyExchanges.end() && X->second.pExchange == NULL)
SendCryptoRequest(X->first.pNode, X->first.pChannel, &X->second, NULL);
}
CVariant CKademlia::SetupRoute(const CUInt128& TargetID, CPrivateKey* pEntityKey, int HopLimit, int JumpCount, bool bTrace)
{
if(!m_pKadHandler)
return CVariant();
CPointer<CKadRoute> pRoute = new CKadRouteImpl(TargetID, pEntityKey, m_pLookupManager);
if(HopLimit != -1)
pRoute->SetHopLimit(HopLimit);
if(JumpCount != -1)
pRoute->SetJumpCount(JumpCount);
if(bTrace)
pRoute->EnableTrace();
if(CKadRoute* pOldRoute = m_pLookupManager->GetRelay(pRoute->GetEntityID())->Cast<CKadRoute>())
m_pLookupManager->StopLookup(pOldRoute);
m_pLookupManager->StartLookup(pRoute.Obj());
return pRoute->GetEntityID();
}
void TestObjectReaderChunkedDeserialised(void)
{
CObjectReaderChunkFileDisk cReader;
CObjectGraphDeserialiser cGraphDeserialiser;
CPointer cBase;
Ptr<CTestWithArray> cA1;
Ptr<CTestWithArray> cA2;
Ptr<CTestNamedString> cNS1;
Ptr<CTestNamedString> cNS2;
Ptr<CTestNamedString> cNS3;
Ptr<CTestNamedString> cNS4;
Ptr<CString> sz1;
Ptr<CString> sz2;
Ptr<CString> sz3;
CPointer cTemp;
Ptr<CTestInteger> cI1;
Ptr<CTestInteger> cI2;
Ptr<CTestInteger> cI3;
CObjectAllocator cAllocator;
CDependentReadObjects cDependentReadObjects;
OIndex oiI1;
OIndex oiI2;
OIndex oiI3;
int iNumMemoryIndexes;
gcObjects.AddConstructor<CTestWithArray>();
gcObjects.AddConstructor<CTestInteger>();
gcObjects.AddConstructor<CTestNamedString>();
gcObjects.AddConstructor<CString>();
gcObjects.AddConstructor<CArrayObject>();
iNumMemoryIndexes = WriteObjectReaderChunkedFile();
AssertLongLongInt(0, gcObjects.NumDatabaseObjects());
AssertLongLongInt(14, iNumMemoryIndexes);
ObjectsKill();
ObjectsInit();
gcObjects.AddConstructor<CTestWithArray>();
gcObjects.AddConstructor<CTestInteger>();
gcObjects.AddConstructor<CTestNamedString>();
gcObjects.AddConstructor<CString>();
gcObjects.AddConstructor<CArrayObject>();
AssertLongLongInt(0, gcObjects.NumDatabaseObjects());
AssertLongLongInt(0, gcObjects.NumMemoryIndexes());
cAllocator.Init(&gcObjects);
cDependentReadObjects.Init();
cReader.Init("Output\\ObjectReaderChunked\\Test\\", "Reader");
cGraphDeserialiser.Init(&cReader, FALSE, &cAllocator, &cDependentReadObjects, gcObjects.GetMemory());
cBase = cGraphDeserialiser.Read("Array 1");
AssertTrue(cBase.IsNotNull());
AssertString("CTestWithArray", cBase.ClassName());
AssertLongLongInt(0, gcObjects.NumDatabaseObjects());
AssertLongLongInt(14, gcObjects.NumMemoryIndexes());
cA1 = gcObjects.Get("Array 1");
AssertTrue(cA1.IsNotNull());
AssertString("CTestWithArray", cA1->ClassName());
AssertString("Something with One", cA1->mszString.Text());
AssertInt(1, cA1->mx);
AssertPointer(cBase.Object(), cA1.Object());
cA2 = gcObjects.Get("Array X");
AssertTrue(cA2.IsNotNull());
AssertString("CTestWithArray", cA2.ClassName());
AssertString("An with 2", cA2->mszString.Text());
AssertInt(2, cA2->mx);
cNS1 = gcObjects.Get("NamedString 1");
AssertTrue(cNS1.IsNotNull());
AssertString("CTestNamedString", cNS1->ClassName());
AssertString("In Named 1", cNS1->mszEmbedded.Text());
cNS2 = gcObjects.Get("NamedString 2");
AssertTrue(cNS2.IsNotNull());
AssertString("CTestNamedString", cNS2->ClassName());
AssertString("Another in 2", cNS2->mszEmbedded.Text());
cNS3 = gcObjects.Get("NamedString 3");
AssertTrue(cNS3.IsNotNull());
AssertString("CTestNamedString", cNS3->ClassName());
AssertString("Three", cNS3->mszEmbedded.Text());
cNS4 = gcObjects.Get("NamedString 4");
AssertTrue(cNS4.IsNotNull());
AssertTrue(cBase.IsNotNull());
AssertString("CTestWithArray", cBase->ClassName());
AssertPointer(&cA1, &cBase);
AssertNotNull(&cA1->mcArray);
AssertInt(6, cA1->mcArray->NumElements())
sz2 = cA1->mcArray->Get(0);
AssertString("Ye!", sz2->Text());
cTemp = cA1->mcArray->Get(1);
AssertPointer(&cNS1, &cTemp);
oiI1 = cGraphDeserialiser.GetNewIndexFromOld(5LL);
oiI2 = cGraphDeserialiser.GetNewIndexFromOld(6LL);
oiI3 = cGraphDeserialiser.GetNewIndexFromOld(7LL);
cI1 = gcObjects.Get(oiI1);
AssertString("CTestInteger", cI1->ClassName());
cI2 = gcObjects.Get(oiI2);
AssertString("CTestInteger", cI2->ClassName());
cI3 = gcObjects.Get(oiI3);
AssertString("CTestInteger", cI3->ClassName());
AssertInt(3, cI1->mx);
AssertInt(2, cI1->my);
AssertInt(1, cI1->mz);
AssertPointer(&cNS2, &cNS1->mpAnother);
AssertPointer(&cI1, &cA1->mcArray->Get(2));
AssertPointer(&cNS3, &cA1->mcArray->Get(3));
AssertPointer(&cNS1, &cNS3->mpAnother);
AssertPointer(&cI2, &cA1->mcArray->Get(4));
AssertPointer(&cA2, &cA1->mcArray->Get(5));
AssertNotNull(&cA2->mcArray);
AssertInt(4, cA2->mcArray->NumElements());
AssertPointer(&cI3, &cA2->mcArray->Get(0));
AssertPointer(&cNS2, &cA2->mcArray->Get(1));
AssertPointer(&cNS3, &cNS2->mpAnother);
AssertPointer(&cI1, &cA2->mcArray->Get(2));
AssertPointer(&cNS4, &cA2->mcArray->Get(3));
AssertPointer(NULL, &cNS4->mpAnother);
AssertPointer(NULL, &cNS4->mszString);
cGraphDeserialiser.Kill();
cDependentReadObjects.Kill();
cAllocator.Kill();
cReader.Kill();
}
CPointer* CBinaryFile::FindSignature(object oSignature)
{
unsigned char* sigstr = (unsigned char *) PyBytes_AsString(oSignature.ptr());
if (!sigstr)
BOOST_RAISE_EXCEPTION(PyExc_ValueError, "Failed to read the given signature.");
// Search for a cached signature
PythonLog(4, "Searching for a cached signature...");
for (std::list<Signature_t>::iterator iter=m_Signatures.begin(); iter != m_Signatures.end(); iter++)
{
Signature_t sig = *iter;
if (strcmp((const char *) sig.m_szSignature, (const char *) sigstr) == 0)
{
PythonLog(4, "Found a cached signature!");
return new CPointer(sig.m_ulAddr);
}
}
PythonLog(4, "Could not find a cached signature. Searching in the binary...");
// Search for a signature in the binary
int iLength = len(oSignature);
CPointer* pPtr = FindSignatureRaw(oSignature);
// Found the signature?
if (pPtr->IsValid())
{
PythonLog(4, "Found a signature in the binary!");
// Add the signature to the cache
Signature_t sig_t = {new unsigned char[iLength+1], pPtr->m_ulAddr};
strcpy((char*) sig_t.m_szSignature, (char*) sigstr);
m_Signatures.push_back(sig_t);
// Return the result
return pPtr;
}
delete pPtr;
// Haven't found a match? Then seach for a hooked signature
PythonLog(4, "Could not find the signature in the binary. Searching for a hooked signature...");
// Check length of signature
if (iLength <= 6)
BOOST_RAISE_EXCEPTION(PyExc_ValueError, "Signature is too short to search for a hooked signature.");
// Create the hooked signature
oSignature = import("binascii").attr("unhexlify")("E92A2A2A2A") + oSignature.slice(5, _);
// Try to find the hooked signature
pPtr = FindSignatureRaw(oSignature);
// Couldn't find it?
if (!pPtr->IsValid())
{
PythonLog(4, "Could not find a hooked signature.");
delete pPtr;
}
// Yay, we found a match! Now, check if the signature is unique
else
{
PythonLog(4, "Found a hooked signature! Checking if it's unique...");
// Add iLength, so we start searching after the match
CPointer new_ptr = CPointer(pPtr->m_ulAddr + iLength);
// Got another match after the first one?
CPointer* pNext = new_ptr.SearchBytes(oSignature, (m_ulAddr + m_ulSize) - new_ptr.m_ulAddr);
bool bIsValid = pNext->IsValid();
delete pNext;
if (bIsValid)
BOOST_RAISE_EXCEPTION(PyExc_ValueError, "Found more than one hooked signatures. Please pass more bytes.");
PythonLog(4, "Signature is unique!");
// It's unique! So, add the original signature to the cache
Signature_t sig_t = {new unsigned char[iLength+1], pPtr->m_ulAddr};
strcpy((char*) sig_t.m_szSignature, (char*) sigstr);
m_Signatures.push_back(sig_t);
// Now, return the result
return pPtr;
}
BOOST_RAISE_EXCEPTION(PyExc_ValueError, "Could not find signature.");
return new CPointer(); // To fix a warning. This will never get called.
}
CVariant CKademlia::StartLookup(const CUInt128& TargetID, const CVariant& CodeID, const TCallMap& Execute, const TStoreMap& Store, CPrivateKey* pStoreKey, const TLoadMap& Load
, int Timeout, int HopLimit, int JumpCount, int SpreadCount, bool bTrace, const wstring& Name)
{
if(!m_pKadHandler)
return CVariant();
if(!CodeID.IsValid() && Store.empty() && Load.empty())
{
LogLine(LOG_ERROR, L"Attempted to start an empty Lookup");
return CVariant();
}
CPointer<CKadTask> pLookup = new CKadTask(TargetID, m_pLookupManager);
pLookup->SetName(Name);
if(Timeout != -1)
pLookup->SetTimeOut(Timeout);
if(HopLimit != -1)
pLookup->SetHopLimit(HopLimit);
if(JumpCount != -1)
pLookup->SetJumpCount(JumpCount);
if(SpreadCount != -1)
pLookup->SetSpreadCount(SpreadCount);
if(bTrace)
pLookup->EnableTrace();
if(pStoreKey)
pLookup->SetStoreKey(pStoreKey);
for(TStoreMap::const_iterator I = Store.begin(); I != Store.end(); I++)
pLookup->Store(I->first, I->second.Path, I->second.Data);
for(TLoadMap::const_iterator I = Load.begin(); I != Load.end(); I++)
pLookup->Load(I->first, I->second.Path);
if(CodeID.IsValid())
{
if(!pLookup->SetupScript(CodeID))
{
LogLine(LOG_ERROR, L"Attempted to start a smart lookup with an unavailable script: %s", ToHex(CodeID.GetData(), CodeID.GetSize()).c_str());
return CVariant();
}
for(TCallMap::const_iterator I = Execute.begin(); I != Execute.end(); I++)
pLookup->AddCall(I->second.Function, I->second.Parameters, I->first);
}
CVariant LookupID = m_pLookupManager->StartLookup(pLookup.Obj());
return LookupID;
}
