PacketLog Class Reference

#include "PacketLog.h"

Public Member Functions
void	Initialize ()
bool	CanLogPacket () const
void	LogPacket (WorldPacket const &packet, Direction direction, boost::asio::ip::address const &addr, uint16 port)

Static Public Member Functions
static PacketLog *	instance ()

Private Member Functions
	PacketLog ()
	~PacketLog ()

Private Attributes
std::mutex	_logPacketLock
std::once_flag	_initializeFlag
FILE *	_file

Detailed Description

Constructor & Destructor Documentation

PacketLog()

PacketLog::PacketLog ( )

private

                     : _file(nullptr)
{
    std::call_once(_initializeFlag, &PacketLog::Initialize, this);
}

References _initializeFlag, and Initialize().

~PacketLog()

PacketLog::~PacketLog ( )

private

{
    if (_file)
    {
        fclose(_file);
    }
 
    _file = nullptr;
}

References _file.

Member Function Documentation

CanLogPacket()

bool PacketLog::CanLogPacket ( ) const

inline

{ return (_file != nullptr); }

Referenced by Initialize().

Initialize()

void PacketLog::Initialize

(

)

{
    std::string logsDir = sConfigMgr->GetOption<std::string>("LogsDir", "");
 
    if (!logsDir.empty() && (logsDir.at(logsDir.length() - 1) != '/') && (logsDir.at(logsDir.length() - 1) != '\\'))
    {
        logsDir.push_back('/');
    }
 
    std::string logname = sConfigMgr->GetOption<std::string>("PacketLogFile", "");
    if (!logname.empty())
    {
        _file = fopen((logsDir + logname).c_str(), "wb");
 
        LogHeader header;
        header.Signature[0] = 'P'; header.Signature[1] = 'K'; header.Signature[2] = 'T';
        header.FormatVersion = 0x0301;
        header.SnifferId = 'T';
        header.Build = 12340;
        header.Locale[0] = 'e'; header.Locale[1] = 'n'; header.Locale[2] = 'U'; header.Locale[3] = 'S';
        std::memset(header.SessionKey, 0, sizeof(header.SessionKey));
        header.SniffStartUnixtime = GameTime::GetGameTime().count();
        header.SniffStartTicks = getMSTime();
        header.OptionalDataSize = 0;
 
        if (CanLogPacket())
        {
            fwrite(&header, sizeof(header), 1, _file);
        }
    }
}

References _file, LogHeader::Build, CanLogPacket(), LogHeader::FormatVersion, GameTime::GetGameTime(), getMSTime(), LogHeader::Locale, LogHeader::OptionalDataSize, sConfigMgr, LogHeader::SessionKey, LogHeader::Signature, LogHeader::SnifferId, LogHeader::SniffStartTicks, and LogHeader::SniffStartUnixtime.

Referenced by PacketLog().

instance()

PacketLog * PacketLog::instance ( )

static

{
    static PacketLog instance;
    return &instance;
}

References instance().

Referenced by instance().

LogPacket()

void PacketLog::LogPacket	(	WorldPacket const &	packet,
		Direction	direction,
		boost::asio::ip::address const &	addr,
		uint16	port
	)

{
    std::lock_guard<std::mutex> lock(_logPacketLock);
 
    PacketHeader header;
    header.Direction = direction == CLIENT_TO_SERVER ? 0x47534d43 : 0x47534d53;
    header.ConnectionId = 0;
    header.ArrivalTicks = getMSTime();
 
    header.OptionalDataSize = sizeof(header.OptionalData);
    memset(header.OptionalData.SocketIPBytes, 0, sizeof(header.OptionalData.SocketIPBytes));
 
    if (addr.is_v4())
    {
        auto bytes = addr.to_v4().to_bytes();
        memcpy(header.OptionalData.SocketIPBytes, bytes.data(), bytes.size());
    }
    else if (addr.is_v6())
    {
        auto bytes = addr.to_v6().to_bytes();
        memcpy(header.OptionalData.SocketIPBytes, bytes.data(), bytes.size());
    }
 
    header.OptionalData.SocketPort = port;
    header.Length = packet.size() + sizeof(header.Opcode);
    header.Opcode = packet.GetOpcode();
 
    fwrite(&header, sizeof(header), 1, _file);
 
    if (!packet.empty())
    {
        fwrite(packet.contents(), 1, packet.size(), _file);
    }
 
    fflush(_file);
}

References _file, _logPacketLock, PacketHeader::ArrivalTicks, CLIENT_TO_SERVER, PacketHeader::ConnectionId, ByteBuffer::contents(), PacketHeader::Direction, ByteBuffer::empty(), getMSTime(), WorldPacket::GetOpcode(), PacketHeader::Length, PacketHeader::Opcode, PacketHeader::OptionalData, PacketHeader::OptionalDataSize, ByteBuffer::size(), PacketHeader::OptionalData::SocketIPBytes, and PacketHeader::OptionalData::SocketPort.

Member Data Documentation

_file

FILE* PacketLog::_file

private

Referenced by Initialize(), LogPacket(), and ~PacketLog().

_initializeFlag

std::once_flag PacketLog::_initializeFlag

private

Referenced by PacketLog().

_logPacketLock

std::mutex PacketLog::_logPacketLock

private

Referenced by LogPacket().