Added profiling to a lot of /common, though not all some misc or small functions were purposely skipped

common/CMakeLists.txt

@@ -39,7 +39,6 @@ SET(common_sources
 	mutex.cpp
 	mysql_request_result.cpp
 	mysql_request_row.cpp
-	opcode_map.cpp
 	opcodemgr.cpp
 	packet_dump.cpp
 	packet_dump_file.cpp
@@ -49,7 +48,6 @@ SET(common_sources
 	proc_launcher.cpp
 	ptimer.cpp
 	races.cpp
-	rdtsc.cpp
 	rulesys.cpp
 	serverinfo.cpp
 	shareddb.cpp
@@ -163,7 +161,6 @@ SET(common_headers
 	queue.h
 	races.h
 	random.h
-	rdtsc.h
 	rulesys.h
 	ruletypes.h
 	seperator.h

common/eq_stream_factory.cpp

@@ -23,6 +23,7 @@
 
 ThreadReturnType EQStreamFactoryReaderLoop(void *eqfs)
 {
+	_eqp
 	EQStreamFactory *fs = (EQStreamFactory*)eqfs;
 
 #ifndef WIN32
@@ -40,6 +41,7 @@ ThreadReturnType EQStreamFactoryReaderLoop(void *eqfs)
 
 ThreadReturnType EQStreamFactoryWriterLoop(void *eqfs)
 {
+	_eqp
 	EQStreamFactory *fs = (EQStreamFactory*)eqfs;
 
 #ifndef WIN32
@@ -58,6 +60,7 @@ ThreadReturnType EQStreamFactoryWriterLoop(void *eqfs)
 EQStreamFactory::EQStreamFactory(EQStreamType type, int port, uint32 timeout)
 	: Timeoutable(5000), stream_timeout(timeout)
 {
+	_eqp
 	StreamType=type;
 	Port=port;
 	sock=-1;
@@ -65,6 +68,7 @@ EQStreamFactory::EQStreamFactory(EQStreamType type, int port, uint32 timeout)
 
 void EQStreamFactory::Close()
 {
+	_eqp
 	Stop();
 
 #ifdef _WINDOWS
@@ -77,6 +81,7 @@ void EQStreamFactory::Close()
 
 bool EQStreamFactory::Open()
 {
+	_eqp
 	struct sockaddr_in address;
 #ifndef WIN32
 	pthread_t t1,t2;
@@ -118,6 +123,7 @@ bool EQStreamFactory::Open()
 
 std::shared_ptr<EQStream> EQStreamFactory::Pop()
 {
+	_eqp
 	std::shared_ptr<EQStream> s = nullptr;
 	MNewStreams.lock();
 	if (NewStreams.size()) {
@@ -132,6 +138,7 @@ std::shared_ptr<EQStream> EQStreamFactory::Pop()
 
 void EQStreamFactory::Push(std::shared_ptr<EQStream> s)
 {
+	_eqp
 	MNewStreams.lock();
 	NewStreams.push(s);
 	MNewStreams.unlock();
@@ -139,6 +146,7 @@ void EQStreamFactory::Push(std::shared_ptr<EQStream> s)
 
 void EQStreamFactory::ReaderLoop()
 {
+	_eqp
 	fd_set readset;
 	std::map<std::pair<uint32, uint16>, std::shared_ptr<EQStream>>::iterator stream_itr;
 	int num;
@@ -216,6 +224,7 @@ void EQStreamFactory::ReaderLoop()
 
 void EQStreamFactory::CheckTimeout()
 {
+	_eqp
 	//lock streams the entire time were checking timeouts, it should be fast.
 	MStreams.lock();
 
@@ -250,6 +259,7 @@ void EQStreamFactory::CheckTimeout()
 
 void EQStreamFactory::WriterLoop()
 {
+	_eqp
 	std::map<std::pair<uint32, uint16>, std::shared_ptr<EQStream>>::iterator stream_itr;
 	bool havework=true;
 	std::vector<std::shared_ptr<EQStream>> wants_write;

common/eq_stream_ident.cpp

@@ -5,6 +5,7 @@
 
 
 EQStreamIdentifier::~EQStreamIdentifier() {
+	_eqp
 	while(!m_identified.empty()) {
 		m_identified.front()->ReleaseFromUse();
 		m_identified.pop();
@@ -25,6 +26,7 @@ EQStreamIdentifier::~EQStreamIdentifier() {
 }
 
 void EQStreamIdentifier::RegisterPatch(const EQStream::Signature &sig, const char *name, OpcodeManager ** opcodes, const StructStrategy *structs) {
+	_eqp
 	Patch *p = new Patch;
 	p->signature = sig;
 	p->name = name;
@@ -34,6 +36,7 @@ void EQStreamIdentifier::RegisterPatch(const EQStream::Signature &sig, const cha
 }
 
 void EQStreamIdentifier::Process() {
+	_eqp
 	std::vector<Record>::iterator cur;
 	std::vector<Patch *>::iterator curp, endp;
 
@@ -143,11 +146,13 @@ void EQStreamIdentifier::Process() {
 }
 
 void EQStreamIdentifier::AddStream(std::shared_ptr<EQStream> &eqs) {
+	_eqp
 	m_streams.push_back(Record(eqs));
 	eqs = nullptr;
 }
 
 EQStreamInterface *EQStreamIdentifier::PopIdentified() {
+	_eqp
 	if(m_identified.empty())
 		return(nullptr);
 	EQStreamInterface *res = m_identified.front();
@@ -159,5 +164,6 @@ EQStreamIdentifier::Record::Record(std::shared_ptr<EQStream> s)
 :	stream(s),
 	expire(STREAM_IDENT_WAIT_MS)
 {
+	_eqp
 }
 

common/eq_stream_proxy.cpp

@@ -10,23 +10,28 @@ EQStreamProxy::EQStreamProxy(std::shared_ptr<EQStream> &stream, const StructStra
 	m_structs(structs),
 	m_opcodes(opcodes)
 {
+	_eqp
 	stream = nullptr;	//take the stream.
 	m_stream->SetOpcodeManager(m_opcodes);
 }
 
 EQStreamProxy::~EQStreamProxy() {
+	_eqp
 }
 
 std::string EQStreamProxy::Describe() const {
+	_eqp
 	return(m_structs->Describe());
 }
 
 const ClientVersion EQStreamProxy::GetClientVersion() const
 {
+	_eqp
 	return m_structs->GetClientVersion();
 }
 
 void EQStreamProxy::QueuePacket(const EQApplicationPacket *p, bool ack_req) {
+	_eqp
 	if(p == nullptr)
 		return;
 
@@ -35,12 +40,14 @@ void EQStreamProxy::QueuePacket(const EQApplicationPacket *p, bool ack_req) {
 }
 
 void EQStreamProxy::FastQueuePacket(EQApplicationPacket **p, bool ack_req) {
+	_eqp
 	if(p == nullptr || *p == nullptr)
 		return;
 	m_structs->Encode(p, m_stream, ack_req);
 }
 
 EQApplicationPacket *EQStreamProxy::PopPacket() {
+	_eqp
 	EQApplicationPacket *pack = m_stream->PopPacket();
 	if(pack == nullptr)
 		return(nullptr);
@@ -51,46 +58,56 @@ EQApplicationPacket *EQStreamProxy::PopPacket() {
 }
 
 void EQStreamProxy::Close() {
+	_eqp
 	m_stream->Close();
 }
 
 uint32 EQStreamProxy::GetRemoteIP() const {
+	_eqp
 	return(m_stream->GetRemoteIP());
 }
 
 uint16 EQStreamProxy::GetRemotePort() const {
+	_eqp
 	return(m_stream->GetRemotePort());
 }
 
 const uint32 EQStreamProxy::GetBytesSent() const
 {
+	_eqp
 	return(m_stream->GetBytesSent());
 }
 
 const uint32 EQStreamProxy::GetBytesRecieved() const
 {
+	_eqp
 	return(m_stream->GetBytesRecieved());
 }
 
 const uint32 EQStreamProxy::GetBytesSentPerSecond() const
 {
+	_eqp
 	return(m_stream->GetBytesSentPerSecond());
 }
 
 const uint32 EQStreamProxy::GetBytesRecvPerSecond() const
 {
+	_eqp
 	return(m_stream->GetBytesRecvPerSecond());
 }
 
 void EQStreamProxy::ReleaseFromUse() {
+	_eqp
 	m_stream->ReleaseFromUse();
 }
 
 void EQStreamProxy::RemoveData() {
+	_eqp
 	m_stream->RemoveData();
 }
 
 bool EQStreamProxy::CheckState(EQStreamState state) {
+	_eqp
 	if(m_stream)
 		return(m_stream->CheckState(state));
 

common/eqemu_config.cpp

@@ -28,6 +28,7 @@ EQEmuConfig *EQEmuConfig::_config = nullptr;
 
 void EQEmuConfig::do_world(TiXmlElement *ele)
 {
+	_eqp
 	const char *text;
 	TiXmlElement * sub_ele;;
 	text = ParseTextBlock(ele, "shortname");
@@ -145,6 +146,7 @@ void EQEmuConfig::do_world(TiXmlElement *ele)
 
 void EQEmuConfig::do_chatserver(TiXmlElement *ele)
 {
+	_eqp
 	const char *text;
 	text = ParseTextBlock(ele, "host", true);
 	if (text) {
@@ -158,6 +160,7 @@ void EQEmuConfig::do_chatserver(TiXmlElement *ele)
 
 void EQEmuConfig::do_mailserver(TiXmlElement *ele)
 {
+	_eqp
 	const char *text;
 	text = ParseTextBlock(ele, "host", true);
 	if (text) {
@@ -171,6 +174,7 @@ void EQEmuConfig::do_mailserver(TiXmlElement *ele)
 
 void EQEmuConfig::do_database(TiXmlElement *ele)
 {
+	_eqp
 	const char *text;
 	text = ParseTextBlock(ele, "host", true);
 	if (text) {
@@ -197,6 +201,7 @@ void EQEmuConfig::do_database(TiXmlElement *ele)
 
 void EQEmuConfig::do_qsdatabase(TiXmlElement *ele)
 {
+	_eqp
 	const char *text;
 	text = ParseTextBlock(ele, "host", true);
 	if (text) {
@@ -222,6 +227,7 @@ void EQEmuConfig::do_qsdatabase(TiXmlElement *ele)
 
 void EQEmuConfig::do_zones(TiXmlElement *ele)
 {
+	_eqp
 	const char *text;
 	TiXmlElement *sub_ele;
 //	TiXmlNode *node,*sub_node;
@@ -245,6 +251,7 @@ void EQEmuConfig::do_zones(TiXmlElement *ele)
 
 void EQEmuConfig::do_files(TiXmlElement *ele)
 {
+	_eqp
 	const char *text;
 	text = ParseTextBlock(ele, "spells", true);
 	if (text) {
@@ -262,6 +269,7 @@ void EQEmuConfig::do_files(TiXmlElement *ele)
 
 void EQEmuConfig::do_directories(TiXmlElement *ele)
 {
+	_eqp
 	const char *text;
 	text = ParseTextBlock(ele, "maps", true);
 	if (text) {
@@ -279,6 +287,7 @@ void EQEmuConfig::do_directories(TiXmlElement *ele)
 
 void EQEmuConfig::do_launcher(TiXmlElement *ele)
 {
+	_eqp
 	const char *text;
 	TiXmlElement *sub_ele;
 	text = ParseTextBlock(ele, "logprefix", true);
@@ -318,6 +327,7 @@ void EQEmuConfig::do_launcher(TiXmlElement *ele)
 
 std::string EQEmuConfig::GetByName(const std::string &var_name) const
 {
+	_eqp
 	if (var_name == "ShortName") {
 		return (ShortName);
 	}
@@ -445,6 +455,7 @@ std::string EQEmuConfig::GetByName(const std::string &var_name) const
 
 void EQEmuConfig::Dump() const
 {
+	_eqp
 	std::cout << "ShortName = " << ShortName << std::endl;
 	std::cout << "LongName = " << LongName << std::endl;
 	std::cout << "WorldAddress = " << WorldAddress << std::endl;

common/eqemu_logsys.cpp

@@ -273,12 +273,14 @@ void EQEmuLogSys::ProcessConsoleMessage(uint16 debug_level, uint16 log_category,
 
 void EQEmuLogSys::Out(Logs::DebugLevel debug_level, uint16 log_category, std::string message, ...)
 {
+	_eqp
 	const bool log_to_console = log_settings[log_category].log_to_console > 0;
 	const bool log_to_file = log_settings[log_category].log_to_file > 0;
 	const bool log_to_gmsay = log_settings[log_category].log_to_gmsay > 0;
 	const bool nothing_to_log = !log_to_console && !log_to_file && !log_to_gmsay;
 
-	if (nothing_to_log) return;
+	if (nothing_to_log) 
+		return;
 
 	va_list args;
 	va_start(args, message);

common/extprofile.cpp

@@ -26,6 +26,7 @@ void InitExtendedProfile(ExtendedProfile_Struct *p) {
 }
 
 bool SetExtendedProfile(ExtendedProfile_Struct *to, char *old, unsigned int len) {
+	_eqp
 	if(len == 0 || old == nullptr) {
 		//handle old chars without an extended profile...
 		InitExtendedProfile(to);

common/faction.cpp

@@ -21,6 +21,7 @@
 
 const char *FactionValueToString(FACTION_VALUE fv)
 {
+	_eqp
 	switch (fv) {
 		case FACTION_ALLY:
 			return ("Ally");
@@ -55,6 +56,7 @@ const char *FactionValueToString(FACTION_VALUE fv)
 //o--------------------------------------------------------------
 FACTION_VALUE CalculateFaction(FactionMods* fm, int32 tmpCharacter_value)
 {
+	_eqp
 	int32 character_value = tmpCharacter_value;
 	if (fm) {
 		character_value += fm->base + fm->class_mod + fm->race_mod + fm->deity_mod;
@@ -92,6 +94,7 @@ FACTION_VALUE CalculateFaction(FactionMods* fm, int32 tmpCharacter_value)
 // this function should check if some races have more than one race define
 bool IsOfEqualRace(int r1, int r2)
 {
+	_eqp
 	if (r1 == r2) {
 		return true;
 	}
@@ -113,6 +116,7 @@ bool IsOfEqualRace(int r1, int r2)
 // trolls endure ogres, dark elves, ...
 bool IsOfIndiffRace(int r1, int r2)
 {
+	_eqp
 	if (r1 == r2) {
 		return true;
 	}

common/guild_base.cpp

@@ -39,10 +39,8 @@ BaseGuildManager::~BaseGuildManager() {
 	ClearGuilds();
 }
 
-
-
 bool BaseGuildManager::LoadGuilds() {
-
+	_eqp
 	ClearGuilds();
 
 	if(m_db == nullptr) {
@@ -104,6 +102,7 @@ bool BaseGuildManager::LoadGuilds() {
 }
 
 bool BaseGuildManager::RefreshGuild(uint32 guild_id) {
+	_eqp
 	if(m_db == nullptr) {
 		Log.Out(Logs::Detail, Logs::Guilds, "Requested to refresh guild %d when we have no database object.", guild_id);
 		return(false);
@@ -169,6 +168,7 @@ bool BaseGuildManager::RefreshGuild(uint32 guild_id) {
 
 BaseGuildManager::GuildInfo *BaseGuildManager::_CreateGuild(uint32 guild_id, const char *guild_name, uint32 leader_char_id, uint8 minstatus, const char *guild_motd, const char *motd_setter, const char *Channel, const char *URL)
 {
+	_eqp
 	std::map<uint32, GuildInfo *>::iterator res;
 
 	//remove any old entry.
@@ -213,6 +213,7 @@ BaseGuildManager::GuildInfo *BaseGuildManager::_CreateGuild(uint32 guild_id, con
 }
 
 bool BaseGuildManager::_StoreGuildDB(uint32 guild_id) {
+	_eqp
 	if(m_db == nullptr) {
 		Log.Out(Logs::Detail, Logs::Guilds, "Requested to store guild %d when we have no database object.", guild_id);
 		return(false);
@@ -295,6 +296,7 @@ bool BaseGuildManager::_StoreGuildDB(uint32 guild_id) {
 }
 
 uint32 BaseGuildManager::_GetFreeGuildID() {
+	_eqp
 	if(m_db == nullptr) {
 		Log.Out(Logs::Detail, Logs::Guilds, "Requested find a free guild ID when we have no database object.");
 		return(GUILD_NONE);
@@ -342,6 +344,7 @@ uint32 BaseGuildManager::_GetFreeGuildID() {
 
 
 uint32 BaseGuildManager::CreateGuild(const char* name, uint32 leader_char_id) {
+	_eqp
 	uint32 gid = DBCreateGuild(name, leader_char_id);
 	if(gid == GUILD_NONE)
 		return(GUILD_NONE);
@@ -353,6 +356,7 @@ uint32 BaseGuildManager::CreateGuild(const char* name, uint32 leader_char_id) {
 }
 
 bool BaseGuildManager::DeleteGuild(uint32 guild_id) {
+	_eqp
 	if(!DBDeleteGuild(guild_id))
 		return(false);
 
@@ -362,6 +366,7 @@ bool BaseGuildManager::DeleteGuild(uint32 guild_id) {
 }
 
 bool BaseGuildManager::RenameGuild(uint32 guild_id, const char* name) {
+	_eqp
 	if(!DBRenameGuild(guild_id, name))
 		return(false);
 
@@ -371,6 +376,7 @@ bool BaseGuildManager::RenameGuild(uint32 guild_id, const char* name) {
 }
 
 bool BaseGuildManager::SetGuildLeader(uint32 guild_id, uint32 leader_char_id) {
+	_eqp
 	//get old leader first.
 	std::map<uint32, GuildInfo *>::const_iterator res;
 	res = m_guilds.find(guild_id);
@@ -390,6 +396,7 @@ bool BaseGuildManager::SetGuildLeader(uint32 guild_id, uint32 leader_char_id) {
 }
 
 bool BaseGuildManager::SetGuildMOTD(uint32 guild_id, const char* motd, const char *setter) {
+	_eqp
 	if(!DBSetGuildMOTD(guild_id, motd, setter))
 		return(false);
 
@@ -400,6 +407,7 @@ bool BaseGuildManager::SetGuildMOTD(uint32 guild_id, const char* motd, const cha
 
 bool BaseGuildManager::SetGuildURL(uint32 GuildID, const char* URL)
 {
+	_eqp
 	if(!DBSetGuildURL(GuildID, URL))
 		return(false);
 
@@ -410,6 +418,7 @@ bool BaseGuildManager::SetGuildURL(uint32 GuildID, const char* URL)
 
 bool BaseGuildManager::SetGuildChannel(uint32 GuildID, const char* Channel)
 {
+	_eqp
 	if(!DBSetGuildChannel(GuildID, Channel))
 		return(false);
 
@@ -419,6 +428,7 @@ bool BaseGuildManager::SetGuildChannel(uint32 GuildID, const char* Channel)
 }
 
 bool BaseGuildManager::SetGuild(uint32 charid, uint32 guild_id, uint8 rank) {
+	_eqp
 	if(rank > GUILD_MAX_RANK && guild_id != GUILD_NONE)
 		return(false);
 
@@ -439,6 +449,7 @@ bool BaseGuildManager::SetGuild(uint32 charid, uint32 guild_id, uint8 rank) {
 
 //changes rank, but not guild.
 bool BaseGuildManager::SetGuildRank(uint32 charid, uint8 rank) {
+	_eqp
 	if(rank > GUILD_MAX_RANK)
 		return(false);
 
@@ -452,6 +463,7 @@ bool BaseGuildManager::SetGuildRank(uint32 charid, uint8 rank) {
 
 
 bool BaseGuildManager::SetBankerFlag(uint32 charid, bool is_banker) {
+	_eqp
 	if(!DBSetBankerFlag(charid, is_banker))
 		return(false);
 
@@ -461,12 +473,14 @@ bool BaseGuildManager::SetBankerFlag(uint32 charid, bool is_banker) {
 }
 
 bool BaseGuildManager::ForceRankUpdate(uint32 charid) {
+	_eqp
 	SendRankUpdate(charid);
 	return(true);
 }
 
 bool BaseGuildManager::SetAltFlag(uint32 charid, bool is_alt)
 {
+	_eqp
 	if(!DBSetAltFlag(charid, is_alt))
 		return(false);
 
@@ -476,6 +490,7 @@ bool BaseGuildManager::SetAltFlag(uint32 charid, bool is_alt)
 }
 
 bool BaseGuildManager::SetTributeFlag(uint32 charid, bool enabled) {
+	_eqp
 	if(!DBSetTributeFlag(charid, enabled))
 		return(false);
 
@@ -485,6 +500,7 @@ bool BaseGuildManager::SetTributeFlag(uint32 charid, bool enabled) {
 }
 
 bool BaseGuildManager::SetPublicNote(uint32 charid, const char *note) {
+	_eqp
 	if(!DBSetPublicNote(charid, note))
 		return(false);
 
@@ -494,6 +510,7 @@ bool BaseGuildManager::SetPublicNote(uint32 charid, const char *note) {
 }
 
 uint32 BaseGuildManager::DBCreateGuild(const char* name, uint32 leader) {
+	_eqp
 	//first try to find a free ID.
 	uint32 new_id = _GetFreeGuildID();
 	if(new_id == GUILD_NONE)
@@ -515,6 +532,7 @@ uint32 BaseGuildManager::DBCreateGuild(const char* name, uint32 leader) {
 }
 
 bool BaseGuildManager::DBDeleteGuild(uint32 guild_id) {
+	_eqp
 
 	//remove the local entry
 	std::map<uint32, GuildInfo *>::iterator res;
@@ -551,6 +569,7 @@ bool BaseGuildManager::DBDeleteGuild(uint32 guild_id) {
 }
 
 bool BaseGuildManager::DBRenameGuild(uint32 guild_id, const char* name) {
+	_eqp
 	if(m_db == nullptr) {
 		Log.Out(Logs::Detail, Logs::Guilds, "Requested to rename guild %d when we have no database object.", guild_id);
 		return false;
@@ -587,6 +606,7 @@ bool BaseGuildManager::DBRenameGuild(uint32 guild_id, const char* name) {
 }
 
 bool BaseGuildManager::DBSetGuildLeader(uint32 guild_id, uint32 leader) {
+	_eqp
 	if(m_db == nullptr) {
 		Log.Out(Logs::Detail, Logs::Guilds, "Requested to set the leader for guild %d when we have no database object.", guild_id);
 		return false;
@@ -622,6 +642,7 @@ bool BaseGuildManager::DBSetGuildLeader(uint32 guild_id, uint32 leader) {
 }
 
 bool BaseGuildManager::DBSetGuildMOTD(uint32 guild_id, const char* motd, const char *setter) {
+	_eqp
 	if(m_db == nullptr) {
 		Log.Out(Logs::Detail, Logs::Guilds, "Requested to set the MOTD for guild %d when we have no database object.", guild_id);
 		return(false);
@@ -664,6 +685,7 @@ bool BaseGuildManager::DBSetGuildMOTD(uint32 guild_id, const char* motd, const c
 
 bool BaseGuildManager::DBSetGuildURL(uint32 GuildID, const char* URL)
 {
+	_eqp
 	if(m_db == nullptr)
 		return false;
 
@@ -697,6 +719,7 @@ bool BaseGuildManager::DBSetGuildURL(uint32 GuildID, const char* URL)
 
 bool BaseGuildManager::DBSetGuildChannel(uint32 GuildID, const char* Channel)
 {
+	_eqp
 	if(m_db == nullptr)
 		return(false);
 
@@ -730,6 +753,7 @@ bool BaseGuildManager::DBSetGuildChannel(uint32 GuildID, const char* Channel)
 }
 
 bool BaseGuildManager::DBSetGuild(uint32 charid, uint32 guild_id, uint8 rank) {
+	_eqp
 	if(m_db == nullptr) {
 		Log.Out(Logs::Detail, Logs::Guilds, "Requested to set char to guild %d when we have no database object.", guild_id);
 		return(false);
@@ -758,11 +782,13 @@ bool BaseGuildManager::DBSetGuild(uint32 charid, uint32 guild_id, uint8 rank) {
 }
 
 bool BaseGuildManager::DBSetGuildRank(uint32 charid, uint8 rank) {
+	_eqp
 	std::string query = StringFormat("UPDATE guild_members SET rank=%d WHERE char_id=%d", rank, charid);
 	return(QueryWithLogging(query, "setting a guild member's rank"));
 }
 
 bool BaseGuildManager::DBSetBankerFlag(uint32 charid, bool is_banker) {
+	_eqp
 	std::string query = StringFormat("UPDATE guild_members SET banker=%d WHERE char_id=%d",
 		is_banker? 1: 0, charid);
 	return(QueryWithLogging(query, "setting a guild member's banker flag"));
@@ -770,6 +796,7 @@ bool BaseGuildManager::DBSetBankerFlag(uint32 charid, bool is_banker) {
 
 bool BaseGuildManager::GetBankerFlag(uint32 CharID)
 {
+	_eqp
 	if(!m_db)
 		return false;
 
@@ -792,6 +819,7 @@ bool BaseGuildManager::GetBankerFlag(uint32 CharID)
 
 bool BaseGuildManager::DBSetAltFlag(uint32 charid, bool is_alt)
 {
+	_eqp
 	std::string query = StringFormat("UPDATE guild_members SET alt=%d WHERE char_id=%d",
 		is_alt ? 1: 0, charid);
 
@@ -800,6 +828,7 @@ bool BaseGuildManager::DBSetAltFlag(uint32 charid, bool is_alt)
 
 bool BaseGuildManager::GetAltFlag(uint32 CharID)
 {
+	_eqp
     if(!m_db)
 		return false;
 
@@ -821,12 +850,14 @@ bool BaseGuildManager::GetAltFlag(uint32 CharID)
 }
 
 bool BaseGuildManager::DBSetTributeFlag(uint32 charid, bool enabled) {
+	_eqp
 	std::string query = StringFormat("UPDATE guild_members SET tribute_enable=%d WHERE char_id=%d",
 		enabled ? 1: 0, charid);
 	return(QueryWithLogging(query, "setting a guild member's tribute flag"));
 }
 
 bool BaseGuildManager::DBSetPublicNote(uint32 charid, const char* note) {
+	_eqp
 	if(m_db == nullptr)
 		return(false);
 
@@ -851,6 +882,7 @@ bool BaseGuildManager::DBSetPublicNote(uint32 charid, const char* note) {
 }
 
 bool BaseGuildManager::QueryWithLogging(std::string query, const char *errmsg) {
+	_eqp
 	if(m_db == nullptr)
 		return(false);
 
@@ -879,6 +911,7 @@ bool BaseGuildManager::QueryWithLogging(std::string query, const char *errmsg) {
 " FROM `character_data` AS c LEFT JOIN guild_members AS g ON c.id=g.char_id "
 #endif
 static void ProcessGuildMember(MySQLRequestRow row, CharGuildInfo &into) {
+	_eqp
 	//fields from `characer_`
 	into.char_id		= atoi(row[0]);
 	into.char_name		= row[1];
@@ -906,6 +939,7 @@ static void ProcessGuildMember(MySQLRequestRow row, CharGuildInfo &into) {
 
 
 bool BaseGuildManager::GetEntireGuild(uint32 guild_id, std::vector<CharGuildInfo *> &members) {
+	_eqp
 	members.clear();
 
 	if(m_db == nullptr)
@@ -930,6 +964,7 @@ bool BaseGuildManager::GetEntireGuild(uint32 guild_id, std::vector<CharGuildInfo
 }
 
 bool BaseGuildManager::GetCharInfo(const char *char_name, CharGuildInfo &into) {
+	_eqp
 	if(m_db == nullptr) {
 		Log.Out(Logs::Detail, Logs::Guilds, "Requested char info on %s when we have no database object.", char_name);
 		return(false);
@@ -961,6 +996,7 @@ bool BaseGuildManager::GetCharInfo(const char *char_name, CharGuildInfo &into) {
 }
 
 bool BaseGuildManager::GetCharInfo(uint32 char_id, CharGuildInfo &into) {
+	_eqp
 	if(m_db == nullptr) {
 		Log.Out(Logs::Detail, Logs::Guilds, "Requested char info on %d when we have no database object.", char_id);
 		return false;
@@ -991,6 +1027,7 @@ bool BaseGuildManager::GetCharInfo(uint32 char_id, CharGuildInfo &into) {
 
 //returns ownership of the buffer.
 uint8 *BaseGuildManager::MakeGuildList(const char *head_name, uint32 &length) const {
+	_eqp
 	//dynamic structs will make this a lot less painful.
 
 	length = sizeof(GuildsList_Struct);
@@ -1018,6 +1055,7 @@ uint8 *BaseGuildManager::MakeGuildList(const char *head_name, uint32 &length) co
 }
 
 const char *BaseGuildManager::GetRankName(uint32 guild_id, uint8 rank) const {
+	_eqp
 	if(rank > GUILD_MAX_RANK)
 		return("Invalid Rank");
 	std::map<uint32, GuildInfo *>::const_iterator res;
@@ -1028,6 +1066,7 @@ const char *BaseGuildManager::GetRankName(uint32 guild_id, uint8 rank) const {
 }
 
 const char *BaseGuildManager::GetGuildName(uint32 guild_id) const {
+	_eqp
 	if(guild_id == GUILD_NONE)
 		return("");
 	std::map<uint32, GuildInfo *>::const_iterator res;
@@ -1038,6 +1077,7 @@ const char *BaseGuildManager::GetGuildName(uint32 guild_id) const {
 }
 
 bool BaseGuildManager::GetGuildNameByID(uint32 guild_id, std::string &into) const {
+	_eqp
 	std::map<uint32, GuildInfo *>::const_iterator res;
 	res = m_guilds.find(guild_id);
 	if(res == m_guilds.end())
@@ -1048,6 +1088,7 @@ bool BaseGuildManager::GetGuildNameByID(uint32 guild_id, std::string &into) cons
 
 uint32 BaseGuildManager::GetGuildIDByName(const char *GuildName)
 {
+	_eqp
 	std::map<uint32, GuildInfo *>::iterator Iterator;
 
 	for(Iterator = m_guilds.begin(); Iterator != m_guilds.end(); ++Iterator)
@@ -1060,6 +1101,7 @@ uint32 BaseGuildManager::GetGuildIDByName(const char *GuildName)
 }
 
 bool BaseGuildManager::GetGuildMOTD(uint32 guild_id, char *motd_buffer, char *setter_buffer) const {
+	_eqp
 	std::map<uint32, GuildInfo *>::const_iterator res;
 	res = m_guilds.find(guild_id);
 	if(res == m_guilds.end())
@@ -1071,6 +1113,7 @@ bool BaseGuildManager::GetGuildMOTD(uint32 guild_id, char *motd_buffer, char *se
 
 bool BaseGuildManager::GetGuildURL(uint32 GuildID, char *URLBuffer) const
 {
+	_eqp
 	std::map<uint32, GuildInfo *>::const_iterator res;
 	res = m_guilds.find(GuildID);
 	if(res == m_guilds.end())
@@ -1082,6 +1125,7 @@ bool BaseGuildManager::GetGuildURL(uint32 GuildID, char *URLBuffer) const
 
 bool BaseGuildManager::GetGuildChannel(uint32 GuildID, char *ChannelBuffer) const
 {
+	_eqp
 	std::map<uint32, GuildInfo *>::const_iterator res;
 	res = m_guilds.find(GuildID);
 	if(res == m_guilds.end())
@@ -1091,12 +1135,14 @@ bool BaseGuildManager::GetGuildChannel(uint32 GuildID, char *ChannelBuffer) cons
 }
 
 bool BaseGuildManager::GuildExists(uint32 guild_id) const {
+	_eqp
 	if(guild_id == GUILD_NONE)
 		return(false);
 	return(m_guilds.find(guild_id) != m_guilds.end());
 }
 
 bool BaseGuildManager::IsGuildLeader(uint32 guild_id, uint32 char_id) const {
+	_eqp
 	if(guild_id == GUILD_NONE) {
 		Log.Out(Logs::Detail, Logs::Guilds, "Check leader for char %d: not a guild.", char_id);
 		return(false);
@@ -1112,6 +1158,7 @@ bool BaseGuildManager::IsGuildLeader(uint32 guild_id, uint32 char_id) const {
 }
 
 uint32 BaseGuildManager::FindGuildByLeader(uint32 leader) const {
+	_eqp
 	std::map<uint32, GuildInfo *>::const_iterator cur, end;
 	cur = m_guilds.begin();
 	end = m_guilds.end();
@@ -1124,6 +1171,7 @@ uint32 BaseGuildManager::FindGuildByLeader(uint32 leader) const {
 
 //returns the rank to be sent to the client for display purposes, given their eqemu rank.
 uint8 BaseGuildManager::GetDisplayedRank(uint32 guild_id, uint8 rank, uint32 char_id) const {
+	_eqp
 	std::map<uint32, GuildInfo *>::const_iterator res;
 	res = m_guilds.find(guild_id);
 	if(res == m_guilds.end())
@@ -1136,6 +1184,7 @@ uint8 BaseGuildManager::GetDisplayedRank(uint32 guild_id, uint8 rank, uint32 cha
 }
 
 bool BaseGuildManager::CheckGMStatus(uint32 guild_id, uint8 status) const {
+	_eqp
 	if(status >= 250) {
 		Log.Out(Logs::Detail, Logs::Guilds, "Check permission on guild %d with user status %d > 250, granted.", guild_id, status);
 		return(true);	//250+ as allowed anything
@@ -1157,6 +1206,7 @@ bool BaseGuildManager::CheckGMStatus(uint32 guild_id, uint8 status) const {
 }
 
 bool BaseGuildManager::CheckPermission(uint32 guild_id, uint8 rank, GuildAction act) const {
+	_eqp
 	if(rank > GUILD_MAX_RANK) {
 		Log.Out(Logs::Detail, Logs::Guilds, "Check permission on guild %d and rank %d for action %s (%d): Invalid rank, denied.",
 			guild_id, rank, GuildActionNames[act], act);
@@ -1182,6 +1232,7 @@ bool BaseGuildManager::CheckPermission(uint32 guild_id, uint8 rank, GuildAction
 }
 
 bool BaseGuildManager::LocalDeleteGuild(uint32 guild_id) {
+	_eqp
 	std::map<uint32, GuildInfo *>::iterator res;
 	res = m_guilds.find(guild_id);
 	if(res == m_guilds.end())
@@ -1201,18 +1252,21 @@ void BaseGuildManager::ClearGuilds() {
 }
 
 BaseGuildManager::RankInfo::RankInfo() {
+	_eqp
 	uint8 r;
 	for(r = 0; r < _MaxGuildAction; r++)
 		permissions[r] = false;
 }
 
 BaseGuildManager::GuildInfo::GuildInfo() {
+	_eqp
 	leader_char_id = 0;
 	minstatus = 0;
 }
 
 uint32 BaseGuildManager::DoesAccountContainAGuildLeader(uint32 AccountID)
 {
+	_eqp
 	std::string query = StringFormat("SELECT guild_id FROM guild_members WHERE char_id IN "
 		"(SELECT id FROM `character_data` WHERE account_id = %i) AND rank = 2",
                                     AccountID);

common/misc.cpp

@@ -24,36 +24,6 @@
 
 std::map<int,std::string> DBFieldNames;
 
-#ifndef WIN32
-#if defined(FREEBSD) || defined(__CYGWIN__)
-int print_stacktrace()
-{
-	printf("Insert stack trace here...\n");
-	return(0);
-}
-#else //!WIN32 && !FREEBSD == linux
-#include <execinfo.h>
-int print_stacktrace()
-{
-	void *ba[20];
-	int n = backtrace (ba, 20);
-	if (n != 0)
-	{
-		char **names = backtrace_symbols (ba, n);
-		if (names != nullptr)
-		{
-			int i;
-			std::cerr << "called from " << (char*)names[0] << std::endl;
-			for (i = 1; i < n; ++i)
-				std::cerr << "            " << (char*)names[i] << std::endl;
-			free (names);
-		}
-	}
-	return(0);
-}
-#endif //!FREEBSD
-#endif //!WIN32
-
 void Unprotect(std::string &s, char what)
 {
 	if (s.length()) {

common/misc.h

@@ -24,10 +24,6 @@ void decode(char *in, char *out);
 void encode_chunk(char *in, int len, char *out);
 void decode_chunk(char *in, char *out);
 
-#ifndef WIN32
-int print_stacktrace();
-#endif
-
 void dump_message_column(unsigned char *buffer, unsigned long length, std::string leader="", FILE *to = stdout);
 std::string string_from_time(std::string pattern, time_t now=0);
 std::string timestamp(time_t now=0);

common/mysql_request_result.cpp

@@ -10,6 +10,7 @@ MySQLRequestResult::MySQLRequestResult()
 MySQLRequestResult::MySQLRequestResult(MYSQL_RES* result, uint32 rowsAffected, uint32 rowCount, uint32 columnCount, uint32 lastInsertedID, uint32 errorNumber, char *errorBuffer)
 	: m_CurrentRow(result), m_OneBeyondRow()
 {
+	_eqp
 	m_Result = result;
 	m_RowsAffected = rowsAffected;
 	m_RowCount = rowCount;
@@ -32,7 +33,7 @@ MySQLRequestResult::MySQLRequestResult(MYSQL_RES* result, uint32 rowsAffected, u
 
 void MySQLRequestResult::FreeInternals()
 {
-
+	_eqp
 	safe_delete_array(m_ErrorBuffer);
 
 	if (m_Result != nullptr)
@@ -43,6 +44,7 @@ void MySQLRequestResult::FreeInternals()
 
 void MySQLRequestResult::ZeroOut()
 {
+	_eqp
 	m_Success = false;
 	m_Result = nullptr;
 	m_ErrorBuffer = nullptr;
@@ -55,11 +57,13 @@ void MySQLRequestResult::ZeroOut()
 
 MySQLRequestResult::~MySQLRequestResult()
 {
+	_eqp
 	FreeInternals();
 }
 
 uint32 MySQLRequestResult::LengthOfColumn(int columnIndex)
 {
+	_eqp
 	if (m_ColumnLengths == nullptr && m_Result != nullptr)
 		m_ColumnLengths = mysql_fetch_lengths(m_Result);
 
@@ -82,6 +86,7 @@ uint32 MySQLRequestResult::LengthOfColumn(int columnIndex)
 
 const std::string MySQLRequestResult::FieldName(int columnIndex)
 {
+	_eqp
 	if (columnIndex >= m_ColumnCount || m_Result == nullptr)
 		return std::string();
 
@@ -94,6 +99,7 @@ const std::string MySQLRequestResult::FieldName(int columnIndex)
 MySQLRequestResult::MySQLRequestResult(MySQLRequestResult&& moveItem)
 	: m_CurrentRow(moveItem.m_CurrentRow), m_OneBeyondRow()
 {
+	_eqp
 	m_Result = moveItem.m_Result;
 	m_ErrorBuffer = moveItem.m_ErrorBuffer;
 	m_Success = moveItem.m_Success;
@@ -111,6 +117,7 @@ MySQLRequestResult::MySQLRequestResult(MySQLRequestResult&& moveItem)
 
 MySQLRequestResult& MySQLRequestResult::operator=(MySQLRequestResult&& other)
 {
+	_eqp
 	// Assigning something to itself?
 	// Silly! (but happens)
 	if (this == &other)

common/mysql_request_row.cpp

@@ -12,6 +12,7 @@ MySQLRequestRow::MySQLRequestRow()
 
 MySQLRequestRow::MySQLRequestRow(MySQLRequestRow&& moveItem)
 {
+	_eqp
 	m_Result = moveItem.m_Result;
 	m_MySQLRow = moveItem.m_MySQLRow;
 
@@ -21,6 +22,7 @@ MySQLRequestRow::MySQLRequestRow(MySQLRequestRow&& moveItem)
 
 MySQLRequestRow& MySQLRequestRow::operator=(MySQLRequestRow& moveItem)
 {
+	_eqp
 	m_Result = moveItem.m_Result;
 	m_MySQLRow = moveItem.m_MySQLRow;
 
@@ -33,12 +35,14 @@ MySQLRequestRow& MySQLRequestRow::operator=(MySQLRequestRow& moveItem)
 
 MySQLRequestRow MySQLRequestRow::operator*()
 {
+	_eqp
 	return *this;
 }
 
 MySQLRequestRow::MySQLRequestRow(MYSQL_RES *result)
 	: m_Result(result)
 {
+	_eqp
     if (result != nullptr)
         m_MySQLRow = mysql_fetch_row(result);
     else
@@ -47,12 +51,14 @@ MySQLRequestRow::MySQLRequestRow(MYSQL_RES *result)
 
 MySQLRequestRow& MySQLRequestRow::operator++()
 {
+	_eqp
 	m_MySQLRow = mysql_fetch_row(m_Result);
 	return *this;
 }
 
 MySQLRequestRow MySQLRequestRow::operator++(int)
 {
+	_eqp
 	MySQLRequestRow tmp(*this);
 	operator++();
 	return tmp;
@@ -60,15 +66,18 @@ MySQLRequestRow MySQLRequestRow::operator++(int)
 
 bool MySQLRequestRow::operator==(const MySQLRequestRow& rhs)
 {
+	_eqp
 	return m_MySQLRow == rhs.m_MySQLRow;
 }
 
 bool MySQLRequestRow::operator!=(const MySQLRequestRow& rhs)
 {
+	_eqp
 	return m_MySQLRow != rhs.m_MySQLRow;
 }
 
 char* MySQLRequestRow::operator[](int index)
 {
+	_eqp
 	return m_MySQLRow[index];
 }

common/opcode_map.cpp

@@ -1,307 +0,0 @@
-#include "global_define.h"
-#include <map>
-#include <string>
-
-std::map<unsigned long, std::string> opcode_map;
-
-std::string get_opcode_name(unsigned long opcode)
-{
-	std::map<unsigned long, std::string>::iterator itr;;
-	return (itr = opcode_map.find(opcode)) != opcode_map.end() ? itr->second : "OP_Unknown";
-}
-
-void load_opcode_names()
-{
-	opcode_map[0x0176] = "LiveOP_Heartbeat";
-	opcode_map[0x02d7] = "LiveOP_ReloadUI";
-	opcode_map[0x01eb] = "LiveOP_IncreaseStats";
-	opcode_map[0x0134] = "LiveOP_ApproveZone";
-	opcode_map[0x01d5] = "LiveOP_Dye";
-	opcode_map[0x0168] = "LiveOP_Stamina";
-	opcode_map[0x014d] = "LiveOP_ControlBoat";
-	opcode_map[0x003e] = "LiveOP_MobUpdate";
-	opcode_map[0x0027] = "LiveOP_ClientUpdate";
-	opcode_map[0x0024] = "LiveOP_ChannelMessage";
-	opcode_map[0x01d7] = "LiveOP_SimpleMessage";
-	opcode_map[0x01d8] = "LiveOP_FormattedMessage";
-	opcode_map[0x01c6] = "LiveOP_TGB";
-	opcode_map[0x0285] = "LiveOP_TestBuff";
-	opcode_map[0x012d] = "LiveOP_Bind_Wound";
-	opcode_map[0x01ab] = "LiveOP_Charm";
-	opcode_map[0x014c] = "LiveOP_Begging";
-	opcode_map[0x0152] = "LiveOP_MoveCoin";
-	opcode_map[0x0292] = "LiveOP_SpawnDoor";
-	opcode_map[0x009d] = "LiveOP_Sneak";
-	opcode_map[0x0079] = "LiveOP_ExpUpdate";
-	opcode_map[0x027d] = "LiveOP_DumpName";
-	opcode_map[0x01ea] = "LiveOP_RespondAA";
-	opcode_map[0x01c9] = "LiveOP_SendAAStats";
-	opcode_map[0x0366] = "LiveOP_SendAATable";
-	opcode_map[0x01e9] = "LiveOP_AAAction";
-	opcode_map[0x00bb] = "LiveOP_BoardBoat";
-	opcode_map[0x00bc] = "LiveOP_LeaveBoat";
-	opcode_map[0x02b8] = "LiveOP_AdventureInfoRequest";
-	opcode_map[0x02b9] = "LiveOP_AdventureInfo";
-	opcode_map[0x02a6] = "LiveOP_AdventureRequest";
-	opcode_map[0x02a8] = "LiveOP_AdventureDetails";
-	opcode_map[0x02a9] = "LiveOP_LDoNButton";
-	opcode_map[0x02ba] = "LiveOP_AdventureData";
-	opcode_map[0x02c9] = "LiveOP_AdventureFinish";
-	opcode_map[0x02c6] = "LiveOP_LeaveAdventure";
-	opcode_map[0x02ce] = "LiveOP_AdventureUpdate";
-	opcode_map[0x002b] = "LiveOP_SendExpZonein";
-	opcode_map[0x01e4] = "LiveOP_ZoneInSendName";
-	opcode_map[0x01bf] = "LiveOP_GuildLeader";
-	opcode_map[0x009a] = "LiveOP_GuildPeace";
-	opcode_map[0x0132] = "LiveOP_GuildRemove";
-	opcode_map[0x0059] = "LiveOP_GuildMemberList";
-	opcode_map[0x026e] = "LiveOP_GuildMemberUpdate";
-	opcode_map[0x0130] = "LiveOP_GuildInvite";
-	opcode_map[0x01c0] = "LiveOP_GuildMOTD";
-	opcode_map[0x003c] = "LiveOP_GuildPublicNote";
-	opcode_map[0x027e] = "LiveOP_GetGuildMOTD";
-	opcode_map[0x0277] = "LiveOP_GuildDemote";
-	opcode_map[0x0131] = "LiveOP_GuildInviteAccept";
-	opcode_map[0x00a4] = "LiveOP_GuildWar";
-	opcode_map[0x0133] = "LiveOP_GuildDelete";
-	opcode_map[0x0233] = "LiveOP_GuildManageRemove";
-	opcode_map[0x022d] = "LiveOP_GuildManageAdd";
-	opcode_map[0x0039] = "LiveOP_GuildManageStatus";
-	opcode_map[0x01e8] = "LiveOP_Trader";
-	opcode_map[0x01e7] = "LiveOP_Bazaar";
-	opcode_map[0x01c4] = "LiveOP_BecomeTrader";
-	opcode_map[0x01f4] = "LiveOP_BazaarInspect";
-	opcode_map[0x006e] = "LiveOP_TraderItemUpdate";
-	opcode_map[0x017c] = "LiveOP_TraderDelItem";
-	opcode_map[0x01eb] = "LiveOP_TraderShop";
-	opcode_map[0x01ca] = "LiveOP_TraderBuy";
-	opcode_map[0x01ac] = "LiveOP_PetCommands";
-	opcode_map[0x0042] = "LiveOP_TradeSkillCombine";
-	opcode_map[0x02e5] = "LiveOP_AugmentItem";
-	opcode_map[0x0367] = "LiveOP_ItemName";
-	opcode_map[0x02cd] = "LiveOP_ShopItem";
-	opcode_map[0x0065] = "LiveOP_ShopPlayerBuy";
-	opcode_map[0x006a] = "LiveOP_ShopPlayerSell";
-	opcode_map[0x006d] = "LiveOP_ShopDelItem";
-	opcode_map[0x0f6d] = "LiveOP_ShopEndConfirm";
-	opcode_map[0x00f7] = "LiveOP_ShopRequest";
-	opcode_map[0x006c] = "LiveOP_ShopEnd";
-	opcode_map[0x02d1] = "LiveOP_AdventureMerchantRequest";
-	opcode_map[0x02d2] = "LiveOP_AdventureMerchantResponse";
-	opcode_map[0x02d3] = "LiveOP_AdventureMerchantPurchase";
-	opcode_map[0x02e3] = "LiveOP_AdventurePointsUpdate";
-	opcode_map[0x0270] = "LiveOP_LFGCommand";
-	opcode_map[0x01d0] = "LiveOP_LFGAppearance";
-	opcode_map[0x01b5] = "LiveOP_MoneyUpdate";
-	opcode_map[0x0721] = "LiveOP_GroupDelete";
-	opcode_map[0x0272] = "LiveOP_GroupAcknowledge";
-	opcode_map[0x024a] = "LiveOP_GroupUpdate";
-	opcode_map[0x025f] = "LiveOP_GroupInvite";
-	opcode_map[0x00ff] = "LiveOP_GroupDisband";
-	opcode_map[0x00d5] = "LiveOP_GroupInvite2";
-	opcode_map[0x025e] = "LiveOP_GroupFollow";
-	opcode_map[0x00d7] = "LiveOP_GroupFollow2";
-	opcode_map[0x00d6] = "LiveOP_GroupCancelInvite";
-	opcode_map[0x0156] = "LiveOP_Split";
-	opcode_map[0x00d8] = "LiveOP_Jump";
-	opcode_map[0x01d6] = "LiveOP_ConsiderCorpse";
-	opcode_map[0x0064] = "LiveOP_SkillUpdate";
-	opcode_map[0x0178] = "LiveOP_GMEndTrainingResponse";
-	opcode_map[0x013c] = "LiveOP_GMEndTraining";
-	opcode_map[0x0175] = "LiveOP_GMTrainSkill";
-	opcode_map[0x013b] = "LiveOP_GMTraining";
-	opcode_map[0x017b] = "LiveOP_ConsumeAmmo";
-	opcode_map[0x0171] = "LiveOP_CombatAbility";
-	opcode_map[0x009c] = "LiveOP_TrackUnknown";
-	opcode_map[0x0234] = "LiveOP_TrackTarget";
-	opcode_map[0x0286] = "LiveOP_Track";
-	opcode_map[0x0297] = "LiveOP_ReadBook";
-	opcode_map[0x001f] = "LiveOP_ItemLinkClick";
-	opcode_map[0x01f4] = "LiveOP_ItemLinkResponse";
-	opcode_map[0x01d9] = "LiveOP_ItemLinkText";
-	opcode_map[0x0a41] = "LiveOP_RezzRequest";
-	opcode_map[0x00e5] = "LiveOP_RezzAnswer";
-	opcode_map[0x019b] = "LiveOP_RezzComplete";
-	opcode_map[0x0128] = "LiveOP_MoveDoor";
-	opcode_map[0x0127] = "LiveOP_ClickDoor";
-	opcode_map[0x0247] = "LiveOP_SendZonepoints";
-	opcode_map[0x008c] = "LiveOP_SetRunMode";
-	opcode_map[0x0248] = "LiveOP_InspectRequest";
-	opcode_map[0x0249] = "LiveOP_InspectAnswer";
-	opcode_map[0x0187] = "LiveOP_SenseTraps";
-	opcode_map[0x018e] = "LiveOP_DisarmTraps";
-	opcode_map[0x01bc] = "LiveOP_Assist";
-	opcode_map[0x0240] = "LiveOP_PickPocket";
-	opcode_map[0x0119] = "LiveOP_LootRequest";
-	opcode_map[0x011a] = "LiveOP_EndLootRequest";
-	opcode_map[0x011b] = "LiveOP_MoneyOnCorpse";
-	opcode_map[0x0179] = "LiveOP_LootComplete";
-	opcode_map[0x013f] = "LiveOP_LootItem";
-	opcode_map[0x0151] = "LiveOP_MoveItem";
-	opcode_map[0x0056] = "LiveOP_WhoAllRequest";
-	opcode_map[0x0229] = "LiveOP_WhoAllResponse";
-	opcode_map[0x0167] = "LiveOP_Consume";
-	opcode_map[0x0172] = "LiveOP_AutoAttack";
-	opcode_map[0x0186] = "LiveOP_AutoAttack2";
-	opcode_map[0x0173] = "LiveOP_TargetMouse";
-	opcode_map[0x01ba] = "LiveOP_TargetCommand";
-	opcode_map[0x01d8] = "LiveOP_TargetReject";
-	opcode_map[0x009e] = "LiveOP_Hide";
-	opcode_map[0x012e] = "LiveOP_Forage";
-	opcode_map[0x0077] = "LiveOP_Fishing";
-	opcode_map[0x0246] = "LiveOP_Bug";
-	opcode_map[0x00f2] = "LiveOP_Emote";
-	opcode_map[0x0140] = "LiveOP_EmoteAnim";
-	opcode_map[0x015c] = "LiveOP_Consider";
-	opcode_map[0x01cb] = "LiveOP_FaceChange";
-	opcode_map[0x0197] = "LiveOP_RandomReq";
-	opcode_map[0x0087] = "LiveOP_RandomReply";
-	opcode_map[0x01c3] = "LiveOP_Camp";
-	opcode_map[0x0192] = "LiveOP_YellForHelp";
-	opcode_map[0x00ef] = "LiveOP_SafePoint";
-	opcode_map[0x0157] = "LiveOP_Buff";
-	opcode_map[0x00c0] = "LiveOP_ColoredText";
-	opcode_map[0x0440] = "LiveOP_MultiLineMsg";
-	opcode_map[0x021c] = "LiveOP_SpecialMesg";
-	opcode_map[0x0013] = "LiveOP_Consent";
-	opcode_map[0x029d] = "LiveOP_ConsentResponse";
-	opcode_map[0x02d4] = "LiveOP_Deny";
-	opcode_map[0x016c] = "LiveOP_Stun";
-	opcode_map[0x0021] = "LiveOP_BeginCast";
-	opcode_map[0x00be] = "LiveOP_CastSpell";
-	opcode_map[0x01a8] = "LiveOP_InterruptCast";
-	opcode_map[0x0105] = "LiveOP_Death";
-	opcode_map[0x023f] = "LiveOP_FeignDeath";
-	opcode_map[0x012b] = "LiveOP_Illusion";
-	opcode_map[0x0078] = "LiveOP_LevelUpdate";
-	opcode_map[0x0371] = "LiveOP_LevelAppearance";
-	opcode_map[0x00c2] = "LiveOP_MemorizeSpell";
-	opcode_map[0x0244] = "LiveOP_HPUpdate";
-	opcode_map[0x022e] = "LiveOP_SendHPTarget";
-	opcode_map[0x007d] = "LiveOP_Mend";
-	opcode_map[0x0160] = "LiveOP_Taunt";
-	opcode_map[0x0199] = "LiveOP_GMDelCorpse";
-	opcode_map[0x0047] = "LiveOP_GMFind";
-	opcode_map[0x0020] = "LiveOP_GMServers";
-	opcode_map[0x010b] = "LiveOP_GMGoto";
-	opcode_map[0x028c] = "LiveOP_GMSummon";
-	opcode_map[0x010a] = "LiveOP_GMKick";
-	opcode_map[0x0109] = "LiveOP_GMKill";
-	opcode_map[0x0b40] = "LiveOP_GMNameChange";
-	opcode_map[0x00a3] = "LiveOP_GMLastName";
-	opcode_map[0x01b3] = "LiveOP_GMToggle";
-	opcode_map[0x028f] = "LiveOP_GMEmoteZone";
-	opcode_map[0x0074] = "LiveOP_GMBecomeNPC";
-	opcode_map[0x00de] = "LiveOP_GMHideMe";
-	opcode_map[0x0184] = "LiveOP_GMZoneRequest";
-	opcode_map[0x0239] = "LiveOP_GMZoneRequest2";
-	opcode_map[0x0068] = "LiveOP_Petition";
-	opcode_map[0x0085] = "LiveOP_PetitionRefresh";
-	opcode_map[0x01ee] = "LiveOP_PDeletePetition";
-	opcode_map[0x0092] = "LiveOP_PetitionBug";
-	opcode_map[0x0069] = "LiveOP_PetitionUpdate";
-	opcode_map[0x0076] = "LiveOP_PetitionCheckout";
-	opcode_map[0x0056] = "LiveOP_PetitionCheckout2";
-	opcode_map[0x0091] = "LiveOP_PetitionDelete";
-	opcode_map[0x02b4] = "LiveOP_PetitionResolve";
-	opcode_map[0x007e] = "LiveOP_PetitionCheckIn";
-	opcode_map[0x0090] = "LiveOP_PetitionUnCheckout";
-	opcode_map[0x01ec] = "LiveOP_PetitionQue";
-	opcode_map[0x01bb] = "LiveOP_SetServerFilter";
-	opcode_map[0x0218] = "LiveOP_NewSpawn";
-	opcode_map[0x0140] = "LiveOP_Animation";
-	opcode_map[0x0142] = "LiveOP_ZoneChange";
-	opcode_map[0x00f3] = "LiveOP_DeleteSpawn";
-	opcode_map[0x0265] = "LiveOP_CrashDump";
-	opcode_map[0x00e8] = "LiveOP_EnvDamage";
-	opcode_map[0x0101] = "LiveOP_Action";
-	opcode_map[0x00e2] = "LiveOP_Damage";
-	opcode_map[0x00bf] = "LiveOP_ManaChange";
-	opcode_map[0x027c] = "LiveOP_ClientError";
-	opcode_map[0x00fb] = "LiveOP_Save";
-	opcode_map[0x0316] = "LiveOP_LocInfo";
-	opcode_map[0x0188] = "LiveOP_Surname";
-	opcode_map[0x018f] = "LiveOP_SwapSpell";
-	opcode_map[0x01db] = "LiveOP_DeleteSpell";
-	opcode_map[0x029f] = "LiveOP_CloseContainer";
-	opcode_map[0x029f] = "LiveOP_ClickObjectAck";
-	opcode_map[0x00fa] = "LiveOP_CreateObject";
-	opcode_map[0x00f9] = "LiveOP_ClickObject";
-	opcode_map[0x01c1] = "LiveOP_ClearObject";
-	opcode_map[0x0265] = "LiveOP_ZoneUnavail";
-	opcode_map[0x02e0] = "LiveOP_ItemPacket";
-	opcode_map[0x029a] = "LiveOP_TradeRequest";
-	opcode_map[0x0037] = "LiveOP_TradeRequestAck";
-	opcode_map[0x002d] = "LiveOP_TradeAcceptClick";
-	opcode_map[0x0162] = "LiveOP_TradeMoneyUpdate";
-	opcode_map[0x0036] = "LiveOP_TradeCoins";
-	opcode_map[0x002e] = "LiveOP_CancelTrade";
-	opcode_map[0x002f] = "LiveOP_FinishTrade";
-	opcode_map[0x00a1] = "LiveOP_SaveOnZoneReq";
-	opcode_map[0x0185] = "LiveOP_Logout";
-	opcode_map[0x0298] = "LiveOP_RequestDuel";
-	opcode_map[0x0a5d] = "LiveOP_DuelResponse";
-	opcode_map[0x016e] = "LiveOP_DuelResponse2";
-	opcode_map[0x007c] = "LiveOP_InstillDoubt";
-	opcode_map[0x00ac] = "LiveOP_SafeFallSuccess";
-	opcode_map[0x02fb] = "LiveOP_DisciplineUpdate";
-	opcode_map[0x02f2] = "LiveOP_TributeUpdate";
-	opcode_map[0x02f3] = "LiveOP_TributeItem";
-	opcode_map[0x02f4] = "LiveOP_TributePointUpdate";
-	opcode_map[0x02f5] = "LiveOP_SendTributes";
-	opcode_map[0x02f6] = "LiveOP_TributeInfo";
-	opcode_map[0x02f7] = "LiveOP_SelectTribute";
-	opcode_map[0x02f8] = "LiveOP_TributeTimer";
-	opcode_map[0x02f9] = "LiveOP_StartTribute";
-	opcode_map[0x02fa] = "LiveOP_TributeNPC";
-	opcode_map[0x02fe] = "LiveOP_TributeMoney";
-	opcode_map[0x0364] = "LiveOP_TributeToggle";
-	opcode_map[0x0322] = "LiveOP_RecipesFavorite";
-	opcode_map[0x01f9] = "LiveOP_RecipesSearch";
-	opcode_map[0x01fa] = "LiveOP_RecipeReply";
-	opcode_map[0x01fb] = "LiveOP_RecipeDetails";
-	opcode_map[0x01fc] = "LiveOP_RecipeAutoCombine";
-	opcode_map[0x02db] = "LiveOP_FindPersonRequest";
-	opcode_map[0x02dc] = "LiveOP_FindPersonReply";
-	opcode_map[0x01dd] = "LiveOP_Shielding";
-	opcode_map[0x0198] = "LiveOP_SetDataRate";
-	opcode_map[0x023b] = "LiveOP_ZoneEntry";
-	opcode_map[0x006b] = "LiveOP_PlayerProfile";
-	opcode_map[0x0291] = "LiveOP_CharInventory";
-	opcode_map[0x0170] = "LiveOP_ZoneSpawns";
-	opcode_map[0x0026] = "LiveOP_TimeOfDay";
-	opcode_map[0x015b] = "LiveOP_Weather";
-	opcode_map[0x00ec] = "LiveOP_ReqNewZone";
-	opcode_map[0x00eb] = "LiveOP_NewZone";
-	opcode_map[0x00fd] = "LiveOP_ReqClientSpawn";
-	opcode_map[0x012F] = "LiveOP_SpawnAppearance";
-	opcode_map[0x0086] = "LiveOP_ClientReady";
-	opcode_map[0x0086] = "LiveOP_ZoneComplete";
-	opcode_map[0x02db] = "LiveOP_LoginComplete";
-	opcode_map[0x0195] = "LiveOP_ApproveWorld";
-	opcode_map[0x035f] = "LiveOP_LogServer";
-	opcode_map[0x01b2] = "LiveOP_MOTD";
-	opcode_map[0x0251] = "LiveOP_SendLoginInfo";
-	opcode_map[0x00ea] = "LiveOP_DeleteCharacter";
-	opcode_map[0x0102] = "LiveOP_SendCharInfo";
-	opcode_map[0x00e1] = "LiveOP_ExpansionInfo";
-	opcode_map[0x0104] = "LiveOP_CharacterCreate";
-	opcode_map[0x02ab] = "LiveOP_RandomNameGenerator";
-	opcode_map[0x005d] = "LiveOP_GuildsList";
-	opcode_map[0x0125] = "LiveOP_ApproveName";
-	opcode_map[0x0261] = "LiveOP_EnterWorld";
-	opcode_map[0x015a] = "LiveOP_World_Client_CRC1";
-	opcode_map[0x015e] = "LiveOP_World_Client_CRC2";
-	opcode_map[0x0269] = "LiveOP_SetChatServer";
-	opcode_map[0x0264] = "LiveOP_ZoneServerInfo";
-	opcode_map[0x0017] = "LiveOP_AckPacket";
-	opcode_map[0x012c] = "LiveOP_WearChange";
-	opcode_map[0x1FA1] = "LiveOP_WorldObjectsSent";
-	opcode_map[0x39C4] = "LiveOP_BlockedBuffs";
-	opcode_map[0x4656] = "LiveOP_SpawnPositionUpdate";
-	opcode_map[0x4b61] = "LiveOP_ManaUpdate";
-	opcode_map[0x02d6] = "LiveOP_EnduranceUpdate";
-	opcode_map[0x2ac1] = "LiveOP_MobManaUpdate";
-	opcode_map[0x6c5f] = "LiveOP_MobEnduranceUpdate";
-	opcode_map[0x73a8] = "LiveOP_SendMaxCharacters";
-}

common/packet_dump.cpp

@@ -25,6 +25,7 @@
 #include "../common/servertalk.h"
 
 void DumpPacketAscii(const uchar* buf, uint32 size, uint32 cols, uint32 skip) {
+	_eqp
 	// Output as ASCII
 	for(uint32 i=skip; i<size; i++)
 	{
@@ -49,6 +50,7 @@ void DumpPacketAscii(const uchar* buf, uint32 size, uint32 cols, uint32 skip) {
 }
 
 void DumpPacketHex(const uchar* buf, uint32 size, uint32 cols, uint32 skip) {
+	_eqp
 	if (size == 0 || size > 39565)
 		return;
 	// Output as HEX
@@ -91,6 +93,7 @@ void DumpPacketHex(const uchar* buf, uint32 size, uint32 cols, uint32 skip) {
 }
 
 std::string DumpPacketHexToString(const uchar* buf, uint32 size, uint32 cols, uint32 skip) {
+	_eqp
 	std::ostringstream out;
 	if (size == 0 || size > 39565)
 		return "";
@@ -140,11 +143,13 @@ std::string DumpPacketHexToString(const uchar* buf, uint32 size, uint32 cols, ui
 
 void DumpPacket(const uchar* buf, uint32 size)
 {
+	_eqp
 	DumpPacketHex(buf, size);
 //	DumpPacketAscii(buf,size);
 }
 
 void DumpPacket(const ServerPacket* pack, bool iShowInfo) {
+	_eqp
 	if (iShowInfo) {
 		std::cout << "Dumping ServerPacket: 0x" << std::hex << std::setfill('0') << std::setw(4) << pack->opcode << std::dec;
 		std::cout << " size:" << pack->size << std::endl;
@@ -153,23 +158,28 @@ void DumpPacket(const ServerPacket* pack, bool iShowInfo) {
 }
 
 void DumpPacketBin(const ServerPacket* pack) {
+	_eqp
 	DumpPacketBin(pack->pBuffer, pack->size);
 }
 
 void DumpPacketBin(uint32 data) {
+	_eqp
 	DumpPacketBin((uchar*)&data, sizeof(uint32));
 }
 
 void DumpPacketBin(uint16 data) {
+	_eqp
 	DumpPacketBin((uchar*)&data, sizeof(uint16));
 }
 
 void DumpPacketBin(uint8 data) {
+	_eqp
 	DumpPacketBin((uchar*)&data, sizeof(uint8));
 }
 
 
 void DumpPacketBin(const void* iData, uint32 len) {
+	_eqp
 	if (!len)
 		return;
 	const uint8* data = (const uint8*) iData;

common/packet_dump_file.cpp

@@ -41,6 +41,7 @@
 #include "packet_dump_file.h"
 
 void FileDumpPacketAscii(const char* filename, const uchar* buf, uint32 size, uint32 cols, uint32 skip) {
+	_eqp
 	std::ofstream logfile(filename, std::ios::app);
 	// Output as ASCII
 	for(uint32 i=skip; i<size; i++)
@@ -67,6 +68,7 @@ void FileDumpPacketAscii(const char* filename, const uchar* buf, uint32 size, ui
 
 void oldFileDumpPacketHex(const char* filename, const uchar* buf, uint32 size, uint32 cols, uint32 skip)
 {
+	_eqp
 	std::ofstream logfile(filename, std::ios::app);
 	// Output as HEX
 	char output[4];
@@ -89,6 +91,7 @@ void oldFileDumpPacketHex(const char* filename, const uchar* buf, uint32 size, u
 
 void FileDumpPacketHex(const char* filename, const uchar* buf, uint32 size, uint32 cols, uint32 skip)
 {
+	_eqp
 	if (size == 0)
 		return;
 	std::ofstream logfile(filename, std::ios::app);
@@ -131,16 +134,19 @@ void FileDumpPacketHex(const char* filename, const uchar* buf, uint32 size, uint
 
 void FileDumpPacketHex(const char* filename, const EQApplicationPacket* app)
 {
+	_eqp
 	FileDumpPacketHex(filename, app->pBuffer, app->size);
 }
 
 void FileDumpPacketAscii(const char* filename, const EQApplicationPacket* app)
 {
+	_eqp
 	FileDumpPacketAscii(filename, app->pBuffer, app->size);
 }
 
 void FileDumpPacket(const char* filename, const uchar* buf, uint32 size)
 {
+	_eqp
 	FilePrintLine(filename, true, "Size: %5i", size);
 	FileDumpPacketHex(filename, buf, size);
 //	FileDumpPacketAscii(filename, buf,size);
@@ -148,6 +154,7 @@ void FileDumpPacket(const char* filename, const uchar* buf, uint32 size)
 
 void FileDumpPacket(const char* filename, const EQApplicationPacket* app)
 {
+	_eqp
 	FilePrintLine(filename, true, "Size: %5i, OPCode: 0x%04x", app->size, app->GetOpcode());
 	FileDumpPacketHex(filename, app->pBuffer, app->size);
 //	FileDumpPacketAscii(filename, app->pBuffer, app->size);
@@ -158,6 +165,7 @@ void FileDumpPacket(const char* filename, const EQApplicationPacket* app)
 	if prefix_timestamp specified, prints the current date/time to the file + ": " + text
 */
 void FilePrintLine(const char* filename, bool prefix_timestamp, const char* text, ...) {
+	_eqp
 	std::ofstream logfile(filename, std::ios::app);
 	if (prefix_timestamp) {
 		time_t rawtime;
@@ -182,6 +190,7 @@ void FilePrintLine(const char* filename, bool prefix_timestamp, const char* text
 }
 
 void FilePrint(const char* filename, bool newline, bool prefix_timestamp, const char* text, ...) {
+	_eqp
 	std::ofstream logfile(filename, std::ios::app);
 	if (prefix_timestamp) {
 		time_t rawtime;

common/packetfile.cpp

@@ -1,438 +0,0 @@
-#ifndef WIN32
-#include <unistd.h>
-#else
-#include <winsock2.h>
-#endif
-
-#include <errno.h>
-#include <string.h>
-#include <time.h>
-#include "packetfile.h"
-#include "../common/eq_opcodes.h"
-#include "../common/eq_packet_structs.h"
-#include "../common/misc.h"
-#include <map>
-
-PacketFileWriter::PacketFileWriter(bool _force_flush) {
-	out = NULL;
-	force_flush = _force_flush;
-}
-
-PacketFileWriter::~PacketFileWriter() {
-	CloseFile();
-}
-
-bool PacketFileWriter::SetPacketStamp(const char *name, uint32 stamp) {
-	FILE *in;
-	in = fopen(name, "r+b");
-	if(in == NULL) {
-		fprintf(stderr, "Error opening packet file '%s': %s\n", name, strerror(errno));
-		return(false);
-	}
-
-	unsigned long magic = 0;
-
-	if(fread(&magic, sizeof(magic), 1, in) != 1) {
-		fprintf(stderr, "Error reading header from packet file: %s\n", strerror(errno));
-		fclose(in);
-		return(false);
-	}
-
-	PacketFileReader *ret = NULL;
-	if(magic == OLD_PACKET_FILE_MAGIC) {
-		OldPacketFileHeader *pos = 0;
-		uint32 stamp_pos = (uint32) &pos->packet_file_stamp;
-		fseek(in, stamp_pos, SEEK_SET);
-		OldPacketFileHeader hdr;
-		hdr.packet_file_stamp = stamp;
-		if(fwrite(&hdr.packet_file_stamp, sizeof(hdr.packet_file_stamp), 1, in) != 1) {
-			fprintf(stderr, "Error writting to packet file: %s\n", strerror(errno));
-			fclose(in);
-			return(false);
-		}
-	} else if(magic == PACKET_FILE_MAGIC) {
-		PacketFileHeader *pos = 0;
-		uint32 stamp_pos = (uint32) &pos->packet_file_stamp;
-		fseek(in, stamp_pos, SEEK_SET);
-		PacketFileHeader hdr;
-		hdr.packet_file_stamp = stamp;
-		if(fwrite(&hdr.packet_file_stamp, sizeof(hdr.packet_file_stamp), 1, in) != 1) {
-			fprintf(stderr, "Error writting to packet file: %s\n", strerror(errno));
-			fclose(in);
-			return(false);
-		}
-	} else {
-		fprintf(stderr, "Unknown packet file type 0x%.8x\n", magic);
-		fclose(in);
-		return(false);
-	}
-
-	fclose(in);
-	return(true);
-}
-
-bool PacketFileWriter::OpenFile(const char *name) {
-	CloseFile();
-
-	printf("Opening packet file: %s\n", name);
-
-	out = fopen(name, "wb");
-	if(out == NULL) {
-		fprintf(stderr, "Error opening packet file '%s': %s\n", name, strerror(errno));
-		return(false);
-	}
-
-	PacketFileHeader head;
-	head.packet_file_magic = PACKET_FILE_MAGIC;
-	head.packet_file_version = PACKET_FILE_CURRENT_VERSION;
-	head.packet_file_stamp = time(NULL);
-
-	if(fwrite(&head, sizeof(head), 1, out) != 1) {
-		fprintf(stderr, "Error writting header to packet file: %s\n", strerror(errno));
-		fclose(out);
-		return(false);
-	}
-
-	return(true);
-}
-
-void PacketFileWriter::CloseFile() {
-	if(out != NULL) {
-		fclose(out);
-		out = NULL;
-		printf("Closed packet file.\n");
-	}
-}
-
-void PacketFileWriter::WritePacket(uint16 eq_op, uint32 packlen, const unsigned char *packet, bool to_server, const struct timeval &tv) {
-	if(out == NULL)
-		return;
-
-	_WriteBlock(eq_op, packet, packlen, to_server, tv);
-
-/*
-	Could log only the packets we care about, but this is most of the stream,
-	so just log them all...
-
-	switch(eq_op) {
-	case OP_NewZone:
-	case OP_ZoneSpawns:
-	case OP_NewSpawn:
-	case OP_MobUpdate:
-	case OP_ClientUpdate:
-	case OP_Death:
-	case OP_DeleteSpawn:
-	case OP_CastSpell:
-	case OP_ShopRequest:
-	case OP_ShopEndConfirm:
-	case OP_ItemPacket:
-		_WriteBlock(eq_op, packet, packlen);
-	default:
-		return;
-	}
-	*/
-}
-
-bool PacketFileWriter::_WriteBlock(uint16 eq_op, const void *d, uint16 len, bool to_server, const struct timeval &tv) {
-	if(out == NULL)
-		return(false);
-
-	PacketFileSection s;
-	s.opcode = eq_op;
-	s.len = len;
-	s.tv_sec = tv.tv_sec;
-	s.tv_msec = tv.tv_usec/1000;
-
-	if(to_server)
-		SetToServer(s);
-	else
-		SetToClient(s);
-
-	if(fwrite(&s, sizeof(s), 1, out) != 1) {
-		fprintf(stderr, "Error writting block header: %s\n", strerror(errno));
-		return(false);
-	}
-
-	if(fwrite(d, 1, len, out) != len) {
-		fprintf(stderr, "Error writting block body: %s\n", strerror(errno));
-		return(false);
-	}
-
-	if(force_flush)
-		fflush(out);
-
-	return(true);
-}
-
-
-
-
-
-
-PacketFileReader *PacketFileReader::OpenPacketFile(const char *name) {
-	FILE *in;
-	in = fopen(name, "rb");
-	if(in == NULL) {
-		fprintf(stderr, "Error opening packet file '%s': %s\n", name, strerror(errno));
-		return(NULL);
-	}
-
-	unsigned long magic = 0;
-
-	if(fread(&magic, sizeof(magic), 1, in) != 1) {
-		fprintf(stderr, "Error reading header to packet file: %s\n", strerror(errno));
-		fclose(in);
-		return(NULL);
-	}
-
-	PacketFileReader *ret = NULL;
-	if(magic == OLD_PACKET_FILE_MAGIC) {
-		ret = new OldPacketFileReader();
-	} else if(magic == PACKET_FILE_MAGIC) {
-		ret = new NewPacketFileReader();
-	} else {
-		fprintf(stderr, "Unknown packet file type 0x%.8x\n", magic);
-		fclose(in);
-		return(NULL);
-	}
-
-	if(!ret->OpenFile(name)) {
-		safe_delete(ret);
-		return(NULL);
-	}
-
-	return(ret);
-}
-
-PacketFileReader::PacketFileReader() {
-	packet_file_stamp = 0;
-}
-
-OldPacketFileReader::OldPacketFileReader()
-: PacketFileReader()
-{
-	in = NULL;
-}
-
-OldPacketFileReader::~OldPacketFileReader() {
-	CloseFile();
-}
-
-bool OldPacketFileReader::OpenFile(const char *name) {
-	CloseFile();
-
-
-	in = fopen(name, "rb");
-	if(in == NULL) {
-		fprintf(stderr, "Error opening packet file '%s': %s\n", name, strerror(errno));
-		return(false);
-	}
-
-	OldPacketFileHeader head;
-
-	if(fread(&head, sizeof(head), 1, in) != 1) {
-		fprintf(stderr, "Error reading header to packet file: %s\n", strerror(errno));
-		fclose(in);
-		return(false);
-	}
-
-	if(head.packet_file_magic != OLD_PACKET_FILE_MAGIC) {
-		fclose(in);
-		if(head.packet_file_magic > (OLD_PACKET_FILE_MAGIC)) {
-			fprintf(stderr, "Error: this is a build file, not a packet file, its allready processed!\n");
-		} else {
-			fprintf(stderr, "Error: this is not a packet file!\n");
-		}
-		return(false);
-	}
-
-	uint32 now = time(NULL);
-	if(head.packet_file_stamp > now) {
-		fprintf(stderr, "Error: invalid timestamp in file. Your clock or the collector's is wrong (%d sec ahead).\n", head.packet_file_stamp-now);
-		fclose(in);
-		return(false);
-	}
-
-	packet_file_stamp = head.packet_file_stamp;
-
-	return(true);
-}
-
-void OldPacketFileReader::CloseFile() {
-	if(in != NULL) {
-		fclose(in);
-		in = NULL;
-	}
-}
-
-bool OldPacketFileReader::ResetFile() {
-	if(in == NULL)
-		return(false);
-	rewind(in);
-
-	//gotta read past the header again
-	OldPacketFileHeader head;
-
-	if(fread(&head, sizeof(head), 1, in) != 1) {
-		return(false);
-	}
-
-	return(true);
-}
-
-bool OldPacketFileReader::ReadPacket(uint16 &eq_op, uint32 &packlen, unsigned char *packet, bool &to_server, struct timeval &tv) {
-	if(in == NULL)
-		return(false);
-	if(feof(in))
-		return(false);
-
-	OldPacketFileSection s;
-
-	if(fread(&s, sizeof(s), 1, in) != 1) {
-		if(!feof(in))
-			fprintf(stderr, "Error reading section header: %s\n", strerror(errno));
-		return(false);
-	}
-
-	eq_op = s.opcode;
-
-	if(packlen < s.len) {
-		fprintf(stderr, "Packet buffer is too small! %d < %d, skipping\n", packlen, s.len);
-		fseek(in, s.len, SEEK_CUR);
-		return(false);
-	}
-
-	if(fread(packet, 1, s.len, in) != s.len) {
-		if(feof(in))
-			fprintf(stderr, "Error: EOF encountered when expecting packet data.\n");
-		else
-			fprintf(stderr, "Error reading packet body: %s\n", strerror(errno));
-		return(false);
-	}
-
-	packlen = s.len;
-	to_server = false;
-	tv.tv_sec = 0;
-	tv.tv_usec = 0;
-
-	return(true);
-}
-
-
-NewPacketFileReader::NewPacketFileReader()
-: PacketFileReader()
-{
-	in = NULL;
-}
-
-NewPacketFileReader::~NewPacketFileReader() {
-	CloseFile();
-}
-
-bool NewPacketFileReader::OpenFile(const char *name) {
-	CloseFile();
-
-
-	in = fopen(name, "rb");
-	if(in == NULL) {
-		fprintf(stderr, "Error opening packet file '%s': %s\n", name, strerror(errno));
-		return(false);
-	}
-
-	PacketFileHeader head;
-
-	if(fread(&head, sizeof(head), 1, in) != 1) {
-		fprintf(stderr, "Error reading header to packet file: %s\n", strerror(errno));
-		fclose(in);
-		return(false);
-	}
-
-	if(head.packet_file_magic != PACKET_FILE_MAGIC) {
-		fclose(in);
-		if(head.packet_file_magic == (PACKET_FILE_MAGIC+1)) {
-			fprintf(stderr, "Error: this is a build file, not a packet file, its allready processed!\n");
-		} else {
-			fprintf(stderr, "Error: this is not a packet file!\n");
-		}
-		return(false);
-	}
-
-	uint32 now = time(NULL);
-	if(head.packet_file_stamp > now) {
-		fprintf(stderr, "Error: invalid timestamp in file. Your clock or the collector's is wrong (%d sec ahead).\n", head.packet_file_stamp-now);
-		fclose(in);
-		return(false);
-	}
-
-	packet_file_stamp = head.packet_file_stamp;
-
-	return(true);
-}
-
-void NewPacketFileReader::CloseFile() {
-	if(in != NULL) {
-		fclose(in);
-		in = NULL;
-	}
-}
-
-bool NewPacketFileReader::ResetFile() {
-	if(in == NULL)
-		return(false);
-	rewind(in);
-
-	//gotta read past the header again
-	PacketFileHeader head;
-
-	if(fread(&head, sizeof(head), 1, in) != 1) {
-		return(false);
-	}
-
-	return(true);
-}
-
-bool NewPacketFileReader::ReadPacket(uint16 &eq_op, uint32 &packlen, unsigned char *packet, bool &to_server, struct timeval &tv) {
-	if(in == NULL)
-		return(false);
-	if(feof(in))
-		return(false);
-
-	PacketFileSection s;
-
-	if(fread(&s, sizeof(s), 1, in) != 1) {
-		if(!feof(in))
-			fprintf(stderr, "Error reading section header: %s\n", strerror(errno));
-		return(false);
-	}
-
-	eq_op = s.opcode;
-
-	if(packlen < s.len) {
-		fprintf(stderr, "Packet buffer is too small! %d < %d, skipping\n", packlen, s.len);
-		fseek(in, s.len, SEEK_CUR);
-		return(false);
-	}
-
-	if(fread(packet, 1, s.len, in) != s.len) {
-		if(feof(in))
-			fprintf(stderr, "Error: EOF encountered when expecting packet data.\n");
-		else
-			fprintf(stderr, "Error reading packet body: %s\n", strerror(errno));
-		return(false);
-	}
-
-	packlen = s.len;
-	to_server = IsToServer(s);
-	tv.tv_sec = s.tv_sec;
-	tv.tv_usec = 1000*s.tv_msec;
-
-	return(true);
-}
-
-
-
-
-
-
-
-

common/packetfile.h

@@ -1,130 +0,0 @@
-#ifndef PACKET_FILE_H
-#define PACKET_FILE_H
-
-#include "../common/types.h"
-#include <stdio.h>
-#include <time.h>
-//#include <zlib.h>
-
-//constants used in the packet file header
-#define PACKET_FILE_MAGIC 0x93a7b6f6
-#define OLD_PACKET_FILE_MAGIC 0x93a7b6f7
-
-#define PACKET_FILE_CURRENT_VERSION 1
-
-#pragma pack(1)
-//old structs from when I forgot to put the version number in
-struct OldPacketFileHeader {
-	uint32 packet_file_magic;
-	uint32 packet_file_stamp;
-};
-struct OldPacketFileSection {
-	uint16 opcode;
-	uint32 len;
-};
-
-struct PacketFileHeader {
-	uint32 packet_file_magic;
-	uint16 packet_file_version;
-	uint32 packet_file_stamp;
-};
-
-struct PacketFileSection {
-	uint16 opcode;
-	uint8 flags;	//mainly for client->server, but others could be added
-	uint32 tv_sec;
-	uint16 tv_msec;
-	uint32 len;
-};
-#pragma pack()
-
-#define TO_SERVER_FLAG 0x01
-#define SetToClient(pfs) pfs.flags = pfs.flags&~TO_SERVER_FLAG
-#define SetToServer(pfs) pfs.flags = pfs.flags|TO_SERVER_FLAG
-#define IsToClient(pfs) (pfs.flags&TO_SERVER_FLAG == 0)
-#define IsToServer(pfs) (pfs.flags&TO_SERVER_FLAG != 0)
-
-
-class PacketFileWriter {
-public:
-	PacketFileWriter(bool force_flush);
-	~PacketFileWriter();
-
-	bool OpenFile(const char *name);
-	void CloseFile();
-
-	void WritePacket(uint16 eq_op, uint32 packlen, const unsigned char *packet, bool to_server, const struct timeval &tv);
-
-	static bool SetPacketStamp(const char *file, uint32 stamp);
-
-protected:
-	bool _WriteBlock(uint16 eq_op, const void *d, uint16 len, bool to_server, const struct timeval &tv);
-
-	//gzFile out;
-	FILE *out;
-	bool force_flush;
-};
-
-
-class PacketFileReader {
-public:
-	PacketFileReader();
-
-	virtual bool OpenFile(const char *name) = 0;
-	virtual void CloseFile() = 0;
-	virtual bool ResetFile() = 0;	//aka rewind
-
-	virtual bool ReadPacket(uint16 &eq_op, uint32 &packlen, unsigned char *packet, bool &to_server, struct timeval &tv) = 0;
-
-	time_t GetStamp() { return(time_t(packet_file_stamp)); }
-
-	//factory method to open the right packet file.
-	static PacketFileReader *OpenPacketFile(const char *name);
-
-protected:
-
-	uint32 packet_file_stamp;
-};
-
-class OldPacketFileReader : public PacketFileReader {
-public:
-	OldPacketFileReader();
-	virtual ~OldPacketFileReader();
-
-	bool OpenFile(const char *name);
-	void CloseFile();
-	bool ResetFile();	//aka rewind
-
-	bool ReadPacket(uint16 &eq_op, uint32 &packlen, unsigned char *packet, bool &to_server, struct timeval &tv);
-
-	time_t GetStamp() { return(time_t(packet_file_stamp)); }
-
-protected:
-
-	//gzFile in;
-	FILE *in;
-};
-
-class NewPacketFileReader: public PacketFileReader {
-public:
-	NewPacketFileReader();
-	virtual ~NewPacketFileReader();
-
-	bool OpenFile(const char *name);
-	void CloseFile();
-	bool ResetFile();	//aka rewind
-
-	bool ReadPacket(uint16 &eq_op, uint32 &packlen, unsigned char *packet, bool &to_server, struct timeval &tv);
-
-	time_t GetStamp() { return(time_t(packet_file_stamp)); }
-
-protected:
-
-	//gzFile in;
-	FILE *in;
-};
-
-
-#endif
-
-

common/proc_launcher.cpp

@@ -47,6 +47,7 @@ const ProcLauncher::ProcRef ProcLauncher::ProcError = -1;
 
 ProcLauncher::ProcLauncher()
 {
+	_eqp
 #ifndef WIN32
 	if(signal(SIGCHLD, ProcLauncher::HandleSigChild) == SIG_ERR)
 		fprintf(stderr, "Unable to register child signal handler. Thats bad.");
@@ -55,6 +56,7 @@ ProcLauncher::ProcLauncher()
 }
 
 void ProcLauncher::Process() {
+	_eqp
 #ifdef _WINDOWS
 	std::map<ProcRef, Spec *>::iterator cur, end, tmp;
 	cur = m_running.begin();
@@ -108,7 +110,7 @@ void ProcLauncher::Process() {
 }
 
 void ProcLauncher::ProcessTerminated(std::map<ProcRef, Spec *>::iterator &it) {
-
+	_eqp
 	if(it->second->handler != nullptr)
 		it->second->handler->OnTerminate(it->first, it->second);
 
@@ -121,6 +123,7 @@ void ProcLauncher::ProcessTerminated(std::map<ProcRef, Spec *>::iterator &it) {
 }
 
 ProcLauncher::ProcRef ProcLauncher::Launch(Spec *&to_launch) {
+	_eqp
 	//consume the pointer
 	Spec *it = to_launch;
 	to_launch = nullptr;
@@ -275,6 +278,7 @@ ProcLauncher::ProcRef ProcLauncher::Launch(Spec *&to_launch) {
 
 //if graceful is true, we try to be nice about it if possible
 bool ProcLauncher::Terminate(const ProcRef &proc, bool graceful) {
+	_eqp
 	//we are only willing to kill things we started...
 	std::map<ProcRef, Spec *>::iterator res = m_running.find(proc);
 	if(res == m_running.end())
@@ -301,6 +305,7 @@ bool ProcLauncher::Terminate(const ProcRef &proc, bool graceful) {
 }
 
 void ProcLauncher::TerminateAll(bool final) {
+	_eqp
 	if(!final) {
 		//send a nice terminate to each process, with intention of waiting for them
 		std::map<ProcRef, Spec *>::iterator cur, end;
@@ -333,8 +338,6 @@ void ProcLauncher::HandleSigChild(int signum) {
 }
 #endif
 
-
-
 ProcLauncher::Spec::Spec() {
 	handler = nullptr;
 }

common/ptimer.cpp

@@ -88,6 +88,7 @@ CREATE TABLE timers (
 
 
 PersistentTimer *PersistentTimer::LoadTimer(Database *db, uint32 char_id, pTimerType type) {
+	_eqp
 	PersistentTimer *p;
 	p = new PersistentTimer(char_id, type, 0);
 	if(p->Load(db))
@@ -97,6 +98,7 @@ PersistentTimer *PersistentTimer::LoadTimer(Database *db, uint32 char_id, pTimer
 }
 
 PersistentTimer::PersistentTimer(uint32 char_id, pTimerType type, uint32 in_timer_time) {
+	_eqp
 	_char_id = char_id;
 	_type = type;
 
@@ -113,6 +115,7 @@ PersistentTimer::PersistentTimer(uint32 char_id, pTimerType type, uint32 in_time
 }
 
 PersistentTimer::PersistentTimer(uint32 char_id, pTimerType type, uint32 in_start_time, uint32 in_timer_time, bool in_enable) {
+	_eqp
 	_char_id = char_id;
 	_type = type;
 
@@ -125,6 +128,7 @@ PersistentTimer::PersistentTimer(uint32 char_id, pTimerType type, uint32 in_star
 }
 
 bool PersistentTimer::Load(Database *db) {
+	_eqp
 
 #ifdef DEBUG_PTIMERS
 	printf("Loading timer: char %lu of type %u\n", (unsigned long)_char_id, _type);
@@ -151,6 +155,7 @@ bool PersistentTimer::Load(Database *db) {
 }
 
 bool PersistentTimer::Store(Database *db) {
+	_eqp
 	if(Expired(db, false))	//dont need to store expired timers.
 		return true;
 
@@ -175,7 +180,7 @@ bool PersistentTimer::Store(Database *db) {
 }
 
 bool PersistentTimer::Clear(Database *db) {
-
+	_eqp
     std::string query = StringFormat("DELETE FROM timers "
                                     "WHERE char_id = %lu AND type = %u ",
                                     (unsigned long)_char_id, _type);
@@ -197,6 +202,7 @@ bool PersistentTimer::Clear(Database *db) {
 
 /* This function checks if the timer triggered */
 bool PersistentTimer::Expired(Database *db, bool iReset) {
+	_eqp
 	if (this == nullptr) {
 		Log.Out(Logs::General, Logs::Error, "Null timer during ->Check()!?\n");
 		return(true);
@@ -216,6 +222,7 @@ bool PersistentTimer::Expired(Database *db, bool iReset) {
 
 /* This function set the timer and restart it */
 void PersistentTimer::Start(uint32 set_timer_time) {
+	_eqp
 	start_time = get_current_time();
 	enabled = true;
 	if (set_timer_time != 0) {
@@ -228,6 +235,7 @@ void PersistentTimer::Start(uint32 set_timer_time) {
 
 // This timer updates the timer without restarting it
 void PersistentTimer::SetTimer(uint32 set_timer_time) {
+	_eqp
 	// If we were disabled before => restart the timer
 	timer_time = set_timer_time;
 	if (!enabled) {
@@ -240,6 +248,7 @@ void PersistentTimer::SetTimer(uint32 set_timer_time) {
 }
 
 uint32 PersistentTimer::GetRemainingTime() {
+	_eqp
 	if (enabled) {
 		uint32 current_time = get_current_time();
 		if (current_time-start_time > timer_time)
@@ -254,16 +263,19 @@ uint32 PersistentTimer::GetRemainingTime() {
 
 
 uint32 PersistentTimer::get_current_time() {
+	_eqp
 	timeval tv;
 	gettimeofday(&tv, nullptr);
 	return(tv.tv_sec);
 }
 
 PTimerList::PTimerList(uint32 char_id) {
+	_eqp
 	_char_id = char_id;
 }
 
 PTimerList::~PTimerList() {
+	_eqp
 	std::map<pTimerType, PersistentTimer *>::iterator s;
 	s = _list.begin();
 	while(s != _list.end()) {
@@ -275,6 +287,7 @@ PTimerList::~PTimerList() {
 
 
 bool PTimerList::Load(Database *db) {
+	_eqp
 
 	for (auto timerIterator = _list.begin(); timerIterator != _list.end(); ++timerIterator)
 		if(timerIterator->second != nullptr)
@@ -319,6 +332,7 @@ bool PTimerList::Load(Database *db) {
 }
 
 bool PTimerList::Store(Database *db) {
+	_eqp
 #ifdef DEBUG_PTIMERS
 	printf("Storing all timers for char %lu\n", (unsigned long)_char_id);
 #endif
@@ -340,6 +354,7 @@ bool PTimerList::Store(Database *db) {
 }
 
 bool PTimerList::Clear(Database *db) {
+	_eqp
 	_list.clear();
 
 	std::string query = StringFormat("DELETE FROM timers WHERE char_id=%lu ", (unsigned long)_char_id);
@@ -358,6 +373,7 @@ bool PTimerList::Clear(Database *db) {
 }
 
 void PTimerList::Start(pTimerType type, uint32 duration) {
+	_eqp
 	if(_list.count(type) == 1 && _list[type] != nullptr) {
 		_list[type]->Start(duration);
 	} else {
@@ -366,6 +382,7 @@ void PTimerList::Start(pTimerType type, uint32 duration) {
 }
 
 void PTimerList::Clear(Database *db, pTimerType type) {
+	_eqp
 	if(_list.count(type) == 1) {
 		if(_list[type] != nullptr) {
 			_list[type]->Clear(db);
@@ -376,6 +393,7 @@ void PTimerList::Clear(Database *db, pTimerType type) {
 }
 
 bool PTimerList::Expired(Database *db, pTimerType type, bool reset) {
+	_eqp
 	if(_list.count(type) != 1)
 		return(true);
 	if(_list[type] == nullptr)
@@ -384,6 +402,7 @@ bool PTimerList::Expired(Database *db, pTimerType type, bool reset) {
 }
 
 bool PTimerList::Enabled(pTimerType type) {
+	_eqp
 	if(_list.count(type) != 1)
 		return(false);
 	if(_list[type] == nullptr)
@@ -392,16 +411,19 @@ bool PTimerList::Enabled(pTimerType type) {
 }
 
 void PTimerList::Enable(pTimerType type) {
+	_eqp
 	if(_list.count(type) == 1 && _list[type] != nullptr)
 		_list[type]->Enable();
 }
 
 void PTimerList::Disable(pTimerType type) {
+	_eqp
 	if(_list.count(type) == 1 && _list[type] != nullptr)
 		_list[type]->Disable();
 }
 
 uint32 PTimerList::GetRemainingTime(pTimerType type) {
+	_eqp
 	if(_list.count(type) != 1)
 		return(0);
 	if(_list[type] == nullptr)
@@ -410,13 +432,14 @@ uint32 PTimerList::GetRemainingTime(pTimerType type) {
 }
 
 PersistentTimer *PTimerList::Get(pTimerType type) {
+	_eqp
 	if(_list.count(type) != 1)
 		return(nullptr);
 	return(_list[type]);
 }
 
 void PTimerList::ToVector(std::vector< std::pair<pTimerType, PersistentTimer *> > &out) {
-
+	_eqp
 	std::pair<pTimerType, PersistentTimer *> p;
 
 	std::map<pTimerType, PersistentTimer *>::iterator s;
@@ -432,7 +455,7 @@ void PTimerList::ToVector(std::vector< std::pair<pTimerType, PersistentTimer *>
 }
 
 bool PTimerList::ClearOffline(Database *db, uint32 char_id, pTimerType type) {
-
+	_eqp
 	std::string query = StringFormat("DELETE FROM timers WHERE char_id=%lu AND type=%u ",(unsigned long)char_id, type);
 
 #ifdef DEBUG_PTIMERS

common/rdtsc.cpp

@@ -1,167 +0,0 @@
-/*	EQEMu: Everquest Server Emulator
-	Copyright (C) 2001-2006 EQEMu Development Team (http://eqemulator.net)
-
-	This program is free software; you can redistribute it and/or modify
-	it under the terms of the GNU General Public License as published by
-	the Free Software Foundation; version 2 of the License.
-
-	This program is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY except by those people which sell it, which
-	are required to give you total support for your newly bought product;
-	without even the implied warranty of MERCHANTABILITY or FITNESS FOR
-	A PARTICULAR PURPOSE. See the GNU General Public License for more details.
-
-	You should have received a copy of the GNU General Public License
-	along with this program; if not, write to the Free Software
-	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-*/
-
-#include "rdtsc.h"
-#include "types.h"
-
-#ifdef _WINDOWS
-	#include <sys/timeb.h>
-	#include "../common/timer.h"
-#else
-	#include <unistd.h>
-	#include <sys/time.h>
-#endif
-
-#ifdef i386
-	#define USE_RDTSC
-#endif
-
-bool RDTSC_Timer::_inited = false;
-int64 RDTSC_Timer::_ticsperms = 0;
-
-RDTSC_Timer::RDTSC_Timer() {
-	if(!_inited) {
-		//find our clock rate
-		RDTSC_Timer::init();
-	}
-	_start = 0;
-	_end = 0;
-}
-
-RDTSC_Timer::RDTSC_Timer(bool start_it) {
-	if(!_inited) {
-		//find our clock rate
-		RDTSC_Timer::init();
-	}
-	if(start_it)
-		start();
-	else {
-		_start = 0;
-		_end = 0;
-	}
-}
-
-int64 RDTSC_Timer::rdtsc() {
-	int64 res = 0;
-#ifdef USE_RDTSC
-#ifndef WIN64
-#ifdef WIN32
-	//untested!
-	unsigned long highw, loww;
-	__asm {
-		push eax
-		push edx
-		rdtsc
-		mov highw, eax
-		mov loww, edx
-		pop edx
-		pop eax
-	}
-	res = ((int64)highw)<<32 | loww;
-#else
-	//gnu version
-	__asm__ __volatile__ ("rdtsc" : "=A" (res));
-#endif
-#else
-	//fall back to get time of day
-	timeval t;
-	gettimeofday(&t, nullptr);
-	res = ((int64)t.tv_sec) * 1000 + t.tv_usec;
-#endif
-#endif
-	return(res);
-}
-
-void RDTSC_Timer::init() {
-#ifdef USE_RDTSC
-	int64 before, after, sum;
-
-	int r;
-	sum = 0;
-	// run an average to increase accuracy of clock rate
-	for(r = 0; r < CALIBRATE_LOOPS; r++) {
-		before = rdtsc();
-
-		//sleep a know duration to figure out clock rate
-#ifdef _WINDOWS
-		Sleep(SLEEP_TIME);
-#else
-		usleep(SLEEP_TIME * 1000);	//ms * 1000
-#endif
-
-		after = rdtsc();
-
-		sum += after - before;
-	}
-
-	//ticks per sleep / ms per sleep
-	_ticsperms = (sum / CALIBRATE_LOOPS) / SLEEP_TIME;
-
-#else
-	//if using gettimeofday, this is fixed at 1000
-	_ticsperms = 1000;
-#endif
-//	printf("Tics per milisecond: %llu \n", _ticsperms);
-
-	_inited = true;	//only want to do this once
-}
-
-//start the timer
-void RDTSC_Timer::start() {
-	_start = rdtsc();
-	_end = 0;
-}
-
-//stop the timer
-void RDTSC_Timer::stop() {
-	_end = rdtsc();
-}
-
-//calculate the elapsed duration
-double RDTSC_Timer::getDuration() {
-	return(((double)(getTicks())) / double(_ticsperms));
-}
-
-RDTSC_Collector::RDTSC_Collector() : RDTSC_Timer() {
-	reset();
-}
-
-RDTSC_Collector::RDTSC_Collector(bool start_it) : RDTSC_Timer(start_it) {
-	reset();
-}
-
-void RDTSC_Collector::stop() {
-	RDTSC_Timer::stop();
-	_sum += RDTSC_Timer::getTicks();
-	_count++;
-}
-
-//calculate the elapsed duration
-double RDTSC_Collector::getTotalDuration() {
-	return(((double)(getTotalTicks())) / double(_ticsperms));
-}
-
-double RDTSC_Collector::getAverage() {
-	return(((double)(getTotalTicks())) / double(_ticsperms * _count));
-}
-
-void RDTSC_Collector::reset() {
-	_sum = 0;
-	_count = 0;
-}
-

common/rdtsc.h

@@ -1,86 +0,0 @@
-/*	EQEMu: Everquest Server Emulator
-	Copyright (C) 2001-2006 EQEMu Development Team (http://eqemulator.net)
-
-	This program is free software; you can redistribute it and/or modify
-	it under the terms of the GNU General Public License as published by
-	the Free Software Foundation; version 2 of the License.
-
-	This program is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY except by those people which sell it, which
-	are required to give you total support for your newly bought product;
-	without even the implied warranty of MERCHANTABILITY or FITNESS FOR
-	A PARTICULAR PURPOSE. See the GNU General Public License for more details.
-
-	You should have received a copy of the GNU General Public License
-	along with this program; if not, write to the Free Software
-	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-*/
-#ifndef RDTSC_H
-#define RDTSC_H
-
-
-#define CALIBRATE_LOOPS 3
-#define SLEEP_TIME 10	//in ms
-
-/*
-
-	This class implementes the highest possibly prescision timer
-	which is avaliable on the current archetecture.
-
-	On intel, this uses the rdtsc instruction to get the actual
-	clock cycle count, and elsewhere it falls back to gettimeofday
-
-	All calculations are carried out in 64 bit integers.
-*/
-
-#include "types.h"
-
-class RDTSC_Timer {
-public:
-	RDTSC_Timer();
-	RDTSC_Timer(bool start_it);
-
-	void start();	//start the timer
-	virtual void stop();	//stop the timer
-	double getDuration();	//returns the number of miliseconds elapsed
-
-	//access functions
-	int64 getTicks() { return(_end - _start); }
-	static int64 ticksPerMS() { return(_ticsperms); }
-
-protected:
-	static int64 rdtsc();
-
-	int64 _start;
-	int64 _end;
-
-protected:
-	static void init();
-	static bool _inited;
-	static int64 _ticsperms;
-};
-
-//this is a timer which can be started and stoped many times.
-//each time it contributes its counter to a sum, whic is used
-//to find net duration.
-class RDTSC_Collector : public RDTSC_Timer {
-public:
-	RDTSC_Collector();
-	RDTSC_Collector(bool start_it);
-
-	void reset();
-
-	void stop();	//stop the timer
-
-	double getTotalDuration();	//returns the number of miliseconds elapsed
-	double getAverage();
-
-	int64 getTotalTicks() { return(_sum); }
-	int64 getCount() { return(_count); }
-
-protected:
-	int64 _sum;
-	int64 _count;
-};
-
-#endif

common/string_util.cpp

@@ -64,6 +64,7 @@ const std::string vStringFormat(const char* format, va_list args)
 
 const std::string StringFormat(const char* format, ...)
 {
+	_eqp
 	va_list args;
 	va_start(args, format);
 	std::string output = vStringFormat(format,args);
@@ -121,6 +122,7 @@ void MakeLowerString(const char *source, char *target) {
 }
 
 int MakeAnyLenString(char** ret, const char* format, ...) {
+	_eqp
 	int buf_len = 128;
 	int chars = -1;
 	va_list argptr, tmpargptr;
@@ -140,6 +142,7 @@ int MakeAnyLenString(char** ret, const char* format, ...) {
 }
 
 uint32 AppendAnyLenString(char** ret, uint32* bufsize, uint32* strlen, const char* format, ...) {
+	_eqp
 	if (*bufsize == 0)
 		*bufsize = 256;
 	if (*ret == 0)
@@ -258,6 +261,7 @@ bool atobool(const char* iBool) {
 // removes the crap and turns the underscores into spaces.
 char *CleanMobName(const char *in, char *out)
 {
+	_eqp
 	unsigned i, j;
 	
 	for(i = j = 0; i < strlen(in); i++)
@@ -312,6 +316,7 @@ const char *ConvertArrayF(float input, char *returnchar)
 }
 
 std::vector<std::string> SplitString(const std::string &str, char delim) {
+	_eqp
 	std::vector<std::string> ret;
 	std::stringstream ss(str);
     std::string item;
@@ -324,6 +329,7 @@ std::vector<std::string> SplitString(const std::string &str, char delim) {
 }
 
 std::string EscapeString(const std::string &s) {
+	_eqp
 	std::string ret;
 
 	size_t sz = s.length();
@@ -361,6 +367,7 @@ std::string EscapeString(const std::string &s) {
 }
 
 std::string EscapeString(const char *src, size_t sz) {
+	_eqp
 	std::string ret;
 
 	for(size_t i = 0; i < sz; ++i) {

common/struct_strategy.cpp

@@ -11,6 +11,7 @@
 //note: all encoders and decoders must be valid functions.
 //so if you specify set_defaults=false
 StructStrategy::StructStrategy() {
+	_eqp
 	int r;
 	for(r = 0; r < _maxEmuOpcode; r++) {
 		encoders[r] = PassEncoder;
@@ -19,6 +20,7 @@ StructStrategy::StructStrategy() {
 }
 
 void StructStrategy::Encode(EQApplicationPacket **p, std::shared_ptr<EQStream> dest, bool ack_req) const {
+	_eqp
 	if((*p)->GetOpcodeBypass() != 0) {
 		PassEncoder(p, dest, ack_req);
 		return;
@@ -30,6 +32,7 @@ void StructStrategy::Encode(EQApplicationPacket **p, std::shared_ptr<EQStream> d
 }
 
 void StructStrategy::Decode(EQApplicationPacket *p) const {
+	_eqp
 	EmuOpcode op = p->GetOpcode();
 	Decoder proc = decoders[op];
 	proc(p);
@@ -37,6 +40,7 @@ void StructStrategy::Decode(EQApplicationPacket *p) const {
 
 
 void StructStrategy::ErrorEncoder(EQApplicationPacket **in_p, std::shared_ptr<EQStream> dest, bool ack_req) {
+	_eqp
 	EQApplicationPacket *p = *in_p;
 	*in_p = nullptr;
 
@@ -46,11 +50,13 @@ void StructStrategy::ErrorEncoder(EQApplicationPacket **in_p, std::shared_ptr<EQ
 }
 
 void StructStrategy::ErrorDecoder(EQApplicationPacket *p) {
+	_eqp
 	Log.Out(Logs::General, Logs::Netcode, "[STRUCTS] Error decoding opcode %s: no decoder provided. Invalidating.", OpcodeManager::EmuToName(p->GetOpcode()));
 	p->SetOpcode(OP_Unknown);
 }
 
 void StructStrategy::PassEncoder(EQApplicationPacket **p, std::shared_ptr<EQStream> dest, bool ack_req) {
+	_eqp
 	dest->FastQueuePacket(p, ack_req);
 }
 
@@ -67,10 +73,12 @@ namespace StructStrategyFactory {
 	static std::map<EmuOpcode, const StructStrategy *> strategies;
 
 	void RegisterPatch(EmuOpcode first_opcode, const StructStrategy *structs) {
+		_eqp
 		strategies[first_opcode] = structs;
 	}
 
 	const StructStrategy *FindPatch(EmuOpcode first_opcode) {
+		_eqp
 		std::map<EmuOpcode, const StructStrategy *>::const_iterator res;
 		res = strategies.find(first_opcode);
 		if(res == strategies.end())

common/tcp_connection.cpp

@@ -75,6 +75,7 @@ TCPConnection::TCPConnection(uint32 ID, SOCKET in_socket, uint32 irIP, uint16 ir
 	rIP(irIP),
 	rPort(irPort)
 {
+	_eqp
 	pState = TCPS_Connected;
 	pFree = false;
 	pEcho = false;
@@ -90,6 +91,7 @@ TCPConnection::TCPConnection(uint32 ID, SOCKET in_socket, uint32 irIP, uint16 ir
 }
 
 TCPConnection::~TCPConnection() {
+	_eqp
 	FinishDisconnect();
 	ClearBuffers();
 	if (ConnectionType == Outgoing) {
@@ -113,12 +115,14 @@ TCPConnection::~TCPConnection() {
 }
 
 void TCPConnection::SetState(State_t in_state) {
+	_eqp
 	MState.lock();
 	pState = in_state;
 	MState.unlock();
 }
 
 TCPConnection::State_t TCPConnection::GetState() const {
+	_eqp
 	State_t ret;
 	MState.lock();
 	ret = pState;
@@ -128,6 +132,7 @@ TCPConnection::State_t TCPConnection::GetState() const {
 
 bool TCPConnection::GetSockName(char *host, uint16 *port)
 {
+	_eqp
 	bool result=false;
 	LockMutex lock(&MState);
 	if (!Connected())
@@ -165,11 +170,13 @@ bool TCPConnection::GetSockName(char *host, uint16 *port)
 }
 
 void TCPConnection::Free() {
+	_eqp
 	Disconnect();
 	pFree = true;
 }
 
 bool TCPConnection::Send(const uchar* data, int32 size) {
+	_eqp
 	if (!Connected())
 		return false;
 	if (!size)
@@ -179,6 +186,7 @@ bool TCPConnection::Send(const uchar* data, int32 size) {
 }
 
 void TCPConnection::ServerSendQueuePushEnd(const uchar* data, int32 size) {
+	_eqp
 	MSendQueue.lock();
 	if (sendbuf == nullptr) {
 		sendbuf = new uchar[size];
@@ -198,6 +206,7 @@ void TCPConnection::ServerSendQueuePushEnd(const uchar* data, int32 size) {
 }
 
 void TCPConnection::ServerSendQueuePushEnd(uchar** data, int32 size) {
+	_eqp
 	MSendQueue.lock();
 	if (sendbuf == 0) {
 		sendbuf = *data;
@@ -221,6 +230,7 @@ void TCPConnection::ServerSendQueuePushEnd(uchar** data, int32 size) {
 }
 
 void TCPConnection::ServerSendQueuePushFront(uchar* data, int32 size) {
+	_eqp
 	MSendQueue.lock();
 	if (sendbuf == 0) {
 		sendbuf = new uchar[size];
@@ -240,6 +250,7 @@ void TCPConnection::ServerSendQueuePushFront(uchar* data, int32 size) {
 }
 
 bool TCPConnection::ServerSendQueuePop(uchar** data, int32* size) {
+	_eqp
 	bool ret;
 	if (!MSendQueue.trylock())
 		return false;
@@ -257,6 +268,7 @@ bool TCPConnection::ServerSendQueuePop(uchar** data, int32* size) {
 }
 
 bool TCPConnection::ServerSendQueuePopForce(uchar** data, int32* size) {
+	_eqp
 	bool ret;
 	MSendQueue.lock();
 	if (sendbuf) {
@@ -273,6 +285,7 @@ bool TCPConnection::ServerSendQueuePopForce(uchar** data, int32* size) {
 }
 
 char* TCPConnection::PopLine() {
+	_eqp
 	char* ret;
 	if (!MLineOutQueue.trylock())
 		return 0;
@@ -282,6 +295,7 @@ char* TCPConnection::PopLine() {
 }
 
 bool TCPConnection::LineOutQueuePush(char* line) {
+	_eqp
 	MLineOutQueue.lock();
 	LineOutQueue.push(line);
 	MLineOutQueue.unlock();
@@ -290,6 +304,7 @@ bool TCPConnection::LineOutQueuePush(char* line) {
 
 
 void TCPConnection::FinishDisconnect() {
+	_eqp
 	MState.lock();
 	if (connection_socket != INVALID_SOCKET && connection_socket != 0) {
 		if (pState == TCPS_Connected || pState == TCPS_Disconnecting || pState == TCPS_Disconnected) {
@@ -314,6 +329,7 @@ void TCPConnection::FinishDisconnect() {
 }
 
 void TCPConnection::Disconnect() {
+	_eqp
 	MState.lock();
 	if(pState == TCPS_Connected || pState == TCPS_Connecting) {
 		pState = TCPS_Disconnecting;
@@ -322,6 +338,7 @@ void TCPConnection::Disconnect() {
 }
 
 bool TCPConnection::GetAsyncConnect() {
+	_eqp
 	bool ret;
 	MAsyncConnect.lock();
 	ret = pAsyncConnect;
@@ -330,6 +347,7 @@ bool TCPConnection::GetAsyncConnect() {
 }
 
 bool TCPConnection::SetAsyncConnect(bool iValue) {
+	_eqp
 	bool ret;
 	MAsyncConnect.lock();
 	ret = pAsyncConnect;
@@ -339,6 +357,7 @@ bool TCPConnection::SetAsyncConnect(bool iValue) {
 }
 
 bool TCPConnection::ConnectReady() const {
+	_eqp
 	State_t s = GetState();
 	if (s != TCPS_Ready && s != TCPS_Disconnected)
 		return(false);
@@ -346,6 +365,7 @@ bool TCPConnection::ConnectReady() const {
 }
 
 void TCPConnection::AsyncConnect(const char* irAddress, uint16 irPort) {
+	_eqp
 	safe_delete_array(charAsyncConnect);
 	charAsyncConnect = new char[strlen(irAddress) + 1];
 	strcpy(charAsyncConnect, irAddress);
@@ -353,6 +373,7 @@ void TCPConnection::AsyncConnect(const char* irAddress, uint16 irPort) {
 }
 
 void TCPConnection::AsyncConnect(uint32 irIP, uint16 irPort) {
+	_eqp
 	if (ConnectionType != Outgoing) {
 		// If this code runs, we got serious problems
 		// Crash and burn.
@@ -394,6 +415,7 @@ void TCPConnection::AsyncConnect(uint32 irIP, uint16 irPort) {
 }
 
 bool TCPConnection::Connect(const char* irAddress, uint16 irPort, char* errbuf) {
+	_eqp
 	if (errbuf)
 		errbuf[0] = 0;
 	uint32 tmpIP = ResolveIP(irAddress);
@@ -411,6 +433,7 @@ bool TCPConnection::Connect(const char* irAddress, uint16 irPort, char* errbuf)
 }
 
 bool TCPConnection::ConnectIP(uint32 in_ip, uint16 in_port, char* errbuf) {
+	_eqp
 	if (errbuf)
 		errbuf[0] = 0;
 	if (ConnectionType != Outgoing) {
@@ -499,6 +522,7 @@ bool TCPConnection::ConnectIP(uint32 in_ip, uint16 in_port, char* errbuf) {
 }
 
 void TCPConnection::ClearBuffers() {
+	_eqp
 	LockMutex lock1(&MSendQueue);
 	LockMutex lock3(&MRunLoop);
 	LockMutex lock4(&MState);
@@ -511,6 +535,7 @@ void TCPConnection::ClearBuffers() {
 }
 
 bool TCPConnection::CheckNetActive() {
+	_eqp
 	MState.lock();
 	if (pState == TCPS_Connected || pState == TCPS_Disconnecting) {
 		MState.unlock();
@@ -523,6 +548,7 @@ bool TCPConnection::CheckNetActive() {
 /* This is always called from an IO thread. Either the server socket's thread, or a
  * special thread we create when we make an outbound connection. */
 bool TCPConnection::Process() {
+	_eqp
 	char errbuf[TCPConnection_ErrorBufferSize];
 	switch(GetState()) {
 	case TCPS_Ready:
@@ -594,6 +620,7 @@ bool TCPConnection::Process() {
 }
 
 bool TCPConnection::RecvData(char* errbuf) {
+	_eqp
 	if (errbuf)
 		errbuf[0] = 0;
 	if (!Connected()) {
@@ -666,16 +693,19 @@ bool TCPConnection::RecvData(char* errbuf) {
 
 
 bool TCPConnection::GetEcho() {
+	_eqp
 	bool ret;
 	ret = pEcho;
 	return ret;
 }
 
 void TCPConnection::SetEcho(bool iValue) {
+	_eqp
 	pEcho = iValue;
 }
 
 bool TCPConnection::ProcessReceivedData(char* errbuf) {
+	_eqp
 	if (errbuf)
 		errbuf[0] = 0;
 	if (!recvbuf)
@@ -810,6 +840,7 @@ bool TCPConnection::ProcessReceivedData(char* errbuf) {
 }
 
 bool TCPConnection::SendData(bool &sent_something, char* errbuf) {
+	_eqp
 	if (errbuf)
 		errbuf[0] = 0;
 	/************ Get first send packet on queue and send it! ************/
@@ -891,6 +922,7 @@ bool TCPConnection::SendData(bool &sent_something, char* errbuf) {
 }
 
 ThreadReturnType TCPConnection::TCPConnectionLoop(void* tmp) {
+	_eqp
 #ifdef _WINDOWS
 	SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_ABOVE_NORMAL);
 #endif
@@ -933,6 +965,7 @@ ThreadReturnType TCPConnection::TCPConnectionLoop(void* tmp) {
 }
 
 bool TCPConnection::RunLoop() {
+	_eqp
 	bool ret;
 	MRunLoop.lock();
 	ret = pRunLoop;

common/timeoutmgr.cpp

@@ -24,18 +24,22 @@
 Timeoutable::Timeoutable(uint32 check_frequency)
  : next_check(check_frequency)
 {
+	_eqp
 	timeout_manager.AddMember(this);
 }
 
 Timeoutable::~Timeoutable() {
+	_eqp
 	timeout_manager.DeleteMember(this);
 }
 
 
 TimeoutManager::TimeoutManager() {
+	_eqp
 }
 
 void TimeoutManager::CheckTimeouts() {
+	_eqp
 	std::vector<Timeoutable *>::iterator cur,end;
 	cur = members.begin();
 	end = members.end();
@@ -52,6 +56,7 @@ void TimeoutManager::CheckTimeouts() {
 
 //methods called by Timeoutable objects:
 void TimeoutManager::AddMember(Timeoutable *who) {
+	_eqp
 	if(who == nullptr)
 		return;
 
@@ -63,6 +68,7 @@ void TimeoutManager::AddMember(Timeoutable *who) {
 }
 
 void TimeoutManager::DeleteMember(Timeoutable *who) {
+	_eqp
 #ifdef TIMEOUT_DEBUG
 	Log.Out(Logs::General, Logs::None, "Removing timeoutable 0x%x\n", who);
 #endif

common/timer.cpp

@@ -30,6 +30,7 @@ uint32 current_time = 0;
 uint32 last_time = 0;
 
 Timer::Timer() {
+	_eqp
 	timer_time = 0;
 	start_time = current_time;
 	set_at_trigger = timer_time;
@@ -38,6 +39,7 @@ Timer::Timer() {
 }
 
 Timer::Timer(uint32 in_timer_time, bool iUseAcurateTiming) {
+	_eqp
 	timer_time = in_timer_time;
 	start_time = current_time;
 	set_at_trigger = timer_time;
@@ -51,6 +53,7 @@ Timer::Timer(uint32 in_timer_time, bool iUseAcurateTiming) {
 }
 
 Timer::Timer(uint32 start, uint32 timer, bool iUseAcurateTiming = false) {
+	_eqp
 	timer_time = timer;
 	start_time = start;
 	set_at_trigger = timer_time;
@@ -81,6 +84,7 @@ int gettimeofday (timeval *tp, ...)
 /* This function checks if the timer triggered */
 bool Timer::Check(bool iReset)
 {
+	_eqp
 	if (enabled && current_time-start_time > timer_time) {
 		if (iReset) {
 			if (pUseAcurateTiming)
@@ -97,15 +101,18 @@ bool Timer::Check(bool iReset)
 
 /* This function disables the timer */
 void Timer::Disable() {
+	_eqp
 	enabled = false;
 }
 
 void Timer::Enable() {
+	_eqp
 	enabled = true;
 }
 
 /* This function set the timer and restart it */
 void Timer::Start(uint32 set_timer_time, bool ChangeResetTimer) {
+	_eqp
 	start_time = current_time;
 	enabled = true;
 	if (set_timer_time != 0)
@@ -118,6 +125,7 @@ void Timer::Start(uint32 set_timer_time, bool ChangeResetTimer) {
 
 /* This timer updates the timer without restarting it */
 void Timer::SetTimer(uint32 set_timer_time) {
+	_eqp
 	/* If we were disabled before => restart the timer */
 	if (!enabled) {
 		start_time = current_time;
@@ -130,6 +138,7 @@ void Timer::SetTimer(uint32 set_timer_time) {
 }
 
 uint32 Timer::GetRemainingTime() {
+	_eqp
 	if (enabled) {
 		if (current_time-start_time > timer_time)
 			return 0;
@@ -142,6 +151,7 @@ uint32 Timer::GetRemainingTime() {
 }
 
 void Timer::SetAtTrigger(uint32 in_set_at_trigger, bool iEnableIfDisabled, bool ChangeTimerTime) {
+	_eqp
 	set_at_trigger = in_set_at_trigger;
 	if (!Enabled() && iEnableIfDisabled) {
 		Enable();
@@ -152,6 +162,7 @@ void Timer::SetAtTrigger(uint32 in_set_at_trigger, bool iEnableIfDisabled, bool
 
 void Timer::Trigger()
 {
+	_eqp
 	enabled = true;
 
 	timer_time = set_at_trigger;
@@ -160,11 +171,13 @@ void Timer::Trigger()
 
 const uint32 Timer::GetCurrentTime()
 {
+	_eqp
 	return current_time;
 }
 
 //just to keep all time related crap in one place... not really related to timers.
 const uint32 Timer::GetTimeSeconds() {
+	_eqp
 	struct timeval read_time;
 
 	gettimeofday(&read_time,0);
@@ -173,6 +186,7 @@ const uint32 Timer::GetTimeSeconds() {
 
 const uint32 Timer::SetCurrentTime()
 {
+	_eqp
 	struct timeval read_time;
 	uint32 this_time;
 

common/worldconn.cpp

@@ -28,21 +28,25 @@
 WorldConnection::WorldConnection(EmuTCPConnection::ePacketMode mode, const char *password)
 : m_password(password)
 {
+	_eqp
 	tcpc.SetPacketMode(mode);
 	pTryReconnect = true;
 	pConnected = false;
 }
 
 WorldConnection::~WorldConnection() {
+	_eqp
 }
 
 bool WorldConnection::SendPacket(ServerPacket* pack) {
+	_eqp
 	if (!Connected())
 		return false;
 	return tcpc.SendPacket(pack);
 }
 
 void WorldConnection::OnConnected() {
+	_eqp
 	const EQEmuConfig *Config=EQEmuConfig::get();
 	Log.Out(Logs::General, Logs::Netcode, "[WORLD] Connected to World: %s:%d", Config->WorldIP.c_str(), Config->WorldTCPPort);
 
@@ -53,6 +57,7 @@ void WorldConnection::OnConnected() {
 }
 
 void WorldConnection::Process() {
+	_eqp
 	//persistent connection....
 	if (!Connected()) {
 		pConnected = tcpc.Connected();
@@ -66,11 +71,13 @@ void WorldConnection::Process() {
 }
 
 void WorldConnection::AsyncConnect() {
+	_eqp
 	const EQEmuConfig *Config=EQEmuConfig::get();
 	tcpc.AsyncConnect(Config->WorldIP.c_str(), Config->WorldTCPPort);
 }
 
 bool WorldConnection::Connect() {
+	_eqp
 	const EQEmuConfig *Config=EQEmuConfig::get();
 	char errbuf[TCPConnection_ErrorBufferSize];
 	if (tcpc.Connect(Config->WorldIP.c_str(), Config->WorldTCPPort, errbuf)) {
@@ -82,6 +89,7 @@ bool WorldConnection::Connect() {
 }
 
 void WorldConnection::Disconnect() {
+	_eqp
 	tcpc.Disconnect();
 }
 

common/xml_parser.cpp

@@ -23,6 +23,7 @@ XMLParser::XMLParser() {
 }
 
 bool XMLParser::ParseFile(const char *file, const char *root_ele) {
+	_eqp
 	std::map<std::string,ElementHandler>::iterator handler;
 	TiXmlDocument doc( file );
 	if(!doc.LoadFile()) {
@@ -70,6 +71,7 @@ bool XMLParser::ParseFile(const char *file, const char *root_ele) {
 }
 
 const char *XMLParser::ParseTextBlock(TiXmlNode *within, const char *name, bool optional) {
+	_eqp
 	TiXmlElement * txt = within->FirstChildElement(name);
 	if(txt == nullptr) {
 		if(!optional) {
@@ -88,6 +90,7 @@ const char *XMLParser::ParseTextBlock(TiXmlNode *within, const char *name, bool
 }
 
 const char *XMLParser::GetText(TiXmlNode *within, bool optional) {
+	_eqp
 	TiXmlNode *contents = within->FirstChild();
 	if(contents == nullptr || contents->Type() != TiXmlNode::TEXT) {
 		if(!optional) {

tests/CMakeLists.txt

@@ -27,10 +27,12 @@ INSTALL(TARGETS tests RUNTIME DESTINATION ${CMAKE_INSTALL_PREFIX})
 IF(MSVC)
 	SET_TARGET_PROPERTIES(tests PROPERTIES LINK_FLAGS_RELEASE "/OPT:REF /OPT:ICF")
 	TARGET_LINK_LIBRARIES(tests "Ws2_32.lib")
+	TARGET_LINK_LIBRARIES(tests "rpcrt4")
 ENDIF(MSVC)
 
 IF(MINGW)
 	TARGET_LINK_LIBRARIES(tests "WS2_32")
+	TARGET_LINK_LIBRARIES(tests "rpcrt4")
 ENDIF(MINGW)
 
 IF(UNIX)
@@ -41,6 +43,7 @@ IF(UNIX)
 		TARGET_LINK_LIBRARIES(tests "rt")
 	ENDIF(NOT DARWIN)
 	TARGET_LINK_LIBRARIES(tests "pthread")
+	TARGET_LINK_LIBRARIES(tests "uuid")
 	ADD_DEFINITIONS(-fPIC)
 ENDIF(UNIX)
 

zone/client_packet.cpp

@@ -41,7 +41,6 @@
 #include "../common/data_verification.h"
 #include "../common/faction.h"
 #include "../common/guilds.h"
-#include "../common/rdtsc.h"
 #include "../common/rulesys.h"
 #include "../common/skills.h"
 #include "../common/spdat.h"
@@ -11968,8 +11967,6 @@ void Client::Handle_OP_ShopPlayerBuy(const EQApplicationPacket *app)
 			sizeof(Merchant_Sell_Struct), app->size);
 		return;
 	}
-	RDTSC_Timer t1;
-	t1.start();
 	Merchant_Sell_Struct* mp = (Merchant_Sell_Struct*)app->pBuffer;
 #if EQDEBUG >= 5
 	Log.Out(Logs::General, Logs::None, "%s, purchase item..", GetName());
@@ -12220,8 +12217,6 @@ void Client::Handle_OP_ShopPlayerBuy(const EQApplicationPacket *app)
 			DiscoverItem(item_id);
 	}
 
-	t1.stop();
-	std::cout << "At 1: " << t1.getDuration() << std::endl;
 	return;
 }
 void Client::Handle_OP_ShopPlayerSell(const EQApplicationPacket *app)
@@ -12231,7 +12226,6 @@ void Client::Handle_OP_ShopPlayerSell(const EQApplicationPacket *app)
 			sizeof(Merchant_Purchase_Struct), app->size);
 		return;
 	}
-	RDTSC_Timer t1(true);
 	Merchant_Purchase_Struct* mp = (Merchant_Purchase_Struct*)app->pBuffer;
 
 	Mob* vendor = entity_list.GetMob(mp->npcid);
@@ -12373,10 +12367,7 @@ void Client::Handle_OP_ShopPlayerSell(const EQApplicationPacket *app)
 	QueuePacket(outapp);
 	safe_delete(outapp);
 	SendMoneyUpdate();
-	t1.start();
 	Save(1);
-	t1.stop();
-	std::cout << "Save took: " << t1.getDuration() << std::endl;
 	return;
 }