bool ClientController::route_request_inside_invite( const string& rawSipMsg, const SipMsgData_t& meta, nta_incoming_t* irq, sip_t const *sip, const string& transactionId, const string& dialogId ) { //client_ptr client = this->findClientForDialog( dialogId ); //if( !client ) { client_ptr client = this->findClientForNetTransaction( transactionId ); if( !client ) { DR_LOG(log_warning) << "ClientController::route_response_inside_invite - client managing transaction has disconnected: " << transactionId ; return false ; } //} DR_LOG(log_debug) << "ClientController::route_response_inside_invite - sending response to client" ; m_ioservice.post( boost::bind(&Client::sendSipMessageToClient, client, transactionId, dialogId, rawSipMsg, meta) ) ; return true ; }
void Pdb::WriteContext(HANDLE hThread, Context& context) { DR_LOG("WriteContext"); #ifdef CPU_64 if(win64) { CONTEXT ctx; memcpy(&ctx, &context.context64, sizeof(CONTEXT)); ctx.ContextFlags = CONTEXT_CONTROL; if(!SetThreadContext(hThread, &ctx)) Error("SetThreadContext failed"); } else { WOW64_CONTEXT ctx; memcpy(&ctx, &context.context32, sizeof(WOW64_CONTEXT)); ctx.ContextFlags = CONTEXT_CONTROL; if(!Wow64SetThreadContext(hThread, &ctx)) Error("Wow64SetThreadContext failed"); } #else CONTEXT ctx; memcpy(&ctx, &context.context32, sizeof(WOW64_CONTEXT)); ctx.ContextFlags = CONTEXT_CONTROL; if(!SetThreadContext(hThread, &ctx)) Error("SetThreadContext failed"); #endif }
void DrachtioController::handleSigHup( int signal ) { if( !m_ConfigNew ) { DR_LOG(log_notice) << "Re-reading configuration file" << endl ; m_ConfigNew.reset( new DrachtioConfig( m_configFilename.c_str() ) ) ; if( !m_ConfigNew->isValid() ) { DR_LOG(log_error) << "Error reading configuration file; no changes will be made. Please correct the configuration file and try to reload again" << endl ; m_ConfigNew.reset() ; } } else { DR_LOG(log_error) << "Ignoring signal; already have a new configuration file to install" << endl ; } }
Pdb::Context Pdb::ReadContext(HANDLE hThread) { DR_LOG("ReadContext"); Context r; #ifdef CPU_64 if(win64) { CONTEXT ctx; ctx.ContextFlags = CONTEXT_FULL; if(!GetThreadContext(hThread, &ctx)) Error("GetThreadContext failed"); memcpy(&r.context64, &ctx, sizeof(CONTEXT)); } else { WOW64_CONTEXT ctx; ctx.ContextFlags = WOW64_CONTEXT_FULL; if(!Wow64GetThreadContext(hThread, &ctx)) Error("Wow64GetThreadContext failed"); memcpy(&r.context32, &ctx, sizeof(WOW64_CONTEXT)); } #else CONTEXT ctx; ctx.ContextFlags = CONTEXT_FULL; if(!GetThreadContext(hThread, &ctx)) Error("GetThreadContext failed"); memcpy(&r.context32, &ctx, sizeof(CONTEXT)); #endif return r; }
client_ptr ClientController::selectClientForRequestOutsideDialog( const char* keyword ) { string method_name = keyword ; transform(method_name.begin(), method_name.end(), method_name.begin(), ::tolower); /* round robin select a client that has registered for this request type */ boost::lock_guard<boost::mutex> l( m_lock ) ; client_ptr client ; string matchId ; pair<map_of_request_types::iterator,map_of_request_types::iterator> pair = m_request_types.equal_range( method_name ) ; unsigned int nPossibles = std::distance( pair.first, pair.second ) ; if( 0 == nPossibles ) { if( 0 == method_name.find("cdr") ) { DR_LOG(log_debug) << "No connected clients found to handle incoming " << method_name << " request" ; } else { DR_LOG(log_info) << "No connected clients found to handle incoming " << method_name << " request" ; } return client ; } unsigned int nOffset = 0 ; map_of_request_type_offsets::const_iterator itOffset = m_map_of_request_type_offsets.find( method_name ) ; if( m_map_of_request_type_offsets.end() != itOffset ) { unsigned int i = itOffset->second; if( i < nPossibles ) nOffset = i ; else nOffset = 0; } DR_LOG(log_debug) << "ClientController::route_request_outside_dialog - there are " << nPossibles << " possible clients, we are starting with offset " << nOffset ; m_map_of_request_type_offsets.erase( itOffset ) ; m_map_of_request_type_offsets.insert(map_of_request_type_offsets::value_type(method_name, nOffset + 1)) ; unsigned int nTries = 0 ; do { map_of_request_types::iterator it = pair.first ; std::advance( it, nOffset) ; RequestSpecifier& spec = it->second ; client = spec.client() ; if( !client ) { DR_LOG(log_debug) << "Removing disconnected client while iterating" ; m_request_types.erase( it ) ; pair = m_request_types.equal_range( method_name ) ; if( nOffset >= m_request_types.size() ) { nOffset = m_request_types.size() - 1 ; } DR_LOG(log_debug) << "Offset has been set to " << nOffset << " size of range is " << m_request_types.size() ; } else { DR_LOG(log_debug) << "Selected client at offset " << nOffset ; } } while( !client && ++nTries < nPossibles ) ; if( !client ) { DR_LOG(log_info) << "No clients found to handle incoming " << method_name << " request" ; return client ; } return client ; }
void SipDialog::doSessionTimerHandling() { bool bWeAreRefresher = areWeRefresher() ; if( bWeAreRefresher ) { //TODO: send a refreshing reINVITE, and notify the client DR_LOG(log_debug) << "SipDialog::doSessionTimerHandling - sending refreshing re-INVITE with call-id " << getCallId() ; theOneAndOnlyController->getDialogController()->notifyRefreshDialog( shared_from_this() ) ; } else { //TODO: tear down the leg, and notify the client DR_LOG(log_debug) << "SipDialog::doSessionTimerHandling - tearing down sip dialog with call-id " << getCallId() << " because remote peer did not refresh the session within the specified interval" ; theOneAndOnlyController->getDialogController()->notifyTerminateStaleDialog( shared_from_this() ) ; } assert( m_ppSelf ) ; delete m_ppSelf ; m_ppSelf = NULL ; m_timerSessionRefresh = NULL ; m_refresher = no_refresher ; m_nSessionExpiresSecs = 0 ; }
bool ClientController::route_api_response( const string& clientMsgId, const string& responseText, const string& additionalResponseData ) { client_ptr client = this->findClientForApiRequest( clientMsgId ); if( !client ) { DR_LOG(log_warning) << "ClientController::route_api_response - client that has sent the request has disconnected: " << clientMsgId ; return false ; } if( string::npos == additionalResponseData.find("|continue") ) removeApiRequest( clientMsgId ) ; m_ioservice.post( boost::bind(&Client::sendApiResponseToClient, client, clientMsgId, responseText, additionalResponseData) ) ; return true ; }
int DrachtioController::validateSipMessage( sip_t const *sip ) { if( sip_method_invite == sip->sip_request->rq_method && (!sip->sip_contact || !sip->sip_contact->m_url[0].url_host ) ) { DR_LOG(log_error) << "Invalid or missing contact header" << endl ; return 400 ; } if( !sip->sip_call_id || !sip->sip_call_id->i_id ) { DR_LOG(log_error) << "Invalid or missing call-id header" << endl ; return 400 ; } if( sip_method_invite == sip->sip_request->rq_method && (!sip->sip_to || !sip->sip_to->a_url[0].url_user ) ) { DR_LOG(log_error) << "Invalid or missing to header or dialed number information" << endl ; return 400 ; } if( sip_method_invite == sip->sip_request->rq_method && (!sip->sip_from || !sip->sip_from->a_tag ) ) { DR_LOG(log_error) << "Missing tag on From header on invite" << endl ; return 400 ; } return 0 ; }
bool ClientController::route_ack_request_inside_dialog( const string& rawSipMsg, const SipMsgData_t& meta, nta_incoming_t* prack, sip_t const *sip, const string& transactionId, const string& inviteTransactionId, const string& dialogId ) { client_ptr client = this->findClientForDialog( dialogId ); if( !client ) { client = this->findClientForNetTransaction( inviteTransactionId ); if( !client ) { DR_LOG(log_warning) << "ClientController::route_ack_request_inside_dialog - client managing dialog has disconnected: " << dialogId ; //TODO: try to find another client providing the same service return false ; } } m_ioservice.post( boost::bind(&Client::sendSipMessageToClient, client, transactionId, dialogId, rawSipMsg, meta) ) ; this->removeNetTransaction( inviteTransactionId ) ; DR_LOG(log_debug) << "ClientController::route_ack_request_inside_dialog - removed incoming invite transaction, map size is now: " << m_mapNetTransactions.size() << " request" ; return true ; }
void ClientController::threadFunc() { DR_LOG(log_debug) << "Client controller thread id: " << boost::this_thread::get_id() ; /* to make sure the event loop doesn't terminate when there is no work to do */ boost::asio::io_service::work work(m_ioservice); for(;;) { try { DR_LOG(log_notice) << "ClientController: io_service run loop started" ; m_ioservice.run() ; DR_LOG(log_notice) << "ClientController: io_service run loop ended normally" ; break ; } catch( std::exception& e) { DR_LOG(log_error) << "Error in event thread: " << string( e.what() ) ; break ; } } }
bool ClientController::wants_requests( client_ptr client, const string& verb ) { RequestSpecifier spec( client ) ; boost::lock_guard<boost::mutex> l( m_lock ) ; m_request_types.insert( map_of_request_types::value_type(verb, spec)) ; DR_LOG(log_debug) << "Added client for " << verb << " requests" ; //initialize the offset if this is the first client registering for that verb map_of_request_type_offsets::iterator it = m_map_of_request_type_offsets.find( verb ) ; if( m_map_of_request_type_offsets.end() == it ) m_map_of_request_type_offsets.insert(map_of_request_type_offsets::value_type(verb,0)) ; //TODO: validate the verb is supported return true ; }
client_ptr ClientController::findClientForDialog_nolock( const string& dialogId ) { client_ptr client ; mapId2Client::iterator it = m_mapDialogs.find( dialogId ) ; if( m_mapDialogs.end() != it ) client = it->second.lock() ; // if that client is no longer connected, randomly select another client that is running that app if( !client ) { mapDialogId2Appname::iterator it = m_mapDialogId2Appname.find( dialogId ) ; if( m_mapDialogId2Appname.end() != it ) { string appName = it->second ; DR_LOG(log_info) << "Attempting to find another client for app " << appName ; pair<map_of_services::iterator,map_of_services::iterator> pair = m_services.equal_range( appName ) ; unsigned int nPossibles = std::distance( pair.first, pair.second ) ; if( 0 == nPossibles ) { DR_LOG(log_warning) << "No other clients found for app " << appName ; return client ; } unsigned int nOffset = rand() % nPossibles ; unsigned int nTries = 0 ; do { map_of_services::iterator itTemp = pair.first ; std::advance( itTemp, nOffset) ; client = itTemp->second.lock() ; if( !client ) { if( ++nOffset == nPossibles ) nOffset = 0 ; } } while( !client && ++nTries < nPossibles ) ; if( !client ) DR_LOG(log_warning) << "No other connected clients found for app " << appName ; else DR_LOG(log_info) << "Found alternative client for app " << appName << " " << nOffset << ":" << nPossibles ; } } return client ; }
void SipDialog::setSessionTimer( unsigned long nSecs, SessionRefresher_t whoIsResponsible ) { assert( NULL == m_timerSessionRefresh ) ; m_refresher = whoIsResponsible ; su_duration_t nMilliseconds = nSecs * 1000 ; m_nSessionExpiresSecs = nSecs ; DR_LOG(log_debug) << "Session expires has been set to " << nSecs << " seconds and refresher is " << (areWeRefresher() ? "us" : "them") ; /* if we are the refresher, then we want the timer to go off halfway through the interval */ if( areWeRefresher() ) nMilliseconds /= 2 ; m_timerSessionRefresh = su_timer_create( su_root_task(theOneAndOnlyController->getRoot()), nMilliseconds ) ; m_ppSelf = new boost::weak_ptr<SipDialog>( shared_from_this() ) ; su_timer_set(m_timerSessionRefresh, session_timer_handler, (su_timer_arg_t *) m_ppSelf ); }
bool Pdb::Tip(const String& exp, CodeEditor::MouseTip& mt) { /* mt.display = &StdDisplay(); mt.value = exp; mt.sz = Size(100, 20); return true;*/ DR_LOG("Pdb::Tip"); Visual r; try { CParser p(exp); Val v = Exp(p); Visualise(r, v, 2); if(r.part.GetCount()) { mt.sz = r.GetSize() + Size(4, 4); mt.value = RawPickToValue(r); mt.display = &Single<VisualDisplay>(); DR_LOG("Pdb::Tip true"); return true; } } catch(CParser::Error) {} DR_LOG("Pdb::Tip false"); return false; }
int DrachtioController::processRequestInsideDialog( nta_leg_t* leg, nta_incoming_t* irq, sip_t const *sip) { DR_LOG(log_debug) << "DrachtioController::processRequestInsideDialog" << endl ; int rc = validateSipMessage( sip ) ; if( 0 != rc ) { return rc ; } boost::shared_ptr<SipDialog> dlg ; if( m_pDialogController->findDialogByLeg( leg, dlg ) ) { return m_pDialogController->processRequestInsideDialog( leg, irq, sip ) ; } assert(false) ; return 0 ; }
void Pdb::AddThread(dword dwThreadId, HANDLE hThread) { if(threads.Find(dwThreadId) >= 0) return; DR_LOG("AddThread"); Thread& f = threads.GetAdd(dwThreadId); // Retrive "base-level" stack-pointer, to have limit for stackwalks: Context c = ReadContext(hThread); #ifdef CPU_64 f.sp = win64 ? c.context64.Rsp : c.context32.Esp; #else f.sp = c.context32.Esp; #endif f.hThread = hThread; LLOG("Adding thread " << dwThreadId << ", Thread SP: " << Hex(f.sp) << ", handle: " << FormatIntHex((dword)(hThread))); }
SipDialog::~SipDialog() { DR_LOG(log_debug) << "SipDialog::~SipDialog - destroying sip dialog with call-id " << getCallId() ; if( NULL != m_timerSessionRefresh ) { cancelSessionTimer() ; assert( m_ppSelf ) ; } if( m_ppSelf ) { delete m_ppSelf ; } nta_leg_t *leg = nta_leg_by_call_id( theOneAndOnlyController->getAgent(), getCallId().c_str() ); assert( leg ) ; if( leg ) { nta_leg_destroy( leg ) ; } }
int DrachtioController::sendRequestInsideDialog( boost::shared_ptr<JsonMsg> pMsg, const string& rid ) { boost::shared_ptr<SipDialog> dlg ; const char *dialogId=NULL ; json_error_t err ; if( 0 > json_unpack_ex(pMsg->value(), &err, 0, "{s:{s:s}}", "data", "dialogId", &dialogId) ) { DR_LOG(log_error) << "DrachtioController::sendRequestInsideDialog - failed parsing message: " << err.text << endl ; return -1 ; } if( !m_pDialogController->findDialogById( dialogId, dlg ) ) { //DO I need to look in dialog maker also ? What about an UPDATE sent during an INVITE transaction? return -1; } m_pDialogController->sendRequestInsideDialog( pMsg, rid, dlg ) ; return 0 ; }
bool ClientController::route_request_inside_dialog( const string& rawSipMsg, const SipMsgData_t& meta, nta_incoming_t* irq, sip_t const *sip, const string& transactionId, const string& dialogId ) { client_ptr client = this->findClientForDialog( dialogId ); if( !client ) { DR_LOG(log_warning) << "ClientController::route_request_inside_dialog - client managing dialog has disconnected: " << dialogId ; //TODO: try to find another client providing the same service return false ; } this->addNetTransaction( client, transactionId ) ; m_ioservice.post( boost::bind(&Client::sendSipMessageToClient, client, transactionId, dialogId, rawSipMsg, meta) ) ; // if this is a BYE from the network, it ends the dialog string method_name = sip->sip_request->rq_method_name ; if( 0 == method_name.compare("BYE") ) { removeDialog( dialogId ) ; } return true ; }
bool ClientController::route_response_inside_transaction( const string& rawSipMsg, const SipMsgData_t& meta, nta_outgoing_t* orq, sip_t const *sip, const string& transactionId, const string& dialogId ) { client_ptr client = this->findClientForAppTransaction( transactionId ); if( !client ) { DR_LOG(log_warning) << "ClientController::route_response_inside_transaction - client managing transaction has disconnected: " << transactionId ; return false ; } m_ioservice.post( boost::bind(&Client::sendSipMessageToClient, client, transactionId, dialogId, rawSipMsg, meta) ) ; string method_name = sip->sip_cseq->cs_method_name ; if( sip->sip_status->st_status >= 200 ) { removeAppTransaction( transactionId ) ; } if( 0 == method_name.compare("BYE") ) { removeDialog( dialogId ) ; } return true ; }
void DrachtioController::generateOutgoingContact( sip_contact_t* const incomingContact, string& strContact ) { ostringstream o ; if( incomingContact->m_display && *incomingContact->m_display ) { o << incomingContact->m_display ; } o << "<sip:" ; if( incomingContact->m_url[0].url_user ) { o << incomingContact->m_url[0].url_user ; o << "@" ; } sip_contact_t* contact = nta_agent_contact( m_nta ) ; o << contact->m_url[0].url_host ; if( contact->m_url[0].url_port && *contact->m_url[0].url_port ) { o << ":" ; o << contact->m_url[0].url_port ; } o << ">" ; DR_LOG(log_debug) << "generated Contact: " << o.str() << endl ; strContact = o.str() ; }
void ClientController::addDialogForTransaction( const string& transactionId, const string& dialogId ) { boost::lock_guard<boost::mutex> l( m_lock ) ; mapId2Client::iterator it = m_mapNetTransactions.find( transactionId ) ; if( m_mapNetTransactions.end() != it ) { m_mapDialogs.insert( mapId2Client::value_type(dialogId, it->second ) ) ; DR_LOG(log_warning) << "ClientController::addDialogForTransaction - added dialog (uas), now tracking: " << m_mapDialogs.size() << " dialogs and " << m_mapNetTransactions.size() << " net transactions" ; } else { /* dialog will already exist if we received a reliable provisional response */ mapId2Client::iterator itDialog = m_mapDialogs.find( dialogId ) ; if( m_mapDialogs.end() == itDialog ) { mapId2Client::iterator itApp = m_mapAppTransactions.find( transactionId ) ; if( m_mapAppTransactions.end() != itApp ) { m_mapDialogs.insert( mapId2Client::value_type(dialogId, itApp->second ) ) ; DR_LOG(log_warning) << "ClientController::addDialogForTransaction - added dialog (uac), now tracking: " << m_mapDialogs.size() << " dialogs and " << m_mapAppTransactions.size() << " app transactions" ; } else { DR_LOG(log_error) << "ClientController::addDialogForTransaction - transaction id " << transactionId << " not found" ; assert(false) ; } } } DR_LOG(log_debug) << "ClientController::addDialogForTransaction - transaction id " << transactionId << " has associated dialog " << dialogId ; client_ptr client = this->findClientForDialog_nolock( dialogId ); if( !client ) { m_mapDialogs.erase( dialogId ) ; DR_LOG(log_warning) << "ClientController::addDialogForTransaction - client managing dialog has disconnected: " << dialogId ; return ; } else { string strAppName ; if( client->getAppName( strAppName ) ) { m_mapDialogId2Appname.insert( mapDialogId2Appname::value_type( dialogId, strAppName ) ) ; DR_LOG(log_debug) << "ClientController::addDialogForTransaction - dialog id " << dialogId << " has been established for client app " << strAppName << "; count of tracked dialogs is " << m_mapDialogId2Appname.size() ; } } }
void DrachtioConfig::Log() const { DR_LOG(log_notice) << "Configuration:" << endl ; }
void DrachtioController::processWatchdogTimer() { DR_LOG(log_debug) << "DrachtioController::processWatchdogTimer" << endl ; this->printStats() ; m_pDialogController->logStorageCount() ; m_pClientController->logStorageCount() ; }
bool Pdb::RunToException() { DR_LOG("RunToException"); LLOG("RUN TO EXCEPTION"); TimeStop ts; bool disasfocus = disas.HasFocus(); bool locked = false; bool frestored = false; invalidpage.Clear(); mempage.Clear(); int opn = 0; for(;;) { if(terminated) { if(locked) Unlock(); return false; } opn++; DR_LOG("WaitForDebugEvent"); if(WaitForDebugEvent(&event, 0)) { DR_LOG("WaitForDebugEvent ended"); debug_threadid = event.dwThreadId; opn = 0; running = false; switch(event.dwDebugEventCode) { case EXCEPTION_DEBUG_EVENT: { DR_LOG("EXCEPTION_DEBUG_EVENT"); LLOG("Exception: " << FormatIntHex(event.u.Exception.ExceptionRecord.ExceptionCode) << " at: " << FormatIntHex(event.u.Exception.ExceptionRecord.ExceptionAddress) << " first: " << event.u.Exception.dwFirstChance); SaveForeground(); const EXCEPTION_RECORD& x = event.u.Exception.ExceptionRecord; if(findarg(x.ExceptionCode, EXCEPTION_BREAKPOINT, EXCEPTION_SINGLE_STEP, STATUS_WX86_BREAKPOINT, STATUS_WX86_SINGLE_STEP) < 0) { LLOG("Non-debug EXCEPTION"); if(event.u.Exception.dwFirstChance) { LLOG("First chance " << FormatIntHex(x.ExceptionCode)); break; } String desc = Format("Exception: [* %lX] at [* %16llX]&", (int64)x.ExceptionCode, (int64)x.ExceptionAddress); for(int i = 0; i < __countof(ex_desc); i++) if(ex_desc[i].code == x.ExceptionCode) desc << "[* " << DeQtf(ex_desc[i].text) << "]&"; if(x.ExceptionCode == EXCEPTION_ACCESS_VIOLATION) { desc << (x.ExceptionInformation[0] ? "[*@3 writing]" : "[*@4 reading]"); desc << Format(" at [* %08llX]", (int64)x.ExceptionInformation[1]); } ToForeground(); PromptOK(desc); } #ifdef CPU_64 if(!win64 && x.ExceptionCode == EXCEPTION_BREAKPOINT && !break_running) // Ignore x64 breakpoint in wow64 break; #endif if(break_running) debug_threadid = mainThreadId; break_running = false; ToForeground(); if(disasfocus) disas.SetFocus(); if(locked) Unlock(); if(refreshmodules) LoadModuleInfo(); LLOG("event.dwThreadId = " << event.dwThreadId); bool isbreakpoint = findarg(x.ExceptionCode, EXCEPTION_BREAKPOINT, STATUS_WX86_BREAKPOINT) >= 0; for(int i = 0; i < threads.GetCount(); i++) { Thread& t = threads[i]; (Context&)t = ReadContext(threads[i].hThread); if(event.dwThreadId == threads.GetKey(i)) { LLOG("Setting current context"); if(isbreakpoint #ifdef CPU_64 && bp_set.Find((win64 ? t.context64.Rip : t.context32.Eip) - 1) >= 0 #else && bp_set.Find(t.context32.Eip - 1) >= 0 #endif ) // We have stopped at breakpoint, need to move address back #ifdef CPU_64 if(win64) t.context64.Rip--; else #endif t.context32.Eip--; context = t; } } RemoveBp(); return true; } case CREATE_THREAD_DEBUG_EVENT: DR_LOG("CREATE_THREAD_DEBUG_EVENT"); LLOG("Create thread: " << event.dwThreadId); AddThread(event.dwThreadId, event.u.CreateThread.hThread); break; case EXIT_THREAD_DEBUG_EVENT: DR_LOG("EXIT_THREAD_DEBUG_EVENT"); LLOG("Exit thread: " << event.dwThreadId); RemoveThread(event.dwThreadId); break; case CREATE_PROCESS_DEBUG_EVENT: DR_LOG("CREATE_PROCESS_DEBUG_EVENT"); LLOG("Create process: " << event.dwProcessId); processid = event.dwProcessId; AddThread(event.dwThreadId, event.u.CreateProcessInfo.hThread); CloseHandle(event.u.CreateProcessInfo.hFile); CloseHandle(event.u.CreateProcessInfo.hProcess); break; case EXIT_PROCESS_DEBUG_EVENT: DR_LOG("EXIT_PROCESS_DEBUG_EVENT"); LLOG("Exit process: " << event.dwProcessId); if(locked) Unlock(); terminated = true; return false; case LOAD_DLL_DEBUG_EVENT: { DR_LOG("LOAD_DLL_DEBUG_EVENT"); LLOG("Load dll: " << event.u.LoadDll.lpBaseOfDll); CloseHandle(event.u.LoadDll.hFile); refreshmodules = true; break; } case UNLOAD_DLL_DEBUG_EVENT: DR_LOG("UNLOAD_DLL_DEBUG_EVENT"); LLOG("UnLoad dll: " << event.u.UnloadDll.lpBaseOfDll); refreshmodules = true; break; case RIP_EVENT: DR_LOG("RIP_EVENT"); LLOG("RIP!"); Exclamation("Process being debugged died unexpectedly!"); terminated = true; if(locked) Unlock(); return false; } DR_LOG("ContinueDebugEvent"); ContinueDebugEvent(event.dwProcessId, event.dwThreadId, DBG_EXCEPTION_NOT_HANDLED); running = true; } if(ts.Elapsed() > 200) { DR_LOG("ts.Elpsed() > 200"); if(!lock) { Lock(); locked = true; } if(!frestored) { RestoreForeground(); frestored = true; } } if(lock) { DR_LOG("GuiSleep"); GuiSleep(opn < 1000 ? 0 : 100); Ctrl::ProcessEvents(); } else { DR_LOG("Sleep"); Sleep(opn < 1000 ? 0 : 100); } } }
void ClientController::leave( client_ptr client ) { m_clients.erase( client ) ; DR_LOG(log_debug) << "Removed client, count of connected clients is now: " << m_clients.size() ; }
void ClientController::join( client_ptr client ) { m_clients.insert( client ) ; client_weak_ptr p( client ) ; DR_LOG(log_debug) << "Added client, count of connected clients is now: " << m_clients.size() ; }
void ClientController::removeNetTransaction( const string& transactionId ) { boost::lock_guard<boost::mutex> l( m_lock ) ; m_mapNetTransactions.erase( transactionId ) ; DR_LOG(log_debug) << "removeNetTransaction: transactionId " << transactionId << "; size: " << m_mapNetTransactions.size() ; }
void ClientController::logStorageCount() { boost::lock_guard<boost::mutex> lock(m_lock) ; DR_LOG(log_debug) << "ClientController storage counts" ; DR_LOG(log_debug) << "----------------------------------" ; DR_LOG(log_debug) << "m_clients size: " << m_clients.size() ; DR_LOG(log_debug) << "m_services size: " << m_services.size() ; DR_LOG(log_debug) << "m_request_types size: " << m_request_types.size() ; DR_LOG(log_debug) << "m_map_of_request_type_offsets size: " << m_map_of_request_type_offsets.size() ; DR_LOG(log_debug) << "m_mapDialogs size: " << m_mapDialogs.size() ; DR_LOG(log_debug) << "m_mapNetTransactions size: " << m_mapNetTransactions.size() ; DR_LOG(log_debug) << "m_mapAppTransactions size: " << m_mapAppTransactions.size() ; DR_LOG(log_debug) << "m_mapApiRequests size: " << m_mapApiRequests.size() ; DR_LOG(log_debug) << "m_mapDialogId2Appname size: " << m_mapDialogId2Appname.size() ; }
void ClientController::addNetTransaction( client_ptr client, const string& transactionId ) { boost::lock_guard<boost::mutex> l( m_lock ) ; m_mapNetTransactions.insert( make_pair( transactionId, client ) ) ; DR_LOG(log_debug) << "addNetTransaction: transactionId " << transactionId << "; size: " << m_mapNetTransactions.size() ; }