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