struct Node* ast_new_node(int token, int nch, struct Node** child, long long line){ struct Node* node = (struct Node *) malloc ( sizeof (struct Node) ); // free in ast_free_tree /* if(token==BELONG && 0){ // not used char* temp = strCatAlloc("", 3, child[1]->lexval.sval, "_", child[0]->lexval.sval); //child[1]->code = child[1]->lexval.sval; child[1]->lexval.sval = temp; }*/ node->token = token; node->type = UNKNOWN_T; // default node->typeCon = NULL; node->nch = nch; // assign children node->child = child; node->symbol = NULL; // default NULL node->line = line; // line # in source (for corresponding token) node->code = NULL; node->codetmp = NULL; node->scope[0] = sStackLevel; node->scope[1] = sStackTopId; node->tmp[0] = 0; #ifdef _AST_DEBUG_EXTRA debugInfo("ast_new_node :: create \n"); debugInfo("==DEBUG INFO==\n"); ast_output_tree(node, stdout,0); #endif return node; }
void CommonString::setString( const unsigned char * charstr ) { debugInfo ( __FILE__, __LINE__); //set me to be a NULL ? if( charstr == NULL) { this->clear(); return; } //use my char pointer to set to myself ?? if( this->stringData == charstr ) { return ; } debugInfo ( __FILE__, __LINE__); //set me to a empty string "" if( charstr[0]==0 ) { if(string_debug_cg) { printf(" hit ! \n"); } this->clear(); return; } //If this already has string , erase it. if ( stringData != NULL ) { this->clear(); } debugInfo ( __FILE__, __LINE__); //copy this->size = getStringSize( charstr ) ; if( string_debug_cg) { printf("size = %u \n", this->size ) ; } stringData = new unsigned char [ this->size+1 ]; //Not enough memory if( stringData == NULL ) { this->size = 0 ; return; } strcpy( (char *)this->stringData, ( char *) charstr ) ; return ; }
bool Server::isThisNameRegistered(const QString& name) { for (auto user: m_online_users) { if (user.name == name) { debugInfo(name + " found a match, already registered."); return true; } } debugInfo(name + " did not found a match, going to register."); return false; }
int Server::getIndexOfUEIp(const QString& ip) { for (unsigned i = 0; i < m_online_users.size(); ++i) { if (m_online_users.at(i).ip == ip) { debugInfo(ip + " found a match at index: " + QString::number(i)); return i; } } debugInfo(ip + " was not found on list. Returning -1."); return -1; }
bool Server::isThisIpRegistered(const QString& ip) { for (auto user: m_online_users) { if (user.ip == ip) { debugInfo(ip + " found a match, already registered."); return true; } } debugInfo(ip + " did not found a match, going to register."); return false; }
void IndigoOutput::toString (Array<char> &str) { if (_own_buf) str.copy(_buf); else throw IndigoError("can not convert %s to string", debugInfo()); }
string AbstractPlanNode::debug(const string& spacer) const { ostringstream buffer; buffer << spacer << "* " << debug() << "\n"; string info_spacer = spacer + " |"; buffer << debugInfo(info_spacer); // // Inline PlanNodes // if (!m_inlineNodes.empty()) { buffer << info_spacer << "Inline Plannodes: " << m_inlineNodes.size() << "\n"; string internal_spacer = info_spacer + " "; map<PlanNodeType, AbstractPlanNode*>::const_iterator it; for (it = m_inlineNodes.begin(); it != m_inlineNodes.end(); it++) { buffer << info_spacer << "Inline " << planNodeToString(it->second->getPlanNodeType()) << ":\n"; buffer << it->second->debugInfo(internal_spacer); } } // // Traverse the tree // string child_spacer = spacer + " "; for (int ctr = 0, cnt = static_cast<int>(m_children.size()); ctr < cnt; ctr++) { buffer << child_spacer << m_children[ctr]->getPlanNodeType() << "\n"; buffer << m_children[ctr]->debug(child_spacer); } return (buffer.str()); }
CommonString::CommonString( ) { debugInfo ( __FILE__, __LINE__); stringData = NULL; size = 0; }
QString Server::filterMessage(QString& dest, QString &from, QString data) { //currently, a data structure has the following format // ue_message(message);ue_dest(dest);ue_from(sender); //This function extracts both dest and message int i1 = data.indexOf("ue_message") + QString("ue_message").size() + 1; int i2 = data.indexOf("ue_dest") - 2; int i3 = data.indexOf("ue_dest") + QString("ue_dest").size() + 1; int i4 = data.indexOf("ue_from") - 2; int i5 = data.indexOf("ue_from") + QString("ue_from").size() + 1; int i6 = data.lastIndexOf(";") - 1; dest = data.mid(i3, i4 - i3) ; from = data.mid(i5, i6 - i5); debugInfo("Parsed dest:" + dest); debugInfo("Parsed dender:" + from); debugInfo("Parsed message:" + data.mid(i1, i2 - i1)); return data.mid(i1, i2 - i1); }
/** * Internal function used to clear persistent data (counters and SD) if requested by user at reset. * * @return <tt>true</tt> if all persistent data have been cleared */ boolean clearAllPersistentDataOnRequest() { delay(1000); if (digitalRead(USER_SWITCH_PIN) == LOW) { debugInfo("@Clear\r\n"); // reset all counters counters.reset(); if (sdFileLogger.clear()) { debugInfo("@SD Cleared\r\n"); } return true; } return false; }
string AbstractPlanNode::debug(const string& spacer) const { std::ostringstream buffer; buffer << spacer << "* " << debug() << "\n"; std::string info_spacer = spacer + " |"; buffer << debugInfo(info_spacer); // // Inline PlanNodes // if (!m_inlineNodes.empty()) { buffer << info_spacer << "Inline Plannodes: " << m_inlineNodes.size() << "\n"; string internal_spacer = info_spacer + " "; map<PlanNodeType, AbstractPlanNode*>::const_iterator it; for (it = m_inlineNodes.begin(); it != m_inlineNodes.end(); it++) { buffer << info_spacer << "Inline " << planNodeToString(it->second->getPlanNodeType()) << ":\n"; buffer << it->second->debugInfo(internal_spacer); } } // // Output table // Table* outputTable = getOutputTable(); buffer << info_spacer << "Output table:\n"; if (outputTable != NULL) { buffer << outputTable->debug(spacer + " "); } else { buffer << " " << info_spacer << "<NULL>\n"; } // // Input tables // for (int i = 0; i < getInputTableCount(); ++i) { Table* inputTable = getInputTable(i); buffer << info_spacer << "Input table " << i << ":\n"; if (inputTable != NULL) { buffer << inputTable->debug(spacer + " "); } else { buffer << " " << info_spacer << "<NULL>\n"; } } // // Traverse the tree // string child_spacer = spacer + " "; for (int ctr = 0, cnt = static_cast<int>(m_children.size()); ctr < cnt; ctr++) { buffer << child_spacer << m_children[ctr]->getPlanNodeType() << "\n"; buffer << m_children[ctr]->debug(child_spacer); } return (buffer.str()); }
// Attach the variable to the SemanticAnalysis node tree. void attachVar(Context& context, const String& name, const AST::Node<AST::TypeVar>& astTypeVarNode, SEM::Var* const var, const Debug::VarInfo::Kind varKind) { assert(var->isBasic()); const auto insertResult = insertVar(context.scopeStack().back(), name, var); if (!insertResult.second) { const auto existingVar = insertResult.first->second; throw ErrorException(makeString("Variable name '%s' at position %s duplicates existing variable of the same name at position %s.", name.c_str(), astTypeVarNode.location().toString().c_str(), existingVar->debugInfo()->declLocation.toString().c_str())); } var->setDebugInfo(makeVarInfo(varKind, astTypeVarNode)); }
/** * LEDs initialization */ void initSD() { pinMode(SD_CARD_CHIP_SELECT_PIN, OUTPUT); debugInfo("@SD_"); if (!SD.begin(SD_CARD_CHIP_SELECT_PIN)) { debugInfo("KO\r\n"); } else { debugInfo("OK\r\n"); } if (!clearAllPersistentDataOnRequest()) { debugInfo("@Restart\r\n"); resetCounter.increment(1); } }
void CommonString::append( const unsigned char * charstr ) { if ( charstr == 0 ) return ; //NULL and empty string "" is different size_t part2Size ; part2Size = strlen( (const char *)charstr ); if ( part2Size <= 0) { return ; } //Both str1 and str2 have something, none of them are "" "" debugInfo ( __FILE__, __LINE__); unsigned char * temp_p; unsigned long size; size = this->getSize() + part2Size + 1; temp_p = new unsigned char [ size ]; debugInfo ( __FILE__, __LINE__); strcpy ( ( char *)temp_p, (const char *)this->getChar_p_readonly() ); strcat( (char *)temp_p , (const char *)charstr ); this->setString( temp_p); delete temp_p; return ; }
// destroy Symbol Table entry void s_destroy_entry ( gpointer dummy1, gpointer entry, gpointer dummy2 ) { #ifdef _DEBUG debugInfo("Destroy Entry: "); s_show_entry(NULL, entry, DEBUGIO); #endif SymbolTableEntry* e = ( SymbolTableEntry* ) entry ; if (e->typeCon != NULL) { g_array_free( e->typeCon, 1 ); #ifdef _DEBUG debugInfoExt(" >> destroy typeCon... \n"); #endif } free( e ); }
GList* s_table_all_variables_in_scope (SymbolTable* table, ScopeId sid, int type) { GList* gl = NULL; GList* vals = g_hash_table_get_values( table ); int i, l = g_list_length( vals ); for ( i=0; i<l; ++i ) { SymbolTableEntry * e = (SymbolTableEntry *) g_list_nth_data( vals, i ); if ( e->scope[1] == sid && e->type == type ) { #ifdef _DEBUG debugInfo("s_table_all_variables_in_scope: sid = %d, type = %d, %s\n", sid, type, e->bind); #endif gl = g_list_append( gl, (gpointer) e ); } } g_list_free(vals); return gl; }
int ModuleI2C::init() { bool ret = Module::init(); if(ret) { // wiring PI Setup always returns 0. it does fatal faults... wiringPiSetup(); i2cFileHandle = wiringPiI2CSetup(i2cAddress); if(i2cFileHandle == -1) return failed("I2C file handle for address " + std::to_string(i2cAddress) + " could not be created"); } debugInfo("I2C Library init done for device on address: " + std::to_string(i2cAddress)); return ret; }
void ast_free_tree(struct Node* node) { if ( node == NULL ) return; #ifdef _AST_DEBUG_MEMORY debugInfo("TO FREE node:"); ast_output_node(node, DEBUGIO, "\n"); #endif /* free sval */ if ( node->token == STRING_LITERAL || node->token == IDENTIFIER ) { #ifdef _AST_DEBUG_MEMORY debugInfo("FREE sval: %s\n",node->lexval.sval); #endif free(node->lexval.sval); // malloc by LexAly.l node->lexval.sval = NULL; } /* free code */ if ( node->code != NULL ) { #ifdef _AST_DEBUG_MEMORY debugInfo("FREE code: %s\n", node->code); #endif free(node->code); node->code = NULL; } if ( node->codetmp != NULL ) { #ifdef _AST_DEBUG_MEMORY debugInfo("FREE codetmp: %s\n", node->codetmp); #endif free(node->codetmp); node->codetmp = NULL; } /* if child exsits, free child first */ if ( node->nch > 0 && node->child != NULL ) { // free children int i;for(i=0; i<node->nch; ++i) { ast_free_tree( node->child[i] ); node->child[i] = NULL; } // free child ptr array #ifdef _AST_DEBUG_MEMORY debugInfo("FREE child ptrs in "); ast_output_node(node, DEBUGIO, "\n"); #endif free(node->child); node->child = NULL; } else if (node->nch > 0 || node->child != NULL) { fprintf(stderr, "ERROR:: ast_free_tree :: nch does NOT match child! code bug detected!!\n "); } /* free myself */ #ifdef _AST_DEBUG_MEMORY debugInfo("FREE this node : %d", node->token); ast_output_node(node, DEBUGIO, "\n"); fflush(DEBUGIO); #endif free(node); node = NULL; return; }
// Broadcast character's position void GameEngine::SendCharacterPosition(int _indexCharacter) { MovingObject *character = m_characters[_indexCharacter]; if (character == NULL || character->IsDead()) return; InfoForDisplay info = character->GetInfoForDisplay(); Event posInfo(&info); m_eventEngine->dispatch(CHAR_POS_UPDATED, &posInfo); #ifdef DEBUG_MODE if (_indexCharacter == m_indexMario) { *m_debugInfo = character->GetDebugInfo(); Event debugInfo(m_debugInfo); m_eventEngine->dispatch(DEBUG_INFO_UPDATED, &debugInfo); } #endif }
std::string AbstractExpression::debug(const std::string &spacer) const { std::ostringstream buffer; buffer << spacer << "+ " << debug() << "\n"; std::string info_spacer = spacer + " "; buffer << debugInfo(info_spacer); // process children if (m_left != NULL || m_right != NULL) { buffer << info_spacer << "left: " << (m_left != NULL ? "\n" + m_left->debug(info_spacer) : "<NULL>\n"); buffer << info_spacer << "right: " << (m_right != NULL ? "\n" + m_right->debug(info_spacer) : "<NULL>\n"); } return (buffer.str()); }
void CommonString::print( void ) { debugInfo ( __FILE__, __LINE__); if( this->getChar_p()!= NULL ) { if( this->getSize() <=0) printf("<empty string \"\"> " ); else printf("%s", this->getChar_p() ); }else { printf("<NULL>" ); } }
/** * Internal function used to initialize serial debug. */ void initDebugSerial() { SERIAL_DEBUG.begin(SERIAL_DEBUG_BAUDRATE); debugInfo("@Reset\r\n"); }
//设置在屏幕上的坐标(像素) VOID CCreatureBoard::SetPosition(FLOAT nX, FLOAT nY) { float fAlpha = 1.0f; if(m_nDistance > CUICreatureBoardSystem::GetMe()->GetMaxDispearDistance()) { m_pWindow->hide(); return; } if(m_nDistance > CUICreatureBoardSystem::GetMe()->GetMaxDistance()) { fAlpha -= (m_nDistance - CUICreatureBoardSystem::GetMe()->GetMaxDistance() )/ ( CUICreatureBoardSystem::GetMe()->GetMaxDispearDistance() - CUICreatureBoardSystem::GetMe()->GetMaxDistance()); } CEGUI::Point fPos(nX, nY); float fOffset = 0; float fY = fPos.d_y; CEGUI::Size size; // 判断是否要显示 if( m_bShowHpLevel ) { if( m_pHPlevelWindow && m_pHPWindow ) { // 计算位置 fOffset -= m_pHPlevelWindow->getAbsoluteHeight(); fPos.d_y += fOffset; fPos.d_x -= m_pHPlevelWindow->getAbsoluteWidth() / 2.0f; m_pHPlevelWindow->setPosition(CEGUI::Absolute, fPos); // 血条 m_pHPWindow->setPosition(CEGUI::Absolute, fPos); // 设置进度 ((CEGUI::ProgressBar*)m_pHPWindow)->setProgress( m_fProgross ); //laim1648 m_pHPWindow->show(); } } // 恢复x偏移 fPos.d_x = nX; fPos.d_y = nY; // 计算名字的位置 fPos.d_y += fOffset; ( ( CEGUI::IFalagardSelfFitWindow* )( CEGUI::FalagardSelfFitWindow* )m_pNameWindow )->setCenter(fPos); fOffset -= m_pNameWindow->getAbsoluteHeight(); // 名字 if( m_pNameWindow->isVisible() && !( m_pNameWindow->getText().empty() ) ) { m_pWindow->show(); debugInfo(); } else { // 摆摊状态时,其他玩家名字不显示时,信息板还要显示 20100527 BLL if ( m_bShowStallSign == FALSE ) { m_pWindow->hide(); } else m_pWindow->show(); } // 20100504 AddCodeBegin // 级别显示在玩家名字后面 if( m_bShowHpLevel ) { CEGUI::Point fLevelPos = m_pNameWindow->getAbsolutePosition(); CEGUI::Size nameSize = m_pNameWindow->getAbsoluteSize(); fLevelPos.d_x = fLevelPos.d_x + nameSize.d_width; ( ( CEGUI::IFalagardSelfFitWindow* )( CEGUI::FalagardSelfFitWindow* )m_pLevelTextWindow )->setCenter(fLevelPos); m_pLevelTextWindow->setPosition( CEGUI::Absolute, fLevelPos ); m_pLevelIcoWindow->setPosition( CEGUI::Absolute, fLevelPos ); if( !m_bShowLevelIco ) { m_pLevelTextWindow->show(); } else { size = m_pNameWindow->getAbsoluteSize(); size.d_width = size.d_height; m_pLevelIcoWindow->setSize( CEGUI::Absolute, size ); m_pLevelIcoWindow->show(); } } // 20100504 AddCodeEnd // 国家称号 if( m_bCountryTitle && !( m_pCountryTitleWindow->getText().empty() ) ) { fPos.d_y = fY + fOffset; ((CEGUI::IFalagardSelfFitWindow*)(CEGUI::FalagardSelfFitWindow*)m_pCountryTitleWindow)->setCenter( fPos ); fOffset -= m_pCountryTitleWindow->getAbsoluteHeight(); m_pCountryTitleWindow->show(); } // 帮会称号 if( m_bGuildTitle && !( m_pGuildTitleWindow->getText().empty() ) ) { fPos.d_y = fY + fOffset; ((CEGUI::IFalagardSelfFitWindow*)(CEGUI::FalagardSelfFitWindow*)m_pGuildTitleWindow)->setCenter( fPos ); fOffset -= m_pGuildTitleWindow->getAbsoluteHeight(); m_pGuildTitleWindow->show(); } // 称号 if( m_bTitle && !(m_pTitleWindow->getText().empty()) ) { fPos.d_y = fY + fOffset; ((CEGUI::IFalagardSelfFitWindow*)(CEGUI::FalagardSelfFitWindow*)m_pTitleWindow)->setCenter(fPos); fOffset -= m_pTitleWindow->getAbsoluteHeight(); m_pTitleWindow->show(); } // 摆摊 if( m_pSaleWindow->isVisible() ) { fPos.d_y = fY + fOffset; m_pSaleWindow->setProperty( "HookPosition", CEGUI::PropertyHelper::pointToString( fPos ) ); ((CEGUI::PushButton*)m_pSaleWindow)->resizeWithText(); fOffset -= m_pSaleWindow->getAbsoluteHeight(); } // 头顶泡泡 if( m_pPaoPao->isVisible() ) { fPos.d_y = fY + fOffset; ((CEGUI::IFalagardSelfFitWindow*)(CEGUI::FalagardSelfFitWindow*)m_pPaoPao)->setCenter(fPos); fOffset -= m_pPaoPao->getAbsoluteHeight(); } // PK标志 // 20100513 ModifyCodeBegin if( m_pPKWindow->isVisible() ) { CEGUI::Size pkSize; fOffset -= m_pPKWindow->getAbsoluteHeight(); fPos.d_y = fY + fOffset; fPos.d_x = nX - m_pPKWindow->getAbsoluteWidth() / 2; //pkSize.d_width = ((CEGUI::StaticImage*)m_pPKWindow)->getImage()->getWidth(); //pkSize.d_height = ((CEGUI::StaticImage*)m_pPKWindow)->getImage()->getHeight(); pkSize = CEGUI::AnimateManager::getSingleton().getAnimate( (CEGUI::utf8*)"questsign_accept" )->getSize(); m_pPKWindow->setSize( CEGUI::Absolute, pkSize ); m_pPKWindow->setPosition( CEGUI::Absolute, fPos ); } // 20100513 ModifyCodeEnd // 国家标志 size = m_pNameWindow->getAbsoluteSize(); fPos = m_pNameWindow->getAbsolutePosition(); fPos.d_x -= size.d_height; m_pCountryFlag->setPosition(CEGUI::Absolute, fPos); size.d_width = size.d_height; m_pCountryFlag->setSize(CEGUI::Absolute, size); // 队长标志 size = m_pNameWindow->getAbsoluteSize(); fPos = m_pNameWindow->getAbsolutePosition(); // 20100504 ModifyCodeBegin 级别改为在名字后面显示后,修改队长标记位置 CEGUI::Size levelTextSize = m_pLevelTextWindow->getAbsoluteSize(); fPos.d_x += size.d_width; fPos.d_x += levelTextSize.d_width; // 20100504 ModifyCodeEnd m_pLeadFlag->setPosition(CEGUI::Absolute, fPos); size.d_width = size.d_height; m_pLeadFlag->setSize(CEGUI::Absolute, size); // 帮派权限图标标的位置 size = m_pTitleWindow->getAbsoluteSize(); fPos = m_pTitleWindow->getAbsolutePosition(); fPos.d_x -= size.d_height; m_pBangpaiFlag->setPosition( CEGUI::Absolute, fPos ); size.d_width = size.d_height; m_pBangpaiFlag->setSize( CEGUI::Absolute, size ); // 设置透明度 m_pCountryFlag->setAlpha( fAlpha ); m_pBangpaiFlag->setAlpha( fAlpha ); m_pLeadFlag->setAlpha( fAlpha ); m_pPKWindow->setAlpha( fAlpha ); m_pSaleWindow->setAlpha( fAlpha ); m_pNameWindow->setAlpha( fAlpha ); m_pTitleWindow->setAlpha(fAlpha); m_pCountryTitleWindow->setAlpha(fAlpha); m_pGuildTitleWindow->setAlpha(fAlpha); switch( m_InfoState ) { case STATE_NORMAL: break; case STATE_DIE: m_pNameWindow->setProperty( "TextColor", CEGUI::PropertyHelper::colourToString( CEGUI::colour( 0.5,0.5,0.5, fAlpha ) ) ); break; default: break; } }
// See if a previous image is still running of the process we're debugging // Might want to keep the thread/process in a state of suspended animation BOOL PreviousStillRunning(std::wstring & exeImageName, DWORD processId) { // Why all this rigamorole when there's: // // DebugEv->u.CreateProcessInfo.lpImageName? // // Ok, here's why: // // "This member is strictly optional. Debuggers must be prepared to handle // the case where lpImageName is NULL or *lpImageName (in the address space // of the process being debugged) is NULL. Specifically, the system does // not provide an image name for a create process event, and will not // likely pass an image name for the first DLL event. The system also // does not provide this information in the case of debug events that // originate from a call to the DebugActiveProcess function. DWORD dwPIDCount; static smPROCESSINFO lpi[MAX_PI] = {0}; // Get processes list debugInfo(L"Beginning process enumeration"); dwPIDCount = EnumProcesses2Array(lpi); debugInfo(L"Ending process enumeration"); smPROCESSINFO* outerExecutiveProcessInfo = NULL; // remember we run a "CMD" via system() smPROCESSINFO* cmdShellOuterProcessInfo = NULL; // remember we run a "CMD /C" via system() smPROCESSINFO* cmdShellInnerProcessInfo = NULL; smPROCESSINFO* nestedExecutiveProcessInfo = NULL; smPROCESSINFO* mainDebuggeeProcessInfo = NULL; DWORD outerExecutiveProcessId = GetCurrentProcessId(); DWORD cmdShellOuterProcessId = 0; DWORD cmdShellInnerProcessId = 0; DWORD nestedExecutiveProcessId = 0; DWORD mainDebuggeeProcessId = 0; { if (WaitForSingleObject(processListMutex, INFINITE) != WAIT_OBJECT_0) WindowsVerify(L"WaitForSingleObject", FALSE); if (numProcesses > 0) cmdShellOuterProcessId = processIds[0]; if (numProcesses > 1) cmdShellInnerProcessId = processIds[1]; if (numProcesses > 2) nestedExecutiveProcessId = processIds[2]; if (numProcesses > 3) mainDebuggeeProcessId = processIds[3]; WindowsVerify(L"ReleaseMutex", ReleaseMutex(processListMutex)); } // little sanity check here... // How would we receive these debug events if the shell isn't running?! Verify(L"Nested executive command process couldn't be found.", cmdShellOuterProcessId != 0 ); if (mainDebuggeeProcessId == 0) { return FALSE; // not ready to do the process test yet. } if (processId != 0 and mainDebuggeeProcessId != processId) { return FALSE; // don't suspend threads in wrong process! } for (int index = 0; index < dwPIDCount; index++) { if (lpi[index].dwPID == outerExecutiveProcessId) outerExecutiveProcessInfo = &lpi[index]; if (lpi[index].dwPID == cmdShellOuterProcessId) cmdShellOuterProcessInfo = &lpi[index]; if (lpi[index].dwPID == cmdShellInnerProcessId) cmdShellInnerProcessInfo = &lpi[index]; if (lpi[index].dwPID == nestedExecutiveProcessId) nestedExecutiveProcessInfo = &lpi[index]; if (lpi[index].dwPID == mainDebuggeeProcessId) mainDebuggeeProcessInfo = &lpi[index]; } debugInfo(L"GetNtProcessInfo(%s)", mainDebuggeeProcessInfo->szImgPath); for (int index = 0; index < dwPIDCount; index++) { if (lpi[index].dwPID == outerExecutiveProcessId) continue; if (lpi[index].dwPID == cmdShellOuterProcessId) continue; if (lpi[index].dwPID == cmdShellInnerProcessId) continue; if (lpi[index].dwPID == nestedExecutiveProcessId) continue; if (lpi[index].dwPID == mainDebuggeeProcessId) continue; // windows filenames are case insensitive debugInfo(L"Process Image: %s", lpi[index].szImgPath); if (!lstrcmpi(mainDebuggeeProcessInfo->szImgPath, lpi[index].szImgPath)) { exeImageName = std::wstring(mainDebuggeeProcessInfo->szImgPath); return TRUE; } } return FALSE; }
// EnterDebugLoop was taken from: // http://msdn.microsoft.com/en-us/library/ms681675(VS.85).aspx // // Note that we don't actually *want* to be a debugger, but CreateProcess has // some bug or security dependency which is leading it to (in some situations) // not show the window of the process it launches. Somehow, calling a debug // loop addresses this. I've left the full code from the sample here in order // to make it easier to set breakpoints to discover what's going wrong if // there is a problem with the technique of working around CreateProcess's // flaw with the debug API. // DWORD WINAPI DebugLoopMain(LPVOID lpParam) // returns a MainReturn { DebugArgs & debugArgs = *static_cast<DebugArgs *>(lpParam); HMODULE ntDllModule = sm_LoadNTDLLFunctions(); debugInfo(L"Got to DebugLoopMain thread code."); PROCESS_INFORMATION processInfo; processInfo.hProcess = NULL; processInfo.hThread = NULL; // Windows can modify the command line, so we have to make a copy std::vector<WCHAR> commandLineCopy ( debugArgs.commandLine.begin(), debugArgs.commandLine.end() ); commandLineCopy.push_back(L'\0'); DWORD dwCreationFlags = #ifdef USE_STARTUPINFO_FOR_WINDOW_POSITION // These options don't work :-( (config->runWindowPosition ? STARTF_USEPOSITION : 0) | (config->runWindowSize ? STARTF_USESIZE : 0) | #endif (config->shutdownEvent ? 0 : DEBUG_PROCESS) | STARTF_USESHOWWINDOW; // REVIEW: for security should lpApplicationName be the same as the // name in the command line? WindowsVerify( L"CreateProcess", CreateProcess( 0, // lpApplicationName &commandLineCopy[0], // lpCommandLine (no .data() in C++98) 0, // lpProcessAttributes 0, // lpThreadAttributes config->shutdownEvent == NULL ? TRUE : FALSE, // bInheritHandles dwCreationFlags, 0, // lpEnvironment 0, // lpCurrentDirectory debugArgs.startupInfo, // lpStartupInfo &processInfo // lpProcessInformation ) ); Verify(L"Thread or process was null.", processInfo.hThread and processInfo.hProcess ); debugInfo(L"CreateProcess(%s) - Id = %d\n", debugArgs.commandLine.c_str(), processInfo.dwProcessId ); debugInfo(L"Entering debugger loop...\n"); HANDLE suspendedThread = NULL; BOOL previouslyWaited = FALSE; DEBUG_EVENT Ev; const LPDEBUG_EVENT DebugEv = &Ev; while (TRUE) { // Wait for a debugging event to occur. The second parameter indicates // that the function does not return until a debugging event occurs. BOOL gotDebugEvent = FALSE; BOOL handledEvent = TRUE; DWORD tickBefore = GetTickCount(); if (WaitForDebugEvent( DebugEv, suspendedThread ? 1000 : *debugArgs.msecLeft )) { gotDebugEvent = TRUE; } else { DWORD lastError = GetLastError(); if (lastError == 0x79) { // The semaphore timeout period has expired, that is ok } else { ExitProgramOnWindowsError(L"WaitForDebugEvent", lastError); } } if (suspendedThread) { switch(WaitForSingleObject(debugArgs.retryEvent, 0)) { case WAIT_OBJECT_0: { WindowsVerify(L"ResetEvent", ResetEvent(debugArgs.retryEvent)); // need to poll processes again... std::wstring exeImageName; if (PreviousStillRunning(exeImageName, 0)) { debugInfo(L"Retry failed, show message box again."); WindowsVerify(L"SetEvent", SetEvent(debugArgs.deferEvent)); } else { debugInfo(L"Resuming thread handle 0x%x", suspendedThread); WindowsVerify(L"ResumeThread", ResumeThread(suspendedThread) != -1 ); WindowsVerify(L"CloseHandle", CloseHandle(suspendedThread)); suspendedThread = NULL; previouslyWaited = TRUE; } break; } case WAIT_TIMEOUT: // nope, do nothing, try again in a second... break; default: WindowsVerify(L"WaitForSingleObject", FALSE); } } DWORD tickAfter = GetTickCount(); if (*debugArgs.msecLeft != INFINITE) { bool timedOut = false; if (tickAfter < tickBefore) { // happens once every 28 days, the tick count rolls over... // account for the rollover only if (tickBefore > *debugArgs.msecLeft) { timedOut = true; } else { *debugArgs.msecLeft = *debugArgs.msecLeft - tickBefore; } } else { if (tickAfter - tickBefore > *debugArgs.msecLeft) { timedOut = true; } else { *debugArgs.msecLeft = *debugArgs.msecLeft - (tickAfter - tickBefore); } } if (timedOut) { // Need to take the screenshot here, because if we return from // the DebugLoop the windows will be closed and the state lost // by the time we return to the caller if (not config->timeoutSnapshot.empty()) { Verify(L"Screen Capture Failed", TakeScreenshotToFile(config->timeoutSnapshot.c_str()) ); } return TitleWait::TimeoutReturn; } } // Process the debugging event code. if (gotDebugEvent) { switch (DebugEv->dwDebugEventCode) { case EXCEPTION_DEBUG_EVENT: { // Process the exception code. When handling // exceptions, remember to set the continuation // status parameter (dwContinueStatus). This value // is used by the ContinueDebugEvent function. switch(DebugEv->u.Exception.ExceptionRecord.ExceptionCode) { case EXCEPTION_ACCESS_VIOLATION: { // First chance: Pass this on to the system. // Last chance: Display an appropriate error. debugInfo(L"EXCEPTION_ACCESS_VIOLATION"); if (not config->crashSnapshot.empty()) { Verify(L"Screen Capture Failed", TakeScreenshotToFile(config->crashSnapshot.c_str()) ); } debugInfo(L"Child Process Crashed - Quitting"); return TitleWait::CrashedReturn; } case EXCEPTION_BREAKPOINT: { // First chance: Display the current // instruction and register values. debugInfo(L"EXCEPTION_BREAKPOINT"); // No process functions during CREATE_PROCESS_DEBUG_EVENT // have to wait for a later time if (!config->defer or previouslyWaited or suspendedThread) break; if (PreviousStillRunning( debugArgs.exeImageName, DebugEv->dwProcessId )) { WindowsVerify(L"SetEvent", SetEvent(debugArgs.deferEvent)); // don't block, keep processing debug events... // but suspend the thread! debugInfo( L"About to suspend thread handle 0x%x", DebugEv->dwThreadId ); suspendedThread = OpenThread( THREAD_SUSPEND_RESUME, FALSE, DebugEv->dwThreadId ); WindowsVerify(L"OpenThread", suspendedThread != NULL); WindowsVerify(L"Suspend Thread", SuspendThread(suspendedThread) != -1 ); } } break; case EXCEPTION_DATATYPE_MISALIGNMENT: // First chance: Pass this on to the system. // Last chance: Display an appropriate error. debugInfo(L"EXCEPTION_DATATYPE_MISALIGNMENT"); break; case EXCEPTION_SINGLE_STEP: // First chance: Update the display of the // current instruction and register values. debugInfo(L"EXCEPTION_SINGLE_STEP"); break; case DBG_CONTROL_C: // First chance: Pass this on to the system. // Last chance: Display an appropriate error. debugInfo(L"DBG_CONTROL_C"); break; default: debugInfo( L"EXCEPTION_(0x%x) (unrecognized, passing through)", DebugEv->u.Exception.ExceptionRecord.ExceptionCode ); // We have debugger behaviors for everything we // understand, but not random exceptions...pass on up // the chain and say we don't handle it. handledEvent = false; break; } break; } case CREATE_THREAD_DEBUG_EVENT: { // As needed, examine or change the thread's registers // with the GetThreadContext and SetThreadContext functions; // and suspend and resume thread execution with the // SuspendThread and ResumeThread functions. debugInfo( L"CREATE_THREAD_DEBUG_EVENT - H: 0x%x - P: 0x%x", DebugEv->u.CreateThread.hThread, DebugEv->dwProcessId ); break; } case CREATE_PROCESS_DEBUG_EVENT: { // As needed, examine or change the registers of the // process's initial thread with the GetThreadContext and // SetThreadContext functions; read from and write to the // process's virtual memory with the ReadProcessMemory and // WriteProcessMemory functions; and suspend and resume // thread execution with the SuspendThread and ResumeThread // functions. SetLastError(0); DWORD processId = GetProcessId( DebugEv->u.CreateProcessInfo.hProcess ); DWORD lastError = GetLastError(); if (lastError != ERROR_SUCCESS) { ExitProgramOnWindowsError(L"GetProcessId", lastError); } debugInfo( L"CREATE_PROCESS_DEBUG_EVENT - P: 0x%x - T: 0x%x", processId, DebugEv->dwThreadId ); DWORD processMonThreadId; HANDLE processMonThread = CreateThread( NULL, // default security attributes 0, // use default stack size ProcessMonitorMain, // thread function name // argument to thread function DebugEv->u.CreateProcessInfo.hProcess, CREATE_SUSPENDED, // create the thread as suspended &processMonThreadId); // returns thread identifier if (processMonThread == NULL) { WindowsVerify(L"CreateThread", FALSE); } // lock process list mutex and append tracking data for thread if (WaitForSingleObject(processListMutex, INFINITE) != WAIT_OBJECT_0) { WindowsVerify(L"WaitForSingleObject", FALSE); } processIds[numProcesses] = processId; processMonThreads[numProcesses] = processMonThread; numProcesses++; WindowsVerify(L"ReleaseMutex", ReleaseMutex(processListMutex)); WindowsVerify(L"ResumeThread", ResumeThread(processMonThread) != -1 ); // "Be sure to close the handle to the process image // file with CloseHandle." Ok, sure. WindowsVerify(L"CloseHandle", CloseHandle(DebugEv->u.CreateProcessInfo.hFile) ); break; } case EXIT_THREAD_DEBUG_EVENT: debugInfo(L"EXIT_THREAD_DEBUG_EVENT"); break; case EXIT_PROCESS_DEBUG_EVENT: { // Display the process's exit code. We should only get this if // the main spawn has returned. This should not happen, ever, // but if we catch the first spawn we can perhaps watch on it // and pipe its result back. debugInfo( L"EXIT_PROCESS_DEBUG_EVENT - ExitCode: 0x%x", DebugEv->u.ExitProcess.dwExitCode ); #ifdef QUIT_WHEN_MAIN_PROCESS_EXITS // we used to exit here, but now we wait for the LAST // process exiting signal. We could in theory return // ClosedReturn if we want the behavior of quitting // just because the main process we spawned quit...but that // is not a good default when people are using things like // iexplore which launches a child.... so // make that a non-default option? if (WaitForSingleObject(lastProcessExitedEvent, INFINITE) != WAIT_OBJECT_0 ) { WindowsVerify(L"WaitForSingleObject", FALSE); } if (processInfo.hThread) { WindowsVerify(L"CloseHandle", CloseHandle(processInfo.hThread) ); } if (processInfo.hProcess) { WindowsVerify(L"CloseHandle", CloseHandle(processInfo.hProcess) ); } sm_FreeNTDLLFunctions(ntDllModule); return ClosedReturn; #endif break; } case LOAD_DLL_DEBUG_EVENT: // Read the debugging information included in the newly // loaded DLL. Be sure to close the handle to the loaded DLL // with CloseHandle. WindowsVerify(L"CloseHandle", CloseHandle(DebugEv->u.LoadDll.hFile) ); #ifdef DEBUG_DLL_EVENTS // A lot of these go by, disable by default debugInfo(L"LOAD_DLL_DEBUG_EVENT"); #endif break; case UNLOAD_DLL_DEBUG_EVENT: #ifdef DEBUG_DLL_EVENTS // A lot of these go by, disable by default debugInfo(L"UNLOAD_DLL_DEBUG_EVENT"); #endif break; case OUTPUT_DEBUG_STRING_EVENT: // Client wants us to display the output debug string. // Pass through to WinDbg or display ourselves? // For now, say we don't handle it. handledEvent = false; debugInfo( L"OUTPUT_DEBUG_STRING_EVENT - ExceptionCode 0x%x", DebugEv->u.Exception.ExceptionRecord.ExceptionCode ); break; case RIP_EVENT: debugInfo(L"RIP_EVENT"); break; } // Resume executing the thread that reported the debugging event. WindowsVerify( L"ContinueDebugEvent", ContinueDebugEvent( DebugEv->dwProcessId, DebugEv->dwThreadId, handledEvent ? DBG_CONTINUE : DBG_EXCEPTION_NOT_HANDLED ) ); } } // end while(TRUE) loop if (processInfo.hThread) { WindowsVerify(L"CloseHandle", CloseHandle(processInfo.hThread)); } if (processInfo.hProcess) { WindowsVerify(L"CloseHandle", CloseHandle(processInfo.hProcess)); } sm_FreeNTDLLFunctions(ntDllModule); // unreachable point return TitleWait::InternalErrorReturn; }
void AltSpeedController::updateAltitude(cvg_double curAlt, cvg_double maxAltSpeedCommand) { if (!enabled) return; /* cvg_double elapsed = dTimer.getElapsedSeconds(); dTimer.restart(started); // Filter altitude for (cvg_int i = 0; i < ALTSC_D_FILTER_LENGTH - 1; i++) dHistory[i] = dHistory[i + 1]; dHistory[ALTSC_D_FILTER_LENGTH - 1] = curAlt; cvg_double fAlt = 0.0; cvg_double weight = 2.0 / (ALTSC_D_FILTER_LENGTH + 1); for (cvg_int i = 0; i < ALTSC_D_FILTER_LENGTH; i++) { fAlt += weight * dHistory[ALTSC_D_FILTER_LENGTH - i - 1]; #if ALTSC_D_FILTER_LENGTH > 1 weight -= (2.0 / (ALTSC_D_FILTER_LENGTH * (ALTSC_D_FILTER_LENGTH + 1))); #endif } */ cvg_double fAlt = curAlt; /* if (fAlt == lastAlt) { repeatCount++; if (repeatCount >= 10) repeatCount = 0; } else { repeatCount = 0; } */ repeatCount++; if (repeatCount >= SUBSAMPLING_DIVIDER) repeatCount = 0; cvg_double altSpeed, altSpeedF; if (repeatCount == 0) { if (!started) { started = true; lastAlt = fAlt; } cvg_double elapsed = dTimer.getElapsedSeconds(); dTimer.restart(); altSpeed = (fAlt - lastAlt) / elapsed; // Altitude speed saturation to avoid altitude sensor peaks cvg_double speedLimit = fabs(maxAltSpeedCommand * ALT_SPEED_MEASURE_SATURATION_FACTOR); if (altSpeed > speedLimit) altSpeed = speedLimit; else if (altSpeed < -speedLimit) altSpeed = -speedLimit; lastAlt = fAlt; // altSpeedF = outputFilter.filter(altSpeed); // lastSpeedF = altSpeedF; lastSpeed = altSpeed; } else { // altSpeedF = lastSpeedF; altSpeed = lastSpeed; } altSpeedF = outputFilter.filter(altSpeed); #ifdef SHOW_DEBUG debugInfo(cvgString("A_measure:") + curAlt + " A_filt:" + fAlt + " AS_calc:" + altSpeed + " AS_filt:" + altSpeedF); #endif pid.setFeedback(altSpeedF); }
void debug(int INmode) { ClearScreen(); SDL_Flip(screen); selectGame(1); gameResetVars(); if (INmode==2) //ClearFullRows() { for (int i=0; i<AREA_HEIGHT+2; i++) { for (int j=0; j<AREA_WIDTH; j++) { area[j][i] = (rand()%15)-EMPTY_AREA; if (area[j][i]>EMPTY_AREA) area[j][i]=area[j][i]%3+1; } } drawBoard(); SDL_Delay(5000); clearFullRows(); SDL_Delay(250); drawBoard(); SDL_Delay(5000); } else if (INmode==3) //drawTetromino() { int tets,angl; for (tets=0; tets<7; tets++) { for (angl=0; angl<4; angl++) { ClearScreen(); drawTetromino(tets,(angl+2)%4,0,0,REAL_TET); SDL_Flip(screen); SDL_Delay(600); } } } else if (INmode==4) //peiceSetinto() { pieceCreate(COMING); tetUD=10; drawTetromino(currentPiece,currentRotate,tetLR,tetUD,REAL_TET); SDL_Delay(3000); drawBoard(); SDL_Delay(3000); pieceSetInto(currentPiece); drawBoard(); SDL_Delay(3000); debugInfo(0); } else if (INmode==5) //peiceCreate() { for (int i=0; i<10; i++) { pieceCreate(COMING); ClearScreen(); printf("c%d n%d n%d n%d\n",currentPiece,nextPiece[0],nextPiece[1],nextPiece[2]); SDL_Delay(100); } } else if (INmode==6) //gravity { pieceCreate(COMING); while(tetUD<AREA_HEIGHT) //off by 2? { ClearScreen(); //drawBoard(true); drawTetromino(currentPiece,currentRotate,tetLR,tetUD,REAL_TET); printf("y=%d",tetUD); SDL_Delay(1000); tetUD++; } } }
void Function::setDebugPosition(const Debug::SourcePosition& position) { const auto debugLoc = llvm::DebugLoc::get(position.lineNumber(), position.column(), debugInfo()); getBuilder().SetCurrentDebugLocation(debugLoc); }
void Shader::getTranslatedSourceWithDebugInfo(GLsizei bufSize, GLsizei *length, char *buffer) const { std::string debugInfo(mShader->getDebugInfo()); getSourceImpl(debugInfo, bufSize, length, buffer); }
void Server::acceptUser() { //to be called every time a new connection is received QTcpSocket *socket = m_tcp_server->nextPendingConnection(); debugInfo("New incoming connection, from IP " + socket->peerAddress().toString() + " and port: " + QString::number(socket->peerPort())); //check if ip is registered if (!isThisIpRegistered(socket->peerAddress().toString())) { //then parse user UE new_ue; new_ue.name = ""; new_ue.ip = socket->peerAddress().toString(); //will change when ue_name() is sent new_ue.rx_port = 0; m_online_users.append(new_ue); debugInfo("New empty UE registered!"); } else { debugInfo("user is transmitting either its name or data"); socket->waitForReadyRead(1000); //parse data QDataStream in(socket); in.setVersion(QDataStream::Qt_4_0); debugInfo("m_block_size: " + QString::number(m_block_size)); if (m_block_size == 0) { if (socket->bytesAvailable() < (int)sizeof(quint16)) return; in >> m_block_size; } debugInfo("bytes available in socket: " + QString::number(socket->bytesAvailable())); if (socket->bytesAvailable() < m_block_size) return; QString message; in >> message; debugInfo(">Message: [" + message + "]"); ProtocolStreamType_UE type; QStringList params = m_protocol->parseStream_UE(type, message); switch (type) { case UE_REGISTER: { QString temp_name = params.at(0); quint16 temp_port = (quint16) params.at(1).toInt(); DLOG (INFO) << "Parsed port: " << temp_port; if (temp_name.isEmpty()) { m_block_size=0; return; } UE temp; int index; if (!isThisNameRegistered(temp_name)) { //case for same ip, different name debugInfo("New user " + temp_name + " connected from same IP. Registering user."); temp.name = temp_name; temp.ip = socket->peerAddress().toString(); //parse ue_rx_port temp.rx_port = temp_port; index = getIndexOfUEIp(socket->peerAddress().toString()); if (m_online_users.at(index).name.isEmpty()) { //first time, when username is still empty if (index != -1) { temp = m_online_users.at(index); temp.name = temp_name; temp.rx_port = temp_port; m_online_users.replace(index,temp); } } else { //same ip but different username, then append new UE m_online_users.append(temp); } } else { LOG (ERROR) << "User already exists on server. Notifying user..."; //inform user of currently online users QByteArray block; QDataStream out(&block, QIODevice::WriteOnly); out.setVersion(QDataStream::Qt_4_0); out << (quint16)0; out << QString("ue_error(Existing user on server. Choose other username);"); out.device()->seek(0); out << (quint16)(block.size() - sizeof(quint16)); DLOG (INFO) <<"Sending error message to UE ...\n"; m_log_label->setText(m_log_label->toPlainText() + "\nError: attempted connection with same " "username from same IP. Sending error to client..."); socket->write(block); //reset m_block_size m_block_size = 0; return; } DLOG (INFO) << "New user is online: " << temp; debugInfo("Nr. online users: " + QString::number(m_online_users.size())); if (m_log_label->toPlainText() != "") { m_log_label->setText(m_log_label->toPlainText() + "\n[" + temp.name + "]@" + temp.ip + ":" + QString::number(temp.rx_port) + " is now online."); } else { m_log_label->setText(m_log_label->toPlainText() + "[" + temp.name + "]@" + temp.ip + ":" + QString::number(temp.rx_port) + " is now online."); } //parse online users QString users; for (auto user: m_online_users) { users += user.name + "\n"; } users.chop(1); m_online_users_label->setText(users); qobject_cast<QLabel*>(m_main_layout->itemAt(2)->widget())->setText("Currently online users(" + QString::number(m_online_users.size()) + "):"); //inform user of currently online users QByteArray block; QDataStream out(&block, QIODevice::WriteOnly); out.setVersion(QDataStream::Qt_4_0); out << (quint16)0; QStringList params; for (auto user: m_online_users) { params << user.name; } out << m_protocol->constructStream_Server(params, ProtocolStreamType_Server::SERVER_ALL); out.device()->seek(0); out << (quint16)(block.size() - sizeof(quint16)); DLOG (INFO) <<"Sending information about currently online users...\n"; /*At this point, this block will be sent to all current users, not only to the user that is currently connected*/ for (auto connection: m_online_users) { QTcpSocket *temp_socket = new QTcpSocket(this); temp_socket->connectToHost(QHostAddress(connection.ip), connection.rx_port); if (!temp_socket->waitForConnected(3000)) { LOG (ERROR) << "ERROR: Connection attempt @" << connection.ip.toStdString() << ":" << connection.rx_port << " timed out. Omitting current..."; } else { debugInfo("Connection to client @" + connection.ip + ":" + QString::number(connection.rx_port) + " was established. Now sending..."); temp_socket->write(block); if (!temp_socket->waitForBytesWritten()) { LOG (ERROR) << "ERROR: Connection attempt @" << connection.ip.toStdString() << ":" << connection.rx_port << " timed out. Omitting current..."; } else { debugInfo("Transmission to client @" + connection.ip + ":" + QString::number(connection.rx_port) + " was successful!"); } } temp_socket->disconnectFromHost(); if (temp_socket->state() == QAbstractSocket::UnconnectedState || temp_socket->waitForDisconnected(1000)) { debugInfo("Socket disconnected."); } } break; } case UE_ACK: { m_log_label->setText(m_log_label->toPlainText() + "\n" + message); debugInfo("Going to forward user ack to destination"); QByteArray block; QDataStream out(&block, QIODevice::WriteOnly); out.setVersion(QDataStream::Qt_4_0); out << (quint16)0; out << m_protocol->constructStream_Server(QStringList(message), ProtocolStreamType_Server::SERVER_FWD_TO_SENDER); out.device()->seek(0); out << (quint16)(block.size() - sizeof(quint16)); //and lookup destination details for given user QString dest = params.at(0); QString from = params.at(1); unsigned int message_id = (unsigned int) params.at(2).toInt(); //Create temporary socket QTcpSocket* dest_socket = new QTcpSocket(this); QString dest_ip; quint16 dest_port; int index = getIndexOfUEName(dest); if (index != -1) { dest_ip = m_online_users.at(index).ip; dest_port = m_online_users.at(index).rx_port; debugInfo("Going to forward ack to " + dest_ip + ":" + QString::number(dest_port)); } else { LOG (ERROR) << "ERROR: name was not found on server. Returning..."; m_block_size=0; return; } dest_socket->connectToHost(QHostAddress(dest_ip), dest_port); if (!dest_socket->waitForConnected(2000)) { debugInfo("ERROR: request timed out"); } else { debugInfo("Established connection with client. Forwarding user ack..."); dest_socket->write(block); if (!dest_socket->waitForBytesWritten(5000)) { debugInfo("ERROR: transmission timed out"); } else { debugInfo("Success! ACK was forwarded to destination"); } dest_socket->disconnectFromHost(); } break; } case UE_ERROR: { debugInfo("Some error encountered by user. Returning ..."); m_block_size=0; return; } case UE_MESSAGE: { m_log_label->setText(m_log_label->toPlainText() + "\n" + message); //and send it back to the user debugInfo("Going to resend message to dest client: [" + message + "]"); QString content = params.at(0); QString dest = params.at(1); QString from = params.at(2); unsigned int message_id = (unsigned int) params.at(3).toInt(); DLOG (INFO) << "Message: " << content.toStdString() << ", from " << from.toStdString() << " and to " << dest.toStdString() << ", with message ID: " << message_id; QByteArray block; QDataStream out(&block, QIODevice::WriteOnly); out.setVersion(QDataStream::Qt_4_0); out << (quint16)0; out << m_protocol->constructStream_Server(QStringList(message), ProtocolStreamType_Server::SERVER_FWD_TO_SENDER); out.device()->seek(0); out << (quint16)(block.size() - sizeof(quint16)); if (dest == from) { debugInfo("WARNING: Message intended for self UE. Sending back to user..."); socket->write(block); if (!socket->waitForBytesWritten(2000)) { LOG (ERROR) << "ERROR: transmission timeout"; } else { debugInfo("Success!"); } } else { QTcpSocket *dest_socket = new QTcpSocket(this); QString dest_ip; quint16 dest_port; int index = getIndexOfUEName(dest); if (index != -1) { dest_ip = m_online_users.at(index).ip; dest_port = m_online_users.at(index).rx_port; debugInfo("Going to forward message to " + dest_ip + ":" + QString::number(dest_port)); } else { LOG (ERROR) << "ERROR: name was not found on server. Returning..."; m_block_size=0; return; } dest_socket->connectToHost(QHostAddress(dest_ip), dest_port); if (!dest_socket->waitForConnected(2000)) { debugInfo("ERROR: request timed out"); } else { debugInfo("Established connection with client. Sending..."); dest_socket->write(block); if (!dest_socket->waitForBytesWritten(5000)) { debugInfo("ERROR: transmission timed out"); } else { debugInfo("Success! Message was forwarded to destination"); } dest_socket->disconnectFromHost(); //and send an ack to the user to inform that message was received QByteArray ack_data; QDataStream ack(&ack_data, QIODevice::WriteOnly); ack.setVersion(QDataStream::Qt_4_0); ack << (quint16)0; QStringList params; params << from << QString::number(message_id); ack << m_protocol->constructStream_Server(params, ProtocolStreamType_Server::SERVER_ACK); ack.device()->seek(0); debugInfo("Sending ack to user: "******"ERROR: transmission timeout!"; } else { debugInfo("Success!"); } } } break; } case UE_UNREGISTER: { unregisterUser(); break; } case UE_TYPING: { debugInfo("User is typing..."); m_log_label->setText(m_log_label->toPlainText() + "\n" + message); //no need to parse parameters, going to forward to user QString dest = params.at(0); QString from = params.at(1); debugInfo(dest + "," + from); QByteArray typing_data; QDataStream typing_stream(&typing_data, QIODevice::WriteOnly); typing_stream.setVersion(QDataStream::Qt_4_0); typing_stream << (quint16)0; QStringList typing_params; typing_params << params.at(0) << params.at(1) << params.at(2); typing_stream << m_protocol->constructStream_Server(typing_params, ProtocolStreamType_Server::SERVER_FWD_TYPING); typing_stream.device()->seek(0); DLOG (INFO) << "Sending: " << m_protocol->constructStream_Server(typing_params, ProtocolStreamType_Server::SERVER_FWD_TYPING).toStdString(); QTcpSocket *dest_socket = new QTcpSocket(this); QString dest_ip; quint16 dest_port; int index = getIndexOfUEName(dest); if (index != -1) { dest_ip = m_online_users.at(index).ip; dest_port = m_online_users.at(index).rx_port; debugInfo("Going to forward typing info to " + dest_ip + ":" + QString::number(dest_port)); } else { LOG (ERROR) << "ERROR: name was not found on server. Returning..."; m_block_size=0; return; } dest_socket->connectToHost(QHostAddress(dest_ip), dest_port); if (!dest_socket->waitForConnected(2000)) { debugInfo("ERROR: request timed out"); } else { debugInfo("Established connection with client. Sending..."); dest_socket->write(typing_data); if (!dest_socket->waitForBytesWritten(5000)) { debugInfo("ERROR: transmission timed out"); } else { debugInfo("Success! Typing information was forwarded to destination"); } dest_socket->disconnectFromHost(); } break; } default: LOG (WARNING) << "Unrecognized stream type"; break; } } //reset m_block_size m_block_size=0; }