StockTime getNextClose(const StockTime& stockTime)
{
boost::posix_time::time_duration closeTime(13, 0, 0, 0);
boost::posix_time::time_duration timeOfDay(stockTime.time_of_day());
boost::gregorian::date date(stockTime.date());
// if the time of day is after 13:00, then we at least have to go forward
// to the next day
if (timeOfDay >= closeTime)
{
date = date + boost::gregorian::date_duration(1);
}
// if we're now in a weekend, go forward to Monday
if (date.day_of_week() == boost::gregorian::Sunday)
{
date = date + boost::gregorian::date_duration(1);
}
else if (date.day_of_week() == boost::gregorian::Saturday)
{
date = date + boost::gregorian::date_duration(2);
}
// return the day we've figured out plus the closeTime as offset
return StockTime(date, closeTime);
}
StockTime getPreviousClose(const StockTime& stockTime)
{
boost::posix_time::time_duration closeTime(13, 0, 0, 0);
boost::posix_time::time_duration timeOfDay(stockTime.time_of_day());
boost::gregorian::date date(stockTime.date());
// if the time of day is before 13:00, then we at least have to back
// up to the previous day
if (timeOfDay < closeTime)
{
date = date - boost::gregorian::date_duration(1);
}
// if we're now in a weekend, back up to previous Friday
if (date.day_of_week() == boost::gregorian::Sunday)
{
date = date - boost::gregorian::date_duration(2);
}
else if (date.day_of_week() == boost::gregorian::Saturday)
{
date = date - boost::gregorian::date_duration(1);
}
// return the day we've figured out plus the closeTime as offset
return StockTime(date, closeTime);
}
int main(int argc, char **argv){
sqlite3_int64 iBegin; /* Start time of this program */
int quietFlag = 0; /* True if --quiet or -q */
int verboseFlag = 0; /* True if --verbose or -v */
char *zInsSql = 0; /* SQL statement for --load-db or --load-sql */
int iFirstInsArg = 0; /* First argv[] to use for --load-db or --load-sql */
sqlite3 *db = 0; /* The open database connection */
sqlite3_stmt *pStmt; /* A prepared statement */
int rc; /* Result code from SQLite interface calls */
Blob *pSql; /* For looping over SQL scripts */
Blob *pDb; /* For looping over template databases */
int i; /* Loop index for the argv[] loop */
int onlySqlid = -1; /* --sqlid */
int onlyDbid = -1; /* --dbid */
int nativeFlag = 0; /* --native-vfs */
int rebuildFlag = 0; /* --rebuild */
int vdbeLimitFlag = 0; /* --limit-vdbe */
int timeoutTest = 0; /* undocumented --timeout-test flag */
int runFlags = 0; /* Flags sent to runSql() */
char *zMsg = 0; /* Add this message */
int nSrcDb = 0; /* Number of source databases */
char **azSrcDb = 0; /* Array of source database names */
int iSrcDb; /* Loop over all source databases */
int nTest = 0; /* Total number of tests performed */
char *zDbName = ""; /* Appreviated name of a source database */
const char *zFailCode = 0; /* Value of the TEST_FAILURE environment variable */
int cellSzCkFlag = 0; /* --cell-size-check */
int sqlFuzz = 0; /* True for SQL fuzz testing. False for DB fuzz */
int iTimeout = 120; /* Default 120-second timeout */
int nMem = 0; /* Memory limit */
char *zExpDb = 0; /* Write Databases to files in this directory */
char *zExpSql = 0; /* Write SQL to files in this directory */
iBegin = timeOfDay();
#ifdef __unix__
signal(SIGALRM, timeoutHandler);
#endif
g.zArgv0 = argv[0];
zFailCode = getenv("TEST_FAILURE");
for(i=1; i<argc; i++){
const char *z = argv[i];
if( z[0]=='-' ){
z++;
if( z[0]=='-' ) z++;
if( strcmp(z,"cell-size-check")==0 ){
cellSzCkFlag = 1;
}else
if( strcmp(z,"dbid")==0 ){
if( i>=argc-1 ) fatalError("missing arguments on %s", argv[i]);
onlyDbid = integerValue(argv[++i]);
}else
if( strcmp(z,"export-db")==0 ){
if( i>=argc-1 ) fatalError("missing arguments on %s", argv[i]);
zExpDb = argv[++i];
}else
if( strcmp(z,"export-sql")==0 ){
if( i>=argc-1 ) fatalError("missing arguments on %s", argv[i]);
zExpSql = argv[++i];
}else
if( strcmp(z,"help")==0 ){
showHelp();
return 0;
}else
if( strcmp(z,"limit-mem")==0 ){
if( i>=argc-1 ) fatalError("missing arguments on %s", argv[i]);
nMem = integerValue(argv[++i]);
}else
if( strcmp(z,"limit-vdbe")==0 ){
vdbeLimitFlag = 1;
}else
if( strcmp(z,"load-sql")==0 ){
zInsSql = "INSERT INTO xsql(sqltext) VALUES(CAST(readfile(?1) AS text))";
iFirstInsArg = i+1;
break;
}else
if( strcmp(z,"load-db")==0 ){
zInsSql = "INSERT INTO db(dbcontent) VALUES(readfile(?1))";
iFirstInsArg = i+1;
break;
}else
if( strcmp(z,"m")==0 ){
if( i>=argc-1 ) fatalError("missing arguments on %s", argv[i]);
zMsg = argv[++i];
}else
if( strcmp(z,"native-vfs")==0 ){
nativeFlag = 1;
}else
if( strcmp(z,"quiet")==0 || strcmp(z,"q")==0 ){
quietFlag = 1;
verboseFlag = 0;
}else
if( strcmp(z,"rebuild")==0 ){
rebuildFlag = 1;
}else
if( strcmp(z,"result-trace")==0 ){
runFlags |= SQL_OUTPUT;
}else
if( strcmp(z,"sqlid")==0 ){
if( i>=argc-1 ) fatalError("missing arguments on %s", argv[i]);
onlySqlid = integerValue(argv[++i]);
}else
if( strcmp(z,"timeout")==0 ){
if( i>=argc-1 ) fatalError("missing arguments on %s", argv[i]);
iTimeout = integerValue(argv[++i]);
}else
if( strcmp(z,"timeout-test")==0 ){
timeoutTest = 1;
#ifndef __unix__
fatalError("timeout is not available on non-unix systems");
#endif
}else
if( strcmp(z,"verbose")==0 || strcmp(z,"v")==0 ){
quietFlag = 0;
verboseFlag = 1;
runFlags |= SQL_TRACE;
}else
{
fatalError("unknown option: %s", argv[i]);
}
}else{
nSrcDb++;
azSrcDb = safe_realloc(azSrcDb, nSrcDb*sizeof(azSrcDb[0]));
azSrcDb[nSrcDb-1] = argv[i];
}
}
if( nSrcDb==0 ) fatalError("no source database specified");
if( nSrcDb>1 ){
if( zMsg ){
fatalError("cannot change the description of more than one database");
}
if( zInsSql ){
fatalError("cannot import into more than one database");
}
}
/* Process each source database separately */
for(iSrcDb=0; iSrcDb<nSrcDb; iSrcDb++){
rc = sqlite3_open(azSrcDb[iSrcDb], &db);
if( rc ){
fatalError("cannot open source database %s - %s",
azSrcDb[iSrcDb], sqlite3_errmsg(db));
}
rc = sqlite3_exec(db,
"CREATE TABLE IF NOT EXISTS db(\n"
" dbid INTEGER PRIMARY KEY, -- database id\n"
" dbcontent BLOB -- database disk file image\n"
");\n"
"CREATE TABLE IF NOT EXISTS xsql(\n"
" sqlid INTEGER PRIMARY KEY, -- SQL script id\n"
" sqltext TEXT -- Text of SQL statements to run\n"
");"
"CREATE TABLE IF NOT EXISTS readme(\n"
" msg TEXT -- Human-readable description of this file\n"
");", 0, 0, 0);
if( rc ) fatalError("cannot create schema: %s", sqlite3_errmsg(db));
if( zMsg ){
char *zSql;
zSql = sqlite3_mprintf(
"DELETE FROM readme; INSERT INTO readme(msg) VALUES(%Q)", zMsg);
rc = sqlite3_exec(db, zSql, 0, 0, 0);
sqlite3_free(zSql);
if( rc ) fatalError("cannot change description: %s", sqlite3_errmsg(db));
}
if( zInsSql ){
sqlite3_create_function(db, "readfile", 1, SQLITE_UTF8, 0,
readfileFunc, 0, 0);
rc = sqlite3_prepare_v2(db, zInsSql, -1, &pStmt, 0);
if( rc ) fatalError("cannot prepare statement [%s]: %s",
zInsSql, sqlite3_errmsg(db));
rc = sqlite3_exec(db, "BEGIN", 0, 0, 0);
if( rc ) fatalError("cannot start a transaction");
for(i=iFirstInsArg; i<argc; i++){
sqlite3_bind_text(pStmt, 1, argv[i], -1, SQLITE_STATIC);
sqlite3_step(pStmt);
rc = sqlite3_reset(pStmt);
if( rc ) fatalError("insert failed for %s", argv[i]);
}
sqlite3_finalize(pStmt);
rc = sqlite3_exec(db, "COMMIT", 0, 0, 0);
if( rc ) fatalError("cannot commit the transaction: %s", sqlite3_errmsg(db));
rebuild_database(db);
sqlite3_close(db);
return 0;
}
if( zExpDb!=0 || zExpSql!=0 ){
sqlite3_create_function(db, "writefile", 2, SQLITE_UTF8, 0,
writefileFunc, 0, 0);
if( zExpDb!=0 ){
const char *zExDb =
"SELECT writefile(printf('%s/db%06d.db',?1,dbid),dbcontent),"
" dbid, printf('%s/db%06d.db',?1,dbid), length(dbcontent)"
" FROM db WHERE ?2<0 OR dbid=?2;";
rc = sqlite3_prepare_v2(db, zExDb, -1, &pStmt, 0);
if( rc ) fatalError("cannot prepare statement [%s]: %s",
zExDb, sqlite3_errmsg(db));
sqlite3_bind_text64(pStmt, 1, zExpDb, strlen(zExpDb),
SQLITE_STATIC, SQLITE_UTF8);
sqlite3_bind_int(pStmt, 2, onlyDbid);
while( sqlite3_step(pStmt)==SQLITE_ROW ){
printf("write db-%d (%d bytes) into %s\n",
sqlite3_column_int(pStmt,1),
sqlite3_column_int(pStmt,3),
sqlite3_column_text(pStmt,2));
}
sqlite3_finalize(pStmt);
}
if( zExpSql!=0 ){
const char *zExSql =
"SELECT writefile(printf('%s/sql%06d.txt',?1,sqlid),sqltext),"
" sqlid, printf('%s/sql%06d.txt',?1,sqlid), length(sqltext)"
" FROM xsql WHERE ?2<0 OR sqlid=?2;";
rc = sqlite3_prepare_v2(db, zExSql, -1, &pStmt, 0);
if( rc ) fatalError("cannot prepare statement [%s]: %s",
zExSql, sqlite3_errmsg(db));
sqlite3_bind_text64(pStmt, 1, zExpSql, strlen(zExpSql),
SQLITE_STATIC, SQLITE_UTF8);
sqlite3_bind_int(pStmt, 2, onlySqlid);
while( sqlite3_step(pStmt)==SQLITE_ROW ){
printf("write sql-%d (%d bytes) into %s\n",
sqlite3_column_int(pStmt,1),
sqlite3_column_int(pStmt,3),
sqlite3_column_text(pStmt,2));
}
sqlite3_finalize(pStmt);
}
sqlite3_close(db);
return 0;
}
/* Load all SQL script content and all initial database images from the
** source db
*/
blobListLoadFromDb(db, "SELECT sqlid, sqltext FROM xsql", onlySqlid,
&g.nSql, &g.pFirstSql);
if( g.nSql==0 ) fatalError("need at least one SQL script");
blobListLoadFromDb(db, "SELECT dbid, dbcontent FROM db", onlyDbid,
&g.nDb, &g.pFirstDb);
if( g.nDb==0 ){
g.pFirstDb = safe_realloc(0, sizeof(Blob));
memset(g.pFirstDb, 0, sizeof(Blob));
g.pFirstDb->id = 1;
g.pFirstDb->seq = 0;
g.nDb = 1;
sqlFuzz = 1;
}
/* Print the description, if there is one */
if( !quietFlag ){
int i;
zDbName = azSrcDb[iSrcDb];
i = strlen(zDbName) - 1;
while( i>0 && zDbName[i-1]!='/' && zDbName[i-1]!='\\' ){ i--; }
zDbName += i;
sqlite3_prepare_v2(db, "SELECT msg FROM readme", -1, &pStmt, 0);
if( pStmt && sqlite3_step(pStmt)==SQLITE_ROW ){
printf("%s: %s\n", zDbName, sqlite3_column_text(pStmt,0));
}
sqlite3_finalize(pStmt);
}
/* Rebuild the database, if requested */
if( rebuildFlag ){
if( !quietFlag ){
printf("%s: rebuilding... ", zDbName);
fflush(stdout);
}
rebuild_database(db);
if( !quietFlag ) printf("done\n");
}
/* Close the source database. Verify that no SQLite memory allocations are
** outstanding.
*/
sqlite3_close(db);
if( sqlite3_memory_used()>0 ){
fatalError("SQLite has memory in use before the start of testing");
}
/* Limit available memory, if requested */
if( nMem>0 ){
void *pHeap;
sqlite3_shutdown();
pHeap = malloc(nMem);
if( pHeap==0 ){
fatalError("failed to allocate %d bytes of heap memory", nMem);
}
sqlite3_config(SQLITE_CONFIG_HEAP, pHeap, nMem, 128);
}
/* Register the in-memory virtual filesystem
*/
formatVfs();
inmemVfsRegister();
/* Run a test using each SQL script against each database.
*/
if( !verboseFlag && !quietFlag ) printf("%s:", zDbName);
for(pSql=g.pFirstSql; pSql; pSql=pSql->pNext){
for(pDb=g.pFirstDb; pDb; pDb=pDb->pNext){
int openFlags;
const char *zVfs = "inmem";
sqlite3_snprintf(sizeof(g.zTestName), g.zTestName, "sqlid=%d,dbid=%d",
pSql->id, pDb->id);
if( verboseFlag ){
printf("%s\n", g.zTestName);
fflush(stdout);
}else if( !quietFlag ){
static int prevAmt = -1;
int idx = pSql->seq*g.nDb + pDb->id - 1;
int amt = idx*10/(g.nDb*g.nSql);
if( amt!=prevAmt ){
printf(" %d%%", amt*10);
fflush(stdout);
prevAmt = amt;
}
}
createVFile("main.db", pDb->sz, pDb->a);
openFlags = SQLITE_OPEN_CREATE | SQLITE_OPEN_READWRITE;
if( nativeFlag && pDb->sz==0 ){
openFlags |= SQLITE_OPEN_MEMORY;
zVfs = 0;
}
rc = sqlite3_open_v2("main.db", &db, openFlags, zVfs);
if( rc ) fatalError("cannot open inmem database");
#ifdef SQLITE_ENABLE_JSON1
{
extern int sqlite3_json_init(sqlite3*);
sqlite3_json_init(db);
}
#endif
if( cellSzCkFlag ) runSql(db, "PRAGMA cell_size_check=ON", runFlags);
setAlarm(iTimeout);
#ifndef SQLITE_OMIT_PROGRESS_CALLBACK
if( sqlFuzz || vdbeLimitFlag ){
sqlite3_progress_handler(db, 100000, progressHandler, &vdbeLimitFlag);
}
#endif
do{
runSql(db, (char*)pSql->a, runFlags);
}while( timeoutTest );
setAlarm(0);
sqlite3_close(db);
if( sqlite3_memory_used()>0 ) fatalError("memory leak");
reformatVfs();
nTest++;
g.zTestName[0] = 0;
/* Simulate an error if the TEST_FAILURE environment variable is "5".
** This is used to verify that automated test script really do spot
** errors that occur in this test program.
*/
if( zFailCode ){
if( zFailCode[0]=='5' && zFailCode[1]==0 ){
fatalError("simulated failure");
}else if( zFailCode[0]!=0 ){
/* If TEST_FAILURE is something other than 5, just exit the test
** early */
printf("\nExit early due to TEST_FAILURE being set\n");
iSrcDb = nSrcDb-1;
goto sourcedb_cleanup;
}
}
}
}
if( !quietFlag && !verboseFlag ){
printf(" 100%% - %d tests\n", g.nDb*g.nSql);
}
/* Clean up at the end of processing a single source database
*/
sourcedb_cleanup:
blobListFree(g.pFirstSql);
blobListFree(g.pFirstDb);
reformatVfs();
} /* End loop over all source databases */
if( !quietFlag ){
sqlite3_int64 iElapse = timeOfDay() - iBegin;
printf("fuzzcheck: 0 errors out of %d tests in %d.%03d seconds\n"
"SQLite %s %s\n",
nTest, (int)(iElapse/1000), (int)(iElapse%1000),
sqlite3_libversion(), sqlite3_sourceid());
}
free(azSrcDb);
return 0;
}
///////////////////////////////////////////
// Dispatches Zone data packets based on the opCode
void EQPacket::dispatchZoneData(const uint8_t *data, size_t len,
uint8_t dir, uint16_t opCode)
{
#ifdef DEBUG_PACKET
debug ("dispatchZoneData()");
#endif /* DEBUG_PACKET */
QString tempStr;
bool unk = true;
switch (opCode)
{
case OP_ClientUpdate: // old PlayerPosCode:
{
#ifdef PACKET_PAYLOAD_SIZE_DIAG
if ((len != sizeof(playerSpawnPosStruct)) &&
(len != sizeof(playerSelfPosStruct)))
{
fprintf(stderr, "WARNING: OP_ClientUpdate (%04x) (dataLen: %d != sizeof(playerSpawnPosStruct):%d or sizeof(playerSpawnSelfStruct):%d)\n",
OP_ClientUpdate, len,
sizeof(playerSpawnPosStruct), sizeof(playerSelfPosStruct));
unk = true;
}
else
unk = false;
#else
unk = false;
#endif
if (len == sizeof(playerSpawnPosStruct))
emit playerUpdate((const playerSpawnPosStruct*)data, len, dir);
else if (len == sizeof(playerSelfPosStruct))
emit playerUpdate((const playerSelfPosStruct*)data, len, dir);
else
unk = true;
break;
}
case OP_MobUpdate: // old MobUpdateCode:
{
unk = ! ValidatePayload(OP_MobUpdate, spawnPositionUpdate);
emit updateSpawns((const spawnPositionUpdate *)data, len, dir);
break;
}
case OP_WearChange: // old SpawnUpdateCode:
{
unk = ! ValidatePayload(OP_WearChange, SpawnUpdateStruct);
SpawnUpdateStruct *su = (SpawnUpdateStruct*)data;
// printf("SpawnUpdateCode(id=%d, sub=%d, arg1=%d, arg2=%d)\n",
// su->spawnId, su->subcommand,
// su->arg1, su->arg2);
/* Belith - I believe this is depreciated no? Doesn't work anyway ;) */
switch(su->subcommand) {
case 17:
emit updateSpawnMaxHP(su, len, dir);
break;
}
break;
emit updateSpawnInfo(su, len, dir);
}
case OP_SpawnAppearance: // old SpawnAppearanceCode:
{
unk = false;
emit spawnAppearance((const spawnAppearanceStruct*)data, len, dir);
break;
}
case OP_CommonMessage: // old ChannelMessageCode:
{
unk = false;
emit channelMessage((const channelMessageStruct*)data, len, dir);
break;
}
case OP_FormattedMessage: // old FormattedMessageCode:
{
unk = false;
emit formattedMessage((const formattedMessageStruct*)data, len, dir);
break;
}
case OP_SimpleMessage: // old SimpleMessageCode:
{
unk = false;
emit simpleMessage((const simpleMessageStruct*)data, len, dir);
break;
}
case OP_SpecialMesg:
{
unk = false;
emit specialMessage((const specialMessageStruct*)data, len, dir);
break;
}
case OP_GuildMOTD:
{
unk = false;
emit guildMOTD((const guildMOTDStruct*)data, len, dir);
break;
}
case OP_Death: // old NewCorpseCode:
{
unk = ! ValidatePayload(OP_Death, newCorpseStruct);
emit killSpawn((const newCorpseStruct*) data, len, dir);
break;
} /* end CorpseCode */
case OP_DeleteSpawn: // old DeleteSpawnCode:
{
unk = ! ValidatePayload(OP_DeleteSpawn, deleteSpawnStruct);
emit deleteSpawn((const deleteSpawnStruct*)data, len, dir);
break;
}
case OP_ItemLinkResponse: // old ItemInfoCode:
{
unk = false;
if (dir == DIR_SERVER)
emit itemInfo((const itemInfoStruct*)data, len, dir);
else
emit itemInfoReq((const itemInfoReqStruct*)data, len, dir);
}
case OP_ItemPacket: // old ItemCode:
{
unk = false;
if (dir == DIR_SERVER)
emit item((const itemPacketStruct*)data, len, dir);
break;
}
case OP_ItemPlayerPacket:
{
unk = false;
if (dir == DIR_SERVER)
emit playerItem((const char*)data, len, dir);
break;
}
case OP_NewSpawn: // old NewSpawnCode:
{
unk = ! ValidatePayload(OP_NewSpawn, newSpawnStruct);
emit newSpawn((const newSpawnStruct*)data, len, dir);
break;
}
case OP_ItemTextFile: // old BookTextCode:
{
unk = false;
printf("BOOK: '%s'\n", ((const bookTextStruct *)data)->text);
emit bookText((const bookTextStruct*)data, len, dir);
break;
}
case OP_MoneyOnCorpse: // old MoneyOnCorpseCode:
{
unk = ! ValidatePayload(OP_MoneyOnCorpse, moneyOnCorpseStruct);
emit moneyOnCorpse((const moneyOnCorpseStruct*)data, len, dir);
break;
} /* end MoneyOnCorpseCode */
case OP_RandomReply: // old RandomCode:
{
unk = ! ValidatePayload(OP_RandomReply, randomStruct);
emit random((const randomStruct*)data, len, dir);
break;
}
case OP_RandomReq: // RandomReqCode:
{
unk = ! ValidatePayload(OP_RandomReq, randomReqStruct);
emit random((const randomReqStruct*)data, len, dir);
break;
}
case OP_Emote: // old EmoteEmoteTextCode:
{
unk = false;
emit emoteText((const emoteTextStruct*)data, len, dir);
break;
}
case OP_CorpseLocResponse: // old CorpseLocCode:
{
unk = ! ValidatePayload(OP_CorpseLocResponse, corpseLocStruct);
emit corpseLoc((const corpseLocStruct*)data, len, dir);
break;
}
case OP_InspectAnswer: // old InspectDataCode:
{
unk = ! ValidatePayload(OP_InspectAnswer, inspectDataStruct);
emit inspectData((const inspectDataStruct *)data, len, dir);
break;
}
case OP_HPUpdate: // old NpcHpUpdateCode:
{
unk = ! ValidatePayload(OP_HPUpdate, hpNpcUpdateStruct);
emit updateNpcHP((const hpNpcUpdateStruct*)data, len, dir);
break;
}
case SPMesgCode:
{
unk = false;
emit spMessage((const spMesgStruct *)data, len, dir);
break;
}
case OP_MemorizeSpell: // old MemSpellCode:
{
unk = ! ValidatePayload(OP_MemorizeSpell, memSpellStruct);
emit handleSpell((const memSpellStruct*)data, len, dir);
break;
}
case OP_BeginCast: // old BeginCastCode
{
unk = ! ValidatePayload(OP_BeginCast, beginCastStruct);
emit beginCast((const beginCastStruct*)data, len, dir);
break;
}
case OP_CastSpell: // old StartCastCode:
{
unk = ! ValidatePayload(OP_CastSpell, startCastStruct);
emit startCast((const startCastStruct*)data, len, dir);
break;
}
case OP_BuffFadeMsg: // old SpellFadeCode:
{
unk = false;
emit spellFaded((const spellFadedStruct*)data, len, dir);
break;
}
case OP_ExpUpdate: // old ExpUpdateCode:
{
unk = ! ValidatePayload(OP_ExpUpdate, expUpdateStruct);
emit updateExp((const expUpdateStruct*)data, len, dir);
break;
}
case OP_LevelUpdate: // old LevelUpUpdateCode:
{
unk = ! ValidatePayload(OP_LevelUpdate, levelUpUpdateStruct);
emit updateLevel((const levelUpUpdateStruct *)data, len, dir);
break;
}
case OP_SkillUpdate: // old SkillIncCode
{
unk = ! ValidatePayload(OP_SkillUpdate, skillIncStruct);
emit increaseSkill((const skillIncStruct *)data, len, dir);
break;
}
case OP_MoveDoor: // old DoorOpenCode:
{
unk = false;
emit doorOpen(data, len, dir);
break;
}
case OP_Illusion: // old IllusionCode:
{
unk = false;
emit illusion(data, len, dir);
break;
}
case OP_ZoneChange: // old ZoneChangeCode:
{
unk = ! ValidatePayload(OP_ZoneChange, zoneChangeStruct);
// in the process of zoning, server hasn't switched yet.
emit zoneChange((const zoneChangeStruct*)data, len, dir);
break;
}
case OP_ZoneEntry: // old ZoneEntryCode:
{
// We're only interested in the server version
if (dir == DIR_CLIENT)
{
unk = ! ValidatePayload(OP_ZoneEntry, ClientZoneEntryStruct);
emit zoneEntry((const ClientZoneEntryStruct*)data, len, dir);
break;
}
unk = ! ValidatePayload(OP_ZoneEntry, ServerZoneEntryStruct);
emit zoneEntry((const ServerZoneEntryStruct*)data, len, dir);
break;
} /* end ZoneEntryCode */
case OP_NewZone: // old - NewZoneCode:
{
unk = ! ValidatePayload(OP_NewZone, newZoneStruct);
emit zoneNew((const newZoneStruct*)data, len, dir);
if (m_vPacket)
printf("New Zone at byte: %ld\n", m_vPacket->FilePos());
break;
}
case OP_PlayerProfile: // Character Profile server to client - old CharProfileCode
{
unk = false;
ValidatePayload(OP_PlayerProfile, charProfileStruct);
emit backfillPlayer((const charProfileStruct*)data, len, DIR_SERVER);
break;
}
case OP_ZoneSpawns: // ZoneSpawnsCode:
{
unk = false;
emit zoneSpawns((const zoneSpawnsStruct*)data, len, dir);
break;
}
case OP_TimeOfDay: // old TimeOfDayCode:
{
unk = ! ValidatePayload(OP_TimeOfDay, timeOfDayStruct);
emit timeOfDay((const timeOfDayStruct*)data, len, dir);
break;
}
case WearChangeCode:
{
unk = ! ValidatePayload(WearChangeCode, wearChangeStruct);
emit spawnWearingUpdate ((const wearChangeStruct*)data, len, dir);
break;
}
case OP_Action:
{
unk = ! ValidatePayload(OP_Action, actionStruct);
emit action((const actionStruct*)data, len, dir);
break;
}
case OP_CastBuff: // old ActionCode:
{
unk = false;
emit action2Message ((const action2Struct *)data, len, dir);
break;
}
case OP_Stamina: /// old StaminaCode:
{
unk = ! ValidatePayload(OP_Stamina, staminaStruct);
emit updateStamina((const staminaStruct *)data, len, dir);
break;
}
case OP_GroundSpawn: // old MakeDropCode:
{
#ifdef PACKET_PAYLOAD_SIZE_DIAG
if ((len != sizeof(makeDropStruct)) &&
(len != 0))
{
fprintf(stderr, "WARNING: OP_GroundSpawn (%04x) (dataLen: %d != sizeof(makeDropStruct):%d or 0)\n",
OP_GroundSpawn, len,
sizeof(makeDropStruct));
unk = true;
}
else
unk = false;
#else
unk = false;
#endif
emit newGroundItem((const makeDropStruct*)data, len, dir);
break;
}
case OP_ClickObject: // Old RemDropCode:
{
unk = ! ValidatePayload(OP_ClickObject, remDropStruct);
emit removeGroundItem((const remDropStruct *)data, len, dir);
break;
}
case OP_ShopRequest: // old OpenVendorCode:
{
unk = false;
emit openVendor(data, len, dir);
break;
}
case OP_ShopEnd: // old CloseVendorCode:
{
unk = false;
emit closeVendor(data, len, dir);
break;
}
case OP_GMTraining: // old OpenGMCode:
{
unk = false;
emit openGM(data, len, dir);
break;
}
case OP_GMEndTrainingResponse: // old CloseGMCode:
{
unk = false;
emit closeGM(data, len, dir);
break;
}
case OP_Consider: // old ConsiderCode:
{
unk = false;
ValidatePayload(OP_Consider, considerStruct);
emit consMessage((const considerStruct*)data, len, dir);
break;
}
case OP_TargetMouse: // old ClientTargetCode:
{
unk = ! ValidatePayload(OP_TargetMouse, clientTargetStruct);
emit clientTarget((const clientTargetStruct*) data, len, dir);
break;
}
case OP_SpawnDoor: // old DoorSpawnsCode:
{
unk = false;
#ifdef PACKET_PAYLOAD_SIZE_DIAG
// verify size
if (len % sizeof(doorStruct) != 0)
{
printf("WARNING: OP_SpawnDoor (%.04x) (dataLen:%d "
"%% sizeof(doorStruct):%d) != 0!\n",
OP_SpawnDoor, len, sizeof(doorStruct));
unk = true;
break;
}
#endif
int nDoors = len / sizeof(doorStruct);
const DoorSpawnsStruct *doorsStruct = (const DoorSpawnsStruct *)data;
for (int i = 0; i < nDoors; i++) {
emit newDoorSpawn(&doorsStruct->doors[i], len, dir);
}
emit newDoorSpawns(doorsStruct, len, dir);
break;
}
case OP_Buff: // old BuffDropCode:
{
unk = ! ValidatePayload(OP_Buff, buffStruct);
emit buff((const buffStruct*)data, len, dir);
// this is the server 'buff fading' AND the client 'cancel buff'
break;
}
case OP_Logout: // no contents
{
unk = false;
emit logOut(data, len, dir);
break;
}
case OP_SendZonePoints:
{
unk = false;
#ifdef PACKET_PAYLOAD_SIZE_DIAG
const zonePointsStruct* zp = (const zonePointsStruct*)data;
// verify size
if (((len - sizeof(zp->count) - sizeof(zp->unknown0xxx))
% sizeof(zonePointStruct)) != 0)
{
fprintf(stderr, "WARNING: OP_SendZonePoints (%04x) (dataLen: %d %% sizeof(zonePointStruct):%d) != 0!\n",
OP_SendZonePoints, len, sizeof(zonePointStruct));
unk = true;
break;
}
#endif
emit zonePoints((const zonePointsStruct*)data, len, dir);
break;
}
case OP_GuildMemberList: // old GuildMemberListCode
{
unk = false;
break;
}
case OP_GuildMemberUpdate: // old GuildMemberUpdateCode:
{
unk = false;
break;
}
case OP_SetRunMode: // old cRunToggleCode:
{
//unk = ! ValidatePayload(cRunToggleCode, cRunToggleStruct);
//emit cRunToggle((const cRunToggleStruct*)data, len, dir);
unk = false;
break;
}
case OP_Jump: // old cJumpCode:
{
//no data
unk = false;
break;
}
case OP_Camp: // old cStartCampingCode:
{
//no data
unk = false;
break;
}
case OP_SenseHeading: // old cSenseHeadingCode:
{
//no data
unk = false;
break;
}
case OP_Forage: // old ForageCode:
{
//no data
unk = false;
break;
}
#if 0 // ZBTEMP : If we don't bother setting unk, don't bother processing
case OP_ConsiderCorpse: //unknown contents // old cConCorpseCode:
{
//unk = ! ValidatePayload(cConCorpseCode, cConCorpseStruct);
//emit cConCorpse((const cConCorpseStruct*)data, len, dir);
break;
}
case OP_LootRequest: //unknown contents - old cLootCorpseCode
{
//unk = ! ValidatePayload(cLootCorpseCode, cLootCorpseStruct);
//emit cLootCorpse((const cLootCorpseStruct*)data, len, dir);
break;
}
case OP_EndLootRequest: //unknown contents - old cDoneLootingCode
{
//unk = ! ValidatePayload(cDoneLootingCode, cDoneLootingStruct);
//emit cDoneLooting((const cDoneLootingStruct*)data, len, dir);
break;
}
case OP_LootComplete: //unknown contents - old sDoneLootingCode
{
//unk = ! ValidatePayload(sDoneLootingCode, sDoneLootingStruct);
//emit sDoneLooting((const sDoneLootingStruct*)data, len, dir);
break;
}
case OP_WhoAllRequest: //unknown contents - old WhoAllReqCode
{
//unk = ! ValidatePayload(cWhoAllCode, cWhoAllStruct);
//emit cWhoAll((const cWhoAllStruct*)data, len, dir);
break;
}
case OP_WhoAllResponse: // old sWhoAllOutputCode: unknown contents
{
//unk = ! ValidatePayload(sWhoAllOutputCode, sWhoAllOutputStruct);
//emit sWhoAllOutput((const sWhoAllOutputStruct*)data, len, dir);
break;
}
case OP_ShopPlayerBuy: //unknown contents - old BuyItemCode
{
//unk = ! ValidatePayload(xBuyItemCode, xBuyItemStruct);
//emit xBuyItem((const xBuyItemStruct*)data, len, dir);
//both the client command and the server acknowledgement when buying
break;
}
#endif // ZBTEMP
#if 0 // ZBTEMP: OPCode Graveyard
case CastOnCode:
{
unk = false;
emit castOn((castOnStruct*)data, len, dir);
break;
}
case ManaDecrementCode:
{
unk = ! ValidatePayload(ManaDecrementCode, manaDecrementStruct);
emit manaChange((struct manaDecrementStruct *)data, len, dir);
break;
}
case BadCastCode:
{
unk = false; //! ValidatePayload(BadCastCode, badCastStruct);
emit interruptSpellCast((const badCastStruct*)data, len, dir);
break;
}
case SysMsgCode:
{
unk = false;
emit systemMessage((const sysMsgStruct*)data, len, dir);
break;
}
case AltExpUpdateCode:
{
unk = ! ValidatePayload(AltExpUpdateCode, altExpUpdateStruct);
emit updateAltExp((const altExpUpdateStruct*)data, len, dir);
break;
}
case Attack2Code:
{
unk = false;
emit attack2Hand1 ((const attack2Struct *)data, len, dir);
break;
}
case NewGuildInZoneCode:
{
unk = false;
break;
}
case MoneyUpdateCode:
{
unk = false;
emit moneyUpdate((const moneyUpdateStruct*)data, len, dir);
break;
}
case MoneyThingCode:
{
unk = false;
emit moneyThing((const moneyThingStruct*)data, len, dir);
break;
}
case BindWoundCode:
{
unk = false;
emit bindWound((bindWoundStruct*)data, len, dir);
break;
}
case GroupInfoCode:
{
// Too much still unknown.
unk = ! ValidatePayload(GroupInfoCode, groupMemberStruct);
emit groupInfo((const groupMemberStruct*)data, len, dir);
break;
}
case GroupInviteCode:
{
unk = ! ValidatePayload(GroupInviteCode, groupInviteStruct);
emit groupInvite((const groupInviteStruct*)data, len, dir);
break;
}
case GroupDeclineCode:
{
unk = ! ValidatePayload(GroupDeclineCode, groupDeclineStruct);
emit groupDecline((const groupDeclineStruct*)data, len, dir);
break;
}
case GroupAcceptCode:
{
unk = ! ValidatePayload(GroupAcceptCode, groupAcceptStruct);
emit groupAccept((const groupAcceptStruct*)data, len, dir);
break;
}
case GroupDeleteCode:
{
unk = ! ValidatePayload(GroupDeleteCode, groupDeleteStruct);
emit groupDelete((const groupDeleteStruct*)data, len, dir);
break;
}
case CharUpdateCode:
{
break;
}
case cChatFiltersCode:
{
//unk = ! ValidatePayload(cChatFiltersCode, cChatFiltersStruct);
//emit cChatFilters((const cChatFiltersStruct*)data, len, dir);
unk = false;
break;
}
case cOpenSpellBookCode:
{
//unk = ! ValidatePayload(cOpenSpellBookCode, cOpenSpellBookStruct);
//emit cOpenSpellBook((const cOpenSpellBookStruct*)data, len, dir);
unk = false;
break;
}
case OP_SwapSpell: // old TradeSpellBookSlotsCode:
{
unk = ! ValidatePayload(OP_SwapSpell, tradeSpellBookSlotsStruct);
emit tradeSpellBookSlots((const tradeSpellBookSlotsStruct*)data, len, dir);
break;
}
case sSpellFizzleRegainCode: //unknown contents, also comes when you Forage
{
//unk = ! ValidatePayload(sSpellFizzleRegainCode, sSpellFizzleRegainStruct);
//emit sSpellFizzleRegain((const sSpellFizzleRegainStruct*)data, len, dir);
break;
}
case sSpellInterruptedCode: //unknown contents
{
//unk = ! ValidatePayload(sSpellInterruptedCode, sSpellInterruptedStruct);
//emit sSpellInterrupted((const sSpellInterruptedStruct*)data, len, dir);
break;
}
case cHideCode:
{
//no data
unk = false;
break;
}
case cSneakCode:
{
//no data
unk = false;
break;
}
case cTrackCode:
{
//no data
unk = false;
break;
}
#endif // ZBTEMP // Currently dead opcodes
default:
{
}
} /* end switch(opCode) */
emit decodedZonePacket(data, len, dir, opCode, unk);
}
const ssize_t SerialPort::asyncRead(void *buf, const size_t len)
{
if(m_sigHandlerInstalled)
throw SerialPortException("Cannot do async read on multiple ports");
m_sigHandlerInstalled = true;
// install signal handler
struct sigaction sa;
sa.sa_handler = sigIoHandler;
sa.sa_flags = 0;
sa.sa_restorer = NULL;
::sigemptyset(&sa.sa_mask);
if(::sigaction(SIGIO, &sa, NULL))
throw SysException();
int flags;
if((flags = ::fcntl(m_fd, F_GETFL, 0)) == -1)
throw SysException();
// Set asynchronous mode
flags |= FASYNC;
if(::fcntl(m_fd, F_SETFL, flags) == -1)
throw SysException();
double timeout_time = timeOfDay() + m_asyncTimeout;
bool timeout = false;
int res;
for(;;)
{
if(m_sigIoReceived)
{
res = ::read(m_fd, buf, len - 1);
m_sigIoReceived = false;
break;
}
else
{
::usleep(ASYNC_SLEEP_INTERVAL);
if(timeOfDay() > timeout_time)
{
timeout = true;
res = 0;
break;
}
}
}
((char *) buf)[res] = '\0';
// Unset asynchronous mode
flags &= ~FASYNC;
if(::fcntl(m_fd, F_SETFL, FASYNC) == -1)
throw SysException();
// Uninstall signal handler
sa.sa_handler = SIG_DFL;
if(::sigaction(SIGIO, &sa, NULL))
throw SysException();
m_sigHandlerInstalled = false;
return res;
}
