extern int32_t iwlog_init(int32_t verbose) { struct iwlog *plog = NULL; int fd = -1; tzset(); if ((fd = open(LOGFILEPATH, O_WRONLY | O_CREAT | O_APPEND, S_IRUSR | S_IWUSR)) == -1) { pmsg(EV_FAIL_OPEN, LOGFILEPATH, strerror(errno)); goto err; } if (! (plog = malloc(sizeof(struct iwlog)))) { pmsg(E_FAIL_MALLOC, __FUNCTION__); goto err; } plog->fverbose = verbose ? IW_TRUE : IW_FALSE; plog->logfd = fd; plog->msglen = 0; alog = plog; return IW_OK; err: if (fd > 0) close(fd); free(plog); return IW_ERR; }
// make FAT[_cluster_] point to cluster _value_ byte update_FAT(byte* buf, word cluster, word value) { dword abs_addr; dword sec_start; word value_rev; memreverse(&value, &value_rev, 2); abs_addr = prtn.FAT_addr + cluster*2; sec_start = abs_addr - (abs_addr % 512); if(!read_block(buf, sec_start)) { #if DEBUG pmsg("Problem updating FAT!\r\n"); #endif return 0; } memmove(buf + (abs_addr % 512), &value_rev, 2); if (!write_block(buf, sec_start)) { #if DEBUG pmsg("Problem updating FAT!\r\n"); #endif return 0; } return 1; }
// returns FAT index (cluster number) of first unused cluster found in FAT word get_unused_cluster(byte* buf) { byte i,j; byte b; word FAT_entry; for (i=0;i<prtn.FAT_size/prtn.bytes_per_sec;i++) { b = read_block(buf, prtn.FAT_addr + i*512); for(j=0;j<512/2;j++) { FAT_entry = buf[j*2]&0x00ff | (buf[j*2+1]&0x00ff)<<8; if(FAT_entry == 0x0000) { #if DEBUG pmsg("found unused cluster. FAT index: 0x"); disword(i*512/2 + j); pmsg("\r\n"); #endif return i*512/2 + j; } } } #if DEBUG pmsg("Failed to find unused cluster!\r\n"); #endif return 0; }
byte create_dir_entry(dir_entry_t* de, char* filename, byte fn_length, byte* buf) { dword dir_entry_addr; memmove(de->filename, filename, fn_length); de->attributes = NEW_FILE_ATTR; de->filesize = 0; memset(de->unused_attr, 0, 14); dir_entry_addr = get_empty_dir_entry(buf); #if DEBUG pmsg("get_direntry returned: 0x"); disdword(dir_entry_addr); pmsg("\r\n"); #endif if (!dir_entry_addr) { #if DEBUG pmsg("Couldn't find empty direntry!\r\n"); #endif return 0; } de->entry_addr = dir_entry_addr; // when direntry is allocated cluster is not yet entered de->first_cluster = 0x0000; return 1; }
// sets FAT[_cluster_] to 0x00 and returns FAT[_cluster_]'s original value word clear_FAT(byte* buf, word cluster) { dword abs_addr; dword sec_start; word ori_cluster; abs_addr = prtn.FAT_addr + cluster*2; sec_start = abs_addr - (abs_addr % 512); if(!read_block(buf, sec_start)) { #if DEBUG pmsg("Problem clearing FAT!\r\n"); #endif return 0; } memreverse(buf + (abs_addr % 512), &ori_cluster, 2); memmove(buf + (abs_addr % 512), (word)0, 2); if (!write_block(buf, sec_start)) { #if DEBUG pmsg("Problem clearing FAT!\r\n"); #endif return 0; } return ori_cluster; }
void prtn_set_addr(byte* bootSec, dword partition_addr) { int resSecs; //# of reserved sectors byte numFATs; //# of FATs word max_root_entries; /* max# of root dir entries */ word secs_per_FAT; byte secs_per_clus; secs_per_clus = bootSec[0x0d]; resSecs = ((bootSec[0x0f]<<8)&0xFF00)|(bootSec[0x0e]&0x00FF); max_root_entries = ((bootSec[0x12]<<8)&0xFF00)|(bootSec[0x11]&0x00FF); numFATs = bootSec[0x10]; secs_per_FAT = ((bootSec[0x17]<<8)&0xFF00)|(bootSec[0x16]&0x00FF); prtn.bytes_per_sec = ((bootSec[0x0c]<<8)&0xFF00)|(bootSec[0x0b]&0x00FF); prtn.root_dir_addr = partition_addr + ((long)resSecs + (long)secs_per_FAT*(long)numFATs)*(long)(prtn.bytes_per_sec); prtn.FAT_addr = partition_addr + (long)resSecs*(long)(prtn.bytes_per_sec); prtn.data_addr = prtn.root_dir_addr + (max_root_entries*32); prtn.clus_size = prtn.bytes_per_sec * secs_per_clus; prtn.FAT_size = prtn.bytes_per_sec * secs_per_FAT; prtn.root_dir_size = max_root_entries * 16; #if DEBUG pmsg("Bytes per sector: "); disword_dec(prtn.bytes_per_sec); pmsg("\r\n"); pmsg("Number of reserved sectors: "); disword_dec(resSecs); pmsg("\r\n"); pmsg("root dir at: 0x"); disdword(prtn.root_dir_addr); pmsg("\r\n"); pmsg("FAT at: 0x"); disdword(prtn.FAT_addr); pmsg("\r\n"); pmsg("Data starts at: 0x"); disdword(prtn.data_addr); pmsg("\r\n"); #endif }
// returns address of first empty root dir entry dword get_empty_dir_entry(byte* buf) { byte i,j; byte b; for (i=0;i<32;i++) { b = read_block(buf, prtn.root_dir_addr + i*512); for(j=0;j<16;j++) { if(buf[j*32] == 0x00 || buf[j*32] == 0xE5) { #if DEBUG pmsg("found empty direntry at addr: 0x"); disdword(prtn.root_dir_addr + i*512 + j*32); pmsg("\r\n"); #endif return (prtn.root_dir_addr + i*512 + j*32); } } } #if DEBUG pmsg("Failed to find empty directory entry!\r\n"); #endif return 0; }
extern void iwlog_print_msg(const char *msg, size_t msglen) { time_t logtime; struct tm tm; char timebuf[TIMESTRLEN_MAX]; char *pb; size_t timelen = 0; if (! alog) { pmsg(EV_NULL_OBJ); return; } logtime = time(NULL); if (! localtime_r(&logtime, &tm)) { pmsg(EV_FAIL_LOCALTIME, strerror(errno)); strncpy(timebuf, "- DATETIME ERROR -", sizeof timebuf); } else { if (! strftime(timebuf, sizeof timebuf, "%Y-%m-%d %T", &tm)) { pmsg(EV_FAIL_STRFTIME, strerror(errno)); strncpy(timebuf, "- TIMEFORM ERROR -", sizeof timebuf); } } /* create string, "yyyy-MM-DD hh:mm:ss MESSAGE" */ strncpy(alog->msgbuf, timebuf, LOGMSGBUF_SIZE); for (pb = alog->msgbuf; pb - alog->msgbuf < LOGMSGBUF_SIZE - 1; pb++) { if (! *pb) { *pb++ = ' '; break; } } *pb = '\0'; timelen = pb - alog->msgbuf; if (timelen + msglen < LOGMSGBUF_SIZE - 2) { strncpy(pb, msg, msglen); } else { strncpy(pb, msg, LOGMSGBUF_SIZE - timelen - 2); } *(alog->msgbuf + strlen(alog->msgbuf)) = '\n'; *(alog->msgbuf + strlen(alog->msgbuf) + 1) = '\0'; alog->msglen = strlen(alog->msgbuf); /* write to logfile */ if (write(alog->logfd, alog->msgbuf, alog->msglen) == -1) { pmsg(EV_FAIL_WRITE, alog->logfd, alog->msglen, strerror(errno)); fprintf(stderr, "[log fallback]: %s", alog->msgbuf); } }
byte read_block(byte* buf,dword addr) { int i; byte c; byte r1; if (addr % 512 != 0) { #if DEBUG pmsg("read_block: Address 0x"); disdword(addr); pmsg("is not aligned to a 512 byte block!\r\n"); #endif return 0; } #if DEBUG pmsg("Reading block at address 0x"); disdword(addr); pmsg("\r\n"); #endif r1=CMD(17,addr); for (i=0;i<50;i++) // wait until the data is found { if (r1==0x00) break; r1 = SPI_Byte(0xFF); } if (r1!=0x00) { #if DEBUG pmsg("Read block timed out!\r\n"); #endif return 0; } c = SPI_Byte(0xFF); while (c!=0xFE) { c=SPI_Byte(0xFF); } // wait for the "data follows" code for (i=0;i<512;i++) { *(buf++)=SPI_Byte(0xFF); } c=SPI_Byte(0xFF); c=SPI_Byte(0xFF); // dummy bytes to clear any queues return 1; }
void testMetadata(bool showPassedTests) { /* write to file */ FILE *f = fopen("highscore-test.txt", "w+b"); HighscoreMetadata *hm = new HighscoreMetadata(3); hm->writeMetadata(f); fclose(f); delete hm; /* read from file */ FILE *g = fopen("highscore-test.txt", "rb"); char *line = NULL; size_t linecap = 0; getline(&line, &linecap, g); fclose(g); /* parse */ string l = string(line); hm = new HighscoreMetadata(l); free(line); /* check */ if (hm->count != 3) { fmsg("testMetadata, count != 3, is %d", hm->count); } else { pmsg("testMetadata"); } delete hm; }
void CL_MenuBar_Impl::on_process_message(CL_GUIMessage &msg) { if (msg.is_type(CL_GUIMessage_Input::get_type_name())) { CL_GUIMessage_Input input_msg = msg; CL_InputEvent e = input_msg.get_event(); if (e.type == CL_InputEvent::pressed && e.id == CL_MOUSE_LEFT) { msg.set_consumed(); std::vector<CL_TopMenu>::size_type index; for (index = 0; index < menus.size(); index++) { CL_Rect item_rect = get_menu_item_rect(index); if (item_rect.contains(e.mouse_pos)) { selected_index = index; hot_index = -1; menubar->request_repaint(); menu_loop.reset(new CL_MenuModalLoop(menubar->get_gui_manager())); menu_loop.get()->start(menubar, menubar); return; } } } else if (e.type == CL_InputEvent::pointer_moved ) { msg.set_consumed(); std::vector<CL_TopMenu>::size_type index; for (index = 0; index < menus.size(); index++) { CL_Rect item_rect = get_menu_item_rect(index); if (item_rect.contains(e.mouse_pos)) { if (selected_index != index && index != hot_index) { hot_index = index; menubar->request_repaint(); } break; } } } } else if (msg.is_type(CL_GUIMessage_Pointer::get_type_name())) { CL_GUIMessage_Pointer pmsg(msg); if (pmsg.get_pointer_type() == CL_GUIMessage_Pointer::pointer_leave) { msg.set_consumed(); hot_index = -1; menubar->request_repaint(); } } }
void testInsertRecord(bool showPassedTests) { Record *r1 = new Record(2, 11, "1"); Record *r2 = new Record(1, 12, "2"); Record *r3 = new Record(12, 13, "3"); Record **arr = new Record*[2]; arr[0] = r1; arr[1] = r2; HighscoreTable ht = HighscoreTable(arr, 2, 2); ht.addRecord(r3); ht.sort(); Record **r = ht.getRecords(); if (recordEqual(r3, r[0]) == false) { fmsg("testInsertRecord, records not sorted, r3 isn't first"); } else if (recordEqual(r2, r[1]) == false) { fmsg("testInsertRecord, records not sorted, r2 isn't second"); } else if (recordEqual(r1, r[2]) == false) { fmsg("testInsertRecord, records not sorted, r1 isn't last"); } else { pmsg("testInsertRecord"); } }
void CGuildManager::Initialize() { char szQuery[1024]; snprintf(szQuery, sizeof(szQuery), "SELECT id, name, ladder_point, win, draw, loss, gold, level FROM guild%s", GetTablePostfix()); std::auto_ptr<SQLMsg> pmsg(CDBManager::instance().DirectQuery(szQuery)); if (pmsg->Get()->uiNumRows) ParseResult(pmsg->Get()); char str[128 + 1]; if (!CConfig::instance().GetValue("POLY_POWER", str, sizeof(str))) *str = '\0'; if (!polyPower.Analyze(str)) sys_err("cannot set power poly: %s", str); else sys_log(0, "POWER_POLY: %s", str); if (!CConfig::instance().GetValue("POLY_HANDICAP", str, sizeof(str))) *str = '\0'; if (!polyHandicap.Analyze(str)) sys_err("cannot set handicap poly: %s", str); else sys_log(0, "HANDICAP_POLY: %s", str); QueryRanking(); }
void testRecordWithSpaces(bool showPassedTests) { /* write the record */ FILE *f = fopen("highscore-test.txt", "w+b"); Record r = Record(123, (long) 123456, "name and number"); r.writeRecord(f); fclose(f); /* read the record */ FILE *g = fopen("highscore-test.txt", "rb"); char *line = NULL; size_t linecap = 0; getline(&line, &linecap, g); fclose(g); /* parse the record */ Record r2 = Record(string(line)); if (r2.getScore() != r.getScore() || r2.getTimestamp() != r.getTimestamp() || strcmp(r2.getName().c_str(), r.getName().c_str()) != 0) { fmsg("testRecordWithSpaces, records differ"); } else { pmsg("testRecord"); } free(line); }
// writes a dir entry to disk byte write_dir_entry(dir_entry_t* de, byte* buf) { dword de_sec_offset; dword de_sec_start; byte b; word cluster_rev; dword filesize_rev; de_sec_offset = de->entry_addr % 512; de_sec_start = de->entry_addr - de_sec_offset; b = read_block(buf, de_sec_start); memreverse((void*)&(de->first_cluster), &cluster_rev, 2); memreverse((void*)&(de->filesize), &filesize_rev, 4); // enter dir_entry info into buffer (based on http://en.wikipedia.org/wiki/8.3_filename) memmove(buf+de_sec_offset, de->filename, 11); memmove(buf+de_sec_offset+0x0b, &(de->attributes), 1); memmove(buf+de_sec_offset+0x0c, &(de->unused_attr), 14); memmove(buf+de_sec_offset+0x1a, &cluster_rev, 2); memmove(buf+de_sec_offset+0x1c, &filesize_rev, 4); if(!write_block(buf, de_sec_start)) { #if DEBUG pmsg("problem writing direntry!\r\n"); #endif return 0; } return 1; }
byte getFile(dir_entry_t* de, byte* buf, char* filename, byte length) { int i,j; word cluster; dword file_size; byte b; char filename_upper[12]; for (i = 0; i < prtn.root_dir_size/512; i++) { b = read_block(buf, prtn.root_dir_addr + i*512); for(j = 0; j < 16; j++) { if (*(buf + j*32)==0 || *(buf + j*32)==0x2e || *(buf + j*32)==0xe5) { continue; } strncpy(filename_upper, (char*)(buf+j*32), 11); filename_upper[11] = '\0'; if(strcmp(filename, str_toupper(filename_upper)) == 0) { #if DEBUG pmsg("found file!\r\n"); #endif memreverse(buf + j*32 + 0x1c, &file_size, 4); memreverse(buf + j*32 + 0x1a, &cluster, 2); #if DEBUG pmsg("cluster numer:"); disword_dec(cluster); pmsg("\r\n"); #endif // fill in dir_entry memmove(de->filename, filename, length); de->attributes = *(buf + j*32 + 0x0b); memmove(de->unused_attr, buf + j*32 + 0x0c, 14); de->filesize = file_size; de->entry_addr = prtn.root_dir_addr + i*512 + j*32; de->first_cluster = cluster; return 1; } } } return 0; }
void FaceDetectorFilter::facesCallback(const pcl::PointCloud<pcl::PointXYZL>::ConstPtr& msg) { tf::Transform cameraTransform; try { tf::StampedTransform tr; transformListener.lookupTransform ( "odom","camera_link2",ros::Time(0),tr); cameraTransform=tr; } catch(...) { return; } std::set<unsigned int> usedUsers = deleteOld(); std::list<Point> incomingUsers; fillList(incomingUsers, msg,cameraTransform); while(1) { std::pair<unsigned int,std::list<Point>::iterator> match = findClosest(incomingUsers); if(match.first == 0) break; float distance = getDistance(users[match.first],*match.second); if(distance> MAX_SPEED) break; if(usedUsers.find(match.first) == usedUsers.end()) { users[match.first] = *match.second; usedUsers.insert(match.first); std::cerr<<"user updated: "<<match.first<<", distance:" <<distance<<std::endl; } else { std::cerr<<"user ignored: "<<match.first<<", distance:" <<distance<<std::endl; } incomingUsers.erase(match.second); } for(std::list<Point>::iterator it = incomingUsers.begin(); it!=incomingUsers.end(); ++it) { unsigned int newId = getAvailableId(usedUsers); users[newId] = *it; std::cerr<<"added user: "******"camera_link2"; pmsg->height = 1; for(std::map<unsigned int,Point>::iterator it = users.begin(); it != users.end(); ++it) { pcl::PointXYZL point; Point p(it->second); transformPoint(p,cameraTransform,true); point.label = it->first; point.x=p.x; point.y=p.y; point.z = p.z; pmsg->points.push_back(point); } pmsg->width = pmsg->points.size(); facePublisher.publish(pmsg); }
void transmitMessage(const std::string& sys, const InlineMessage<IMC::Message>& imsg) { if (!hasTransducer()) return; MicroModemMap::iterator itr = m_ummap.find(sys); if (itr == m_ummap.end()) return; const IMC::Message* msg = NULL; std::string command; try { msg = imsg.get(); } catch (...) { return; } if (msg->getId() == DUNE_IMC_PLANCONTROL) { const IMC::PlanControl* pc = static_cast<const IMC::PlanControl*>(msg); Memory::replace(m_pc, new IMC::PlanControl(*pc)); if (pc->op == IMC::PlanControl::PC_START) { std::vector<char> pmsg(c_binary_size, 0); if (pc->plan_id.size() > c_binary_size - 1) { err(DTR("unable to send plan %s"), pc->plan_id.c_str()); return; } // Make packet. pmsg[0] = (char)c_code_plan; std::memcpy(&pmsg[1], &pc->plan_id[0], std::min(c_binary_size - 1, (int)pc->plan_id.size())); std::string hex = String::toHex(pmsg); std::string cmd = String::str("$CCTXD,%u,%u,0,%s\r\n", m_address, itr->second, hex.c_str()); sendCommand(cmd); std::string cyc = String::str("$CCCYC,0,%u,%u,0,0,1\r\n", m_address, itr->second); sendCommand(cyc); } } if (command.empty()) return; sendCommand(command); }
void CGuildManager::Load(DWORD dwGuildID) { char szQuery[1024]; snprintf(szQuery, sizeof(szQuery), "SELECT id, name, ladder_point, win, draw, loss, gold, level FROM guild%s WHERE id=%u", GetTablePostfix(), dwGuildID); std::auto_ptr<SQLMsg> pmsg(CDBManager::instance().DirectQuery(szQuery)); if (pmsg->Get()->uiNumRows) ParseResult(pmsg->Get()); }
void testRecordEqual(bool showPassedTests) { Record *r1 = new Record(1, 2, "3"); Record *r2 = new Record(1, 2, "3"); if (recordEqual(r1, r2) == false) { fmsg("testRecordEqual, r1 != r2"); } else { pmsg("testRecordEqual"); } }
// creates a new file that can be used in an OS byte create_file(dir_entry_t* de, char* filename, byte fn_length, byte* buf) { if(!create_dir_entry(de, filename, fn_length, buf)) { #if DEBUG pmsg("Couldn't create direntry!\r\n"); #endif return 0; } if(!write_dir_entry(de, buf)) { #if DEBUG pmsg("problem writing direntry!\r\n"); #endif return 0; } return 1; }
int main(int argc, char *argv[]) { B b; D d; BPROC bpr = &B::bProc; AFX_PMSG pmsg(bpr); BPROC ppr = pmsg; return 0; }
extern int iwlog_getfd(void) { if (! alog) { pmsg(EV_NULL_OBJ); goto err; } return alog->logfd; err: return IW_ERR; }
byte initFAT(byte* buf) { byte i; dword partition_addr; i = read_block(buf,0); if(!i){ #if DEBUG pmsg("read timed out"); #endif return 0; } if (buf[PARTENTRY1 + 0x04] != 0x04 && buf[PARTENTRY1 + 0x04] != 0x06) { #if DEBUG pmsg("drive is not FAT16!\r\n"); #endif return 0; } partition_addr = ((dword)buf[PARTENTRY1 + 0x08] | (dword)buf[PARTENTRY1 + 0x09] << 8 | (dword)buf[PARTENTRY1 + 0x0a] << 16 | (dword)buf[PARTENTRY1 + 0x0b] << 24) * 512; #if DEBUG pmsg("partition_addr is: "); disdword(partition_addr); pmsg("\r\n"); #endif if (!read_block(buf, partition_addr)) { #if DEBUG pmsg("couldn't read start of partition!\r\n"); #endif return 0; } prtn_set_addr(buf, partition_addr); return 1; }
extern void iwlog_exit(void) { if (! alog) { return; } if (alog->logfd >= 0) { if (close(alog->logfd) == -1) { pmsg(EV_FAIL_CLOSE, alog->logfd, strerror(errno)); } } free(alog); }
//function for critical section, open file, sleep, write to file, close file void critical_section(){ pmsg(pnc, "is in CS"); f = fopen("cstest", "a"); time_t x; sleep((rand() % 3)); time(&x); char * t = ctime(&x); if(f != NULL){ fprintf(f, "%s %02s at time %.8s.\n", "File modified by process number", pnc, (t + 11)); } fclose(f); f = NULL; }
void testAddRecord(bool showPassedTests) { Record **arr = new Record*[2]; arr[0] = new Record(1, 11, "1"); arr[1] = new Record(2, 12, "1"); HighscoreTable ht = HighscoreTable(arr, 2, 2); Record *r = new Record(3, 13, "3"); ht.addRecord(r); if (recordEqual(r, ht.getRecords()[2]) != true) { fmsg("testAddRecord, records differ"); } else { pmsg("testAddRecord"); } }
word next_clus(word clus, byte *buf) { dword addr; word next; addr = prtn.FAT_addr + 2*clus; if(!read_block(buf, addr - addr % 512)) { #if DEBUG pmsg("next_clus failed when reading block!\r\n"); #endif return 0; } memreverse(buf + addr%512, &next, 2); return next; }
void CClientManager::GuildAddMember(CPeer* peer, TPacketGDGuildAddMember * p) { CGuildManager::instance().TouchGuild(p->dwGuild); sys_log(0, "GuildAddMember %u %u", p->dwGuild, p->dwPID); char szQuery[512]; snprintf(szQuery, sizeof(szQuery), "INSERT INTO guild_member%s VALUES(%u, %u, %d, 0, 0)", GetTablePostfix(), p->dwPID, p->dwGuild, p->bGrade); std::auto_ptr<SQLMsg> pmsg_insert(CDBManager::instance().DirectQuery(szQuery)); snprintf(szQuery, sizeof(szQuery), "SELECT pid, grade, is_general, offer, level, job, name FROM guild_member%s, player%s WHERE guild_id = %u and pid = id and pid = %u", GetTablePostfix(), GetTablePostfix(), p->dwGuild, p->dwPID); std::auto_ptr<SQLMsg> pmsg(CDBManager::instance().DirectQuery(szQuery)); if (pmsg->Get()->uiNumRows == 0) { sys_err("Query failed when getting guild member data %s", pmsg->stQuery.c_str()); return; } MYSQL_ROW row = mysql_fetch_row(pmsg->Get()->pSQLResult); if (!row[0] || !row[1]) return; TPacketDGGuildMember dg; dg.dwGuild = p->dwGuild; str_to_number(dg.dwPID, row[0]); str_to_number(dg.bGrade, row[1]); str_to_number(dg.isGeneral, row[2]); str_to_number(dg.dwOffer, row[3]); str_to_number(dg.bLevel, row[4]); str_to_number(dg.bJob, row[5]); strlcpymt(dg.szName, row[6], sizeof(dg.szName)); ForwardPacket(HEADER_DG_GUILD_ADD_MEMBER, &dg, sizeof(TPacketDGGuildMember)); }
void CClientManager::LoadEventFlag() { char szQuery[1024]; snprintf(szQuery, sizeof(szQuery), "SELECT szName, lValue FROM quest%s WHERE dwPID = 0", GetTablePostfix()); std::auto_ptr<SQLMsg> pmsg(CDBManager::instance().DirectQuery(szQuery)); SQLResult* pRes = pmsg->Get(); if (pRes->uiNumRows) { MYSQL_ROW row; while ((row = mysql_fetch_row(pRes->pSQLResult))) { TPacketSetEventFlag p; strlcpymt(p.szFlagName, row[0], sizeof(p.szFlagName)); str_to_number(p.lValue, row[1]); sys_log(0, "EventFlag Load %s %d", p.szFlagName, p.lValue); m_map_lEventFlag.insert(std::make_pair(std::string(p.szFlagName), p.lValue)); ForwardPacket(HEADER_DG_SET_EVENT_FLAG, &p, sizeof(TPacketSetEventFlag)); } } }