LogMessage::~LogMessage() {
// Finish constructing the message.
if (data_->GetError() != -1) {
data_->GetBuffer() << ": " << strerror(data_->GetError());
}
std::string msg(data_->ToString());
{
// Do the actual logging with the lock held.
lock_guard<mutex> lock(logging_lock);
if (msg.find('\n') == std::string::npos) {
LogLine(data_->GetFile(), data_->GetLineNumber(), data_->GetId(),
data_->GetSeverity(), msg.c_str());
} else {
msg += '\n';
size_t i = 0;
while (i < msg.size()) {
size_t nl = msg.find('\n', i);
msg[nl] = '\0';
LogLine(data_->GetFile(), data_->GetLineNumber(), data_->GetId(),
data_->GetSeverity(), &msg[i]);
i = nl + 1;
}
}
}
// Abort if necessary.
if (data_->GetSeverity() == FATAL) {
#ifdef __ANDROID__
android_set_abort_message(msg.c_str());
#endif
abort();
}
}
void CKadOperation::LogReport(UINT Flags, const wstring& ErrorMessage, const string& Error, const CVariant& Trace)
{
wstring Operation = L"Kad Operation";
if(m_pOperator)
{
CKadScript* pKadScript = m_pOperator->GetScript();
ASSERT(pKadScript);
Operation += L" (" + pKadScript->GetName() + L" v" + CKadScript::GetVersion(pKadScript->GetVersion()) + L")";
}
if(Trace.Count() > 0) // remote result
{
wstring Sender = CUInt128(Trace.At((uint32)0)).ToHex();
if(!Error.empty())
LogLine(LOG_DEBUG | Flags, L"%s recived an Error: %s from %s", Operation.c_str(), ErrorMessage.c_str(), Sender.c_str());
else
LogLine(LOG_DEBUG | Flags, L"%s recived a Report: %s from %s", Operation.c_str(), ErrorMessage.c_str(), Sender.c_str());
}
else
{
if(!Error.empty())
LogLine(LOG_DEBUG | Flags, L"%s caused an Error: %s", Operation.c_str(), ErrorMessage.c_str());
else
LogLine(LOG_DEBUG | Flags, L"%s Reports: %s", Operation.c_str(), ErrorMessage.c_str());
}
}
void SoftwareAuthority::errorData(int err)
{
switch((Q3Socket::Error)err) {
case Q3Socket::ErrConnectionRefused:
LogLine(RDConfig::LogNotice,QString().sprintf(
"Connection to SoftwareAuthority device at %s:%d refused, attempting reconnect",
(const char *)swa_ipaddress.toString(),
swa_ipport));
swa_reconnect_timer->start(SWAUTHORITY_RECONNECT_INTERVAL,true);
break;
case Q3Socket::ErrHostNotFound:
LogLine(RDConfig::LogWarning,QString().sprintf(
"Error on connection to SoftwareAuthority device at %s:%d: Host Not Found",
(const char *)swa_ipaddress.toString(),
swa_ipport));
break;
case Q3Socket::ErrSocketRead:
LogLine(RDConfig::LogWarning,QString().sprintf(
"Error on connection to SoftwareAuthority device at %s:%d: Socket Read Error",
(const char *)swa_ipaddress.toString(),
swa_ipport));
break;
}
}
void Harlond::ProcessResponse(const QString &str)
{
// LogLine(RDConfig::LogNotice,str);
QStringList cmds=cmds.split(" ",str);
if(cmds[0]=="PW") {
if(cmds.size()==2) {
if(cmds[1]=="+") {
LogLine(RDConfig::LogInfo,tr("connection to harlond device at ")+
bt_ip_address.toString()+QString().sprintf(":%d ",bt_tcp_port)+
tr("established"));
bt_socket->writeBlock("SS!",3);
return;
}
}
LogLine(RDConfig::LogInfo,tr("connection to harlond device at ")+
bt_ip_address.toString()+QString().sprintf(":%d ",bt_tcp_port)+
tr("refused, invalid password"));
}
if(cmds[0]=="ON") {
if(cmds.size()==2) {
emit gpiChanged(bt_matrix,cmds[1].toInt()-1,true);
}
}
if(cmds[0]=="OF") {
if(cmds.size()==2) {
emit gpiChanged(bt_matrix,cmds[1].toInt()-1,false);
}
}
}
void SigHandler(int signo)
{
pid_t pLocalPid;
switch(signo) {
case SIGCHLD:
pLocalPid=waitpid(-1,NULL,WNOHANG);
while(pLocalPid>0) {
pLocalPid=waitpid(-1,NULL,WNOHANG);
}
::signal(SIGCHLD,SigHandler);
::signal(SIGTERM,SigHandler);
::signal(SIGINT,SigHandler);
return;
case SIGTERM:
LogLine(RDConfig::LogInfo,"ripcd exiting normally");
RDDeletePid(RD_PID_DIR,"ripcd.pid");
exit(0);
break;
case SIGINT:
LogLine(RDConfig::LogInfo,"ripcd exiting on SIGINT");
RDDeletePid(RD_PID_DIR,"ripcd.pid");
exit(0);
break;
}
}
void CIPCServer::LocalListen(const QString& Name)
{
if(!Name.isEmpty())
{
m_Local = new QLocalServer(this);
if(m_Local->listen(Name))
{
m_Name = Name;
LogLine(LOG_NOTE, tr("Start local server %1").arg(Name));
}
else
{
LogLine(LOG_WARNING, tr("Failed to start local server name %1, selecting alternative name").arg(Name));
QString tmpName = QString("%1_%2").arg(Name).arg(GetRand64());
if(m_Local->listen(tmpName))
{
m_Name = tmpName;
LogLine(LOG_WARNING, tr("Started Local server witn temporary name %1").arg(tmpName));
}
else
LogLine(LOG_ERROR, tr("Failed to start local server!"));
}
connect(m_Local, SIGNAL(newConnection()), this, SLOT(OnLocalConnection()));
}
else
m_Local = NULL;
}
void CIPCServer::RemoteListen(quint16 Port)
{
if(Port != 0)
{
m_Remote = new QTcpServer(this);
if(m_Remote->listen(QHostAddress::Any, Port))
{
m_Port = Port;
LogLine(LOG_NOTE, tr("Start remote server on port %1").arg(Port));
}
else
{
LogLine(LOG_WARNING, tr("Failed to start remote server on port %1, selecting alternative port").arg(Port));
quint16 tmpPort = Port + GetRandomInt(1, 1000);
if(m_Remote->listen(QHostAddress::Any, tmpPort))
{
m_Port = tmpPort;
LogLine(LOG_WARNING, tr("Started remote server witn temporary port %1").arg(tmpPort));
}
else
LogLine(LOG_ERROR, tr("Failed to start remote server!"));
}
connect(m_Remote, SIGNAL(newConnection()), this, SLOT(OnRemoteConnection()));
}
else
m_Remote = NULL;
}
void CKadHandler::HandleNodeReq(const CVariant& NodeReq, CKadNode* pNode, CComChannel* pChannel)
{
if(GetParent<CKademlia>()->Cfg()->GetBool("DebugRT"))
LogLine(LOG_DEBUG, L"Recived 'Node Resuest' to %s", pNode->GetID().ToHex().c_str());
CVariant NodeRes;
uint32 uDesiredCount = NodeReq["RCT"];
if(uDesiredCount == 0)
throw CException(LOG_ERROR, L"node requested 0 nodes");
int iMaxState = NodeReq.Get("MNC", NODE_2ND_CLASS);
NodeMap Nodes;
if(!NodeReq.Has("TID"))
GetParent<CKademlia>()->Root()->GetBootstrapNodes(GetParent<CKademlia>()->Root()->GetID(), Nodes, uDesiredCount, pChannel->GetAddress().GetProtocol(), iMaxState);
else
GetParent<CKademlia>()->Root()->GetClosestNodes(NodeReq["TID"], Nodes, uDesiredCount, pChannel->GetAddress().GetProtocol(), iMaxState);
CVariant List;
for(NodeMap::iterator I = Nodes.begin(); I != Nodes.end(); I++)
List.Append(I->second->Store());
NodeRes["LIST"] = List;
if(GetParent<CKademlia>()->Cfg()->GetBool("DebugRT"))
LogLine(LOG_DEBUG, L"Sending 'Node Response' to %s", pNode->GetID().ToHex().c_str());
pChannel->QueuePacket(KAD_NODE_RESPONSE, NodeRes);
}
bool CTorrent::TryInstallMetadata()
{
if(m_MetadataExchange && m_MetadataExchange->NewData)
{
m_MetadataExchange->NewData = false;
QByteArray Payload = TryAssemblyMetadata();
if(!Payload.isEmpty())
{
if(!m_TorrentInfo->LoadMetadata(Payload))
{
LogLine(LOG_DEBUG | LOG_ERROR, tr("The torrent metadata for %1 (%2) cannot not be parsed.").arg(GetFile()->GetFileName()).arg(QString(m_TorrentInfo->GetInfoHash().toHex())));
// that is not recoverable!!!!
GetFile()->GetInspector()->BlackListHash(GetHash()); // Note: This will delete this
return false;
}
else
{
LogLine(LOG_DEBUG | LOG_SUCCESS, tr("recived metadata for torrent %1 (%2)").arg(GetFile()->GetFileName()).arg(QString(m_TorrentInfo->GetInfoHash().toHex())));
if(!GetFile()->IsPending())
SaveTorrentToFile();
if(!InstallMetadata()) // Note: This can delete this
return false;
emit MetadataLoaded();
}
delete m_MetadataExchange;
m_MetadataExchange = NULL;
return true;
}
}
return true;
}
void CUDTSocketListner::Process()
{
for(;;) // repeat untill all pending connections are accepted
{
/*timeval tv;
tv.tv_sec = 0;
tv.tv_usec = 0;
UDT::UDSET readfds;
UD_ZERO(&readfds);
UD_SET(m_Server, &readfds);
int res = UDT::select(0, &readfds, NULL, NULL, &tv);
if (!((res != UDT::ERROR) && (UD_ISSET(m_Server, &readfds))))
break;*/
sockaddr_in6 sa; // sockaddr_in is smaller
int sa_len = sizeof(sa);
UDTSOCKET Client = UDT::accept(m_Server, (sockaddr*)&sa, &sa_len);
if (UDT::INVALID_SOCK == Client)
{
LogLine(LOG_ERROR, L"accept: %S", UDT::getlasterror().getErrorMessage());
break;
}
else if(Client == NULL)
break;
ConfigSocket(Client);
uint64_t SendKey = 0;
int KeySize = sizeof(SendKey);
UDT::getsockopt(Client, 0, UDT_SENDKEY, &SendKey, &KeySize);
CSafeAddress Address((sockaddr*)&sa, sa_len, sa_len == sizeof(sockaddr_in) ? CSafeAddress::eUDT_IP4 : CSafeAddress::eUDT_IP6);
Address.SetPassKey(SendKey);
GetParent<CSmartSocket>()->AddSessions(Address, new CUDTSocketSession(this, Client, Address));
}
const uint64 Size = 0xFFFF;
char Buffer[Size];
for(;;) // repeat untill all data is read
{
sockaddr_in6 sa; // sockaddr_in is smaller
int sa_len = sizeof(sa);
uint64_t RecvKey = 0;
int Recived = UDT::recvfrom(m_Server, Buffer, Size, (sockaddr*)&sa, &sa_len, &RecvKey);
if (UDT::ERROR == Recived)
{
LogLine(LOG_ERROR, L"recvfrom: %S", UDT::getlasterror().getErrorMessage());
break;
}
else if(Recived == 0)
break; // nothing more to be recived
CBuffer Packet(Buffer, Recived, true);
CSafeAddress Address((sockaddr*)&sa, sa_len, sa_len == sizeof(sockaddr_in) ? CSafeAddress::eUDT_IP4 : CSafeAddress::eUDT_IP6);
Address.SetPassKey(RecvKey);
ReceiveFrom(Packet, Address);
}
}
CUDTSocketListner::CUDTSocketListner(CSmartSocket* pSocket, bool bIPv6, uint16 Port)
: CSocketListner(pSocket)
{
if(m_Count++ == 0)
UDT::startup();
m_bIPv6 = bIPv6;
m_Port = 0;
if(m_bIPv6)
{
m_sa = (sockaddr*)new sockaddr_in6;
memset(m_sa, 0, sizeof(sockaddr_in6));
((sockaddr_in6*)m_sa)->sin6_family = AF_INET6;
((sockaddr_in6*)m_sa)->sin6_addr = in6addr_any;
((sockaddr_in6*)m_sa)->sin6_port = htons((u_short)Port);
}
else
{
m_sa = (sockaddr*)new sockaddr_in;
memset(m_sa, 0, sizeof(sockaddr_in));
((sockaddr_in*)m_sa)->sin_family = AF_INET;
((sockaddr_in*)m_sa)->sin_addr.s_addr = INADDR_ANY;
((sockaddr_in*)m_sa)->sin_port = htons((u_short)Port);
}
m_Server = UDT::socket(m_bIPv6 ? AF_INET6 : AF_INET, SOCK_STREAM, IPPROTO_IP);
if(uint64 RecvKey = pSocket->GetRecvKey())
{
UDT::setsockopt(m_Server, 0, UDT_RECVKEY, &RecvKey, sizeof(RecvKey));
bool Obfuscate = true;
UDT::setsockopt(m_Server, 0, UDT_OBFUSCATE, &Obfuscate, sizeof(Obfuscate));
}
bool DirectUDP = true;
UDT::setsockopt(m_Server, 0, UDT_DIRECT, &DirectUDP, sizeof(DirectUDP));
bool reuse_addr = true; // Note: this is true by default anyways
UDT::setsockopt(m_Server, 0, UDT_REUSEADDR, &reuse_addr, sizeof(reuse_addr));
if (UDT::ERROR == UDT::bind(m_Server, m_sa, m_bIPv6 ? sizeof(sockaddr_in6) : sizeof(sockaddr_in)))
{
LogLine(LOG_ERROR, L"bind: %S", UDT::getlasterror().getErrorMessage());
return;
}
if (UDT::ERROR == UDT::listen(m_Server, 1024))
{
LogLine(LOG_ERROR, L"listen: %S", UDT::getlasterror().getErrorMessage());
return;
}
m_Port = Port;
LogLine(LOG_SUCCESS, L"%s Socket is listening at port %d", m_bIPv6 ? L"UDTv6" : L"UDT", m_Port);
bool blockng = false;
UDT::setsockopt(m_Server, 0, UDT_RCVSYN, &blockng, sizeof(blockng));
}
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);
}
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;
}
void CKadScript::LogReport(UINT Flags, const wstring& ErrorMessage, const string& Error)
{
wstring Operation = L"Kad Script";
Operation += L" (" + GetName() + L" v" + CKadScript::GetVersion(GetVersion()) + L")";
if(!Error.empty())
LogLine(LOG_DEBUG | Flags, L"%s caused an Error: %s", Operation.c_str(), ErrorMessage.c_str());
else
LogLine(LOG_DEBUG | Flags, L"%s Reports: %s", Operation.c_str(), ErrorMessage.c_str());
if(m_pLogger)
m_pLogger->LogReport(Flags, ErrorMessage, Error);
}
bool CTorrent::LoadTorrentFromFile(const QByteArray& InfoHash)
{
ASSERT(m_TorrentInfo == NULL);
m_TorrentInfo = new CTorrentInfo(this);
ASSERT(m_pHash.isNull());
m_pHash = CFileHashPtr(new CFileHash(HashTorrent));
m_pHash->SetHash(InfoHash);
QString TorrentFile = QString(InfoHash.toHex()) + ".torrent";
if(m_TorrentInfo->LoadTorrentFile(theCore->m_TorrentManager->GetTorrentDir() + TorrentFile))
{
if(m_TorrentInfo->GetInfoHash() == InfoHash)
{
CFile* pFile = GetFile();
if(pFile->GetFileSize() == 0)
pFile->SetFileSize(m_TorrentInfo->GetTotalLength());
LoadPieceHashes();
if(m_TorrentInfo->IsMultiFile() && !pFile->IsMultiFile())
{
CFileHashPtr pMasterHash = pFile->GetMasterHash();
if(!pMasterHash.isNull() && pMasterHash->GetHash() == InfoHash)
{
LogLine(LOG_DEBUG | LOG_ERROR, tr("The multi file %1 is missing its proper index, restoring form torrent").arg(pFile->GetFileName()));
InstallMetadata();
}
}
if(!m_TorrentInfo->IsEmpty() && !pFile->IsComplete() && !pFile->GetPartMap())
SetupPartMap();
}
else
{
LogLine(LOG_DEBUG | LOG_ERROR, tr("The torrent file %1 contains an invalid infohash").arg(TorrentFile));
delete m_TorrentInfo;
m_TorrentInfo = new CTorrentInfo(this);
m_TorrentInfo->SetInfoHash(InfoHash);
}
}
else
m_TorrentInfo->SetInfoHash(InfoHash);
theCore->m_TorrentManager->RegisterInfoHash(m_TorrentInfo->GetInfoHash());
return true; // Note: that is always true even if we fail to load as we always wil be able to proceed one way or another
}
void CKadHandler::HandleHello(const CVariant& Hello, CKadNode* pNode, CComChannel* pChannel, bool bReq)
{
if(GetParent<CKademlia>()->Cfg()->GetBool("DebugRT"))
LogLine(LOG_DEBUG, L"Recived 'Hello %s' to %s", bReq ? L"Request" : L"Response", pNode->GetID().ToHex().c_str());
SKadData* pData = pChannel->GetData<SKadData>();
CVariant Addr = Hello["ADDR"];
vector<CNodeAddress> AuthAddress;
for(uint32 i=0; i < Addr.Count(); i++)
{
AuthAddress.push_back(CNodeAddress());
AuthAddress.back().FromVariant(Addr.At(i));
}
// update node addresses
for(vector<CNodeAddress>::iterator I = AuthAddress.begin(); I != AuthAddress.end(); I++)
{
if(pData->Authenticated)
I->SetVerifyed();
pNode->UpdateAddress(*I);
}
if(bReq)
SendHello(pNode, pChannel, false);
SetLastContact();
pNode->UpdateClass(true, pChannel->GetAddress());
}
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);
}
bool CKademlia::LoadData()
{
m_pKadKey = new CPrivateKey(CAbstractKey::eUndefined);
wstring ConfigPath = Cfg()->GetString("ConfigPath");
if(!ConfigPath.empty())
{
CVariant Data;
if(ReadFile(ConfigPath + L"NeoKad.dat", Data))
{
try
{
const CVariant& Info = Data["INFO"];
string Version = Info["VER"];
const CVariant& KeyValue = Info["PK"];
if(!m_pKadKey->SetKey(KeyValue.GetData(), KeyValue.GetSize()))
LogLine(LOG_ERROR, L"Loaded Invalid private Key from file");
/*CBuffer PL = QByteArray("1234567890ABCDEF");
CBuffer Sig;
m_pKadKey->Sign(&PL, &Sig);
Sig.GetSize();*/
}
catch(const CException&)
{
ASSERT(0);
return false;
}
}
}
return true;
}
CPublicKey* CKadNode::SetIDKey(const CVariant& Info)
{
const CVariant& KeyValue = Info["PK"];
CHolder<CPublicKey> pKey = new CPublicKey();
if(pKey->SetKey(KeyValue.GetData(), KeyValue.GetSize()))
{
UINT eHashFunkt = Info.Has("HK") ? CAbstractKey::Str2Algorithm(Info["HK"]) & CAbstractKey::eHashFunkt : CAbstractKey::eUndefined;
if(m_ID.SetKey(pKey, eHashFunkt))
return m_ID.GetKey();
else
LogLine(LOG_ERROR, L"Recived wrong Key from Node");
}
else
LogLine(LOG_ERROR, L"Recived Invalid Key from Node");
return NULL;
}
void CKadOperation::ProxyingResponse(CKadNode* pNode, CComChannel* pChannel, const string &Error)
{
if(m_LookupHistory)
m_LookupHistory->RegisterResponse(pNode->GetID());
SOpProgress* pProgress = GetProgress(pNode);
if(!pProgress)
return;
pProgress->uTimeOut = -1;
if(!Error.empty())
{
pProgress->Shares = 0;
pProgress->OpState = eOpFailed;
LogLine(LOG_DEBUG, L"Recived error: '%S' on proxy lookup", Error.c_str());
}
else
{
pProgress->OpState = eOpProxy;
if(m_pOperator && m_pOperator->IsValid())
m_pOperator->OnProxyNode(pNode);
SendRequests(pNode, pChannel, pProgress, false);
}
}
void CKadHandler::HandleRouteRes(const CVariant& RouteRes, CKadNode* pNode, CComChannel* pChannel)
{
if(GetParent<CKademlia>()->Cfg()->GetBool("DebugRU"))
LogLine(LOG_DEBUG, L"Recived 'Route Response' from %s", pNode->GetID().ToHex().c_str());
SKadData* pData = pChannel->GetData<SKadData>();
CKadRelay* pRelay = pData->pLookup->Cast<CKadRelay>();
if(!pRelay)
throw CException(LOG_ERROR, L"Recived Route Response for a lookup that is not a CKadRelay");
// Note: this is for trace only, it does not have any deeper purpose
if(pRelay->IsTraced())
{
CVariant Trace = RouteRes.Get("TRACE").Clone();
Trace.Append(pNode->GetID());
if(!pRelay->Inherits("CKadRoute")) // if its just a relay we have to relay the trace back
{
CVariant RouteRel;
RouteRel["TID"] = RouteRes["TID"]; // pRelay->GetID()
RouteRel["TRACE"] = Trace;
if(CFrameRelay* pDownLink = pRelay->GetDownLink())
{
CFrameRelay::TRelayMap& DownNodes = pDownLink->GetNodes();
for(CFrameRelay::TRelayMap::iterator I = DownNodes.begin(); I != DownNodes.end(); I++)
{
if(I->first.pChannel->IsConnected())
{
if(GetParent<CKademlia>()->Cfg()->GetBool("DebugLU"))
LogLine(LOG_DEBUG, L"Relaying 'Route Response' from %s to %s", pNode->GetID().ToHex().c_str(), I->first.pNode->GetID().ToHex().c_str());
I->first.pChannel->QueuePacket(KAD_ROUTE_RESPONSE, RouteRel);
}
}
}
}
else
pRelay->RecivedTraceResults(Trace);
}
if(RouteRes.Has("TRACE")) // if this is set its a pro forma trace response ignore it
return;
pRelay->UpLinkResponse(pNode, pChannel, RouteRes.Get("ERR"));
}
void CmLog::LogWarning(const char* fmt, ...)
{
char buf[1 << 16];
strcpy(buf, "Warning: ");
va_list args;
va_start( args, fmt );
vsnprintf(buf + 9, 1<<16, fmt, args );
LogLine(FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_INTENSITY, buf);
}
void CmLog::LogError(const char* fmt, ...)
{
char buf[1 << 16];
strcpy(buf, "Error: ");
va_list args;
va_start( args, fmt );
vsnprintf(buf + 7, 1<<16, fmt, args );
LogLine(FOREGROUND_RED | FOREGROUND_INTENSITY, buf);
}
CHttpServer::CHttpServer(int Port, QObject* qObject)
{
m_Port = Port;
if(!Listen(Port))
LogLine(LOG_ERROR, tr("Failed to listen on http port"));
m_TransferBufferSize = KB2B(4);
m_KeepAlive = 115; // seconds
}
void Harlond::socketErrorData(int err)
{
bt_watchdog_timer->start(HARLOND_RECONNECT_INTERVAL,true);
switch(err) {
case QSocket::ErrConnectionRefused:
LogLine(RDConfig::LogWarning,tr("connection to harlond device at ")+
bt_ip_address.toString()+QString().sprintf(":%d ",bt_tcp_port)+
tr("refused, attempting reconnect"));
break;
default:
LogLine(RDConfig::LogWarning,tr("received network error")+
QString().sprintf(" %d ",err)+tr("from harlond device at ")+
bt_ip_address.toString()+QString().sprintf(":%d ",bt_tcp_port)+", "+
tr("attempting reconnect"));
break;
}
}
void MainObject::gpoChangedData(int matrix,int line,bool state)
{
if(state) {
LogLine(RDConfig::LogInfo,QString().sprintf("GPO %d:%d ON",matrix,line+1));
}
else {
LogLine(RDConfig::LogInfo,QString().sprintf("GPO %d:%d OFF",matrix,line+1));
}
ripcd_gpo_state[matrix][line]=state;
BroadcastCommand(QString().sprintf("GO %d %d %d %d!",matrix,line,state,
ripcd_gpo_mask[matrix][line]));
if(!ripcd_gpo_mask[matrix][line]) {
return;
}
if(ripcd_gpo_macro[matrix][line][state]>0) {
ExecCart(ripcd_gpo_macro[matrix][line][state]);
}
}
void MainObject::LoadLocalMacros()
{
QString sql;
RDSqlQuery *q;
unsigned tty_port;
for(int i=0;i<MAX_MATRICES;i++) {
ripcd_switcher_tty[i][0]=-1;
ripcd_switcher_tty[i][1]=-1;
}
for(int i=0;i<MAX_TTYS;i++) {
ripcd_tty_inuse[i]=false;
ripcd_tty_dev[i]=NULL;
}
//
// Initialize Matrices
//
sql=QString().sprintf("select MATRIX,TYPE,PORT,INPUTS,OUTPUTS from MATRICES \
where STATION_NAME=\"%s\"",
(const char *)rdstation->name());
q=new RDSqlQuery(sql);
while(q->next()) {
if(!LoadSwitchDriver(q->value(0).toInt())) {
LogLine(RDConfig::LogErr,QString().
sprintf("attempted to load unknown switcher driver for matrix %d",
q->value(0).toInt()));
}
}
delete q;
//
// Initialize TTYs
//
sql=QString().sprintf("select PORT_ID,PORT,BAUD_RATE,DATA_BITS,PARITY,\
TERMINATION from TTYS where (STATION_NAME=\"%s\")&&\
(ACTIVE=\"Y\")",
(const char *)rdstation->name());
q=new RDSqlQuery(sql);
while(q->next()) {
tty_port=q->value(0).toUInt();
if(!ripcd_tty_inuse[tty_port]) {
ripcd_tty_dev[tty_port]=new RDTTYDevice();
ripcd_tty_dev[tty_port]->setName(q->value(1).toString());
ripcd_tty_dev[tty_port]->setSpeed(q->value(2).toInt());
ripcd_tty_dev[tty_port]->setWordLength(q->value(3).toInt());
ripcd_tty_dev[tty_port]->
setParity((RDTTYDevice::Parity)q->value(4).toInt());
if(ripcd_tty_dev[tty_port]->open(IO_ReadWrite)) {
ripcd_tty_term[tty_port]=(RDTty::Termination)q->value(5).toInt();
ripcd_tty_inuse[tty_port]=true;
ripcd_tty_trap[tty_port]=new RDCodeTrap(this);
connect(ripcd_tty_trap[tty_port],SIGNAL(trapped(int)),
this,SLOT(ttyTrapData(int)));
}
else {
delete ripcd_tty_dev[tty_port];
void MainObject::ParseCommand(int ch)
{
char buf[256];
int c;
RipcdConnection *conn=ripcd_conns[ch];
while((c=conn->socket->readBlock(buf,256))>0) {
buf[c]=0;
for(int i=0;i<c;i++) {
if(buf[i]==' ') {
if(conn->argnum<RD_RML_MAX_ARGS) {
conn->args[conn->argnum][conn->argptr]=0;
conn->argnum++;
conn->argptr=0;
}
else {
LogLine(RDConfig::LogWarning,QString().
sprintf("*** ParseCommand1: argument list truncated. LocalBuffer: %s ***",buf));
}
}
if(buf[i]=='!') {
conn->args[conn->argnum++][conn->argptr]=0;
DispatchCommand(ch);
conn->argnum=0;
conn->argptr=0;
if(conn->socket==NULL) {
return;
}
}
if((isgraph(buf[i]))&&(buf[i]!='!')) {
if(conn->argptr<RIPCD_MAX_LENGTH) {
conn->args[conn->argnum][conn->argptr]=buf[i];
conn->argptr++;
}
else {
if(debug) {
LogLine(RDConfig::LogWarning,QString().
sprintf("*** ParseCommand2: argument list truncated. LocalBuffer: %s ***",buf));
}
}
}
}
}
}
CSocketSession* CUDTSocketListner::CreateSession(const CSafeAddress& Address, bool bRendevouz, bool bEmpty)
{
if(bEmpty)
return new CUDTSocketSession(this, UDT::INVALID_SOCK, Address);
sockaddr_in6 sa; // sockaddr_in is smaller
int sa_len = sizeof(sa);
Address.ToSA((sockaddr*)&sa, &sa_len);
UDTSOCKET Client = UDT::socket(m_bIPv6 ? AF_INET6 : AF_INET, SOCK_STREAM, IPPROTO_IP);
CSmartSocket* pSocket = GetParent<CSmartSocket>();
if(uint64 RecvKey = pSocket->GetRecvKey())
{
UDT::setsockopt(Client, 0, UDT_RECVKEY, &RecvKey, sizeof(RecvKey));
bool Obfuscate = true;
UDT::setsockopt(Client, 0, UDT_OBFUSCATE, &Obfuscate, sizeof(Obfuscate));
}
if(uint64 SendKey = Address.GetPassKey())
UDT::setsockopt(Client, 0, UDT_SENDKEY, &SendKey, sizeof(SendKey));
ConfigSocket(Client);
bool reuse_addr = true; // Note: this is true by default anyways
UDT::setsockopt(Client, 0, UDT_REUSEADDR, &reuse_addr, sizeof(reuse_addr));
if(bRendevouz)
{
bool value = true;
UDT::setsockopt(Client, 0, UDT_RENDEZVOUS, &value, sizeof(value));
}
if (UDT::ERROR == UDT::bind(Client, m_sa, m_bIPv6 ? sizeof(sockaddr_in6) : sizeof(sockaddr_in)))
{
LogLine(LOG_ERROR, L"bind: %S", UDT::getlasterror().getErrorMessage());
return NULL;
}
if (UDT::ERROR == UDT::connect(Client, (sockaddr*)&sa, sa_len))
{
LogLine(LOG_ERROR, L"connect: %S", UDT::getlasterror().getErrorMessage());
return NULL;
}
return new CUDTSocketSession(this, Client, Address);
}
void MainObject::ParseCommand(int ch)
{
char buf[256];
int c;
while((c=socket[ch]->readBlock(buf,256))>0) {
buf[c]=0;
for(int i=0;i<c;i++) {
if(buf[i]==' ') {
if(argnum[ch]<RD_RML_MAX_ARGS) {
args[ch][argnum[ch]][argptr[ch]]=0;
argnum[ch]++;
argptr[ch]=0;
}
else {
LogLine(RDConfig::LogWarning,QString().
sprintf("*** ParseCommand1: argument list truncated. LocalBuffer: %s ***",buf));
}
}
if(buf[i]=='!') {
args[ch][argnum[ch]++][argptr[ch]]=0;
DispatchCommand(ch);
argnum[ch]=0;
argptr[ch]=0;
if(socket[ch]==NULL) {
return;
}
}
if((isgraph(buf[i]))&&(buf[i]!='!')) {
if(argptr[ch]<RIPCD_MAX_LENGTH) {
args[ch][argnum[ch]][argptr[ch]]=buf[i];
argptr[ch]++;
}
else {
if(debug) {
LogLine(RDConfig::LogWarning,QString().
sprintf("*** ParseCommand2: argument list truncated. LocalBuffer: %s ***",buf));
}
}
}
}
}
}
