// local s = oid2str(oid)
int luaU_oid2str(lua_State* L)
{
char buf[256];
if(lua_isnumber(L, 1))
{
double number = lua_tonumber(L, 1);
UINT64 val;
memcpy(&val, &number, sizeof(UINT64));
size_t l = sprintf_k(buf, sizeof(buf), "%lld", val);
lua_pushlstring(L, buf, l);
return 1;
}
else if(lua_islightuserdata(L, 1))
{
UINT64 val = (UINT64)lua_touserdata(L, 1);
size_t l = sprintf_k(buf, sizeof(buf), "%lld", val);
lua_pushlstring(L, buf, l);
return 1;
}
else
{
luaL_argerror(L, 1, "arg:oid should be a number value");
return 0;
}
}
string_512 KChatMessage::buildMessageFilePath(const JgMessageID& mid, const JgMessageTarget& target)
{
char buf[512];
switch(target.targetType)
{
case JgMessageTargetType::PERSON:
{
int n = sprintf_k(buf, sizeof(buf), "received/%08d/person/%llu/%u",
mid.yyyy_mm_dd,
target.targetID,
mid.sequence);
return string_512(buf, n);
}
case JgMessageTargetType::GROUP:
{
int n = sprintf_k(buf, sizeof(buf), "received/%08d/group/%llu/%u",
mid.yyyy_mm_dd,
target.targetID,
mid.sequence);
return string_512(buf, n);
}
case JgMessageTargetType::AVATAR:
{
int n = sprintf_k(buf, sizeof(buf), "avatar/%llu/%08d-%u",
target.targetID,
mid.yyyy_mm_dd,
mid.sequence);
return string_512(buf, n);
}
case JgMessageTargetType::PUBLIC:
break;
}
return string_512();
}
int KItemCreate::_LoadItemInfo(KTabFile2& itemTabFile, KCreateInfo_ItemBase& CIIB)
{
int nParam = 0;
itemTabFile.GetInteger("ID", 0, (int*)&nParam);
CIIB.s_nItemID = nParam;
if(0 == CIIB.s_nItemID)
return -1;
itemTabFile.GetInteger("NameID", 0, (int*)&nParam);
CIIB.s_nNameID = nParam;
itemTabFile.GetInteger("DesID", 0, (int*)&nParam);
CIIB.s_nDesID = nParam;
itemTabFile.GetInteger("Level", 0, (int*)&nParam);
CIIB.s_nLevel = nParam;
itemTabFile.GetInteger("Quality", 0, (int*)&nParam);
CIIB.s_byQuality = nParam;
itemTabFile.GetInteger("DisplayID", 0, (int*)&nParam);
CIIB.s_nDisplayID = nParam;
itemTabFile.GetInteger("ItemType", 0, (int*)&nParam);
CIIB.s_byItemType = nParam;
itemTabFile.GetInteger("Price", 0, (int*)&nParam);
CIIB.s_nPrice = nParam;
itemTabFile.GetInteger("Bind", 0, (int*)&nParam);
CIIB.s_byBindType = nParam;
itemTabFile.GetInteger("AliveType", 0, (int*)&nParam);
CIIB.s_byAliveType = nParam;
itemTabFile.GetInteger("AliveTime", 0, (int*)&nParam);
CIIB.s_dwAliveTime = nParam;
itemTabFile.GetInteger("Flags", 0, (int*)&nParam);
CIIB.s_dwFlags = nParam;
for(int i = 0 ; i < MAX_WORLD_DROP_COUNT; i++)
{
char chBuf[128] = { 0 };
sprintf_k( chBuf, sizeof(chBuf), "WGroup%d", i + 1);
itemTabFile.GetInteger(chBuf, 0, (int*)&nParam);
CIIB.s_nWGroup[i] = nParam;
sprintf_k(chBuf, sizeof(chBuf), "WProb%d", i + 1);
itemTabFile.GetInteger(chBuf, 0, (int*)&nParam);
CIIB.s_nWProb[i] = nParam;
}
itemTabFile.GetInteger("Stacks", 0, (int*)&nParam);
CIIB.s_nMaxStacks = max(nParam, 1);
itemTabFile.GetInteger("VanishType", 0, (int*)&nParam);
CIIB.s_byVanishType = nParam;
itemTabFile.GetInteger("CostType", 0, (int*)&nParam);
CIIB.s_nCostType = nParam;
itemTabFile.GetString("Icon", "", CIIB.s_icon, sizeof(CIIB.s_icon));
itemTabFile.GetInteger("MaxKeep", 0, (int*)&nParam);
CIIB.s_nMaxKeep = nParam;
return CIIB.s_nItemID;
}
bool KAccount::load(KRedis& redis, int hours, const char* acctName)
{
KDatetime dtStart;
dtStart.AddSecond(-hours*KDatetime::hour_seconds);
m_startTime = (time_t)dtStart.Time();
m_acctName = g_stringPool.get(acctName);
char acctKey[128];
sprintf_k(acctKey, sizeof(acctKey), "acct.%s", acctName);
char lastActive[32];
if(!redis.hget(acctKey, "lastActive", lastActive, sizeof(lastActive)))
return false;
m_lastActive = (time_t)str2int(lastActive);
if(!m_activeServerSet.loadFromRedis(redis, m_startTime, acctKey))
return false;
int n = m_activeServerSet.size();
for(int i=0; i<n; i++)
{
const char* serverName = m_activeServerSet.at(i);
KServer* pServer = this->newServer(serverName);
// player.server.acct.<acct>.<server>
{
char playerKey[128];
sprintf_k(playerKey, sizeof(playerKey), "player.server.acct.%s.%s", acctName, serverName);
h_player_visitor v(m_acctName, pServer, m_startTime);
redis.hscan(playerKey, "*", v);
}
// login.server.acct.<acct>.<server>
{
char loginKey[128];
sprintf_k(loginKey, sizeof(loginKey), "login.server.acct.%s.%s", acctName, serverName);
l_login_visitor v(m_acctName, pServer, m_startTime);
redis.lrange(loginKey, 0, -1, v);
v.afterDone();
}
// trade.server.acct.<acct>.<server>
{
char tradeKey[128];
sprintf_k(tradeKey, sizeof(tradeKey), "trade.server.acct.%s.%s", acctName, serverName);
l_trade_visitor v(m_acctName, pServer, m_startTime);
redis.lrange(tradeKey, 0, -1, v);
}
}
return true;
}
void FS_DeleteMessageByDate::execute()
{
int n;
char path[512];
JG_F::KDirectory dir;
JG_F::KDirectory::FileList flist;
sprintf_k(path, sizeof(path), "%s/private", g_pApp->m_storageAgent.m_dataDir.c_str());
dir.Open(path);
flist.clear();
dir.ListFile(flist);
n = flist.size();
for(int i=0; i<n; i++)
{
const JG_F::KFileData& fdata = flist.at(i);
if(!fdata._isDir()) continue;
int n = str2int(fdata.m_shortName);
if(!n) continue;
if(n <= m_yyyymmdd)
{
JG_F::KFileData::FilePath filePath = fdata.getPath();
JG_F::KFileUtil::rmDirRecursive(filePath.c_str());
Log(LOG_WARN, "warn: recursive rmDir '%s'", filePath.c_str());
}
}
sprintf_k(path, sizeof(path), "%s/public", g_pApp->m_storageAgent.m_dataDir.c_str());
dir.Open(path);
flist.clear();
dir.ListFile(flist);
n = flist.size();
for(int i=0; i<n; i++)
{
const JG_F::KFileData& fdata = flist.at(i);
if(!fdata._isDir()) continue;
int n = str2int(fdata.m_shortName);
if(!n) continue;
if(n <= m_yyyymmdd)
{
JG_F::KFileData::FilePath filePath = fdata.getPath();
JG_F::KFileUtil::rmDirRecursive(filePath.c_str());
Log(LOG_WARN, "warn: recursive rmDir '%s'", filePath.c_str());
}
}
return;
}
bool KApplicationStatus::initialize(const char* dataDir)
{
char filename[512];
sprintf_k(filename, sizeof(filename), "%s/.appstatus.dat", dataDir);
if(!m_mmap.Initialize(filename, 0, sizeof(ApplicationData)))
return false;
m_appData = (ApplicationData*)m_mmap.GetMemory();
KMMap::eFileOpenStatus openStatus = m_mmap.GetOpenStatus();
switch(openStatus)
{
case KMMap::enum_CreateNew:
case KMMap::enum_ModifyExists:
{
memset(m_appData, 0, sizeof(ApplicationData));
KDatetime nowDate;
KLocalDatetime ldt = nowDate.GetLocalTime();
m_appData->yyyy_mm_dd = ldt.year * 10000 + ldt.month * 100 + ldt.day;
m_appData->expireTime = KDatetime::nextDayFirstSecond((TIME_T)nowDate.Time());
m_appData->daySequence = 0;
} break;
}
return true;
}
variant& variant::setobject(const char* typeName, void* val)
{
this->clear();
this->vt = vt_object;
sprintf_k((char*)&this->obj.first, sizeof(this->obj.first), typeName);
this->obj.second = val;
return *this;
}
string_512 KOutgoingMessage::buildMessageFullPath() const
{
char buf[512];
int n = sprintf_k(buf, sizeof(buf), "%s/%s",
getUserDirectory(),
this->buildMessageFilePath().c_str());
return string_512(buf, n);
}
static const char* time2str(int t)
{
static char buf[32];
KDatetime dt(t);
JG_C::KString<32> s = dt.ToString();
sprintf_k(buf, sizeof(buf), "%s", s.c_str());
return buf;
}
bool KAnalysis::scanPatternAcctList(int hours, const char* acct_pattern)
{
name_visitor v(*this);
KRedis redis = g_pApp->masterRedis();
char pattern[128];
sprintf_k(pattern, sizeof(pattern), "acct.%s", acct_pattern);
if(!redis.scan(pattern, v))
{
Log(LOG_CONSOLE|LOG_ERROR, "error: scan account name from redis");
return false;
}
KDatetime dt;
dt.AddSecond(-hours*KDatetime::hour_seconds);
int startTime = (int)dt.Time();
char acctKey[128];
char lastActive[64];
KLargeNameList::iterator it = m_acctNameList.begin();
for(; it != m_acctNameList.end(); it++)
{
const char* name = *it;
sprintf_k(acctKey, sizeof(acctKey), "acct.%s", name);
if(!redis.hget(acctKey, "lastActive", lastActive, sizeof(lastActive)))
{
if(!redis.isReady())
return false;
m_deactiveNameList.append(name);
}
else
{
int t = str2int(lastActive);
if(t > startTime) m_activeNameList.append(name);
else m_deactiveNameList.append(name);
}
}
return true;
}
string_512 KOutgoingMessage::buildTmpFileName() const
{
char buf[512];
KDatetime nowDate;
KLocalDatetime ldt = nowDate.GetLocalTime();
int n = sprintf_k(buf, sizeof(buf), "%s/tmp/%04d%02d%02d/%d",
getUserDirectory(),
ldt.year, ldt.month, ldt.day, m_sequence);
return string_512(buf, n);
}
JG_C::KString<256> PooledConnection::toString() const
{
if(!m_setting) return "<empty>";
char buf[256];
int n = sprintf_k(buf, sizeof(buf), "(%s) %s:%u max:%d",
m_setting->m_name.c_str(),
m_setting->m_ip.c_str(), m_setting->m_port,
m_setting->m_maxConnection);
return JG_C::KString<256>(buf, n);
}
bool KMapSettings::initialize(StreamInterface& si)
{
char buf[64];
XMLDomParser parser;
if(!parser.Initialize())
{
Log(LOG_ERROR, "error: KMapSettings::initialize, init xml parser");
return false;
}
XMLElementNode xmlRoot;
if(!parser.Parse(si, xmlRoot))
{
Log(LOG_ERROR, "error: KMapSettings::initialize, parse xml, %s", parser.GetErrorMsg());
return false;
}
KMapSetting ms;
XMLNodeColl coll = xmlRoot.QueryChildren2("MapSettings/Map");
int n = coll.Size();
for(int i=0; i<n; i++)
{
ms.clear();
XMLElementNode* mapXml = (XMLElementNode*)coll.GetNode(i);
const char* mapName = mapXml->QueryAtt("file")->c_str();
const char* descName = mapXml->QueryAtt("name")->c_str();
ms.m_mapID = mapXml->QueryAtt("id")->Integer();
if(mapXml->QueryAtt("dup"))
{
ms.m_duplicate = mapXml->QueryAtt("dup")->Integer() ? 1:0;
}
ms.m_mapName = KBuffer64k::WriteData(mapName, strlen(mapName)+1);
ms.m_descName = KBuffer64k::WriteData(descName, strlen(descName)+1);
if(mapXml->QueryAtt("EntryPoint.value")) ms.setEntryPoint(0, mapXml->QueryAtt("EntryPoint.value")->Integer());
if(mapXml->QueryAtt("BornPoint.value")) ms.setBornPoint(0, mapXml->QueryAtt("BornPoint.value")->Integer());
if(mapXml->QueryAtt("RelivePoint.value")) ms.setRelivePoint(0, mapXml->QueryAtt("RelivePoint.value")->Integer());
if(mapXml->QueryAtt("ExitPoint.value")) ms.setExitPoint(0, mapXml->QueryAtt("ExitPoint.value")->Integer());
if(mapXml->QueryAtt("ReturnPoint.value")) ms.setReturnPoint(0, mapXml->QueryAtt("ReturnPoint.value")->Integer());
int len = sprintf_k(buf, sizeof(buf), "Map_%d", ms.m_mapID);
ms.m_luaTable = KBuffer64k::WriteData(buf, len+1);
ms.m_createTimeout = ms.getIntAttr("createTimeout", 2*60);
ms.m_idleTimeout = ms.getIntAttr("idleTimeout", ms.m_duplicate?5*60:-1);
ms.m_carePlayerEnter = ms.getBoolAttr("carePlayerEnter", false) ? TRUE : FALSE;
m_maps[ms.m_mapID] = ms;
}
return true;
}
string_512 LogFileWriter::buildFilepath(const char* serverName, int yyyymmdd, const char* verb)
{
char buf[512];
const char* dirName = g_pApp->getDataDir();
const char* platformName = g_pApp->getPlatformName();
const char* baseFilename = g_pApp->getBaseFileName();
const char* fileExt = g_pApp->getLogFileExt();
int n = sprintf_k(buf,sizeof(buf), "%s\\%s\\server%s\\%s_%d%s", dirName, platformName, serverName, baseFilename, yyyymmdd, fileExt);
return string_512(buf, n);
}
void KPerfHitchCounter::Init(const char* pLogFileName,size_t iMaxCount)
{
m_MainThreadId = GetCurrentThreadId();
m_logger.Open(pLogFileName);
m_iMaxCount = iMaxCount;
m_recs = new PerfHitchRec[m_iMaxCount];
char szName[128];
for(size_t i = 0;i<m_iMaxCount;++i)
{
m_recs[i].id = (int)i;
char szName[128];
sprintf_k(szName,sizeof(szName),"UnNamed_FuncID_%d",m_recs[i].id);
m_recs[i].name = szName;
}
}
LuaString KTrade::olist()
{
char buf[1024];
int pos = 0;
ItemMap::iterator it = m_olist.begin();
for(; it!=m_olist.end(); it++)
{
int t = it->first;
int c = it->second;
int n = sprintf_k(&buf[pos], sizeof(buf)-pos, "%s%d:%d", pos?",":"", t, c);
pos += n;
int avail = sizeof(buf) - pos;
if(avail < 20) break;
}
buf[pos] = '\0';
return LuaString(buf, pos);
}
void PerfHitchRecUnit::WriteInfor(AsyncFileLogger& logger,unsigned short iFormatLevel,KPerfHitchStackRec* pStack)
{
static DWORD cpuSecCycles = GetCpuCyclesPerSecond();
/*double fAvg = 0.0f;
if(SumCount>0)
{
fAvg = (double)(SumCycles/SumCount);
}*/
UINT64 sumCycles = (UINT64) (((double)SumCycles/cpuSecCycles)*1000000);
if(sumCycles == 0)
return ;
UINT64 maxCycles = (UINT64) (((double)MaxCycles/cpuSecCycles)*1000000);
if(NULL != pPerfHitchRec)
{
::System::Collections::KString<64>FormatBuf;
for(int i = 0;i<iFormatLevel;++i)
{
FormatBuf.append(" ");
}
char buf[1024];
size_t n = sprintf_k(buf, sizeof(buf), "%s %llu %llu %llu",
pPerfHitchRec->name.c_str(),
SumCount,
sumCycles,
maxCycles);
logger.WriteLog(" %s%s", FormatBuf.c_str(),buf);
if(-1 != iParamIndex)
{
logger.WriteLog("--Param: %s", pStack->m_ParamPool[iParamIndex]->c_str());
}
}
for(int i = 0;i<ChildArray.size();++i)
{
ChildArray[i]->WriteInfor(logger,iFormatLevel+1,pStack);
}
}
int KItemCreate::_LoadItemInfo(KTabFile2& itemTabFile, KCreateInfo_Item& CII)
{
int nBaseReturn = _LoadItemInfo(itemTabFile, *((KCreateInfo_ItemBase*)(&CII)));
if(nBaseReturn > 0)
{
int nParam = 0;
itemTabFile.GetInteger("SkillID", 0, (int*)&nParam);
CII.s_nSkillID = nParam;
for( int i = 0 ; i < MAX_EFFECT_PARAM_COUNT; i ++ )
{
char chBuf[128] = { 0 };
sprintf_k( chBuf, sizeof(chBuf), "Effect1Param%d", i + 1);
itemTabFile.GetInteger(chBuf, 0, (int*)&nParam);
}
itemTabFile.GetInteger("ConditionID", 0, (int*)&nParam);
CII.s_nConditionID = nParam;
itemTabFile.GetInteger("CParam1", 0, (int*)&nParam);
CII.s_nCParam = nParam;
itemTabFile.GetInteger("MaxDura", 0, (int*)&nParam);
CII.s_wMaxDura = nParam;
itemTabFile.GetInteger("InitDura", 0, (int*)&nParam);
CII.s_wInitDura = nParam;
itemTabFile.GetInteger("MaxUseTime", 0, (int*)&nParam);
CII.s_byMaxUseTime = nParam;
itemTabFile.GetInteger("InitFrequency", 0, (int*)&nParam);
CII.s_byInitUseTime = nParam;
itemTabFile.GetInteger("ItemWeight", 0, (int*)&nParam);
CII.s_nItemWeight = nParam;
itemTabFile.GetInteger("ItemMaterial", 0, (int*)&nParam);
CII.ItemMaterial = nParam;
}
return nBaseReturn;
}
void KPerfHitchCounter::WriteInforImp()
{
if(m_bWriteSumRec)
{
m_logger.WriteLog(">>>>>>>>>>>>>>> perf Hitch sum Infor >>>>>>>>>>>>>>>>>>>>>>>>>");
m_logger.WriteLog(" Name LastCount avg Last");
char buf[512];
for(size_t i=0; i<m_iMaxCount; i++)
{
if(m_recs[i].used)
{
static DWORD cpuSecCycles = GetCpuCyclesPerSecond();
double fAvg = 0.0f;
if(m_recs[i].sumCount>0)
{
fAvg = (double)(m_recs[i].sumCycles/m_recs[i].sumCount);
}
size_t n = sprintf_k(buf, sizeof(buf), "%s %llu %llu %llu",
m_recs[i].name.c_str(),
m_recs[i].lastrunCount,
(UINT64) (((double)fAvg/cpuSecCycles)*1000000),
(UINT64) (((double)m_recs[i].lastCycles/cpuSecCycles)*1000000));
m_logger.WriteLog(" %s", buf);
}
}
m_logger.WriteLog(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");
}
if(m_bWriteStackRec)
{
m_logger.WriteLog(">>>>>>>>>>>>>>> perf Hitch stack Infor >>>>>>>>>>>>>>>>>>>>>>>>>");
m_logger.WriteLog(" Name Count Sum Max");
m_StackRec.WriteInfor(m_logger);
m_logger.WriteLog(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");
}
}
JG_C::KString<128> WorldID::toString() const
{
char buf[128];
int len = sprintf_k(buf, sizeof(buf), "%u(%d:%d:%d)", (DWORD)*this, m_lineID, m_worldType, m_idx);
return JG_C::KString<128>(buf, len);
}
XMLElementNode& XMLElementNode::SetAttribute(const char* name, float val)
{
char cTmp[64];
sprintf_k(cTmp, sizeof(cTmp), "%.2f", val);
return this->SetAttribute(name, cTmp);
}
bool KWorldSettings::initialize(KMapSettings& mss, StreamInterface& fi)
{
char buf[128];
XMLDomParser parser;
if(!parser.Initialize())
{
Log(LOG_ERROR, "error: KWorldSettings::initialize, init xml parser");
return false;
}
XMLElementNode xmlRoot;
if(!parser.Parse(fi, xmlRoot))
{
Log(LOG_ERROR, "error: KWorldSettings::initialize, parse xml, %s", parser.GetErrorMsg());
return false;
}
KWorldSetting ws;
XMLNodeColl coll2; int c;
XMLNodeColl coll = xmlRoot.QueryChildren2("WorldSettings/World");
int n = coll.Size();
for(int i=0; i<n; i++)
{
ws.clear();
XMLElementNode* worldXml = (XMLElementNode*)coll.GetNode(i);
const char* worldName = worldXml->QueryAtt("name")->c_str();
ws.m_mapID = worldXml->QueryAtt("map")->Integer();
ws.m_mapSetting = mss.getMapSetting(ws.m_mapID);
if(!ws.m_mapSetting)
{
Log(LOG_ERROR, "error: KWorldSettings::initialize, map %d not found", ws.m_mapID);
return false;
}
ws.m_worldType = worldXml->QueryAtt("type")->Integer();
ws.m_worldName = KBuffer64k::WriteData(worldName, strlen(worldName)+1);
int len = sprintf_k(buf, sizeof(buf), "WorldMonitor_%d", ws.m_worldType);
ws.m_luaTable = KBuffer64k::WriteData(buf, len+1);
coll2 = worldXml->QueryChildren2("Monster"); c = coll2.Size();
for(int k=0; k<c; k++)
{
KWorldSetting::Monster monster;
XMLElementNode* elemXml = (XMLElementNode*)coll2.GetNode(k);
const char* fileName = elemXml->QueryAtt("value")->c_str();
monster.first = elemXml->QueryAtt("id")->Integer();
monster.second = KBuffer64k::WriteData(fileName, strlen(fileName)+1);
ws.m_monsters.push_back(monster);
}
coll2 = worldXml->QueryChildren2("TreasureCase"); c = coll2.Size();
for(int k=0; k<c; k++)
{
XMLElementNode* elemXml = (XMLElementNode*)coll2.GetNode(k);
const char* fileName = elemXml->QueryAtt("value")->c_str();
ws.m_tcs.push_back(KBuffer64k::WriteData(fileName, strlen(fileName)+1));
}
coll2 = worldXml->QueryChildren2("Transimission"); c = coll2.Size();
for(int k=0; k<c; k++)
{
XMLElementNode* elemXml = (XMLElementNode*)coll2.GetNode(k);
const char* fileName = elemXml->QueryAtt("value")->c_str();
ws.m_transes.push_back(KBuffer64k::WriteData(fileName, strlen(fileName)+1));
}
coll2 = worldXml->QueryChildren2("Traffic"); c = coll2.Size();
for(int k=0; k<c; k++)
{
XMLElementNode* elemXml = (XMLElementNode*)coll2.GetNode(k);
int trafficRoute = elemXml->QueryAtt("value")->Integer();
ws.m_traffics.push_back(trafficRoute);
}
//coll2 = worldXml->QueryChildren2("Scene"); c = coll2.Size();
//for(int k=0; k<c; k++)
//{
// KWorldSetting::Scene scene;
// XMLElementNode* elemXml = (XMLElementNode*)coll2.GetNode(k);
// scene.first = elemXml->QueryAtt("x")->Integer();
// scene.second = elemXml->QueryAtt("y")->Integer();
// ws.m_scenes.insert_unique(scene);
//}
this->_addWorldType(ws);
}
return true;
}
BOOL DB_SavePersonPrivate::execute(KSqlContext& ctx)
{
KSQLCommand& cmd = ctx.cmd;
KSQLResultSet& rs = ctx.rs;
const char* sql = "call proc_SavePersonPrivateMessage(?,?,?,?,?,?)";
KSQLFieldDescribe params[6];
params[0].m_name = "mid";
params[0].m_cdt = KSQLTypes::sql_c_uint64;
params[1].m_name = "recvID";
params[1].m_cdt = KSQLTypes::sql_c_uint64;
params[2].m_name = "senderID";
params[2].m_cdt = KSQLTypes::sql_c_uint64;
params[3].m_name = "contentType";
params[3].m_cdt = KSQLTypes::sql_c_int32;
params[4].m_name = "msgFile";
params[4].m_cdt = KSQLTypes::sql_c_string;
params[4].m_length = 32;
params[5].m_name = "recvTime";
params[5].m_cdt = KSQLTypes::sql_c_uint64;
if(!cmd.SetSQLStatement(sql))
{
m_result = JgErrorCode::err_SqlStatement;
return FALSE;
}
if(!cmd.DescribeParameters(params, 6))
{
m_result = JgErrorCode::err_SqlParams;
return FALSE;
}
char fileName[256];
int namelen = sprintf_k(fileName, sizeof(fileName), "private/%08d/person/%llu/%u",
m_message->m_messageID.yyyy_mm_dd,
m_message->m_target.targetID,
m_message->m_messageID.sequence);
m_messageFile.assign(fileName, namelen);
if( !cmd.SetInt64 (0, MessageID2Int64(m_message->m_messageID))
|| !cmd.SetInt64 (1, m_receiverID)
|| !cmd.SetInt64 (2, m_senderID)
|| !cmd.SetInteger(3, m_message->m_contentType)
|| !cmd.SetString (4, fileName, namelen)
|| !cmd.SetInt64 (5, time(NULL)))
{
m_result = JgErrorCode::err_SqlParams;
return FALSE;
}
if(!cmd.ExecuteQuery(rs))
{
m_result = JgErrorCode::err_SqlExecute;
Log(LOG_ERROR, "error: DB_SavePersonPrivate, %s", cmd.GetLastErrorMsg());
return FALSE;
}
return TRUE;
}
BOOL XMLDomParser::Parse(StreamInterface& s, XMLElementNode& root)
{
this->Reset();
size_t pos = s.tell();
DWORD flag = 0;
int_r n2 = s.ReadData(&flag, 3);
if(n2 == 3 && flag == utf8_signature)
{
const char* encoding = "UTF-8";
if(stricmp(encoding, m_encoding.c_str()) && m_parser)
{
XML_ParserFree(m_parser);
m_parser = NULL;
}
m_encoding = encoding;
}
else
{
s.Seek(pos);
}
if(!m_parser)
{
if(m_encoding.empty()) m_encoding = "GB2312";
m_parser = XML_ParserCreate(m_encoding.c_str());
if(!m_parser) return FALSE;
XML_SetUserData(m_parser, this);
XML_SetElementHandler(m_parser, &StartElementHandler, &EndElementHandler);
XML_SetCharacterDataHandler(m_parser, &CharacterDataHandler);
}
if(root.m_tagName.empty())
root.SetTagName("XMLRoot");
m_pRootNode = &root;
m_stack.push(m_pRootNode);
//const char* orglocale = NULL;
//if(m_encoding.icompare("GB2312") == 0)
// orglocale = setLocaleToGbk();
//else if(g_encoding == encode_ansii && m_encoding.icompare("UTF-8") == 0)
// orglocale = setLocaleToGbk();
int_r n;
char cBuffer[2048];
while(n = s.ReadData(&cBuffer, 2048), n>=0)
{
BOOL isFinal = (n < 2048);
XML_Status status = XML_Parse(m_parser, cBuffer, (int)n, isFinal);
if(status == XML_STATUS_ERROR)
{
//if(orglocale) setlocale(LC_CTYPE, orglocale);
sprintf_k(cBuffer, sizeof(cBuffer), "%s at line:%d col:%d",
XML_ErrorString(XML_GetErrorCode(m_parser)),
XML_GetCurrentLineNumber(m_parser),
XML_GetCurrentColumnNumber(m_parser));
m_errMsg = cBuffer;
return FALSE;
}
if(isFinal) break;
}
//if(orglocale) setlocale(LC_CTYPE, orglocale);
return TRUE;
}
