VOID LogSpewAlwaysValist(const char *fmt, va_list args)
{
SCAN_IGNORE_FAULT; // calls to new (nothrow) in logging code are OK
STATIC_CONTRACT_NOTHROW;
STATIC_CONTRACT_GC_NOTRIGGER;
DEBUG_ONLY_FUNCTION;
// We can't do heap allocations at all. The current thread may have
// suspended another thread, and the suspended thread may be inside of the
// heap lock.
//
// (Some historical comments:)
//
// We must operate with a very small stack (in case we're logging durring
// a stack overflow)
//
// We're going to bypass our debug memory allocator and just allocate memory from
// the process heap. Why? Because our debug memory allocator will log out of memory
// conditions. If we're low on memory, and we try to log an out of memory condition, and we try
// and allocate memory again using the debug allocator, we could (and probably will) hit
// another low memory condition, try to log it, and we spin indefinately until we hit a stack overflow.
const int BUFFERSIZE = 1000;
static char rgchBuffer[BUFFERSIZE];
EnterLogLock();
char * pBuffer = &rgchBuffer[0];
DWORD buflen = 0;
DWORD written;
static bool needsPrefix = true;
if (needsPrefix)
buflen = sprintf_s(pBuffer, COUNTOF(rgchBuffer), "TID %04x: ", GetCurrentThreadId());
needsPrefix = (fmt[strlen(fmt)-1] == '\n');
int cCountWritten = _vsnprintf(&pBuffer[buflen], BUFFERSIZE-buflen, fmt, args );
pBuffer[BUFFERSIZE-1] = 0;
if (cCountWritten < 0) {
buflen = BUFFERSIZE - 1;
} else {
buflen += cCountWritten;
}
// Its a little late for this, but at least you wont continue
// trashing your program...
_ASSERTE((buflen < (DWORD) BUFFERSIZE) && "Log text is too long!") ;
#if !PLATFORM_UNIX
//convert NL's to CR NL to fixup notepad
const int BUFFERSIZE2 = BUFFERSIZE + 500;
char rgchBuffer2[BUFFERSIZE2];
char * pBuffer2 = &rgchBuffer2[0];
char *d = pBuffer2;
for (char *p = pBuffer; *p != '\0'; p++)
{
if (*p == '\n') {
_ASSERTE(d < pBuffer2 + BUFFERSIZE2);
*(d++) = '\r';
}
_ASSERTE(d < pBuffer2 + BUFFERSIZE2);
*(d++) = *p;
}
*d = 0;
buflen = (DWORD)(d - pBuffer2);
pBuffer = pBuffer2;
#endif // PLATFORM_UNIX
if (LogFlags & LOG_ENABLE_FILE_LOGGING && LogFileHandle != INVALID_HANDLE_VALUE)
{
WriteFile(LogFileHandle, pBuffer, buflen, &written, NULL);
if (LogFlags & LOG_ENABLE_FLUSH_FILE) {
FlushFileBuffers( LogFileHandle );
}
}
if (LogFlags & LOG_ENABLE_CONSOLE_LOGGING)
{
WriteFile(GetStdHandle(STD_OUTPUT_HANDLE), pBuffer, buflen, &written, 0);
//<TODO>@TODO ...Unnecessary to flush console?</TODO>
if (LogFlags & LOG_ENABLE_FLUSH_FILE)
FlushFileBuffers( GetStdHandle(STD_OUTPUT_HANDLE) );
}
if (LogFlags & LOG_ENABLE_DEBUGGER_LOGGING)
{
OutputDebugStringA(pBuffer);
}
LeaveLogLock();
}
void CItemStone::SetCharter( unsigned int iLine, LPCTSTR pCharter )
{
ASSERT(iLine<COUNTOF(m_sCharter));
m_sCharter[iLine] = pCharter;
}
bool CItemStone::r_WriteVal( LPCTSTR pszKey, CGString & sVal, CTextConsole * pSrc )
{
ADDTOCALLSTACK("CItemStone::r_WriteVal");
EXC_TRY("WriteVal");
CChar * pCharSrc = pSrc->GetChar();
if ( !strnicmp("member.",pszKey,7) )
{
LPCTSTR pszCmd = pszKey + 7;
if ( !strnicmp("COUNT",pszCmd,5) )
{
pszCmd = pszCmd + 5;
int i = 0;
CStoneMember * pMember = STATIC_CAST <CStoneMember *>(GetHead());
if ( *pszCmd )
{
SKIP_ARGSEP(pszCmd);
STONEPRIV_TYPE iPriv = static_cast<STONEPRIV_TYPE>(Exp_GetVal(pszCmd));
for (; pMember != NULL; pMember = pMember->GetNext())
{
if ( !pMember->GetLinkUID().IsChar() )
continue;
if ( pMember->GetPriv() != iPriv )
continue;
i++;
}
}
else
{
for (; pMember != NULL; pMember = pMember->GetNext())
{
if (!pMember->GetLinkUID().IsChar())
continue;
i++;
}
}
sVal.FormatVal(i);
return true;
}
int nNumber = Exp_GetVal(pszCmd);
SKIP_SEPARATORS(pszCmd);
CStoneMember * pMember = STATIC_CAST <CStoneMember *>(GetHead());
sVal.FormatVal(0);
for ( int i = 0 ; pMember != NULL; pMember = pMember->GetNext() )
{
if (!pMember->GetLinkUID().IsChar())
continue;
if ( nNumber == i )
{
if (!pszCmd[0])
return true;
return pMember->r_WriteVal(pszCmd, sVal, pSrc);
}
i++;
}
return true;
}
else if ( !strnicmp("memberfromuid.", pszKey, 14) )
{
LPCTSTR pszCmd = pszKey + 14;
sVal.FormatVal(0);
if ( !pszCmd[0] )
return true;
CGrayUID pMemberUid = static_cast<DWORD>(Exp_GetVal(pszCmd));
SKIP_SEPARATORS(pszCmd);
CChar * pMemberChar = pMemberUid.CharFind();
if ( pMemberChar )
{
CStoneMember * pMemberGuild = GetMember( pMemberChar );
if ( pMemberGuild )
{
return pMemberGuild->r_WriteVal(pszCmd, sVal, pSrc);
}
}
return true;
}
else if ( !strnicmp("guild.",pszKey,6) )
{
LPCTSTR pszCmd = pszKey + 6;
if ( !strnicmp("COUNT",pszCmd,5) )
{
pszCmd = pszCmd + 5;
int i = 0;
CStoneMember * pMember = STATIC_CAST <CStoneMember *>(GetHead());
if ( *pszCmd )
{
SKIP_ARGSEP(pszCmd);
int iToCheck = Exp_GetVal(pszCmd);
for (; pMember != NULL; pMember = pMember->GetNext())
{
if ( pMember->GetLinkUID().IsChar() )
continue;
if ( ( iToCheck == 1 ) && ( pMember->GetWeDeclared() && !pMember->GetTheyDeclared() ) )
i++;
else if ( ( iToCheck == 2 ) && ( !pMember->GetWeDeclared() && pMember->GetTheyDeclared() ) )
i++;
else if ( ( iToCheck == 3 ) && ( pMember->GetWeDeclared() && pMember->GetTheyDeclared() ) )
i++;
}
}
else
{
for (; pMember != NULL; pMember = pMember->GetNext())
{
if (pMember->GetLinkUID().IsChar())
continue;
i++;
}
}
sVal.FormatVal(i);
return true;
}
int nNumber = Exp_GetVal(pszCmd);
SKIP_SEPARATORS(pszCmd);
CStoneMember * pMember = STATIC_CAST <CStoneMember *>(GetHead());
sVal.FormatVal(0);
for ( int i = 0 ; pMember != NULL; pMember = pMember->GetNext() )
{
if (pMember->GetLinkUID().IsChar())
continue;
if ( nNumber == i )
{
if (!pszCmd[0])
return true;
return pMember->r_WriteVal(pszCmd, sVal, pSrc);
}
i++;
}
return true;
}
else if ( !strnicmp("guildfromuid.", pszKey, 13) )
{
LPCTSTR pszCmd = pszKey + 13;
sVal.FormatVal(0);
if ( !pszCmd[0] )
return true;
CGrayUID pGuildUid = static_cast<DWORD>(Exp_GetVal(pszCmd));
SKIP_SEPARATORS(pszCmd);
CItem * pMemberGuild = pGuildUid.ItemFind();
if ( pMemberGuild )
{
CStoneMember * pGuild = GetMember( pMemberGuild );
if ( pGuild )
{
return pGuild->r_WriteVal(pszCmd, sVal, pSrc);
}
}
return true;
}
else if ( !strnicmp(sm_szLoadKeys[STC_CHARTER], pszKey, 7) )
{
LPCTSTR pszCmd = pszKey + 7;
unsigned int i = ATOI(pszCmd);
if ( i >= COUNTOF(m_sCharter))
sVal = "";
else
sVal = m_sCharter[i];
return( true );
}
STC_TYPE iIndex = (STC_TYPE) FindTableSorted( pszKey, sm_szLoadKeys, COUNTOF( sm_szLoadKeys )-1 );
switch ( iIndex )
{
case STC_ABBREV: // "ABBREV"
sVal = m_sAbbrev;
return true;
case STC_ALIGN:
sVal.FormatVal( GetAlignType());
return true;
case STC_WEBPAGE: // "WEBPAGE"
sVal = GetWebPageURL();
return true;
case STC_AbbreviationToggle:
{
CStoneMember * pMember = GetMember(pCharSrc);
CVarDefCont * pResult = NULL;
if ( pMember == NULL )
{
pResult = g_Exp.m_VarDefs.GetKey("STONECONFIG_VARIOUSNAME_NONMEMBER");
}
else
{
pResult = pMember->IsAbbrevOn() ? g_Exp.m_VarDefs.GetKey("STONECONFIG_VARIOUSNAME_ABBREVON") :
g_Exp.m_VarDefs.GetKey("STONECONFIG_VARIOUSNAME_ABBREVOFF");
}
sVal = pResult ? pResult->GetValStr() : "";
}
return true;
case STC_AlignType:
sVal = GetAlignName();
return true;
case STC_LoyalTo:
{
CStoneMember * pMember = GetMember(pCharSrc);
CVarDefCont * pResult = NULL;
if ( pMember == NULL )
{
pResult = g_Exp.m_VarDefs.GetKey("STONECONFIG_VARIOUSNAME_NONMEMBER");
}
else
{
CChar * pLoyalTo = pMember->GetLoyalToUID().CharFind();
if ((pLoyalTo == NULL) || (pLoyalTo == pCharSrc ))
{
pResult = g_Exp.m_VarDefs.GetKey("STONECONFIG_VARIOUSNAME_YOURSELF");
}
else
{
sVal = pLoyalTo->GetName();
return true;
}
}
sVal = pResult ? pResult->GetValStr() : "";
}
return( true );
case STC_Master:
{
CChar * pMaster = GetMaster();
sVal = (pMaster) ? pMaster->GetName() : g_Exp.m_VarDefs.GetKeyStr("STONECONFIG_VARIOUSNAME_PENDVOTE");
}
return( true );
case STC_MasterGenderTitle:
{
CChar * pMaster = GetMaster();
if ( pMaster == NULL )
sVal = ""; // If no master (vote pending)
else if ( pMaster->Char_GetDef()->IsFemale())
sVal = g_Exp.m_VarDefs.GetKeyStr("STONECONFIG_VARIOUSNAME_MASTERGENDERFEMALE");
else
sVal = g_Exp.m_VarDefs.GetKeyStr("STONECONFIG_VARIOUSNAME_MASTERGENDERMALE");
}
return( true );
case STC_MasterTitle:
{
CStoneMember * pMember = GetMasterMember();
sVal = (pMember) ? pMember->GetTitle() : "";
}
return( true );
case STC_MasterUid:
{
CChar * pMaster = GetMaster();
if ( pMaster )
sVal.FormatHex( (DWORD) pMaster->GetUID() );
else
sVal.FormatHex( (DWORD) 0 );
}
return( true );
default:
return( CItem::r_WriteVal( pszKey, sVal, pSrc ));
}
EXC_CATCH;
EXC_DEBUG_START;
EXC_ADD_KEYRET(pSrc);
EXC_DEBUG_END;
return false;
}
bool CItemStone::r_Verb( CScript & s, CTextConsole * pSrc ) // Execute command from script
{
ADDTOCALLSTACK("CItemStone::r_Verb");
EXC_TRY("Verb");
// NOTE:: ONLY CALL this from CChar::r_Verb !!!
// Little to no security checking here !!!
ASSERT(pSrc);
int index = FindTableSorted( s.GetKey(), sm_szVerbKeys, COUNTOF(sm_szVerbKeys)-1 );
if ( index < 0 )
{
return( CItem::r_Verb( s, pSrc ));
}
CChar * pCharSrc = pSrc->GetChar();
CStoneMember * pMember = GetMember(pCharSrc);
switch ( index )
{
case ISV_ALLGUILDS:
{
if ( s.HasArgs() )
{
TCHAR * pszArgs = s.GetArgRaw();
int iFlags = Exp_GetVal(pszArgs);
SKIP_ARGSEP(pszArgs);
if ( iFlags < 0 )
{
g_Log.EventError("ItemStone::AllGuilds invalid parameter '%i'.\n", iFlags);
return false;
}
else
{
if ( pszArgs[0] != '\0' )
{
pMember = STATIC_CAST <CStoneMember *>(GetHead());
CScript scriptVerb( pszArgs );
for (; pMember != NULL; pMember = pMember->GetNext())
{
if ( pMember->GetLinkUID().IsChar() )
continue;
if ( !iFlags )
{
pMember->r_Verb(scriptVerb, pSrc);
}
else if ( ( iFlags == 1 ) && ( pMember->GetWeDeclared() && !pMember->GetTheyDeclared() ) )
{
pMember->r_Verb(scriptVerb, pSrc);
}
else if ( ( iFlags == 2 ) && ( !pMember->GetWeDeclared() && pMember->GetTheyDeclared() ) )
{
pMember->r_Verb(scriptVerb, pSrc);
}
else if ( ( iFlags == 3 ) && ( pMember->GetWeDeclared() && pMember->GetTheyDeclared() ) )
{
pMember->r_Verb(scriptVerb, pSrc);
}
}
}
else
{
g_Log.EventError("ItemStone::AllGuilds empty args.\n");
return false;
}
}
}
}
break;
case ISV_ALLMEMBERS:
{
if ( s.HasArgs() )
{
TCHAR * pszArgs = s.GetArgRaw();
int iFlags = Exp_GetVal(pszArgs);
SKIP_ARGSEP(pszArgs);
if (( iFlags < -1 ) || ( iFlags > STONEPRIV_ACCEPTED ))
{
g_Log.EventError("ItemStone::AllMembers invalid parameter '%i'.\n", iFlags);
return false;
}
else
{
if ( pszArgs[0] != '\0' )
{
pMember = STATIC_CAST <CStoneMember *>(GetHead());
CScript scriptVerb( pszArgs );
for (; pMember != NULL; pMember = pMember->GetNext())
{
if ( !pMember->GetLinkUID().IsChar() )
continue;
if ( iFlags == -1 )
{
pMember->r_Verb(scriptVerb, pSrc);
}
else if ( pMember->GetPriv() == static_cast<STONEPRIV_TYPE>(iFlags) )
{
pMember->r_Verb(scriptVerb, pSrc);
}
}
}
else
{
g_Log.EventError("ItemStone::AllMembers empty args.\n");
return false;
}
}
}
}
break;
case ISV_APPLYTOJOIN:
if ( s.HasArgs())
{
CGrayUID pMemberUid = s.GetArgVal();
CChar * pMemberChar = pMemberUid.CharFind();
if ( pMemberChar )
{
AddRecruit( pMemberChar, STONEPRIV_CANDIDATE );
}
}
break;
case ISV_CHANGEALIGN:
if ( s.HasArgs())
{
SetAlignType(static_cast<STONEALIGN_TYPE>(s.GetArgVal()));
TCHAR *pszMsg = Str_GetTemp();
sprintf(pszMsg, "%s is now a %s %s\n", static_cast<LPCTSTR>(GetName()), static_cast<LPCTSTR>(GetAlignName()), static_cast<LPCTSTR>(GetTypeName()));
Speak(pszMsg);
}
break;
case ISV_DECLAREPEACE:
if ( s.HasArgs())
{
CGrayUID pMemberUid = s.GetArgVal();
WeDeclarePeace(pMemberUid);
}
break;
case ISV_DECLAREWAR:
if ( s.HasArgs())
{
CGrayUID pMemberUid = s.GetArgVal();
CItem * pEnemyItem = pMemberUid.ItemFind();
if ( pEnemyItem )
{
CItemStone * pNewEnemy = dynamic_cast<CItemStone*>(pEnemyItem);
if ( pNewEnemy )
{
WeDeclareWar(pNewEnemy);
}
}
}
break;
case ISV_ELECTMASTER:
ElectMaster();
break;
// Need to change FixWeirdness or rewrite how cstonemember guilds are handled.
case ISV_INVITEWAR:
{
if ( s.HasArgs() )
{
INT64 piCmd[2];
size_t iArgQty = Str_ParseCmds( s.GetArgStr(), piCmd, COUNTOF(piCmd));
if ( iArgQty == 2 )
{
CGrayUID pGuildUid = static_cast<unsigned long>(piCmd[0]);
bool bWeDeclared = (piCmd[1] != 0);
CItem * pEnemyItem = pGuildUid.ItemFind();
if ( pEnemyItem && (pEnemyItem->IsType(IT_STONE_GUILD) || pEnemyItem->IsType(IT_STONE_TOWN)) )
{
CStoneMember * pMemberGuild = GetMember( pEnemyItem );
if ( !pMemberGuild )
pMemberGuild = new CStoneMember(this, pGuildUid, STONEPRIV_ENEMY);
if ( bWeDeclared )
pMemberGuild->SetWeDeclared(true);
else
pMemberGuild->SetTheyDeclared(true);
}
}
}
} break;
case ISV_JOINASMEMBER:
if ( s.HasArgs())
{
CGrayUID pMemberUid = s.GetArgVal();
CChar * pMemberChar = pMemberUid.CharFind();
if ( pMemberChar )
{
AddRecruit( pMemberChar, STONEPRIV_MEMBER );
}
}
break;
case ISV_RESIGN:
if ( s.HasArgs())
{
CGrayUID pMemberUid = s.GetArgVal();
CChar * pMemberChar = pMemberUid.CharFind();
if ( pMemberChar )
{
CStoneMember * pMemberGuild = GetMember( pMemberChar );
if ( pMemberGuild )
{
delete pMemberGuild;
}
}
}
else
{
if ( pMember != NULL )
delete pMember;
}
break;
case ISV_TOGGLEABBREVIATION:
{
CGrayUID pMemberUid = pMember->GetLinkUID();
if ( s.HasArgs() )
pMemberUid = s.GetArgVal();
CChar * pMemberChar = pMemberUid.CharFind();
if ( pMemberChar )
{
CStoneMember * pMemberGuild = GetMember( pMemberChar );
if ( pMemberGuild )
{
pMemberGuild->ToggleAbbrev();
pMemberChar->ResendTooltip();
}
}
}
break;
default:
return( false );
}
return true;
EXC_CATCH;
EXC_DEBUG_START;
EXC_ADD_SCRIPTSRC;
EXC_DEBUG_END;
return false;
}
bool CStoneMember::r_WriteVal( LPCTSTR pszKey, CGString & sVal, CTextConsole * pSrc )
{
ADDTOCALLSTACK("CStoneMember::r_WriteVal");
EXC_TRY("WriteVal");
STMM_TYPE iIndex = (STMM_TYPE) FindTableSorted( pszKey, sm_szLoadKeys, COUNTOF( sm_szLoadKeys )-1 );
if ( GetLinkUID().IsChar() )
{
switch ( iIndex )
{
case STMM_ACCOUNTGOLD:
sVal.FormatVal(GetAccountGold());
break;
case STMM_ISMASTER:
sVal.FormatVal(IsPrivMaster());
break;
case STMM_ISMEMBER:
sVal.FormatVal(IsPrivMember());
break;
case STMM_LOYALTO:
sVal.FormatHex(GetLoyalToUID());
break;
case STMM_PRIV:
sVal.FormatVal(GetPriv());
break;
case STMM_PRIVNAME:
sVal = GetPrivName();
break;
case STMM_TITLE:
sVal = GetTitle();
break;
case STMM_SHOWABBREV:
sVal.FormatVal(IsAbbrevOn());
break;
case STMM_ISCANDIDATE:
sVal.FormatVal((GetPriv() == STONEPRIV_CANDIDATE) ? 1 : 0);
break;
default:
{
CScriptObj *pRef = GetLinkUID().CharFind();
return pRef->r_WriteVal(pszKey,sVal,pSrc);
}
}
}
else if ( GetLinkUID().IsItem() )
{
switch ( iIndex )
{
case STMM_GUILD_ISENEMY:
sVal.FormatVal(GetWeDeclared() && GetTheyDeclared());
break;
case STMM_GUILD_THEYWAR:
sVal.FormatVal(GetTheyDeclared());
break;
case STMM_GUILD_WEWAR:
sVal.FormatVal(GetWeDeclared());
break;
case STMM_GUILD_WEALLIANCE:
sVal.FormatVal(0);
break;
case STMM_GUILD_THEYALLIANCE:
sVal.FormatVal(0);
break;
default:
{
CScriptObj *pRef = GetLinkUID().ItemFind();
return pRef->r_WriteVal(pszKey,sVal,pSrc);
}
}
}
return true;
EXC_CATCH;
EXC_DEBUG_START;
EXC_ADD_KEYRET(pSrc);
EXC_DEBUG_END;
return false;
}
{
#if defined(TARGET_GP2X) || defined(TARGET_DINGUX)
{ 320, 240, no_scale, nn_16, nn_32, "None" },
#else
{ 1 * vga_width, 1 * vga_height, no_scale, nn_16, nn_32, "None" },
{ 2 * vga_width, 2 * vga_height, NULL, nn_16, nn_32, "2x" },
{ 2 * vga_width, 2 * vga_height, NULL, scale2x_16, scale2x_32, "Scale2x" },
{ 2 * vga_width, 2 * vga_height, NULL, NULL, hq2x_32, "hq2x" },
{ 3 * vga_width, 3 * vga_height, NULL, nn_16, nn_32, "3x" },
{ 3 * vga_width, 3 * vga_height, NULL, scale3x_16, scale3x_32, "Scale3x" },
{ 3 * vga_width, 3 * vga_height, NULL, NULL, hq3x_32, "hq3x" },
{ 4 * vga_width, 4 * vga_height, NULL, nn_16, nn_32, "4x" },
{ 4 * vga_width, 4 * vga_height, NULL, NULL, hq4x_32, "hq4x" },
#endif
};
const uint scalers_count = COUNTOF(scalers);
void set_scaler_by_name( const char *name )
{
for (uint i = 0; i < scalers_count; ++i)
{
if (strcmp(name, scalers[i].name) == 0)
{
scaler = i;
break;
}
}
}
#if defined(TARGET_GP2X) || defined(TARGET_DINGUX)
#define VGA_CENTERED
void JE_saveConfiguration( void )
{
#ifdef TARGET_UNIX
if (getenv("HOME"))
{
char dir[1000];
snprintf(dir, sizeof(dir), "%s/.opentyrian", getenv("HOME"));
mkdir(dir, 0755);
}
#endif /* HOME */
FILE *f;
JE_byte *p;
int z;
p = saveTemp;
for (z = 0; z < SAVE_FILES_NUM; z++)
{
JE_SaveFileType tempSaveFile;
memcpy(&tempSaveFile, &saveFiles[z], sizeof(tempSaveFile));
tempSaveFile.encode = SDL_SwapLE16(tempSaveFile.encode);
memcpy(p, &tempSaveFile.encode, sizeof(JE_word)); p += 2;
tempSaveFile.level = SDL_SwapLE16(tempSaveFile.level);
memcpy(p, &tempSaveFile.level, sizeof(JE_word)); p += 2;
memcpy(p, &tempSaveFile.items, sizeof(JE_PItemsType)); p += sizeof(JE_PItemsType);
tempSaveFile.score = SDL_SwapLE32(tempSaveFile.score);
memcpy(p, &tempSaveFile.score, sizeof(JE_longint)); p += 4;
tempSaveFile.score2 = SDL_SwapLE32(tempSaveFile.score2);
memcpy(p, &tempSaveFile.score2, sizeof(JE_longint)); p += 4;
/* SYN: Pascal strings are prefixed by a byte holding the length! */
memset(p, 0, sizeof(tempSaveFile.levelName));
*p = strlen(tempSaveFile.levelName);
memcpy(&p[1], &tempSaveFile.levelName, *p);
p += 10;
/* This was a BYTE array, not a STRING, in the original. Go fig. */
memcpy(p, &tempSaveFile.name, 14);
p += 14;
memcpy(p, &tempSaveFile.cubes, sizeof(JE_byte)); p++;
memcpy(p, &tempSaveFile.power, sizeof(JE_byte) * 2); p += 2;
memcpy(p, &tempSaveFile.episode, sizeof(JE_byte)); p++;
memcpy(p, &tempSaveFile.lastItems, sizeof(JE_PItemsType)); p += sizeof(JE_PItemsType);
memcpy(p, &tempSaveFile.difficulty, sizeof(JE_byte)); p++;
memcpy(p, &tempSaveFile.secretHint, sizeof(JE_byte)); p++;
memcpy(p, &tempSaveFile.input1, sizeof(JE_byte)); p++;
memcpy(p, &tempSaveFile.input2, sizeof(JE_byte)); p++;
/* booleans were 1 byte in pascal -- working around it */
Uint8 temp = tempSaveFile.gameHasRepeated != false;
memcpy(p, &temp, 1); p++;
memcpy(p, &tempSaveFile.initialDifficulty, sizeof(JE_byte)); p++;
tempSaveFile.highScore1 = SDL_SwapLE32(tempSaveFile.highScore1);
memcpy(p, &tempSaveFile.highScore1, sizeof(JE_longint)); p += 4;
tempSaveFile.highScore2 = SDL_SwapLE32(tempSaveFile.highScore2);
memcpy(p, &tempSaveFile.highScore2, sizeof(JE_longint)); p += 4;
memset(p, 0, sizeof(tempSaveFile.highScoreName));
*p = strlen(tempSaveFile.highScoreName);
memcpy(&p[1], &tempSaveFile.highScoreName, *p);
p += 30;
memcpy(p, &tempSaveFile.highScoreDiff, sizeof(JE_byte)); p++;
}
saveTemp[SIZEOF_SAVEGAMETEMP - 6] = editorLevel >> 8;
saveTemp[SIZEOF_SAVEGAMETEMP - 5] = editorLevel;
JE_encryptSaveTemp();
f = dir_fopen_warn(get_user_directory(), "tyrian.sav", "wb");
if (f)
{
efwrite(saveTemp, 1, sizeof(saveTemp), f);
fclose(f);
#if (_BSD_SOURCE || _XOPEN_SOURCE >= 500)
sync();
#endif
}
JE_decryptSaveTemp();
f = dir_fopen_warn(get_user_directory(), "tyrian.cfg", "wb");
if (f)
{
efwrite(&background2, 1, 1, f);
efwrite(&gameSpeed, 1, 1, f);
efwrite(&inputDevice_, 1, 1, f);
efwrite(&jConfigure, 1, 1, f);
efwrite(&versionNum, 1, 1, f);
efwrite(&processorType, 1, 1, f);
efwrite(&midiPort, 1, 1, f);
efwrite(&soundEffects, 1, 1, f);
efwrite(&gammaCorrection, 1, 1, f);
efwrite(&difficultyLevel, 1, 1, f);
efwrite(joyButtonAssign, 1, 4, f);
efwrite(&tyrMusicVolume, 2, 1, f);
efwrite(&fxVolume, 2, 1, f);
efwrite(inputDevice, 1, 2, f);
efwrite(keySettings, sizeof(*keySettings), COUNTOF(keySettings), f);
fclose(f);
}
save_opentyrian_config();
#if (_BSD_SOURCE || _XOPEN_SOURCE >= 500)
sync();
#endif
}
/*
* The way windows takes environment variables is different than what C does;
* Windows wants a contiguous block of null-terminated strings, terminated
* with an additional null.
*
* Windows has a few "essential" environment variables. winsock will fail
* to initialize if SYSTEMROOT is not defined; some APIs make reference to
* TEMP. SYSTEMDRIVE is probably also important. We therefore ensure that
* these get defined if the input environment block does not contain any
* values for them.
*/
wchar_t* make_program_env(char** env_block) {
wchar_t* dst;
wchar_t* ptr;
char** env;
int env_len = 1 * sizeof(wchar_t); /* room for closing null */
int len;
int i;
DWORD var_size;
env_var_t required_vars[] = {
E_V("SYSTEMROOT"),
E_V("SYSTEMDRIVE"),
E_V("TEMP"),
};
for (env = env_block; *env; env++) {
check_required_vars_contains_var(required_vars,
COUNTOF(required_vars),
*env);
env_len += (uv_utf8_to_utf16(*env, NULL, 0) * sizeof(wchar_t));
}
for (i = 0; i < COUNTOF(required_vars); ++i) {
if (!required_vars[i].supplied) {
env_len += required_vars[i].len * sizeof(wchar_t);
var_size = GetEnvironmentVariableW(required_vars[i].wide, NULL, 0);
if (var_size == 0) {
uv_fatal_error(GetLastError(), "GetEnvironmentVariableW");
}
required_vars[i].value_len = (int)var_size;
env_len += (int)var_size * sizeof(wchar_t);
}
}
dst = malloc(env_len);
if (!dst) {
uv_fatal_error(ERROR_OUTOFMEMORY, "malloc");
}
ptr = dst;
for (env = env_block; *env; env++, ptr += len) {
len = uv_utf8_to_utf16(*env, ptr, (size_t)(env_len - (ptr - dst)));
if (!len) {
free(dst);
return NULL;
}
}
for (i = 0; i < COUNTOF(required_vars); ++i) {
if (!required_vars[i].supplied) {
wcscpy(ptr, required_vars[i].wide);
ptr += required_vars[i].len - 1;
*ptr++ = L'=';
var_size = GetEnvironmentVariableW(required_vars[i].wide,
ptr,
required_vars[i].value_len);
if (var_size == 0) {
uv_fatal_error(GetLastError(), "GetEnvironmentVariableW");
}
ptr += required_vars[i].value_len;
}
}
*ptr = L'\0';
return dst;
}
int uv_spawn(uv_loop_t* loop, uv_process_t* process,
uv_process_options_t options) {
int err = 0, keep_child_stdio_open = 0;
wchar_t* path = NULL;
int size;
BOOL result;
wchar_t* application_path = NULL, *application = NULL, *arguments = NULL, *env = NULL, *cwd = NULL;
HANDLE* child_stdio = process->child_stdio;
STARTUPINFOW startup;
PROCESS_INFORMATION info;
if (!options.file) {
uv__set_artificial_error(loop, UV_EINVAL);
return -1;
}
uv_process_init(loop, process);
process->exit_cb = options.exit_cb;
UTF8_TO_UTF16(options.file, application);
arguments = options.args ? make_program_args(options.args,
options.windows_verbatim_arguments) : NULL;
env = options.env ? make_program_env(options.env) : NULL;
if (options.cwd) {
UTF8_TO_UTF16(options.cwd, cwd);
} else {
size = GetCurrentDirectoryW(0, NULL) * sizeof(wchar_t);
if (size) {
cwd = (wchar_t*)malloc(size);
if (!cwd) {
uv_fatal_error(ERROR_OUTOFMEMORY, "malloc");
}
GetCurrentDirectoryW(size, cwd);
} else {
uv__set_sys_error(loop, GetLastError());
err = -1;
goto done;
}
}
/* Get PATH env. variable. */
size = GetEnvironmentVariableW(L"PATH", NULL, 0) + 1;
path = (wchar_t*)malloc(size * sizeof(wchar_t));
if (!path) {
uv_fatal_error(ERROR_OUTOFMEMORY, "malloc");
}
GetEnvironmentVariableW(L"PATH", path, size * sizeof(wchar_t));
path[size - 1] = L'\0';
application_path = search_path(application,
cwd,
path);
if (!application_path) {
/* CreateProcess will fail, but this allows us to pass this error to */
/* the user asynchronously. */
application_path = application;
}
/* Create stdio pipes. */
if (options.stdin_stream) {
err = uv_create_stdio_pipe_pair(
loop,
options.stdin_stream,
&child_stdio[0],
PIPE_ACCESS_OUTBOUND,
GENERIC_READ | FILE_WRITE_ATTRIBUTES);
} else {
err = duplicate_std_handle(loop, STD_INPUT_HANDLE, &child_stdio[0]);
}
if (err) {
goto done;
}
if (options.stdout_stream) {
err = uv_create_stdio_pipe_pair(
loop, options.stdout_stream,
&child_stdio[1],
PIPE_ACCESS_INBOUND,
GENERIC_WRITE);
} else {
err = duplicate_std_handle(loop, STD_OUTPUT_HANDLE, &child_stdio[1]);
}
if (err) {
goto done;
}
if (options.stderr_stream) {
err = uv_create_stdio_pipe_pair(
loop,
options.stderr_stream,
&child_stdio[2],
PIPE_ACCESS_INBOUND,
GENERIC_WRITE);
} else {
err = duplicate_std_handle(loop, STD_ERROR_HANDLE, &child_stdio[2]);
}
if (err) {
goto done;
}
startup.cb = sizeof(startup);
startup.lpReserved = NULL;
startup.lpDesktop = NULL;
startup.lpTitle = NULL;
startup.dwFlags = STARTF_USESTDHANDLES;
startup.cbReserved2 = 0;
startup.lpReserved2 = NULL;
startup.hStdInput = child_stdio[0];
startup.hStdOutput = child_stdio[1];
startup.hStdError = child_stdio[2];
if (CreateProcessW(application_path,
arguments,
NULL,
NULL,
1,
CREATE_UNICODE_ENVIRONMENT,
env,
cwd,
&startup,
&info)) {
/* Spawn succeeded */
process->process_handle = info.hProcess;
process->pid = info.dwProcessId;
/* Setup notifications for when the child process exits. */
result = RegisterWaitForSingleObject(&process->wait_handle,
process->process_handle, exit_wait_callback, (void*)process, INFINITE,
WT_EXECUTEINWAITTHREAD | WT_EXECUTEONLYONCE);
if (!result) {
uv_fatal_error(GetLastError(), "RegisterWaitForSingleObject");
}
CloseHandle(info.hThread);
} else {
/* CreateProcessW failed, but this failure should be delivered */
/* asynchronously to retain unix compatibility. So pretent spawn */
/* succeeded, and start a thread instead that prints an error */
/* to the child's intended stderr. */
process->spawn_errno = GetLastError();
keep_child_stdio_open = 1;
if (!QueueUserWorkItem(spawn_failure, process, WT_EXECUTEDEFAULT)) {
uv_fatal_error(GetLastError(), "QueueUserWorkItem");
}
}
done:
free(application);
if (application_path != application) {
free(application_path);
}
free(arguments);
free(cwd);
free(env);
free(path);
/* Under normal circumstances we should close the stdio handles now - */
/* the child now has its own duplicates, or something went horribly wrong. */
/* The only exception is when CreateProcess has failed, then we actually */
/* need to keep the stdio handles to report the error asynchronously. */
if (!keep_child_stdio_open) {
close_child_stdio(process);
} else {
/* We're keeping the handles open, the thread pool is going to have */
/* it's way with them. But at least make them noninheritable. */
int i;
for (i = 0; i < COUNTOF(process->child_stdio); i++) {
SetHandleInformation(child_stdio[i], HANDLE_FLAG_INHERIT, 0);
}
}
if (err) {
if (process->wait_handle != INVALID_HANDLE_VALUE) {
UnregisterWait(process->wait_handle);
process->wait_handle = INVALID_HANDLE_VALUE;
}
if (process->process_handle != INVALID_HANDLE_VALUE) {
CloseHandle(process->process_handle);
process->process_handle = INVALID_HANDLE_VALUE;
}
}
return err;
}
void CResourceVersionInfo::ExportToStream(GrowBuf &strm, int Index)
{
DWORD v;
WORD wSize;
int p, p1;
strm.resize(0);
SaveVersionHeader(strm, 0, sizeof (VS_FIXEDFILEINFO), 0, L"VS_VERSION_INFO", &m_FixedInfo);
DefineList *pChildStrings = m_ChildStringLists.get_strings(Index);
if ( pChildStrings->getnum() > 0 )
{
GrowBuf stringInfoStream;
int codepage = m_ChildStringLists.get_codepage(Index);
LANGID langid = m_ChildStringLists.get_lang(Index);
wchar_t Buff[16];
_snwprintf(Buff, COUNTOF(Buff), L"%04x%04x", langid, codepage);
SaveVersionHeader(stringInfoStream, 0, 0, 0, Buff, &ZEROS);
for ( int i = 0; i < pChildStrings->getnum(); i++ )
{
PadStream (stringInfoStream);
WCToUTF16LEHlpr cnvName, cnvValue;
if (!cnvName.Create(pChildStrings->getname(i), codepage)) throw std::runtime_error("Unicode conversion failed");
if (!cnvValue.Create(pChildStrings->getvalue(i), codepage)) throw std::runtime_error("Unicode conversion failed");
p = stringInfoStream.getlen();
SaveVersionHeaderUTF16LE(stringInfoStream, 0, WORD(StrLenUTF16(cnvValue.Get()) + 1), 1, cnvName.Get(), (void*)cnvValue.Get());
cnvName.Destroy(), cnvValue.Destroy();
wSize = WORD(stringInfoStream.getlen() - p);
*(WORD*)((PBYTE)stringInfoStream.get()+p)=wSize;
}
wSize = WORD(stringInfoStream.getlen());
*(WORD*)((PBYTE)stringInfoStream.get())=wSize;
PadStream (strm);
p = strm.getlen();
SaveVersionHeader(strm, 0, 0, 0, L"StringFileInfo", &ZEROS);
strm.add (stringInfoStream.get(), stringInfoStream.getlen());
wSize = WORD(strm.getlen() - p);
*(WORD*)((PBYTE)strm.get()+p)=wSize;
}
// Show all languages avaiable using Var-Translations
if ( m_ChildStringLists.getnum() > 0 )
{
PadStream (strm);
p = strm.getlen();
SaveVersionHeader(strm, 0, 0, 0, L"VarFileInfo", &ZEROS);
PadStream (strm);
p1 = strm.getlen();
SaveVersionHeader(strm, 0, 0, 0, L"Translation", &ZEROS);
// First add selected code language translation
v = MAKELONG(m_ChildStringLists.get_lang(Index), m_ChildStringLists.get_codepage(Index));
strm.add (&v, sizeof (v));
for ( int k =0; k < m_ChildStringLists.getnum(); k++ )
{
if ( k != Index )
{
v = MAKELONG(m_ChildStringLists.get_lang(k), m_ChildStringLists.get_codepage(k));
strm.add (&v, sizeof (v));
}
}
wSize = WORD(strm.getlen() - p1);
*(WORD*)((PBYTE)strm.get()+p1)=wSize;
wSize = WORD(sizeof (int) * m_ChildStringLists.getnum());
p1+=sizeof(WORD);
*(WORD*)((PBYTE)strm.get()+p1)=wSize;
wSize = WORD(strm.getlen() - p);
*(WORD*)((PBYTE)strm.get()+p)=wSize;
}
wSize = WORD(strm.getlen());
*(WORD*)((PBYTE)strm.get())=wSize;
}
DECL(DRIVING_EMPTYGRANDSTAND),
DECL(DRIVING_TUNNEL),
DECL(CITY_STREETS),
DECL(CITY_SUBWAY),
DECL(CITY_MUSEUM),
DECL(CITY_LIBRARY),
DECL(CITY_UNDERPASS),
DECL(CITY_ABANDONED),
DECL(DUSTYROOM),
DECL(CHAPEL),
DECL(SMALLWATERROOM),
};
#undef DECL
static const ALsizei reverblistsize = COUNTOF(reverblist);
ALvoid LoadReverbPreset(const char *name, ALeffect *effect)
{
int i;
if(strcasecmp(name, "NONE") == 0)
{
InitEffectParams(effect, AL_EFFECT_NULL);
TRACE("Loading reverb '%s'\n", "NONE");
return;
}
if(!DisabledEffects[EAXREVERB])
InitEffectParams(effect, AL_EFFECT_EAXREVERB);
else if(!DisabledEffects[REVERB])
bool ValidateHKDF()
{
bool pass = true;
{
// SHA-1 from RFC 5869, Appendix A, https://tools.ietf.org/html/rfc5869
static const HKDF_TestTuple testSet[] =
{
// Test Case #4
{"0b0b0b0b0b0b0b0b0b0b0b", "000102030405060708090a0b0c", "f0f1f2f3f4f5f6f7f8f9", "085a01ea1b10f36933068b56efa5ad81 a4f14b822f5b091568a9cdd4f155fda2 c22e422478d305f3f896", 42},
// Test Case #5
{"000102030405060708090a0b0c0d0e0f 101112131415161718191a1b1c1d1e1f 202122232425262728292a2b2c2d2e2f 303132333435363738393a3b3c3d3e3f 404142434445464748494a4b4c4d4e4f", "606162636465666768696a6b6c6d6e6f 707172737475767778797a7b7c7d7e7f 808182838485868788898a8b8c8d8e8f 909192939495969798999a9b9c9d9e9f a0a1a2a3a4a5a6a7a8a9aaabacadaeaf", "b0b1b2b3b4b5b6b7b8b9babbbcbdbebf c0c1c2c3c4c5c6c7c8c9cacbcccdcecf d0d1d2d3d4d5d6d7d8d9dadbdcdddedf e0e1e2e3e4e5e6e7e8e9eaebecedeeef f0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", "0bd770a74d1160f7c9f12cd5912a06eb ff6adcae899d92191fe4305673ba2ffe 8fa3f1a4e5ad79f3f334b3b202b2173c 486ea37ce3d397ed034c7f9dfeb15c5e 927336d0441f4c4300e2cff0d0900b52 d3b4", 82},
// Test Case #6
{"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b", NULL, NULL, "0ac1af7002b3d761d1e55298da9d0506 b9ae52057220a306e07b6b87e8df21d0 ea00033de03984d34918", 42}
};
HKDF<SHA1> hkdf;
cout << "\nRFC 5869 HKDF(SHA-1) validation suite running...\n\n";
pass = TestHKDF(hkdf, testSet, COUNTOF(testSet)) && pass;
}
{
// SHA-256 from RFC 5869, Appendix A, https://tools.ietf.org/html/rfc5869
static const HKDF_TestTuple testSet[] =
{
// Test Case #1
{"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b", "000102030405060708090a0b0c", "f0f1f2f3f4f5f6f7f8f9", "3cb25f25faacd57a90434f64d0362f2a 2d2d0a90cf1a5a4c5db02d56ecc4c5bf 34007208d5b887185865", 42},
// Test Case #2
{"000102030405060708090a0b0c0d0e0f 101112131415161718191a1b1c1d1e1f 202122232425262728292a2b2c2d2e2f 303132333435363738393a3b3c3d3e3f 404142434445464748494a4b4c4d4e4f", "606162636465666768696a6b6c6d6e6f 707172737475767778797a7b7c7d7e7f 808182838485868788898a8b8c8d8e8f 909192939495969798999a9b9c9d9e9f a0a1a2a3a4a5a6a7a8a9aaabacadaeaf", "b0b1b2b3b4b5b6b7b8b9babbbcbdbebf c0c1c2c3c4c5c6c7c8c9cacbcccdcecf d0d1d2d3d4d5d6d7d8d9dadbdcdddedf e0e1e2e3e4e5e6e7e8e9eaebecedeeef f0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", "b11e398dc80327a1c8e7f78c596a4934 4f012eda2d4efad8a050cc4c19afa97c 59045a99cac7827271cb41c65e590e09 da3275600c2f09b8367793a9aca3db71 cc30c58179ec3e87c14c01d5c1f3434f 1d87", 82},
// Test Case #3
{"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b", NULL, NULL, "8da4e775a563c18f715f802a063c5a31 b8a11f5c5ee1879ec3454e5f3c738d2d 9d201395faa4b61a96c8", 42}
};
HKDF<SHA256> hkdf;
cout << "\nRFC 5869 HKDF(SHA-256) validation suite running...\n\n";
pass = TestHKDF(hkdf, testSet, COUNTOF(testSet)) && pass;
}
{
// SHA-512 based on RFC 5869, https://tools.ietf.org/html/rfc5869
static const HKDF_TestTuple testSet[] =
{
// Test Case #0
{"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b", "000102030405060708090a0b0c", "f0f1f2f3f4f5f6f7f8f9", "832390086CDA71FB47625BB5CEB168E4 C8E26A1A16ED34D9FC7FE92C14815793 38DA362CB8D9F925D7CB", 42},
// Test Case #0
{"000102030405060708090a0b0c0d0e0f 101112131415161718191a1b1c1d1e1f 202122232425262728292a2b2c2d2e2f 303132333435363738393a3b3c3d3e3f 404142434445464748494a4b4c4d4e4f", "606162636465666768696a6b6c6d6e6f 707172737475767778797a7b7c7d7e7f 808182838485868788898a8b8c8d8e8f 909192939495969798999a9b9c9d9e9f a0a1a2a3a4a5a6a7a8a9aaabacadaeaf", "b0b1b2b3b4b5b6b7b8b9babbbcbdbebf c0c1c2c3c4c5c6c7c8c9cacbcccdcecf d0d1d2d3d4d5d6d7d8d9dadbdcdddedf e0e1e2e3e4e5e6e7e8e9eaebecedeeef f0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", "CE6C97192805B346E6161E821ED16567 3B84F400A2B514B2FE23D84CD189DDF1 B695B48CBD1C8388441137B3CE28F16A A64BA33BA466B24DF6CFCB021ECFF235 F6A2056CE3AF1DE44D572097A8505D9E 7A93", 82},
// Test Case #0
{"0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b", NULL, NULL, "F5FA02B18298A72A8C23898A8703472C 6EB179DC204C03425C970E3B164BF90F FF22D04836D0E2343BAC", 42}
};
HKDF<SHA512> hkdf;
cout << "\nRFC 5869 HKDF(SHA-512) validation suite running...\n\n";
pass = TestHKDF(hkdf, testSet, COUNTOF(testSet)) && pass;
}
return pass;
}
bool ValidateRIPEMD()
{
static const HashTestTuple testSet128[] =
{
HashTestTuple("", "\xcd\xf2\x62\x13\xa1\x50\xdc\x3e\xcb\x61\x0f\x18\xf6\xb3\x8b\x46"),
HashTestTuple("a", "\x86\xbe\x7a\xfa\x33\x9d\x0f\xc7\xcf\xc7\x85\xe7\x2f\x57\x8d\x33"),
HashTestTuple("abc", "\xc1\x4a\x12\x19\x9c\x66\xe4\xba\x84\x63\x6b\x0f\x69\x14\x4c\x77"),
HashTestTuple("message digest", "\x9e\x32\x7b\x3d\x6e\x52\x30\x62\xaf\xc1\x13\x2d\x7d\xf9\xd1\xb8"),
HashTestTuple("abcdefghijklmnopqrstuvwxyz", "\xfd\x2a\xa6\x07\xf7\x1d\xc8\xf5\x10\x71\x49\x22\xb3\x71\x83\x4e"),
HashTestTuple("abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq", "\xa1\xaa\x06\x89\xd0\xfa\xfa\x2d\xdc\x22\xe8\x8b\x49\x13\x3a\x06"),
HashTestTuple("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789", "\xd1\xe9\x59\xeb\x17\x9c\x91\x1f\xae\xa4\x62\x4c\x60\xc5\xc7\x02"),
HashTestTuple("12345678901234567890123456789012345678901234567890123456789012345678901234567890", "\x3f\x45\xef\x19\x47\x32\xc2\xdb\xb2\xc4\xa2\xc7\x69\x79\x5f\xa3"),
HashTestTuple("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "\x4a\x7f\x57\x23\xf9\x54\xeb\xa1\x21\x6c\x9d\x8f\x63\x20\x43\x1f", 15625)
};
static const HashTestTuple testSet160[] =
{
HashTestTuple("", "\x9c\x11\x85\xa5\xc5\xe9\xfc\x54\x61\x28\x08\x97\x7e\xe8\xf5\x48\xb2\x25\x8d\x31"),
HashTestTuple("a", "\x0b\xdc\x9d\x2d\x25\x6b\x3e\xe9\xda\xae\x34\x7b\xe6\xf4\xdc\x83\x5a\x46\x7f\xfe"),
HashTestTuple("abc", "\x8e\xb2\x08\xf7\xe0\x5d\x98\x7a\x9b\x04\x4a\x8e\x98\xc6\xb0\x87\xf1\x5a\x0b\xfc"),
HashTestTuple("message digest", "\x5d\x06\x89\xef\x49\xd2\xfa\xe5\x72\xb8\x81\xb1\x23\xa8\x5f\xfa\x21\x59\x5f\x36"),
HashTestTuple("abcdefghijklmnopqrstuvwxyz", "\xf7\x1c\x27\x10\x9c\x69\x2c\x1b\x56\xbb\xdc\xeb\x5b\x9d\x28\x65\xb3\x70\x8d\xbc"),
HashTestTuple("abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq", "\x12\xa0\x53\x38\x4a\x9c\x0c\x88\xe4\x05\xa0\x6c\x27\xdc\xf4\x9a\xda\x62\xeb\x2b"),
HashTestTuple("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789", "\xb0\xe2\x0b\x6e\x31\x16\x64\x02\x86\xed\x3a\x87\xa5\x71\x30\x79\xb2\x1f\x51\x89"),
HashTestTuple("12345678901234567890123456789012345678901234567890123456789012345678901234567890", "\x9b\x75\x2e\x45\x57\x3d\x4b\x39\xf4\xdb\xd3\x32\x3c\xab\x82\xbf\x63\x32\x6b\xfb"),
HashTestTuple("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "\x52\x78\x32\x43\xc1\x69\x7b\xdb\xe1\x6d\x37\xf9\x7f\x68\xf0\x83\x25\xdc\x15\x28", 15625)
};
static const HashTestTuple testSet256[] =
{
HashTestTuple("", "\x02\xba\x4c\x4e\x5f\x8e\xcd\x18\x77\xfc\x52\xd6\x4d\x30\xe3\x7a\x2d\x97\x74\xfb\x1e\x5d\x02\x63\x80\xae\x01\x68\xe3\xc5\x52\x2d"),
HashTestTuple("a", "\xf9\x33\x3e\x45\xd8\x57\xf5\xd9\x0a\x91\xba\xb7\x0a\x1e\xba\x0c\xfb\x1b\xe4\xb0\x78\x3c\x9a\xcf\xcd\x88\x3a\x91\x34\x69\x29\x25"),
HashTestTuple("abc", "\xaf\xbd\x6e\x22\x8b\x9d\x8c\xbb\xce\xf5\xca\x2d\x03\xe6\xdb\xa1\x0a\xc0\xbc\x7d\xcb\xe4\x68\x0e\x1e\x42\xd2\xe9\x75\x45\x9b\x65"),
HashTestTuple("message digest", "\x87\xe9\x71\x75\x9a\x1c\xe4\x7a\x51\x4d\x5c\x91\x4c\x39\x2c\x90\x18\xc7\xc4\x6b\xc1\x44\x65\x55\x4a\xfc\xdf\x54\xa5\x07\x0c\x0e"),
HashTestTuple("abcdefghijklmnopqrstuvwxyz", "\x64\x9d\x30\x34\x75\x1e\xa2\x16\x77\x6b\xf9\xa1\x8a\xcc\x81\xbc\x78\x96\x11\x8a\x51\x97\x96\x87\x82\xdd\x1f\xd9\x7d\x8d\x51\x33"),
HashTestTuple("abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq", "\x38\x43\x04\x55\x83\xaa\xc6\xc8\xc8\xd9\x12\x85\x73\xe7\xa9\x80\x9a\xfb\x2a\x0f\x34\xcc\xc3\x6e\xa9\xe7\x2f\x16\xf6\x36\x8e\x3f"),
HashTestTuple("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789", "\x57\x40\xa4\x08\xac\x16\xb7\x20\xb8\x44\x24\xae\x93\x1c\xbb\x1f\xe3\x63\xd1\xd0\xbf\x40\x17\xf1\xa8\x9f\x7e\xa6\xde\x77\xa0\xb8"),
HashTestTuple("12345678901234567890123456789012345678901234567890123456789012345678901234567890", "\x06\xfd\xcc\x7a\x40\x95\x48\xaa\xf9\x13\x68\xc0\x6a\x62\x75\xb5\x53\xe3\xf0\x99\xbf\x0e\xa4\xed\xfd\x67\x78\xdf\x89\xa8\x90\xdd"),
HashTestTuple("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "\xac\x95\x37\x44\xe1\x0e\x31\x51\x4c\x15\x0d\x4d\x8d\x7b\x67\x73\x42\xe3\x33\x99\x78\x82\x96\xe4\x3a\xe4\x85\x0c\xe4\xf9\x79\x78", 15625)
};
static const HashTestTuple testSet320[] =
{
HashTestTuple("", "\x22\xd6\x5d\x56\x61\x53\x6c\xdc\x75\xc1\xfd\xf5\xc6\xde\x7b\x41\xb9\xf2\x73\x25\xeb\xc6\x1e\x85\x57\x17\x7d\x70\x5a\x0e\xc8\x80\x15\x1c\x3a\x32\xa0\x08\x99\xb8"),
HashTestTuple("a", "\xce\x78\x85\x06\x38\xf9\x26\x58\xa5\xa5\x85\x09\x75\x79\x92\x6d\xda\x66\x7a\x57\x16\x56\x2c\xfc\xf6\xfb\xe7\x7f\x63\x54\x2f\x99\xb0\x47\x05\xd6\x97\x0d\xff\x5d"),
HashTestTuple("abc", "\xde\x4c\x01\xb3\x05\x4f\x89\x30\xa7\x9d\x09\xae\x73\x8e\x92\x30\x1e\x5a\x17\x08\x5b\xef\xfd\xc1\xb8\xd1\x16\x71\x3e\x74\xf8\x2f\xa9\x42\xd6\x4c\xdb\xc4\x68\x2d"),
HashTestTuple("message digest", "\x3a\x8e\x28\x50\x2e\xd4\x5d\x42\x2f\x68\x84\x4f\x9d\xd3\x16\xe7\xb9\x85\x33\xfa\x3f\x2a\x91\xd2\x9f\x84\xd4\x25\xc8\x8d\x6b\x4e\xff\x72\x7d\xf6\x6a\x7c\x01\x97"),
HashTestTuple("abcdefghijklmnopqrstuvwxyz", "\xca\xbd\xb1\x81\x0b\x92\x47\x0a\x20\x93\xaa\x6b\xce\x05\x95\x2c\x28\x34\x8c\xf4\x3f\xf6\x08\x41\x97\x51\x66\xbb\x40\xed\x23\x40\x04\xb8\x82\x44\x63\xe6\xb0\x09"),
HashTestTuple("abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq", "\xd0\x34\xa7\x95\x0c\xf7\x22\x02\x1b\xa4\xb8\x4d\xf7\x69\xa5\xde\x20\x60\xe2\x59\xdf\x4c\x9b\xb4\xa4\x26\x8c\x0e\x93\x5b\xbc\x74\x70\xa9\x69\xc9\xd0\x72\xa1\xac"),
HashTestTuple("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789", "\xed\x54\x49\x40\xc8\x6d\x67\xf2\x50\xd2\x32\xc3\x0b\x7b\x3e\x57\x70\xe0\xc6\x0c\x8c\xb9\xa4\xca\xfe\x3b\x11\x38\x8a\xf9\x92\x0e\x1b\x99\x23\x0b\x84\x3c\x86\xa4"),
HashTestTuple("12345678901234567890123456789012345678901234567890123456789012345678901234567890", "\x55\x78\x88\xaf\x5f\x6d\x8e\xd6\x2a\xb6\x69\x45\xc6\xd2\xa0\xa4\x7e\xcd\x53\x41\xe9\x15\xeb\x8f\xea\x1d\x05\x24\x95\x5f\x82\x5d\xc7\x17\xe4\xa0\x08\xab\x2d\x42"),
HashTestTuple("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "\xbd\xee\x37\xf4\x37\x1e\x20\x64\x6b\x8b\x0d\x86\x2d\xda\x16\x29\x2a\xe3\x6f\x40\x96\x5e\x8c\x85\x09\xe6\x3d\x1d\xbd\xde\xcc\x50\x3e\x2b\x63\xeb\x92\x45\xbb\x66", 15625)
};
bool pass = true;
cout << "\nRIPEMD-128 validation suite running...\n\n";
RIPEMD128 md128;
pass = HashModuleTest(md128, testSet128, COUNTOF(testSet128)) && pass;
cout << "\nRIPEMD-160 validation suite running...\n\n";
RIPEMD160 md160;
pass = HashModuleTest(md160, testSet160, COUNTOF(testSet160)) && pass;
cout << "\nRIPEMD-256 validation suite running...\n\n";
RIPEMD256 md256;
pass = HashModuleTest(md256, testSet256, COUNTOF(testSet256)) && pass;
cout << "\nRIPEMD-320 validation suite running...\n\n";
RIPEMD320 md320;
pass = HashModuleTest(md320, testSet320, COUNTOF(testSet320)) && pass;
return pass;
}
VOID InitLogging()
{
STATIC_CONTRACT_NOTHROW;
// <TODO>FIX bit of a workaround for now, check for the log file in the
// registry and if there, turn on file logging VPM</TODO>
LogFlags |= REGUTIL::GetConfigFlag_DontUse_(CLRConfig::INTERNAL_LogEnable, LOG_ENABLE);
LogFacilityMask = REGUTIL::GetConfigDWORD_DontUse_(CLRConfig::INTERNAL_LogFacility, LogFacilityMask) | LF_ALWAYS;
LogVMLevel = REGUTIL::GetConfigDWORD_DontUse_(CLRConfig::EXTERNAL_LogLevel, LogVMLevel);
LogFlags |= REGUTIL::GetConfigFlag_DontUse_(CLRConfig::INTERNAL_LogFileAppend, LOG_ENABLE_APPEND_FILE);
LogFlags |= REGUTIL::GetConfigFlag_DontUse_(CLRConfig::INTERNAL_LogFlushFile, LOG_ENABLE_FLUSH_FILE);
LogFlags |= REGUTIL::GetConfigFlag_DontUse_(CLRConfig::INTERNAL_LogToDebugger, LOG_ENABLE_DEBUGGER_LOGGING);
LogFlags |= REGUTIL::GetConfigFlag_DontUse_(CLRConfig::INTERNAL_LogToFile, LOG_ENABLE_FILE_LOGGING);
LogFlags |= REGUTIL::GetConfigFlag_DontUse_(CLRConfig::INTERNAL_LogToConsole, LOG_ENABLE_CONSOLE_LOGGING);
LogFacilityMask2 = REGUTIL::GetConfigDWORD_DontUse_(CLRConfig::INTERNAL_LogFacility2, LogFacilityMask2) | LF_ALWAYS;
LPWSTR fileName = CLRConfig::GetConfigValue(CLRConfig::INTERNAL_LogFile);
if (fileName != 0)
{
int ret;
ret = WszWideCharToMultiByte(CP_ACP, 0, fileName, -1, szLogFileName, sizeof(szLogFileName)-1, NULL, NULL);
_ASSERTE(ret != 0);
delete fileName;
}
if (REGUTIL::GetConfigDWORD_DontUse_(CLRConfig::INTERNAL_LogWithPid, FALSE))
{
char szPid[20];
sprintf_s(szPid, COUNTOF(szPid), ".%d", GetCurrentProcessId());
strcat_s(szLogFileName, _countof(szLogFileName), szPid);
}
if ((LogFlags & LOG_ENABLE) &&
(LogFlags & LOG_ENABLE_FILE_LOGGING) &&
(LogFileHandle == INVALID_HANDLE_VALUE))
{
DWORD fdwCreate = (LogFlags & LOG_ENABLE_APPEND_FILE) ? OPEN_ALWAYS : CREATE_ALWAYS;
LogFileHandle = CreateFileA(
szLogFileName,
GENERIC_WRITE,
FILE_SHARE_READ,
NULL,
fdwCreate,
FILE_ATTRIBUTE_NORMAL | FILE_FLAG_SEQUENTIAL_SCAN | ((LogFlags & LOG_ENABLE_FLUSH_FILE) ? FILE_FLAG_WRITE_THROUGH : 0),
NULL);
if(0 == LogFileMutex)
{
LogFileMutex = ClrCreateMutex(
NULL,
FALSE,
NULL);
_ASSERTE(LogFileMutex != 0);
}
// Some other logging may be going on, try again with another file name
if (LogFileHandle == INVALID_HANDLE_VALUE)
{
char* ptr = szLogFileName + strlen(szLogFileName) + 1;
ptr[-1] = '.';
ptr[0] = '0';
ptr[1] = 0;
for(int i = 0; i < 10; i++)
{
LogFileHandle = CreateFileA(
szLogFileName,
GENERIC_WRITE,
FILE_SHARE_READ,
NULL,
fdwCreate,
FILE_ATTRIBUTE_NORMAL | FILE_FLAG_SEQUENTIAL_SCAN | ((LogFlags & LOG_ENABLE_FLUSH_FILE) ? FILE_FLAG_WRITE_THROUGH : 0),
NULL);
if (LogFileHandle != INVALID_HANDLE_VALUE)
break;
*ptr = *ptr + 1;
}
if (LogFileHandle == INVALID_HANDLE_VALUE) {
DWORD written;
char buff[MAX_PATH+60];
strcpy(buff, "Could not open log file, logging to ");
strcat_s(buff, _countof(buff), szLogFileName);
// ARULM--Changed WriteConsoleA to WriteFile to be CE compat
WriteFile(GetStdHandle(STD_OUTPUT_HANDLE), buff, (DWORD)strlen(buff), &written, 0);
}
}
if (LogFileHandle == INVALID_HANDLE_VALUE)
UtilMessageBoxNonLocalized(NULL, W("Could not open log file"), W("CLR logging"), MB_OK | MB_ICONINFORMATION, FALSE, TRUE);
if (LogFileHandle != INVALID_HANDLE_VALUE)
{
if (LogFlags & LOG_ENABLE_APPEND_FILE)
SetFilePointer(LogFileHandle, 0, NULL, FILE_END);
LogSpew( LF_ALWAYS, FATALERROR, "************************ New Output *****************\n" );
}
}
}
bool CTaksiConfig::WriteIniFile()
{
// RETURN: true = success
// false = cant save!
//
char* pFileOld = NULL;
DWORD nSizeOld = 0;
TCHAR szIniFileName[_MAX_PATH];
Str_MakeFilePath( szIniFileName, COUNTOF(szIniFileName),
sg_Shared.m_szIniDir, _T(TAKSI_INI_FILE) );
// first read all lines
CNTHandle FileOld( ::CreateFile( szIniFileName,
GENERIC_READ, 0, NULL,
OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL ));
if ( FileOld.IsValidHandle())
{
nSizeOld = ::GetFileSize(FileOld, NULL);
pFileOld = (char*) ::HeapAlloc( g_Proc.m_hHeap, HEAP_ZERO_MEMORY, nSizeOld);
if (pFileOld == NULL)
return false;
DWORD dwBytesRead = 0;
::ReadFile(FileOld, pFileOld, nSizeOld, &dwBytesRead, NULL);
if (dwBytesRead != nSizeOld)
{
::HeapFree( g_Proc.m_hHeap, 0, pFileOld );
return false;
}
FileOld.CloseHandle();
}
// create new file
FILE* pFile = fopen( TAKSI_INI_FILE, "wt");
if ( pFile == NULL )
return false;
// loop over every line from the old file, and overwrite it in the new file
// if necessary. Otherwise - copy the old line.
CIniObject* pObj = NULL;
char* pszLine = pFileOld;
if (pFileOld)
while (true)
{
if ( pszLine >= pFileOld + nSizeOld )
break;
if ( *pszLine == '[' )
{
if ( pObj ) // finish previous section.
{
pObj->PropsWrite(pFile);
}
if ( ! strnicmp( pszLine, "[" TAKSI_SECTION "]", sizeof(TAKSI_SECTION)+1 ))
{
pObj = this;
}
else if ( ! strnicmp( pszLine, "[" TAKSI_CUSTOM_SECTION " ", sizeof(TAKSI_CUSTOM_SECTION)+1 ))
{
TCHAR szSection[ _MAX_PATH ];
#ifdef _UNICODE
ASSERT(0);
#else
strncpy( szSection, pszLine+14, sizeof(szSection));
#endif
TCHAR* pszEnd = _tcschr(szSection, ']');
if (pszEnd)
*pszEnd = '\0';
pObj = CustomConfig_FindAppId(szSection);
}
else
{
pObj = NULL;
}
}
char* pszEndLine = strchr(pszLine, '\n' ); // INI_CR
if (pszEndLine)
{
// covers \n or \r\n
char* pszTmp = pszEndLine;
for ( ; pszTmp >= pszLine && Str_IsSpace(*pszTmp); pszTmp-- )
pszTmp[0] = '\0';
pszEndLine++;
}
// it's a custom setting.
bool bReplaced;
if (pObj)
{
bReplaced = pObj->PropWriteName( pFile, pszLine );
}
else
{
bReplaced = false;
}
if (!bReplaced)
{
// take the old line as it was, might be blank or comment.
fprintf(pFile, "%s" INI_CR, pszLine);
}
if (pszEndLine == NULL)
break;
pszLine = pszEndLine;
}
// release buffer
if(pFileOld)
{
::HeapFree( g_Proc.m_hHeap, 0, pFileOld );
}
if ( pObj ) // finish previous section.
{
pObj->PropsWrite(pFile);
}
// if wasn't written, make sure we write it.
if (!m_dwWrittenMask)
{
fprintf( pFile, "[" TAKSI_SECTION "]" INI_CR );
PropsWrite(pFile);
}
PropsInit();
// same goes for NEW custom configs
CTaksiConfigCustom* p = m_pCustomList;
while (p != NULL)
{
if ( ! p->m_dwWrittenMask )
{
fprintf( pFile, "[" TAKSI_CUSTOM_SECTION " %s]" INI_CR, p->m_szAppId );
p->PropsWrite(pFile);
}
p->PropsInit();
p = p->m_pNext;
}
fclose(pFile);
return true;
}
INT_PTR
CALLBACK
CProgressDlg::DialogProc(
HWND hDlg,
UINT uMsg,
WPARAM wParam,
LPARAM lParam
)
{
switch (uMsg)
{
case WM_INITDIALOG:
{
// Retrieve and store the "this" pointer
CProgressDlg *that = (CProgressDlg *) lParam;
SetWindowLongPtr(hDlg, DWLP_USER, (LONG_PTR) that);
that->m_hDlg = hDlg;
// Initialize progress bar to the range 0 to 100
SendDlgItemMessage(hDlg, IDC_PROGRESS_BAR, PBM_SETRANGE32, (WPARAM) 0, (LPARAM) 100);
// Signal the main thread that we are ready
SetEvent(that->m_hInitDlg);
return TRUE;
}
case WM_COMMAND:
{
switch (LOWORD(wParam))
{
case IDCANCEL:
{
// If the user presses the cancel button, set the m_bCancelled flag.
CProgressDlg *that = (CProgressDlg *) GetWindowLongPtr(hDlg, DWLP_USER);
InterlockedIncrement(&that->m_bCancelled);
// The cancel operation will probably take some time, so
// change the cancel button text to "wait...", so that
// the user will see the cancel command is received and
// is being processed
TCHAR szWait[DEFAULT_STRING_SIZE] = _T("...");
LoadString(g_hInstance, IDS_WAIT, szWait, COUNTOF(szWait));
SetDlgItemText(hDlg, IDCANCEL, szWait);
return TRUE;
}
}
break;
}
}
return FALSE;
}
bool CPointBase::r_WriteVal( LPCTSTR pszKey, CGString & sVal ) const
{
ADDTOCALLSTACK("CPointBase::r_WriteVal");
if ( !strnicmp( pszKey, "STATICS", 7 ) )
{
pszKey += 7;
const CGrayMapBlock * pBlock = g_World.GetMapBlock( *(this) );
if ( !pBlock ) return false;
if ( *pszKey == '\0' )
{
int iStaticQty = 0;
for ( size_t i = 0; i < pBlock->m_Statics.GetStaticQty(); i++ )
{
const CUOStaticItemRec * pStatic = pBlock->m_Statics.GetStatic( i );
CPointMap ptTest( pStatic->m_x+pBlock->m_x, pStatic->m_y+pBlock->m_y, pStatic->m_z, this->m_map );
if ( this->GetDist( ptTest ) > 0 )
continue;
iStaticQty++;
}
sVal.FormatVal( iStaticQty );
return true;
}
SKIP_SEPARATORS( pszKey );
const CUOStaticItemRec * pStatic = NULL;
int iStatic = 0;
int type = 0;
if ( !strnicmp( pszKey, "FINDID", 6 ) )
{
pszKey += 6;
SKIP_SEPARATORS( pszKey );
iStatic = Exp_GetVal( pszKey );
type = RES_GET_TYPE( iStatic );
if ( type == 0 )
type = RES_ITEMDEF;
SKIP_SEPARATORS( pszKey );
}
else
{
iStatic = Exp_GetVal( pszKey );
type = RES_GET_TYPE( iStatic );
}
if ( type == RES_ITEMDEF )
{
const CItemBase * pItemDef = CItemBase::FindItemBase(static_cast<ITEMID_TYPE>(RES_GET_INDEX(iStatic)));
if ( !pItemDef )
{
sVal.FormatVal( 0 );
return false;
}
for ( size_t i = 0; i < pBlock->m_Statics.GetStaticQty(); pStatic = NULL, i++ )
{
pStatic = pBlock->m_Statics.GetStatic( i );
CPointMap ptTest( pStatic->m_x+pBlock->m_x, pStatic->m_y+pBlock->m_y, pStatic->m_z, this->m_map);
if ( this->GetDist( ptTest ) > 0 )
continue;
if ( pStatic->GetDispID() == pItemDef->GetDispID() )
break;
}
}
else
{
for ( size_t i = 0; i < pBlock->m_Statics.GetStaticQty(); pStatic = NULL, i++ )
{
pStatic = pBlock->m_Statics.GetStatic( i );
CPointMap ptTest( pStatic->m_x+pBlock->m_x, pStatic->m_y+pBlock->m_y, pStatic->m_z, this->m_map);
if ( this->GetDist( ptTest ) > 0 )
continue;
if ( iStatic == 0 )
break;
iStatic--;
}
}
if ( !pStatic )
{
sVal.FormatHex(0);
return true;
}
SKIP_SEPARATORS( pszKey );
if ( !*pszKey )
pszKey = "ID";
ITEMID_TYPE idTile = pStatic->GetDispID();
if ( !strnicmp( pszKey, "COLOR", 5 ) )
{
sVal.FormatHex( pStatic->m_wHue );
return true;
}
else if ( !strnicmp( pszKey, "ID", 2 ) )
{
sVal.FormatHex( idTile );
return true;
}
else if ( !strnicmp( pszKey, "Z", 1 ) )
{
sVal.FormatVal( pStatic->m_z );
return true;
}
// Check the script def for the item.
CItemBase * pItemDef = CItemBase::FindItemBase( idTile );
if ( pItemDef == NULL )
{
DEBUG_ERR(("Must have ITEMDEF section for item ID 0%x\n", idTile ));
return false;
}
return pItemDef->r_WriteVal( pszKey, sVal, &g_Serv );
}
else if ( !strnicmp( pszKey, "COMPONENTS", 10) )
{
pszKey += 10;
CRegionLinks rlinks;
const CRegionBase* pRegion = NULL;
CItem* pItem = NULL;
const CGrayMulti* pMulti = NULL;
const CUOMultiItemRec2* pMultiItem = NULL;
size_t iMultiQty = GetRegions(REGION_TYPE_MULTI, rlinks);
if ( *pszKey == '\0' )
{
int iComponentQty = 0;
for (size_t i = 0; i < iMultiQty; i++)
{
pRegion = rlinks.GetAt(i);
if (pRegion == NULL)
continue;
pItem = pRegion->GetResourceID().ItemFind();
if (pItem == NULL)
continue;
const CPointMap ptMulti = pItem->GetTopPoint();
pMulti = g_Cfg.GetMultiItemDefs(pItem);
if (pMulti == NULL)
continue;
size_t iQty = pMulti->GetItemCount();
for (size_t ii = 0; ii < iQty; ii++)
{
pMultiItem = pMulti->GetItem(ii);
if (pMultiItem == NULL)
break;
if (pMultiItem->m_visible == 0)
continue;
CPointMap ptTest(static_cast<WORD>(ptMulti.m_x + pMultiItem->m_dx), static_cast<WORD>(ptMulti.m_y + pMultiItem->m_dy), static_cast<signed char>(ptMulti.m_z + pMultiItem->m_dz), this->m_map);
if (GetDist(ptTest) > 0)
continue;
iComponentQty++;
}
}
sVal.FormatVal( iComponentQty );
return true;
}
SKIP_SEPARATORS( pszKey );
int iComponent = 0;
int type = 0;
if ( strnicmp( pszKey, "FINDID", 6 ) == 0 )
{
pszKey += 6;
SKIP_SEPARATORS( pszKey );
iComponent = Exp_GetVal( pszKey );
type = RES_GET_TYPE( iComponent );
if ( type == 0 )
type = RES_ITEMDEF;
SKIP_SEPARATORS( pszKey );
}
else
{
iComponent = Exp_GetVal( pszKey );
type = RES_GET_TYPE( iComponent );
}
if ( type == RES_ITEMDEF )
{
const CItemBase * pItemDef = CItemBase::FindItemBase(static_cast<ITEMID_TYPE>(RES_GET_INDEX(iComponent)));
if ( pItemDef == NULL )
{
sVal.FormatVal( 0 );
return false;
}
for (size_t i = 0; i < iMultiQty; i++)
{
pRegion = rlinks.GetAt(i);
if (pRegion == NULL)
continue;
pItem = pRegion->GetResourceID().ItemFind();
if (pItem == NULL)
continue;
const CPointMap ptMulti = pItem->GetTopPoint();
pMulti = g_Cfg.GetMultiItemDefs(pItem);
if (pMulti == NULL)
continue;
size_t iQty = pMulti->GetItemCount();
for (size_t ii = 0; ii < iQty; pMultiItem = NULL, ii++)
{
pMultiItem = pMulti->GetItem(ii);
if (pMultiItem == NULL)
break;
if (pMultiItem->m_visible == 0)
continue;
CPointMap ptTest(static_cast<WORD>(ptMulti.m_x + pMultiItem->m_dx), static_cast<WORD>(ptMulti.m_y + pMultiItem->m_dy), static_cast<signed char>(ptMulti.m_z + pMultiItem->m_dz), this->m_map);
if (GetDist(ptTest) > 0)
continue;
const CItemBase* pMultiItemDef = CItemBase::FindItemBase(pMultiItem->GetDispID());
if (pMultiItemDef != NULL && pMultiItemDef->GetDispID() == pItemDef->GetDispID())
break;
}
if (pMultiItem != NULL)
break;
}
}
else
{
for (size_t i = 0; i < iMultiQty; i++)
{
pRegion = rlinks.GetAt(i);
if (pRegion == NULL)
continue;
pItem = pRegion->GetResourceID().ItemFind();
if (pItem == NULL)
continue;
const CPointMap ptMulti = pItem->GetTopPoint();
pMulti = g_Cfg.GetMultiItemDefs(pItem);
if (pMulti == NULL)
continue;
size_t iQty = pMulti->GetItemCount();
for (size_t ii = 0; ii < iQty; pMultiItem = NULL, ii++)
{
pMultiItem = pMulti->GetItem(ii);
if (pMultiItem == NULL)
break;
if (pMultiItem->m_visible == 0)
continue;
CPointMap ptTest(static_cast<WORD>(ptMulti.m_x + pMultiItem->m_dx), static_cast<WORD>(ptMulti.m_y + pMultiItem->m_dy), static_cast<signed char>(ptMulti.m_z + pMultiItem->m_dz), this->m_map);
if (GetDist(ptTest) > 0)
continue;
if (iComponent == 0)
break;
iComponent--;
}
if (pMultiItem != NULL)
break;
}
}
if ( pMultiItem == NULL )
{
sVal.FormatHex(0);
return true;
}
SKIP_SEPARATORS( pszKey );
if ( !*pszKey )
pszKey = "ID";
ITEMID_TYPE idTile = pMultiItem->GetDispID();
if ( strnicmp( pszKey, "ID", 2 ) == 0 )
{
sVal.FormatHex( idTile );
return true;
}
else if ( strnicmp( pszKey, "MULTI", 5 ) == 0 )
{
pszKey += 5;
if (*pszKey != '\0')
{
SKIP_SEPARATORS(pszKey);
return pItem->r_WriteVal( pszKey, sVal, &g_Serv );
}
sVal.FormatHex( pItem->GetUID() );
return true;
}
else if ( strnicmp( pszKey, "Z", 1 ) == 0 )
{
sVal.FormatVal( pItem->GetTopZ() + pMultiItem->m_dz );
return true;
}
// Check the script def for the item.
CItemBase * pItemDef = CItemBase::FindItemBase( idTile );
if ( pItemDef == NULL )
{
DEBUG_ERR(("Must have ITEMDEF section for item ID 0%x\n", idTile ));
return false;
}
return pItemDef->r_WriteVal( pszKey, sVal, &g_Serv );
}
int index = FindTableHeadSorted( pszKey, sm_szLoadKeys, COUNTOF(sm_szLoadKeys)-1 );
if ( index < 0 )
return false;
switch ( index )
{
case PT_M:
case PT_MAP:
sVal.FormatVal(m_map);
break;
case PT_X:
sVal.FormatVal(m_x);
break;
case PT_Y:
sVal.FormatVal(m_y);
break;
case PT_Z:
sVal.FormatVal(m_z);
break;
case PT_ISNEARTYPE:
{
pszKey += 10;
SKIP_SEPARATORS( pszKey );
SKIP_ARGSEP( pszKey );
int iType = g_Cfg.ResourceGetIndexType( RES_TYPEDEF, pszKey );
int iDistance = 0;
bool bCheckMulti = false;
SKIP_IDENTIFIERSTRING( pszKey );
SKIP_SEPARATORS( pszKey );
SKIP_ARGSEP( pszKey );
if ( *pszKey ) iDistance = Exp_GetVal(pszKey);
if ( *pszKey ) bCheckMulti = Exp_GetVal(pszKey) != 0;
sVal.FormatVal( g_World.IsItemTypeNear(*this, static_cast<IT_TYPE>(iType), iDistance, bCheckMulti));
break;
}
case PT_REGION:
{
// Check that the syntax is correct.
if ( pszKey[6] && pszKey[6] != '.' )
return false;
CRegionWorld * pRegionTemp = dynamic_cast <CRegionWorld*>(this->GetRegion(REGION_TYPE_AREA | REGION_TYPE_MULTI));
if ( !pszKey[6] )
{
// We're just checking if the reference is valid.
sVal.FormatVal( pRegionTemp? 1:0 );
return true;
}
// We're trying to retrieve a property from the region.
pszKey += 7;
if ( pRegionTemp )
return pRegionTemp->r_WriteVal( pszKey, sVal, &g_Serv );
return false;
}
case PT_ROOM:
{
if ( pszKey[4] && pszKey[4] != '.' )
return false;
CRegionBase * pRegionTemp = this->GetRegion( REGION_TYPE_ROOM );
if ( !pszKey[4] )
{
sVal.FormatVal( pRegionTemp? 1:0 );
return true;
}
pszKey += 5;
if ( pRegionTemp )
return pRegionTemp->r_WriteVal( pszKey, sVal, &g_Serv );
return false;
}
case PT_SECTOR:
{
if ( pszKey[6] == '.' )
{
pszKey += 7;
CSector * pSectorTemp = this->GetSector();
if (pSectorTemp)
return pSectorTemp->r_WriteVal(pszKey, sVal, &g_Serv);
}
return false;
}
default:
{
const CUOMapMeter * pMeter = g_World.GetMapMeter(*this);
if ( pMeter )
{
switch( index )
{
case PT_TYPE:
{
CItemTypeDef * pTypeDef = g_World.GetTerrainItemTypeDef( pMeter->m_wTerrainIndex );
if ( pTypeDef != NULL )
sVal = pTypeDef->GetResourceName();
else
sVal = "";
} return true;
case PT_TERRAIN:
{
pszKey += strlen(sm_szLoadKeys[index]);
if ( *pszKey == '.' ) // do we have an argument?
{
SKIP_SEPARATORS( pszKey );
if ( !strnicmp( pszKey, "Z", 1 ))
{
sVal.FormatVal( pMeter->m_z );
return( true );
}
return( false );
}
else
{
sVal.FormatHex( pMeter->m_wTerrainIndex );
}
} return true;
}
}
return false;
}
}
return true;
}
bool CClient::OnRxConsole( const BYTE * pData, size_t iLen )
{
ADDTOCALLSTACK("CClient::OnRxConsole");
// A special console version of the client. (Not game protocol)
if ( !iLen || ( GetConnectType() != CONNECT_TELNET ))
return false;
if ( IsSetEF( EF_AllowTelnetPacketFilter ) )
{
bool fFiltered = xPacketFilter(pData, iLen);
if ( fFiltered )
return fFiltered;
}
while ( iLen -- )
{
int iRet = OnConsoleKey( m_Targ_Text, *pData++, m_pAccount != NULL );
if ( ! iRet )
return( false );
if ( iRet == 2 )
{
if ( !m_pAccount )
{
if ( !m_zLogin[0] )
{
if ( static_cast<size_t>(m_Targ_Text.GetLength()) > COUNTOF(m_zLogin) - 1 )
{
SysMessage("Login:\n");
}
else
{
strcpy(m_zLogin, m_Targ_Text);
SysMessage("Password:\n");
}
m_Targ_Text.Empty();
}
else
{
CGString sMsg;
CAccountRef pAccount = g_Accounts.Account_Find(m_zLogin);
if (( pAccount == NULL ) || ( pAccount->GetPrivLevel() < PLEVEL_Admin ))
{
SysMessagef("%s\n", g_Cfg.GetDefaultMsg(DEFMSG_CONSOLE_NOT_PRIV));
m_Targ_Text.Empty();
return false;
}
if ( LogIn(m_zLogin, m_Targ_Text, sMsg ) == PacketLoginError::Success )
{
m_Targ_Text.Empty();
return OnRxConsoleLoginComplete();
}
else if ( ! sMsg.IsEmpty())
{
SysMessage( sMsg );
return false;
}
m_Targ_Text.Empty();
}
return true;
}
else
{
iRet = g_Serv.OnConsoleCmd( m_Targ_Text, this );
if (g_Cfg.m_fTelnetLog && GetPrivLevel() >= g_Cfg.m_iCommandLog)
g_Log.Event(LOGM_GM_CMDS, "%lx:'%s' commands '%s'=%d\n", GetSocketID(), GetName(), static_cast<LPCTSTR>(m_Targ_Text), iRet);
}
}
}
return true;
}
void JE_loadConfiguration( void )
{
FILE *fi;
int z;
JE_byte *p;
int y;
fi = dir_fopen_warn(get_user_directory(), "tyrian.cfg", "rb");
if (fi && ftell_eof(fi) == 20 + sizeof(keySettings))
{
/* SYN: I've hardcoded the sizes here because the .CFG file format is fixed
anyways, so it's not like they'll change. */
background2 = 0;
efread(&background2, 1, 1, fi);
efread(&gameSpeed, 1, 1, fi);
efread(&inputDevice_, 1, 1, fi);
efread(&jConfigure, 1, 1, fi);
efread(&versionNum, 1, 1, fi);
efread(&processorType, 1, 1, fi);
efread(&midiPort, 1, 1, fi);
efread(&soundEffects, 1, 1, fi);
efread(&gammaCorrection, 1, 1, fi);
efread(&difficultyLevel, 1, 1, fi);
efread(joyButtonAssign, 1, 4, fi);
efread(&tyrMusicVolume, 2, 1, fi);
efread(&fxVolume, 2, 1, fi);
efread(inputDevice, 1, 2, fi);
efread(keySettings, sizeof(*keySettings), COUNTOF(keySettings), fi);
fclose(fi);
}
else
{
printf("\nInvalid or missing TYRIAN.CFG! Continuing using defaults.\n\n");
soundEffects = 1;
memcpy(&keySettings, &defaultKeySettings, sizeof(keySettings));
background2 = true;
tyrMusicVolume = fxVolume = 128;
gammaCorrection = 0;
processorType = 3;
gameSpeed = 4;
}
load_opentyrian_config();
if (tyrMusicVolume > 255)
tyrMusicVolume = 255;
if (fxVolume > 255)
fxVolume = 255;
JE_calcFXVol();
set_volume(tyrMusicVolume, fxVolume);
fi = dir_fopen_warn(get_user_directory(), "tyrian.sav", "rb");
if (fi)
{
fseek(fi, 0, SEEK_SET);
efread(saveTemp, 1, sizeof(saveTemp), fi);
JE_decryptSaveTemp();
/* SYN: The original mostly blasted the save file into raw memory. However, our lives are not so
easy, because the C struct is necessarily a different size. So instead we have to loop
through each record and load fields manually. *emo tear* :'( */
p = saveTemp;
for (z = 0; z < SAVE_FILES_NUM; z++)
{
memcpy(&saveFiles[z].encode, p, sizeof(JE_word)); p += 2;
saveFiles[z].encode = SDL_SwapLE16(saveFiles[z].encode);
memcpy(&saveFiles[z].level, p, sizeof(JE_word)); p += 2;
saveFiles[z].level = SDL_SwapLE16(saveFiles[z].level);
memcpy(&saveFiles[z].items, p, sizeof(JE_PItemsType)); p += sizeof(JE_PItemsType);
memcpy(&saveFiles[z].score, p, sizeof(JE_longint)); p += 4;
saveFiles[z].score = SDL_SwapLE32(saveFiles[z].score);
memcpy(&saveFiles[z].score2, p, sizeof(JE_longint)); p += 4;
saveFiles[z].score2 = SDL_SwapLE32(saveFiles[z].score2);
/* SYN: Pascal strings are prefixed by a byte holding the length! */
memset(&saveFiles[z].levelName, 0, sizeof(saveFiles[z].levelName));
memcpy(&saveFiles[z].levelName, &p[1], *p);
p += 10;
/* This was a BYTE array, not a STRING, in the original. Go fig. */
memcpy(&saveFiles[z].name, p, 14);
p += 14;
memcpy(&saveFiles[z].cubes, p, sizeof(JE_byte)); p++;
memcpy(&saveFiles[z].power, p, sizeof(JE_byte) * 2); p += 2;
memcpy(&saveFiles[z].episode, p, sizeof(JE_byte)); p++;
memcpy(&saveFiles[z].lastItems, p, sizeof(JE_PItemsType)); p += sizeof(JE_PItemsType);
memcpy(&saveFiles[z].difficulty, p, sizeof(JE_byte)); p++;
memcpy(&saveFiles[z].secretHint, p, sizeof(JE_byte)); p++;
memcpy(&saveFiles[z].input1, p, sizeof(JE_byte)); p++;
memcpy(&saveFiles[z].input2, p, sizeof(JE_byte)); p++;
/* booleans were 1 byte in pascal -- working around it */
Uint8 temp;
memcpy(&temp, p, 1); p++;
saveFiles[z].gameHasRepeated = temp != 0;
memcpy(&saveFiles[z].initialDifficulty, p, sizeof(JE_byte)); p++;
memcpy(&saveFiles[z].highScore1, p, sizeof(JE_longint)); p += 4;
saveFiles[z].highScore1 = SDL_SwapLE32(saveFiles[z].highScore1);
memcpy(&saveFiles[z].highScore2, p, sizeof(JE_longint)); p += 4;
saveFiles[z].highScore2 = SDL_SwapLE32(saveFiles[z].highScore2);
memset(&saveFiles[z].highScoreName, 0, sizeof(saveFiles[z].highScoreName));
memcpy(&saveFiles[z].highScoreName, &p[1], *p);
p += 30;
memcpy(&saveFiles[z].highScoreDiff, p, sizeof(JE_byte)); p++;
}
/* SYN: This is truncating to bytes. I have no idea what this is doing or why. */
/* TODO: Figure out what this is about and make sure it isn't broked. */
editorLevel = (saveTemp[SIZEOF_SAVEGAMETEMP - 5] << 8) | saveTemp[SIZEOF_SAVEGAMETEMP - 6];
fclose(fi);
} else {
/* We didn't have a save file! Let's make up random stuff! */
editorLevel = 800;
for (z = 0; z < 100; z++)
{
saveTemp[SAVE_FILES_SIZE + z] = initialItemAvail[z];
}
for (z = 0; z < SAVE_FILES_NUM; z++)
{
saveFiles[z].level = 0;
for (y = 0; y < 14; y++)
{
saveFiles[z].name[y] = ' ';
}
saveFiles[z].name[14] = 0;
saveFiles[z].highScore1 = ((mt_rand() % 20) + 1) * 1000;
if (z % 6 > 2)
{
saveFiles[z].highScore2 = ((mt_rand() % 20) + 1) * 1000;
strcpy(saveFiles[z].highScoreName, defaultTeamNames[mt_rand() % 22]);
} else {
strcpy(saveFiles[z].highScoreName, defaultHighScoreNames[mt_rand() % 34]);
}
}
}
JE_initProcessorType();
}
bool CClient::OnRxAxis( const BYTE * pData, size_t iLen )
{
ADDTOCALLSTACK("CClient::OnRxAxis");
if ( !iLen || ( GetConnectType() != CONNECT_AXIS ))
return false;
while ( iLen -- )
{
int iRet = OnConsoleKey( m_Targ_Text, *pData++, m_pAccount != NULL );
if ( ! iRet )
return( false );
if ( iRet == 2 )
{
if ( !m_pAccount )
{
if ( !m_zLogin[0] )
{
if ( static_cast<unsigned int>(m_Targ_Text.GetLength()) <= (COUNTOF(m_zLogin) - 1) )
strcpy(m_zLogin, m_Targ_Text);
m_Targ_Text.Empty();
}
else
{
CGString sMsg;
CAccountRef pAccount = g_Accounts.Account_Find(m_zLogin);
if (( pAccount == NULL ) || ( pAccount->GetPrivLevel() < PLEVEL_Counsel ))
{
SysMessagef("\"MSG:%s\"", g_Cfg.GetDefaultMsg(DEFMSG_AXIS_NOT_PRIV));
m_Targ_Text.Empty();
return false;
}
if ( LogIn(m_zLogin, m_Targ_Text, sMsg ) == PacketLoginError::Success )
{
m_Targ_Text.Empty();
if ( GetPrivLevel() < PLEVEL_Counsel )
{
SysMessagef("\"MSG:%s\"", g_Cfg.GetDefaultMsg(DEFMSG_AXIS_NOT_PRIV));
return false;
}
if (GetPeer().IsValidAddr())
{
CScriptTriggerArgs Args;
Args.m_VarsLocal.SetStrNew("Account",GetName());
Args.m_VarsLocal.SetStrNew("IP",GetPeer().GetAddrStr());
TRIGRET_TYPE tRet = TRIGRET_RET_DEFAULT;
r_Call("f_axis_preload", this, &Args, NULL, &tRet);
if ( tRet == TRIGRET_RET_FALSE )
return false;
if ( tRet == TRIGRET_RET_TRUE )
{
SysMessagef("\"MSG:%s\"", g_Cfg.GetDefaultMsg(DEFMSG_AXIS_DENIED));
return false;
}
time_t dateChange;
DWORD dwSize;
if ( ! CFileList::ReadFileInfo( "Axis.db", dateChange, dwSize ))
{
SysMessagef("\"MSG:%s\"", g_Cfg.GetDefaultMsg(DEFMSG_AXIS_INFO_ERROR));
return false;
}
CGFile FileRead;
if ( ! FileRead.Open( "Axis.db", OF_READ|OF_BINARY ))
{
SysMessagef("\"MSG:%s\"", g_Cfg.GetDefaultMsg(DEFMSG_AXIS_FILE_ERROR));
return false;
}
TCHAR szTmp[8*1024];
PacketWeb packet;
for (;;)
{
size_t iLength = FileRead.Read( szTmp, sizeof( szTmp ) );
if ( iLength <= 0 )
break;
packet.setData((BYTE*)szTmp, iLength);
packet.send(this);
dwSize -= iLength;
if ( dwSize <= 0 )
break;
}
return true;
}
return false;
}
else if ( ! sMsg.IsEmpty())
{
SysMessagef("\"MSG:%s\"", (LPCTSTR)sMsg);
return false;
}
m_Targ_Text.Empty();
}
return true;
}
}
}
return true;
}
// parse a configuration string in the form "ALL:opt, CAT:opt, ALT:opt"
// where opt can be one or more of
// 0-3 verbosity level, 0 is least and 3 is most. default is usually 1
// NONE disable all
// ALL enable all
// R enable Recent (default)
// !R disable Recent
// D enable Debug
// !D disable Debug (default)
// Z don't publish values markerd IF_NONZERO when their value is 0
// !Z ignore IF_NONZERO publishing flag
//
// return value is the PublishFlags that should be passed in to StatisticsPool::Publish
// for this category.
//
int generic_stats_ParseConfigString(
const char * config, // name of the string parameter to read from the config file
const char * pool_name, // name of the stats pool/category of stats to look for
const char * pool_alt, // alternate name of the category to look for
int flags_def) // default value for publish flags for this pool
{
// special case, if there is no string, or the string is just "default", then
// return the default flags
if ( ! config || MATCH == strcasecmp(config,"DEFAULT"))
return flags_def;
// special case, if the string is empty, or the string is just "none", then
// return 0 (disable all)
if ( ! config[0] || MATCH == strcasecmp(config,"NONE"))
return 0;
// tokenize the list on , or space
StringList items;
items.initializeFromString(config);
// if the config string is non-trivial, then it must contain either our pool_name
// or pool_alt or "DEFAULT" or "ALL" or we do not publish this pool.
int PublishFlags = 0;
// walk the list, looking for items that match our pool name or the keyword DEFAULT or ALL
//
items.rewind();
while (const char * p = items.next()) {
int flags = PublishFlags;
const char * psep = strchr(p,':');
if (psep) {
size_t cch = psep - p;
char sz[64];
if (cch >= COUNTOF(sz))
continue;
strncpy(sz, p, cch);
sz[cch] = 0;
if (strcasecmp(sz,pool_name) && strcasecmp(sz,pool_alt) && strcasecmp(sz,"DEFAULT") && strcasecmp(sz,"ALL"))
continue;
} else {
if (strcasecmp(p,pool_name) && strcasecmp(p,pool_alt) && strcasecmp(p,"DEFAULT") && strcasecmp(p,"ALL"))
continue;
}
// if we get to here, we found our pool name or "DEFAULT" or "ALL"
// so we begin with our default flags
flags = flags_def;
// if there are any options, then parse them and modify the flags
if (psep) {
const char * popt = psep+1;
if (MATCH == strcasecmp(popt,"NONE")) {
flags = 0;
} else {
bool bang = false;
const char * parse_error = NULL;
while (popt[0]) {
char ch = popt[0];
if (ch >= '0' && ch <= '3') {
int level = (atoi(popt) * IF_BASICPUB) & IF_PUBLEVEL;
flags = (flags & ~IF_PUBLEVEL) | level;
} else if (ch == '!') {
bang = true;
} else if (ch == 'd' || ch == 'D') {
flags = bang ? (flags & ~IF_DEBUGPUB) : (flags | IF_DEBUGPUB);
} else if (ch == 'r' || ch == 'R') {
flags = bang ? (flags & ~IF_RECENTPUB) : (flags | IF_RECENTPUB);
} else if (ch == 'z' || ch == 'Z') {
flags = bang ? (flags & ~IF_NONZERO) : (flags | IF_NONZERO);
} else if (ch == 'l' || ch == 'L') {
flags = bang ? (flags | IF_NOLIFETIME) : (flags & ~IF_NOLIFETIME);
} else {
if ( ! parse_error) parse_error = popt;
}
++popt;
}
if (parse_error) {
dprintf(D_ALWAYS, "Option '%s' invalid in '%s' when parsing statistics to publish. effect is %08X\n",
parse_error, p, flags);
}
}
}
PublishFlags = flags;
dprintf(D_FULLDEBUG, "'%s' gives flags %08X for %s statistics\n", p, PublishFlags, pool_name);
}
return PublishFlags;
}
bool CClient::addLoginErr(BYTE code)
{
ADDTOCALLSTACK("CClient::addLoginErr");
// code
// 0 = no account
// 1 = account used.
// 2 = blocked.
// 3 = no password
// LOGIN_ERR_OTHER
if (code == PacketLoginError::Success)
return( true );
// console message to display for each login error code
static LPCTSTR const sm_Login_ErrMsg[] =
{
"Account does not exist",
"The account entered is already being used",
"This account or IP is blocked",
"The password entered is not correct",
"Timeout / Wrong encryption / Unknown error",
"Invalid client version. See the CLIENTVERSION setting in " GRAY_FILE ".ini",
"Invalid character selected (chosen character does not exist)",
"AuthID is not correct. This normally means that the client did not log in via the login server",
"The account details entered are invalid (username or password is too short, too long or contains invalid characters). This can sometimes be caused by incorrect/missing encryption keys",
"The account details entered are invalid (username or password is too short, too long or contains invalid characters). This can sometimes be caused by incorrect/missing encryption keys",
"Encryption error (packet length does not match what was expected)",
"Encryption error (unknown encryption or bad login packet)",
"Encrypted client not permitted. See the USECRYPT setting in " GRAY_FILE ".ini",
"Unencrypted client not permitted. See the USENOCRYPT setting in " GRAY_FILE ".ini",
"Another character on this account is already ingame",
"Account is full. Cannot create a new character",
"Character creation blocked.",
"This IP is blocked",
"The maximum number of clients has been reached. See the CLIENTMAX setting in " GRAY_FILE ".ini",
"The maximum number of guests has been reached. See the GUESTSMAX setting in " GRAY_FILE ".ini",
"The maximum number of password tries has been reached"
};
if (code >= COUNTOF(sm_Login_ErrMsg))
code = PacketLoginError::Other;
g_Log.EventWarn( "%lx:Bad Login %d (%s)\n", GetSocketID(), code, sm_Login_ErrMsg[static_cast<size_t>(code)] );
// translate the code into a code the client will understand
switch (code)
{
case PacketLoginError::Invalid:
code = PacketLoginError::Invalid;
break;
case PacketLoginError::InUse:
case PacketLoginError::CharIdle:
code = PacketLoginError::InUse;
break;
case PacketLoginError::Blocked:
case PacketLoginError::BlockedIP:
case PacketLoginError::MaxClients:
case PacketLoginError::MaxGuests:
code = PacketLoginError::Blocked;
break;
case PacketLoginError::BadPass:
case PacketLoginError::BadAccount:
case PacketLoginError::BadPassword:
code = PacketLoginError::BadPass;
break;
case PacketLoginError::Other:
case PacketLoginError::BadVersion:
case PacketLoginError::BadCharacter:
case PacketLoginError::BadAuthID:
case PacketLoginError::BadEncLength:
case PacketLoginError::EncCrypt:
case PacketLoginError::EncNoCrypt:
case PacketLoginError::TooManyChars:
case PacketLoginError::MaxPassTries:
case PacketLoginError::EncUnknown:
default:
code = PacketLoginError::Other;
break;
}
new PacketLoginError(this, static_cast<PacketLoginError::Reason>(code));
m_NetState->markReadClosed();
return( false );
}
bool CStoneMember::r_LoadVal( CScript & s ) // Load an item Script
{
ADDTOCALLSTACK("CStoneMember::r_LoadVal");
EXC_TRY("LoadVal");
STMM_TYPE iIndex = (STMM_TYPE) FindTableSorted( s.GetKey(), sm_szLoadKeys, COUNTOF( sm_szLoadKeys )-1 );
if ( GetLinkUID().IsChar() )
{
switch ( iIndex )
{
case STMM_ACCOUNTGOLD:
SetAccountGold(s.GetArgVal());
break;
case STMM_LOYALTO:
{
CGrayUID uid = s.GetArgVal();
SetLoyalTo(uid.CharFind());
}
break;
case STMM_PRIV:
SetPriv(static_cast<STONEPRIV_TYPE>(s.GetArgVal()));
break;
case STMM_TITLE:
SetTitle(s.GetArgStr());
break;
case STMM_SHOWABBREV:
SetAbbrev( s.GetArgVal() ? 1 : 0 );
break;
default:
return false;
}
}
else if ( GetLinkUID().IsItem() )
{
switch ( iIndex )
{
case STMM_GUILD_THEYALLIANCE:
break;
case STMM_GUILD_THEYWAR:
SetTheyDeclared(s.GetArgVal() ? true : false);
break;
case STMM_GUILD_WEALLIANCE:
break;
case STMM_GUILD_WEWAR:
SetWeDeclared(s.GetArgVal() ? true : false);
break;
default:
return false;
}
}
return true;
EXC_CATCH;
EXC_DEBUG_START;
EXC_ADD_SCRIPT;
EXC_DEBUG_END;
return false;
}
bool CClient::OnRxWebPageRequest( BYTE * pRequest, size_t iLen )
{
ADDTOCALLSTACK("CClient::OnRxWebPageRequest");
// Seems to be a web browser pointing at us ? typical stuff :
if ( GetConnectType() != CONNECT_HTTP )
return false;
// ensure request is null-terminated (if the request is well-formed, we are overwriting a trailing \n here)
pRequest[iLen - 1] = '\0';
if ( strlen(reinterpret_cast<char *>(pRequest)) > 1024 ) // too long request
return false;
if ( !strpbrk( reinterpret_cast<char *>(pRequest), " \t\012\015" ) ) // malformed request
return false;
TCHAR * ppLines[16];
size_t iQtyLines = Str_ParseCmds(reinterpret_cast<char *>(pRequest), ppLines, COUNTOF(ppLines), "\r\n");
if (( iQtyLines < 1 ) || ( iQtyLines >= 15 )) // too long request
return false;
// Look for what they want to do with the connection.
bool fKeepAlive = false;
CGTime dateIfModifiedSince;
TCHAR * pszReferer = NULL;
size_t iContentLength = 0;
for ( size_t j = 1; j < iQtyLines; j++ )
{
TCHAR *pszArgs = Str_TrimWhitespace(ppLines[j]);
if ( !strnicmp(pszArgs, "Connection:", 11 ) )
{
pszArgs += 11;
GETNONWHITESPACE(pszArgs);
if ( !strnicmp(pszArgs, "Keep-Alive", 10) )
fKeepAlive = true;
}
else if ( !strnicmp(pszArgs, "Referer:", 8) )
{
pszReferer = pszArgs+8;
}
else if ( !strnicmp(pszArgs, "Content-Length:", 15) )
{
pszArgs += 15;
GETNONWHITESPACE(pszArgs);
iContentLength = strtoul(pszArgs, NULL, 10);
}
else if ( ! strnicmp( pszArgs, "If-Modified-Since:", 18 ))
{
// If-Modified-Since: Fri, 17 Dec 1999 14:59:20 GMT\r\n
pszArgs += 18;
dateIfModifiedSince.Read(pszArgs);
}
}
TCHAR * ppRequest[4];
size_t iQtyArgs = Str_ParseCmds(ppLines[0], ppRequest, COUNTOF(ppRequest), " ");
if (( iQtyArgs < 2 ) || ( strlen(ppRequest[1]) >= _MAX_PATH ))
return false;
if ( strchr(ppRequest[1], '\r') || strchr(ppRequest[1], 0x0c) )
return false;
// if the client hasn't requested a keep alive, we must act as if they had
// when async networking is used, otherwise data may not be completely sent
if ( fKeepAlive == false )
{
fKeepAlive = m_NetState->isAsyncMode();
// must switch to a blocking socket when the connection is not being kept
// alive, or else pending data will be lost when the socket shuts down
if ( fKeepAlive == false )
m_NetState->m_socket.SetNonBlocking(false);
}
linger llinger;
llinger.l_onoff = 1;
llinger.l_linger = 500; // in mSec
m_NetState->m_socket.SetSockOpt(SO_LINGER, reinterpret_cast<char *>(&llinger), sizeof(linger));
BOOL nbool = true;
m_NetState->m_socket.SetSockOpt(SO_KEEPALIVE, &nbool, sizeof(BOOL));
// disable NAGLE algorythm for data compression
nbool = true;
m_NetState->m_socket.SetSockOpt( TCP_NODELAY, &nbool, sizeof(BOOL), IPPROTO_TCP);
if ( memcmp(ppLines[0], "POST", 4) == 0 )
{
if ( iContentLength > strlen(ppLines[iQtyLines-1]) )
return false;
// POST /--WEBBOT-SELF-- HTTP/1.1
// Referer: http://127.0.0.1:2593/spherestatus.htm
// Content-Type: application/x-www-form-urlencoded
// Host: 127.0.0.1:2593
// Content-Length: 29
// T1=stuff1&B1=Submit&T2=stuff2
g_Log.Event(LOGM_HTTP|LOGL_EVENT, "%lx:HTTP Page Post '%s'\n", GetSocketID(), static_cast<LPCTSTR>(ppRequest[1]));
CWebPageDef *pWebPage = g_Cfg.FindWebPage(ppRequest[1]);
if ( !pWebPage )
pWebPage = g_Cfg.FindWebPage(pszReferer);
if ( pWebPage )
{
if ( pWebPage->ServPagePost(this, ppRequest[1], ppLines[iQtyLines-1], iContentLength) )
{
if ( fKeepAlive )
return true;
return false;
}
return false;
}
}
else if ( !memcmp(ppLines[0], "GET", 3) )
{
// GET /pagename.htm HTTP/1.1\r\n
// If-Modified-Since: Fri, 17 Dec 1999 14:59:20 GMT\r\n
// Host: localhost:2593\r\n
// \r\n
TCHAR szPageName[_MAX_PATH];
if ( !Str_GetBare( szPageName, Str_TrimWhitespace(ppRequest[1]), sizeof(szPageName), "!\"#$%&()*,:;<=>?[]^{|}-+'`" ) )
return false;
g_Log.Event(LOGM_HTTP|LOGL_EVENT, "%lx:HTTP Page Request '%s', alive=%d\n", GetSocketID(), static_cast<LPCTSTR>(szPageName), fKeepAlive);
if ( CWebPageDef::ServPage(this, szPageName, &dateIfModifiedSince) )
{
if ( fKeepAlive )
return true;
return false;
}
}
return false;
}
LPCTSTR CItemStone::GetCharter(unsigned int iLine) const
{
ASSERT(iLine<COUNTOF(m_sCharter));
return( m_sCharter[iLine] );
}
bool CTaksiConfig::PropSet( int eProp, const char* pszValue )
{
// TAKSI_CFGPROP_TYPE
switch (eProp)
{
case TAKSI_CFGPROP_DebugLog:
m_bDebugLog = GetStrBool(pszValue);
break;
case TAKSI_CFGPROP_CaptureDir:
if (! Str_GetQuoted( m_szCaptureDir, COUNTOF(m_szCaptureDir), pszValue))
return false;
break;
case TAKSI_CFGPROP_FileNamePostfix:
if (! Str_GetQuoted( m_szFileNamePostfix, COUNTOF(m_szFileNamePostfix), pszValue))
return false;
break;
case TAKSI_CFGPROP_ImageFormatExt:
if (! Str_GetQuoted( m_szImageFormatExt, COUNTOF(m_szImageFormatExt), pszValue))
return false;
break;
case TAKSI_CFGPROP_MovieFrameRateTarget:
m_fFrameRateTarget = (float) atof(pszValue);
break;
case TAKSI_CFGPROP_PosMasterWindow:
sscanf( pszValue, "%d,%d", &m_ptMasterWindow.x, &m_ptMasterWindow.y );
break;
case TAKSI_CFGPROP_PosMasterTopMost:
m_bMasterTopMost = GetStrBool(pszValue);
break;
case TAKSI_CFGPROP_VKey_ConfigOpen:
case TAKSI_CFGPROP_VKey_HookModeToggle:
case TAKSI_CFGPROP_VKey_IndicatorToggle:
case TAKSI_CFGPROP_VKey_RecordBegin:
case TAKSI_CFGPROP_VKey_RecordPause:
case TAKSI_CFGPROP_VKey_RecordStop:
case TAKSI_CFGPROP_VKey_Screenshot:
case TAKSI_CFGPROP_VKey_SmallScreenshot:
{
int iKey = TAKSI_HOTKEY_ConfigOpen + ( eProp - TAKSI_CFGPROP_VKey_ConfigOpen );
ASSERT( iKey >= 0 && iKey < TAKSI_HOTKEY_QTY );
char* pszEnd;
m_wHotKey[iKey] = (WORD) strtol(pszValue,&pszEnd,0);
}
break;
case TAKSI_CFGPROP_KeyboardUseDirectInput:
m_bUseDirectInput = GetStrBool(pszValue);
break;
case TAKSI_CFGPROP_VideoHalfSize:
m_bVideoHalfSize = GetStrBool(pszValue);
break;
case TAKSI_CFGPROP_VideoCodecMsg:
m_bVideoCodecMsg = GetStrBool(pszValue);
break;
case TAKSI_CFGPROP_VideoCodecInfo:
if ( ! m_VideoCodec.put_Str(pszValue))
return false;
break;
case TAKSI_CFGPROP_AudioFormat:
{
BYTE bTmp[1024];
ZeroMemory( &bTmp, sizeof(bTmp));
int iSize = Mem_ReadFromString( bTmp, sizeof(bTmp)-1, pszValue );
if ( iSize < sizeof(PCMWAVEFORMAT))
{
//ASSERT( iSize >= sizeof(PCMWAVEFORMAT));
return false;
}
if ( ! m_AudioFormat.SetFormatBytes( bTmp, iSize ))
{
//ASSERT(0);
return false;
}
}
break;
case TAKSI_CFGPROP_AudioDevice:
m_iAudioDevice = atoi(pszValue);
break;
case TAKSI_CFGPROP_ShowIndicator:
m_bShowIndicator = GetStrBool(pszValue);
break;
case TAKSI_CFGPROP_GDIFrame:
m_bGDIFrame = GetStrBool(pszValue);
break;
case TAKSI_CFGPROP_GDICursor:
m_bGDICursor = GetStrBool(pszValue);
break;
case TAKSI_CFGPROP_GDIDesktop:
m_abUseGAPI[TAKSI_GAPI_DESKTOP] = GetStrBool(pszValue);
break;
case TAKSI_CFGPROP_UseGDI:
m_abUseGAPI[TAKSI_GAPI_GDI] = GetStrBool(pszValue);
break;
case TAKSI_CFGPROP_UseOGL:
m_abUseGAPI[TAKSI_GAPI_OGL] = GetStrBool(pszValue);
break;
#ifdef USE_DIRECTX8
case TAKSI_CFGPROP_UseDX8:
m_abUseGAPI[TAKSI_GAPI_DX8] = GetStrBool(pszValue);
break;
#endif
#ifdef USE_DIRECTX9
case TAKSI_CFGPROP_UseDX9:
m_abUseGAPI[TAKSI_GAPI_DX9] = GetStrBool(pszValue);
break;
#endif
case TAKSI_CFGPROP_UseOverheadCompensation:
m_bUseOverheadCompensation = GetStrBool(pszValue);
break;
default:
DEBUG_ERR(("CTaksiConfig::PropSet bad code %d" LOG_CR, eProp ));
ASSERT(0);
return false;
}
#if 0 // def _DEBUG
char szTmp[_MAX_PATH*2];
if ( PropGet(eProp,szTmp,sizeof(szTmp)) < 0 )
{
strcpy( szTmp, "<NA>" );
}
LOG_MSG(( "PropSet '%s'='%s'" LOG_CR, sm_Props[eProp], szTmp));
#endif
return true;
}
bool CItemStone::r_LoadVal( CScript & s ) // Load an item Script
{
ADDTOCALLSTACK("CItemStone::r_LoadVal");
EXC_TRY("LoadVal");
switch ( FindTableSorted( s.GetKey(), sm_szLoadKeys, COUNTOF( sm_szLoadKeys )-1 ))
{
case STC_ABBREV: // "ABBREV"
m_sAbbrev = s.GetArgStr();
return true;
case STC_ALIGN: // "ALIGN"
SetAlignType(static_cast<STONEALIGN_TYPE>(s.GetArgVal()));
return true;
case STC_MasterUid:
{
if ( s.HasArgs() )
{
CGrayUID pNewMasterUid = (DWORD) s.GetArgVal();
CChar * pChar = pNewMasterUid.CharFind();
if ( !pChar )
{
DEBUG_ERR(( "MASTERUID called on non char 0%lx uid.\n", (DWORD)pNewMasterUid ));
return( false );
}
CStoneMember * pNewMaster = GetMember( pChar );
if ( !pNewMaster )
{
DEBUG_ERR(( "MASTERUID called on char 0%lx (%s) that is not a valid member of stone with 0x%lx uid.\n", (DWORD)pNewMasterUid, pChar->GetName(), (DWORD)GetUID() ));
return( false );
}
CStoneMember * pMaster = GetMasterMember();
if ( pMaster )
{
if ( pMaster->GetLinkUID() == pNewMasterUid )
return( true );
pMaster->SetPriv(STONEPRIV_MEMBER);
//pMaster->SetLoyalTo(pChar);
}
//pNewMaster->SetLoyalTo(pChar);
pNewMaster->SetPriv(STONEPRIV_MASTER);
}
else
{
DEBUG_ERR(( "MASTERUID called without arguments.\n" ));
return( false );
}
}
return( true );
case STC_MEMBER: // "MEMBER"
{
TCHAR *Arg_ppCmd[8]; // Maximum parameters in one line
size_t Arg_Qty = Str_ParseCmds( s.GetArgStr(), Arg_ppCmd, COUNTOF( Arg_ppCmd ), "," );
if (Arg_Qty < 1) // must at least provide the member uid
return false;
new CStoneMember(
this,
ahextoi(Arg_ppCmd[0]), // Member's UID
Arg_Qty > 2 ? static_cast<STONEPRIV_TYPE>(ATOI(Arg_ppCmd[2])) : STONEPRIV_CANDIDATE, // Members priv level (use as a type)
Arg_Qty > 1 ? Arg_ppCmd[1] : "", // Title
ahextoi(Arg_ppCmd[3]), // Member is loyal to this
Arg_Qty > 4 ? (ATOI( Arg_ppCmd[4] ) != 0) : 0, // Paperdoll stone abbreviation (also if they declared war)
Arg_Qty > 5 ? (ATOI( Arg_ppCmd[5] ) != 0) : 0, // If we declared war
Arg_Qty > 6 ? ATOI( Arg_ppCmd[6] ) : 0); // AccountGold
}
return true;
case STC_WEBPAGE: // "WEBPAGE"
m_sWebPageURL = s.GetArgStr();
return true;
}
if ( s.IsKeyHead( sm_szLoadKeys[STC_CHARTER], 7 ))
{
unsigned int i = ATOI(s.GetKey() + 7);
if ( i >= COUNTOF(m_sCharter))
return( false );
m_sCharter[i] = s.GetArgStr();
return( true );
}
return CItem::r_LoadVal(s);
EXC_CATCH;
EXC_DEBUG_START;
EXC_ADD_SCRIPT;
EXC_DEBUG_END;
return false;
}
bool CTaksiConfig::ReadIniFile()
{
// Read an INI file in standard INI file format.
// Returns true if successful.
TCHAR szIniFileName[_MAX_PATH];
Str_MakeFilePath( szIniFileName, COUNTOF(szIniFileName),
sg_Shared.m_szIniDir, _T(TAKSI_INI_FILE) );
#ifdef _UNICODE
// convert from UNICODE. fopen() is multibyte only.
FILE* pFile = NULL; ASSERT(0);
#else
FILE* pFile = fopen(szIniFileName, _T("rt"));
#endif
if (pFile == NULL)
{
// ASSUME constructor has already set this to all defaults.
return false;
}
LOG_MSG(( "Reading INI file '%s'" LOG_CR, szIniFileName ));
CIniObject* pObj = NULL;
while (true)
{
char szBuffer[_MAX_PATH*2];
fgets(szBuffer, sizeof(szBuffer)-1, pFile);
if (feof(pFile))
break;
// skip/trim comments
char* pszComment = strstr(szBuffer, ";");
if (pszComment != NULL)
pszComment[0] = '\0';
// parse the line
char* pszName = Str_SkipSpace(szBuffer); // skip leading spaces.
if ( *pszName == '\0' )
continue;
if ( *pszName == '[' )
{
if ( ! strnicmp( pszName, "[" TAKSI_SECTION "]", 7 ))
{
pObj = this;
}
else if ( ! strnicmp( pszName, "[" TAKSI_CUSTOM_SECTION " ", sizeof(TAKSI_CUSTOM_SECTION)+1 ))
{
TCHAR szSection[ _MAX_PATH ];
#ifdef _UNICODE
ASSERT(0);
#else
strncpy( szSection, pszName+sizeof(TAKSI_CUSTOM_SECTION)+1, sizeof(szSection));
#endif
TCHAR* pszEnd = _tcschr(szSection, ']');
if (pszEnd)
*pszEnd = '\0';
pObj = CustomConfig_Lookup(szSection,true);
}
else
{
pObj = NULL;
LOG_MSG(("INI Bad Section %s" LOG_CR, pszName ));
}
continue;
}
if ( pObj == NULL ) // skip
continue;
char* pszEq = strstr(pszName, "=");
if (pszEq == NULL)
continue;
pszEq[0] = '\0';
char* pszValue = Str_SkipSpace( pszEq + 1 ); // skip leading spaces.
if ( ! pObj->PropSetName( pszName, pszValue ))
{
LOG_MSG(("INI Bad Prop %s" LOG_CR, pszName ));
}
}
fclose(pFile);
FixCaptureDir();
return true;
}
bool CTar32::readdir_TAR(CTar32FileStatus &stat)
{
HEADER tar_header;
if(!readTarHeader(tar_header))return false;
//get tar format : GNU or POSIX
int tar_format=tar_header.getFormat();
// HP-UX's tar command create 100chars filename part. fixed on 2003.12.19
char tmp_name[COUNTOF(tar_header.dbuf.name)+1];
strncpy(tmp_name, tar_header.dbuf.name, COUNTOF(tar_header.dbuf.name));
tmp_name[COUNTOF(tar_header.dbuf.name)] = '\0';
stat.filename = tmp_name; /* tar_header.dbuf.name; */
stat.original_size = parseOctNum(tar_header.dbuf.size,COUNTOF(tar_header.dbuf.size));
if(tar_header.dbuf.typeflag == LNKTYPE){
// Fixed on 2003/11/28. For "spencer_pwb.tar.gz". Thanks to rollo-san.
stat.original_size = 0;
}
stat.blocksize = 512;
if(tar_header.dbuf.typeflag == LONGLINK){ // tar_header.dbuf.name == "././@LongLink"
//NOTE:TAR32.DLL earlier than 2.33 makes LONGLINK entry with POSIX header
tar_format=TAR_FORMAT_GNU;
//char longfilename[2000] = "";
std::vector<char> longfilename;
size64 readsize = (size_t(stat.original_size-1)/512+1)*512;
longfilename.resize((size_t)readsize+1); //TODO:size lost
size64 ret = m_pfile->read(&longfilename[0], readsize);
if(ret == 0){
throw CTar32Exception("can't get filename(LongLink)",ERROR_HEADER_BROKEN);
}
longfilename[(size_t)stat.original_size]='\0'; //TODO:size lost
if(!readTarHeader(tar_header))return false;
stat.filename = &longfilename[0];
stat.original_size = parseOctNum(tar_header.dbuf.size, COUNTOF(tar_header.dbuf.size));
}
bool bPaxFilenameSupplied=false;
time_t pax_atime=0,pax_ctime=0,pax_mtime=0;
if(tar_header.dbuf.typeflag == PAX_GLOBAL || tar_header.dbuf.typeflag == PAX_ENTRTY){
std::vector<char> content;
size64 readsize = (size_t(stat.original_size-1)/512+1)*512;
content.resize((size_t)readsize+1); //TODO:size lost
size64 ret = m_pfile->read(&content[0], readsize);
if(ret == 0){
throw CTar32Exception("can't get PAX Extended Global Header",ERROR_HEADER_BROKEN);
}
content[(size_t)stat.original_size]='\0'; //TODO:size lost
if(!readTarHeader(tar_header))return false;
stat.original_size = parseOctNum(tar_header.dbuf.size, COUNTOF(tar_header.dbuf.size));
strncpy(tmp_name, tar_header.dbuf.name, COUNTOF(tar_header.dbuf.name));
tmp_name[COUNTOF(tar_header.dbuf.name)] = '\0';
stat.filename = tmp_name; /* tar_header.dbuf.name; */
std::string extFilename;
size64 filesize;
if(!parsePaxExtHeader(&content[0],content.size(),extFilename,filesize,pax_atime,pax_ctime,pax_mtime)){
if(tar_header.dbuf.typeflag == PAX_GLOBAL){
throw CTar32Exception("Broken PAX Extended Global Header",ERROR_HEADER_BROKEN);
}else{
throw CTar32Exception("Broken PAX Extended Header",ERROR_HEADER_BROKEN);
}
}
if(tar_header.dbuf.typeflag == PAX_GLOBAL){
//global header
//TODO:need test
//if(filesize!=-1)m_currentfile_status.original_size=filesize;
}else{
//entry header
//TODO:need test
//if(filesize!=-1)stat.original_size=filesize;
if(!extFilename.empty()){
bPaxFilenameSupplied=true;
stat.filename=extFilename;
}
}
}
//charset conversion
if(m_archive_charset!=CHARSET_DONTCARE && !bPaxFilenameSupplied){
if(m_archive_charset==CHARSET_UNKNOWN){
//detect charset
m_archive_charset=detect_charset(stat.filename.c_str());
}
switch(m_archive_charset){
case CHARSET_EUCJP:
stat.filename=CConvertCharsetHelper::getInstance().eucjp_to_sjis(stat.filename.c_str(),stat.filename.size());
break;
case CHARSET_UTF8N: //FALLTHROUGH
case CHARSET_UTF8:
stat.filename=CConvertCharsetHelper::getInstance().utf8_to_sjis(stat.filename.c_str(),stat.filename.size());
break;
case CHARSET_JIS:
//FALLTHROUGH
/*
force to extract even if charset is not supported.
*/
//throw CTar32Exception("tar header charset error.",ERROR_NOT_SUPPORT);
//break;
case CHARSET_SJIS: //FALLTHROUGH
default:
//nothing to do
break;
}
}
stat.mode = strtol(tar_header.dbuf.mode, NULL, 8);
stat.uid = strtol(tar_header.dbuf.uid , NULL, 8);
stat.gid = strtol(tar_header.dbuf.gid , NULL, 8);
stat.mtime = strtol(tar_header.dbuf.mtime , NULL, 8);
stat.chksum = strtol(tar_header.dbuf.chksum , NULL, 8);
stat.typeflag = tar_header.dbuf.typeflag;
stat.linkname = tar_header.dbuf.linkname;
strncpy(stat.magic_version, tar_header.dbuf.magic,8);
strncpy(stat.uname, tar_header.dbuf.uname, 32);
strncpy(stat.gname, tar_header.dbuf.gname, 32);
stat.devmajor = strtol(tar_header.dbuf.devmajor , NULL, 8);
stat.devminor = strtol(tar_header.dbuf.devminor , NULL, 8);
if(tar_format==TAR_FORMAT_GNU){
stat.atime = strtol(tar_header.dbuf.exthead.gnu.atime , NULL, 8);
stat.ctime = strtol(tar_header.dbuf.exthead.gnu.ctime , NULL, 8);
stat.offset = parseOctNum(tar_header.dbuf.exthead.gnu.offset , COUNTOF(tar_header.dbuf.exthead.gnu.offset));
}else{ //POSIX
int length=min(COUNTOF(tar_header.dbuf.exthead.posix.prefix),strlen(tar_header.dbuf.exthead.posix.prefix));
if(length>0){
std::string prefix(tar_header.dbuf.exthead.posix.prefix,tar_header.dbuf.exthead.posix.prefix+length);
stat.filename= prefix + '/' + stat.filename;
}
}
if(pax_atime!=0)stat.atime=pax_atime;
if(pax_ctime!=0)stat.ctime=pax_ctime;
if(pax_mtime!=0)stat.mtime=pax_mtime;
if(stat.typeflag == DIRTYPE){
stat.mode &= ~_S_IFMT;
stat.mode |= _S_IFDIR;
}
if((stat.mode & _S_IFMT) == _S_IFDIR){
const char * f = stat.filename.c_str();
if((char*)max(_mbsrchr((unsigned char*)f, '/'), _mbsrchr((unsigned char*)f,'\\')) != f+strlen(f)-1){
stat.filename = stat.filename + "/";
}
}
return true;
}
/*
* yylex() - function that does the actual scanning.
* Bison expects this function to be called yylex and for it to take no
* input and return an int.
* Conceptually yylex "returns" yylval as well as the actual return
* value representing the token or type.
*/
int
yylex(
void
)
{
static follby followedby = FOLLBY_TOKEN;
int i;
int instring;
int yylval_was_set;
int converted;
int token; /* The return value */
int ch;
instring = FALSE;
yylval_was_set = FALSE;
do {
/* Ignore whitespace at the beginning */
while (EOF != (ch = get_next_char()) &&
isspace(ch) &&
!is_EOC(ch))
; /* Null Statement */
if (EOF == ch) {
if (!input_from_file || !curr_include_level)
return 0;
FCLOSE(fp[curr_include_level]);
ip_file = fp[--curr_include_level];
token = T_EOC;
goto normal_return;
} else if (is_EOC(ch)) {
/* end FOLLBY_STRINGS_TO_EOC effect */
followedby = FOLLBY_TOKEN;
token = T_EOC;
goto normal_return;
} else if (is_special(ch) && FOLLBY_TOKEN == followedby) {
/* special chars are their own token values */
token = ch;
/*
* '=' outside simulator configuration implies
* a single string following as in:
* setvar Owner = "The Boss" default
*/
if ('=' == ch && old_config_style)
followedby = FOLLBY_STRING;
yytext[0] = (char)ch;
yytext[1] = '\0';
goto normal_return;
} else
push_back_char(ch);
/* save the position of start of the token */
ip_file->prev_token_line_no = ip_file->line_no;
ip_file->prev_token_col_no = ip_file->col_no;
/* Read in the lexeme */
i = 0;
while (EOF != (ch = get_next_char())) {
yytext[i] = (char)ch;
/* Break on whitespace or a special character */
if (isspace(ch) || is_EOC(ch)
|| '"' == ch
|| (FOLLBY_TOKEN == followedby
&& is_special(ch)))
break;
/* Read the rest of the line on reading a start
of comment character */
if ('#' == ch) {
while (EOF != (ch = get_next_char())
&& '\n' != ch)
; /* Null Statement */
break;
}
i++;
if (i >= COUNTOF(yytext))
goto lex_too_long;
}
/* Pick up all of the string inside between " marks, to
* end of line. If we make it to EOL without a
* terminating " assume it for them.
*
* XXX - HMS: I'm not sure we want to assume the closing "
*/
if ('"' == ch) {
instring = TRUE;
while (EOF != (ch = get_next_char()) &&
ch != '"' && ch != '\n') {
yytext[i++] = (char)ch;
if (i >= COUNTOF(yytext))
goto lex_too_long;
}
/*
* yytext[i] will be pushed back as not part of
* this lexeme, but any closing quote should
* not be pushed back, so we read another char.
*/
if ('"' == ch)
ch = get_next_char();
}
/* Pushback the last character read that is not a part
* of this lexeme.
* If the last character read was an EOF, pushback a
* newline character. This is to prevent a parse error
* when there is no newline at the end of a file.
*/
if (EOF == ch)
push_back_char('\n');
else
push_back_char(ch);
yytext[i] = '\0';
} while (i == 0);
/* Now return the desired token */
/* First make sure that the parser is *not* expecting a string
* as the next token (based on the previous token that was
* returned) and that we haven't read a string.
*/
if (followedby == FOLLBY_TOKEN && !instring) {
token = is_keyword(yytext, &followedby);
if (token) {
/*
* T_Server is exceptional as it forces the
* following token to be a string in the
* non-simulator parts of the configuration,
* but in the simulator configuration section,
* "server" is followed by "=" which must be
* recognized as a token not a string.
*/
if (T_Server == token && !old_config_style)
followedby = FOLLBY_TOKEN;
goto normal_return;
} else if (is_integer(yytext)) {
yylval_was_set = TRUE;
errno = 0;
if ((yylval.Integer = strtol(yytext, NULL, 10)) == 0
&& ((errno == EINVAL) || (errno == ERANGE))) {
msyslog(LOG_ERR,
"Integer cannot be represented: %s",
yytext);
if (input_from_file) {
exit(1);
} else {
/* force end of parsing */
yylval.Integer = 0;
return 0;
}
}
token = T_Integer;
goto normal_return;
} else if (is_u_int(yytext)) {
yylval_was_set = TRUE;
if ('0' == yytext[0] &&
'x' == tolower(yytext[1]))
converted = sscanf(&yytext[2], "%x",
&yylval.U_int);
else
converted = sscanf(yytext, "%u",
&yylval.U_int);
if (1 != converted) {
msyslog(LOG_ERR,
"U_int cannot be represented: %s",
yytext);
if (input_from_file) {
exit(1);
} else {
/* force end of parsing */
yylval.Integer = 0;
return 0;
}
}
token = T_U_int;
goto normal_return;
} else if (is_double(yytext)) {
yylval_was_set = TRUE;
errno = 0;
if ((yylval.Double = atof(yytext)) == 0 && errno == ERANGE) {
msyslog(LOG_ERR,
"Double too large to represent: %s",
yytext);
exit(1);
} else {
token = T_Double;
goto normal_return;
}
} else {
/* Default: Everything is a string */
yylval_was_set = TRUE;
token = create_string_token(yytext);
goto normal_return;
}
}
/*
* Either followedby is not FOLLBY_TOKEN or this lexeme is part
* of a string. Hence, we need to return T_String.
*
* _Except_ we might have a -4 or -6 flag on a an association
* configuration line (server, peer, pool, etc.).
*
* This is a terrible hack, but the grammar is ambiguous so we
* don't have a choice. [SK]
*
* The ambiguity is in the keyword scanner, not ntp_parser.y.
* We do not require server addresses be quoted in ntp.conf,
* complicating the scanner's job. To avoid trying (and
* failing) to match an IP address or DNS name to a keyword,
* the association keywords use FOLLBY_STRING in the keyword
* table, which tells the scanner to force the next token to be
* a T_String, so it does not try to match a keyword but rather
* expects a string when -4/-6 modifiers to server, peer, etc.
* are encountered.
* restrict -4 and restrict -6 parsing works correctly without
* this hack, as restrict uses FOLLBY_TOKEN. [DH]
*/
if ('-' == yytext[0]) {
if ('4' == yytext[1]) {
token = T_Ipv4_flag;
goto normal_return;
} else if ('6' == yytext[1]) {
token = T_Ipv6_flag;
goto normal_return;
}
}
instring = FALSE;
if (FOLLBY_STRING == followedby)
followedby = FOLLBY_TOKEN;
yylval_was_set = TRUE;
token = create_string_token(yytext);
normal_return:
if (T_EOC == token)
DPRINTF(4,("\t<end of command>\n"));
else
DPRINTF(4, ("yylex: lexeme '%s' -> %s\n", yytext,
token_name(token)));
if (!yylval_was_set)
yylval.Integer = token;
return token;
lex_too_long:
yytext[min(sizeof(yytext) - 1, 50)] = 0;
msyslog(LOG_ERR,
"configuration item on line %d longer than limit of %lu, began with '%s'",
ip_file->line_no, (u_long)min(sizeof(yytext) - 1, 50),
yytext);
/*
* If we hit the length limit reading the startup configuration
* file, abort.
*/
if (input_from_file)
exit(sizeof(yytext) - 1);
/*
* If it's runtime configuration via ntpq :config treat it as
* if the configuration text ended before the too-long lexeme,
* hostname, or string.
*/
yylval.Integer = 0;
return 0;
}