/// <summary>
/// <para name='Name'>SLog::openLog</para>
/// <para name='Purpose'>Open a log for output</para>
/// </summary>
/// <param name='szFullPathToLog'>the full path to the log file to open</param>
/// <param name='makeUnique'>Whether to append a date/time stamp to the file name</param>
/// <returns>S_OK if successful, failure if it failed</returns>
/// <remarks>
/// <para name='Notes'></para>
/// <para name='Author'>Kenn Guilstorf</para>
/// <para name='LastModified'>2015-10-26</para>
/// </remarks>
HRESULT SLog::openLog(TSTRING szFullPathToLog, bool makeUnique)
{
HRESULT hrRetVal = S_OK;
TSTRING szFullLogPath = TSTRING();
// If we're trying to open when a log is already open...
// Let's flush and close the main OSTREAM first...
if (NULL != m_pO)
{
m_pO->flush();
delete m_pO;
m_pO = NULL;
}
// Now, close the file stream...
if (NULL != m_log)
{
if (m_log->is_open())
{
m_log->flush();
m_log->close();
delete m_log;
m_log = NULL;
}
}
// Split the path into path, name and ext
hrRetVal = splitFullPath(szFullPathToLog);
if (hrRetVal == ERROR_BAD_ARGUMENTS)
goto EXIT;
// Do we want to add date/time to the file?
if (makeUnique)
m_szLogFileName->append(getDateTimeString(false));
szFullLogPath.append(m_szLogFilePath->c_str());
szFullLogPath.append(m_szLogFileName->c_str());
szFullLogPath.append(m_szLogFileExt->c_str());
// Enter our critical section
EnterCriticalSection(&m_CriticalSection);
// Open our file stream
m_log = new TOFSTREAM(szFullLogPath.c_str(),
TOFSTREAM::app | TOFSTREAM::out);
// Open a new output stream
m_pO = new TOSTREAM(m_log->rdbuf());
// Leave our critical section
LeaveCriticalSection(&m_CriticalSection);
EXIT:
return hrRetVal;
}
///////////////////////////////////////////////////////////////////////////////
// MakeFileError
///////////////////////////////////////////////////////////////////////////////
TSTRING cErrorUtil::MakeFileError( const TSTRING& msg, const TSTRING& fileName )
{
TSTRING ret;
ret = TSS_GetString( cCore, core::STR_ERR2_FILENAME );
ret.append( fileName );
ret.append( 1, _T('\n') );
if ( msg.length() > 0 )
{
ret.append(msg);
}
return ret;
}
TSTRING cSHASignature::AsStringHex() const
{
TSTRING ret;
TCHAR stringBuffer[128];
TCHAR sigStringOut[128];
sigStringOut[0] = '\0';
for (int i=0; i < SIG_UINT32_SIZE; ++i)
{
_stprintf(stringBuffer, _T("%08x"), mSHAInfo.digest[i]);
_tcscat(sigStringOut, stringBuffer);
}
ret.append(sigStringOut);
return ret;
}
TSTRING cHAVALSignature::AsStringHex() const
{
TSTRING ret;
TCHAR stringBuffer[128];
TCHAR sigStringOut[128];
sigStringOut[0] = _T('\0');
for (int i=0; i < SIG_BYTE_SIZE; ++i)
{
_stprintf(stringBuffer, _T("%02x"), mSignature[i]);
_tcscat(sigStringOut, stringBuffer);
}
ret.append(sigStringOut);
return ret;
}
TSTRING cSHASignature::AsStringHex() const
{
TSTRING ret;
TCHAR stringBuffer[128];
TCHAR sigStringOut[128];
sigStringOut[0] = '\0';
uint8 *dbuf = (uint8 *)sha_digest;
for (int i=0; i < SIG_UINT32_SIZE*(int)sizeof(uint32); ++i)
{
_stprintf(stringBuffer, _T("%02x"), dbuf[i]);
_tcscat(sigStringOut, stringBuffer);
}
ret.append(sigStringOut);
return ret;
}
TSTRING cMD5Signature::AsStringHex() const
{
TSTRING ret;
TCHAR stringBuffer[128];
TCHAR sigStringOut[128];
sigStringOut[0] = '\0';
uint8 *dbuf = (uint8 *)md5_digest;
for(int i = 0; i < SIG_BYTE_SIZE; ++i)
{
_stprintf(stringBuffer, _T("%02lx"), (unsigned long)dbuf[i]);
_tcscat(sigStringOut, stringBuffer);
}
ret.append(sigStringOut);
return ret;
}
TSTRING cChecksumSignature::AsString() const
{
TSTRING ret;
char *ps_signature;
char buf[100];
uint32 local[2];
local[0] = (uint32)(mChecksum >> 32); // note we put the MSB first
local[1] = (uint32)(mChecksum);
ps_signature = pltob64(local, buf, 2);
//ps_signature holds base64 representation of mCRC
#ifdef _UNICODE
ret.resize(strlen(ps_signature));
mbstowcs((TCHAR*)ret.data(), ps_signature, strlen(ps_signature));
#else
ret.append(ps_signature);
#endif
return ret;
}
///////////////////////////////////////////////////////////////////////////////
// AsString -- Returns a TSTRING that holds the base64 representation of
// mCRC
TSTRING cCRC32Signature::AsString() const
{
if (cArchiveSigGen::Hex())
return AsStringHex();
TSTRING ret;
char *ps_signature;
char buf[100];
uint32 local = mCRCInfo.crc;
ps_signature = pltob64(&local, buf, 1);
//ps_signature holds base64 representation of mCRCInfo.crc
#ifdef _UNICODE
ret.resize(strlen(ps_signature));
mbstowcs((TCHAR*)ret.data(), ps_signature, strlen(ps_signature));
#else
ret.append(ps_signature);
#endif
return ret;
}
void cEncoder::Encode( TSTRING& strIn ) const
{
// TODO:BAM -- reserve space for strOut as an optimization?
TSTRING strOut; // encoded string we will build up
TSTRING::const_iterator cur = strIn.begin(); // pointer to working position in strIn
const TSTRING::const_iterator end = strIn.end(); // end of strIn
TSTRING::const_iterator first = end; // identifies beginning of current character
TSTRING::const_iterator last = end; // identifies end of current character
// while get next char (updates cur)
while( cCharUtil::PopNextChar( cur, end, first, last ) )
{
bool fCharEncoded = false; // answers: did char need encoding?
sack_type::const_iterator atE;
// for all encoders
for( atE = m_encodings.begin();
atE != m_encodings.end();
atE++ )
{
// does char need encoding?
if( (*atE)->NeedsEncoding( first, last ) )
{
strOut += Encode( first, last, atE );
fCharEncoded = true;
break; // each char should only fail at most one
// encoding test, so it should be cool to quit
}
}
if( ! fCharEncoded )
{
strOut.append( first, last ); // simply add current char to output since it needed no encoding
}
}
// pass back encoded string
strIn = strOut;
}
///////////////////////////////////////////////////////////////////////////////
// AsString -- Returns Base64 representation of mSignature in a TSTRING
TSTRING cHAVALSignature::AsString() const
{
if (cArchiveSigGen::Hex())
return AsStringHex();
TSTRING ret;
char buf[24];
btob64((byte*)mSignature, buf, 128);
//converting to base64 representation.
#ifdef _UNICODE //making it TSTRING sensitive
int length;
length = strlen(buf);
ret.resize(length);
mbstowcs((TCHAR*) ret.data(), buf, length);
#else
ret.append(buf);
#endif
return ret;
}
TSTRING cSHASignature::AsString(void) const
{
if (cArchiveSigGen::Hex())
return AsStringHex();
TSTRING ret;
char* ps_signature;
char buf[100];
ps_signature = btob64((uint8*)sha_digest, buf, SIG_UINT32_SIZE*sizeof(uint32)*8);
//converting to base64 representation.
#ifdef _UNICODE //making it TSTRING sensitive
int length;
length = strlen(ps_signature);
ret.resize(length);
mbstowcs((TCHAR*) ret.data(), ps_signature, length);
#else
ret.append(ps_signature);
#endif
return ret;
}
////////////////////////////////////////////////////////////////////////////////
// AsString -- Converts to Base64 representation and returns a TSTRING
TSTRING cMD5Signature::AsString() const
{
if (cArchiveSigGen::Hex())
return AsStringHex();
TSTRING ret;
char buf[24];
ASSERT( sizeof( uint8 ) == sizeof( byte ) ); /* everything breaks otherwise */
btob64((byte*)md5_digest, buf, SIG_BYTE_SIZE*8);
//converting to base64 representation.
#ifdef _UNICODE //making it TSTRING sensitive
int length;
length = strlen(buf);
ret.resize(length);
mbstowcs((TCHAR*) ret.data(), buf, length);
#else
ret.append(buf);
#endif
return ret;
}
void cEncoder::Decode( TSTRING& strIn ) const
{
// TODO:BAM -- reserve space for strOut as an optimization?
TSTRING strOut; // decoded string we will build up
TSTRING::const_iterator cur = strIn.begin(); // pointer to working position in strIn
const TSTRING::const_iterator end = strIn.end(); // end of strIn
TSTRING::const_iterator first = end; // identifies beginning of current character
TSTRING::const_iterator last = end; // identifies end of current character
// while get next char (updates cur)
while( cCharUtil::PopNextChar( cur, end, first, last ) )
{
// is this char the escape character?
if( IsSingleTCHAR( first, last ) &&
*first == iCharEncoder::EscapeChar() )
{
// get to identifier
if( ! cCharUtil::PopNextChar( cur, end, first, last ) )
ThrowAndAssert( eBadDecoderInput() );
// this algorithm assumes that all identifiers are single char
// so anything following the escape char should be a
// single-char identifier
if( ! IsSingleTCHAR( first, last ) )
THROW_INTERNAL( "displayencoder.cpp" );
// determine to which encoding the identifier belongs
bool fFoundEncoding = false;
sack_type::const_iterator atE;
for( atE = m_encodings.begin();
atE != m_encodings.end();
atE++ )
{
// is this the right encoding?
if( *first == (*atE)->Identifier() )
{
// this is the correct encoding....
fFoundEncoding = true;
// ...so decode char
strOut += (*atE)->Decode( &first, end ); // should modify cur
cur = first; // advance current char pointer
break; // no need to run other tests after
// this because all identifiers should be unique
}
}
if( ! fFoundEncoding )
ThrowAndAssert( eUnknownEscapeEncoding( TSTRING( 1, *first ) ) );
}
else
{
strOut.append( first, last );
}
}
strIn = strOut;
}
int main(int argc, char* argv[])
{
// Get application path
g_ApplicationExePath.append(argv[0]);
// Calculate INI file path
g_ApplicationIniPath = g_ApplicationExePath;
g_ApplicationIniPath.resize(g_ApplicationIniPath.find_last_of(_T('.')));
g_ApplicationIniPath.append(_T(".ini"));
if (! InitInstance())
return 255;
Emulator_Start();
// The main loop
Uint32 ticksLast;
Uint32 ticksLastFps = SDL_GetTicks();
int frames = 0;
while (!g_okQuit)
{
ticksLast = SDL_GetTicks(); // Time at frame start
SDL_Event evt;
while (SDL_PollEvent(&evt))
{
if (evt.type == SDL_QUIT)
{
g_okQuit = TRUE;
break;
}
else
{
if (evt.type == SDL_KEYDOWN || evt.type == SDL_KEYUP ||
evt.type == SDL_JOYBUTTONDOWN || evt.type == SDL_JOYBUTTONUP)
{
Main_OnKeyJoyEvent(evt);
}
}
}
if (g_okEmulatorRunning)
{
Emulator_SystemFrame();
Main_DrawScreen();
frames++;
}
// Delay
Uint32 ticksNew = SDL_GetTicks();
Uint32 ticksElapsed = ticksNew - ticksLast;
g_LastDelay = 0;
if (ticksElapsed < FRAME_TICKS)
{
g_LastDelay = FRAME_TICKS - ticksElapsed;
SDL_Delay(FRAME_TICKS - ticksElapsed);
}
ticksLast = ticksNew;
if (ticksLast - ticksLastFps > 1000) //DEBUG: FPS calculation
{
g_LastFps = frames;
frames = 0;
ticksLastFps += 1000;
}
}
Emulator_Stop();
DoneInstance();
return 0;
}
/// <summary>
/// <para name='Name'>GetEID</para>
/// <para name='Purpose'>Resolve the EID from the email address</para>
/// </summary>
/// <param name='szEmailAddress'>Email address to resolve</param>
/// <param name='sbEID'>[out]SBinary EID to return</param>
/// <returns>HRESULT</returns>
/// <remarks>
/// <para name='Notes'></para>
/// <para name='Author'>Kenn Guilstorf</para>
/// <para name='LastModified'>28Jan2016</para>
/// </remarks>
STDMETHODIMP ZybraxiSoft::CMailbox::GetEID(const TSTRING sEmailAddress, SBinary &sbEID)
{
FBEG;
HRESULT hr = S_OK;
LPMDB lpDefaultMDB = NULL;
LPEXCHANGEMANAGESTORE lpExStore = NULL;
TSTRING sServerName;
TSTRING sServerPre = TSTRING(SERVER_PRE);
TSTRING sServerPost = TSTRING(SERVER_POST);
TSTRING sServerDN = wstring();
std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> converter;
string sTempEmailAddress;
string sTempServerDN;
// Clean our sbEID
sbEID.cb = 0;
// Get a pointer to the default message store
if (FAILED(hr = OpenDefaultMessageStore(
&lpDefaultMDB)))
{
ERROR_MSG_W_HR("OpenDefaultMessageStore failed", hr);
goto CLEANUP;
}
// Use the pointer to the default message store to
// Get a pointer to the Manage Store interface
if (FAILED(hr = lpDefaultMDB->QueryInterface(
IID_IExchangeManageStore,
(LPVOID*)&lpExStore)))
{
ERROR_MSG_W_HR("Getting the Exchange store manager failed", hr);
goto CLEANUP;
}
// Get our Server Name
if (FAILED(hr = this->GetServerNameFromProfile(sServerName)))
{
ERROR_MSG_W_HR("Getting the server name failed", hr);
goto CLEANUP;
}
// Go ahead and build our server dn
sServerDN.append(sServerPre.c_str());
sServerDN.append(sServerName.c_str());
sServerDN.append(sServerPost.c_str());
// if we're in UNICODE, we need to convert; we can only pass ASCII
#if defined(UNICODE) || defined(_UNICODE)
sTempServerDN = converter.to_bytes(sServerDN);
sTempEmailAddress = converter.to_bytes(sEmailAddress);
#else
sTempServerDN = sServerDN;
sTempEmailAddress = sEmailAddress;
#endif
// Get the EID
if (FAILED(hr = lpExStore->CreateStoreEntryID(
(LPSTR)sTempServerDN.c_str(),
(LPSTR)sTempEmailAddress.c_str(),
OPENSTORE_TAKE_OWNERSHIP,
&sbEID.cb,
(LPENTRYID*)&sbEID.lpb)))
{
ERROR_MSG_W_HR("CreateStoreEntryID failed", hr);
goto CLEANUP;
}
// Check to make sure we got an actual EID
if (sbEID.cb == 0)
{
hr = MAPI_E_NOT_FOUND;
ERROR_MSG_W_HR("Failed to resolve the mailbox", hr);
goto CLEANUP;
}
CLEANUP:
if (lpExStore)
{
lpExStore->Release();
lpExStore = NULL;
}
if (lpDefaultMDB)
{
lpDefaultMDB->Release();
lpDefaultMDB = NULL;
}
FEND;
return hr;
}
