Files
metin2-server/tests/features/test_sql_mark_bounds.py
T

154 lines
10 KiB
Python

"""Run the production SQL metadata, mark index and boot encoder boundaries."""
from pathlib import Path
import subprocess
import tempfile
import unittest
ROOT=Path(__file__).resolve().parents[2]
def function(text,signature):
start=text.index(signature);a=text.index('{',start);depth=1;b=a+1
while depth:
if text[b]=='{':depth+=1
elif text[b]=='}':depth-=1
b+=1
return text[start:b]+'\n'
class SQLMarkBounds(unittest.TestCase):
def native(self,code):
with tempfile.TemporaryDirectory() as tmp:
src=Path(tmp)/'probe.cpp';exe=src.with_suffix('');src.write_text(code)
subprocess.run(['c++','-std=c++17','-fsanitize=address,undefined','-fno-sanitize-recover=all','-Werror=implicit-int-conversion','-Werror=shorten-64-to-32','-I'+str(ROOT),str(src),'-o',str(exe)],check=True)
subprocess.run([str(exe)],cwd=tmp,check=True)
def test_sql_store_preserves_mysql_width_and_error_sentinel(self):
text=(ROOT/'src/server/libsql/AsyncSQL.h').read_text(encoding='latin1');a=text.index('typedef struct _SQLResult');b=text.index('class CAsyncSQL')
self.native(r'''
#include <cassert>
#include <cstdint>
#include <cstddef>
#include <string>
#include <vector>
using my_ulonglong=unsigned long long;
struct MYSQL_RES {my_ulonglong rows;};
struct Fake {MYSQL_RES* rows;my_ulonglong id,affected;};
struct MYSQL {std::vector<Fake> results;size_t index=0;};
unsigned frees=0;
MYSQL_RES* mysql_store_result(MYSQL* m){return m->results[m->index].rows;}
my_ulonglong mysql_insert_id(MYSQL* m){return m->results[m->index].id;}
my_ulonglong mysql_affected_rows(MYSQL* m){return m->results[m->index].affected;}
my_ulonglong mysql_num_rows(MYSQL_RES* r){return r->rows;}
int mysql_next_result(MYSQL* m){return ++m->index<m->results.size()?0:-1;}
void mysql_free_result(MYSQL_RES*){++frees;}
'''+text[a:b]+r'''
int main(){
static_assert(sizeof(SQLResult::uiNumRows)==8 && sizeof(SQLResult::uiAffectedRows)==8 && sizeof(SQLResult::uiInsertID)==8);
MYSQL_RES rows={uint64_t(UINT32_MAX)+17};MYSQL db={{{&rows,uint64_t(UINT32_MAX)+1,UINT64_MAX},{nullptr,UINT32_MAX,UINT32_MAX},{nullptr,0,0}}};
{
SQLMsg msg;msg.m_pkSQL=&db;msg.Store();assert(msg.vec_pkResult.size()==3);
SQLResult* result=msg.Get();assert(result->uiNumRows==uint64_t(UINT32_MAX)+17&&result->uiInsertID==uint64_t(UINT32_MAX)+1&&result->uiAffectedRows==UINT64_MAX&&!result->HasAffectedRows());
uint32_t id=123;assert(!result->GetInsertID32(id)&&id==123);
assert(msg.Next());result=msg.Get();assert(result->HasAffectedRows());assert(result->GetInsertID32(id)&&id==UINT32_MAX); // 2^32-1 is a valid count/ID, not the 64-bit error.
assert(msg.Next());assert(!msg.Get()->HasAffectedRows());id=7;assert(!msg.Get()->GetInsertID32(id)&&id==7);assert(!msg.Next());
}
assert(frees==1);
}
''')
def test_mark_index_validation_atomic_load_and_unaligned_output(self):
text=(ROOT/'src/server/game/src/MarkManager.cpp').read_text(encoding='latin1')
methods=''.join(function(text,s) for s in ['CGuildMarkManager::CGuildMarkManager()','bool CGuildMarkManager::LoadMarkIndex()','bool CGuildMarkManager::AddMarkIDByGuildID','DWORD CGuildMarkManager::GetMarkCount()','bool CGuildMarkManager::CopyMarkIdx','DWORD CGuildMarkManager::GetMarkID','DWORD CGuildMarkManager::__AllocMarkID','DWORD CGuildMarkManager::SaveMark'])
self.native(r'''
#include <cassert>
#include <cstdio>
#include <cstring>
#include <cstdint>
#include <map>
#include <set>
#include <string>
#include <sstream>
#include <fstream>
#include <array>
#include <sys/stat.h>
using BYTE=uint8_t;using WORD=uint16_t;using DWORD=uint32_t;
struct CGuildMarkImage {static constexpr unsigned MARK_TOTAL_COUNT=1280;void SaveMark(DWORD,BYTE*){}};
#define sys_log(...) ((void)0)
#define sys_err(...) ((void)0)
struct CGuildMarkManager {
static constexpr unsigned MAX_IMAGE_COUNT=5;static constexpr DWORD INVALID_MARK_ID=UINT32_MAX;CGuildMarkImage image;
std::map<DWORD,DWORD> m_mapGID_MarkID;std::set<DWORD> m_setFreeMarkID;std::string m_pathPrefix="probe";int imageLoads=0;
DWORD GetMarkID(DWORD);DWORD __AllocMarkID(DWORD);DWORD SaveMark(DWORD,BYTE*);CGuildMarkImage* __GetImage(DWORD){return &image;}void SaveMarkImage(DWORD){}bool SaveMarkIndex(){return true;}
CGuildMarkManager();bool LoadMarkIndex();bool AddMarkIDByGuildID(DWORD,DWORD);DWORD GetMarkCount()const;bool CopyMarkIdx(char*,size_t)const;void LoadMarkImages(){++imageLoads;}
};
'''+methods+r'''
void file(const std::string& text){std::ofstream out("mark/probe_index");out<<text;}
int main(){
mkdir("mark",0700);CGuildMarkManager marks;
assert(marks.SaveMark(65536,nullptr)==UINT32_MAX && !marks.GetMarkCount());assert(marks.SaveMark(1,nullptr)==0);
assert(marks.AddMarkIDByGuildID(1,0));assert(marks.AddMarkIDByGuildID(1,0));
assert(!marks.AddMarkIDByGuildID(1,1)&&!marks.AddMarkIDByGuildID(2,0));
assert(!marks.AddMarkIDByGuildID(65536,1)&&!marks.AddMarkIDByGuildID(0,1)&&!marks.AddMarkIDByGuildID(2,6400));
file("1 0\n65535 6399\n");assert(marks.LoadMarkIndex()&&marks.GetMarkCount()==2&&marks.imageLoads==1);
std::array<char,12> bytes;bytes.fill('Z');assert(!marks.CopyMarkIdx(bytes.data()+1,7));for(char c:bytes)assert(c=='Z');
assert(marks.CopyMarkIdx(bytes.data()+1,8));assert(bytes[0]=='Z'&&bytes[9]=='Z');WORD pair[4];memcpy(pair,bytes.data()+1,8);assert(pair[0]==1&&pair[1]==0&&pair[2]==65535&&pair[3]==6399);
for(const char* bad:{"1 0\n1 1\n","1 0\n2 0\n","65536 1\n","-1 1\n","1 6400\n","1 nope\n","1 2 junk\n"}){
file(bad);auto map=marks.m_mapGID_MarkID;auto free=marks.m_setFreeMarkID;assert(!marks.LoadMarkIndex());assert(marks.m_mapGID_MarkID==map&&marks.m_setFreeMarkID==free&&marks.imageLoads==1);
}
file(std::string("1 0\0junk\n",9));assert(!marks.LoadMarkIndex()&&marks.GetMarkCount()==2&&marks.imageLoads==1);
file("2 1\n");assert(marks.LoadMarkIndex()&&marks.GetMarkCount()==1&&!marks.m_mapGID_MarkID.count(1));
file("");assert(marks.LoadMarkIndex()&&marks.GetMarkCount()==0&&marks.m_setFreeMarkID.size()==6400&&marks.CopyMarkIdx(nullptr,0));
}
''')
def test_boot_table_counts_and_total_match_encoded_stream(self):
text=(ROOT/'src/server/db/src/ClientManager.cpp').read_text(encoding='latin1');actual=function(text,'void CClientManager::QUERY_BOOT')+function(text,'void CClientManager::ReloadAdmin(')
self.native(r'''
#include <cassert>
#include <cstdint>
#include <cstring>
#include <ctime>
#include <map>
#include <string>
#include <vector>
using BYTE=uint8_t;using WORD=uint16_t;using DWORD=uint32_t;using LONG=int32_t;using INT=int32_t;
#include "src/server/common/tables.h"
#include "src/server/common/building.h"
#include "src/server/common/wire_bounds.h"
#define sys_log(...) ((void)0)
#define sys_err(...) ((void)0)
#define itertype(v) decltype((v).begin())
bool g_test_server=false;
struct CPeer {
std::vector<char> bytes;DWORD announced=0;int headers=0;
void EncodeHeader(int,int,DWORD size){announced=size;++headers;}
void Encode(const void* p,size_t n){if(!n)return;assert(p);const char* b=static_cast<const char*>(p);bytes.insert(bytes.end(),b,b+n);}
void EncodeWORD(WORD value){Encode(&value,2);}int GetChannel(){return 1;}
void SetItemIDRange(TItemIDRangeTable){}void SetSpareItemIDRange(TItemIDRangeTable){}
};
struct CMonarch {
using VEC_MONARCHCANDIDACY=std::vector<MonarchCandidacy>;VEC_MONARCHCANDIDACY candidates;TMonarchInfo info={};
static CMonarch& instance(){static CMonarch m;return m;}size_t MonarchCandidacySize(){return candidates.size();}VEC_MONARCHCANDIDACY& GetVecMonarchCandidacy(){return candidates;}TMonarchInfo* GetMonarch(){return &info;}
};
struct CItemIDRangeManager {static CItemIDRangeManager& instance(){static CItemIDRangeManager m;return m;}TItemIDRangeTable GetRange(){return {};}};
struct CClientManager {
std::vector<TMobTable> m_vec_mobTable;std::vector<TItemTable> m_vec_itemTable;std::vector<TSkillTable> m_vec_skillTable;
int m_iShopTableSize=0,m_iRefineTableSize=0;TShopTable* m_pShopTable=nullptr;TRefineTable* m_pRefineTable=nullptr;
std::vector<TItemAttrTable> m_vec_itemAttrTable,m_vec_itemRareTable;std::vector<TBanwordTable> m_vec_banwordTable;
std::vector<building::TLand> m_vec_kLandTable;std::vector<building::TObjectProto> m_vec_kObjectProto;std::map<DWORD,building::TObject*> m_map_pkObjectTable;
std::vector<CPeer*> m_peerList;
std::map<DWORD,TOfflineShop*> m_Offlineshop;std::vector<std::string> hosts;std::vector<tAdminInfo> admins;bool queryOK=true;
bool __GetHostInfo(std::vector<std::string>& out){out=hosts;return queryOK;}bool __GetAdminInfo(const char*,std::vector<tAdminInfo>& out){out=admins;return queryOK;}
void QUERY_BOOT(CPeer*,TPacketGDBoot*);void ReloadAdmin(CPeer*,TPacketReloadAdmin*);
};
'''+actual+r'''
int main(){
PortBootSizer huge(0);assert(!huge.Add(UINT16_MAX,UINT16_MAX)&&!huge.Valid()&&!huge.Bytes());
PortBootSizer invalid(UINT64_MAX);assert(!invalid.Add(0,0)&&!invalid.Bytes());
CClientManager manager;TPacketGDBoot request={};CPeer peer;manager.QUERY_BOOT(&peer,&request);assert(peer.headers==1&&peer.announced==peer.bytes.size());
manager.hosts={"1.2.3.4"};manager.m_vec_banwordTable.resize(2);CPeer normal;manager.QUERY_BOOT(&normal,&request);assert(normal.headers==1&&normal.announced==normal.bytes.size());
DWORD declared=0;memcpy(&declared,normal.bytes.data(),4);assert(declared==normal.bytes.size()&&normal.bytes[4]==6);
manager.m_vec_banwordTable.resize(65536);CPeer overflow;manager.QUERY_BOOT(&overflow,&request);assert(!overflow.headers&&overflow.bytes.empty());manager.m_vec_banwordTable.clear();
manager.m_iShopTableSize=-1;manager.QUERY_BOOT(&overflow,&request);assert(!overflow.headers);manager.m_iShopTableSize=1;manager.QUERY_BOOT(&overflow,&request);assert(!overflow.headers);manager.m_iShopTableSize=0;
CPeer adminPeer;manager.m_peerList={&adminPeer};TPacketReloadAdmin adminRequest={};manager.ReloadAdmin(nullptr,&adminRequest);assert(adminPeer.headers==1&&adminPeer.announced==adminPeer.bytes.size());
adminPeer={};manager.admins.resize(65536);manager.ReloadAdmin(nullptr,&adminRequest);assert(!adminPeer.headers&&adminPeer.bytes.empty());manager.admins.clear();
manager.hosts={std::string(16,'x')};manager.QUERY_BOOT(&overflow,&request);assert(!overflow.headers);manager.hosts.clear();manager.queryOK=false;manager.QUERY_BOOT(&overflow,&request);assert(!overflow.headers);
}
''')
if __name__=='__main__':unittest.main()