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