Error NativeThreadLinux::RequestStop () { Log* log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_THREAD)); NativeProcessLinux &process = GetProcess(); lldb::pid_t pid = process.GetID(); lldb::tid_t tid = GetID(); if (log) log->Printf ("NativeThreadLinux::%s requesting thread stop(pid: %" PRIu64 ", tid: %" PRIu64 ")", __FUNCTION__, pid, tid); Error err; errno = 0; if (::tgkill (pid, tid, SIGSTOP) != 0) { err.SetErrorToErrno (); if (log) log->Printf ("NativeThreadLinux::%s tgkill(%" PRIu64 ", %" PRIu64 ", SIGSTOP) failed: %s", __FUNCTION__, pid, tid, err.AsCString ()); } return err; }
UINT CPoomCalendar::LoadMarkup(UINT uAgentId) { //leggo dal markup lo sha1 dei singoli contatti del Calendar e riempio la struttura BYTE *pBuf = NULL; UINT uSize; UINT numMarkupAppointment=0; Log pPOOMMarkupRead = Log(); //se esiste un markup lo carico if (pPOOMMarkupRead.IsMarkup(uAgentId)) { pBuf = pPOOMMarkupRead.ReadMarkup(uAgentId, &uSize); numMarkupAppointment=uSize/sizeof(identifyAppointment); identifyAppointment* storeMarkupContact; storeMarkupContact=(identifyAppointment*)pBuf; calendarMapSha1.clear(); for(unsigned int j=0;j<numMarkupAppointment;j++) { identifyAppointment IdSha1; IdSha1.ID=storeMarkupContact->ID; memcpy(IdSha1.sha1,storeMarkupContact->sha1,sizeof(IdSha1.sha1)); IdSha1.sha1flag=0; calendarMapSha1[storeMarkupContact->ID]=IdSha1; storeMarkupContact++; } //ho storato tutto in addressbookMapSha1 per cui posso liberare la memoria SAFE_DELETE(pBuf); } return numMarkupAppointment; }
void POSIXThread::BreakNotify(const ProcessMessage &message) { bool status; Log *log (ProcessPOSIXLog::GetLogIfAllCategoriesSet (POSIX_LOG_THREAD)); assert(GetRegisterContext()); status = GetPOSIXBreakpointProtocol()->UpdateAfterBreakpoint(); assert(status && "Breakpoint update failed!"); // With our register state restored, resolve the breakpoint object // corresponding to our current PC. assert(GetRegisterContext()); lldb::addr_t pc = GetRegisterContext()->GetPC(); if (log) log->Printf ("POSIXThread::%s () PC=0x%8.8" PRIx64, __FUNCTION__, pc); lldb::BreakpointSiteSP bp_site(GetProcess()->GetBreakpointSiteList().FindByAddress(pc)); // If the breakpoint is for this thread, then we'll report the hit, but if it is for another thread, // we create a stop reason with should_stop=false. If there is no breakpoint location, then report // an invalid stop reason. We don't need to worry about stepping over the breakpoint here, that will // be taken care of when the thread resumes and notices that there's a breakpoint under the pc. if (bp_site) { lldb::break_id_t bp_id = bp_site->GetID(); if (bp_site->ValidForThisThread(this)) SetStopInfo (StopInfo::CreateStopReasonWithBreakpointSiteID(*this, bp_id)); else { const bool should_stop = false; SetStopInfo (StopInfo::CreateStopReasonWithBreakpointSiteID(*this, bp_id, should_stop)); } } else SetStopInfo(StopInfoSP()); }
void Log::vprint(int logLevel, const TCHAR *fmt, va_list argList) { Log *instance = getInstance(); if (instance == 0) { return; } StringStorage timeString(_T("[Temporary unavaliable]")); SYSTEMTIME st; GetLocalTime(&st); timeString.format(_T("%.4d-%.2d-%.2d %.2d:%.2d:%.2d"), st.wYear, st.wMonth, st.wDay, st.wHour, st.wMinute, st.wSecond); const TCHAR logLevelSignature[] = _T("@!*+-: xxxxxx"); TCHAR sig = logLevelSignature[logLevel & 0x0F]; int count = _vsctprintf(fmt, argList); TCHAR *formattedString = new TCHAR[count + 1]; _vstprintf(formattedString, fmt, argList); StringStorage message; message.format(_T("[%4d] %s %c %s"), GetCurrentThreadId(), timeString.getString(), sig, formattedString); const TCHAR badCharacters[] = {13, 10, 0}; message.removeChars(badCharacters, sizeof(badCharacters) / sizeof(TCHAR)); delete[] formattedString; const TCHAR endLine[3] = {13, 10, 0}; message.appendString(endLine); instance->flushLine(logLevel, message.getString()); }
static void signal_handler(int signo) { Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS)); fprintf (stderr, "lldb-server:%s received signal %d\n", __FUNCTION__, signo); if (log) log->Printf ("lldb-server:%s received signal %d", __FUNCTION__, signo); switch (signo) { case SIGPIPE: g_sigpipe_received = 1; break; case SIGHUP: ++g_sighup_received_count; // For now, swallow SIGHUP. if (log) log->Printf ("lldb-server:%s swallowing SIGHUP (receive count=%d)", __FUNCTION__, g_sighup_received_count); signal (SIGHUP, signal_handler); break; } }
int main() { // Disable Ogre logging new LogManager; Log *log = LogManager::getSingleton().createLog(""); log->setDebugOutputEnabled(false); // Set up Root Root *root = new Root("","",""); // Add the BSA addBSA("../../data/Morrowind.bsa"); // Pick a sample file String tex = "textures\\tx_natural_cavern_wall13.dds"; cout << "Opening file: " << tex << endl; // Get it from the resource system DataStreamPtr data = ResourceGroupManager::getSingleton().openResource(tex, "General"); cout << "Size: " << data->size() << endl; return 0; }
bool ThreadPlanStepThroughObjCTrampoline::ShouldStop (Event *event_ptr) { if (m_func_sp.get() == NULL || m_thread.IsThreadPlanDone(m_func_sp.get())) { m_func_sp.reset(); if (!m_run_to_sp) { Value target_addr_value; ExecutionContext exc_context; m_thread.Calculate(exc_context); m_impl_function->FetchFunctionResults (exc_context, m_args_addr, target_addr_value); m_impl_function->DeallocateFunctionResults(exc_context, m_args_addr); lldb::addr_t target_addr = target_addr_value.GetScalar().ULongLong(); Address target_address(NULL, target_addr); Log *log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP); if (log) log->Printf("Running to ObjC method implementation: 0x%llx", target_addr); m_objc_trampoline_handler->AddToCache (m_class_ptr, m_sel_ptr, target_addr); // Extract the target address from the value: m_run_to_sp.reset(new ThreadPlanRunToAddress(m_thread, target_address, m_stop_others)); m_thread.QueueThreadPlan(m_run_to_sp, false); m_run_to_sp->SetPrivate(true); return false; } else if (m_thread.IsThreadPlanDone(m_run_to_sp.get())) { SetPlanComplete(); return true; } } return false; }
bool logf ( long type , char *formatString , ...) { if ( g_log.m_disabled ) return false; // do not log it if we should not //if ( type == LOG_WARN && ! g_conf.m_logWarnings ) return false; // is it congestion? if ( g_errno == ENOSLOTS && ! g_conf.m_logNetCongestion ) return false; // this is the argument list (variable list) va_list ap; // can we log if we're a sig handler? don't take changes // print msg into this buf char buf[1024*10]; // copy the error into the buffer space va_start ( ap, formatString); // debug hack for testing if ( g_inSigHandler ) return g_log.logLater ( g_now , type , formatString , ap); // print it into our buf now vsnprintf ( buf , 1024*10 , formatString , ap ); va_end(ap); // pass buf to g_log g_log.logR ( 0 , type , buf , false , true /*forced?*/ ); // always return false return false; }
lldb_private::ConstString PlatformRemoteGDBServer::GetRemoteWorkingDirectory() { if (IsConnected()) { Log *log = GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PLATFORM); std::string cwd; if (m_gdb_client.GetWorkingDir(cwd)) { ConstString working_dir(cwd.c_str()); if (log) log->Printf("PlatformRemoteGDBServer::GetRemoteWorkingDirectory() -> '%s'", working_dir.GetCString()); return working_dir; } else { return ConstString(); } } else { return Platform::GetRemoteWorkingDirectory(); } }
CProcessViewerApp::CProcessViewerApp() { const DWORD dwBuffSize = MAX_PATH * 2; TCHAR szModuleFileName[dwBuffSize] = { 0 }; // Get exe name GetModuleFileName( 0, szModuleFileName, dwBuffSize ); // Remove file name part PathRemoveFileSpec( szModuleFileName ); // Concatenate file name _tcscat_s( szModuleFileName, dwBuffSize, _T( "\\PVLog.log" )); VERIFY( g_Log.Open( szModuleFileName )); }
bool POSIXThread::Resume() { lldb::StateType resume_state = GetResumeState(); ProcessMonitor &monitor = GetMonitor(); bool status; Log *log (ProcessPOSIXLog::GetLogIfAllCategoriesSet (POSIX_LOG_THREAD)); if (log) log->Printf ("POSIXThread::%s (), resume_state = %s", __FUNCTION__, StateAsCString(resume_state)); switch (resume_state) { default: assert(false && "Unexpected state for resume!"); status = false; break; case lldb::eStateRunning: SetState(resume_state); status = monitor.Resume(GetID(), GetResumeSignal()); break; case lldb::eStateStepping: SetState(resume_state); status = monitor.SingleStep(GetID(), GetResumeSignal()); break; case lldb::eStateStopped: case lldb::eStateSuspended: status = true; break; } return status; }
bool HostInfoPosix::ComputePathRelativeToLibrary(FileSpec &file_spec, llvm::StringRef dir) { Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_HOST); FileSpec lldb_file_spec; if (!GetLLDBPath(lldb::ePathTypeLLDBShlibDir, lldb_file_spec)) return false; std::string raw_path = lldb_file_spec.GetPath(); // drop library directory llvm::StringRef parent_path = llvm::sys::path::parent_path(raw_path); // Most Posix systems (e.g. Linux/*BSD) will attempt to replace a */lib with // */bin as the base directory for helper exe programs. This will fail if the // /lib and /bin directories are rooted in entirely different trees. if (log) log->Printf("HostInfoPosix::ComputePathRelativeToLibrary() attempting to " "derive the %s path from this path: %s", dir.data(), raw_path.c_str()); if (!parent_path.empty()) { // Now write in bin in place of lib. raw_path = (parent_path + dir).str(); if (log) log->Printf("Host::%s() derived the bin path as: %s", __FUNCTION__, raw_path.c_str()); } else { if (log) log->Printf("Host::%s() failed to find /lib/liblldb within the shared " "lib path, bailing on bin path construction", __FUNCTION__); } file_spec.GetDirectory().SetString(raw_path); return (bool)file_spec.GetDirectory(); }
void parseObjectDataBlobDataElement( const Byte* bytes, UINT64& offset, Log& logfile ) { ObjectHeader object_header; object_header.parse(bytes + offset); logfile.log(offset, toString(object_header)); offset += object_header.bytes_use; BinaryItem data; data.parse(bytes + offset); logfile.log(L"Blob Data: " + toString(data)); offset += data.bytes_use; object_header.parse(bytes + offset); if (object_header.object_type != kOTData_element) goto FAILED_END; logfile.log(offset, toString(object_header)); offset += object_header.bytes_use; return; FAILED_END: printf("parse failed, current offset:0x%X\n", offset); }
inline void Log::detachLog(Log & other) { m_debugStream.detachStream(other.debugStream()); m_noteStream.detachStream(other.noteStream()); m_warnStream.detachStream(other.warnStream()); m_fatalStream.detachStream(other.fatalStream()); m_criticalStream.detachStream(other.criticalStream()); m_infoStream.detachStream(other.infoStream()); }
///Платформо-зависимая инициализация void PlatformInitialize () { native_display = (NativeDisplayType)syslib::x11::DisplayManager::DisplayHandle (); log.Printf ("...get window name"); char* window_name = 0; if (!XFetchName ((Display*)native_display, (Window)native_window, &window_name)) window_name = (char*)"default"; if (!window_name) window_name = (char*)"default"; strncpy (name, window_name, sizeof (name)); }
// Wrapper for ptrace to catch errors and log calls. // Note that ptrace sets errno on error because -1 is reserved as a valid result. extern long PtraceWrapper(int req, lldb::pid_t pid, void *addr, int data, const char* reqName, const char* file, int line) { long int result; Log *log (ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PTRACE)); if (log) { log->Printf("ptrace(%s, %" PRIu64 ", %p, %x) called from file %s line %d", reqName, pid, addr, data, file, line); if (req == PT_IO) { struct ptrace_io_desc *pi = (struct ptrace_io_desc *) addr; log->Printf("PT_IO: op=%s offs=%zx size=%zu", Get_PT_IO_OP(pi->piod_op), (size_t)pi->piod_offs, pi->piod_len); } } //PtraceDisplayBytes(req, data); errno = 0; result = ptrace(req, pid, (caddr_t) addr, data); //PtraceDisplayBytes(req, data); if (log && errno != 0) { const char* str; switch (errno) { case ESRCH: str = "ESRCH"; break; case EINVAL: str = "EINVAL"; break; case EBUSY: str = "EBUSY"; break; case EPERM: str = "EPERM"; break; default: str = "<unknown>"; } log->Printf("ptrace() failed; errno=%d (%s)", errno, str); } #ifdef __amd64__ if (log) { if (req == PT_GETREGS) { struct reg *r = (struct reg *) addr; log->Printf("PT_GETREGS: ip=0x%lx", r->r_rip); log->Printf("PT_GETREGS: sp=0x%lx", r->r_rsp); log->Printf("PT_GETREGS: bp=0x%lx", r->r_rbp); log->Printf("PT_GETREGS: ax=0x%lx", r->r_rax); } } #endif return result; }
//----------------------------------------------------------------- bool InitVideo(const Log& log) { // initialize SDL if not already initialized if (SDL_Init(SDL_INIT_VIDEO) != 0) { log.error() << "Failed initializing SDL: " << SDL_GetError(); return false; } // hide hardware mouse cursor SDL_ShowCursor(0); // ensure SDL will be properly deinitialized atexit(SDL_Quit); return true; }
Object* GetObject(char* cmd) { char buf[50]; memset(buf, 0, sizeof(buf)); String logContent = cmd; for(int i=0;i<strlen(cmd);i++) { if( cmd[i] == ':' ) { strncpy(buf, cmd, i); cmd += i + 1; break; } cmd[i] = tolower(cmd[i]); } String para = ""; if( strlen( cmd ) != 0) { para = cmd; } /*if ( strcmp(buf, "login") == 0 ) { logContent = "receive cmd " + logContent; logContent += " and return a Login object."; log.write(logContent, Log::INFO); logContent = "use para " + para + " to init the Login object."; log.write(logContent, Log::INFO); Object* obj = new Login(para); if( obj == NULL) perror("new error:"); return obj; } */ UnknownCmd* unknown = new UnknownCmd(); logContent = "receive cmd " + logContent; logContent += ",system do not supplied, return a UnknownCmd object."; log.write(logContent, Log::ERROR); return unknown; }
void Auth::Do() { log.write("begin Auth::Do.", Log::INFO); //参数检查 log.write("begin process parameter.", Log::INFO); if( getPara() == false) { ackCode = "ACK:LOGIN:RETN=4,DESC=parameter error"; return; } log.write("end process parameter.", Log::INFO); //检查用户名密码是否正确 log.write("begin check user name and password.", Log::INFO); if( checkPass() == false) { ackCode = "ACK:LOGIN:RETN=1001,DESC=user name or pass is error"; return; } log.write("end check user name and password.", Log::INFO); if( userType == 0 ) { ackCode = "ACK:LOGIN:RETN=0,DESC=success,RESULT=-1|-1"; return; } //////////////////////获取权限数据 log.write("begin get permission data.", Log::INFO); if( getPermissionData() == false) { ackCode = "ACK:LOGIN:RETN=8,DESC=system internal error,cannot get permissionData from database."; return; } log.write("end get permission data.", Log::INFO); ackCode = "ACK:LOGIN:RETN=0,DESC=success,RESULT=" + permissionData; log.write("end Auth::Do.", Log::INFO); }
int UserClient::_CmdRSTO( OmniPacket *packet ) { int errCode = ERROR_OK; char ret[BUFLEN]; bzero( ret, BUFLEN ); char param[NODELEN]; PARSE_TAG_INIT( packet->mHeader ); PARSE_TAG_NEXT( packet->mHeader, param ); gLog.log("Restore Table [%s]", param ); errCode = Table::Restore( param ); sprintf( ret, "RSTO %lu %d 0\r\n", packet->mTrid, errCode ); WritePacket( ret, strlen(ret) ); return errCode; }
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, PSTR szCmdLine, int iCmdShow) #endif { setbuf(stderr, 0); bool console = false; // The state of the application as a whole is contained in the one app object #ifdef _WIN32_WCE VNCviewerApp app(hInstance, szCmdLine); #else VNCviewerApp32 app(hInstance, szCmdLine); #endif console = app.m_options.m_logToConsole; // Start a new connection if specified on command line, // or if not in listening mode if (app.m_options.m_connectionSpecified) { app.NewConnection(app.m_options.m_host, app.m_options.m_port); } else if (!app.m_options.m_listening) { // This one will also read from config file if specified app.NewConnection(); } MSG msg; try { while ( GetMessage(&msg, NULL, 0,0) ) { DispatchMessage(&msg); } } catch (WarningException &e) { e.Report(); } catch (QuietException &e) { e.Report(); } // Clean up winsock WSACleanup(); log.Print(3, _T("Exiting\n")); if (console) Sleep(2000); return msg.wParam; }
static void ExtractFileFromResource(HMODULE hImage, DWORD resId, LPCTSTR path) { g_Log.Debug(_T("Extracting resource %d to \"%s\"..."), resId, path); HRSRC hDbghelpRes = FindResource(hImage, MAKEINTRESOURCE(resId), RT_RCDATA); if (!hDbghelpRes) throw runtime_error("failed to find file in resources"); HGLOBAL hDbghelpGlobal = LoadResource(hImage, hDbghelpRes); if (!hDbghelpGlobal) throw runtime_error("failed to load file from resources"); CAtlFile hFile(CreateFile(path, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL)); if (hFile == INVALID_HANDLE_VALUE) throw runtime_error("failed to create file"); if (FAILED(hFile.Write(LockResource(hDbghelpGlobal), SizeofResource(hImage, hDbghelpRes)))) throw runtime_error("failed to write file"); }
int TimerThread::CreateInstance() { pthread_mutex_init(&mTimerMutex, NULL); int status, rc; rc = pthread_create( &mTimerThread, NULL, TimerThread::TimerLoop, NULL ); if( rc ) { gLog.log("pthread_create return rc %d", rc); return rc; } /* rc = pthread_join( mTimerThread, (void **)&status); if( rc ) gLog.log("pthread_join return rc %d", rc); */ return rc; }
void LogsConsole::drawElemData(const Log& log) const { this->setColor(m_colorFactory.getColor(log.getColor() - 1)); if (log.isBold()) this->activeAttr(A_BOLD); { this->print("%s: %s", log.getName(), log.isActive() ? "on" : "off"); } if (log.isBold()) this->disactiveAttr(A_BOLD); this->unsetColor(m_colorFactory.getColor(log.getColor() - 1)); }
static void WINAPI Load() { string cmdline = GetCommandLineA(); string ip; int port = NULL; std::vector<std::string> a; Log *log = new Log("log.txt"); a = split(cmdline, ' '); log->Write((char*)cmdline.c_str()); for (vector<string>::iterator i = a.begin(); i != a.end(); i++) { if (!i->compare("-h")) { advance(i, 1); ip = (*i); } else if (!i->compare("-p")) { advance(i, 1); port = atoi((*i).c_str()); } } log->Write("before try"); log->Write((char*)ip.c_str()); try { SocketHandler s = SocketHandler(ip, 7667); log->Write("just connected"); //s.AddDataFile("HANDLING"); s.AddDataFile("WEAPON"); s.AddDataFile("surfinfo"); s.AddDataFile("melee"); s.AddDataFile("ANIMGRP"); disableSampAC(); while(true) { s.WaitForServerResponse(); } } catch (SocketException e) { log->Write((char*)e.what()); return; } //log->Write(buf); delete log; }
void ClimbPeriodic() { displayCount++; // This is the distance in inches the climber must be initially raised static const float PullupPostion = -5.0f; log->info("current state is: %s\n",ClimbStateString(climbState)); // depending on state, cont switch (climbState) { case NotInitialized: { leftClimber->encoder->Start(); rightClimber->encoder->Start(); bar = LowerBar; climber = NULL; setClimbState(InitialGrab); break; } //when they set up the robot they have to set the climbers 6" above the bar case InitialGrab: { // Pulling both arms down enough to latch (low power consumption) // We have several options here: // 1. Move a specific distance and assume it is right // 2. Move until the power goes up, and then check the encoders to see if the distance // is plausible // 3. Move until a limit HookSwitch inside the grip for each climber trips bool leftDone = leftClimber->UpdateState(-1.0, PullupPostion); bool rightDone = rightClimber->UpdateState(-1.0, PullupPostion); startingState = false; // moving climbers into initial position if (leftDone && rightDone) setClimbState(Abort); break; } case Abort: { return; } default: log->info("unexpected climber state!"); log->print(); } log->info("LR %f %f", leftClimber->encoder->GetDistance(), rightClimber->encoder->GetDistance()); log->info("LRL %d %d %d %d %d %d %d", leftClimber->lowerLimitSwitch->Get(), leftClimber->lowerHookSwitch->Get(), leftClimber->upperHookSwitch->Get(), rightClimber->lowerLimitSwitch->Get(), rightClimber->lowerHookSwitch->Get(), rightClimber->upperHookSwitch->Get(), loaderSwitch->Get()); log->print(); }
void IM::output (Log& log) const { for (std::map<symbol, double>::const_iterator i = content.begin (); i != content.end (); i++) { static const symbol chemlib (Chemical::component); const symbol name = (*i).first; if (!log.check_entry (name, chemlib)) continue; Log::Shallow named (log, name, chemlib); output_variable (name, log); const double value = (*i).second; output_variable (value, log); } }
int GPIOUnexport(int pin) { char buffer[BUFFER_MAX]; ssize_t bytes_written; int fd; fd = open("/sys/class/gpio/unexport", O_WRONLY); if (-1 == fd) { stringstream ss; ss << "Failed to open unexport for writing! GPIO pin #" << pin; g_log.v("System", ss.str()); return(-1); } bytes_written = snprintf(buffer, BUFFER_MAX, "%d", pin); write(fd, buffer, bytes_written); close(fd); return(0); }
bool DeleteVM::applySC2FreeDisk() { String request = "DEL NFS STOR:ID=" + vmID + ",TYPE=0"; int sock = connect2Server( scServerIP.c_str(), scServerPort); if( sock == -1 ) { log.write("connect sc node server error.", Log::ERROR); return false; } if( sendData( request.c_str(), request.size(), sock) == false ) { log.write("send request to sc node server error.", Log::ERROR); return false; } String ack; if( recvData( sock, ack) == false ) { log.write("recv ack message from sc node server error.", Log::ERROR); return false; } log.write("recv ack message:" + ack + " from sc node server.", Log::INFO); //分析结果 int iRetn; if( getIntParaValue( ack, "retn", iRetn) == false ) { log.write("get para ip error from ack message.", Log::ERROR); return false; } closeSock( sock ); if( iRetn == 0 ) { log.write("apply sc server to free disk success.", Log::INFO); return true; } log.write("apply sc server to free disk failed.", Log::ERROR); return false; }
int UserClient::_CmdSTAB( OmniPacket *packet ) { int errCode = ERROR_OK; char ret[BUFLEN]; bzero( ret, BUFLEN ); char body[BUFLEN*10]; bzero( body, BUFLEN*10 ); char param[NODELEN]; string table; PARSE_TAG_INIT( packet->mHeader ); PARSE_TAG_NEXT( packet->mHeader, param ); gLog.log("Show Table [%s]", param ); table = param; Table *tab; Column *col; map<string, Table*>::iterator iter = Table::mTableMap.find(table); if( iter == Table::mTableMap.end() ) { errCode = ERROR_TABLE_NOT_FOUND; sprintf( ret, "STAB %lu %d 0\r\n", packet->mTrid, errCode ); WritePacket( ret, strlen(ret) ); } else { tab = iter->second; list<Column*>::iterator iter2 = tab->mColInfo.mColList.begin(); while( iter2 != tab->mColInfo.mColList.end() ) { col = *iter2; sprintf( ret, "%s %d %d\r\n", col->mColName, col->mType, col->mSize ); iter2++; strcat( body, ret ); } sprintf( ret, "STAB %lu %d %lu\r\n", packet->mTrid, errCode, strlen(body) ); WritePacket( ret, strlen(ret) ); WritePacket( body, strlen(body) ); } return errCode; }