mirror of
https://github.com/EQEmu/Server.git
synced 2025-12-11 21:01:29 +00:00
566 lines
15 KiB
C++
566 lines
15 KiB
C++
#include <iostream>
|
|
#include <string>
|
|
|
|
#ifdef _WINDOWS
|
|
#include <process.h>
|
|
|
|
#define snprintf _snprintf
|
|
#define vsnprintf _vsnprintf
|
|
#define strncasecmp _strnicmp
|
|
#define strcasecmp _stricmp
|
|
|
|
#include <conio.h>
|
|
#include <iostream>
|
|
#include <dos.h>
|
|
|
|
namespace ConsoleColor {
|
|
enum Colors {
|
|
Black = 0,
|
|
Blue = 1,
|
|
Green = 2,
|
|
Cyan = 3,
|
|
Red = 4,
|
|
Magenta = 5,
|
|
Brown = 6,
|
|
LightGray = 7,
|
|
DarkGray = 8,
|
|
LightBlue = 9,
|
|
LightGreen = 10,
|
|
LightCyan = 11,
|
|
LightRed = 12,
|
|
LightMagenta = 13,
|
|
Yellow = 14,
|
|
White = 15,
|
|
};
|
|
}
|
|
|
|
#else
|
|
|
|
#include <sys/types.h>
|
|
#include <unistd.h>
|
|
|
|
#endif
|
|
|
|
#include "debug.h"
|
|
#include "misc_functions.h"
|
|
#include "platform.h"
|
|
|
|
#ifndef va_copy
|
|
#define va_copy(d,s) ((d) = (s))
|
|
#endif
|
|
|
|
static volatile bool logFileValid = false;
|
|
static EQEmuLog realLogFile;
|
|
EQEmuLog *LogFile = &realLogFile;
|
|
|
|
static const char* FileNames[EQEmuLog::MaxLogID] = { "logs/eqemu", "logs/eqemu", "logs/eqemu_error", "logs/eqemu_debug", "logs/eqemu_quest", "logs/eqemu_commands", "logs/crash" };
|
|
static const char* LogNames[EQEmuLog::MaxLogID] = { "Status", "Normal", "Error", "Debug", "Quest", "Command", "Crash" };
|
|
|
|
EQEmuLog::EQEmuLog()
|
|
{
|
|
for (int i = 0; i < MaxLogID; i++) {
|
|
fp[i] = 0;
|
|
logCallbackFmt[i] = nullptr;
|
|
logCallbackBuf[i] = nullptr;
|
|
logCallbackPva[i] = nullptr;
|
|
}
|
|
pLogStatus[EQEmuLog::LogIDs::Status] = LOG_LEVEL_STATUS;
|
|
pLogStatus[EQEmuLog::LogIDs::Normal] = LOG_LEVEL_NORMAL;
|
|
pLogStatus[EQEmuLog::LogIDs::Error] = LOG_LEVEL_ERROR;
|
|
pLogStatus[EQEmuLog::LogIDs::Debug] = LOG_LEVEL_DEBUG;
|
|
pLogStatus[EQEmuLog::LogIDs::Quest] = LOG_LEVEL_QUEST;
|
|
pLogStatus[EQEmuLog::LogIDs::Commands] = LOG_LEVEL_COMMANDS;
|
|
pLogStatus[EQEmuLog::LogIDs::Crash] = LOG_LEVEL_CRASH;
|
|
logFileValid = true;
|
|
}
|
|
|
|
EQEmuLog::~EQEmuLog()
|
|
{
|
|
logFileValid = false;
|
|
for (int i = 0; i < MaxLogID; i++) {
|
|
LockMutex lock(&MLog[i]); //to prevent termination race
|
|
if (fp[i]) {
|
|
fclose(fp[i]);
|
|
}
|
|
}
|
|
}
|
|
|
|
bool EQEmuLog::open(LogIDs id)
|
|
{
|
|
if (!logFileValid) {
|
|
return false;
|
|
}
|
|
if (id >= MaxLogID) {
|
|
return false;
|
|
}
|
|
LockMutex lock(&MOpen);
|
|
if (pLogStatus[id] & 4) {
|
|
return false;
|
|
}
|
|
if (fp[id]) {
|
|
//cerr<<"Warning: LogFile already open"<<endl;
|
|
return true;
|
|
}
|
|
char exename[200] = "";
|
|
const EQEmuExePlatform &platform = GetExecutablePlatform();
|
|
if (platform == ExePlatformWorld) {
|
|
snprintf(exename, sizeof(exename), "_world");
|
|
} else if (platform == ExePlatformZone) {
|
|
snprintf(exename, sizeof(exename), "_zone");
|
|
} else if (platform == ExePlatformLaunch) {
|
|
snprintf(exename, sizeof(exename), "_launch");
|
|
} else if (platform == ExePlatformUCS) {
|
|
snprintf(exename, sizeof(exename), "_ucs");
|
|
} else if (platform == ExePlatformQueryServ) {
|
|
snprintf(exename, sizeof(exename), "_queryserv");
|
|
} else if (platform == ExePlatformSharedMemory) {
|
|
snprintf(exename, sizeof(exename), "_shared_memory");
|
|
} else if (platform == ExePlatformClientImport) {
|
|
snprintf(exename, sizeof(exename), "_import");
|
|
} else if (platform == ExePlatformClientExport) {
|
|
snprintf(exename, sizeof(exename), "_export");
|
|
}
|
|
char filename[200];
|
|
#ifndef NO_PIDLOG
|
|
snprintf(filename, sizeof(filename), "%s%s_%04i.log", FileNames[id], exename, getpid());
|
|
#else
|
|
snprintf(filename, sizeof(filename), "%s%s.log", FileNames[id], exename);
|
|
#endif
|
|
fp[id] = fopen(filename, "a");
|
|
if (!fp[id]) {
|
|
std::cerr << "Failed to open log file: " << filename << std::endl;
|
|
pLogStatus[id] |= 4; // set file state to error
|
|
return false;
|
|
}
|
|
fputs("---------------------------------------------\n", fp[id]);
|
|
write(id, "Starting Log: %s", filename);
|
|
return true;
|
|
}
|
|
|
|
bool EQEmuLog::write(LogIDs id, const char *fmt, ...)
|
|
{
|
|
if (!logFileValid) {
|
|
return false;
|
|
}
|
|
if (id >= MaxLogID) {
|
|
return false;
|
|
}
|
|
bool dofile = false;
|
|
if (pLogStatus[id] & 1) {
|
|
dofile = open(id);
|
|
}
|
|
if (!(dofile || pLogStatus[id] & 2)) {
|
|
return false;
|
|
}
|
|
LockMutex lock(&MLog[id]);
|
|
if (!logFileValid) {
|
|
return false; //check again for threading race reasons (to avoid two mutexes)
|
|
}
|
|
time_t aclock;
|
|
struct tm *newtime;
|
|
time( &aclock ); /* Get time in seconds */
|
|
newtime = localtime( &aclock ); /* Convert time to struct */
|
|
if (dofile)
|
|
#ifndef NO_PIDLOG
|
|
fprintf(fp[id], "[%02d.%02d. - %02d:%02d:%02d] ", newtime->tm_mon + 1, newtime->tm_mday, newtime->tm_hour, newtime->tm_min, newtime->tm_sec);
|
|
#else
|
|
fprintf(fp[id], "%04i [%02d.%02d. - %02d:%02d:%02d] ", getpid(), newtime->tm_mon + 1, newtime->tm_mday, newtime->tm_hour, newtime->tm_min, newtime->tm_sec);
|
|
#endif
|
|
va_list argptr, tmpargptr;
|
|
va_start(argptr, fmt);
|
|
if (dofile) {
|
|
va_copy(tmpargptr, argptr);
|
|
vfprintf( fp[id], fmt, tmpargptr );
|
|
}
|
|
if (logCallbackFmt[id]) {
|
|
msgCallbackFmt p = logCallbackFmt[id];
|
|
va_copy(tmpargptr, argptr);
|
|
p(id, fmt, tmpargptr );
|
|
}
|
|
if (pLogStatus[id] & 2) {
|
|
if (pLogStatus[id] & 8) {
|
|
fprintf(stderr, "[%s] ", LogNames[id]);
|
|
vfprintf( stderr, fmt, argptr );
|
|
}
|
|
/* This is what's outputted to console */
|
|
else {
|
|
|
|
#ifdef _WINDOWS
|
|
HANDLE console_handle;
|
|
console_handle = GetStdHandle(STD_OUTPUT_HANDLE);
|
|
|
|
CONSOLE_FONT_INFOEX info = { 0 };
|
|
info.cbSize = sizeof(info);
|
|
info.dwFontSize.Y = 12; // leave X as zero
|
|
info.FontWeight = FW_NORMAL;
|
|
wcscpy(info.FaceName, L"Lucida Console");
|
|
SetCurrentConsoleFontEx(console_handle, NULL, &info);
|
|
|
|
if (id == EQEmuLog::LogIDs::Status){ SetConsoleTextAttribute(console_handle, ConsoleColor::Colors::Yellow); }
|
|
if (id == EQEmuLog::LogIDs::Error){ SetConsoleTextAttribute(console_handle, ConsoleColor::Colors::LightRed); }
|
|
if (id == EQEmuLog::LogIDs::Normal){ SetConsoleTextAttribute(console_handle, ConsoleColor::Colors::LightGreen); }
|
|
if (id == EQEmuLog::LogIDs::Debug){ SetConsoleTextAttribute(console_handle, ConsoleColor::Colors::Yellow); }
|
|
if (id == EQEmuLog::LogIDs::Quest){ SetConsoleTextAttribute(console_handle, ConsoleColor::Colors::LightCyan); }
|
|
if (id == EQEmuLog::LogIDs::Commands){ SetConsoleTextAttribute(console_handle, ConsoleColor::Colors::LightMagenta); }
|
|
if (id == EQEmuLog::LogIDs::Crash){ SetConsoleTextAttribute(console_handle, ConsoleColor::Colors::LightRed); }
|
|
#endif
|
|
|
|
fprintf(stdout, "[%s] ", LogNames[id]);
|
|
vfprintf( stdout, fmt, argptr );
|
|
|
|
#ifdef _WINDOWS
|
|
/* Always set back to white*/
|
|
SetConsoleTextAttribute(console_handle, ConsoleColor::Colors::White);
|
|
#endif
|
|
}
|
|
}
|
|
va_end(argptr);
|
|
if (dofile) {
|
|
fprintf(fp[id], "\n");
|
|
}
|
|
|
|
/* Print Lind Endings */
|
|
if (pLogStatus[id] & 2) {
|
|
if (pLogStatus[id] & 8) {
|
|
fprintf(stderr, "\n");
|
|
fflush(stderr);
|
|
} else {
|
|
fprintf(stdout, "\n");
|
|
fflush(stdout);
|
|
}
|
|
}
|
|
if (dofile) {
|
|
fflush(fp[id]);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
//write with Prefix and a VA_list
|
|
bool EQEmuLog::writePVA(LogIDs id, const char *prefix, const char *fmt, va_list argptr)
|
|
{
|
|
if (!logFileValid) {
|
|
return false;
|
|
}
|
|
if (id >= MaxLogID) {
|
|
return false;
|
|
}
|
|
bool dofile = false;
|
|
if (pLogStatus[id] & 1) {
|
|
dofile = open(id);
|
|
}
|
|
if (!(dofile || pLogStatus[id] & 2)) {
|
|
return false;
|
|
}
|
|
LockMutex lock(&MLog[id]);
|
|
if (!logFileValid) {
|
|
return false; //check again for threading race reasons (to avoid two mutexes)
|
|
}
|
|
time_t aclock;
|
|
struct tm *newtime;
|
|
time( &aclock ); /* Get time in seconds */
|
|
newtime = localtime( &aclock ); /* Convert time to struct */
|
|
va_list tmpargptr;
|
|
if (dofile) {
|
|
#ifndef NO_PIDLOG
|
|
fprintf(fp[id], "[%02d.%02d. - %02d:%02d:%02d] %s", newtime->tm_mon + 1, newtime->tm_mday, newtime->tm_hour, newtime->tm_min, newtime->tm_sec, prefix);
|
|
#else
|
|
fprintf(fp[id], "%04i [%02d.%02d. - %02d:%02d:%02d] %s", getpid(), newtime->tm_mon + 1, newtime->tm_mday, newtime->tm_hour, newtime->tm_min, newtime->tm_sec, prefix);
|
|
#endif
|
|
va_copy(tmpargptr, argptr);
|
|
vfprintf( fp[id], fmt, tmpargptr );
|
|
}
|
|
if (logCallbackPva[id]) {
|
|
msgCallbackPva p = logCallbackPva[id];
|
|
va_copy(tmpargptr, argptr);
|
|
p(id, prefix, fmt, tmpargptr );
|
|
}
|
|
if (pLogStatus[id] & 2) {
|
|
if (pLogStatus[id] & 8) {
|
|
fprintf(stderr, "[%s] %s", LogNames[id], prefix);
|
|
vfprintf( stderr, fmt, argptr );
|
|
}
|
|
/* Console Output */
|
|
else {
|
|
|
|
|
|
#ifdef _WINDOWS
|
|
HANDLE console_handle;
|
|
console_handle = GetStdHandle(STD_OUTPUT_HANDLE);
|
|
|
|
CONSOLE_FONT_INFOEX info = { 0 };
|
|
info.cbSize = sizeof(info);
|
|
info.dwFontSize.Y = 12; // leave X as zero
|
|
info.FontWeight = FW_NORMAL;
|
|
wcscpy(info.FaceName, L"Lucida Console");
|
|
SetCurrentConsoleFontEx(console_handle, NULL, &info);
|
|
|
|
if (id == EQEmuLog::LogIDs::Status){ SetConsoleTextAttribute(console_handle, ConsoleColor::Colors::Yellow); }
|
|
if (id == EQEmuLog::LogIDs::Error){ SetConsoleTextAttribute(console_handle, ConsoleColor::Colors::LightRed); }
|
|
if (id == EQEmuLog::LogIDs::Normal){ SetConsoleTextAttribute(console_handle, ConsoleColor::Colors::LightGreen); }
|
|
if (id == EQEmuLog::LogIDs::Debug){ SetConsoleTextAttribute(console_handle, ConsoleColor::Colors::Yellow); }
|
|
if (id == EQEmuLog::LogIDs::Quest){ SetConsoleTextAttribute(console_handle, ConsoleColor::Colors::LightCyan); }
|
|
if (id == EQEmuLog::LogIDs::Commands){ SetConsoleTextAttribute(console_handle, ConsoleColor::Colors::LightMagenta); }
|
|
if (id == EQEmuLog::LogIDs::Crash){ SetConsoleTextAttribute(console_handle, ConsoleColor::Colors::LightRed); }
|
|
#endif
|
|
|
|
fprintf(stdout, "[%s] %s", LogNames[id], prefix);
|
|
vfprintf(stdout, fmt, argptr);
|
|
|
|
#ifdef _WINDOWS
|
|
/* Always set back to white*/
|
|
SetConsoleTextAttribute(console_handle, ConsoleColor::Colors::White);
|
|
#endif
|
|
}
|
|
}
|
|
va_end(argptr);
|
|
if (dofile) {
|
|
fprintf(fp[id], "\n");
|
|
}
|
|
if (pLogStatus[id] & 2) {
|
|
if (pLogStatus[id] & 8) {
|
|
fprintf(stderr, "\n");
|
|
} else {
|
|
fprintf(stdout, "\n");
|
|
}
|
|
}
|
|
if (dofile) {
|
|
fflush(fp[id]);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool EQEmuLog::writebuf(LogIDs id, const char *buf, uint8 size, uint32 count)
|
|
{
|
|
if (!logFileValid) {
|
|
return false;
|
|
}
|
|
if (id >= MaxLogID) {
|
|
return false;
|
|
}
|
|
bool dofile = false;
|
|
if (pLogStatus[id] & 1) {
|
|
dofile = open(id);
|
|
}
|
|
if (!(dofile || pLogStatus[id] & 2)) {
|
|
return false;
|
|
}
|
|
LockMutex lock(&MLog[id]);
|
|
if (!logFileValid) {
|
|
return false; //check again for threading race reasons (to avoid two mutexes)
|
|
}
|
|
time_t aclock;
|
|
struct tm *newtime;
|
|
time( &aclock ); /* Get time in seconds */
|
|
newtime = localtime( &aclock ); /* Convert time to struct */
|
|
if (dofile)
|
|
#ifndef NO_PIDLOG
|
|
fprintf(fp[id], "[%02d.%02d. - %02d:%02d:%02d] ", newtime->tm_mon + 1, newtime->tm_mday, newtime->tm_hour, newtime->tm_min, newtime->tm_sec);
|
|
#else
|
|
fprintf(fp[id], "%04i [%02d.%02d. - %02d:%02d:%02d] ", getpid(), newtime->tm_mon + 1, newtime->tm_mday, newtime->tm_hour, newtime->tm_min, newtime->tm_sec);
|
|
#endif
|
|
if (dofile) {
|
|
fwrite(buf, size, count, fp[id]);
|
|
fprintf(fp[id], "\n");
|
|
}
|
|
if (logCallbackBuf[id]) {
|
|
msgCallbackBuf p = logCallbackBuf[id];
|
|
p(id, buf, size, count);
|
|
}
|
|
if (pLogStatus[id] & 2) {
|
|
if (pLogStatus[id] & 8) {
|
|
fprintf(stderr, "[%s] ", LogNames[id]);
|
|
fwrite(buf, size, count, stderr);
|
|
fprintf(stderr, "\n");
|
|
} else {
|
|
#ifdef _WINDOWS
|
|
HANDLE console_handle;
|
|
console_handle = GetStdHandle(STD_OUTPUT_HANDLE);
|
|
|
|
CONSOLE_FONT_INFOEX info = { 0 };
|
|
info.cbSize = sizeof(info);
|
|
info.dwFontSize.Y = 12; // leave X as zero
|
|
info.FontWeight = FW_NORMAL;
|
|
wcscpy(info.FaceName, L"Lucida Console");
|
|
SetCurrentConsoleFontEx(console_handle, NULL, &info);
|
|
|
|
if (id == EQEmuLog::LogIDs::Status){ SetConsoleTextAttribute(console_handle, ConsoleColor::Colors::Yellow); }
|
|
if (id == EQEmuLog::LogIDs::Error){ SetConsoleTextAttribute(console_handle, ConsoleColor::Colors::LightRed); }
|
|
if (id == EQEmuLog::LogIDs::Normal){ SetConsoleTextAttribute(console_handle, ConsoleColor::Colors::LightGreen); }
|
|
if (id == EQEmuLog::LogIDs::Debug){ SetConsoleTextAttribute(console_handle, ConsoleColor::Colors::LightGreen); }
|
|
if (id == EQEmuLog::LogIDs::Quest){ SetConsoleTextAttribute(console_handle, ConsoleColor::Colors::LightCyan); }
|
|
if (id == EQEmuLog::LogIDs::Commands){ SetConsoleTextAttribute(console_handle, ConsoleColor::Colors::LightMagenta); }
|
|
if (id == EQEmuLog::LogIDs::Crash){ SetConsoleTextAttribute(console_handle, ConsoleColor::Colors::LightRed); }
|
|
#endif
|
|
|
|
fprintf(stdout, "[%s] ", LogNames[id]);
|
|
fwrite(buf, size, count, stdout);
|
|
fprintf(stdout, "\n");
|
|
|
|
#ifdef _WINDOWS
|
|
/* Always set back to white*/
|
|
SetConsoleTextAttribute(console_handle, ConsoleColor::Colors::White);
|
|
#endif
|
|
|
|
|
|
}
|
|
}
|
|
if (dofile) {
|
|
fflush(fp[id]);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool EQEmuLog::writeNTS(LogIDs id, bool dofile, const char *fmt, ...)
|
|
{
|
|
va_list argptr, tmpargptr;
|
|
va_start(argptr, fmt);
|
|
if (dofile) {
|
|
va_copy(tmpargptr, argptr);
|
|
vfprintf( fp[id], fmt, tmpargptr );
|
|
}
|
|
if (pLogStatus[id] & 2) {
|
|
if (pLogStatus[id] & 8) {
|
|
vfprintf( stderr, fmt, argptr );
|
|
} else {
|
|
vfprintf( stdout, fmt, argptr );
|
|
}
|
|
}
|
|
va_end(argptr);
|
|
return true;
|
|
};
|
|
|
|
bool EQEmuLog::Dump(LogIDs id, uint8* data, uint32 size, uint32 cols, uint32 skip)
|
|
{
|
|
if (!logFileValid) {
|
|
#if EQDEBUG >= 10
|
|
std::cerr << "Error: Dump() from null pointer" << std::endl;
|
|
#endif
|
|
return false;
|
|
}
|
|
if (size == 0) {
|
|
return true;
|
|
}
|
|
if (!LogFile) {
|
|
return false;
|
|
}
|
|
if (id >= MaxLogID) {
|
|
return false;
|
|
}
|
|
bool dofile = false;
|
|
if (pLogStatus[id] & 1) {
|
|
dofile = open(id);
|
|
}
|
|
if (!(dofile || pLogStatus[id] & 2)) {
|
|
return false;
|
|
}
|
|
LockMutex lock(&MLog[id]);
|
|
if (!logFileValid) {
|
|
return false; //check again for threading race reasons (to avoid two mutexes)
|
|
}
|
|
write(id, "Dumping Packet: %i", size);
|
|
// Output as HEX
|
|
int beginningOfLineOffset = 0;
|
|
uint32 indexInData;
|
|
std::string asciiOutput;
|
|
for (indexInData = skip; indexInData < size; indexInData++) {
|
|
if ((indexInData - skip) % cols == 0) {
|
|
if (indexInData != skip) {
|
|
writeNTS(id, dofile, " | %s\n", asciiOutput.c_str());
|
|
}
|
|
writeNTS(id, dofile, "%4i: ", indexInData - skip);
|
|
asciiOutput.clear();
|
|
beginningOfLineOffset = 0;
|
|
} else if ((indexInData - skip) % (cols / 2) == 0) {
|
|
writeNTS(id, dofile, "- ");
|
|
}
|
|
writeNTS(id, dofile, "%02X ", (unsigned char)data[indexInData]);
|
|
if (data[indexInData] >= 32 && data[indexInData] < 127) {
|
|
// According to http://msdn.microsoft.com/en-us/library/vstudio/ee404875(v=vs.100).aspx
|
|
// Visual Studio 2010 doesn't have std::to_string(int) but it does have the long long
|
|
// version.
|
|
asciiOutput.append(std::to_string((long long)data[indexInData]));
|
|
} else {
|
|
asciiOutput.append(".");
|
|
}
|
|
}
|
|
uint32 k = ((indexInData - skip) - 1) % cols;
|
|
if (k < 8) {
|
|
writeNTS(id, dofile, " ");
|
|
}
|
|
for (uint32 h = k + 1; h < cols; h++) {
|
|
writeNTS(id, dofile, " ");
|
|
}
|
|
writeNTS(id, dofile, " | %s\n", asciiOutput.c_str());
|
|
if (dofile) {
|
|
fflush(fp[id]);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void EQEmuLog::SetCallback(LogIDs id, msgCallbackFmt proc)
|
|
{
|
|
if (!logFileValid) {
|
|
return;
|
|
}
|
|
if (id >= MaxLogID) {
|
|
return;
|
|
}
|
|
logCallbackFmt[id] = proc;
|
|
}
|
|
|
|
void EQEmuLog::SetCallback(LogIDs id, msgCallbackBuf proc)
|
|
{
|
|
if (!logFileValid) {
|
|
return;
|
|
}
|
|
if (id >= MaxLogID) {
|
|
return;
|
|
}
|
|
logCallbackBuf[id] = proc;
|
|
}
|
|
|
|
void EQEmuLog::SetCallback(LogIDs id, msgCallbackPva proc)
|
|
{
|
|
if (!logFileValid) {
|
|
return;
|
|
}
|
|
if (id >= MaxLogID) {
|
|
return;
|
|
}
|
|
logCallbackPva[id] = proc;
|
|
}
|
|
|
|
void EQEmuLog::SetAllCallbacks(msgCallbackFmt proc)
|
|
{
|
|
if (!logFileValid) {
|
|
return;
|
|
}
|
|
int r;
|
|
for (r = Status; r < MaxLogID; r++) {
|
|
SetCallback((LogIDs)r, proc);
|
|
}
|
|
}
|
|
|
|
void EQEmuLog::SetAllCallbacks(msgCallbackBuf proc)
|
|
{
|
|
if (!logFileValid) {
|
|
return;
|
|
}
|
|
int r;
|
|
for (r = Status; r < MaxLogID; r++) {
|
|
SetCallback((LogIDs)r, proc);
|
|
}
|
|
}
|
|
|
|
void EQEmuLog::SetAllCallbacks(msgCallbackPva proc)
|
|
{
|
|
if (!logFileValid) {
|
|
return;
|
|
}
|
|
int r;
|
|
for (r = Status; r < MaxLogID; r++) {
|
|
SetCallback((LogIDs)r, proc);
|
|
}
|
|
}
|
|
|